_ 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 Refund;
   6 class Retry;
   7 class RetryableSendFailure;
   8 class PaymentSendFailure;
   9 class ProbeSendFailure;
  10 class RecipientOnionFields;
  11 class UnsignedBolt12Invoice;
  12 class Bolt12Invoice;
  13 class BlindedPayInfo;
  14 class DelayedPaymentOutputDescriptor;
  15 class StaticPaymentOutputDescriptor;
  16 class SpendableOutputDescriptor;
  17 class ChannelDerivationParameters;
  18 class HTLCDescriptor;
  19 class ChannelSigner;
  20 class EcdsaChannelSigner;
  21 class WriteableEcdsaChannelSigner;
  22 class Recipient;
  23 class EntropySource;
  24 class NodeSigner;
  25 class SignerProvider;
  26 class InMemorySigner;
  27 class KeysManager;
  28 class PhantomKeysManager;
  29 class BackgroundProcessor;
  30 class GossipSync;
  31 class DefaultRouter;
  32 class Router;
  33 class ScorerAccountingForInFlightHtlcs;
  34 class InFlightHtlcs;
  35 class RouteHop;
  36 class BlindedTail;
  37 class Path;
  38 class Route;
  39 class RouteParameters;
  40 class PaymentParameters;
  41 class Payee;
  42 class RouteHint;
  43 class RouteHintHop;
  44 class ScoreLookUp;
  45 class ScoreUpdate;
  46 class Score;
  47 class LockableScore;
  48 class WriteableScore;
  49 class MultiThreadedLockableScore;
  50 class MultiThreadedScoreLockRead;
  51 class MultiThreadedScoreLockWrite;
  52 class ChannelUsage;
  53 class FixedPenaltyScorer;
  54 class ProbabilisticScorer;
  55 class ProbabilisticScoringFeeParameters;
  56 class ProbabilisticScoringDecayParameters;
  57 class BestBlock;
  58 class Listen;
  59 class Confirm;
  60 class ChannelMonitorUpdateStatus;
  61 class Watch;
  62 class Filter;
  63 class WatchedOutput;
  64 class InitFeatures;
  65 class NodeFeatures;
  66 class ChannelFeatures;
  67 class Bolt11InvoiceFeatures;
  68 class OfferFeatures;
  69 class InvoiceRequestFeatures;
  70 class Bolt12InvoiceFeatures;
  71 class BlindedHopFeatures;
  72 class ChannelTypeFeatures;
  73 class Offer;
  74 class Amount;
  75 class Quantity;
  76 class NodeId;
  77 class NetworkGraph;
  78 class ReadOnlyNetworkGraph;
  79 class NetworkUpdate;
  80 class P2PGossipSync;
  81 class ChannelUpdateInfo;
  82 class ChannelInfo;
  83 class DirectedChannelInfo;
  84 class EffectiveCapacity;
  85 class RoutingFees;
  86 class NodeAnnouncementInfo;
  87 class NodeAlias;
  88 class NodeInfo;
  89 class AnchorDescriptor;
  90 class BumpTransactionEvent;
  91 class Input;
  92 class Utxo;
  93 class CoinSelection;
  94 class CoinSelectionSource;
  95 class WalletSource;
  96 class Wallet;
  97 class BumpTransactionEventHandler;
  98 class FailureCode;
  99 class ChannelManager;
 100 class ChainParameters;
 101 class CounterpartyForwardingInfo;
 102 class ChannelCounterparty;
 103 class ChannelDetails;
 104 class ChannelShutdownState;
 105 class RecentPaymentDetails;
 106 class PhantomRouteHints;
 107 class ChannelManagerReadArgs;
 108 class ChannelHandshakeConfig;
 109 class ChannelHandshakeLimits;
 110 class MaxDustHTLCExposure;
 111 class ChannelConfig;
 112 class ChannelConfigUpdate;
 113 class UserConfig;
 114 class APIError;
 115 class TaggedHash;
 116 class ChannelMonitorUpdate;
 117 class MonitorEvent;
 118 class HTLCUpdate;
 119 class Balance;
 120 class ChannelMonitor;
 121 class ExpandedKey;
 122 class CustomMessageHandler;
 123 class IgnoringMessageHandler;
 124 class ErroringMessageHandler;
 125 class MessageHandler;
 126 class SocketDescriptor;
 127 class PeerHandleError;
 128 class PeerManager;
 129 class RapidGossipSync;
 130 class KVStore;
 131 class Persister;
 132 class MonitorUpdatingPersister;
 133 class UnsignedInvoiceRequest;
 134 class InvoiceRequest;
 135 class VerifiedInvoiceRequest;
 136 class DecodeError;
 137 class Init;
 138 class ErrorMessage;
 139 class WarningMessage;
 140 class Ping;
 141 class Pong;
 142 class OpenChannel;
 143 class OpenChannelV2;
 144 class AcceptChannel;
 145 class AcceptChannelV2;
 146 class FundingCreated;
 147 class FundingSigned;
 148 class ChannelReady;
 149 class TxAddInput;
 150 class TxAddOutput;
 151 class TxRemoveInput;
 152 class TxRemoveOutput;
 153 class TxComplete;
 154 class TxSignatures;
 155 class TxInitRbf;
 156 class TxAckRbf;
 157 class TxAbort;
 158 class Shutdown;
 159 class ClosingSignedFeeRange;
 160 class ClosingSigned;
 161 class UpdateAddHTLC;
 162 class OnionMessage;
 163 class UpdateFulfillHTLC;
 164 class UpdateFailHTLC;
 165 class UpdateFailMalformedHTLC;
 166 class CommitmentSigned;
 167 class RevokeAndACK;
 168 class UpdateFee;
 169 class ChannelReestablish;
 170 class AnnouncementSignatures;
 171 class SocketAddress;
 172 class SocketAddressParseError;
 173 class UnsignedGossipMessage;
 174 class UnsignedNodeAnnouncement;
 175 class NodeAnnouncement;
 176 class UnsignedChannelAnnouncement;
 177 class ChannelAnnouncement;
 178 class UnsignedChannelUpdate;
 179 class ChannelUpdate;
 180 class QueryChannelRange;
 181 class ReplyChannelRange;
 182 class QueryShortChannelIds;
 183 class ReplyShortChannelIdsEnd;
 184 class GossipTimestampFilter;
 185 class ErrorAction;
 186 class LightningError;
 187 class CommitmentUpdate;
 188 class ChannelMessageHandler;
 189 class RoutingMessageHandler;
 190 class OnionMessageHandler;
 191 class Level;
 192 class Record;
 193 class Logger;
 194 class FutureCallback;
 195 class Future;
 196 class Sleeper;
 197 class OffersMessageHandler;
 198 class OffersMessage;
 199 class HTLCClaim;
 200 class CounterpartyCommitmentSecrets;
 201 class TxCreationKeys;
 202 class ChannelPublicKeys;
 203 class HTLCOutputInCommitment;
 204 class ChannelTransactionParameters;
 205 class CounterpartyChannelTransactionParameters;
 206 class DirectedChannelTransactionParameters;
 207 class HolderCommitmentTransaction;
 208 class BuiltCommitmentTransaction;
 209 class ClosingTransaction;
 210 class TrustedClosingTransaction;
 211 class CommitmentTransaction;
 212 class TrustedCommitmentTransaction;
 213 class ShutdownScript;
 214 class InvalidShutdownScript;
 215 class Bolt12ParseError;
 216 class Bolt12SemanticError;
 217 class BroadcasterInterface;
 218 class ConfirmationTarget;
 219 class FeeEstimator;
 220 class Packet;
 221 class ParsedOnionMessageContents;
 222 class OnionMessageContents;
 223 class PaymentPurpose;
 224 class ClaimedHTLC;
 225 class PathFailure;
 226 class ClosureReason;
 227 class HTLCDestination;
 228 class PaymentFailureReason;
 229 class Event;
 230 class MessageSendEvent;
 231 class MessageSendEventsProvider;
 232 class EventsProvider;
 233 class EventHandler;
 234 class Bolt11ParseError;
 235 class ParseOrSemanticError;
 236 class Bolt11Invoice;
 237 class SignedRawBolt11Invoice;
 238 class RawBolt11Invoice;
 239 class RawDataPart;
 240 class PositiveTimestamp;
 241 class SiPrefix;
 242 class Currency;
 243 class Sha256;
 244 class Description;
 245 class PayeePubKey;
 246 class ExpiryTime;
 247 class MinFinalCltvExpiryDelta;
 248 class Fallback;
 249 class Bolt11InvoiceSignature;
 250 class PrivateRoute;
 251 class CreationError;
 252 class Bolt11SemanticError;
 253 class SignOrCreationError;
 254 class OutPoint;
 255 class BigSize;
 256 class Hostname;
 257 class TransactionU16LenLimited;
 258 class UntrustedString;
 259 class PrintableString;
 260 class CustomMessageReader;
 261 class Type;
 262 class ForwardNode;
 263 class ForwardTlvs;
 264 class ReceiveTlvs;
 265 class PaymentRelay;
 266 class PaymentConstraints;
 267 class PaymentError;
 268 class ProbingError;
 269 class UtxoLookupError;
 270 class UtxoResult;
 271 class UtxoLookup;
 272 class UtxoFuture;
 273 class OnionMessenger;
 274 class MessageRouter;
 275 class DefaultMessageRouter;
 276 class OnionMessagePath;
 277 class Destination;
 278 class SendError;
 279 class CustomOnionMessageHandler;
 280 class PeeledOnion;
 281 class FilesystemStore;
 282 class BlindedPath;
 283 class BlindedHop;
 284 class GraphSyncError;
 285 class InvoiceError;
 286 class ErroneousField;
 287 class MonitorUpdateId;
 288 class Persist;
 289 class LockedChannelMonitor;
 290 class ChainMonitor;
 291 class CResult_LockedChannelMonitorNoneZ;
 292 class CResult_TransactionU16LenLimitedNoneZ;
 293 class CVec_C2Tuple_BlindedPayInfoBlindedPathZZ;
 294 class CResult_PhantomRouteHintsDecodeErrorZ;
 295 class CResult_FundingCreatedDecodeErrorZ;
 296 class CVec_C2Tuple_u32TxOutZZ;
 297 class CResult_RetryDecodeErrorZ;
 298 class CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ;
 299 class CResult_ChannelInfoDecodeErrorZ;
 300 class COption_MaxDustHTLCExposureZ;
 301 class CResult_NoneSendErrorZ;
 302 class C2Tuple_CVec_u8ZusizeZ;
 303 class COption_OffersMessageZ;
 304 class COption_NetworkUpdateZ;
 305 class COption_u64Z;
 306 class CResult_CVec_u8ZPeerHandleErrorZ;
 307 class CResult_GossipTimestampFilterDecodeErrorZ;
 308 class CResult_RouteHintDecodeErrorZ;
 309 class COption_FilterZ;
 310 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ;
 311 class COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ;
 312 class CResult_COption_APIErrorZDecodeErrorZ;
 313 class CVec_UpdateAddHTLCZ;
 314 class CResult_TxAbortDecodeErrorZ;
 315 class CResult_StaticPaymentOutputDescriptorDecodeErrorZ;
 316 class COption_u32Z;
 317 class CResult_RecipientOnionFieldsNoneZ;
 318 class C2Tuple__u1632_u1632Z;
 319 class CResult_CVec_StrZIOErrorZ;
 320 class CResult_ClosingSignedFeeRangeDecodeErrorZ;
 321 class CResult_TransactionNoneZ;
 322 class CResult_CommitmentSignedDecodeErrorZ;
 323 class CResult_CommitmentTransactionDecodeErrorZ;
 324 class CResult_ErrorMessageDecodeErrorZ;
 325 class CResult_OpenChannelDecodeErrorZ;
 326 class COption_APIErrorZ;
 327 class CResult_QueryChannelRangeDecodeErrorZ;
 328 class CVec_TransactionZ;
 329 class CVec_InputZ;
 330 class CResult_ChannelFeaturesDecodeErrorZ;
 331 class CResult_ChannelReadyDecodeErrorZ;
 332 class CResult_UpdateFeeDecodeErrorZ;
 333 class CResult_NoneBolt11SemanticErrorZ;
 334 class COption_OnionMessageContentsZ;
 335 class CResult_NoneRetryableSendFailureZ;
 336 class CResult_boolLightningErrorZ;
 337 class CResult_NodeIdDecodeErrorZ;
 338 class CResult_ChannelShutdownStateDecodeErrorZ;
 339 class CResult_HTLCOutputInCommitmentDecodeErrorZ;
 340 class CResult_NodeAnnouncementInfoDecodeErrorZ;
 341 class CResult_ShutdownScriptInvalidShutdownScriptZ;
 342 class CResult_COption_NetworkUpdateZDecodeErrorZ;
 343 class CVec_UpdateFailMalformedHTLCZ;
 344 class CResult_ShutdownScriptNoneZ;
 345 class COption_HTLCDestinationZ;
 346 class CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ;
 347 class CVec_RouteHopZ;
 348 class CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ;
 349 class CResult_CVec_UtxoZNoneZ;
 350 class CResult_CVec_u8ZIOErrorZ;
 351 class C3Tuple_OffersMessageDestinationBlindedPathZ;
 352 class CVec_ThirtyTwoBytesZ;
 353 class CResult_ChannelMonitorUpdateStatusNoneZ;
 354 class CResult_ClosingSignedDecodeErrorZ;
 355 class CResult_NonePaymentErrorZ;
 356 class CVec_CResult_NoneAPIErrorZZ;
 357 class CResult_SchnorrSignatureNoneZ;
 358 class CResult_CounterpartyCommitmentSecretsDecodeErrorZ;
 359 class CResult_ReceiveTlvsDecodeErrorZ;
 360 class CResult_HTLCDescriptorDecodeErrorZ;
 361 class CVec_RecentPaymentDetailsZ;
 362 class CVec_RouteHintHopZ;
 363 class CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ;
 364 class CResult_UntrustedStringDecodeErrorZ;
 365 class CVec_U5Z;
 366 class CResult_PaymentParametersDecodeErrorZ;
 367 class C2Tuple_ThirtyTwoBytesChannelMonitorZ;
 368 class COption_U128Z;
 369 class C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ;
 370 class CResult_TxAckRbfDecodeErrorZ;
 371 class CResult_Bolt11InvoiceBolt11SemanticErrorZ;
 372 class COption_UtxoLookupZ;
 373 class CResult_PongDecodeErrorZ;
 374 class CResult_UnsignedChannelAnnouncementDecodeErrorZ;
 375 class C2Tuple_OutPointCVec_MonitorUpdateIdZZ;
 376 class CResult_CVec_u8ZNoneZ;
 377 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ;
 378 class CResult_ChannelTransactionParametersDecodeErrorZ;
 379 class CResult_WriteableEcdsaChannelSignerDecodeErrorZ;
 380 class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ;
 381 class CResult_InFlightHtlcsDecodeErrorZ;
 382 class CResult_COption_HTLCDestinationZDecodeErrorZ;
 383 class CResult_ThirtyTwoBytesNoneZ;
 384 class C3Tuple_OnionMessageContentsDestinationBlindedPathZ;
 385 class C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ;
 386 class CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ;
 387 class CResult_BlindedHopDecodeErrorZ;
 388 class C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ;
 389 class CResult_FixedPenaltyScorerDecodeErrorZ;
 390 class CVec_BlindedPathZ;
 391 class CResult_NoneLightningErrorZ;
 392 class CResult_NonePeerHandleErrorZ;
 393 class CResult_TrustedCommitmentTransactionNoneZ;
 394 class CResult_COption_EventZDecodeErrorZ;
 395 class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ;
 396 class CResult_PaymentFailureReasonDecodeErrorZ;
 397 class COption_SocketAddressZ;
 398 class CResult_COption_MonitorEventZDecodeErrorZ;
 399 class COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ;
 400 class CResult_DescriptionCreationErrorZ;
 401 class CResult_RoutingFeesDecodeErrorZ;
 402 class CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ;
 403 class CResult_PaymentRelayDecodeErrorZ;
 404 class CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ;
 405 class CResult_QueryShortChannelIdsDecodeErrorZ;
 406 class CResult_VerifiedInvoiceRequestNoneZ;
 407 class CResult_UpdateAddHTLCDecodeErrorZ;
 408 class COption_MonitorEventZ;
 409 class COption_TypeZ;
 410 class CResult_COption_TypeZDecodeErrorZ;
 411 class CResult_COption_PathFailureZDecodeErrorZ;
 412 class CResult_Bolt11InvoiceSignOrCreationErrorZ;
 413 class CResult_UpdateFailHTLCDecodeErrorZ;
 414 class CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ;
 415 class CResult_RevokeAndACKDecodeErrorZ;
 416 class CResult_SpendableOutputDescriptorDecodeErrorZ;
 417 class C2Tuple_PublicKeyCOption_SocketAddressZZ;
 418 class CResult_UnsignedChannelUpdateDecodeErrorZ;
 419 class CResult_PayeePubKeySecp256k1ErrorZ;
 420 class COption_BigEndianScalarZ;
 421 class CResult_PublicKeySecp256k1ErrorZ;
 422 class CResult_CVec_ECDSASignatureZNoneZ;
 423 class CVec_BlindedHopZ;
 424 class CResult_COption_ClosureReasonZDecodeErrorZ;
 425 class CResult_InvoiceErrorDecodeErrorZ;
 426 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
 427 class CResult_RouteParametersDecodeErrorZ;
 428 class CResult_PrivateRouteCreationErrorZ;
 429 class CResult_NodeAliasDecodeErrorZ;
 430 class CVec_UpdateFulfillHTLCZ;
 431 class CVec_C2Tuple_u32CVec_u8ZZZ;
 432 class CResult_AnnouncementSignaturesDecodeErrorZ;
 433 class CResult_UpdateFulfillHTLCDecodeErrorZ;
 434 class CResult_TxCompleteDecodeErrorZ;
 435 class CResult_StrSecp256k1ErrorZ;
 436 class CResult_NodeFeaturesDecodeErrorZ;
 437 class CResult_InMemorySignerDecodeErrorZ;
 438 class CResult_TxSignaturesDecodeErrorZ;
 439 class CVec_HTLCDescriptorZ;
 440 class CResult_ReplyShortChannelIdsEndDecodeErrorZ;
 441 class COption_PathFailureZ;
 442 class CVec_ECDSASignatureZ;
 443 class CResult_ChannelUpdateInfoDecodeErrorZ;
 444 class CVec_UpdateFailHTLCZ;
 445 class CVec_TxOutZ;
 446 class CResult_BuiltCommitmentTransactionDecodeErrorZ;
 447 class CVec_SpendableOutputDescriptorZ;
 448 class C2Tuple_OutPointCVec_u8ZZ;
 449 class COption_C2Tuple_u64u64ZZ;
 450 class CResult_ChannelAnnouncementDecodeErrorZ;
 451 class CResult_PeeledOnionNoneZ;
 452 class CResult_HTLCUpdateDecodeErrorZ;
 453 class CResult_TxAddInputDecodeErrorZ;
 454 class CVec_OutPointZ;
 455 class CResult_TxInitRbfDecodeErrorZ;
 456 class COption_WriteableScoreZ;
 457 class CVec_StrZ;
 458 class CResult_PositiveTimestampCreationErrorZ;
 459 class CResult_ChannelMonitorUpdateDecodeErrorZ;
 460 class C2Tuple_BlindedPayInfoBlindedPathZ;
 461 class CResult_ReplyChannelRangeDecodeErrorZ;
 462 class CResult_UnsignedNodeAnnouncementDecodeErrorZ;
 463 class CResult_TrustedClosingTransactionNoneZ;
 464 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ;
 465 class C2Tuple_PublicKeyTypeZ;
 466 class CResult_TxRemoveOutputDecodeErrorZ;
 467 class CResult_ChannelReestablishDecodeErrorZ;
 468 class CResult_OnionMessageDecodeErrorZ;
 469 class CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ;
 470 class CResult_C2Tuple_CVec_u8ZusizeZNoneZ;
 471 class CResult_Bolt11InvoiceParseOrSemanticErrorZ;
 472 class CResult_InitFeaturesDecodeErrorZ;
 473 class CResult_PublicKeyNoneZ;
 474 class CResult_PingDecodeErrorZ;
 475 class CResult_BlindedHopFeaturesDecodeErrorZ;
 476 class CVec_TransactionOutputsZ;
 477 class COption_HTLCClaimZ;
 478 class COption_boolZ;
 479 class CVec_CVec_u8ZZ;
 480 class CResult_ProbabilisticScorerDecodeErrorZ;
 481 class CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ;
 482 class COption_StrZ;
 483 class CResult_ShutdownScriptDecodeErrorZ;
 484 class C2Tuple_usizeTransactionZ;
 485 class CResult_NodeAnnouncementDecodeErrorZ;
 486 class CVec_FutureZ;
 487 class CVec_ChannelMonitorZ;
 488 class CResult_AcceptChannelV2DecodeErrorZ;
 489 class CResult_TxCreationKeysDecodeErrorZ;
 490 class CResult_RouteHopDecodeErrorZ;
 491 class CVec_HTLCOutputInCommitmentZ;
 492 class CResult_CoinSelectionNoneZ;
 493 class C2Tuple_ThirtyTwoBytesPublicKeyZ;
 494 class CResult_SiPrefixBolt11ParseErrorZ;
 495 class CResult_BlindedPathDecodeErrorZ;
 496 class CVec_BalanceZ;
 497 class CResult_NoneIOErrorZ;
 498 class CResult_MaxDustHTLCExposureDecodeErrorZ;
 499 class CVec_CommitmentTransactionZ;
 500 class CResult_FundingSignedDecodeErrorZ;
 501 class CResult_RecoverableSignatureNoneZ;
 502 class CResult_SocketAddressDecodeErrorZ;
 503 class C2Tuple_Z;
 504 class C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ;
 505 class CVec_PathZ;
 506 class CResult_NetworkGraphDecodeErrorZ;
 507 class CResult_NodeInfoDecodeErrorZ;
 508 class CVec_NodeIdZ;
 509 class CVec_u8Z;
 510 class CResult_RouteLightningErrorZ;
 511 class CResult_NonePaymentSendFailureZ;
 512 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ;
 513 class CResult_ChannelPublicKeysDecodeErrorZ;
 514 class CVec_ClaimedHTLCZ;
 515 class COption_CVec_ThirtyTwoBytesZZ;
 516 class CVec_SocketAddressZ;
 517 class CResult_ThirtyTwoBytesPaymentSendFailureZ;
 518 class CResult_HolderCommitmentTransactionDecodeErrorZ;
 519 class CResult_WarningMessageDecodeErrorZ;
 520 class CResult_ChannelCounterpartyDecodeErrorZ;
 521 class CResult_InitDecodeErrorZ;
 522 class CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ;
 523 class CResult_ClaimedHTLCDecodeErrorZ;
 524 class CResult_PaymentPurposeDecodeErrorZ;
 525 class CVec_MonitorUpdateIdZ;
 526 class CResult_OutPointDecodeErrorZ;
 527 class CVec_ChannelDetailsZ;
 528 class CResult_Bolt11InvoiceFeaturesDecodeErrorZ;
 529 class CVec_MessageSendEventZ;
 530 class CResult_RouteHintHopDecodeErrorZ;
 531 class CResult_UpdateFailMalformedHTLCDecodeErrorZ;
 532 class CResult_BlindedPayInfoDecodeErrorZ;
 533 class CResult_ThirtyTwoBytesAPIErrorZ;
 534 class COption_ChannelShutdownStateZ;
 535 class CResult_CVec_CVec_u8ZZNoneZ;
 536 class CResult_AcceptChannelDecodeErrorZ;
 537 class CResult_HostnameDecodeErrorZ;
 538 class C2Tuple_u64u16Z;
 539 class COption_ThirtyTwoBytesZ;
 540 class CVec_u64Z;
 541 class CResult_NoneBolt12SemanticErrorZ;
 542 class COption_SecretKeyZ;
 543 class CResult_ThirtyTwoBytesPaymentErrorZ;
 544 class COption_EventZ;
 545 class CResult_ChannelTypeFeaturesDecodeErrorZ;
 546 class COption_CVec_SocketAddressZZ;
 547 class CVec_RouteHintZ;
 548 class COption_u16Z;
 549 class COption_PaymentFailureReasonZ;
 550 class CResult_ECDSASignatureNoneZ;
 551 class CVec_WitnessZ;
 552 class CResult_BlindedTailDecodeErrorZ;
 553 class CResult_SocketAddressSocketAddressParseErrorZ;
 554 class COption_C2Tuple_u64u16ZZ;
 555 class CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ;
 556 class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ;
 557 class CResult_ChannelDerivationParametersDecodeErrorZ;
 558 class CResult_PaymentConstraintsDecodeErrorZ;
 559 class C2Tuple_u32CVec_u8ZZ;
 560 class CVec_C2Tuple_PublicKeyTypeZZ;
 561 class CResult_OnionMessagePathNoneZ;
 562 class CResult_RefundBolt12ParseErrorZ;
 563 class C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ;
 564 class CVec_C2Tuple_u64CVec_u8ZZZ;
 565 class CResult_u32GraphSyncErrorZ;
 566 class CVec_PhantomRouteHintsZ;
 567 class CResult_NoneAPIErrorZ;
 568 class CResult_Bolt12InvoiceFeaturesDecodeErrorZ;
 569 class COption_f64Z;
 570 class CResult_ChannelDetailsDecodeErrorZ;
 571 class CVec_PublicKeyZ;
 572 class CVec_C2Tuple_usizeTransactionZZ;
 573 class CResult_TxRemoveInputDecodeErrorZ;
 574 class CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ;
 575 class CResult_OffersMessageDecodeErrorZ;
 576 class C2Tuple_u64u64Z;
 577 class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ;
 578 class CResult_RecipientOnionFieldsDecodeErrorZ;
 579 class C2Tuple_u32TxOutZ;
 580 class CVec_UtxoZ;
 581 class CResult_ChannelConfigDecodeErrorZ;
 582 class CVec_PrivateRouteZ;
 583 class COption_i64Z;
 584 class C2Tuple_ThirtyTwoBytesChannelManagerZ;
 585 class CResult_COption_OnionMessageContentsZDecodeErrorZ;
 586 class C2Tuple_u64CVec_u8ZZ;
 587 class CResult_OfferBolt12ParseErrorZ;
 588 class CResult_ThirtyTwoBytesRetryableSendFailureZ;
 589 class CVec_MonitorEventZ;
 590 class CResult_ShutdownDecodeErrorZ;
 591 class CResult_BigSizeDecodeErrorZ;
 592 class CResult_TxOutUtxoLookupErrorZ;
 593 class CResult_BlindedPathNoneZ;
 594 class COption_usizeZ;
 595 class CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ;
 596 class CResult_NoneNoneZ;
 597 class CResult_boolPeerHandleErrorZ;
 598 class CResult_ChannelUpdateDecodeErrorZ;
 599 class CVec_APIErrorZ;
 600 class COption_TxOutZ;
 601 class COption_ClosureReasonZ;
 602 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ;
 603 class CResult_TransactionU16LenLimitedDecodeErrorZ;
 604 class CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ;
 605 class CResult_CounterpartyForwardingInfoDecodeErrorZ;
 606 class CResult_OpenChannelV2DecodeErrorZ;
 607 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ;
 608 class C2Tuple_PublicKeyOnionMessageZ;
 609 class CResult_RouteDecodeErrorZ;
 610 class CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ;
 611 class COption_NoneZ;
 612 class CResult_TxAddOutputDecodeErrorZ;
 613 class COption_CVec_u8ZZ;
 614
 615 class Str {
 616 private:
 617         LDKStr self;
 618 public:
 619         Str(const Str&) = delete;
 620         Str(Str&& o) : self(o.self) { memset(&o, 0, sizeof(Str)); }
 621         Str(LDKStr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStr)); }
 622         operator LDKStr() && { LDKStr res = self; memset(&self, 0, sizeof(LDKStr)); return res; }
 623         ~Str() { Str_free(self); }
 624         Str& operator=(Str&& o) { Str_free(self); self = o.self; memset(&o, 0, sizeof(Str)); return *this; }
 625         LDKStr* operator &() { return &self; }
 626         LDKStr* operator ->() { return &self; }
 627         const LDKStr* operator &() const { return &self; }
 628         const LDKStr* operator ->() const { return &self; }
 629 };
 630 class Refund {
 631 private:
 632         LDKRefund self;
 633 public:
 634         Refund(const Refund&) = delete;
 635         Refund(Refund&& o) : self(o.self) { memset(&o, 0, sizeof(Refund)); }
 636         Refund(LDKRefund&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRefund)); }
 637         operator LDKRefund() && { LDKRefund res = self; memset(&self, 0, sizeof(LDKRefund)); return res; }
 638         ~Refund() { Refund_free(self); }
 639         Refund& operator=(Refund&& o) { Refund_free(self); self = o.self; memset(&o, 0, sizeof(Refund)); return *this; }
 640         LDKRefund* operator &() { return &self; }
 641         LDKRefund* operator ->() { return &self; }
 642         const LDKRefund* operator &() const { return &self; }
 643         const LDKRefund* operator ->() const { return &self; }
 644 };
 645 class Retry {
 646 private:
 647         LDKRetry self;
 648 public:
 649         Retry(const Retry&) = delete;
 650         Retry(Retry&& o) : self(o.self) { memset(&o, 0, sizeof(Retry)); }
 651         Retry(LDKRetry&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetry)); }
 652         operator LDKRetry() && { LDKRetry res = self; memset(&self, 0, sizeof(LDKRetry)); return res; }
 653         ~Retry() { Retry_free(self); }
 654         Retry& operator=(Retry&& o) { Retry_free(self); self = o.self; memset(&o, 0, sizeof(Retry)); return *this; }
 655         LDKRetry* operator &() { return &self; }
 656         LDKRetry* operator ->() { return &self; }
 657         const LDKRetry* operator &() const { return &self; }
 658         const LDKRetry* operator ->() const { return &self; }
 659 };
 660 class RetryableSendFailure {
 661 private:
 662         LDKRetryableSendFailure self;
 663 public:
 664         RetryableSendFailure(const RetryableSendFailure&) = delete;
 665         RetryableSendFailure(RetryableSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(RetryableSendFailure)); }
 666         RetryableSendFailure(LDKRetryableSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetryableSendFailure)); }
 667         operator LDKRetryableSendFailure() && { LDKRetryableSendFailure res = self; memset(&self, 0, sizeof(LDKRetryableSendFailure)); return res; }
 668         RetryableSendFailure& operator=(RetryableSendFailure&& o) { self = o.self; memset(&o, 0, sizeof(RetryableSendFailure)); return *this; }
 669         LDKRetryableSendFailure* operator &() { return &self; }
 670         LDKRetryableSendFailure* operator ->() { return &self; }
 671         const LDKRetryableSendFailure* operator &() const { return &self; }
 672         const LDKRetryableSendFailure* operator ->() const { return &self; }
 673 };
 674 class PaymentSendFailure {
 675 private:
 676         LDKPaymentSendFailure self;
 677 public:
 678         PaymentSendFailure(const PaymentSendFailure&) = delete;
 679         PaymentSendFailure(PaymentSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentSendFailure)); }
 680         PaymentSendFailure(LDKPaymentSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentSendFailure)); }
 681         operator LDKPaymentSendFailure() && { LDKPaymentSendFailure res = self; memset(&self, 0, sizeof(LDKPaymentSendFailure)); return res; }
 682         ~PaymentSendFailure() { PaymentSendFailure_free(self); }
 683         PaymentSendFailure& operator=(PaymentSendFailure&& o) { PaymentSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(PaymentSendFailure)); return *this; }
 684         LDKPaymentSendFailure* operator &() { return &self; }
 685         LDKPaymentSendFailure* operator ->() { return &self; }
 686         const LDKPaymentSendFailure* operator &() const { return &self; }
 687         const LDKPaymentSendFailure* operator ->() const { return &self; }
 688 };
 689 class ProbeSendFailure {
 690 private:
 691         LDKProbeSendFailure self;
 692 public:
 693         ProbeSendFailure(const ProbeSendFailure&) = delete;
 694         ProbeSendFailure(ProbeSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(ProbeSendFailure)); }
 695         ProbeSendFailure(LDKProbeSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbeSendFailure)); }
 696         operator LDKProbeSendFailure() && { LDKProbeSendFailure res = self; memset(&self, 0, sizeof(LDKProbeSendFailure)); return res; }
 697         ~ProbeSendFailure() { ProbeSendFailure_free(self); }
 698         ProbeSendFailure& operator=(ProbeSendFailure&& o) { ProbeSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(ProbeSendFailure)); return *this; }
 699         LDKProbeSendFailure* operator &() { return &self; }
 700         LDKProbeSendFailure* operator ->() { return &self; }
 701         const LDKProbeSendFailure* operator &() const { return &self; }
 702         const LDKProbeSendFailure* operator ->() const { return &self; }
 703 };
 704 class RecipientOnionFields {
 705 private:
 706         LDKRecipientOnionFields self;
 707 public:
 708         RecipientOnionFields(const RecipientOnionFields&) = delete;
 709         RecipientOnionFields(RecipientOnionFields&& o) : self(o.self) { memset(&o, 0, sizeof(RecipientOnionFields)); }
 710         RecipientOnionFields(LDKRecipientOnionFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecipientOnionFields)); }
 711         operator LDKRecipientOnionFields() && { LDKRecipientOnionFields res = self; memset(&self, 0, sizeof(LDKRecipientOnionFields)); return res; }
 712         ~RecipientOnionFields() { RecipientOnionFields_free(self); }
 713         RecipientOnionFields& operator=(RecipientOnionFields&& o) { RecipientOnionFields_free(self); self = o.self; memset(&o, 0, sizeof(RecipientOnionFields)); return *this; }
 714         LDKRecipientOnionFields* operator &() { return &self; }
 715         LDKRecipientOnionFields* operator ->() { return &self; }
 716         const LDKRecipientOnionFields* operator &() const { return &self; }
 717         const LDKRecipientOnionFields* operator ->() const { return &self; }
 718 };
 719 class UnsignedBolt12Invoice {
 720 private:
 721         LDKUnsignedBolt12Invoice self;
 722 public:
 723         UnsignedBolt12Invoice(const UnsignedBolt12Invoice&) = delete;
 724         UnsignedBolt12Invoice(UnsignedBolt12Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedBolt12Invoice)); }
 725         UnsignedBolt12Invoice(LDKUnsignedBolt12Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedBolt12Invoice)); }
 726         operator LDKUnsignedBolt12Invoice() && { LDKUnsignedBolt12Invoice res = self; memset(&self, 0, sizeof(LDKUnsignedBolt12Invoice)); return res; }
 727         ~UnsignedBolt12Invoice() { UnsignedBolt12Invoice_free(self); }
 728         UnsignedBolt12Invoice& operator=(UnsignedBolt12Invoice&& o) { UnsignedBolt12Invoice_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedBolt12Invoice)); return *this; }
 729         LDKUnsignedBolt12Invoice* operator &() { return &self; }
 730         LDKUnsignedBolt12Invoice* operator ->() { return &self; }
 731         const LDKUnsignedBolt12Invoice* operator &() const { return &self; }
 732         const LDKUnsignedBolt12Invoice* operator ->() const { return &self; }
 733 };
 734 class Bolt12Invoice {
 735 private:
 736         LDKBolt12Invoice self;
 737 public:
 738         Bolt12Invoice(const Bolt12Invoice&) = delete;
 739         Bolt12Invoice(Bolt12Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12Invoice)); }
 740         Bolt12Invoice(LDKBolt12Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12Invoice)); }
 741         operator LDKBolt12Invoice() && { LDKBolt12Invoice res = self; memset(&self, 0, sizeof(LDKBolt12Invoice)); return res; }
 742         ~Bolt12Invoice() { Bolt12Invoice_free(self); }
 743         Bolt12Invoice& operator=(Bolt12Invoice&& o) { Bolt12Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12Invoice)); return *this; }
 744         LDKBolt12Invoice* operator &() { return &self; }
 745         LDKBolt12Invoice* operator ->() { return &self; }
 746         const LDKBolt12Invoice* operator &() const { return &self; }
 747         const LDKBolt12Invoice* operator ->() const { return &self; }
 748 };
 749 class BlindedPayInfo {
 750 private:
 751         LDKBlindedPayInfo self;
 752 public:
 753         BlindedPayInfo(const BlindedPayInfo&) = delete;
 754         BlindedPayInfo(BlindedPayInfo&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPayInfo)); }
 755         BlindedPayInfo(LDKBlindedPayInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPayInfo)); }
 756         operator LDKBlindedPayInfo() && { LDKBlindedPayInfo res = self; memset(&self, 0, sizeof(LDKBlindedPayInfo)); return res; }
 757         ~BlindedPayInfo() { BlindedPayInfo_free(self); }
 758         BlindedPayInfo& operator=(BlindedPayInfo&& o) { BlindedPayInfo_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPayInfo)); return *this; }
 759         LDKBlindedPayInfo* operator &() { return &self; }
 760         LDKBlindedPayInfo* operator ->() { return &self; }
 761         const LDKBlindedPayInfo* operator &() const { return &self; }
 762         const LDKBlindedPayInfo* operator ->() const { return &self; }
 763 };
 764 class DelayedPaymentOutputDescriptor {
 765 private:
 766         LDKDelayedPaymentOutputDescriptor self;
 767 public:
 768         DelayedPaymentOutputDescriptor(const DelayedPaymentOutputDescriptor&) = delete;
 769         DelayedPaymentOutputDescriptor(DelayedPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); }
 770         DelayedPaymentOutputDescriptor(LDKDelayedPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); }
 771         operator LDKDelayedPaymentOutputDescriptor() && { LDKDelayedPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); return res; }
 772         ~DelayedPaymentOutputDescriptor() { DelayedPaymentOutputDescriptor_free(self); }
 773         DelayedPaymentOutputDescriptor& operator=(DelayedPaymentOutputDescriptor&& o) { DelayedPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); return *this; }
 774         LDKDelayedPaymentOutputDescriptor* operator &() { return &self; }
 775         LDKDelayedPaymentOutputDescriptor* operator ->() { return &self; }
 776         const LDKDelayedPaymentOutputDescriptor* operator &() const { return &self; }
 777         const LDKDelayedPaymentOutputDescriptor* operator ->() const { return &self; }
 778 };
 779 class StaticPaymentOutputDescriptor {
 780 private:
 781         LDKStaticPaymentOutputDescriptor self;
 782 public:
 783         StaticPaymentOutputDescriptor(const StaticPaymentOutputDescriptor&) = delete;
 784         StaticPaymentOutputDescriptor(StaticPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); }
 785         StaticPaymentOutputDescriptor(LDKStaticPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); }
 786         operator LDKStaticPaymentOutputDescriptor() && { LDKStaticPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); return res; }
 787         ~StaticPaymentOutputDescriptor() { StaticPaymentOutputDescriptor_free(self); }
 788         StaticPaymentOutputDescriptor& operator=(StaticPaymentOutputDescriptor&& o) { StaticPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); return *this; }
 789         LDKStaticPaymentOutputDescriptor* operator &() { return &self; }
 790         LDKStaticPaymentOutputDescriptor* operator ->() { return &self; }
 791         const LDKStaticPaymentOutputDescriptor* operator &() const { return &self; }
 792         const LDKStaticPaymentOutputDescriptor* operator ->() const { return &self; }
 793 };
 794 class SpendableOutputDescriptor {
 795 private:
 796         LDKSpendableOutputDescriptor self;
 797 public:
 798         SpendableOutputDescriptor(const SpendableOutputDescriptor&) = delete;
 799         SpendableOutputDescriptor(SpendableOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SpendableOutputDescriptor)); }
 800         SpendableOutputDescriptor(LDKSpendableOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendableOutputDescriptor)); }
 801         operator LDKSpendableOutputDescriptor() && { LDKSpendableOutputDescriptor res = self; memset(&self, 0, sizeof(LDKSpendableOutputDescriptor)); return res; }
 802         ~SpendableOutputDescriptor() { SpendableOutputDescriptor_free(self); }
 803         SpendableOutputDescriptor& operator=(SpendableOutputDescriptor&& o) { SpendableOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SpendableOutputDescriptor)); return *this; }
 804         LDKSpendableOutputDescriptor* operator &() { return &self; }
 805         LDKSpendableOutputDescriptor* operator ->() { return &self; }
 806         const LDKSpendableOutputDescriptor* operator &() const { return &self; }
 807         const LDKSpendableOutputDescriptor* operator ->() const { return &self; }
 808 };
 809 class ChannelDerivationParameters {
 810 private:
 811         LDKChannelDerivationParameters self;
 812 public:
 813         ChannelDerivationParameters(const ChannelDerivationParameters&) = delete;
 814         ChannelDerivationParameters(ChannelDerivationParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDerivationParameters)); }
 815         ChannelDerivationParameters(LDKChannelDerivationParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDerivationParameters)); }
 816         operator LDKChannelDerivationParameters() && { LDKChannelDerivationParameters res = self; memset(&self, 0, sizeof(LDKChannelDerivationParameters)); return res; }
 817         ~ChannelDerivationParameters() { ChannelDerivationParameters_free(self); }
 818         ChannelDerivationParameters& operator=(ChannelDerivationParameters&& o) { ChannelDerivationParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDerivationParameters)); return *this; }
 819         LDKChannelDerivationParameters* operator &() { return &self; }
 820         LDKChannelDerivationParameters* operator ->() { return &self; }
 821         const LDKChannelDerivationParameters* operator &() const { return &self; }
 822         const LDKChannelDerivationParameters* operator ->() const { return &self; }
 823 };
 824 class HTLCDescriptor {
 825 private:
 826         LDKHTLCDescriptor self;
 827 public:
 828         HTLCDescriptor(const HTLCDescriptor&) = delete;
 829         HTLCDescriptor(HTLCDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCDescriptor)); }
 830         HTLCDescriptor(LDKHTLCDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCDescriptor)); }
 831         operator LDKHTLCDescriptor() && { LDKHTLCDescriptor res = self; memset(&self, 0, sizeof(LDKHTLCDescriptor)); return res; }
 832         ~HTLCDescriptor() { HTLCDescriptor_free(self); }
 833         HTLCDescriptor& operator=(HTLCDescriptor&& o) { HTLCDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(HTLCDescriptor)); return *this; }
 834         LDKHTLCDescriptor* operator &() { return &self; }
 835         LDKHTLCDescriptor* operator ->() { return &self; }
 836         const LDKHTLCDescriptor* operator &() const { return &self; }
 837         const LDKHTLCDescriptor* operator ->() const { return &self; }
 838 };
 839 class ChannelSigner {
 840 private:
 841         LDKChannelSigner self;
 842 public:
 843         ChannelSigner(const ChannelSigner&) = delete;
 844         ChannelSigner(ChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelSigner)); }
 845         ChannelSigner(LDKChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelSigner)); }
 846         operator LDKChannelSigner() && { LDKChannelSigner res = self; memset(&self, 0, sizeof(LDKChannelSigner)); return res; }
 847         ~ChannelSigner() { ChannelSigner_free(self); }
 848         ChannelSigner& operator=(ChannelSigner&& o) { ChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(ChannelSigner)); return *this; }
 849         LDKChannelSigner* operator &() { return &self; }
 850         LDKChannelSigner* operator ->() { return &self; }
 851         const LDKChannelSigner* operator &() const { return &self; }
 852         const LDKChannelSigner* operator ->() const { return &self; }
 853         /**
 854          *  Gets the per-commitment point for a specific commitment number
 855          *
 856          *  Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.
 857          */
 858         inline LDKPublicKey get_per_commitment_point(uint64_t idx);
 859         /**
 860          *  Gets the commitment secret for a specific commitment number as part of the revocation process
 861          *
 862          *  An external signer implementation should error here if the commitment was already signed
 863          *  and should refuse to sign it in the future.
 864          *
 865          *  May be called more than once for the same index.
 866          *
 867          *  Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.
 868          */
 869         inline LDKThirtyTwoBytes release_commitment_secret(uint64_t idx);
 870         /**
 871          *  Validate the counterparty's signatures on the holder commitment transaction and HTLCs.
 872          *
 873          *  This is required in order for the signer to make sure that releasing a commitment
 874          *  secret won't leave us without a broadcastable holder transaction.
 875          *  Policy checks should be implemented in this function, including checking the amount
 876          *  sent to us and checking the HTLCs.
 877          *
 878          *  The preimages of outgoing HTLCs that were fulfilled since the last commitment are provided.
 879          *  A validating signer should ensure that an HTLC output is removed only when the matching
 880          *  preimage is provided, or when the value to holder is restored.
 881          *
 882          *  Note that all the relevant preimages will be provided, but there may also be additional
 883          *  irrelevant or duplicate preimages.
 884          */
 885         inline LDK::CResult_NoneNoneZ validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ preimages);
 886         /**
 887          *  Returns an arbitrary identifier describing the set of keys which are provided back to you in
 888          *  some [`SpendableOutputDescriptor`] types. This should be sufficient to identify this
 889          *  [`EcdsaChannelSigner`] object uniquely and lookup or re-derive its keys.
 890          */
 891         inline LDKThirtyTwoBytes channel_keys_id();
 892         /**
 893          *  Set the counterparty static channel data, including basepoints,
 894          *  `counterparty_selected`/`holder_selected_contest_delay` and funding outpoint.
 895          *
 896          *  This data is static, and will never change for a channel once set. For a given [`ChannelSigner`]
 897          *  instance, LDK will call this method exactly once - either immediately after construction
 898          *  (not including if done via [`SignerProvider::read_chan_signer`]) or when the funding
 899          *  information has been generated.
 900          *
 901          *  channel_parameters.is_populated() MUST be true.
 902          */
 903         inline void provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters);
 904 };
 905 class EcdsaChannelSigner {
 906 private:
 907         LDKEcdsaChannelSigner self;
 908 public:
 909         EcdsaChannelSigner(const EcdsaChannelSigner&) = delete;
 910         EcdsaChannelSigner(EcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(EcdsaChannelSigner)); }
 911         EcdsaChannelSigner(LDKEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEcdsaChannelSigner)); }
 912         operator LDKEcdsaChannelSigner() && { LDKEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKEcdsaChannelSigner)); return res; }
 913         ~EcdsaChannelSigner() { EcdsaChannelSigner_free(self); }
 914         EcdsaChannelSigner& operator=(EcdsaChannelSigner&& o) { EcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(EcdsaChannelSigner)); return *this; }
 915         LDKEcdsaChannelSigner* operator &() { return &self; }
 916         LDKEcdsaChannelSigner* operator ->() { return &self; }
 917         const LDKEcdsaChannelSigner* operator &() const { return &self; }
 918         const LDKEcdsaChannelSigner* operator ->() const { return &self; }
 919         /**
 920          *  Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
 921          *
 922          *  Note that if signing fails or is rejected, the channel will be force-closed.
 923          *
 924          *  Policy checks should be implemented in this function, including checking the amount
 925          *  sent to us and checking the HTLCs.
 926          *
 927          *  The preimages of outgoing HTLCs that were fulfilled since the last commitment are provided.
 928          *  A validating signer should ensure that an HTLC output is removed only when the matching
 929          *  preimage is provided, or when the value to holder is restored.
 930          *
 931          *  Note that all the relevant preimages will be provided, but there may also be additional
 932          *  irrelevant or duplicate preimages.
 933          */
 934         inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ preimages);
 935         /**
 936          *  Validate the counterparty's revocation.
 937          *
 938          *  This is required in order for the signer to make sure that the state has moved
 939          *  forward and it is safe to sign the next counterparty commitment.
 940          */
 941         inline LDK::CResult_NoneNoneZ validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]);
 942         /**
 943          *  Creates a signature for a holder's commitment transaction.
 944          *
 945          *  This will be called
 946          *  - with a non-revoked `commitment_tx`.
 947          *  - with the latest `commitment_tx` when we initiate a force-close.
 948          *
 949          *  This may be called multiple times for the same transaction.
 950          *
 951          *  An external signer implementation should check that the commitment has not been revoked.
 952          */
 953         inline LDK::CResult_ECDSASignatureNoneZ sign_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx);
 954         /**
 955          *  Create a signature for the given input in a transaction spending an HTLC transaction output
 956          *  or a commitment transaction `to_local` output when our counterparty broadcasts an old state.
 957          *
 958          *  A justice transaction may claim multiple outputs at the same time if timelocks are
 959          *  similar, but only a signature for the input at index `input` should be signed for here.
 960          *  It may be called multiple times for same output(s) if a fee-bump is needed with regards
 961          *  to an upcoming timelock expiration.
 962          *
 963          *  Amount is value of the output spent by this input, committed to in the BIP 143 signature.
 964          *
 965          *  `per_commitment_key` is revocation secret which was provided by our counterparty when they
 966          *  revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
 967          *  not allow the spending of any funds by itself (you need our holder `revocation_secret` to do
 968          *  so).
 969          */
 970         inline LDK::CResult_ECDSASignatureNoneZ sign_justice_revoked_output(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]);
 971         /**
 972          *  Create a signature for the given input in a transaction spending a commitment transaction
 973          *  HTLC output when our counterparty broadcasts an old state.
 974          *
 975          *  A justice transaction may claim multiple outputs at the same time if timelocks are
 976          *  similar, but only a signature for the input at index `input` should be signed for here.
 977          *  It may be called multiple times for same output(s) if a fee-bump is needed with regards
 978          *  to an upcoming timelock expiration.
 979          *
 980          *  `amount` is the value of the output spent by this input, committed to in the BIP 143
 981          *  signature.
 982          *
 983          *  `per_commitment_key` is revocation secret which was provided by our counterparty when they
 984          *  revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
 985          *  not allow the spending of any funds by itself (you need our holder revocation_secret to do
 986          *  so).
 987          *
 988          *  `htlc` holds HTLC elements (hash, timelock), thus changing the format of the witness script
 989          *  (which is committed to in the BIP 143 signatures).
 990          */
 991         inline LDK::CResult_ECDSASignatureNoneZ 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);
 992         /**
 993          *  Computes the signature for a commitment transaction's HTLC output used as an input within
 994          *  `htlc_tx`, which spends the commitment transaction at index `input`. The signature returned
 995          *  must be be computed using [`EcdsaSighashType::All`].
 996          *
 997          *  Note that this may be called for HTLCs in the penultimate commitment transaction if a
 998          *  [`ChannelMonitor`] [replica](https://github.com/lightningdevkit/rust-lightning/blob/main/GLOSSARY.md#monitor-replicas)
 999          *  broadcasts it before receiving the update for the latest commitment transaction.
1000          *
1001          *  [`EcdsaSighashType::All`]: bitcoin::blockdata::transaction::EcdsaSighashType::All
1002          *  [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
1003          */
1004         inline LDK::CResult_ECDSASignatureNoneZ sign_holder_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor);
1005         /**
1006          *  Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment
1007          *  transaction, either offered or received.
1008          *
1009          *  Such a transaction may claim multiples offered outputs at same time if we know the
1010          *  preimage for each when we create it, but only the input at index `input` should be
1011          *  signed for here. It may be called multiple times for same output(s) if a fee-bump is
1012          *  needed with regards to an upcoming timelock expiration.
1013          *
1014          *  `witness_script` is either an offered or received script as defined in BOLT3 for HTLC
1015          *  outputs.
1016          *
1017          *  `amount` is value of the output spent by this input, committed to in the BIP 143 signature.
1018          *
1019          *  `per_commitment_point` is the dynamic point corresponding to the channel state
1020          *  detected onchain. It has been generated by our counterparty and is used to derive
1021          *  channel state keys, which are then included in the witness script and committed to in the
1022          *  BIP 143 signature.
1023          */
1024         inline LDK::CResult_ECDSASignatureNoneZ 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);
1025         /**
1026          *  Create a signature for a (proposed) closing transaction.
1027          *
1028          *  Note that, due to rounding, there may be one "missing" satoshi, and either party may have
1029          *  chosen to forgo their output as dust.
1030          */
1031         inline LDK::CResult_ECDSASignatureNoneZ sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx);
1032         /**
1033          *  Computes the signature for a commitment transaction's anchor output used as an
1034          *  input within `anchor_tx`, which spends the commitment transaction, at index `input`.
1035          */
1036         inline LDK::CResult_ECDSASignatureNoneZ sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input);
1037         /**
1038          *  Signs a channel announcement message with our funding key proving it comes from one of the
1039          *  channel participants.
1040          *
1041          *  Channel announcements also require a signature from each node's network key. Our node
1042          *  signature is computed through [`NodeSigner::sign_gossip_message`].
1043          *
1044          *  Note that if this fails or is rejected, the channel will not be publicly announced and
1045          *  our counterparty may (though likely will not) close the channel on us for violating the
1046          *  protocol.
1047          */
1048         inline LDK::CResult_ECDSASignatureNoneZ sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
1049 };
1050 class WriteableEcdsaChannelSigner {
1051 private:
1052         LDKWriteableEcdsaChannelSigner self;
1053 public:
1054         WriteableEcdsaChannelSigner(const WriteableEcdsaChannelSigner&) = delete;
1055         WriteableEcdsaChannelSigner(WriteableEcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(WriteableEcdsaChannelSigner)); }
1056         WriteableEcdsaChannelSigner(LDKWriteableEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWriteableEcdsaChannelSigner)); }
1057         operator LDKWriteableEcdsaChannelSigner() && { LDKWriteableEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKWriteableEcdsaChannelSigner)); return res; }
1058         ~WriteableEcdsaChannelSigner() { WriteableEcdsaChannelSigner_free(self); }
1059         WriteableEcdsaChannelSigner& operator=(WriteableEcdsaChannelSigner&& o) { WriteableEcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(WriteableEcdsaChannelSigner)); return *this; }
1060         LDKWriteableEcdsaChannelSigner* operator &() { return &self; }
1061         LDKWriteableEcdsaChannelSigner* operator ->() { return &self; }
1062         const LDKWriteableEcdsaChannelSigner* operator &() const { return &self; }
1063         const LDKWriteableEcdsaChannelSigner* operator ->() const { return &self; }
1064 };
1065 class Recipient {
1066 private:
1067         LDKRecipient self;
1068 public:
1069         Recipient(const Recipient&) = delete;
1070         Recipient(Recipient&& o) : self(o.self) { memset(&o, 0, sizeof(Recipient)); }
1071         Recipient(LDKRecipient&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecipient)); }
1072         operator LDKRecipient() && { LDKRecipient res = self; memset(&self, 0, sizeof(LDKRecipient)); return res; }
1073         Recipient& operator=(Recipient&& o) { self = o.self; memset(&o, 0, sizeof(Recipient)); return *this; }
1074         LDKRecipient* operator &() { return &self; }
1075         LDKRecipient* operator ->() { return &self; }
1076         const LDKRecipient* operator &() const { return &self; }
1077         const LDKRecipient* operator ->() const { return &self; }
1078 };
1079 class EntropySource {
1080 private:
1081         LDKEntropySource self;
1082 public:
1083         EntropySource(const EntropySource&) = delete;
1084         EntropySource(EntropySource&& o) : self(o.self) { memset(&o, 0, sizeof(EntropySource)); }
1085         EntropySource(LDKEntropySource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEntropySource)); }
1086         operator LDKEntropySource() && { LDKEntropySource res = self; memset(&self, 0, sizeof(LDKEntropySource)); return res; }
1087         ~EntropySource() { EntropySource_free(self); }
1088         EntropySource& operator=(EntropySource&& o) { EntropySource_free(self); self = o.self; memset(&o, 0, sizeof(EntropySource)); return *this; }
1089         LDKEntropySource* operator &() { return &self; }
1090         LDKEntropySource* operator ->() { return &self; }
1091         const LDKEntropySource* operator &() const { return &self; }
1092         const LDKEntropySource* operator ->() const { return &self; }
1093         /**
1094          *  Gets a unique, cryptographically-secure, random 32-byte value. This method must return a
1095          *  different value each time it is called.
1096          */
1097         inline LDKThirtyTwoBytes get_secure_random_bytes();
1098 };
1099 class NodeSigner {
1100 private:
1101         LDKNodeSigner self;
1102 public:
1103         NodeSigner(const NodeSigner&) = delete;
1104         NodeSigner(NodeSigner&& o) : self(o.self) { memset(&o, 0, sizeof(NodeSigner)); }
1105         NodeSigner(LDKNodeSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeSigner)); }
1106         operator LDKNodeSigner() && { LDKNodeSigner res = self; memset(&self, 0, sizeof(LDKNodeSigner)); return res; }
1107         ~NodeSigner() { NodeSigner_free(self); }
1108         NodeSigner& operator=(NodeSigner&& o) { NodeSigner_free(self); self = o.self; memset(&o, 0, sizeof(NodeSigner)); return *this; }
1109         LDKNodeSigner* operator &() { return &self; }
1110         LDKNodeSigner* operator ->() { return &self; }
1111         const LDKNodeSigner* operator &() const { return &self; }
1112         const LDKNodeSigner* operator ->() const { return &self; }
1113         /**
1114          *  Get secret key material as bytes for use in encrypting and decrypting inbound payment data.
1115          *
1116          *  If the implementor of this trait supports [phantom node payments], then every node that is
1117          *  intended to be included in the phantom invoice route hints must return the same value from
1118          *  this method.
1119          *
1120          *  This method must return the same value each time it is called.
1121          *
1122          *  [phantom node payments]: PhantomKeysManager
1123          */
1124         inline LDKThirtyTwoBytes get_inbound_payment_key_material();
1125         /**
1126          *  Get node id based on the provided [`Recipient`].
1127          *
1128          *  This method must return the same value each time it is called with a given [`Recipient`]
1129          *  parameter.
1130          *
1131          *  Errors if the [`Recipient`] variant is not supported by the implementation.
1132          */
1133         inline LDK::CResult_PublicKeyNoneZ get_node_id(enum LDKRecipient recipient);
1134         /**
1135          *  Gets the ECDH shared secret of our node secret and `other_key`, multiplying by `tweak` if
1136          *  one is provided. Note that this tweak can be applied to `other_key` instead of our node
1137          *  secret, though this is less efficient.
1138          *
1139          *  Note that if this fails while attempting to forward an HTLC, LDK will panic. The error
1140          *  should be resolved to allow LDK to resume forwarding HTLCs.
1141          *
1142          *  Errors if the [`Recipient`] variant is not supported by the implementation.
1143          */
1144         inline LDK::CResult_ThirtyTwoBytesNoneZ ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak);
1145         /**
1146          *  Sign an invoice.
1147          *
1148          *  By parameterizing by the raw invoice bytes instead of the hash, we allow implementors of
1149          *  this trait to parse the invoice and make sure they're signing what they expect, rather than
1150          *  blindly signing the hash.
1151          *
1152          *  The `hrp_bytes` are ASCII bytes, while the `invoice_data` is base32.
1153          *
1154          *  The secret key used to sign the invoice is dependent on the [`Recipient`].
1155          *
1156          *  Errors if the [`Recipient`] variant is not supported by the implementation.
1157          */
1158         inline LDK::CResult_RecoverableSignatureNoneZ sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient);
1159         /**
1160          *  Signs the [`TaggedHash`] of a BOLT 12 invoice request.
1161          *
1162          *  May be called by a function passed to [`UnsignedInvoiceRequest::sign`] where
1163          *  `invoice_request` is the callee.
1164          *
1165          *  Implementors may check that the `invoice_request` is expected rather than blindly signing
1166          *  the tagged hash. An `Ok` result should sign `invoice_request.tagged_hash().as_digest()` with
1167          *  the node's signing key or an ephemeral key to preserve privacy, whichever is associated with
1168          *  [`UnsignedInvoiceRequest::payer_id`].
1169          *
1170          *  [`TaggedHash`]: crate::offers::merkle::TaggedHash
1171          */
1172         inline LDK::CResult_SchnorrSignatureNoneZ sign_bolt12_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR invoice_request);
1173         /**
1174          *  Signs the [`TaggedHash`] of a BOLT 12 invoice.
1175          *
1176          *  May be called by a function passed to [`UnsignedBolt12Invoice::sign`] where `invoice` is the
1177          *  callee.
1178          *
1179          *  Implementors may check that the `invoice` is expected rather than blindly signing the tagged
1180          *  hash. An `Ok` result should sign `invoice.tagged_hash().as_digest()` with the node's signing
1181          *  key or an ephemeral key to preserve privacy, whichever is associated with
1182          *  [`UnsignedBolt12Invoice::signing_pubkey`].
1183          *
1184          *  [`TaggedHash`]: crate::offers::merkle::TaggedHash
1185          */
1186         inline LDK::CResult_SchnorrSignatureNoneZ sign_bolt12_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR invoice);
1187         /**
1188          *  Sign a gossip message.
1189          *
1190          *  Note that if this fails, LDK may panic and the message will not be broadcast to the network
1191          *  or a possible channel counterparty. If LDK panics, the error should be resolved to allow the
1192          *  message to be broadcast, as otherwise it may prevent one from receiving funds over the
1193          *  corresponding channel.
1194          */
1195         inline LDK::CResult_ECDSASignatureNoneZ sign_gossip_message(struct LDKUnsignedGossipMessage msg);
1196 };
1197 class SignerProvider {
1198 private:
1199         LDKSignerProvider self;
1200 public:
1201         SignerProvider(const SignerProvider&) = delete;
1202         SignerProvider(SignerProvider&& o) : self(o.self) { memset(&o, 0, sizeof(SignerProvider)); }
1203         SignerProvider(LDKSignerProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignerProvider)); }
1204         operator LDKSignerProvider() && { LDKSignerProvider res = self; memset(&self, 0, sizeof(LDKSignerProvider)); return res; }
1205         ~SignerProvider() { SignerProvider_free(self); }
1206         SignerProvider& operator=(SignerProvider&& o) { SignerProvider_free(self); self = o.self; memset(&o, 0, sizeof(SignerProvider)); return *this; }
1207         LDKSignerProvider* operator &() { return &self; }
1208         LDKSignerProvider* operator ->() { return &self; }
1209         const LDKSignerProvider* operator &() const { return &self; }
1210         const LDKSignerProvider* operator ->() const { return &self; }
1211         /**
1212          *  Generates a unique `channel_keys_id` that can be used to obtain a [`Self::Signer`] through
1213          *  [`SignerProvider::derive_channel_signer`]. The `user_channel_id` is provided to allow
1214          *  implementations of [`SignerProvider`] to maintain a mapping between itself and the generated
1215          *  `channel_keys_id`.
1216          *
1217          *  This method must return a different value each time it is called.
1218          */
1219         inline LDKThirtyTwoBytes generate_channel_keys_id(bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id);
1220         /**
1221          *  Derives the private key material backing a `Signer`.
1222          *
1223          *  To derive a new `Signer`, a fresh `channel_keys_id` should be obtained through
1224          *  [`SignerProvider::generate_channel_keys_id`]. Otherwise, an existing `Signer` can be
1225          *  re-derived from its `channel_keys_id`, which can be obtained through its trait method
1226          *  [`ChannelSigner::channel_keys_id`].
1227          */
1228         inline LDK::WriteableEcdsaChannelSigner derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id);
1229         /**
1230          *  Reads a [`Signer`] for this [`SignerProvider`] from the given input stream.
1231          *  This is only called during deserialization of other objects which contain
1232          *  [`WriteableEcdsaChannelSigner`]-implementing objects (i.e., [`ChannelMonitor`]s and [`ChannelManager`]s).
1233          *  The bytes are exactly those which `<Self::Signer as Writeable>::write()` writes, and
1234          *  contain no versioning scheme. You may wish to include your own version prefix and ensure
1235          *  you've read all of the provided bytes to ensure no corruption occurred.
1236          *
1237          *  This method is slowly being phased out -- it will only be called when reading objects
1238          *  written by LDK versions prior to 0.0.113.
1239          *
1240          *  [`Signer`]: Self::Signer
1241          *  [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
1242          *  [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
1243          */
1244         inline LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ read_chan_signer(struct LDKu8slice reader);
1245         /**
1246          *  Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
1247          *
1248          *  If this function returns an error, this will result in a channel failing to open.
1249          *
1250          *  This method should return a different value each time it is called, to avoid linking
1251          *  on-chain funds across channels as controlled to the same user.
1252          */
1253         inline LDK::CResult_CVec_u8ZNoneZ get_destination_script();
1254         /**
1255          *  Get a script pubkey which we will send funds to when closing a channel.
1256          *
1257          *  If this function returns an error, this will result in a channel failing to open or close.
1258          *  In the event of a failure when the counterparty is initiating a close, this can result in a
1259          *  channel force close.
1260          *
1261          *  This method should return a different value each time it is called, to avoid linking
1262          *  on-chain funds across channels as controlled to the same user.
1263          */
1264         inline LDK::CResult_ShutdownScriptNoneZ get_shutdown_scriptpubkey();
1265 };
1266 class InMemorySigner {
1267 private:
1268         LDKInMemorySigner self;
1269 public:
1270         InMemorySigner(const InMemorySigner&) = delete;
1271         InMemorySigner(InMemorySigner&& o) : self(o.self) { memset(&o, 0, sizeof(InMemorySigner)); }
1272         InMemorySigner(LDKInMemorySigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInMemorySigner)); }
1273         operator LDKInMemorySigner() && { LDKInMemorySigner res = self; memset(&self, 0, sizeof(LDKInMemorySigner)); return res; }
1274         ~InMemorySigner() { InMemorySigner_free(self); }
1275         InMemorySigner& operator=(InMemorySigner&& o) { InMemorySigner_free(self); self = o.self; memset(&o, 0, sizeof(InMemorySigner)); return *this; }
1276         LDKInMemorySigner* operator &() { return &self; }
1277         LDKInMemorySigner* operator ->() { return &self; }
1278         const LDKInMemorySigner* operator &() const { return &self; }
1279         const LDKInMemorySigner* operator ->() const { return &self; }
1280 };
1281 class KeysManager {
1282 private:
1283         LDKKeysManager self;
1284 public:
1285         KeysManager(const KeysManager&) = delete;
1286         KeysManager(KeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(KeysManager)); }
1287         KeysManager(LDKKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysManager)); }
1288         operator LDKKeysManager() && { LDKKeysManager res = self; memset(&self, 0, sizeof(LDKKeysManager)); return res; }
1289         ~KeysManager() { KeysManager_free(self); }
1290         KeysManager& operator=(KeysManager&& o) { KeysManager_free(self); self = o.self; memset(&o, 0, sizeof(KeysManager)); return *this; }
1291         LDKKeysManager* operator &() { return &self; }
1292         LDKKeysManager* operator ->() { return &self; }
1293         const LDKKeysManager* operator &() const { return &self; }
1294         const LDKKeysManager* operator ->() const { return &self; }
1295 };
1296 class PhantomKeysManager {
1297 private:
1298         LDKPhantomKeysManager self;
1299 public:
1300         PhantomKeysManager(const PhantomKeysManager&) = delete;
1301         PhantomKeysManager(PhantomKeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomKeysManager)); }
1302         PhantomKeysManager(LDKPhantomKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomKeysManager)); }
1303         operator LDKPhantomKeysManager() && { LDKPhantomKeysManager res = self; memset(&self, 0, sizeof(LDKPhantomKeysManager)); return res; }
1304         ~PhantomKeysManager() { PhantomKeysManager_free(self); }
1305         PhantomKeysManager& operator=(PhantomKeysManager&& o) { PhantomKeysManager_free(self); self = o.self; memset(&o, 0, sizeof(PhantomKeysManager)); return *this; }
1306         LDKPhantomKeysManager* operator &() { return &self; }
1307         LDKPhantomKeysManager* operator ->() { return &self; }
1308         const LDKPhantomKeysManager* operator &() const { return &self; }
1309         const LDKPhantomKeysManager* operator ->() const { return &self; }
1310 };
1311 class BackgroundProcessor {
1312 private:
1313         LDKBackgroundProcessor self;
1314 public:
1315         BackgroundProcessor(const BackgroundProcessor&) = delete;
1316         BackgroundProcessor(BackgroundProcessor&& o) : self(o.self) { memset(&o, 0, sizeof(BackgroundProcessor)); }
1317         BackgroundProcessor(LDKBackgroundProcessor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBackgroundProcessor)); }
1318         operator LDKBackgroundProcessor() && { LDKBackgroundProcessor res = self; memset(&self, 0, sizeof(LDKBackgroundProcessor)); return res; }
1319         ~BackgroundProcessor() { BackgroundProcessor_free(self); }
1320         BackgroundProcessor& operator=(BackgroundProcessor&& o) { BackgroundProcessor_free(self); self = o.self; memset(&o, 0, sizeof(BackgroundProcessor)); return *this; }
1321         LDKBackgroundProcessor* operator &() { return &self; }
1322         LDKBackgroundProcessor* operator ->() { return &self; }
1323         const LDKBackgroundProcessor* operator &() const { return &self; }
1324         const LDKBackgroundProcessor* operator ->() const { return &self; }
1325 };
1326 class GossipSync {
1327 private:
1328         LDKGossipSync self;
1329 public:
1330         GossipSync(const GossipSync&) = delete;
1331         GossipSync(GossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(GossipSync)); }
1332         GossipSync(LDKGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipSync)); }
1333         operator LDKGossipSync() && { LDKGossipSync res = self; memset(&self, 0, sizeof(LDKGossipSync)); return res; }
1334         ~GossipSync() { GossipSync_free(self); }
1335         GossipSync& operator=(GossipSync&& o) { GossipSync_free(self); self = o.self; memset(&o, 0, sizeof(GossipSync)); return *this; }
1336         LDKGossipSync* operator &() { return &self; }
1337         LDKGossipSync* operator ->() { return &self; }
1338         const LDKGossipSync* operator &() const { return &self; }
1339         const LDKGossipSync* operator ->() const { return &self; }
1340 };
1341 class DefaultRouter {
1342 private:
1343         LDKDefaultRouter self;
1344 public:
1345         DefaultRouter(const DefaultRouter&) = delete;
1346         DefaultRouter(DefaultRouter&& o) : self(o.self) { memset(&o, 0, sizeof(DefaultRouter)); }
1347         DefaultRouter(LDKDefaultRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDefaultRouter)); }
1348         operator LDKDefaultRouter() && { LDKDefaultRouter res = self; memset(&self, 0, sizeof(LDKDefaultRouter)); return res; }
1349         ~DefaultRouter() { DefaultRouter_free(self); }
1350         DefaultRouter& operator=(DefaultRouter&& o) { DefaultRouter_free(self); self = o.self; memset(&o, 0, sizeof(DefaultRouter)); return *this; }
1351         LDKDefaultRouter* operator &() { return &self; }
1352         LDKDefaultRouter* operator ->() { return &self; }
1353         const LDKDefaultRouter* operator &() const { return &self; }
1354         const LDKDefaultRouter* operator ->() const { return &self; }
1355 };
1356 class Router {
1357 private:
1358         LDKRouter self;
1359 public:
1360         Router(const Router&) = delete;
1361         Router(Router&& o) : self(o.self) { memset(&o, 0, sizeof(Router)); }
1362         Router(LDKRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouter)); }
1363         operator LDKRouter() && { LDKRouter res = self; memset(&self, 0, sizeof(LDKRouter)); return res; }
1364         ~Router() { Router_free(self); }
1365         Router& operator=(Router&& o) { Router_free(self); self = o.self; memset(&o, 0, sizeof(Router)); return *this; }
1366         LDKRouter* operator &() { return &self; }
1367         LDKRouter* operator ->() { return &self; }
1368         const LDKRouter* operator &() const { return &self; }
1369         const LDKRouter* operator ->() const { return &self; }
1370         /**
1371          *  Finds a [`Route`] for a payment between the given `payer` and a payee.
1372          *
1373          *  The `payee` and the payment's value are given in [`RouteParameters::payment_params`]
1374          *  and [`RouteParameters::final_value_msat`], respectively.
1375          *
1376          *  Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
1377          */
1378         inline LDK::CResult_RouteLightningErrorZ find_route(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKInFlightHtlcs inflight_htlcs);
1379         /**
1380          *  Finds a [`Route`] for a payment between the given `payer` and a payee.
1381          *
1382          *  The `payee` and the payment's value are given in [`RouteParameters::payment_params`]
1383          *  and [`RouteParameters::final_value_msat`], respectively.
1384          *
1385          *  Includes a [`PaymentHash`] and a [`PaymentId`] to be able to correlate the request with a specific
1386          *  payment.
1387          *
1388          *  Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
1389          */
1390         inline LDK::CResult_RouteLightningErrorZ find_route_with_id(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKInFlightHtlcs inflight_htlcs, struct LDKThirtyTwoBytes _payment_hash, struct LDKThirtyTwoBytes _payment_id);
1391 };
1392 class ScorerAccountingForInFlightHtlcs {
1393 private:
1394         LDKScorerAccountingForInFlightHtlcs self;
1395 public:
1396         ScorerAccountingForInFlightHtlcs(const ScorerAccountingForInFlightHtlcs&) = delete;
1397         ScorerAccountingForInFlightHtlcs(ScorerAccountingForInFlightHtlcs&& o) : self(o.self) { memset(&o, 0, sizeof(ScorerAccountingForInFlightHtlcs)); }
1398         ScorerAccountingForInFlightHtlcs(LDKScorerAccountingForInFlightHtlcs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScorerAccountingForInFlightHtlcs)); }
1399         operator LDKScorerAccountingForInFlightHtlcs() && { LDKScorerAccountingForInFlightHtlcs res = self; memset(&self, 0, sizeof(LDKScorerAccountingForInFlightHtlcs)); return res; }
1400         ~ScorerAccountingForInFlightHtlcs() { ScorerAccountingForInFlightHtlcs_free(self); }
1401         ScorerAccountingForInFlightHtlcs& operator=(ScorerAccountingForInFlightHtlcs&& o) { ScorerAccountingForInFlightHtlcs_free(self); self = o.self; memset(&o, 0, sizeof(ScorerAccountingForInFlightHtlcs)); return *this; }
1402         LDKScorerAccountingForInFlightHtlcs* operator &() { return &self; }
1403         LDKScorerAccountingForInFlightHtlcs* operator ->() { return &self; }
1404         const LDKScorerAccountingForInFlightHtlcs* operator &() const { return &self; }
1405         const LDKScorerAccountingForInFlightHtlcs* operator ->() const { return &self; }
1406 };
1407 class InFlightHtlcs {
1408 private:
1409         LDKInFlightHtlcs self;
1410 public:
1411         InFlightHtlcs(const InFlightHtlcs&) = delete;
1412         InFlightHtlcs(InFlightHtlcs&& o) : self(o.self) { memset(&o, 0, sizeof(InFlightHtlcs)); }
1413         InFlightHtlcs(LDKInFlightHtlcs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInFlightHtlcs)); }
1414         operator LDKInFlightHtlcs() && { LDKInFlightHtlcs res = self; memset(&self, 0, sizeof(LDKInFlightHtlcs)); return res; }
1415         ~InFlightHtlcs() { InFlightHtlcs_free(self); }
1416         InFlightHtlcs& operator=(InFlightHtlcs&& o) { InFlightHtlcs_free(self); self = o.self; memset(&o, 0, sizeof(InFlightHtlcs)); return *this; }
1417         LDKInFlightHtlcs* operator &() { return &self; }
1418         LDKInFlightHtlcs* operator ->() { return &self; }
1419         const LDKInFlightHtlcs* operator &() const { return &self; }
1420         const LDKInFlightHtlcs* operator ->() const { return &self; }
1421 };
1422 class RouteHop {
1423 private:
1424         LDKRouteHop self;
1425 public:
1426         RouteHop(const RouteHop&) = delete;
1427         RouteHop(RouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHop)); }
1428         RouteHop(LDKRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHop)); }
1429         operator LDKRouteHop() && { LDKRouteHop res = self; memset(&self, 0, sizeof(LDKRouteHop)); return res; }
1430         ~RouteHop() { RouteHop_free(self); }
1431         RouteHop& operator=(RouteHop&& o) { RouteHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHop)); return *this; }
1432         LDKRouteHop* operator &() { return &self; }
1433         LDKRouteHop* operator ->() { return &self; }
1434         const LDKRouteHop* operator &() const { return &self; }
1435         const LDKRouteHop* operator ->() const { return &self; }
1436 };
1437 class BlindedTail {
1438 private:
1439         LDKBlindedTail self;
1440 public:
1441         BlindedTail(const BlindedTail&) = delete;
1442         BlindedTail(BlindedTail&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedTail)); }
1443         BlindedTail(LDKBlindedTail&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedTail)); }
1444         operator LDKBlindedTail() && { LDKBlindedTail res = self; memset(&self, 0, sizeof(LDKBlindedTail)); return res; }
1445         ~BlindedTail() { BlindedTail_free(self); }
1446         BlindedTail& operator=(BlindedTail&& o) { BlindedTail_free(self); self = o.self; memset(&o, 0, sizeof(BlindedTail)); return *this; }
1447         LDKBlindedTail* operator &() { return &self; }
1448         LDKBlindedTail* operator ->() { return &self; }
1449         const LDKBlindedTail* operator &() const { return &self; }
1450         const LDKBlindedTail* operator ->() const { return &self; }
1451 };
1452 class Path {
1453 private:
1454         LDKPath self;
1455 public:
1456         Path(const Path&) = delete;
1457         Path(Path&& o) : self(o.self) { memset(&o, 0, sizeof(Path)); }
1458         Path(LDKPath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPath)); }
1459         operator LDKPath() && { LDKPath res = self; memset(&self, 0, sizeof(LDKPath)); return res; }
1460         ~Path() { Path_free(self); }
1461         Path& operator=(Path&& o) { Path_free(self); self = o.self; memset(&o, 0, sizeof(Path)); return *this; }
1462         LDKPath* operator &() { return &self; }
1463         LDKPath* operator ->() { return &self; }
1464         const LDKPath* operator &() const { return &self; }
1465         const LDKPath* operator ->() const { return &self; }
1466 };
1467 class Route {
1468 private:
1469         LDKRoute self;
1470 public:
1471         Route(const Route&) = delete;
1472         Route(Route&& o) : self(o.self) { memset(&o, 0, sizeof(Route)); }
1473         Route(LDKRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoute)); }
1474         operator LDKRoute() && { LDKRoute res = self; memset(&self, 0, sizeof(LDKRoute)); return res; }
1475         ~Route() { Route_free(self); }
1476         Route& operator=(Route&& o) { Route_free(self); self = o.self; memset(&o, 0, sizeof(Route)); return *this; }
1477         LDKRoute* operator &() { return &self; }
1478         LDKRoute* operator ->() { return &self; }
1479         const LDKRoute* operator &() const { return &self; }
1480         const LDKRoute* operator ->() const { return &self; }
1481 };
1482 class RouteParameters {
1483 private:
1484         LDKRouteParameters self;
1485 public:
1486         RouteParameters(const RouteParameters&) = delete;
1487         RouteParameters(RouteParameters&& o) : self(o.self) { memset(&o, 0, sizeof(RouteParameters)); }
1488         RouteParameters(LDKRouteParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteParameters)); }
1489         operator LDKRouteParameters() && { LDKRouteParameters res = self; memset(&self, 0, sizeof(LDKRouteParameters)); return res; }
1490         ~RouteParameters() { RouteParameters_free(self); }
1491         RouteParameters& operator=(RouteParameters&& o) { RouteParameters_free(self); self = o.self; memset(&o, 0, sizeof(RouteParameters)); return *this; }
1492         LDKRouteParameters* operator &() { return &self; }
1493         LDKRouteParameters* operator ->() { return &self; }
1494         const LDKRouteParameters* operator &() const { return &self; }
1495         const LDKRouteParameters* operator ->() const { return &self; }
1496 };
1497 class PaymentParameters {
1498 private:
1499         LDKPaymentParameters self;
1500 public:
1501         PaymentParameters(const PaymentParameters&) = delete;
1502         PaymentParameters(PaymentParameters&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentParameters)); }
1503         PaymentParameters(LDKPaymentParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentParameters)); }
1504         operator LDKPaymentParameters() && { LDKPaymentParameters res = self; memset(&self, 0, sizeof(LDKPaymentParameters)); return res; }
1505         ~PaymentParameters() { PaymentParameters_free(self); }
1506         PaymentParameters& operator=(PaymentParameters&& o) { PaymentParameters_free(self); self = o.self; memset(&o, 0, sizeof(PaymentParameters)); return *this; }
1507         LDKPaymentParameters* operator &() { return &self; }
1508         LDKPaymentParameters* operator ->() { return &self; }
1509         const LDKPaymentParameters* operator &() const { return &self; }
1510         const LDKPaymentParameters* operator ->() const { return &self; }
1511 };
1512 class Payee {
1513 private:
1514         LDKPayee self;
1515 public:
1516         Payee(const Payee&) = delete;
1517         Payee(Payee&& o) : self(o.self) { memset(&o, 0, sizeof(Payee)); }
1518         Payee(LDKPayee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayee)); }
1519         operator LDKPayee() && { LDKPayee res = self; memset(&self, 0, sizeof(LDKPayee)); return res; }
1520         ~Payee() { Payee_free(self); }
1521         Payee& operator=(Payee&& o) { Payee_free(self); self = o.self; memset(&o, 0, sizeof(Payee)); return *this; }
1522         LDKPayee* operator &() { return &self; }
1523         LDKPayee* operator ->() { return &self; }
1524         const LDKPayee* operator &() const { return &self; }
1525         const LDKPayee* operator ->() const { return &self; }
1526 };
1527 class RouteHint {
1528 private:
1529         LDKRouteHint self;
1530 public:
1531         RouteHint(const RouteHint&) = delete;
1532         RouteHint(RouteHint&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHint)); }
1533         RouteHint(LDKRouteHint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHint)); }
1534         operator LDKRouteHint() && { LDKRouteHint res = self; memset(&self, 0, sizeof(LDKRouteHint)); return res; }
1535         ~RouteHint() { RouteHint_free(self); }
1536         RouteHint& operator=(RouteHint&& o) { RouteHint_free(self); self = o.self; memset(&o, 0, sizeof(RouteHint)); return *this; }
1537         LDKRouteHint* operator &() { return &self; }
1538         LDKRouteHint* operator ->() { return &self; }
1539         const LDKRouteHint* operator &() const { return &self; }
1540         const LDKRouteHint* operator ->() const { return &self; }
1541 };
1542 class RouteHintHop {
1543 private:
1544         LDKRouteHintHop self;
1545 public:
1546         RouteHintHop(const RouteHintHop&) = delete;
1547         RouteHintHop(RouteHintHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHintHop)); }
1548         RouteHintHop(LDKRouteHintHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHintHop)); }
1549         operator LDKRouteHintHop() && { LDKRouteHintHop res = self; memset(&self, 0, sizeof(LDKRouteHintHop)); return res; }
1550         ~RouteHintHop() { RouteHintHop_free(self); }
1551         RouteHintHop& operator=(RouteHintHop&& o) { RouteHintHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHintHop)); return *this; }
1552         LDKRouteHintHop* operator &() { return &self; }
1553         LDKRouteHintHop* operator ->() { return &self; }
1554         const LDKRouteHintHop* operator &() const { return &self; }
1555         const LDKRouteHintHop* operator ->() const { return &self; }
1556 };
1557 class ScoreLookUp {
1558 private:
1559         LDKScoreLookUp self;
1560 public:
1561         ScoreLookUp(const ScoreLookUp&) = delete;
1562         ScoreLookUp(ScoreLookUp&& o) : self(o.self) { memset(&o, 0, sizeof(ScoreLookUp)); }
1563         ScoreLookUp(LDKScoreLookUp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScoreLookUp)); }
1564         operator LDKScoreLookUp() && { LDKScoreLookUp res = self; memset(&self, 0, sizeof(LDKScoreLookUp)); return res; }
1565         ~ScoreLookUp() { ScoreLookUp_free(self); }
1566         ScoreLookUp& operator=(ScoreLookUp&& o) { ScoreLookUp_free(self); self = o.self; memset(&o, 0, sizeof(ScoreLookUp)); return *this; }
1567         LDKScoreLookUp* operator &() { return &self; }
1568         LDKScoreLookUp* operator ->() { return &self; }
1569         const LDKScoreLookUp* operator &() const { return &self; }
1570         const LDKScoreLookUp* operator ->() const { return &self; }
1571         /**
1572          *  Returns the fee in msats willing to be paid to avoid routing `send_amt_msat` through the
1573          *  given channel in the direction from `source` to `target`.
1574          *
1575          *  The channel's capacity (less any other MPP parts that are also being considered for use in
1576          *  the same payment) is given by `capacity_msat`. It may be determined from various sources
1577          *  such as a chain data, network gossip, or invoice hints. For invoice hints, a capacity near
1578          *  [`u64::max_value`] is given to indicate sufficient capacity for the invoice's full amount.
1579          *  Thus, implementations should be overflow-safe.
1580          */
1581         inline uint64_t channel_penalty_msat(uint64_t short_channel_id, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params);
1582 };
1583 class ScoreUpdate {
1584 private:
1585         LDKScoreUpdate self;
1586 public:
1587         ScoreUpdate(const ScoreUpdate&) = delete;
1588         ScoreUpdate(ScoreUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ScoreUpdate)); }
1589         ScoreUpdate(LDKScoreUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScoreUpdate)); }
1590         operator LDKScoreUpdate() && { LDKScoreUpdate res = self; memset(&self, 0, sizeof(LDKScoreUpdate)); return res; }
1591         ~ScoreUpdate() { ScoreUpdate_free(self); }
1592         ScoreUpdate& operator=(ScoreUpdate&& o) { ScoreUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ScoreUpdate)); return *this; }
1593         LDKScoreUpdate* operator &() { return &self; }
1594         LDKScoreUpdate* operator ->() { return &self; }
1595         const LDKScoreUpdate* operator &() const { return &self; }
1596         const LDKScoreUpdate* operator ->() const { return &self; }
1597         /**
1598          *  Handles updating channel penalties after failing to route through a channel.
1599          */
1600         inline void payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id);
1601         /**
1602          *  Handles updating channel penalties after successfully routing along a path.
1603          */
1604         inline void payment_path_successful(const struct LDKPath *NONNULL_PTR path);
1605         /**
1606          *  Handles updating channel penalties after a probe over the given path failed.
1607          */
1608         inline void probe_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id);
1609         /**
1610          *  Handles updating channel penalties after a probe over the given path succeeded.
1611          */
1612         inline void probe_successful(const struct LDKPath *NONNULL_PTR path);
1613 };
1614 class Score {
1615 private:
1616         LDKScore self;
1617 public:
1618         Score(const Score&) = delete;
1619         Score(Score&& o) : self(o.self) { memset(&o, 0, sizeof(Score)); }
1620         Score(LDKScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScore)); }
1621         operator LDKScore() && { LDKScore res = self; memset(&self, 0, sizeof(LDKScore)); return res; }
1622         ~Score() { Score_free(self); }
1623         Score& operator=(Score&& o) { Score_free(self); self = o.self; memset(&o, 0, sizeof(Score)); return *this; }
1624         LDKScore* operator &() { return &self; }
1625         LDKScore* operator ->() { return &self; }
1626         const LDKScore* operator &() const { return &self; }
1627         const LDKScore* operator ->() const { return &self; }
1628 };
1629 class LockableScore {
1630 private:
1631         LDKLockableScore self;
1632 public:
1633         LockableScore(const LockableScore&) = delete;
1634         LockableScore(LockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(LockableScore)); }
1635         LockableScore(LDKLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockableScore)); }
1636         operator LDKLockableScore() && { LDKLockableScore res = self; memset(&self, 0, sizeof(LDKLockableScore)); return res; }
1637         ~LockableScore() { LockableScore_free(self); }
1638         LockableScore& operator=(LockableScore&& o) { LockableScore_free(self); self = o.self; memset(&o, 0, sizeof(LockableScore)); return *this; }
1639         LDKLockableScore* operator &() { return &self; }
1640         LDKLockableScore* operator ->() { return &self; }
1641         const LDKLockableScore* operator &() const { return &self; }
1642         const LDKLockableScore* operator ->() const { return &self; }
1643         /**
1644          *  Returns read locked scorer.
1645          */
1646         inline LDK::ScoreLookUp read_lock();
1647         /**
1648          *  Returns write locked scorer.
1649          */
1650         inline LDK::ScoreUpdate write_lock();
1651 };
1652 class WriteableScore {
1653 private:
1654         LDKWriteableScore self;
1655 public:
1656         WriteableScore(const WriteableScore&) = delete;
1657         WriteableScore(WriteableScore&& o) : self(o.self) { memset(&o, 0, sizeof(WriteableScore)); }
1658         WriteableScore(LDKWriteableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWriteableScore)); }
1659         operator LDKWriteableScore() && { LDKWriteableScore res = self; memset(&self, 0, sizeof(LDKWriteableScore)); return res; }
1660         ~WriteableScore() { WriteableScore_free(self); }
1661         WriteableScore& operator=(WriteableScore&& o) { WriteableScore_free(self); self = o.self; memset(&o, 0, sizeof(WriteableScore)); return *this; }
1662         LDKWriteableScore* operator &() { return &self; }
1663         LDKWriteableScore* operator ->() { return &self; }
1664         const LDKWriteableScore* operator &() const { return &self; }
1665         const LDKWriteableScore* operator ->() const { return &self; }
1666 };
1667 class MultiThreadedLockableScore {
1668 private:
1669         LDKMultiThreadedLockableScore self;
1670 public:
1671         MultiThreadedLockableScore(const MultiThreadedLockableScore&) = delete;
1672         MultiThreadedLockableScore(MultiThreadedLockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedLockableScore)); }
1673         MultiThreadedLockableScore(LDKMultiThreadedLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedLockableScore)); }
1674         operator LDKMultiThreadedLockableScore() && { LDKMultiThreadedLockableScore res = self; memset(&self, 0, sizeof(LDKMultiThreadedLockableScore)); return res; }
1675         ~MultiThreadedLockableScore() { MultiThreadedLockableScore_free(self); }
1676         MultiThreadedLockableScore& operator=(MultiThreadedLockableScore&& o) { MultiThreadedLockableScore_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedLockableScore)); return *this; }
1677         LDKMultiThreadedLockableScore* operator &() { return &self; }
1678         LDKMultiThreadedLockableScore* operator ->() { return &self; }
1679         const LDKMultiThreadedLockableScore* operator &() const { return &self; }
1680         const LDKMultiThreadedLockableScore* operator ->() const { return &self; }
1681 };
1682 class MultiThreadedScoreLockRead {
1683 private:
1684         LDKMultiThreadedScoreLockRead self;
1685 public:
1686         MultiThreadedScoreLockRead(const MultiThreadedScoreLockRead&) = delete;
1687         MultiThreadedScoreLockRead(MultiThreadedScoreLockRead&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedScoreLockRead)); }
1688         MultiThreadedScoreLockRead(LDKMultiThreadedScoreLockRead&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedScoreLockRead)); }
1689         operator LDKMultiThreadedScoreLockRead() && { LDKMultiThreadedScoreLockRead res = self; memset(&self, 0, sizeof(LDKMultiThreadedScoreLockRead)); return res; }
1690         ~MultiThreadedScoreLockRead() { MultiThreadedScoreLockRead_free(self); }
1691         MultiThreadedScoreLockRead& operator=(MultiThreadedScoreLockRead&& o) { MultiThreadedScoreLockRead_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedScoreLockRead)); return *this; }
1692         LDKMultiThreadedScoreLockRead* operator &() { return &self; }
1693         LDKMultiThreadedScoreLockRead* operator ->() { return &self; }
1694         const LDKMultiThreadedScoreLockRead* operator &() const { return &self; }
1695         const LDKMultiThreadedScoreLockRead* operator ->() const { return &self; }
1696 };
1697 class MultiThreadedScoreLockWrite {
1698 private:
1699         LDKMultiThreadedScoreLockWrite self;
1700 public:
1701         MultiThreadedScoreLockWrite(const MultiThreadedScoreLockWrite&) = delete;
1702         MultiThreadedScoreLockWrite(MultiThreadedScoreLockWrite&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedScoreLockWrite)); }
1703         MultiThreadedScoreLockWrite(LDKMultiThreadedScoreLockWrite&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedScoreLockWrite)); }
1704         operator LDKMultiThreadedScoreLockWrite() && { LDKMultiThreadedScoreLockWrite res = self; memset(&self, 0, sizeof(LDKMultiThreadedScoreLockWrite)); return res; }
1705         ~MultiThreadedScoreLockWrite() { MultiThreadedScoreLockWrite_free(self); }
1706         MultiThreadedScoreLockWrite& operator=(MultiThreadedScoreLockWrite&& o) { MultiThreadedScoreLockWrite_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedScoreLockWrite)); return *this; }
1707         LDKMultiThreadedScoreLockWrite* operator &() { return &self; }
1708         LDKMultiThreadedScoreLockWrite* operator ->() { return &self; }
1709         const LDKMultiThreadedScoreLockWrite* operator &() const { return &self; }
1710         const LDKMultiThreadedScoreLockWrite* operator ->() const { return &self; }
1711 };
1712 class ChannelUsage {
1713 private:
1714         LDKChannelUsage self;
1715 public:
1716         ChannelUsage(const ChannelUsage&) = delete;
1717         ChannelUsage(ChannelUsage&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUsage)); }
1718         ChannelUsage(LDKChannelUsage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUsage)); }
1719         operator LDKChannelUsage() && { LDKChannelUsage res = self; memset(&self, 0, sizeof(LDKChannelUsage)); return res; }
1720         ~ChannelUsage() { ChannelUsage_free(self); }
1721         ChannelUsage& operator=(ChannelUsage&& o) { ChannelUsage_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUsage)); return *this; }
1722         LDKChannelUsage* operator &() { return &self; }
1723         LDKChannelUsage* operator ->() { return &self; }
1724         const LDKChannelUsage* operator &() const { return &self; }
1725         const LDKChannelUsage* operator ->() const { return &self; }
1726 };
1727 class FixedPenaltyScorer {
1728 private:
1729         LDKFixedPenaltyScorer self;
1730 public:
1731         FixedPenaltyScorer(const FixedPenaltyScorer&) = delete;
1732         FixedPenaltyScorer(FixedPenaltyScorer&& o) : self(o.self) { memset(&o, 0, sizeof(FixedPenaltyScorer)); }
1733         FixedPenaltyScorer(LDKFixedPenaltyScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFixedPenaltyScorer)); }
1734         operator LDKFixedPenaltyScorer() && { LDKFixedPenaltyScorer res = self; memset(&self, 0, sizeof(LDKFixedPenaltyScorer)); return res; }
1735         ~FixedPenaltyScorer() { FixedPenaltyScorer_free(self); }
1736         FixedPenaltyScorer& operator=(FixedPenaltyScorer&& o) { FixedPenaltyScorer_free(self); self = o.self; memset(&o, 0, sizeof(FixedPenaltyScorer)); return *this; }
1737         LDKFixedPenaltyScorer* operator &() { return &self; }
1738         LDKFixedPenaltyScorer* operator ->() { return &self; }
1739         const LDKFixedPenaltyScorer* operator &() const { return &self; }
1740         const LDKFixedPenaltyScorer* operator ->() const { return &self; }
1741 };
1742 class ProbabilisticScorer {
1743 private:
1744         LDKProbabilisticScorer self;
1745 public:
1746         ProbabilisticScorer(const ProbabilisticScorer&) = delete;
1747         ProbabilisticScorer(ProbabilisticScorer&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScorer)); }
1748         ProbabilisticScorer(LDKProbabilisticScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScorer)); }
1749         operator LDKProbabilisticScorer() && { LDKProbabilisticScorer res = self; memset(&self, 0, sizeof(LDKProbabilisticScorer)); return res; }
1750         ~ProbabilisticScorer() { ProbabilisticScorer_free(self); }
1751         ProbabilisticScorer& operator=(ProbabilisticScorer&& o) { ProbabilisticScorer_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScorer)); return *this; }
1752         LDKProbabilisticScorer* operator &() { return &self; }
1753         LDKProbabilisticScorer* operator ->() { return &self; }
1754         const LDKProbabilisticScorer* operator &() const { return &self; }
1755         const LDKProbabilisticScorer* operator ->() const { return &self; }
1756 };
1757 class ProbabilisticScoringFeeParameters {
1758 private:
1759         LDKProbabilisticScoringFeeParameters self;
1760 public:
1761         ProbabilisticScoringFeeParameters(const ProbabilisticScoringFeeParameters&) = delete;
1762         ProbabilisticScoringFeeParameters(ProbabilisticScoringFeeParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScoringFeeParameters)); }
1763         ProbabilisticScoringFeeParameters(LDKProbabilisticScoringFeeParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScoringFeeParameters)); }
1764         operator LDKProbabilisticScoringFeeParameters() && { LDKProbabilisticScoringFeeParameters res = self; memset(&self, 0, sizeof(LDKProbabilisticScoringFeeParameters)); return res; }
1765         ~ProbabilisticScoringFeeParameters() { ProbabilisticScoringFeeParameters_free(self); }
1766         ProbabilisticScoringFeeParameters& operator=(ProbabilisticScoringFeeParameters&& o) { ProbabilisticScoringFeeParameters_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScoringFeeParameters)); return *this; }
1767         LDKProbabilisticScoringFeeParameters* operator &() { return &self; }
1768         LDKProbabilisticScoringFeeParameters* operator ->() { return &self; }
1769         const LDKProbabilisticScoringFeeParameters* operator &() const { return &self; }
1770         const LDKProbabilisticScoringFeeParameters* operator ->() const { return &self; }
1771 };
1772 class ProbabilisticScoringDecayParameters {
1773 private:
1774         LDKProbabilisticScoringDecayParameters self;
1775 public:
1776         ProbabilisticScoringDecayParameters(const ProbabilisticScoringDecayParameters&) = delete;
1777         ProbabilisticScoringDecayParameters(ProbabilisticScoringDecayParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScoringDecayParameters)); }
1778         ProbabilisticScoringDecayParameters(LDKProbabilisticScoringDecayParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScoringDecayParameters)); }
1779         operator LDKProbabilisticScoringDecayParameters() && { LDKProbabilisticScoringDecayParameters res = self; memset(&self, 0, sizeof(LDKProbabilisticScoringDecayParameters)); return res; }
1780         ~ProbabilisticScoringDecayParameters() { ProbabilisticScoringDecayParameters_free(self); }
1781         ProbabilisticScoringDecayParameters& operator=(ProbabilisticScoringDecayParameters&& o) { ProbabilisticScoringDecayParameters_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScoringDecayParameters)); return *this; }
1782         LDKProbabilisticScoringDecayParameters* operator &() { return &self; }
1783         LDKProbabilisticScoringDecayParameters* operator ->() { return &self; }
1784         const LDKProbabilisticScoringDecayParameters* operator &() const { return &self; }
1785         const LDKProbabilisticScoringDecayParameters* operator ->() const { return &self; }
1786 };
1787 class BestBlock {
1788 private:
1789         LDKBestBlock self;
1790 public:
1791         BestBlock(const BestBlock&) = delete;
1792         BestBlock(BestBlock&& o) : self(o.self) { memset(&o, 0, sizeof(BestBlock)); }
1793         BestBlock(LDKBestBlock&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBestBlock)); }
1794         operator LDKBestBlock() && { LDKBestBlock res = self; memset(&self, 0, sizeof(LDKBestBlock)); return res; }
1795         ~BestBlock() { BestBlock_free(self); }
1796         BestBlock& operator=(BestBlock&& o) { BestBlock_free(self); self = o.self; memset(&o, 0, sizeof(BestBlock)); return *this; }
1797         LDKBestBlock* operator &() { return &self; }
1798         LDKBestBlock* operator ->() { return &self; }
1799         const LDKBestBlock* operator &() const { return &self; }
1800         const LDKBestBlock* operator ->() const { return &self; }
1801 };
1802 class Listen {
1803 private:
1804         LDKListen self;
1805 public:
1806         Listen(const Listen&) = delete;
1807         Listen(Listen&& o) : self(o.self) { memset(&o, 0, sizeof(Listen)); }
1808         Listen(LDKListen&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKListen)); }
1809         operator LDKListen() && { LDKListen res = self; memset(&self, 0, sizeof(LDKListen)); return res; }
1810         ~Listen() { Listen_free(self); }
1811         Listen& operator=(Listen&& o) { Listen_free(self); self = o.self; memset(&o, 0, sizeof(Listen)); return *this; }
1812         LDKListen* operator &() { return &self; }
1813         LDKListen* operator ->() { return &self; }
1814         const LDKListen* operator &() const { return &self; }
1815         const LDKListen* operator ->() const { return &self; }
1816         /**
1817          *  Notifies the listener that a block was added at the given height, with the transaction data
1818          *  possibly filtered.
1819          */
1820         inline void filtered_block_connected(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
1821         /**
1822          *  Notifies the listener that a block was added at the given height.
1823          */
1824         inline void block_connected(struct LDKu8slice block, uint32_t height);
1825         /**
1826          *  Notifies the listener that a block was removed at the given height.
1827          */
1828         inline void block_disconnected(const uint8_t (*header)[80], uint32_t height);
1829 };
1830 class Confirm {
1831 private:
1832         LDKConfirm self;
1833 public:
1834         Confirm(const Confirm&) = delete;
1835         Confirm(Confirm&& o) : self(o.self) { memset(&o, 0, sizeof(Confirm)); }
1836         Confirm(LDKConfirm&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirm)); }
1837         operator LDKConfirm() && { LDKConfirm res = self; memset(&self, 0, sizeof(LDKConfirm)); return res; }
1838         ~Confirm() { Confirm_free(self); }
1839         Confirm& operator=(Confirm&& o) { Confirm_free(self); self = o.self; memset(&o, 0, sizeof(Confirm)); return *this; }
1840         LDKConfirm* operator &() { return &self; }
1841         LDKConfirm* operator ->() { return &self; }
1842         const LDKConfirm* operator &() const { return &self; }
1843         const LDKConfirm* operator ->() const { return &self; }
1844         /**
1845          *  Notifies LDK of transactions confirmed in a block with a given header and height.
1846          *
1847          *  Must be called for any transactions registered by [`Filter::register_tx`] or any
1848          *  transactions spending an output registered by [`Filter::register_output`]. Such transactions
1849          *  appearing in the same block do not need to be included in the same call; instead, multiple
1850          *  calls with additional transactions may be made so long as they are made in [chain order].
1851          *
1852          *  May be called before or after [`best_block_updated`] for the corresponding block. However,
1853          *  in the event of a chain reorganization, it must not be called with a `header` that is no
1854          *  longer in the chain as of the last call to [`best_block_updated`].
1855          *
1856          *  [chain order]: Confirm#order
1857          *  [`best_block_updated`]: Self::best_block_updated
1858          */
1859         inline void transactions_confirmed(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
1860         /**
1861          *  Notifies LDK of a transaction that is no longer confirmed as result of a chain reorganization.
1862          *
1863          *  Must be called for any transaction returned by [`get_relevant_txids`] if it has been
1864          *  reorganized out of the best chain or if it is no longer confirmed in the block with the
1865          *  given block hash. Once called, the given transaction will not be returned
1866          *  by [`get_relevant_txids`], unless it has been reconfirmed via [`transactions_confirmed`].
1867          *
1868          *  [`get_relevant_txids`]: Self::get_relevant_txids
1869          *  [`transactions_confirmed`]: Self::transactions_confirmed
1870          */
1871         inline void transaction_unconfirmed(const uint8_t (*txid)[32]);
1872         /**
1873          *  Notifies LDK of an update to the best header connected at the given height.
1874          *
1875          *  Must be called whenever a new chain tip becomes available. May be skipped for intermediary
1876          *  blocks.
1877          */
1878         inline void best_block_updated(const uint8_t (*header)[80], uint32_t height);
1879         /**
1880          *  Returns transactions that must be monitored for reorganization out of the chain along
1881          *  with the hash of the block as part of which it had been previously confirmed.
1882          *
1883          *  Note that the returned `Option<BlockHash>` might be `None` for channels created with LDK
1884          *  0.0.112 and prior, in which case you need to manually track previous confirmations.
1885          *
1886          *  Will include any transactions passed to [`transactions_confirmed`] that have insufficient
1887          *  confirmations to be safe from a chain reorganization. Will not include any transactions
1888          *  passed to [`transaction_unconfirmed`], unless later reconfirmed.
1889          *
1890          *  Must be called to determine the subset of transactions that must be monitored for
1891          *  reorganization. Will be idempotent between calls but may change as a result of calls to the
1892          *  other interface methods. Thus, this is useful to determine which transactions must be
1893          *  given to [`transaction_unconfirmed`].
1894          *
1895          *  If any of the returned transactions are confirmed in a block other than the one with the
1896          *  given hash, they need to be unconfirmed and reconfirmed via [`transaction_unconfirmed`] and
1897          *  [`transactions_confirmed`], respectively.
1898          *
1899          *  [`transactions_confirmed`]: Self::transactions_confirmed
1900          *  [`transaction_unconfirmed`]: Self::transaction_unconfirmed
1901          */
1902         inline LDK::CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ get_relevant_txids();
1903 };
1904 class ChannelMonitorUpdateStatus {
1905 private:
1906         LDKChannelMonitorUpdateStatus self;
1907 public:
1908         ChannelMonitorUpdateStatus(const ChannelMonitorUpdateStatus&) = delete;
1909         ChannelMonitorUpdateStatus(ChannelMonitorUpdateStatus&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateStatus)); }
1910         ChannelMonitorUpdateStatus(LDKChannelMonitorUpdateStatus&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateStatus)); }
1911         operator LDKChannelMonitorUpdateStatus() && { LDKChannelMonitorUpdateStatus res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateStatus)); return res; }
1912         ChannelMonitorUpdateStatus& operator=(ChannelMonitorUpdateStatus&& o) { self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdateStatus)); return *this; }
1913         LDKChannelMonitorUpdateStatus* operator &() { return &self; }
1914         LDKChannelMonitorUpdateStatus* operator ->() { return &self; }
1915         const LDKChannelMonitorUpdateStatus* operator &() const { return &self; }
1916         const LDKChannelMonitorUpdateStatus* operator ->() const { return &self; }
1917 };
1918 class Watch {
1919 private:
1920         LDKWatch self;
1921 public:
1922         Watch(const Watch&) = delete;
1923         Watch(Watch&& o) : self(o.self) { memset(&o, 0, sizeof(Watch)); }
1924         Watch(LDKWatch&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatch)); }
1925         operator LDKWatch() && { LDKWatch res = self; memset(&self, 0, sizeof(LDKWatch)); return res; }
1926         ~Watch() { Watch_free(self); }
1927         Watch& operator=(Watch&& o) { Watch_free(self); self = o.self; memset(&o, 0, sizeof(Watch)); return *this; }
1928         LDKWatch* operator &() { return &self; }
1929         LDKWatch* operator ->() { return &self; }
1930         const LDKWatch* operator &() const { return &self; }
1931         const LDKWatch* operator ->() const { return &self; }
1932         /**
1933          *  Watches a channel identified by `funding_txo` using `monitor`.
1934          *
1935          *  Implementations are responsible for watching the chain for the funding transaction along
1936          *  with any spends of outputs returned by [`get_outputs_to_watch`]. In practice, this means
1937          *  calling [`block_connected`] and [`block_disconnected`] on the monitor.
1938          *
1939          *  A return of `Err(())` indicates that the channel should immediately be force-closed without
1940          *  broadcasting the funding transaction.
1941          *
1942          *  If the given `funding_txo` has previously been registered via `watch_channel`, `Err(())`
1943          *  must be returned.
1944          *
1945          *  [`get_outputs_to_watch`]: channelmonitor::ChannelMonitor::get_outputs_to_watch
1946          *  [`block_connected`]: channelmonitor::ChannelMonitor::block_connected
1947          *  [`block_disconnected`]: channelmonitor::ChannelMonitor::block_disconnected
1948          */
1949         inline LDK::CResult_ChannelMonitorUpdateStatusNoneZ watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor);
1950         /**
1951          *  Updates a channel identified by `funding_txo` by applying `update` to its monitor.
1952          *
1953          *  Implementations must call [`ChannelMonitor::update_monitor`] with the given update. This
1954          *  may fail (returning an `Err(())`), in which case this should return
1955          *  [`ChannelMonitorUpdateStatus::InProgress`] (and the update should never complete). This
1956          *  generally implies the channel has been closed (either by the funding outpoint being spent
1957          *  on-chain or the [`ChannelMonitor`] having decided to do so and broadcasted a transaction),
1958          *  and the [`ChannelManager`] state will be updated once it sees the funding spend on-chain.
1959          *
1960          *  In general, persistence failures should be retried after returning
1961          *  [`ChannelMonitorUpdateStatus::InProgress`] and eventually complete. If a failure truly
1962          *  cannot be retried, the node should shut down immediately after returning
1963          *  [`ChannelMonitorUpdateStatus::UnrecoverableError`], see its documentation for more info.
1964          *
1965          *  [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
1966          */
1967         inline LDK::ChannelMonitorUpdateStatus update_channel(struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update);
1968         /**
1969          *  Returns any monitor events since the last call. Subsequent calls must only return new
1970          *  events.
1971          *
1972          *  Note that after any block- or transaction-connection calls to a [`ChannelMonitor`], no
1973          *  further events may be returned here until the [`ChannelMonitor`] has been fully persisted
1974          *  to disk.
1975          *
1976          *  For details on asynchronous [`ChannelMonitor`] updating and returning
1977          *  [`MonitorEvent::Completed`] here, see [`ChannelMonitorUpdateStatus::InProgress`].
1978          */
1979         inline LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ release_pending_monitor_events();
1980 };
1981 class Filter {
1982 private:
1983         LDKFilter self;
1984 public:
1985         Filter(const Filter&) = delete;
1986         Filter(Filter&& o) : self(o.self) { memset(&o, 0, sizeof(Filter)); }
1987         Filter(LDKFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilter)); }
1988         operator LDKFilter() && { LDKFilter res = self; memset(&self, 0, sizeof(LDKFilter)); return res; }
1989         ~Filter() { Filter_free(self); }
1990         Filter& operator=(Filter&& o) { Filter_free(self); self = o.self; memset(&o, 0, sizeof(Filter)); return *this; }
1991         LDKFilter* operator &() { return &self; }
1992         LDKFilter* operator ->() { return &self; }
1993         const LDKFilter* operator &() const { return &self; }
1994         const LDKFilter* operator ->() const { return &self; }
1995         /**
1996          *  Registers interest in a transaction with `txid` and having an output with `script_pubkey` as
1997          *  a spending condition.
1998          */
1999         inline void register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey);
2000         /**
2001          *  Registers interest in spends of a transaction output.
2002          *
2003          *  Note that this method might be called during processing of a new block. You therefore need
2004          *  to ensure that also dependent output spents within an already connected block are correctly
2005          *  handled, e.g., by re-scanning the block in question whenever new outputs have been
2006          *  registered mid-processing.
2007          */
2008         inline void register_output(struct LDKWatchedOutput output);
2009 };
2010 class WatchedOutput {
2011 private:
2012         LDKWatchedOutput self;
2013 public:
2014         WatchedOutput(const WatchedOutput&) = delete;
2015         WatchedOutput(WatchedOutput&& o) : self(o.self) { memset(&o, 0, sizeof(WatchedOutput)); }
2016         WatchedOutput(LDKWatchedOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatchedOutput)); }
2017         operator LDKWatchedOutput() && { LDKWatchedOutput res = self; memset(&self, 0, sizeof(LDKWatchedOutput)); return res; }
2018         ~WatchedOutput() { WatchedOutput_free(self); }
2019         WatchedOutput& operator=(WatchedOutput&& o) { WatchedOutput_free(self); self = o.self; memset(&o, 0, sizeof(WatchedOutput)); return *this; }
2020         LDKWatchedOutput* operator &() { return &self; }
2021         LDKWatchedOutput* operator ->() { return &self; }
2022         const LDKWatchedOutput* operator &() const { return &self; }
2023         const LDKWatchedOutput* operator ->() const { return &self; }
2024 };
2025 class InitFeatures {
2026 private:
2027         LDKInitFeatures self;
2028 public:
2029         InitFeatures(const InitFeatures&) = delete;
2030         InitFeatures(InitFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InitFeatures)); }
2031         InitFeatures(LDKInitFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInitFeatures)); }
2032         operator LDKInitFeatures() && { LDKInitFeatures res = self; memset(&self, 0, sizeof(LDKInitFeatures)); return res; }
2033         ~InitFeatures() { InitFeatures_free(self); }
2034         InitFeatures& operator=(InitFeatures&& o) { InitFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InitFeatures)); return *this; }
2035         LDKInitFeatures* operator &() { return &self; }
2036         LDKInitFeatures* operator ->() { return &self; }
2037         const LDKInitFeatures* operator &() const { return &self; }
2038         const LDKInitFeatures* operator ->() const { return &self; }
2039 };
2040 class NodeFeatures {
2041 private:
2042         LDKNodeFeatures self;
2043 public:
2044         NodeFeatures(const NodeFeatures&) = delete;
2045         NodeFeatures(NodeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(NodeFeatures)); }
2046         NodeFeatures(LDKNodeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeFeatures)); }
2047         operator LDKNodeFeatures() && { LDKNodeFeatures res = self; memset(&self, 0, sizeof(LDKNodeFeatures)); return res; }
2048         ~NodeFeatures() { NodeFeatures_free(self); }
2049         NodeFeatures& operator=(NodeFeatures&& o) { NodeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(NodeFeatures)); return *this; }
2050         LDKNodeFeatures* operator &() { return &self; }
2051         LDKNodeFeatures* operator ->() { return &self; }
2052         const LDKNodeFeatures* operator &() const { return &self; }
2053         const LDKNodeFeatures* operator ->() const { return &self; }
2054 };
2055 class ChannelFeatures {
2056 private:
2057         LDKChannelFeatures self;
2058 public:
2059         ChannelFeatures(const ChannelFeatures&) = delete;
2060         ChannelFeatures(ChannelFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelFeatures)); }
2061         ChannelFeatures(LDKChannelFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelFeatures)); }
2062         operator LDKChannelFeatures() && { LDKChannelFeatures res = self; memset(&self, 0, sizeof(LDKChannelFeatures)); return res; }
2063         ~ChannelFeatures() { ChannelFeatures_free(self); }
2064         ChannelFeatures& operator=(ChannelFeatures&& o) { ChannelFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelFeatures)); return *this; }
2065         LDKChannelFeatures* operator &() { return &self; }
2066         LDKChannelFeatures* operator ->() { return &self; }
2067         const LDKChannelFeatures* operator &() const { return &self; }
2068         const LDKChannelFeatures* operator ->() const { return &self; }
2069 };
2070 class Bolt11InvoiceFeatures {
2071 private:
2072         LDKBolt11InvoiceFeatures self;
2073 public:
2074         Bolt11InvoiceFeatures(const Bolt11InvoiceFeatures&) = delete;
2075         Bolt11InvoiceFeatures(Bolt11InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11InvoiceFeatures)); }
2076         Bolt11InvoiceFeatures(LDKBolt11InvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11InvoiceFeatures)); }
2077         operator LDKBolt11InvoiceFeatures() && { LDKBolt11InvoiceFeatures res = self; memset(&self, 0, sizeof(LDKBolt11InvoiceFeatures)); return res; }
2078         ~Bolt11InvoiceFeatures() { Bolt11InvoiceFeatures_free(self); }
2079         Bolt11InvoiceFeatures& operator=(Bolt11InvoiceFeatures&& o) { Bolt11InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11InvoiceFeatures)); return *this; }
2080         LDKBolt11InvoiceFeatures* operator &() { return &self; }
2081         LDKBolt11InvoiceFeatures* operator ->() { return &self; }
2082         const LDKBolt11InvoiceFeatures* operator &() const { return &self; }
2083         const LDKBolt11InvoiceFeatures* operator ->() const { return &self; }
2084 };
2085 class OfferFeatures {
2086 private:
2087         LDKOfferFeatures self;
2088 public:
2089         OfferFeatures(const OfferFeatures&) = delete;
2090         OfferFeatures(OfferFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(OfferFeatures)); }
2091         OfferFeatures(LDKOfferFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferFeatures)); }
2092         operator LDKOfferFeatures() && { LDKOfferFeatures res = self; memset(&self, 0, sizeof(LDKOfferFeatures)); return res; }
2093         ~OfferFeatures() { OfferFeatures_free(self); }
2094         OfferFeatures& operator=(OfferFeatures&& o) { OfferFeatures_free(self); self = o.self; memset(&o, 0, sizeof(OfferFeatures)); return *this; }
2095         LDKOfferFeatures* operator &() { return &self; }
2096         LDKOfferFeatures* operator ->() { return &self; }
2097         const LDKOfferFeatures* operator &() const { return &self; }
2098         const LDKOfferFeatures* operator ->() const { return &self; }
2099 };
2100 class InvoiceRequestFeatures {
2101 private:
2102         LDKInvoiceRequestFeatures self;
2103 public:
2104         InvoiceRequestFeatures(const InvoiceRequestFeatures&) = delete;
2105         InvoiceRequestFeatures(InvoiceRequestFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestFeatures)); }
2106         InvoiceRequestFeatures(LDKInvoiceRequestFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestFeatures)); }
2107         operator LDKInvoiceRequestFeatures() && { LDKInvoiceRequestFeatures res = self; memset(&self, 0, sizeof(LDKInvoiceRequestFeatures)); return res; }
2108         ~InvoiceRequestFeatures() { InvoiceRequestFeatures_free(self); }
2109         InvoiceRequestFeatures& operator=(InvoiceRequestFeatures&& o) { InvoiceRequestFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestFeatures)); return *this; }
2110         LDKInvoiceRequestFeatures* operator &() { return &self; }
2111         LDKInvoiceRequestFeatures* operator ->() { return &self; }
2112         const LDKInvoiceRequestFeatures* operator &() const { return &self; }
2113         const LDKInvoiceRequestFeatures* operator ->() const { return &self; }
2114 };
2115 class Bolt12InvoiceFeatures {
2116 private:
2117         LDKBolt12InvoiceFeatures self;
2118 public:
2119         Bolt12InvoiceFeatures(const Bolt12InvoiceFeatures&) = delete;
2120         Bolt12InvoiceFeatures(Bolt12InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12InvoiceFeatures)); }
2121         Bolt12InvoiceFeatures(LDKBolt12InvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12InvoiceFeatures)); }
2122         operator LDKBolt12InvoiceFeatures() && { LDKBolt12InvoiceFeatures res = self; memset(&self, 0, sizeof(LDKBolt12InvoiceFeatures)); return res; }
2123         ~Bolt12InvoiceFeatures() { Bolt12InvoiceFeatures_free(self); }
2124         Bolt12InvoiceFeatures& operator=(Bolt12InvoiceFeatures&& o) { Bolt12InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12InvoiceFeatures)); return *this; }
2125         LDKBolt12InvoiceFeatures* operator &() { return &self; }
2126         LDKBolt12InvoiceFeatures* operator ->() { return &self; }
2127         const LDKBolt12InvoiceFeatures* operator &() const { return &self; }
2128         const LDKBolt12InvoiceFeatures* operator ->() const { return &self; }
2129 };
2130 class BlindedHopFeatures {
2131 private:
2132         LDKBlindedHopFeatures self;
2133 public:
2134         BlindedHopFeatures(const BlindedHopFeatures&) = delete;
2135         BlindedHopFeatures(BlindedHopFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedHopFeatures)); }
2136         BlindedHopFeatures(LDKBlindedHopFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedHopFeatures)); }
2137         operator LDKBlindedHopFeatures() && { LDKBlindedHopFeatures res = self; memset(&self, 0, sizeof(LDKBlindedHopFeatures)); return res; }
2138         ~BlindedHopFeatures() { BlindedHopFeatures_free(self); }
2139         BlindedHopFeatures& operator=(BlindedHopFeatures&& o) { BlindedHopFeatures_free(self); self = o.self; memset(&o, 0, sizeof(BlindedHopFeatures)); return *this; }
2140         LDKBlindedHopFeatures* operator &() { return &self; }
2141         LDKBlindedHopFeatures* operator ->() { return &self; }
2142         const LDKBlindedHopFeatures* operator &() const { return &self; }
2143         const LDKBlindedHopFeatures* operator ->() const { return &self; }
2144 };
2145 class ChannelTypeFeatures {
2146 private:
2147         LDKChannelTypeFeatures self;
2148 public:
2149         ChannelTypeFeatures(const ChannelTypeFeatures&) = delete;
2150         ChannelTypeFeatures(ChannelTypeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTypeFeatures)); }
2151         ChannelTypeFeatures(LDKChannelTypeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTypeFeatures)); }
2152         operator LDKChannelTypeFeatures() && { LDKChannelTypeFeatures res = self; memset(&self, 0, sizeof(LDKChannelTypeFeatures)); return res; }
2153         ~ChannelTypeFeatures() { ChannelTypeFeatures_free(self); }
2154         ChannelTypeFeatures& operator=(ChannelTypeFeatures&& o) { ChannelTypeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTypeFeatures)); return *this; }
2155         LDKChannelTypeFeatures* operator &() { return &self; }
2156         LDKChannelTypeFeatures* operator ->() { return &self; }
2157         const LDKChannelTypeFeatures* operator &() const { return &self; }
2158         const LDKChannelTypeFeatures* operator ->() const { return &self; }
2159 };
2160 class Offer {
2161 private:
2162         LDKOffer self;
2163 public:
2164         Offer(const Offer&) = delete;
2165         Offer(Offer&& o) : self(o.self) { memset(&o, 0, sizeof(Offer)); }
2166         Offer(LDKOffer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffer)); }
2167         operator LDKOffer() && { LDKOffer res = self; memset(&self, 0, sizeof(LDKOffer)); return res; }
2168         ~Offer() { Offer_free(self); }
2169         Offer& operator=(Offer&& o) { Offer_free(self); self = o.self; memset(&o, 0, sizeof(Offer)); return *this; }
2170         LDKOffer* operator &() { return &self; }
2171         LDKOffer* operator ->() { return &self; }
2172         const LDKOffer* operator &() const { return &self; }
2173         const LDKOffer* operator ->() const { return &self; }
2174 };
2175 class Amount {
2176 private:
2177         LDKAmount self;
2178 public:
2179         Amount(const Amount&) = delete;
2180         Amount(Amount&& o) : self(o.self) { memset(&o, 0, sizeof(Amount)); }
2181         Amount(LDKAmount&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAmount)); }
2182         operator LDKAmount() && { LDKAmount res = self; memset(&self, 0, sizeof(LDKAmount)); return res; }
2183         ~Amount() { Amount_free(self); }
2184         Amount& operator=(Amount&& o) { Amount_free(self); self = o.self; memset(&o, 0, sizeof(Amount)); return *this; }
2185         LDKAmount* operator &() { return &self; }
2186         LDKAmount* operator ->() { return &self; }
2187         const LDKAmount* operator &() const { return &self; }
2188         const LDKAmount* operator ->() const { return &self; }
2189 };
2190 class Quantity {
2191 private:
2192         LDKQuantity self;
2193 public:
2194         Quantity(const Quantity&) = delete;
2195         Quantity(Quantity&& o) : self(o.self) { memset(&o, 0, sizeof(Quantity)); }
2196         Quantity(LDKQuantity&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQuantity)); }
2197         operator LDKQuantity() && { LDKQuantity res = self; memset(&self, 0, sizeof(LDKQuantity)); return res; }
2198         ~Quantity() { Quantity_free(self); }
2199         Quantity& operator=(Quantity&& o) { Quantity_free(self); self = o.self; memset(&o, 0, sizeof(Quantity)); return *this; }
2200         LDKQuantity* operator &() { return &self; }
2201         LDKQuantity* operator ->() { return &self; }
2202         const LDKQuantity* operator &() const { return &self; }
2203         const LDKQuantity* operator ->() const { return &self; }
2204 };
2205 class NodeId {
2206 private:
2207         LDKNodeId self;
2208 public:
2209         NodeId(const NodeId&) = delete;
2210         NodeId(NodeId&& o) : self(o.self) { memset(&o, 0, sizeof(NodeId)); }
2211         NodeId(LDKNodeId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeId)); }
2212         operator LDKNodeId() && { LDKNodeId res = self; memset(&self, 0, sizeof(LDKNodeId)); return res; }
2213         ~NodeId() { NodeId_free(self); }
2214         NodeId& operator=(NodeId&& o) { NodeId_free(self); self = o.self; memset(&o, 0, sizeof(NodeId)); return *this; }
2215         LDKNodeId* operator &() { return &self; }
2216         LDKNodeId* operator ->() { return &self; }
2217         const LDKNodeId* operator &() const { return &self; }
2218         const LDKNodeId* operator ->() const { return &self; }
2219 };
2220 class NetworkGraph {
2221 private:
2222         LDKNetworkGraph self;
2223 public:
2224         NetworkGraph(const NetworkGraph&) = delete;
2225         NetworkGraph(NetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkGraph)); }
2226         NetworkGraph(LDKNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkGraph)); }
2227         operator LDKNetworkGraph() && { LDKNetworkGraph res = self; memset(&self, 0, sizeof(LDKNetworkGraph)); return res; }
2228         ~NetworkGraph() { NetworkGraph_free(self); }
2229         NetworkGraph& operator=(NetworkGraph&& o) { NetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(NetworkGraph)); return *this; }
2230         LDKNetworkGraph* operator &() { return &self; }
2231         LDKNetworkGraph* operator ->() { return &self; }
2232         const LDKNetworkGraph* operator &() const { return &self; }
2233         const LDKNetworkGraph* operator ->() const { return &self; }
2234 };
2235 class ReadOnlyNetworkGraph {
2236 private:
2237         LDKReadOnlyNetworkGraph self;
2238 public:
2239         ReadOnlyNetworkGraph(const ReadOnlyNetworkGraph&) = delete;
2240         ReadOnlyNetworkGraph(ReadOnlyNetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); }
2241         ReadOnlyNetworkGraph(LDKReadOnlyNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReadOnlyNetworkGraph)); }
2242         operator LDKReadOnlyNetworkGraph() && { LDKReadOnlyNetworkGraph res = self; memset(&self, 0, sizeof(LDKReadOnlyNetworkGraph)); return res; }
2243         ~ReadOnlyNetworkGraph() { ReadOnlyNetworkGraph_free(self); }
2244         ReadOnlyNetworkGraph& operator=(ReadOnlyNetworkGraph&& o) { ReadOnlyNetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); return *this; }
2245         LDKReadOnlyNetworkGraph* operator &() { return &self; }
2246         LDKReadOnlyNetworkGraph* operator ->() { return &self; }
2247         const LDKReadOnlyNetworkGraph* operator &() const { return &self; }
2248         const LDKReadOnlyNetworkGraph* operator ->() const { return &self; }
2249 };
2250 class NetworkUpdate {
2251 private:
2252         LDKNetworkUpdate self;
2253 public:
2254         NetworkUpdate(const NetworkUpdate&) = delete;
2255         NetworkUpdate(NetworkUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkUpdate)); }
2256         NetworkUpdate(LDKNetworkUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkUpdate)); }
2257         operator LDKNetworkUpdate() && { LDKNetworkUpdate res = self; memset(&self, 0, sizeof(LDKNetworkUpdate)); return res; }
2258         ~NetworkUpdate() { NetworkUpdate_free(self); }
2259         NetworkUpdate& operator=(NetworkUpdate&& o) { NetworkUpdate_free(self); self = o.self; memset(&o, 0, sizeof(NetworkUpdate)); return *this; }
2260         LDKNetworkUpdate* operator &() { return &self; }
2261         LDKNetworkUpdate* operator ->() { return &self; }
2262         const LDKNetworkUpdate* operator &() const { return &self; }
2263         const LDKNetworkUpdate* operator ->() const { return &self; }
2264 };
2265 class P2PGossipSync {
2266 private:
2267         LDKP2PGossipSync self;
2268 public:
2269         P2PGossipSync(const P2PGossipSync&) = delete;
2270         P2PGossipSync(P2PGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(P2PGossipSync)); }
2271         P2PGossipSync(LDKP2PGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKP2PGossipSync)); }
2272         operator LDKP2PGossipSync() && { LDKP2PGossipSync res = self; memset(&self, 0, sizeof(LDKP2PGossipSync)); return res; }
2273         ~P2PGossipSync() { P2PGossipSync_free(self); }
2274         P2PGossipSync& operator=(P2PGossipSync&& o) { P2PGossipSync_free(self); self = o.self; memset(&o, 0, sizeof(P2PGossipSync)); return *this; }
2275         LDKP2PGossipSync* operator &() { return &self; }
2276         LDKP2PGossipSync* operator ->() { return &self; }
2277         const LDKP2PGossipSync* operator &() const { return &self; }
2278         const LDKP2PGossipSync* operator ->() const { return &self; }
2279 };
2280 class ChannelUpdateInfo {
2281 private:
2282         LDKChannelUpdateInfo self;
2283 public:
2284         ChannelUpdateInfo(const ChannelUpdateInfo&) = delete;
2285         ChannelUpdateInfo(ChannelUpdateInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdateInfo)); }
2286         ChannelUpdateInfo(LDKChannelUpdateInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdateInfo)); }
2287         operator LDKChannelUpdateInfo() && { LDKChannelUpdateInfo res = self; memset(&self, 0, sizeof(LDKChannelUpdateInfo)); return res; }
2288         ~ChannelUpdateInfo() { ChannelUpdateInfo_free(self); }
2289         ChannelUpdateInfo& operator=(ChannelUpdateInfo&& o) { ChannelUpdateInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdateInfo)); return *this; }
2290         LDKChannelUpdateInfo* operator &() { return &self; }
2291         LDKChannelUpdateInfo* operator ->() { return &self; }
2292         const LDKChannelUpdateInfo* operator &() const { return &self; }
2293         const LDKChannelUpdateInfo* operator ->() const { return &self; }
2294 };
2295 class ChannelInfo {
2296 private:
2297         LDKChannelInfo self;
2298 public:
2299         ChannelInfo(const ChannelInfo&) = delete;
2300         ChannelInfo(ChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelInfo)); }
2301         ChannelInfo(LDKChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelInfo)); }
2302         operator LDKChannelInfo() && { LDKChannelInfo res = self; memset(&self, 0, sizeof(LDKChannelInfo)); return res; }
2303         ~ChannelInfo() { ChannelInfo_free(self); }
2304         ChannelInfo& operator=(ChannelInfo&& o) { ChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelInfo)); return *this; }
2305         LDKChannelInfo* operator &() { return &self; }
2306         LDKChannelInfo* operator ->() { return &self; }
2307         const LDKChannelInfo* operator &() const { return &self; }
2308         const LDKChannelInfo* operator ->() const { return &self; }
2309 };
2310 class DirectedChannelInfo {
2311 private:
2312         LDKDirectedChannelInfo self;
2313 public:
2314         DirectedChannelInfo(const DirectedChannelInfo&) = delete;
2315         DirectedChannelInfo(DirectedChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(DirectedChannelInfo)); }
2316         DirectedChannelInfo(LDKDirectedChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectedChannelInfo)); }
2317         operator LDKDirectedChannelInfo() && { LDKDirectedChannelInfo res = self; memset(&self, 0, sizeof(LDKDirectedChannelInfo)); return res; }
2318         ~DirectedChannelInfo() { DirectedChannelInfo_free(self); }
2319         DirectedChannelInfo& operator=(DirectedChannelInfo&& o) { DirectedChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(DirectedChannelInfo)); return *this; }
2320         LDKDirectedChannelInfo* operator &() { return &self; }
2321         LDKDirectedChannelInfo* operator ->() { return &self; }
2322         const LDKDirectedChannelInfo* operator &() const { return &self; }
2323         const LDKDirectedChannelInfo* operator ->() const { return &self; }
2324 };
2325 class EffectiveCapacity {
2326 private:
2327         LDKEffectiveCapacity self;
2328 public:
2329         EffectiveCapacity(const EffectiveCapacity&) = delete;
2330         EffectiveCapacity(EffectiveCapacity&& o) : self(o.self) { memset(&o, 0, sizeof(EffectiveCapacity)); }
2331         EffectiveCapacity(LDKEffectiveCapacity&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEffectiveCapacity)); }
2332         operator LDKEffectiveCapacity() && { LDKEffectiveCapacity res = self; memset(&self, 0, sizeof(LDKEffectiveCapacity)); return res; }
2333         ~EffectiveCapacity() { EffectiveCapacity_free(self); }
2334         EffectiveCapacity& operator=(EffectiveCapacity&& o) { EffectiveCapacity_free(self); self = o.self; memset(&o, 0, sizeof(EffectiveCapacity)); return *this; }
2335         LDKEffectiveCapacity* operator &() { return &self; }
2336         LDKEffectiveCapacity* operator ->() { return &self; }
2337         const LDKEffectiveCapacity* operator &() const { return &self; }
2338         const LDKEffectiveCapacity* operator ->() const { return &self; }
2339 };
2340 class RoutingFees {
2341 private:
2342         LDKRoutingFees self;
2343 public:
2344         RoutingFees(const RoutingFees&) = delete;
2345         RoutingFees(RoutingFees&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingFees)); }
2346         RoutingFees(LDKRoutingFees&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingFees)); }
2347         operator LDKRoutingFees() && { LDKRoutingFees res = self; memset(&self, 0, sizeof(LDKRoutingFees)); return res; }
2348         ~RoutingFees() { RoutingFees_free(self); }
2349         RoutingFees& operator=(RoutingFees&& o) { RoutingFees_free(self); self = o.self; memset(&o, 0, sizeof(RoutingFees)); return *this; }
2350         LDKRoutingFees* operator &() { return &self; }
2351         LDKRoutingFees* operator ->() { return &self; }
2352         const LDKRoutingFees* operator &() const { return &self; }
2353         const LDKRoutingFees* operator ->() const { return &self; }
2354 };
2355 class NodeAnnouncementInfo {
2356 private:
2357         LDKNodeAnnouncementInfo self;
2358 public:
2359         NodeAnnouncementInfo(const NodeAnnouncementInfo&) = delete;
2360         NodeAnnouncementInfo(NodeAnnouncementInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncementInfo)); }
2361         NodeAnnouncementInfo(LDKNodeAnnouncementInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncementInfo)); }
2362         operator LDKNodeAnnouncementInfo() && { LDKNodeAnnouncementInfo res = self; memset(&self, 0, sizeof(LDKNodeAnnouncementInfo)); return res; }
2363         ~NodeAnnouncementInfo() { NodeAnnouncementInfo_free(self); }
2364         NodeAnnouncementInfo& operator=(NodeAnnouncementInfo&& o) { NodeAnnouncementInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncementInfo)); return *this; }
2365         LDKNodeAnnouncementInfo* operator &() { return &self; }
2366         LDKNodeAnnouncementInfo* operator ->() { return &self; }
2367         const LDKNodeAnnouncementInfo* operator &() const { return &self; }
2368         const LDKNodeAnnouncementInfo* operator ->() const { return &self; }
2369 };
2370 class NodeAlias {
2371 private:
2372         LDKNodeAlias self;
2373 public:
2374         NodeAlias(const NodeAlias&) = delete;
2375         NodeAlias(NodeAlias&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAlias)); }
2376         NodeAlias(LDKNodeAlias&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAlias)); }
2377         operator LDKNodeAlias() && { LDKNodeAlias res = self; memset(&self, 0, sizeof(LDKNodeAlias)); return res; }
2378         ~NodeAlias() { NodeAlias_free(self); }
2379         NodeAlias& operator=(NodeAlias&& o) { NodeAlias_free(self); self = o.self; memset(&o, 0, sizeof(NodeAlias)); return *this; }
2380         LDKNodeAlias* operator &() { return &self; }
2381         LDKNodeAlias* operator ->() { return &self; }
2382         const LDKNodeAlias* operator &() const { return &self; }
2383         const LDKNodeAlias* operator ->() const { return &self; }
2384 };
2385 class NodeInfo {
2386 private:
2387         LDKNodeInfo self;
2388 public:
2389         NodeInfo(const NodeInfo&) = delete;
2390         NodeInfo(NodeInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeInfo)); }
2391         NodeInfo(LDKNodeInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeInfo)); }
2392         operator LDKNodeInfo() && { LDKNodeInfo res = self; memset(&self, 0, sizeof(LDKNodeInfo)); return res; }
2393         ~NodeInfo() { NodeInfo_free(self); }
2394         NodeInfo& operator=(NodeInfo&& o) { NodeInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeInfo)); return *this; }
2395         LDKNodeInfo* operator &() { return &self; }
2396         LDKNodeInfo* operator ->() { return &self; }
2397         const LDKNodeInfo* operator &() const { return &self; }
2398         const LDKNodeInfo* operator ->() const { return &self; }
2399 };
2400 class AnchorDescriptor {
2401 private:
2402         LDKAnchorDescriptor self;
2403 public:
2404         AnchorDescriptor(const AnchorDescriptor&) = delete;
2405         AnchorDescriptor(AnchorDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(AnchorDescriptor)); }
2406         AnchorDescriptor(LDKAnchorDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnchorDescriptor)); }
2407         operator LDKAnchorDescriptor() && { LDKAnchorDescriptor res = self; memset(&self, 0, sizeof(LDKAnchorDescriptor)); return res; }
2408         ~AnchorDescriptor() { AnchorDescriptor_free(self); }
2409         AnchorDescriptor& operator=(AnchorDescriptor&& o) { AnchorDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(AnchorDescriptor)); return *this; }
2410         LDKAnchorDescriptor* operator &() { return &self; }
2411         LDKAnchorDescriptor* operator ->() { return &self; }
2412         const LDKAnchorDescriptor* operator &() const { return &self; }
2413         const LDKAnchorDescriptor* operator ->() const { return &self; }
2414 };
2415 class BumpTransactionEvent {
2416 private:
2417         LDKBumpTransactionEvent self;
2418 public:
2419         BumpTransactionEvent(const BumpTransactionEvent&) = delete;
2420         BumpTransactionEvent(BumpTransactionEvent&& o) : self(o.self) { memset(&o, 0, sizeof(BumpTransactionEvent)); }
2421         BumpTransactionEvent(LDKBumpTransactionEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBumpTransactionEvent)); }
2422         operator LDKBumpTransactionEvent() && { LDKBumpTransactionEvent res = self; memset(&self, 0, sizeof(LDKBumpTransactionEvent)); return res; }
2423         ~BumpTransactionEvent() { BumpTransactionEvent_free(self); }
2424         BumpTransactionEvent& operator=(BumpTransactionEvent&& o) { BumpTransactionEvent_free(self); self = o.self; memset(&o, 0, sizeof(BumpTransactionEvent)); return *this; }
2425         LDKBumpTransactionEvent* operator &() { return &self; }
2426         LDKBumpTransactionEvent* operator ->() { return &self; }
2427         const LDKBumpTransactionEvent* operator &() const { return &self; }
2428         const LDKBumpTransactionEvent* operator ->() const { return &self; }
2429 };
2430 class Input {
2431 private:
2432         LDKInput self;
2433 public:
2434         Input(const Input&) = delete;
2435         Input(Input&& o) : self(o.self) { memset(&o, 0, sizeof(Input)); }
2436         Input(LDKInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInput)); }
2437         operator LDKInput() && { LDKInput res = self; memset(&self, 0, sizeof(LDKInput)); return res; }
2438         ~Input() { Input_free(self); }
2439         Input& operator=(Input&& o) { Input_free(self); self = o.self; memset(&o, 0, sizeof(Input)); return *this; }
2440         LDKInput* operator &() { return &self; }
2441         LDKInput* operator ->() { return &self; }
2442         const LDKInput* operator &() const { return &self; }
2443         const LDKInput* operator ->() const { return &self; }
2444 };
2445 class Utxo {
2446 private:
2447         LDKUtxo self;
2448 public:
2449         Utxo(const Utxo&) = delete;
2450         Utxo(Utxo&& o) : self(o.self) { memset(&o, 0, sizeof(Utxo)); }
2451         Utxo(LDKUtxo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxo)); }
2452         operator LDKUtxo() && { LDKUtxo res = self; memset(&self, 0, sizeof(LDKUtxo)); return res; }
2453         ~Utxo() { Utxo_free(self); }
2454         Utxo& operator=(Utxo&& o) { Utxo_free(self); self = o.self; memset(&o, 0, sizeof(Utxo)); return *this; }
2455         LDKUtxo* operator &() { return &self; }
2456         LDKUtxo* operator ->() { return &self; }
2457         const LDKUtxo* operator &() const { return &self; }
2458         const LDKUtxo* operator ->() const { return &self; }
2459 };
2460 class CoinSelection {
2461 private:
2462         LDKCoinSelection self;
2463 public:
2464         CoinSelection(const CoinSelection&) = delete;
2465         CoinSelection(CoinSelection&& o) : self(o.self) { memset(&o, 0, sizeof(CoinSelection)); }
2466         CoinSelection(LDKCoinSelection&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCoinSelection)); }
2467         operator LDKCoinSelection() && { LDKCoinSelection res = self; memset(&self, 0, sizeof(LDKCoinSelection)); return res; }
2468         ~CoinSelection() { CoinSelection_free(self); }
2469         CoinSelection& operator=(CoinSelection&& o) { CoinSelection_free(self); self = o.self; memset(&o, 0, sizeof(CoinSelection)); return *this; }
2470         LDKCoinSelection* operator &() { return &self; }
2471         LDKCoinSelection* operator ->() { return &self; }
2472         const LDKCoinSelection* operator &() const { return &self; }
2473         const LDKCoinSelection* operator ->() const { return &self; }
2474 };
2475 class CoinSelectionSource {
2476 private:
2477         LDKCoinSelectionSource self;
2478 public:
2479         CoinSelectionSource(const CoinSelectionSource&) = delete;
2480         CoinSelectionSource(CoinSelectionSource&& o) : self(o.self) { memset(&o, 0, sizeof(CoinSelectionSource)); }
2481         CoinSelectionSource(LDKCoinSelectionSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCoinSelectionSource)); }
2482         operator LDKCoinSelectionSource() && { LDKCoinSelectionSource res = self; memset(&self, 0, sizeof(LDKCoinSelectionSource)); return res; }
2483         ~CoinSelectionSource() { CoinSelectionSource_free(self); }
2484         CoinSelectionSource& operator=(CoinSelectionSource&& o) { CoinSelectionSource_free(self); self = o.self; memset(&o, 0, sizeof(CoinSelectionSource)); return *this; }
2485         LDKCoinSelectionSource* operator &() { return &self; }
2486         LDKCoinSelectionSource* operator ->() { return &self; }
2487         const LDKCoinSelectionSource* operator &() const { return &self; }
2488         const LDKCoinSelectionSource* operator ->() const { return &self; }
2489         /**
2490          *  Performs coin selection of a set of UTXOs, with at least 1 confirmation each, that are
2491          *  available to spend. Implementations are free to pick their coin selection algorithm of
2492          *  choice, as long as the following requirements are met:
2493          *
2494          *  1. `must_spend` contains a set of [`Input`]s that must be included in the transaction
2495          *     throughout coin selection, but must not be returned as part of the result.
2496          *  2. `must_pay_to` contains a set of [`TxOut`]s that must be included in the transaction
2497          *     throughout coin selection. In some cases, like when funding an anchor transaction, this
2498          *     set is empty. Implementations should ensure they handle this correctly on their end,
2499          *     e.g., Bitcoin Core's `fundrawtransaction` RPC requires at least one output to be
2500          *     provided, in which case a zero-value empty OP_RETURN output can be used instead.
2501          *  3. Enough inputs must be selected/contributed for the resulting transaction (including the
2502          *     inputs and outputs noted above) to meet `target_feerate_sat_per_1000_weight`.
2503          *
2504          *  Implementations must take note that [`Input::satisfaction_weight`] only tracks the weight of
2505          *  the input's `script_sig` and `witness`. Some wallets, like Bitcoin Core's, may require
2506          *  providing the full input weight. Failing to do so may lead to underestimating fee bumps and
2507          *  delaying block inclusion.
2508          *
2509          *  The `claim_id` must map to the set of external UTXOs assigned to the claim, such that they
2510          *  can be re-used within new fee-bumped iterations of the original claiming transaction,
2511          *  ensuring that claims don't double spend each other. If a specific `claim_id` has never had a
2512          *  transaction associated with it, and all of the available UTXOs have already been assigned to
2513          *  other claims, implementations must be willing to double spend their UTXOs. The choice of
2514          *  which UTXOs to double spend is left to the implementation, but it must strive to keep the
2515          *  set of other claims being double spent to a minimum.
2516          */
2517         inline LDK::CResult_CoinSelectionNoneZ select_confirmed_utxos(struct LDKThirtyTwoBytes claim_id, struct LDKCVec_InputZ must_spend, struct LDKCVec_TxOutZ must_pay_to, uint32_t target_feerate_sat_per_1000_weight);
2518         /**
2519          *  Signs and provides the full witness for all inputs within the transaction known to the
2520          *  trait (i.e., any provided via [`CoinSelectionSource::select_confirmed_utxos`]).
2521          */
2522         inline LDK::CResult_TransactionNoneZ sign_tx(struct LDKTransaction tx);
2523 };
2524 class WalletSource {
2525 private:
2526         LDKWalletSource self;
2527 public:
2528         WalletSource(const WalletSource&) = delete;
2529         WalletSource(WalletSource&& o) : self(o.self) { memset(&o, 0, sizeof(WalletSource)); }
2530         WalletSource(LDKWalletSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWalletSource)); }
2531         operator LDKWalletSource() && { LDKWalletSource res = self; memset(&self, 0, sizeof(LDKWalletSource)); return res; }
2532         ~WalletSource() { WalletSource_free(self); }
2533         WalletSource& operator=(WalletSource&& o) { WalletSource_free(self); self = o.self; memset(&o, 0, sizeof(WalletSource)); return *this; }
2534         LDKWalletSource* operator &() { return &self; }
2535         LDKWalletSource* operator ->() { return &self; }
2536         const LDKWalletSource* operator &() const { return &self; }
2537         const LDKWalletSource* operator ->() const { return &self; }
2538         /**
2539          *  Returns all UTXOs, with at least 1 confirmation each, that are available to spend.
2540          */
2541         inline LDK::CResult_CVec_UtxoZNoneZ list_confirmed_utxos();
2542         /**
2543          *  Returns a script to use for change above dust resulting from a successful coin selection
2544          *  attempt.
2545          */
2546         inline LDK::CResult_CVec_u8ZNoneZ get_change_script();
2547         /**
2548          *  Signs and provides the full [`TxIn::script_sig`] and [`TxIn::witness`] for all inputs within
2549          *  the transaction known to the wallet (i.e., any provided via
2550          *  [`WalletSource::list_confirmed_utxos`]).
2551          */
2552         inline LDK::CResult_TransactionNoneZ sign_tx(struct LDKTransaction tx);
2553 };
2554 class Wallet {
2555 private:
2556         LDKWallet self;
2557 public:
2558         Wallet(const Wallet&) = delete;
2559         Wallet(Wallet&& o) : self(o.self) { memset(&o, 0, sizeof(Wallet)); }
2560         Wallet(LDKWallet&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWallet)); }
2561         operator LDKWallet() && { LDKWallet res = self; memset(&self, 0, sizeof(LDKWallet)); return res; }
2562         ~Wallet() { Wallet_free(self); }
2563         Wallet& operator=(Wallet&& o) { Wallet_free(self); self = o.self; memset(&o, 0, sizeof(Wallet)); return *this; }
2564         LDKWallet* operator &() { return &self; }
2565         LDKWallet* operator ->() { return &self; }
2566         const LDKWallet* operator &() const { return &self; }
2567         const LDKWallet* operator ->() const { return &self; }
2568 };
2569 class BumpTransactionEventHandler {
2570 private:
2571         LDKBumpTransactionEventHandler self;
2572 public:
2573         BumpTransactionEventHandler(const BumpTransactionEventHandler&) = delete;
2574         BumpTransactionEventHandler(BumpTransactionEventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(BumpTransactionEventHandler)); }
2575         BumpTransactionEventHandler(LDKBumpTransactionEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBumpTransactionEventHandler)); }
2576         operator LDKBumpTransactionEventHandler() && { LDKBumpTransactionEventHandler res = self; memset(&self, 0, sizeof(LDKBumpTransactionEventHandler)); return res; }
2577         ~BumpTransactionEventHandler() { BumpTransactionEventHandler_free(self); }
2578         BumpTransactionEventHandler& operator=(BumpTransactionEventHandler&& o) { BumpTransactionEventHandler_free(self); self = o.self; memset(&o, 0, sizeof(BumpTransactionEventHandler)); return *this; }
2579         LDKBumpTransactionEventHandler* operator &() { return &self; }
2580         LDKBumpTransactionEventHandler* operator ->() { return &self; }
2581         const LDKBumpTransactionEventHandler* operator &() const { return &self; }
2582         const LDKBumpTransactionEventHandler* operator ->() const { return &self; }
2583 };
2584 class FailureCode {
2585 private:
2586         LDKFailureCode self;
2587 public:
2588         FailureCode(const FailureCode&) = delete;
2589         FailureCode(FailureCode&& o) : self(o.self) { memset(&o, 0, sizeof(FailureCode)); }
2590         FailureCode(LDKFailureCode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFailureCode)); }
2591         operator LDKFailureCode() && { LDKFailureCode res = self; memset(&self, 0, sizeof(LDKFailureCode)); return res; }
2592         ~FailureCode() { FailureCode_free(self); }
2593         FailureCode& operator=(FailureCode&& o) { FailureCode_free(self); self = o.self; memset(&o, 0, sizeof(FailureCode)); return *this; }
2594         LDKFailureCode* operator &() { return &self; }
2595         LDKFailureCode* operator ->() { return &self; }
2596         const LDKFailureCode* operator &() const { return &self; }
2597         const LDKFailureCode* operator ->() const { return &self; }
2598 };
2599 class ChannelManager {
2600 private:
2601         LDKChannelManager self;
2602 public:
2603         ChannelManager(const ChannelManager&) = delete;
2604         ChannelManager(ChannelManager&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManager)); }
2605         ChannelManager(LDKChannelManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManager)); }
2606         operator LDKChannelManager() && { LDKChannelManager res = self; memset(&self, 0, sizeof(LDKChannelManager)); return res; }
2607         ~ChannelManager() { ChannelManager_free(self); }
2608         ChannelManager& operator=(ChannelManager&& o) { ChannelManager_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManager)); return *this; }
2609         LDKChannelManager* operator &() { return &self; }
2610         LDKChannelManager* operator ->() { return &self; }
2611         const LDKChannelManager* operator &() const { return &self; }
2612         const LDKChannelManager* operator ->() const { return &self; }
2613 };
2614 class ChainParameters {
2615 private:
2616         LDKChainParameters self;
2617 public:
2618         ChainParameters(const ChainParameters&) = delete;
2619         ChainParameters(ChainParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChainParameters)); }
2620         ChainParameters(LDKChainParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainParameters)); }
2621         operator LDKChainParameters() && { LDKChainParameters res = self; memset(&self, 0, sizeof(LDKChainParameters)); return res; }
2622         ~ChainParameters() { ChainParameters_free(self); }
2623         ChainParameters& operator=(ChainParameters&& o) { ChainParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChainParameters)); return *this; }
2624         LDKChainParameters* operator &() { return &self; }
2625         LDKChainParameters* operator ->() { return &self; }
2626         const LDKChainParameters* operator &() const { return &self; }
2627         const LDKChainParameters* operator ->() const { return &self; }
2628 };
2629 class CounterpartyForwardingInfo {
2630 private:
2631         LDKCounterpartyForwardingInfo self;
2632 public:
2633         CounterpartyForwardingInfo(const CounterpartyForwardingInfo&) = delete;
2634         CounterpartyForwardingInfo(CounterpartyForwardingInfo&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyForwardingInfo)); }
2635         CounterpartyForwardingInfo(LDKCounterpartyForwardingInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyForwardingInfo)); }
2636         operator LDKCounterpartyForwardingInfo() && { LDKCounterpartyForwardingInfo res = self; memset(&self, 0, sizeof(LDKCounterpartyForwardingInfo)); return res; }
2637         ~CounterpartyForwardingInfo() { CounterpartyForwardingInfo_free(self); }
2638         CounterpartyForwardingInfo& operator=(CounterpartyForwardingInfo&& o) { CounterpartyForwardingInfo_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyForwardingInfo)); return *this; }
2639         LDKCounterpartyForwardingInfo* operator &() { return &self; }
2640         LDKCounterpartyForwardingInfo* operator ->() { return &self; }
2641         const LDKCounterpartyForwardingInfo* operator &() const { return &self; }
2642         const LDKCounterpartyForwardingInfo* operator ->() const { return &self; }
2643 };
2644 class ChannelCounterparty {
2645 private:
2646         LDKChannelCounterparty self;
2647 public:
2648         ChannelCounterparty(const ChannelCounterparty&) = delete;
2649         ChannelCounterparty(ChannelCounterparty&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelCounterparty)); }
2650         ChannelCounterparty(LDKChannelCounterparty&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelCounterparty)); }
2651         operator LDKChannelCounterparty() && { LDKChannelCounterparty res = self; memset(&self, 0, sizeof(LDKChannelCounterparty)); return res; }
2652         ~ChannelCounterparty() { ChannelCounterparty_free(self); }
2653         ChannelCounterparty& operator=(ChannelCounterparty&& o) { ChannelCounterparty_free(self); self = o.self; memset(&o, 0, sizeof(ChannelCounterparty)); return *this; }
2654         LDKChannelCounterparty* operator &() { return &self; }
2655         LDKChannelCounterparty* operator ->() { return &self; }
2656         const LDKChannelCounterparty* operator &() const { return &self; }
2657         const LDKChannelCounterparty* operator ->() const { return &self; }
2658 };
2659 class ChannelDetails {
2660 private:
2661         LDKChannelDetails self;
2662 public:
2663         ChannelDetails(const ChannelDetails&) = delete;
2664         ChannelDetails(ChannelDetails&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDetails)); }
2665         ChannelDetails(LDKChannelDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDetails)); }
2666         operator LDKChannelDetails() && { LDKChannelDetails res = self; memset(&self, 0, sizeof(LDKChannelDetails)); return res; }
2667         ~ChannelDetails() { ChannelDetails_free(self); }
2668         ChannelDetails& operator=(ChannelDetails&& o) { ChannelDetails_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDetails)); return *this; }
2669         LDKChannelDetails* operator &() { return &self; }
2670         LDKChannelDetails* operator ->() { return &self; }
2671         const LDKChannelDetails* operator &() const { return &self; }
2672         const LDKChannelDetails* operator ->() const { return &self; }
2673 };
2674 class ChannelShutdownState {
2675 private:
2676         LDKChannelShutdownState self;
2677 public:
2678         ChannelShutdownState(const ChannelShutdownState&) = delete;
2679         ChannelShutdownState(ChannelShutdownState&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelShutdownState)); }
2680         ChannelShutdownState(LDKChannelShutdownState&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelShutdownState)); }
2681         operator LDKChannelShutdownState() && { LDKChannelShutdownState res = self; memset(&self, 0, sizeof(LDKChannelShutdownState)); return res; }
2682         ChannelShutdownState& operator=(ChannelShutdownState&& o) { self = o.self; memset(&o, 0, sizeof(ChannelShutdownState)); return *this; }
2683         LDKChannelShutdownState* operator &() { return &self; }
2684         LDKChannelShutdownState* operator ->() { return &self; }
2685         const LDKChannelShutdownState* operator &() const { return &self; }
2686         const LDKChannelShutdownState* operator ->() const { return &self; }
2687 };
2688 class RecentPaymentDetails {
2689 private:
2690         LDKRecentPaymentDetails self;
2691 public:
2692         RecentPaymentDetails(const RecentPaymentDetails&) = delete;
2693         RecentPaymentDetails(RecentPaymentDetails&& o) : self(o.self) { memset(&o, 0, sizeof(RecentPaymentDetails)); }
2694         RecentPaymentDetails(LDKRecentPaymentDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecentPaymentDetails)); }
2695         operator LDKRecentPaymentDetails() && { LDKRecentPaymentDetails res = self; memset(&self, 0, sizeof(LDKRecentPaymentDetails)); return res; }
2696         ~RecentPaymentDetails() { RecentPaymentDetails_free(self); }
2697         RecentPaymentDetails& operator=(RecentPaymentDetails&& o) { RecentPaymentDetails_free(self); self = o.self; memset(&o, 0, sizeof(RecentPaymentDetails)); return *this; }
2698         LDKRecentPaymentDetails* operator &() { return &self; }
2699         LDKRecentPaymentDetails* operator ->() { return &self; }
2700         const LDKRecentPaymentDetails* operator &() const { return &self; }
2701         const LDKRecentPaymentDetails* operator ->() const { return &self; }
2702 };
2703 class PhantomRouteHints {
2704 private:
2705         LDKPhantomRouteHints self;
2706 public:
2707         PhantomRouteHints(const PhantomRouteHints&) = delete;
2708         PhantomRouteHints(PhantomRouteHints&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomRouteHints)); }
2709         PhantomRouteHints(LDKPhantomRouteHints&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomRouteHints)); }
2710         operator LDKPhantomRouteHints() && { LDKPhantomRouteHints res = self; memset(&self, 0, sizeof(LDKPhantomRouteHints)); return res; }
2711         ~PhantomRouteHints() { PhantomRouteHints_free(self); }
2712         PhantomRouteHints& operator=(PhantomRouteHints&& o) { PhantomRouteHints_free(self); self = o.self; memset(&o, 0, sizeof(PhantomRouteHints)); return *this; }
2713         LDKPhantomRouteHints* operator &() { return &self; }
2714         LDKPhantomRouteHints* operator ->() { return &self; }
2715         const LDKPhantomRouteHints* operator &() const { return &self; }
2716         const LDKPhantomRouteHints* operator ->() const { return &self; }
2717 };
2718 class ChannelManagerReadArgs {
2719 private:
2720         LDKChannelManagerReadArgs self;
2721 public:
2722         ChannelManagerReadArgs(const ChannelManagerReadArgs&) = delete;
2723         ChannelManagerReadArgs(ChannelManagerReadArgs&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerReadArgs)); }
2724         ChannelManagerReadArgs(LDKChannelManagerReadArgs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerReadArgs)); }
2725         operator LDKChannelManagerReadArgs() && { LDKChannelManagerReadArgs res = self; memset(&self, 0, sizeof(LDKChannelManagerReadArgs)); return res; }
2726         ~ChannelManagerReadArgs() { ChannelManagerReadArgs_free(self); }
2727         ChannelManagerReadArgs& operator=(ChannelManagerReadArgs&& o) { ChannelManagerReadArgs_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManagerReadArgs)); return *this; }
2728         LDKChannelManagerReadArgs* operator &() { return &self; }
2729         LDKChannelManagerReadArgs* operator ->() { return &self; }
2730         const LDKChannelManagerReadArgs* operator &() const { return &self; }
2731         const LDKChannelManagerReadArgs* operator ->() const { return &self; }
2732 };
2733 class ChannelHandshakeConfig {
2734 private:
2735         LDKChannelHandshakeConfig self;
2736 public:
2737         ChannelHandshakeConfig(const ChannelHandshakeConfig&) = delete;
2738         ChannelHandshakeConfig(ChannelHandshakeConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeConfig)); }
2739         ChannelHandshakeConfig(LDKChannelHandshakeConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeConfig)); }
2740         operator LDKChannelHandshakeConfig() && { LDKChannelHandshakeConfig res = self; memset(&self, 0, sizeof(LDKChannelHandshakeConfig)); return res; }
2741         ~ChannelHandshakeConfig() { ChannelHandshakeConfig_free(self); }
2742         ChannelHandshakeConfig& operator=(ChannelHandshakeConfig&& o) { ChannelHandshakeConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeConfig)); return *this; }
2743         LDKChannelHandshakeConfig* operator &() { return &self; }
2744         LDKChannelHandshakeConfig* operator ->() { return &self; }
2745         const LDKChannelHandshakeConfig* operator &() const { return &self; }
2746         const LDKChannelHandshakeConfig* operator ->() const { return &self; }
2747 };
2748 class ChannelHandshakeLimits {
2749 private:
2750         LDKChannelHandshakeLimits self;
2751 public:
2752         ChannelHandshakeLimits(const ChannelHandshakeLimits&) = delete;
2753         ChannelHandshakeLimits(ChannelHandshakeLimits&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeLimits)); }
2754         ChannelHandshakeLimits(LDKChannelHandshakeLimits&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeLimits)); }
2755         operator LDKChannelHandshakeLimits() && { LDKChannelHandshakeLimits res = self; memset(&self, 0, sizeof(LDKChannelHandshakeLimits)); return res; }
2756         ~ChannelHandshakeLimits() { ChannelHandshakeLimits_free(self); }
2757         ChannelHandshakeLimits& operator=(ChannelHandshakeLimits&& o) { ChannelHandshakeLimits_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeLimits)); return *this; }
2758         LDKChannelHandshakeLimits* operator &() { return &self; }
2759         LDKChannelHandshakeLimits* operator ->() { return &self; }
2760         const LDKChannelHandshakeLimits* operator &() const { return &self; }
2761         const LDKChannelHandshakeLimits* operator ->() const { return &self; }
2762 };
2763 class MaxDustHTLCExposure {
2764 private:
2765         LDKMaxDustHTLCExposure self;
2766 public:
2767         MaxDustHTLCExposure(const MaxDustHTLCExposure&) = delete;
2768         MaxDustHTLCExposure(MaxDustHTLCExposure&& o) : self(o.self) { memset(&o, 0, sizeof(MaxDustHTLCExposure)); }
2769         MaxDustHTLCExposure(LDKMaxDustHTLCExposure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMaxDustHTLCExposure)); }
2770         operator LDKMaxDustHTLCExposure() && { LDKMaxDustHTLCExposure res = self; memset(&self, 0, sizeof(LDKMaxDustHTLCExposure)); return res; }
2771         ~MaxDustHTLCExposure() { MaxDustHTLCExposure_free(self); }
2772         MaxDustHTLCExposure& operator=(MaxDustHTLCExposure&& o) { MaxDustHTLCExposure_free(self); self = o.self; memset(&o, 0, sizeof(MaxDustHTLCExposure)); return *this; }
2773         LDKMaxDustHTLCExposure* operator &() { return &self; }
2774         LDKMaxDustHTLCExposure* operator ->() { return &self; }
2775         const LDKMaxDustHTLCExposure* operator &() const { return &self; }
2776         const LDKMaxDustHTLCExposure* operator ->() const { return &self; }
2777 };
2778 class ChannelConfig {
2779 private:
2780         LDKChannelConfig self;
2781 public:
2782         ChannelConfig(const ChannelConfig&) = delete;
2783         ChannelConfig(ChannelConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfig)); }
2784         ChannelConfig(LDKChannelConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfig)); }
2785         operator LDKChannelConfig() && { LDKChannelConfig res = self; memset(&self, 0, sizeof(LDKChannelConfig)); return res; }
2786         ~ChannelConfig() { ChannelConfig_free(self); }
2787         ChannelConfig& operator=(ChannelConfig&& o) { ChannelConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfig)); return *this; }
2788         LDKChannelConfig* operator &() { return &self; }
2789         LDKChannelConfig* operator ->() { return &self; }
2790         const LDKChannelConfig* operator &() const { return &self; }
2791         const LDKChannelConfig* operator ->() const { return &self; }
2792 };
2793 class ChannelConfigUpdate {
2794 private:
2795         LDKChannelConfigUpdate self;
2796 public:
2797         ChannelConfigUpdate(const ChannelConfigUpdate&) = delete;
2798         ChannelConfigUpdate(ChannelConfigUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfigUpdate)); }
2799         ChannelConfigUpdate(LDKChannelConfigUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfigUpdate)); }
2800         operator LDKChannelConfigUpdate() && { LDKChannelConfigUpdate res = self; memset(&self, 0, sizeof(LDKChannelConfigUpdate)); return res; }
2801         ~ChannelConfigUpdate() { ChannelConfigUpdate_free(self); }
2802         ChannelConfigUpdate& operator=(ChannelConfigUpdate&& o) { ChannelConfigUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfigUpdate)); return *this; }
2803         LDKChannelConfigUpdate* operator &() { return &self; }
2804         LDKChannelConfigUpdate* operator ->() { return &self; }
2805         const LDKChannelConfigUpdate* operator &() const { return &self; }
2806         const LDKChannelConfigUpdate* operator ->() const { return &self; }
2807 };
2808 class UserConfig {
2809 private:
2810         LDKUserConfig self;
2811 public:
2812         UserConfig(const UserConfig&) = delete;
2813         UserConfig(UserConfig&& o) : self(o.self) { memset(&o, 0, sizeof(UserConfig)); }
2814         UserConfig(LDKUserConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUserConfig)); }
2815         operator LDKUserConfig() && { LDKUserConfig res = self; memset(&self, 0, sizeof(LDKUserConfig)); return res; }
2816         ~UserConfig() { UserConfig_free(self); }
2817         UserConfig& operator=(UserConfig&& o) { UserConfig_free(self); self = o.self; memset(&o, 0, sizeof(UserConfig)); return *this; }
2818         LDKUserConfig* operator &() { return &self; }
2819         LDKUserConfig* operator ->() { return &self; }
2820         const LDKUserConfig* operator &() const { return &self; }
2821         const LDKUserConfig* operator ->() const { return &self; }
2822 };
2823 class APIError {
2824 private:
2825         LDKAPIError self;
2826 public:
2827         APIError(const APIError&) = delete;
2828         APIError(APIError&& o) : self(o.self) { memset(&o, 0, sizeof(APIError)); }
2829         APIError(LDKAPIError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAPIError)); }
2830         operator LDKAPIError() && { LDKAPIError res = self; memset(&self, 0, sizeof(LDKAPIError)); return res; }
2831         ~APIError() { APIError_free(self); }
2832         APIError& operator=(APIError&& o) { APIError_free(self); self = o.self; memset(&o, 0, sizeof(APIError)); return *this; }
2833         LDKAPIError* operator &() { return &self; }
2834         LDKAPIError* operator ->() { return &self; }
2835         const LDKAPIError* operator &() const { return &self; }
2836         const LDKAPIError* operator ->() const { return &self; }
2837 };
2838 class TaggedHash {
2839 private:
2840         LDKTaggedHash self;
2841 public:
2842         TaggedHash(const TaggedHash&) = delete;
2843         TaggedHash(TaggedHash&& o) : self(o.self) { memset(&o, 0, sizeof(TaggedHash)); }
2844         TaggedHash(LDKTaggedHash&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTaggedHash)); }
2845         operator LDKTaggedHash() && { LDKTaggedHash res = self; memset(&self, 0, sizeof(LDKTaggedHash)); return res; }
2846         ~TaggedHash() { TaggedHash_free(self); }
2847         TaggedHash& operator=(TaggedHash&& o) { TaggedHash_free(self); self = o.self; memset(&o, 0, sizeof(TaggedHash)); return *this; }
2848         LDKTaggedHash* operator &() { return &self; }
2849         LDKTaggedHash* operator ->() { return &self; }
2850         const LDKTaggedHash* operator &() const { return &self; }
2851         const LDKTaggedHash* operator ->() const { return &self; }
2852 };
2853 class ChannelMonitorUpdate {
2854 private:
2855         LDKChannelMonitorUpdate self;
2856 public:
2857         ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete;
2858         ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); }
2859         ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); }
2860         operator LDKChannelMonitorUpdate() && { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; }
2861         ~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); }
2862         ChannelMonitorUpdate& operator=(ChannelMonitorUpdate&& o) { ChannelMonitorUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdate)); return *this; }
2863         LDKChannelMonitorUpdate* operator &() { return &self; }
2864         LDKChannelMonitorUpdate* operator ->() { return &self; }
2865         const LDKChannelMonitorUpdate* operator &() const { return &self; }
2866         const LDKChannelMonitorUpdate* operator ->() const { return &self; }
2867 };
2868 class MonitorEvent {
2869 private:
2870         LDKMonitorEvent self;
2871 public:
2872         MonitorEvent(const MonitorEvent&) = delete;
2873         MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); }
2874         MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); }
2875         operator LDKMonitorEvent() && { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; }
2876         ~MonitorEvent() { MonitorEvent_free(self); }
2877         MonitorEvent& operator=(MonitorEvent&& o) { MonitorEvent_free(self); self = o.self; memset(&o, 0, sizeof(MonitorEvent)); return *this; }
2878         LDKMonitorEvent* operator &() { return &self; }
2879         LDKMonitorEvent* operator ->() { return &self; }
2880         const LDKMonitorEvent* operator &() const { return &self; }
2881         const LDKMonitorEvent* operator ->() const { return &self; }
2882 };
2883 class HTLCUpdate {
2884 private:
2885         LDKHTLCUpdate self;
2886 public:
2887         HTLCUpdate(const HTLCUpdate&) = delete;
2888         HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); }
2889         HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); }
2890         operator LDKHTLCUpdate() && { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; }
2891         ~HTLCUpdate() { HTLCUpdate_free(self); }
2892         HTLCUpdate& operator=(HTLCUpdate&& o) { HTLCUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCUpdate)); return *this; }
2893         LDKHTLCUpdate* operator &() { return &self; }
2894         LDKHTLCUpdate* operator ->() { return &self; }
2895         const LDKHTLCUpdate* operator &() const { return &self; }
2896         const LDKHTLCUpdate* operator ->() const { return &self; }
2897 };
2898 class Balance {
2899 private:
2900         LDKBalance self;
2901 public:
2902         Balance(const Balance&) = delete;
2903         Balance(Balance&& o) : self(o.self) { memset(&o, 0, sizeof(Balance)); }
2904         Balance(LDKBalance&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBalance)); }
2905         operator LDKBalance() && { LDKBalance res = self; memset(&self, 0, sizeof(LDKBalance)); return res; }
2906         ~Balance() { Balance_free(self); }
2907         Balance& operator=(Balance&& o) { Balance_free(self); self = o.self; memset(&o, 0, sizeof(Balance)); return *this; }
2908         LDKBalance* operator &() { return &self; }
2909         LDKBalance* operator ->() { return &self; }
2910         const LDKBalance* operator &() const { return &self; }
2911         const LDKBalance* operator ->() const { return &self; }
2912 };
2913 class ChannelMonitor {
2914 private:
2915         LDKChannelMonitor self;
2916 public:
2917         ChannelMonitor(const ChannelMonitor&) = delete;
2918         ChannelMonitor(ChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitor)); }
2919         ChannelMonitor(LDKChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitor)); }
2920         operator LDKChannelMonitor() && { LDKChannelMonitor res = self; memset(&self, 0, sizeof(LDKChannelMonitor)); return res; }
2921         ~ChannelMonitor() { ChannelMonitor_free(self); }
2922         ChannelMonitor& operator=(ChannelMonitor&& o) { ChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitor)); return *this; }
2923         LDKChannelMonitor* operator &() { return &self; }
2924         LDKChannelMonitor* operator ->() { return &self; }
2925         const LDKChannelMonitor* operator &() const { return &self; }
2926         const LDKChannelMonitor* operator ->() const { return &self; }
2927 };
2928 class ExpandedKey {
2929 private:
2930         LDKExpandedKey self;
2931 public:
2932         ExpandedKey(const ExpandedKey&) = delete;
2933         ExpandedKey(ExpandedKey&& o) : self(o.self) { memset(&o, 0, sizeof(ExpandedKey)); }
2934         ExpandedKey(LDKExpandedKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpandedKey)); }
2935         operator LDKExpandedKey() && { LDKExpandedKey res = self; memset(&self, 0, sizeof(LDKExpandedKey)); return res; }
2936         ~ExpandedKey() { ExpandedKey_free(self); }
2937         ExpandedKey& operator=(ExpandedKey&& o) { ExpandedKey_free(self); self = o.self; memset(&o, 0, sizeof(ExpandedKey)); return *this; }
2938         LDKExpandedKey* operator &() { return &self; }
2939         LDKExpandedKey* operator ->() { return &self; }
2940         const LDKExpandedKey* operator &() const { return &self; }
2941         const LDKExpandedKey* operator ->() const { return &self; }
2942 };
2943 class CustomMessageHandler {
2944 private:
2945         LDKCustomMessageHandler self;
2946 public:
2947         CustomMessageHandler(const CustomMessageHandler&) = delete;
2948         CustomMessageHandler(CustomMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(CustomMessageHandler)); }
2949         CustomMessageHandler(LDKCustomMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomMessageHandler)); }
2950         operator LDKCustomMessageHandler() && { LDKCustomMessageHandler res = self; memset(&self, 0, sizeof(LDKCustomMessageHandler)); return res; }
2951         ~CustomMessageHandler() { CustomMessageHandler_free(self); }
2952         CustomMessageHandler& operator=(CustomMessageHandler&& o) { CustomMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(CustomMessageHandler)); return *this; }
2953         LDKCustomMessageHandler* operator &() { return &self; }
2954         LDKCustomMessageHandler* operator ->() { return &self; }
2955         const LDKCustomMessageHandler* operator &() const { return &self; }
2956         const LDKCustomMessageHandler* operator ->() const { return &self; }
2957         /**
2958          *  Handles the given message sent from `sender_node_id`, possibly producing messages for
2959          *  [`CustomMessageHandler::get_and_clear_pending_msg`] to return and thus for [`PeerManager`]
2960          *  to send.
2961          */
2962         inline LDK::CResult_NoneLightningErrorZ handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id);
2963         /**
2964          *  Returns the list of pending messages that were generated by the handler, clearing the list
2965          *  in the process. Each message is paired with the node id of the intended recipient. If no
2966          *  connection to the node exists, then the message is simply not sent.
2967          */
2968         inline LDK::CVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg();
2969         /**
2970          *  Gets the node feature flags which this handler itself supports. All available handlers are
2971          *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
2972          *  which are broadcasted in our [`NodeAnnouncement`] message.
2973          *
2974          *  [`NodeAnnouncement`]: crate::ln::msgs::NodeAnnouncement
2975          */
2976         inline LDK::NodeFeatures provided_node_features();
2977         /**
2978          *  Gets the init feature flags which should be sent to the given peer. All available handlers
2979          *  are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
2980          *  which are sent in our [`Init`] message.
2981          *
2982          *  [`Init`]: crate::ln::msgs::Init
2983          */
2984         inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
2985 };
2986 class IgnoringMessageHandler {
2987 private:
2988         LDKIgnoringMessageHandler self;
2989 public:
2990         IgnoringMessageHandler(const IgnoringMessageHandler&) = delete;
2991         IgnoringMessageHandler(IgnoringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(IgnoringMessageHandler)); }
2992         IgnoringMessageHandler(LDKIgnoringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKIgnoringMessageHandler)); }
2993         operator LDKIgnoringMessageHandler() && { LDKIgnoringMessageHandler res = self; memset(&self, 0, sizeof(LDKIgnoringMessageHandler)); return res; }
2994         ~IgnoringMessageHandler() { IgnoringMessageHandler_free(self); }
2995         IgnoringMessageHandler& operator=(IgnoringMessageHandler&& o) { IgnoringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(IgnoringMessageHandler)); return *this; }
2996         LDKIgnoringMessageHandler* operator &() { return &self; }
2997         LDKIgnoringMessageHandler* operator ->() { return &self; }
2998         const LDKIgnoringMessageHandler* operator &() const { return &self; }
2999         const LDKIgnoringMessageHandler* operator ->() const { return &self; }
3000 };
3001 class ErroringMessageHandler {
3002 private:
3003         LDKErroringMessageHandler self;
3004 public:
3005         ErroringMessageHandler(const ErroringMessageHandler&) = delete;
3006         ErroringMessageHandler(ErroringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ErroringMessageHandler)); }
3007         ErroringMessageHandler(LDKErroringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroringMessageHandler)); }
3008         operator LDKErroringMessageHandler() && { LDKErroringMessageHandler res = self; memset(&self, 0, sizeof(LDKErroringMessageHandler)); return res; }
3009         ~ErroringMessageHandler() { ErroringMessageHandler_free(self); }
3010         ErroringMessageHandler& operator=(ErroringMessageHandler&& o) { ErroringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ErroringMessageHandler)); return *this; }
3011         LDKErroringMessageHandler* operator &() { return &self; }
3012         LDKErroringMessageHandler* operator ->() { return &self; }
3013         const LDKErroringMessageHandler* operator &() const { return &self; }
3014         const LDKErroringMessageHandler* operator ->() const { return &self; }
3015 };
3016 class MessageHandler {
3017 private:
3018         LDKMessageHandler self;
3019 public:
3020         MessageHandler(const MessageHandler&) = delete;
3021         MessageHandler(MessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(MessageHandler)); }
3022         MessageHandler(LDKMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageHandler)); }
3023         operator LDKMessageHandler() && { LDKMessageHandler res = self; memset(&self, 0, sizeof(LDKMessageHandler)); return res; }
3024         ~MessageHandler() { MessageHandler_free(self); }
3025         MessageHandler& operator=(MessageHandler&& o) { MessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(MessageHandler)); return *this; }
3026         LDKMessageHandler* operator &() { return &self; }
3027         LDKMessageHandler* operator ->() { return &self; }
3028         const LDKMessageHandler* operator &() const { return &self; }
3029         const LDKMessageHandler* operator ->() const { return &self; }
3030 };
3031 class SocketDescriptor {
3032 private:
3033         LDKSocketDescriptor self;
3034 public:
3035         SocketDescriptor(const SocketDescriptor&) = delete;
3036         SocketDescriptor(SocketDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SocketDescriptor)); }
3037         SocketDescriptor(LDKSocketDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketDescriptor)); }
3038         operator LDKSocketDescriptor() && { LDKSocketDescriptor res = self; memset(&self, 0, sizeof(LDKSocketDescriptor)); return res; }
3039         ~SocketDescriptor() { SocketDescriptor_free(self); }
3040         SocketDescriptor& operator=(SocketDescriptor&& o) { SocketDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SocketDescriptor)); return *this; }
3041         LDKSocketDescriptor* operator &() { return &self; }
3042         LDKSocketDescriptor* operator ->() { return &self; }
3043         const LDKSocketDescriptor* operator &() const { return &self; }
3044         const LDKSocketDescriptor* operator ->() const { return &self; }
3045         /**
3046          *  Attempts to send some data from the given slice to the peer.
3047          *
3048          *  Returns the amount of data which was sent, possibly 0 if the socket has since disconnected.
3049          *  Note that in the disconnected case, [`PeerManager::socket_disconnected`] must still be
3050          *  called and further write attempts may occur until that time.
3051          *
3052          *  If the returned size is smaller than `data.len()`, a
3053          *  [`PeerManager::write_buffer_space_avail`] call must be made the next time more data can be
3054          *  written. Additionally, until a `send_data` event completes fully, no further
3055          *  [`PeerManager::read_event`] calls should be made for the same peer! Because this is to
3056          *  prevent denial-of-service issues, you should not read or buffer any data from the socket
3057          *  until then.
3058          *
3059          *  If a [`PeerManager::read_event`] call on this descriptor had previously returned true
3060          *  (indicating that read events should be paused to prevent DoS in the send buffer),
3061          *  `resume_read` may be set indicating that read events on this descriptor should resume. A
3062          *  `resume_read` of false carries no meaning, and should not cause any action.
3063          */
3064         inline uintptr_t send_data(struct LDKu8slice data, bool resume_read);
3065         /**
3066          *  Disconnect the socket pointed to by this SocketDescriptor.
3067          *
3068          *  You do *not* need to call [`PeerManager::socket_disconnected`] with this socket after this
3069          *  call (doing so is a noop).
3070          */
3071         inline void disconnect_socket();
3072         /** Checks if two objects are equal given this object's this_arg pointer and another object. */
3073         inline bool eq(const struct LDKSocketDescriptor *NONNULL_PTR other_arg);
3074         /**
3075          * Calculate a succinct non-cryptographic hash for an object given its this_arg pointer.
3076          * This is used, for example, for inclusion of this object in a hash map.
3077          */
3078         inline uint64_t hash();
3079 };
3080 class PeerHandleError {
3081 private:
3082         LDKPeerHandleError self;
3083 public:
3084         PeerHandleError(const PeerHandleError&) = delete;
3085         PeerHandleError(PeerHandleError&& o) : self(o.self) { memset(&o, 0, sizeof(PeerHandleError)); }
3086         PeerHandleError(LDKPeerHandleError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerHandleError)); }
3087         operator LDKPeerHandleError() && { LDKPeerHandleError res = self; memset(&self, 0, sizeof(LDKPeerHandleError)); return res; }
3088         ~PeerHandleError() { PeerHandleError_free(self); }
3089         PeerHandleError& operator=(PeerHandleError&& o) { PeerHandleError_free(self); self = o.self; memset(&o, 0, sizeof(PeerHandleError)); return *this; }
3090         LDKPeerHandleError* operator &() { return &self; }
3091         LDKPeerHandleError* operator ->() { return &self; }
3092         const LDKPeerHandleError* operator &() const { return &self; }
3093         const LDKPeerHandleError* operator ->() const { return &self; }
3094 };
3095 class PeerManager {
3096 private:
3097         LDKPeerManager self;
3098 public:
3099         PeerManager(const PeerManager&) = delete;
3100         PeerManager(PeerManager&& o) : self(o.self) { memset(&o, 0, sizeof(PeerManager)); }
3101         PeerManager(LDKPeerManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerManager)); }
3102         operator LDKPeerManager() && { LDKPeerManager res = self; memset(&self, 0, sizeof(LDKPeerManager)); return res; }
3103         ~PeerManager() { PeerManager_free(self); }
3104         PeerManager& operator=(PeerManager&& o) { PeerManager_free(self); self = o.self; memset(&o, 0, sizeof(PeerManager)); return *this; }
3105         LDKPeerManager* operator &() { return &self; }
3106         LDKPeerManager* operator ->() { return &self; }
3107         const LDKPeerManager* operator &() const { return &self; }
3108         const LDKPeerManager* operator ->() const { return &self; }
3109 };
3110 class RapidGossipSync {
3111 private:
3112         LDKRapidGossipSync self;
3113 public:
3114         RapidGossipSync(const RapidGossipSync&) = delete;
3115         RapidGossipSync(RapidGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(RapidGossipSync)); }
3116         RapidGossipSync(LDKRapidGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRapidGossipSync)); }
3117         operator LDKRapidGossipSync() && { LDKRapidGossipSync res = self; memset(&self, 0, sizeof(LDKRapidGossipSync)); return res; }
3118         ~RapidGossipSync() { RapidGossipSync_free(self); }
3119         RapidGossipSync& operator=(RapidGossipSync&& o) { RapidGossipSync_free(self); self = o.self; memset(&o, 0, sizeof(RapidGossipSync)); return *this; }
3120         LDKRapidGossipSync* operator &() { return &self; }
3121         LDKRapidGossipSync* operator ->() { return &self; }
3122         const LDKRapidGossipSync* operator &() const { return &self; }
3123         const LDKRapidGossipSync* operator ->() const { return &self; }
3124 };
3125 class KVStore {
3126 private:
3127         LDKKVStore self;
3128 public:
3129         KVStore(const KVStore&) = delete;
3130         KVStore(KVStore&& o) : self(o.self) { memset(&o, 0, sizeof(KVStore)); }
3131         KVStore(LDKKVStore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKVStore)); }
3132         operator LDKKVStore() && { LDKKVStore res = self; memset(&self, 0, sizeof(LDKKVStore)); return res; }
3133         ~KVStore() { KVStore_free(self); }
3134         KVStore& operator=(KVStore&& o) { KVStore_free(self); self = o.self; memset(&o, 0, sizeof(KVStore)); return *this; }
3135         LDKKVStore* operator &() { return &self; }
3136         LDKKVStore* operator ->() { return &self; }
3137         const LDKKVStore* operator &() const { return &self; }
3138         const LDKKVStore* operator ->() const { return &self; }
3139         /**
3140          *  Returns the data stored for the given `primary_namespace`, `secondary_namespace`, and
3141          *  `key`.
3142          *
3143          *  Returns an [`ErrorKind::NotFound`] if the given `key` could not be found in the given
3144          *  `primary_namespace` and `secondary_namespace`.
3145          *
3146          *  [`ErrorKind::NotFound`]: io::ErrorKind::NotFound
3147          */
3148         inline LDK::CResult_CVec_u8ZIOErrorZ read(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key);
3149         /**
3150          *  Persists the given data under the given `key`.
3151          *
3152          *  Will create the given `primary_namespace` and `secondary_namespace` if not already present
3153          *  in the store.
3154          */
3155         inline LDK::CResult_NoneIOErrorZ write(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, struct LDKu8slice buf);
3156         /**
3157          *  Removes any data that had previously been persisted under the given `key`.
3158          *
3159          *  If the `lazy` flag is set to `true`, the backend implementation might choose to lazily
3160          *  remove the given `key` at some point in time after the method returns, e.g., as part of an
3161          *  eventual batch deletion of multiple keys. As a consequence, subsequent calls to
3162          *  [`KVStore::list`] might include the removed key until the changes are actually persisted.
3163          *
3164          *  Note that while setting the `lazy` flag reduces the I/O burden of multiple subsequent
3165          *  `remove` calls, it also influences the atomicity guarantees as lazy `remove`s could
3166          *  potentially get lost on crash after the method returns. Therefore, this flag should only be
3167          *  set for `remove` operations that can be safely replayed at a later time.
3168          *
3169          *  Returns successfully if no data will be stored for the given `primary_namespace`,
3170          *  `secondary_namespace`, and `key`, independently of whether it was present before its
3171          *  invokation or not.
3172          */
3173         inline LDK::CResult_NoneIOErrorZ remove(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, bool lazy);
3174         /**
3175          *  Returns a list of keys that are stored under the given `secondary_namespace` in
3176          *  `primary_namespace`.
3177          *
3178          *  Returns the keys in arbitrary order, so users requiring a particular order need to sort the
3179          *  returned keys. Returns an empty list if `primary_namespace` or `secondary_namespace` is unknown.
3180          */
3181         inline LDK::CResult_CVec_StrZIOErrorZ list(struct LDKStr primary_namespace, struct LDKStr secondary_namespace);
3182 };
3183 class Persister {
3184 private:
3185         LDKPersister self;
3186 public:
3187         Persister(const Persister&) = delete;
3188         Persister(Persister&& o) : self(o.self) { memset(&o, 0, sizeof(Persister)); }
3189         Persister(LDKPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersister)); }
3190         operator LDKPersister() && { LDKPersister res = self; memset(&self, 0, sizeof(LDKPersister)); return res; }
3191         ~Persister() { Persister_free(self); }
3192         Persister& operator=(Persister&& o) { Persister_free(self); self = o.self; memset(&o, 0, sizeof(Persister)); return *this; }
3193         LDKPersister* operator &() { return &self; }
3194         LDKPersister* operator ->() { return &self; }
3195         const LDKPersister* operator &() const { return &self; }
3196         const LDKPersister* operator ->() const { return &self; }
3197         /**
3198          *  Persist the given ['ChannelManager'] to disk, returning an error if persistence failed.
3199          */
3200         inline LDK::CResult_NoneIOErrorZ persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager);
3201         /**
3202          *  Persist the given [`NetworkGraph`] to disk, returning an error if persistence failed.
3203          */
3204         inline LDK::CResult_NoneIOErrorZ persist_graph(const struct LDKNetworkGraph *NONNULL_PTR network_graph);
3205         /**
3206          *  Persist the given [`WriteableScore`] to disk, returning an error if persistence failed.
3207          */
3208         inline LDK::CResult_NoneIOErrorZ persist_scorer(const struct LDKWriteableScore *NONNULL_PTR scorer);
3209 };
3210 class MonitorUpdatingPersister {
3211 private:
3212         LDKMonitorUpdatingPersister self;
3213 public:
3214         MonitorUpdatingPersister(const MonitorUpdatingPersister&) = delete;
3215         MonitorUpdatingPersister(MonitorUpdatingPersister&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdatingPersister)); }
3216         MonitorUpdatingPersister(LDKMonitorUpdatingPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdatingPersister)); }
3217         operator LDKMonitorUpdatingPersister() && { LDKMonitorUpdatingPersister res = self; memset(&self, 0, sizeof(LDKMonitorUpdatingPersister)); return res; }
3218         ~MonitorUpdatingPersister() { MonitorUpdatingPersister_free(self); }
3219         MonitorUpdatingPersister& operator=(MonitorUpdatingPersister&& o) { MonitorUpdatingPersister_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdatingPersister)); return *this; }
3220         LDKMonitorUpdatingPersister* operator &() { return &self; }
3221         LDKMonitorUpdatingPersister* operator ->() { return &self; }
3222         const LDKMonitorUpdatingPersister* operator &() const { return &self; }
3223         const LDKMonitorUpdatingPersister* operator ->() const { return &self; }
3224 };
3225 class UnsignedInvoiceRequest {
3226 private:
3227         LDKUnsignedInvoiceRequest self;
3228 public:
3229         UnsignedInvoiceRequest(const UnsignedInvoiceRequest&) = delete;
3230         UnsignedInvoiceRequest(UnsignedInvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedInvoiceRequest)); }
3231         UnsignedInvoiceRequest(LDKUnsignedInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedInvoiceRequest)); }
3232         operator LDKUnsignedInvoiceRequest() && { LDKUnsignedInvoiceRequest res = self; memset(&self, 0, sizeof(LDKUnsignedInvoiceRequest)); return res; }
3233         ~UnsignedInvoiceRequest() { UnsignedInvoiceRequest_free(self); }
3234         UnsignedInvoiceRequest& operator=(UnsignedInvoiceRequest&& o) { UnsignedInvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedInvoiceRequest)); return *this; }
3235         LDKUnsignedInvoiceRequest* operator &() { return &self; }
3236         LDKUnsignedInvoiceRequest* operator ->() { return &self; }
3237         const LDKUnsignedInvoiceRequest* operator &() const { return &self; }
3238         const LDKUnsignedInvoiceRequest* operator ->() const { return &self; }
3239 };
3240 class InvoiceRequest {
3241 private:
3242         LDKInvoiceRequest self;
3243 public:
3244         InvoiceRequest(const InvoiceRequest&) = delete;
3245         InvoiceRequest(InvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequest)); }
3246         InvoiceRequest(LDKInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequest)); }
3247         operator LDKInvoiceRequest() && { LDKInvoiceRequest res = self; memset(&self, 0, sizeof(LDKInvoiceRequest)); return res; }
3248         ~InvoiceRequest() { InvoiceRequest_free(self); }
3249         InvoiceRequest& operator=(InvoiceRequest&& o) { InvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequest)); return *this; }
3250         LDKInvoiceRequest* operator &() { return &self; }
3251         LDKInvoiceRequest* operator ->() { return &self; }
3252         const LDKInvoiceRequest* operator &() const { return &self; }
3253         const LDKInvoiceRequest* operator ->() const { return &self; }
3254 };
3255 class VerifiedInvoiceRequest {
3256 private:
3257         LDKVerifiedInvoiceRequest self;
3258 public:
3259         VerifiedInvoiceRequest(const VerifiedInvoiceRequest&) = delete;
3260         VerifiedInvoiceRequest(VerifiedInvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(VerifiedInvoiceRequest)); }
3261         VerifiedInvoiceRequest(LDKVerifiedInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKVerifiedInvoiceRequest)); }
3262         operator LDKVerifiedInvoiceRequest() && { LDKVerifiedInvoiceRequest res = self; memset(&self, 0, sizeof(LDKVerifiedInvoiceRequest)); return res; }
3263         ~VerifiedInvoiceRequest() { VerifiedInvoiceRequest_free(self); }
3264         VerifiedInvoiceRequest& operator=(VerifiedInvoiceRequest&& o) { VerifiedInvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(VerifiedInvoiceRequest)); return *this; }
3265         LDKVerifiedInvoiceRequest* operator &() { return &self; }
3266         LDKVerifiedInvoiceRequest* operator ->() { return &self; }
3267         const LDKVerifiedInvoiceRequest* operator &() const { return &self; }
3268         const LDKVerifiedInvoiceRequest* operator ->() const { return &self; }
3269 };
3270 class DecodeError {
3271 private:
3272         LDKDecodeError self;
3273 public:
3274         DecodeError(const DecodeError&) = delete;
3275         DecodeError(DecodeError&& o) : self(o.self) { memset(&o, 0, sizeof(DecodeError)); }
3276         DecodeError(LDKDecodeError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDecodeError)); }
3277         operator LDKDecodeError() && { LDKDecodeError res = self; memset(&self, 0, sizeof(LDKDecodeError)); return res; }
3278         ~DecodeError() { DecodeError_free(self); }
3279         DecodeError& operator=(DecodeError&& o) { DecodeError_free(self); self = o.self; memset(&o, 0, sizeof(DecodeError)); return *this; }
3280         LDKDecodeError* operator &() { return &self; }
3281         LDKDecodeError* operator ->() { return &self; }
3282         const LDKDecodeError* operator &() const { return &self; }
3283         const LDKDecodeError* operator ->() const { return &self; }
3284 };
3285 class Init {
3286 private:
3287         LDKInit self;
3288 public:
3289         Init(const Init&) = delete;
3290         Init(Init&& o) : self(o.self) { memset(&o, 0, sizeof(Init)); }
3291         Init(LDKInit&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInit)); }
3292         operator LDKInit() && { LDKInit res = self; memset(&self, 0, sizeof(LDKInit)); return res; }
3293         ~Init() { Init_free(self); }
3294         Init& operator=(Init&& o) { Init_free(self); self = o.self; memset(&o, 0, sizeof(Init)); return *this; }
3295         LDKInit* operator &() { return &self; }
3296         LDKInit* operator ->() { return &self; }
3297         const LDKInit* operator &() const { return &self; }
3298         const LDKInit* operator ->() const { return &self; }
3299 };
3300 class ErrorMessage {
3301 private:
3302         LDKErrorMessage self;
3303 public:
3304         ErrorMessage(const ErrorMessage&) = delete;
3305         ErrorMessage(ErrorMessage&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorMessage)); }
3306         ErrorMessage(LDKErrorMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorMessage)); }
3307         operator LDKErrorMessage() && { LDKErrorMessage res = self; memset(&self, 0, sizeof(LDKErrorMessage)); return res; }
3308         ~ErrorMessage() { ErrorMessage_free(self); }
3309         ErrorMessage& operator=(ErrorMessage&& o) { ErrorMessage_free(self); self = o.self; memset(&o, 0, sizeof(ErrorMessage)); return *this; }
3310         LDKErrorMessage* operator &() { return &self; }
3311         LDKErrorMessage* operator ->() { return &self; }
3312         const LDKErrorMessage* operator &() const { return &self; }
3313         const LDKErrorMessage* operator ->() const { return &self; }
3314 };
3315 class WarningMessage {
3316 private:
3317         LDKWarningMessage self;
3318 public:
3319         WarningMessage(const WarningMessage&) = delete;
3320         WarningMessage(WarningMessage&& o) : self(o.self) { memset(&o, 0, sizeof(WarningMessage)); }
3321         WarningMessage(LDKWarningMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWarningMessage)); }
3322         operator LDKWarningMessage() && { LDKWarningMessage res = self; memset(&self, 0, sizeof(LDKWarningMessage)); return res; }
3323         ~WarningMessage() { WarningMessage_free(self); }
3324         WarningMessage& operator=(WarningMessage&& o) { WarningMessage_free(self); self = o.self; memset(&o, 0, sizeof(WarningMessage)); return *this; }
3325         LDKWarningMessage* operator &() { return &self; }
3326         LDKWarningMessage* operator ->() { return &self; }
3327         const LDKWarningMessage* operator &() const { return &self; }
3328         const LDKWarningMessage* operator ->() const { return &self; }
3329 };
3330 class Ping {
3331 private:
3332         LDKPing self;
3333 public:
3334         Ping(const Ping&) = delete;
3335         Ping(Ping&& o) : self(o.self) { memset(&o, 0, sizeof(Ping)); }
3336         Ping(LDKPing&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPing)); }
3337         operator LDKPing() && { LDKPing res = self; memset(&self, 0, sizeof(LDKPing)); return res; }
3338         ~Ping() { Ping_free(self); }
3339         Ping& operator=(Ping&& o) { Ping_free(self); self = o.self; memset(&o, 0, sizeof(Ping)); return *this; }
3340         LDKPing* operator &() { return &self; }
3341         LDKPing* operator ->() { return &self; }
3342         const LDKPing* operator &() const { return &self; }
3343         const LDKPing* operator ->() const { return &self; }
3344 };
3345 class Pong {
3346 private:
3347         LDKPong self;
3348 public:
3349         Pong(const Pong&) = delete;
3350         Pong(Pong&& o) : self(o.self) { memset(&o, 0, sizeof(Pong)); }
3351         Pong(LDKPong&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPong)); }
3352         operator LDKPong() && { LDKPong res = self; memset(&self, 0, sizeof(LDKPong)); return res; }
3353         ~Pong() { Pong_free(self); }
3354         Pong& operator=(Pong&& o) { Pong_free(self); self = o.self; memset(&o, 0, sizeof(Pong)); return *this; }
3355         LDKPong* operator &() { return &self; }
3356         LDKPong* operator ->() { return &self; }
3357         const LDKPong* operator &() const { return &self; }
3358         const LDKPong* operator ->() const { return &self; }
3359 };
3360 class OpenChannel {
3361 private:
3362         LDKOpenChannel self;
3363 public:
3364         OpenChannel(const OpenChannel&) = delete;
3365         OpenChannel(OpenChannel&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannel)); }
3366         OpenChannel(LDKOpenChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannel)); }
3367         operator LDKOpenChannel() && { LDKOpenChannel res = self; memset(&self, 0, sizeof(LDKOpenChannel)); return res; }
3368         ~OpenChannel() { OpenChannel_free(self); }
3369         OpenChannel& operator=(OpenChannel&& o) { OpenChannel_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannel)); return *this; }
3370         LDKOpenChannel* operator &() { return &self; }
3371         LDKOpenChannel* operator ->() { return &self; }
3372         const LDKOpenChannel* operator &() const { return &self; }
3373         const LDKOpenChannel* operator ->() const { return &self; }
3374 };
3375 class OpenChannelV2 {
3376 private:
3377         LDKOpenChannelV2 self;
3378 public:
3379         OpenChannelV2(const OpenChannelV2&) = delete;
3380         OpenChannelV2(OpenChannelV2&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannelV2)); }
3381         OpenChannelV2(LDKOpenChannelV2&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannelV2)); }
3382         operator LDKOpenChannelV2() && { LDKOpenChannelV2 res = self; memset(&self, 0, sizeof(LDKOpenChannelV2)); return res; }
3383         ~OpenChannelV2() { OpenChannelV2_free(self); }
3384         OpenChannelV2& operator=(OpenChannelV2&& o) { OpenChannelV2_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannelV2)); return *this; }
3385         LDKOpenChannelV2* operator &() { return &self; }
3386         LDKOpenChannelV2* operator ->() { return &self; }
3387         const LDKOpenChannelV2* operator &() const { return &self; }
3388         const LDKOpenChannelV2* operator ->() const { return &self; }
3389 };
3390 class AcceptChannel {
3391 private:
3392         LDKAcceptChannel self;
3393 public:
3394         AcceptChannel(const AcceptChannel&) = delete;
3395         AcceptChannel(AcceptChannel&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannel)); }
3396         AcceptChannel(LDKAcceptChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannel)); }
3397         operator LDKAcceptChannel() && { LDKAcceptChannel res = self; memset(&self, 0, sizeof(LDKAcceptChannel)); return res; }
3398         ~AcceptChannel() { AcceptChannel_free(self); }
3399         AcceptChannel& operator=(AcceptChannel&& o) { AcceptChannel_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannel)); return *this; }
3400         LDKAcceptChannel* operator &() { return &self; }
3401         LDKAcceptChannel* operator ->() { return &self; }
3402         const LDKAcceptChannel* operator &() const { return &self; }
3403         const LDKAcceptChannel* operator ->() const { return &self; }
3404 };
3405 class AcceptChannelV2 {
3406 private:
3407         LDKAcceptChannelV2 self;
3408 public:
3409         AcceptChannelV2(const AcceptChannelV2&) = delete;
3410         AcceptChannelV2(AcceptChannelV2&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannelV2)); }
3411         AcceptChannelV2(LDKAcceptChannelV2&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannelV2)); }
3412         operator LDKAcceptChannelV2() && { LDKAcceptChannelV2 res = self; memset(&self, 0, sizeof(LDKAcceptChannelV2)); return res; }
3413         ~AcceptChannelV2() { AcceptChannelV2_free(self); }
3414         AcceptChannelV2& operator=(AcceptChannelV2&& o) { AcceptChannelV2_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannelV2)); return *this; }
3415         LDKAcceptChannelV2* operator &() { return &self; }
3416         LDKAcceptChannelV2* operator ->() { return &self; }
3417         const LDKAcceptChannelV2* operator &() const { return &self; }
3418         const LDKAcceptChannelV2* operator ->() const { return &self; }
3419 };
3420 class FundingCreated {
3421 private:
3422         LDKFundingCreated self;
3423 public:
3424         FundingCreated(const FundingCreated&) = delete;
3425         FundingCreated(FundingCreated&& o) : self(o.self) { memset(&o, 0, sizeof(FundingCreated)); }
3426         FundingCreated(LDKFundingCreated&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingCreated)); }
3427         operator LDKFundingCreated() && { LDKFundingCreated res = self; memset(&self, 0, sizeof(LDKFundingCreated)); return res; }
3428         ~FundingCreated() { FundingCreated_free(self); }
3429         FundingCreated& operator=(FundingCreated&& o) { FundingCreated_free(self); self = o.self; memset(&o, 0, sizeof(FundingCreated)); return *this; }
3430         LDKFundingCreated* operator &() { return &self; }
3431         LDKFundingCreated* operator ->() { return &self; }
3432         const LDKFundingCreated* operator &() const { return &self; }
3433         const LDKFundingCreated* operator ->() const { return &self; }
3434 };
3435 class FundingSigned {
3436 private:
3437         LDKFundingSigned self;
3438 public:
3439         FundingSigned(const FundingSigned&) = delete;
3440         FundingSigned(FundingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(FundingSigned)); }
3441         FundingSigned(LDKFundingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingSigned)); }
3442         operator LDKFundingSigned() && { LDKFundingSigned res = self; memset(&self, 0, sizeof(LDKFundingSigned)); return res; }
3443         ~FundingSigned() { FundingSigned_free(self); }
3444         FundingSigned& operator=(FundingSigned&& o) { FundingSigned_free(self); self = o.self; memset(&o, 0, sizeof(FundingSigned)); return *this; }
3445         LDKFundingSigned* operator &() { return &self; }
3446         LDKFundingSigned* operator ->() { return &self; }
3447         const LDKFundingSigned* operator &() const { return &self; }
3448         const LDKFundingSigned* operator ->() const { return &self; }
3449 };
3450 class ChannelReady {
3451 private:
3452         LDKChannelReady self;
3453 public:
3454         ChannelReady(const ChannelReady&) = delete;
3455         ChannelReady(ChannelReady&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReady)); }
3456         ChannelReady(LDKChannelReady&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReady)); }
3457         operator LDKChannelReady() && { LDKChannelReady res = self; memset(&self, 0, sizeof(LDKChannelReady)); return res; }
3458         ~ChannelReady() { ChannelReady_free(self); }
3459         ChannelReady& operator=(ChannelReady&& o) { ChannelReady_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReady)); return *this; }
3460         LDKChannelReady* operator &() { return &self; }
3461         LDKChannelReady* operator ->() { return &self; }
3462         const LDKChannelReady* operator &() const { return &self; }
3463         const LDKChannelReady* operator ->() const { return &self; }
3464 };
3465 class TxAddInput {
3466 private:
3467         LDKTxAddInput self;
3468 public:
3469         TxAddInput(const TxAddInput&) = delete;
3470         TxAddInput(TxAddInput&& o) : self(o.self) { memset(&o, 0, sizeof(TxAddInput)); }
3471         TxAddInput(LDKTxAddInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAddInput)); }
3472         operator LDKTxAddInput() && { LDKTxAddInput res = self; memset(&self, 0, sizeof(LDKTxAddInput)); return res; }
3473         ~TxAddInput() { TxAddInput_free(self); }
3474         TxAddInput& operator=(TxAddInput&& o) { TxAddInput_free(self); self = o.self; memset(&o, 0, sizeof(TxAddInput)); return *this; }
3475         LDKTxAddInput* operator &() { return &self; }
3476         LDKTxAddInput* operator ->() { return &self; }
3477         const LDKTxAddInput* operator &() const { return &self; }
3478         const LDKTxAddInput* operator ->() const { return &self; }
3479 };
3480 class TxAddOutput {
3481 private:
3482         LDKTxAddOutput self;
3483 public:
3484         TxAddOutput(const TxAddOutput&) = delete;
3485         TxAddOutput(TxAddOutput&& o) : self(o.self) { memset(&o, 0, sizeof(TxAddOutput)); }
3486         TxAddOutput(LDKTxAddOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAddOutput)); }
3487         operator LDKTxAddOutput() && { LDKTxAddOutput res = self; memset(&self, 0, sizeof(LDKTxAddOutput)); return res; }
3488         ~TxAddOutput() { TxAddOutput_free(self); }
3489         TxAddOutput& operator=(TxAddOutput&& o) { TxAddOutput_free(self); self = o.self; memset(&o, 0, sizeof(TxAddOutput)); return *this; }
3490         LDKTxAddOutput* operator &() { return &self; }
3491         LDKTxAddOutput* operator ->() { return &self; }
3492         const LDKTxAddOutput* operator &() const { return &self; }
3493         const LDKTxAddOutput* operator ->() const { return &self; }
3494 };
3495 class TxRemoveInput {
3496 private:
3497         LDKTxRemoveInput self;
3498 public:
3499         TxRemoveInput(const TxRemoveInput&) = delete;
3500         TxRemoveInput(TxRemoveInput&& o) : self(o.self) { memset(&o, 0, sizeof(TxRemoveInput)); }
3501         TxRemoveInput(LDKTxRemoveInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxRemoveInput)); }
3502         operator LDKTxRemoveInput() && { LDKTxRemoveInput res = self; memset(&self, 0, sizeof(LDKTxRemoveInput)); return res; }
3503         ~TxRemoveInput() { TxRemoveInput_free(self); }
3504         TxRemoveInput& operator=(TxRemoveInput&& o) { TxRemoveInput_free(self); self = o.self; memset(&o, 0, sizeof(TxRemoveInput)); return *this; }
3505         LDKTxRemoveInput* operator &() { return &self; }
3506         LDKTxRemoveInput* operator ->() { return &self; }
3507         const LDKTxRemoveInput* operator &() const { return &self; }
3508         const LDKTxRemoveInput* operator ->() const { return &self; }
3509 };
3510 class TxRemoveOutput {
3511 private:
3512         LDKTxRemoveOutput self;
3513 public:
3514         TxRemoveOutput(const TxRemoveOutput&) = delete;
3515         TxRemoveOutput(TxRemoveOutput&& o) : self(o.self) { memset(&o, 0, sizeof(TxRemoveOutput)); }
3516         TxRemoveOutput(LDKTxRemoveOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxRemoveOutput)); }
3517         operator LDKTxRemoveOutput() && { LDKTxRemoveOutput res = self; memset(&self, 0, sizeof(LDKTxRemoveOutput)); return res; }
3518         ~TxRemoveOutput() { TxRemoveOutput_free(self); }
3519         TxRemoveOutput& operator=(TxRemoveOutput&& o) { TxRemoveOutput_free(self); self = o.self; memset(&o, 0, sizeof(TxRemoveOutput)); return *this; }
3520         LDKTxRemoveOutput* operator &() { return &self; }
3521         LDKTxRemoveOutput* operator ->() { return &self; }
3522         const LDKTxRemoveOutput* operator &() const { return &self; }
3523         const LDKTxRemoveOutput* operator ->() const { return &self; }
3524 };
3525 class TxComplete {
3526 private:
3527         LDKTxComplete self;
3528 public:
3529         TxComplete(const TxComplete&) = delete;
3530         TxComplete(TxComplete&& o) : self(o.self) { memset(&o, 0, sizeof(TxComplete)); }
3531         TxComplete(LDKTxComplete&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxComplete)); }
3532         operator LDKTxComplete() && { LDKTxComplete res = self; memset(&self, 0, sizeof(LDKTxComplete)); return res; }
3533         ~TxComplete() { TxComplete_free(self); }
3534         TxComplete& operator=(TxComplete&& o) { TxComplete_free(self); self = o.self; memset(&o, 0, sizeof(TxComplete)); return *this; }
3535         LDKTxComplete* operator &() { return &self; }
3536         LDKTxComplete* operator ->() { return &self; }
3537         const LDKTxComplete* operator &() const { return &self; }
3538         const LDKTxComplete* operator ->() const { return &self; }
3539 };
3540 class TxSignatures {
3541 private:
3542         LDKTxSignatures self;
3543 public:
3544         TxSignatures(const TxSignatures&) = delete;
3545         TxSignatures(TxSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(TxSignatures)); }
3546         TxSignatures(LDKTxSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxSignatures)); }
3547         operator LDKTxSignatures() && { LDKTxSignatures res = self; memset(&self, 0, sizeof(LDKTxSignatures)); return res; }
3548         ~TxSignatures() { TxSignatures_free(self); }
3549         TxSignatures& operator=(TxSignatures&& o) { TxSignatures_free(self); self = o.self; memset(&o, 0, sizeof(TxSignatures)); return *this; }
3550         LDKTxSignatures* operator &() { return &self; }
3551         LDKTxSignatures* operator ->() { return &self; }
3552         const LDKTxSignatures* operator &() const { return &self; }
3553         const LDKTxSignatures* operator ->() const { return &self; }
3554 };
3555 class TxInitRbf {
3556 private:
3557         LDKTxInitRbf self;
3558 public:
3559         TxInitRbf(const TxInitRbf&) = delete;
3560         TxInitRbf(TxInitRbf&& o) : self(o.self) { memset(&o, 0, sizeof(TxInitRbf)); }
3561         TxInitRbf(LDKTxInitRbf&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxInitRbf)); }
3562         operator LDKTxInitRbf() && { LDKTxInitRbf res = self; memset(&self, 0, sizeof(LDKTxInitRbf)); return res; }
3563         ~TxInitRbf() { TxInitRbf_free(self); }
3564         TxInitRbf& operator=(TxInitRbf&& o) { TxInitRbf_free(self); self = o.self; memset(&o, 0, sizeof(TxInitRbf)); return *this; }
3565         LDKTxInitRbf* operator &() { return &self; }
3566         LDKTxInitRbf* operator ->() { return &self; }
3567         const LDKTxInitRbf* operator &() const { return &self; }
3568         const LDKTxInitRbf* operator ->() const { return &self; }
3569 };
3570 class TxAckRbf {
3571 private:
3572         LDKTxAckRbf self;
3573 public:
3574         TxAckRbf(const TxAckRbf&) = delete;
3575         TxAckRbf(TxAckRbf&& o) : self(o.self) { memset(&o, 0, sizeof(TxAckRbf)); }
3576         TxAckRbf(LDKTxAckRbf&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAckRbf)); }
3577         operator LDKTxAckRbf() && { LDKTxAckRbf res = self; memset(&self, 0, sizeof(LDKTxAckRbf)); return res; }
3578         ~TxAckRbf() { TxAckRbf_free(self); }
3579         TxAckRbf& operator=(TxAckRbf&& o) { TxAckRbf_free(self); self = o.self; memset(&o, 0, sizeof(TxAckRbf)); return *this; }
3580         LDKTxAckRbf* operator &() { return &self; }
3581         LDKTxAckRbf* operator ->() { return &self; }
3582         const LDKTxAckRbf* operator &() const { return &self; }
3583         const LDKTxAckRbf* operator ->() const { return &self; }
3584 };
3585 class TxAbort {
3586 private:
3587         LDKTxAbort self;
3588 public:
3589         TxAbort(const TxAbort&) = delete;
3590         TxAbort(TxAbort&& o) : self(o.self) { memset(&o, 0, sizeof(TxAbort)); }
3591         TxAbort(LDKTxAbort&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAbort)); }
3592         operator LDKTxAbort() && { LDKTxAbort res = self; memset(&self, 0, sizeof(LDKTxAbort)); return res; }
3593         ~TxAbort() { TxAbort_free(self); }
3594         TxAbort& operator=(TxAbort&& o) { TxAbort_free(self); self = o.self; memset(&o, 0, sizeof(TxAbort)); return *this; }
3595         LDKTxAbort* operator &() { return &self; }
3596         LDKTxAbort* operator ->() { return &self; }
3597         const LDKTxAbort* operator &() const { return &self; }
3598         const LDKTxAbort* operator ->() const { return &self; }
3599 };
3600 class Shutdown {
3601 private:
3602         LDKShutdown self;
3603 public:
3604         Shutdown(const Shutdown&) = delete;
3605         Shutdown(Shutdown&& o) : self(o.self) { memset(&o, 0, sizeof(Shutdown)); }
3606         Shutdown(LDKShutdown&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdown)); }
3607         operator LDKShutdown() && { LDKShutdown res = self; memset(&self, 0, sizeof(LDKShutdown)); return res; }
3608         ~Shutdown() { Shutdown_free(self); }
3609         Shutdown& operator=(Shutdown&& o) { Shutdown_free(self); self = o.self; memset(&o, 0, sizeof(Shutdown)); return *this; }
3610         LDKShutdown* operator &() { return &self; }
3611         LDKShutdown* operator ->() { return &self; }
3612         const LDKShutdown* operator &() const { return &self; }
3613         const LDKShutdown* operator ->() const { return &self; }
3614 };
3615 class ClosingSignedFeeRange {
3616 private:
3617         LDKClosingSignedFeeRange self;
3618 public:
3619         ClosingSignedFeeRange(const ClosingSignedFeeRange&) = delete;
3620         ClosingSignedFeeRange(ClosingSignedFeeRange&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSignedFeeRange)); }
3621         ClosingSignedFeeRange(LDKClosingSignedFeeRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSignedFeeRange)); }
3622         operator LDKClosingSignedFeeRange() && { LDKClosingSignedFeeRange res = self; memset(&self, 0, sizeof(LDKClosingSignedFeeRange)); return res; }
3623         ~ClosingSignedFeeRange() { ClosingSignedFeeRange_free(self); }
3624         ClosingSignedFeeRange& operator=(ClosingSignedFeeRange&& o) { ClosingSignedFeeRange_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSignedFeeRange)); return *this; }
3625         LDKClosingSignedFeeRange* operator &() { return &self; }
3626         LDKClosingSignedFeeRange* operator ->() { return &self; }
3627         const LDKClosingSignedFeeRange* operator &() const { return &self; }
3628         const LDKClosingSignedFeeRange* operator ->() const { return &self; }
3629 };
3630 class ClosingSigned {
3631 private:
3632         LDKClosingSigned self;
3633 public:
3634         ClosingSigned(const ClosingSigned&) = delete;
3635         ClosingSigned(ClosingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSigned)); }
3636         ClosingSigned(LDKClosingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSigned)); }
3637         operator LDKClosingSigned() && { LDKClosingSigned res = self; memset(&self, 0, sizeof(LDKClosingSigned)); return res; }
3638         ~ClosingSigned() { ClosingSigned_free(self); }
3639         ClosingSigned& operator=(ClosingSigned&& o) { ClosingSigned_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSigned)); return *this; }
3640         LDKClosingSigned* operator &() { return &self; }
3641         LDKClosingSigned* operator ->() { return &self; }
3642         const LDKClosingSigned* operator &() const { return &self; }
3643         const LDKClosingSigned* operator ->() const { return &self; }
3644 };
3645 class UpdateAddHTLC {
3646 private:
3647         LDKUpdateAddHTLC self;
3648 public:
3649         UpdateAddHTLC(const UpdateAddHTLC&) = delete;
3650         UpdateAddHTLC(UpdateAddHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateAddHTLC)); }
3651         UpdateAddHTLC(LDKUpdateAddHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateAddHTLC)); }
3652         operator LDKUpdateAddHTLC() && { LDKUpdateAddHTLC res = self; memset(&self, 0, sizeof(LDKUpdateAddHTLC)); return res; }
3653         ~UpdateAddHTLC() { UpdateAddHTLC_free(self); }
3654         UpdateAddHTLC& operator=(UpdateAddHTLC&& o) { UpdateAddHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateAddHTLC)); return *this; }
3655         LDKUpdateAddHTLC* operator &() { return &self; }
3656         LDKUpdateAddHTLC* operator ->() { return &self; }
3657         const LDKUpdateAddHTLC* operator &() const { return &self; }
3658         const LDKUpdateAddHTLC* operator ->() const { return &self; }
3659 };
3660 class OnionMessage {
3661 private:
3662         LDKOnionMessage self;
3663 public:
3664         OnionMessage(const OnionMessage&) = delete;
3665         OnionMessage(OnionMessage&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessage)); }
3666         OnionMessage(LDKOnionMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessage)); }
3667         operator LDKOnionMessage() && { LDKOnionMessage res = self; memset(&self, 0, sizeof(LDKOnionMessage)); return res; }
3668         ~OnionMessage() { OnionMessage_free(self); }
3669         OnionMessage& operator=(OnionMessage&& o) { OnionMessage_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessage)); return *this; }
3670         LDKOnionMessage* operator &() { return &self; }
3671         LDKOnionMessage* operator ->() { return &self; }
3672         const LDKOnionMessage* operator &() const { return &self; }
3673         const LDKOnionMessage* operator ->() const { return &self; }
3674 };
3675 class UpdateFulfillHTLC {
3676 private:
3677         LDKUpdateFulfillHTLC self;
3678 public:
3679         UpdateFulfillHTLC(const UpdateFulfillHTLC&) = delete;
3680         UpdateFulfillHTLC(UpdateFulfillHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFulfillHTLC)); }
3681         UpdateFulfillHTLC(LDKUpdateFulfillHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFulfillHTLC)); }
3682         operator LDKUpdateFulfillHTLC() && { LDKUpdateFulfillHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFulfillHTLC)); return res; }
3683         ~UpdateFulfillHTLC() { UpdateFulfillHTLC_free(self); }
3684         UpdateFulfillHTLC& operator=(UpdateFulfillHTLC&& o) { UpdateFulfillHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFulfillHTLC)); return *this; }
3685         LDKUpdateFulfillHTLC* operator &() { return &self; }
3686         LDKUpdateFulfillHTLC* operator ->() { return &self; }
3687         const LDKUpdateFulfillHTLC* operator &() const { return &self; }
3688         const LDKUpdateFulfillHTLC* operator ->() const { return &self; }
3689 };
3690 class UpdateFailHTLC {
3691 private:
3692         LDKUpdateFailHTLC self;
3693 public:
3694         UpdateFailHTLC(const UpdateFailHTLC&) = delete;
3695         UpdateFailHTLC(UpdateFailHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailHTLC)); }
3696         UpdateFailHTLC(LDKUpdateFailHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailHTLC)); }
3697         operator LDKUpdateFailHTLC() && { LDKUpdateFailHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailHTLC)); return res; }
3698         ~UpdateFailHTLC() { UpdateFailHTLC_free(self); }
3699         UpdateFailHTLC& operator=(UpdateFailHTLC&& o) { UpdateFailHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailHTLC)); return *this; }
3700         LDKUpdateFailHTLC* operator &() { return &self; }
3701         LDKUpdateFailHTLC* operator ->() { return &self; }
3702         const LDKUpdateFailHTLC* operator &() const { return &self; }
3703         const LDKUpdateFailHTLC* operator ->() const { return &self; }
3704 };
3705 class UpdateFailMalformedHTLC {
3706 private:
3707         LDKUpdateFailMalformedHTLC self;
3708 public:
3709         UpdateFailMalformedHTLC(const UpdateFailMalformedHTLC&) = delete;
3710         UpdateFailMalformedHTLC(UpdateFailMalformedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); }
3711         UpdateFailMalformedHTLC(LDKUpdateFailMalformedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailMalformedHTLC)); }
3712         operator LDKUpdateFailMalformedHTLC() && { LDKUpdateFailMalformedHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailMalformedHTLC)); return res; }
3713         ~UpdateFailMalformedHTLC() { UpdateFailMalformedHTLC_free(self); }
3714         UpdateFailMalformedHTLC& operator=(UpdateFailMalformedHTLC&& o) { UpdateFailMalformedHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); return *this; }
3715         LDKUpdateFailMalformedHTLC* operator &() { return &self; }
3716         LDKUpdateFailMalformedHTLC* operator ->() { return &self; }
3717         const LDKUpdateFailMalformedHTLC* operator &() const { return &self; }
3718         const LDKUpdateFailMalformedHTLC* operator ->() const { return &self; }
3719 };
3720 class CommitmentSigned {
3721 private:
3722         LDKCommitmentSigned self;
3723 public:
3724         CommitmentSigned(const CommitmentSigned&) = delete;
3725         CommitmentSigned(CommitmentSigned&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentSigned)); }
3726         CommitmentSigned(LDKCommitmentSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentSigned)); }
3727         operator LDKCommitmentSigned() && { LDKCommitmentSigned res = self; memset(&self, 0, sizeof(LDKCommitmentSigned)); return res; }
3728         ~CommitmentSigned() { CommitmentSigned_free(self); }
3729         CommitmentSigned& operator=(CommitmentSigned&& o) { CommitmentSigned_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentSigned)); return *this; }
3730         LDKCommitmentSigned* operator &() { return &self; }
3731         LDKCommitmentSigned* operator ->() { return &self; }
3732         const LDKCommitmentSigned* operator &() const { return &self; }
3733         const LDKCommitmentSigned* operator ->() const { return &self; }
3734 };
3735 class RevokeAndACK {
3736 private:
3737         LDKRevokeAndACK self;
3738 public:
3739         RevokeAndACK(const RevokeAndACK&) = delete;
3740         RevokeAndACK(RevokeAndACK&& o) : self(o.self) { memset(&o, 0, sizeof(RevokeAndACK)); }
3741         RevokeAndACK(LDKRevokeAndACK&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevokeAndACK)); }
3742         operator LDKRevokeAndACK() && { LDKRevokeAndACK res = self; memset(&self, 0, sizeof(LDKRevokeAndACK)); return res; }
3743         ~RevokeAndACK() { RevokeAndACK_free(self); }
3744         RevokeAndACK& operator=(RevokeAndACK&& o) { RevokeAndACK_free(self); self = o.self; memset(&o, 0, sizeof(RevokeAndACK)); return *this; }
3745         LDKRevokeAndACK* operator &() { return &self; }
3746         LDKRevokeAndACK* operator ->() { return &self; }
3747         const LDKRevokeAndACK* operator &() const { return &self; }
3748         const LDKRevokeAndACK* operator ->() const { return &self; }
3749 };
3750 class UpdateFee {
3751 private:
3752         LDKUpdateFee self;
3753 public:
3754         UpdateFee(const UpdateFee&) = delete;
3755         UpdateFee(UpdateFee&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFee)); }
3756         UpdateFee(LDKUpdateFee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFee)); }
3757         operator LDKUpdateFee() && { LDKUpdateFee res = self; memset(&self, 0, sizeof(LDKUpdateFee)); return res; }
3758         ~UpdateFee() { UpdateFee_free(self); }
3759         UpdateFee& operator=(UpdateFee&& o) { UpdateFee_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFee)); return *this; }
3760         LDKUpdateFee* operator &() { return &self; }
3761         LDKUpdateFee* operator ->() { return &self; }
3762         const LDKUpdateFee* operator &() const { return &self; }
3763         const LDKUpdateFee* operator ->() const { return &self; }
3764 };
3765 class ChannelReestablish {
3766 private:
3767         LDKChannelReestablish self;
3768 public:
3769         ChannelReestablish(const ChannelReestablish&) = delete;
3770         ChannelReestablish(ChannelReestablish&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReestablish)); }
3771         ChannelReestablish(LDKChannelReestablish&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReestablish)); }
3772         operator LDKChannelReestablish() && { LDKChannelReestablish res = self; memset(&self, 0, sizeof(LDKChannelReestablish)); return res; }
3773         ~ChannelReestablish() { ChannelReestablish_free(self); }
3774         ChannelReestablish& operator=(ChannelReestablish&& o) { ChannelReestablish_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReestablish)); return *this; }
3775         LDKChannelReestablish* operator &() { return &self; }
3776         LDKChannelReestablish* operator ->() { return &self; }
3777         const LDKChannelReestablish* operator &() const { return &self; }
3778         const LDKChannelReestablish* operator ->() const { return &self; }
3779 };
3780 class AnnouncementSignatures {
3781 private:
3782         LDKAnnouncementSignatures self;
3783 public:
3784         AnnouncementSignatures(const AnnouncementSignatures&) = delete;
3785         AnnouncementSignatures(AnnouncementSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(AnnouncementSignatures)); }
3786         AnnouncementSignatures(LDKAnnouncementSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnnouncementSignatures)); }
3787         operator LDKAnnouncementSignatures() && { LDKAnnouncementSignatures res = self; memset(&self, 0, sizeof(LDKAnnouncementSignatures)); return res; }
3788         ~AnnouncementSignatures() { AnnouncementSignatures_free(self); }
3789         AnnouncementSignatures& operator=(AnnouncementSignatures&& o) { AnnouncementSignatures_free(self); self = o.self; memset(&o, 0, sizeof(AnnouncementSignatures)); return *this; }
3790         LDKAnnouncementSignatures* operator &() { return &self; }
3791         LDKAnnouncementSignatures* operator ->() { return &self; }
3792         const LDKAnnouncementSignatures* operator &() const { return &self; }
3793         const LDKAnnouncementSignatures* operator ->() const { return &self; }
3794 };
3795 class SocketAddress {
3796 private:
3797         LDKSocketAddress self;
3798 public:
3799         SocketAddress(const SocketAddress&) = delete;
3800         SocketAddress(SocketAddress&& o) : self(o.self) { memset(&o, 0, sizeof(SocketAddress)); }
3801         SocketAddress(LDKSocketAddress&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketAddress)); }
3802         operator LDKSocketAddress() && { LDKSocketAddress res = self; memset(&self, 0, sizeof(LDKSocketAddress)); return res; }
3803         ~SocketAddress() { SocketAddress_free(self); }
3804         SocketAddress& operator=(SocketAddress&& o) { SocketAddress_free(self); self = o.self; memset(&o, 0, sizeof(SocketAddress)); return *this; }
3805         LDKSocketAddress* operator &() { return &self; }
3806         LDKSocketAddress* operator ->() { return &self; }
3807         const LDKSocketAddress* operator &() const { return &self; }
3808         const LDKSocketAddress* operator ->() const { return &self; }
3809 };
3810 class SocketAddressParseError {
3811 private:
3812         LDKSocketAddressParseError self;
3813 public:
3814         SocketAddressParseError(const SocketAddressParseError&) = delete;
3815         SocketAddressParseError(SocketAddressParseError&& o) : self(o.self) { memset(&o, 0, sizeof(SocketAddressParseError)); }
3816         SocketAddressParseError(LDKSocketAddressParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketAddressParseError)); }
3817         operator LDKSocketAddressParseError() && { LDKSocketAddressParseError res = self; memset(&self, 0, sizeof(LDKSocketAddressParseError)); return res; }
3818         SocketAddressParseError& operator=(SocketAddressParseError&& o) { self = o.self; memset(&o, 0, sizeof(SocketAddressParseError)); return *this; }
3819         LDKSocketAddressParseError* operator &() { return &self; }
3820         LDKSocketAddressParseError* operator ->() { return &self; }
3821         const LDKSocketAddressParseError* operator &() const { return &self; }
3822         const LDKSocketAddressParseError* operator ->() const { return &self; }
3823 };
3824 class UnsignedGossipMessage {
3825 private:
3826         LDKUnsignedGossipMessage self;
3827 public:
3828         UnsignedGossipMessage(const UnsignedGossipMessage&) = delete;
3829         UnsignedGossipMessage(UnsignedGossipMessage&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedGossipMessage)); }
3830         UnsignedGossipMessage(LDKUnsignedGossipMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedGossipMessage)); }
3831         operator LDKUnsignedGossipMessage() && { LDKUnsignedGossipMessage res = self; memset(&self, 0, sizeof(LDKUnsignedGossipMessage)); return res; }
3832         ~UnsignedGossipMessage() { UnsignedGossipMessage_free(self); }
3833         UnsignedGossipMessage& operator=(UnsignedGossipMessage&& o) { UnsignedGossipMessage_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedGossipMessage)); return *this; }
3834         LDKUnsignedGossipMessage* operator &() { return &self; }
3835         LDKUnsignedGossipMessage* operator ->() { return &self; }
3836         const LDKUnsignedGossipMessage* operator &() const { return &self; }
3837         const LDKUnsignedGossipMessage* operator ->() const { return &self; }
3838 };
3839 class UnsignedNodeAnnouncement {
3840 private:
3841         LDKUnsignedNodeAnnouncement self;
3842 public:
3843         UnsignedNodeAnnouncement(const UnsignedNodeAnnouncement&) = delete;
3844         UnsignedNodeAnnouncement(UnsignedNodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); }
3845         UnsignedNodeAnnouncement(LDKUnsignedNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedNodeAnnouncement)); }
3846         operator LDKUnsignedNodeAnnouncement() && { LDKUnsignedNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedNodeAnnouncement)); return res; }
3847         ~UnsignedNodeAnnouncement() { UnsignedNodeAnnouncement_free(self); }
3848         UnsignedNodeAnnouncement& operator=(UnsignedNodeAnnouncement&& o) { UnsignedNodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); return *this; }
3849         LDKUnsignedNodeAnnouncement* operator &() { return &self; }
3850         LDKUnsignedNodeAnnouncement* operator ->() { return &self; }
3851         const LDKUnsignedNodeAnnouncement* operator &() const { return &self; }
3852         const LDKUnsignedNodeAnnouncement* operator ->() const { return &self; }
3853 };
3854 class NodeAnnouncement {
3855 private:
3856         LDKNodeAnnouncement self;
3857 public:
3858         NodeAnnouncement(const NodeAnnouncement&) = delete;
3859         NodeAnnouncement(NodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncement)); }
3860         NodeAnnouncement(LDKNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncement)); }
3861         operator LDKNodeAnnouncement() && { LDKNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKNodeAnnouncement)); return res; }
3862         ~NodeAnnouncement() { NodeAnnouncement_free(self); }
3863         NodeAnnouncement& operator=(NodeAnnouncement&& o) { NodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncement)); return *this; }
3864         LDKNodeAnnouncement* operator &() { return &self; }
3865         LDKNodeAnnouncement* operator ->() { return &self; }
3866         const LDKNodeAnnouncement* operator &() const { return &self; }
3867         const LDKNodeAnnouncement* operator ->() const { return &self; }
3868 };
3869 class UnsignedChannelAnnouncement {
3870 private:
3871         LDKUnsignedChannelAnnouncement self;
3872 public:
3873         UnsignedChannelAnnouncement(const UnsignedChannelAnnouncement&) = delete;
3874         UnsignedChannelAnnouncement(UnsignedChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); }
3875         UnsignedChannelAnnouncement(LDKUnsignedChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelAnnouncement)); }
3876         operator LDKUnsignedChannelAnnouncement() && { LDKUnsignedChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedChannelAnnouncement)); return res; }
3877         ~UnsignedChannelAnnouncement() { UnsignedChannelAnnouncement_free(self); }
3878         UnsignedChannelAnnouncement& operator=(UnsignedChannelAnnouncement&& o) { UnsignedChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); return *this; }
3879         LDKUnsignedChannelAnnouncement* operator &() { return &self; }
3880         LDKUnsignedChannelAnnouncement* operator ->() { return &self; }
3881         const LDKUnsignedChannelAnnouncement* operator &() const { return &self; }
3882         const LDKUnsignedChannelAnnouncement* operator ->() const { return &self; }
3883 };
3884 class ChannelAnnouncement {
3885 private:
3886         LDKChannelAnnouncement self;
3887 public:
3888         ChannelAnnouncement(const ChannelAnnouncement&) = delete;
3889         ChannelAnnouncement(ChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelAnnouncement)); }
3890         ChannelAnnouncement(LDKChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelAnnouncement)); }
3891         operator LDKChannelAnnouncement() && { LDKChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKChannelAnnouncement)); return res; }
3892         ~ChannelAnnouncement() { ChannelAnnouncement_free(self); }
3893         ChannelAnnouncement& operator=(ChannelAnnouncement&& o) { ChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(ChannelAnnouncement)); return *this; }
3894         LDKChannelAnnouncement* operator &() { return &self; }
3895         LDKChannelAnnouncement* operator ->() { return &self; }
3896         const LDKChannelAnnouncement* operator &() const { return &self; }
3897         const LDKChannelAnnouncement* operator ->() const { return &self; }
3898 };
3899 class UnsignedChannelUpdate {
3900 private:
3901         LDKUnsignedChannelUpdate self;
3902 public:
3903         UnsignedChannelUpdate(const UnsignedChannelUpdate&) = delete;
3904         UnsignedChannelUpdate(UnsignedChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelUpdate)); }
3905         UnsignedChannelUpdate(LDKUnsignedChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelUpdate)); }
3906         operator LDKUnsignedChannelUpdate() && { LDKUnsignedChannelUpdate res = self; memset(&self, 0, sizeof(LDKUnsignedChannelUpdate)); return res; }
3907         ~UnsignedChannelUpdate() { UnsignedChannelUpdate_free(self); }
3908         UnsignedChannelUpdate& operator=(UnsignedChannelUpdate&& o) { UnsignedChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelUpdate)); return *this; }
3909         LDKUnsignedChannelUpdate* operator &() { return &self; }
3910         LDKUnsignedChannelUpdate* operator ->() { return &self; }
3911         const LDKUnsignedChannelUpdate* operator &() const { return &self; }
3912         const LDKUnsignedChannelUpdate* operator ->() const { return &self; }
3913 };
3914 class ChannelUpdate {
3915 private:
3916         LDKChannelUpdate self;
3917 public:
3918         ChannelUpdate(const ChannelUpdate&) = delete;
3919         ChannelUpdate(ChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdate)); }
3920         ChannelUpdate(LDKChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdate)); }
3921         operator LDKChannelUpdate() && { LDKChannelUpdate res = self; memset(&self, 0, sizeof(LDKChannelUpdate)); return res; }
3922         ~ChannelUpdate() { ChannelUpdate_free(self); }
3923         ChannelUpdate& operator=(ChannelUpdate&& o) { ChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdate)); return *this; }
3924         LDKChannelUpdate* operator &() { return &self; }
3925         LDKChannelUpdate* operator ->() { return &self; }
3926         const LDKChannelUpdate* operator &() const { return &self; }
3927         const LDKChannelUpdate* operator ->() const { return &self; }
3928 };
3929 class QueryChannelRange {
3930 private:
3931         LDKQueryChannelRange self;
3932 public:
3933         QueryChannelRange(const QueryChannelRange&) = delete;
3934         QueryChannelRange(QueryChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(QueryChannelRange)); }
3935         QueryChannelRange(LDKQueryChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryChannelRange)); }
3936         operator LDKQueryChannelRange() && { LDKQueryChannelRange res = self; memset(&self, 0, sizeof(LDKQueryChannelRange)); return res; }
3937         ~QueryChannelRange() { QueryChannelRange_free(self); }
3938         QueryChannelRange& operator=(QueryChannelRange&& o) { QueryChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(QueryChannelRange)); return *this; }
3939         LDKQueryChannelRange* operator &() { return &self; }
3940         LDKQueryChannelRange* operator ->() { return &self; }
3941         const LDKQueryChannelRange* operator &() const { return &self; }
3942         const LDKQueryChannelRange* operator ->() const { return &self; }
3943 };
3944 class ReplyChannelRange {
3945 private:
3946         LDKReplyChannelRange self;
3947 public:
3948         ReplyChannelRange(const ReplyChannelRange&) = delete;
3949         ReplyChannelRange(ReplyChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyChannelRange)); }
3950         ReplyChannelRange(LDKReplyChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyChannelRange)); }
3951         operator LDKReplyChannelRange() && { LDKReplyChannelRange res = self; memset(&self, 0, sizeof(LDKReplyChannelRange)); return res; }
3952         ~ReplyChannelRange() { ReplyChannelRange_free(self); }
3953         ReplyChannelRange& operator=(ReplyChannelRange&& o) { ReplyChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(ReplyChannelRange)); return *this; }
3954         LDKReplyChannelRange* operator &() { return &self; }
3955         LDKReplyChannelRange* operator ->() { return &self; }
3956         const LDKReplyChannelRange* operator &() const { return &self; }
3957         const LDKReplyChannelRange* operator ->() const { return &self; }
3958 };
3959 class QueryShortChannelIds {
3960 private:
3961         LDKQueryShortChannelIds self;
3962 public:
3963         QueryShortChannelIds(const QueryShortChannelIds&) = delete;
3964         QueryShortChannelIds(QueryShortChannelIds&& o) : self(o.self) { memset(&o, 0, sizeof(QueryShortChannelIds)); }
3965         QueryShortChannelIds(LDKQueryShortChannelIds&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryShortChannelIds)); }
3966         operator LDKQueryShortChannelIds() && { LDKQueryShortChannelIds res = self; memset(&self, 0, sizeof(LDKQueryShortChannelIds)); return res; }
3967         ~QueryShortChannelIds() { QueryShortChannelIds_free(self); }
3968         QueryShortChannelIds& operator=(QueryShortChannelIds&& o) { QueryShortChannelIds_free(self); self = o.self; memset(&o, 0, sizeof(QueryShortChannelIds)); return *this; }
3969         LDKQueryShortChannelIds* operator &() { return &self; }
3970         LDKQueryShortChannelIds* operator ->() { return &self; }
3971         const LDKQueryShortChannelIds* operator &() const { return &self; }
3972         const LDKQueryShortChannelIds* operator ->() const { return &self; }
3973 };
3974 class ReplyShortChannelIdsEnd {
3975 private:
3976         LDKReplyShortChannelIdsEnd self;
3977 public:
3978         ReplyShortChannelIdsEnd(const ReplyShortChannelIdsEnd&) = delete;
3979         ReplyShortChannelIdsEnd(ReplyShortChannelIdsEnd&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); }
3980         ReplyShortChannelIdsEnd(LDKReplyShortChannelIdsEnd&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyShortChannelIdsEnd)); }
3981         operator LDKReplyShortChannelIdsEnd() && { LDKReplyShortChannelIdsEnd res = self; memset(&self, 0, sizeof(LDKReplyShortChannelIdsEnd)); return res; }
3982         ~ReplyShortChannelIdsEnd() { ReplyShortChannelIdsEnd_free(self); }
3983         ReplyShortChannelIdsEnd& operator=(ReplyShortChannelIdsEnd&& o) { ReplyShortChannelIdsEnd_free(self); self = o.self; memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); return *this; }
3984         LDKReplyShortChannelIdsEnd* operator &() { return &self; }
3985         LDKReplyShortChannelIdsEnd* operator ->() { return &self; }
3986         const LDKReplyShortChannelIdsEnd* operator &() const { return &self; }
3987         const LDKReplyShortChannelIdsEnd* operator ->() const { return &self; }
3988 };
3989 class GossipTimestampFilter {
3990 private:
3991         LDKGossipTimestampFilter self;
3992 public:
3993         GossipTimestampFilter(const GossipTimestampFilter&) = delete;
3994         GossipTimestampFilter(GossipTimestampFilter&& o) : self(o.self) { memset(&o, 0, sizeof(GossipTimestampFilter)); }
3995         GossipTimestampFilter(LDKGossipTimestampFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipTimestampFilter)); }
3996         operator LDKGossipTimestampFilter() && { LDKGossipTimestampFilter res = self; memset(&self, 0, sizeof(LDKGossipTimestampFilter)); return res; }
3997         ~GossipTimestampFilter() { GossipTimestampFilter_free(self); }
3998         GossipTimestampFilter& operator=(GossipTimestampFilter&& o) { GossipTimestampFilter_free(self); self = o.self; memset(&o, 0, sizeof(GossipTimestampFilter)); return *this; }
3999         LDKGossipTimestampFilter* operator &() { return &self; }
4000         LDKGossipTimestampFilter* operator ->() { return &self; }
4001         const LDKGossipTimestampFilter* operator &() const { return &self; }
4002         const LDKGossipTimestampFilter* operator ->() const { return &self; }
4003 };
4004 class ErrorAction {
4005 private:
4006         LDKErrorAction self;
4007 public:
4008         ErrorAction(const ErrorAction&) = delete;
4009         ErrorAction(ErrorAction&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorAction)); }
4010         ErrorAction(LDKErrorAction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorAction)); }
4011         operator LDKErrorAction() && { LDKErrorAction res = self; memset(&self, 0, sizeof(LDKErrorAction)); return res; }
4012         ~ErrorAction() { ErrorAction_free(self); }
4013         ErrorAction& operator=(ErrorAction&& o) { ErrorAction_free(self); self = o.self; memset(&o, 0, sizeof(ErrorAction)); return *this; }
4014         LDKErrorAction* operator &() { return &self; }
4015         LDKErrorAction* operator ->() { return &self; }
4016         const LDKErrorAction* operator &() const { return &self; }
4017         const LDKErrorAction* operator ->() const { return &self; }
4018 };
4019 class LightningError {
4020 private:
4021         LDKLightningError self;
4022 public:
4023         LightningError(const LightningError&) = delete;
4024         LightningError(LightningError&& o) : self(o.self) { memset(&o, 0, sizeof(LightningError)); }
4025         LightningError(LDKLightningError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLightningError)); }
4026         operator LDKLightningError() && { LDKLightningError res = self; memset(&self, 0, sizeof(LDKLightningError)); return res; }
4027         ~LightningError() { LightningError_free(self); }
4028         LightningError& operator=(LightningError&& o) { LightningError_free(self); self = o.self; memset(&o, 0, sizeof(LightningError)); return *this; }
4029         LDKLightningError* operator &() { return &self; }
4030         LDKLightningError* operator ->() { return &self; }
4031         const LDKLightningError* operator &() const { return &self; }
4032         const LDKLightningError* operator ->() const { return &self; }
4033 };
4034 class CommitmentUpdate {
4035 private:
4036         LDKCommitmentUpdate self;
4037 public:
4038         CommitmentUpdate(const CommitmentUpdate&) = delete;
4039         CommitmentUpdate(CommitmentUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentUpdate)); }
4040         CommitmentUpdate(LDKCommitmentUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentUpdate)); }
4041         operator LDKCommitmentUpdate() && { LDKCommitmentUpdate res = self; memset(&self, 0, sizeof(LDKCommitmentUpdate)); return res; }
4042         ~CommitmentUpdate() { CommitmentUpdate_free(self); }
4043         CommitmentUpdate& operator=(CommitmentUpdate&& o) { CommitmentUpdate_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentUpdate)); return *this; }
4044         LDKCommitmentUpdate* operator &() { return &self; }
4045         LDKCommitmentUpdate* operator ->() { return &self; }
4046         const LDKCommitmentUpdate* operator &() const { return &self; }
4047         const LDKCommitmentUpdate* operator ->() const { return &self; }
4048 };
4049 class ChannelMessageHandler {
4050 private:
4051         LDKChannelMessageHandler self;
4052 public:
4053         ChannelMessageHandler(const ChannelMessageHandler&) = delete;
4054         ChannelMessageHandler(ChannelMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMessageHandler)); }
4055         ChannelMessageHandler(LDKChannelMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMessageHandler)); }
4056         operator LDKChannelMessageHandler() && { LDKChannelMessageHandler res = self; memset(&self, 0, sizeof(LDKChannelMessageHandler)); return res; }
4057         ~ChannelMessageHandler() { ChannelMessageHandler_free(self); }
4058         ChannelMessageHandler& operator=(ChannelMessageHandler&& o) { ChannelMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMessageHandler)); return *this; }
4059         LDKChannelMessageHandler* operator &() { return &self; }
4060         LDKChannelMessageHandler* operator ->() { return &self; }
4061         const LDKChannelMessageHandler* operator &() const { return &self; }
4062         const LDKChannelMessageHandler* operator ->() const { return &self; }
4063         /**
4064          *  Handle an incoming `open_channel` message from the given peer.
4065          */
4066         inline void handle_open_channel(struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg);
4067         /**
4068          *  Handle an incoming `open_channel2` message from the given peer.
4069          */
4070         inline void handle_open_channel_v2(struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg);
4071         /**
4072          *  Handle an incoming `accept_channel` message from the given peer.
4073          */
4074         inline void handle_accept_channel(struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg);
4075         /**
4076          *  Handle an incoming `accept_channel2` message from the given peer.
4077          */
4078         inline void handle_accept_channel_v2(struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg);
4079         /**
4080          *  Handle an incoming `funding_created` message from the given peer.
4081          */
4082         inline void handle_funding_created(struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg);
4083         /**
4084          *  Handle an incoming `funding_signed` message from the given peer.
4085          */
4086         inline void handle_funding_signed(struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg);
4087         /**
4088          *  Handle an incoming `channel_ready` message from the given peer.
4089          */
4090         inline void handle_channel_ready(struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg);
4091         /**
4092          *  Handle an incoming `shutdown` message from the given peer.
4093          */
4094         inline void handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg);
4095         /**
4096          *  Handle an incoming `closing_signed` message from the given peer.
4097          */
4098         inline void handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg);
4099         /**
4100          *  Handle an incoming `tx_add_input message` from the given peer.
4101          */
4102         inline void handle_tx_add_input(struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg);
4103         /**
4104          *  Handle an incoming `tx_add_output` message from the given peer.
4105          */
4106         inline void handle_tx_add_output(struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg);
4107         /**
4108          *  Handle an incoming `tx_remove_input` message from the given peer.
4109          */
4110         inline void handle_tx_remove_input(struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg);
4111         /**
4112          *  Handle an incoming `tx_remove_output` message from the given peer.
4113          */
4114         inline void handle_tx_remove_output(struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg);
4115         /**
4116          *  Handle an incoming `tx_complete message` from the given peer.
4117          */
4118         inline void handle_tx_complete(struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg);
4119         /**
4120          *  Handle an incoming `tx_signatures` message from the given peer.
4121          */
4122         inline void handle_tx_signatures(struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg);
4123         /**
4124          *  Handle an incoming `tx_init_rbf` message from the given peer.
4125          */
4126         inline void handle_tx_init_rbf(struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg);
4127         /**
4128          *  Handle an incoming `tx_ack_rbf` message from the given peer.
4129          */
4130         inline void handle_tx_ack_rbf(struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg);
4131         /**
4132          *  Handle an incoming `tx_abort message` from the given peer.
4133          */
4134         inline void handle_tx_abort(struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg);
4135         /**
4136          *  Handle an incoming `update_add_htlc` message from the given peer.
4137          */
4138         inline void handle_update_add_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg);
4139         /**
4140          *  Handle an incoming `update_fulfill_htlc` message from the given peer.
4141          */
4142         inline void handle_update_fulfill_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg);
4143         /**
4144          *  Handle an incoming `update_fail_htlc` message from the given peer.
4145          */
4146         inline void handle_update_fail_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg);
4147         /**
4148          *  Handle an incoming `update_fail_malformed_htlc` message from the given peer.
4149          */
4150         inline void handle_update_fail_malformed_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg);
4151         /**
4152          *  Handle an incoming `commitment_signed` message from the given peer.
4153          */
4154         inline void handle_commitment_signed(struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg);
4155         /**
4156          *  Handle an incoming `revoke_and_ack` message from the given peer.
4157          */
4158         inline void handle_revoke_and_ack(struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg);
4159         /**
4160          *  Handle an incoming `update_fee` message from the given peer.
4161          */
4162         inline void handle_update_fee(struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg);
4163         /**
4164          *  Handle an incoming `announcement_signatures` message from the given peer.
4165          */
4166         inline void handle_announcement_signatures(struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg);
4167         /**
4168          *  Indicates a connection to the peer failed/an existing connection was lost.
4169          */
4170         inline void peer_disconnected(struct LDKPublicKey their_node_id);
4171         /**
4172          *  Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
4173          *
4174          *  May return an `Err(())` if the features the peer supports are not sufficient to communicate
4175          *  with us. Implementors should be somewhat conservative about doing so, however, as other
4176          *  message handlers may still wish to communicate with this peer.
4177          */
4178         inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound);
4179         /**
4180          *  Handle an incoming `channel_reestablish` message from the given peer.
4181          */
4182         inline void handle_channel_reestablish(struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg);
4183         /**
4184          *  Handle an incoming `channel_update` message from the given peer.
4185          */
4186         inline void handle_channel_update(struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg);
4187         /**
4188          *  Handle an incoming `error` message from the given peer.
4189          */
4190         inline void handle_error(struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg);
4191         /**
4192          *  Gets the node feature flags which this handler itself supports. All available handlers are
4193          *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
4194          *  which are broadcasted in our [`NodeAnnouncement`] message.
4195          */
4196         inline LDK::NodeFeatures provided_node_features();
4197         /**
4198          *  Gets the init feature flags which should be sent to the given peer. All available handlers
4199          *  are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
4200          *  which are sent in our [`Init`] message.
4201          *
4202          *  Note that this method is called before [`Self::peer_connected`].
4203          */
4204         inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
4205         /**
4206          *  Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
4207          *
4208          *  If it's `None`, then no particular network chain hash compatibility will be enforced when
4209          *  connecting to peers.
4210          */
4211         inline LDK::COption_CVec_ThirtyTwoBytesZZ get_chain_hashes();
4212 };
4213 class RoutingMessageHandler {
4214 private:
4215         LDKRoutingMessageHandler self;
4216 public:
4217         RoutingMessageHandler(const RoutingMessageHandler&) = delete;
4218         RoutingMessageHandler(RoutingMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingMessageHandler)); }
4219         RoutingMessageHandler(LDKRoutingMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingMessageHandler)); }
4220         operator LDKRoutingMessageHandler() && { LDKRoutingMessageHandler res = self; memset(&self, 0, sizeof(LDKRoutingMessageHandler)); return res; }
4221         ~RoutingMessageHandler() { RoutingMessageHandler_free(self); }
4222         RoutingMessageHandler& operator=(RoutingMessageHandler&& o) { RoutingMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(RoutingMessageHandler)); return *this; }
4223         LDKRoutingMessageHandler* operator &() { return &self; }
4224         LDKRoutingMessageHandler* operator ->() { return &self; }
4225         const LDKRoutingMessageHandler* operator &() const { return &self; }
4226         const LDKRoutingMessageHandler* operator ->() const { return &self; }
4227         /**
4228          *  Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
4229          *  `false` or returning an `Err` otherwise.
4230          */
4231         inline LDK::CResult_boolLightningErrorZ handle_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg);
4232         /**
4233          *  Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
4234          *  or returning an `Err` otherwise.
4235          */
4236         inline LDK::CResult_boolLightningErrorZ handle_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg);
4237         /**
4238          *  Handle an incoming `channel_update` message, returning true if it should be forwarded on,
4239          *  `false` or returning an `Err` otherwise.
4240          */
4241         inline LDK::CResult_boolLightningErrorZ handle_channel_update(const struct LDKChannelUpdate *NONNULL_PTR msg);
4242         /**
4243          *  Gets channel announcements and updates required to dump our routing table to a remote node,
4244          *  starting at the `short_channel_id` indicated by `starting_point` and including announcements
4245          *  for a single channel.
4246          */
4247         inline LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcement(uint64_t starting_point);
4248         /**
4249          *  Gets a node announcement required to dump our routing table to a remote node, starting at
4250          *  the node *after* the provided pubkey and including up to one announcement immediately
4251          *  higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
4252          *  If `None` is provided for `starting_point`, we start at the first node.
4253          *
4254          *  Note that starting_point (or a relevant inner pointer) may be NULL or all-0s to represent None
4255          *  Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
4256          */
4257         inline LDK::NodeAnnouncement get_next_node_announcement(struct LDKNodeId starting_point);
4258         /**
4259          *  Called when a connection is established with a peer. This can be used to
4260          *  perform routing table synchronization using a strategy defined by the
4261          *  implementor.
4262          *
4263          *  May return an `Err(())` if the features the peer supports are not sufficient to communicate
4264          *  with us. Implementors should be somewhat conservative about doing so, however, as other
4265          *  message handlers may still wish to communicate with this peer.
4266          */
4267         inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound);
4268         /**
4269          *  Handles the reply of a query we initiated to learn about channels
4270          *  for a given range of blocks. We can expect to receive one or more
4271          *  replies to a single query.
4272          */
4273         inline LDK::CResult_NoneLightningErrorZ handle_reply_channel_range(struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg);
4274         /**
4275          *  Handles the reply of a query we initiated asking for routing gossip
4276          *  messages for a list of channels. We should receive this message when
4277          *  a node has completed its best effort to send us the pertaining routing
4278          *  gossip messages.
4279          */
4280         inline LDK::CResult_NoneLightningErrorZ handle_reply_short_channel_ids_end(struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg);
4281         /**
4282          *  Handles when a peer asks us to send a list of `short_channel_id`s
4283          *  for the requested range of blocks.
4284          */
4285         inline LDK::CResult_NoneLightningErrorZ handle_query_channel_range(struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg);
4286         /**
4287          *  Handles when a peer asks us to send routing gossip messages for a
4288          *  list of `short_channel_id`s.
4289          */
4290         inline LDK::CResult_NoneLightningErrorZ handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg);
4291         /**
4292          *  Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
4293          *  pending some async action. While there is no guarantee of the rate of future messages, the
4294          *  caller should seek to reduce the rate of new gossip messages handled, especially
4295          *  [`ChannelAnnouncement`]s.
4296          */
4297         inline bool processing_queue_high();
4298         /**
4299          *  Gets the node feature flags which this handler itself supports. All available handlers are
4300          *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
4301          *  which are broadcasted in our [`NodeAnnouncement`] message.
4302          */
4303         inline LDK::NodeFeatures provided_node_features();
4304         /**
4305          *  Gets the init feature flags which should be sent to the given peer. All available handlers
4306          *  are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
4307          *  which are sent in our [`Init`] message.
4308          *
4309          *  Note that this method is called before [`Self::peer_connected`].
4310          */
4311         inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
4312 };
4313 class OnionMessageHandler {
4314 private:
4315         LDKOnionMessageHandler self;
4316 public:
4317         OnionMessageHandler(const OnionMessageHandler&) = delete;
4318         OnionMessageHandler(OnionMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageHandler)); }
4319         OnionMessageHandler(LDKOnionMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageHandler)); }
4320         operator LDKOnionMessageHandler() && { LDKOnionMessageHandler res = self; memset(&self, 0, sizeof(LDKOnionMessageHandler)); return res; }
4321         ~OnionMessageHandler() { OnionMessageHandler_free(self); }
4322         OnionMessageHandler& operator=(OnionMessageHandler&& o) { OnionMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageHandler)); return *this; }
4323         LDKOnionMessageHandler* operator &() { return &self; }
4324         LDKOnionMessageHandler* operator ->() { return &self; }
4325         const LDKOnionMessageHandler* operator &() const { return &self; }
4326         const LDKOnionMessageHandler* operator ->() const { return &self; }
4327         /**
4328          *  Handle an incoming `onion_message` message from the given peer.
4329          */
4330         inline void handle_onion_message(struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg);
4331         /**
4332          *  Returns the next pending onion message for the peer with the given node id.
4333          *
4334          *  Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
4335          */
4336         inline LDK::OnionMessage next_onion_message_for_peer(struct LDKPublicKey peer_node_id);
4337         /**
4338          *  Called when a connection is established with a peer. Can be used to track which peers
4339          *  advertise onion message support and are online.
4340          *
4341          *  May return an `Err(())` if the features the peer supports are not sufficient to communicate
4342          *  with us. Implementors should be somewhat conservative about doing so, however, as other
4343          *  message handlers may still wish to communicate with this peer.
4344          */
4345         inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound);
4346         /**
4347          *  Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
4348          *  drop and refuse to forward onion messages to this peer.
4349          */
4350         inline void peer_disconnected(struct LDKPublicKey their_node_id);
4351         /**
4352          *  Gets the node feature flags which this handler itself supports. All available handlers are
4353          *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
4354          *  which are broadcasted in our [`NodeAnnouncement`] message.
4355          */
4356         inline LDK::NodeFeatures provided_node_features();
4357         /**
4358          *  Gets the init feature flags which should be sent to the given peer. All available handlers
4359          *  are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
4360          *  which are sent in our [`Init`] message.
4361          *
4362          *  Note that this method is called before [`Self::peer_connected`].
4363          */
4364         inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
4365 };
4366 class Level {
4367 private:
4368         LDKLevel self;
4369 public:
4370         Level(const Level&) = delete;
4371         Level(Level&& o) : self(o.self) { memset(&o, 0, sizeof(Level)); }
4372         Level(LDKLevel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLevel)); }
4373         operator LDKLevel() && { LDKLevel res = self; memset(&self, 0, sizeof(LDKLevel)); return res; }
4374         Level& operator=(Level&& o) { self = o.self; memset(&o, 0, sizeof(Level)); return *this; }
4375         LDKLevel* operator &() { return &self; }
4376         LDKLevel* operator ->() { return &self; }
4377         const LDKLevel* operator &() const { return &self; }
4378         const LDKLevel* operator ->() const { return &self; }
4379 };
4380 class Record {
4381 private:
4382         LDKRecord self;
4383 public:
4384         Record(const Record&) = delete;
4385         Record(Record&& o) : self(o.self) { memset(&o, 0, sizeof(Record)); }
4386         Record(LDKRecord&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecord)); }
4387         operator LDKRecord() && { LDKRecord res = self; memset(&self, 0, sizeof(LDKRecord)); return res; }
4388         ~Record() { Record_free(self); }
4389         Record& operator=(Record&& o) { Record_free(self); self = o.self; memset(&o, 0, sizeof(Record)); return *this; }
4390         LDKRecord* operator &() { return &self; }
4391         LDKRecord* operator ->() { return &self; }
4392         const LDKRecord* operator &() const { return &self; }
4393         const LDKRecord* operator ->() const { return &self; }
4394 };
4395 class Logger {
4396 private:
4397         LDKLogger self;
4398 public:
4399         Logger(const Logger&) = delete;
4400         Logger(Logger&& o) : self(o.self) { memset(&o, 0, sizeof(Logger)); }
4401         Logger(LDKLogger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLogger)); }
4402         operator LDKLogger() && { LDKLogger res = self; memset(&self, 0, sizeof(LDKLogger)); return res; }
4403         ~Logger() { Logger_free(self); }
4404         Logger& operator=(Logger&& o) { Logger_free(self); self = o.self; memset(&o, 0, sizeof(Logger)); return *this; }
4405         LDKLogger* operator &() { return &self; }
4406         LDKLogger* operator ->() { return &self; }
4407         const LDKLogger* operator &() const { return &self; }
4408         const LDKLogger* operator ->() const { return &self; }
4409         /**
4410          *  Logs the `Record`
4411          */
4412         inline void log(const struct LDKRecord *NONNULL_PTR record);
4413 };
4414 class FutureCallback {
4415 private:
4416         LDKFutureCallback self;
4417 public:
4418         FutureCallback(const FutureCallback&) = delete;
4419         FutureCallback(FutureCallback&& o) : self(o.self) { memset(&o, 0, sizeof(FutureCallback)); }
4420         FutureCallback(LDKFutureCallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFutureCallback)); }
4421         operator LDKFutureCallback() && { LDKFutureCallback res = self; memset(&self, 0, sizeof(LDKFutureCallback)); return res; }
4422         ~FutureCallback() { FutureCallback_free(self); }
4423         FutureCallback& operator=(FutureCallback&& o) { FutureCallback_free(self); self = o.self; memset(&o, 0, sizeof(FutureCallback)); return *this; }
4424         LDKFutureCallback* operator &() { return &self; }
4425         LDKFutureCallback* operator ->() { return &self; }
4426         const LDKFutureCallback* operator &() const { return &self; }
4427         const LDKFutureCallback* operator ->() const { return &self; }
4428         /**
4429          *  The method which is called.
4430          */
4431         inline void call();
4432 };
4433 class Future {
4434 private:
4435         LDKFuture self;
4436 public:
4437         Future(const Future&) = delete;
4438         Future(Future&& o) : self(o.self) { memset(&o, 0, sizeof(Future)); }
4439         Future(LDKFuture&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFuture)); }
4440         operator LDKFuture() && { LDKFuture res = self; memset(&self, 0, sizeof(LDKFuture)); return res; }
4441         ~Future() { Future_free(self); }
4442         Future& operator=(Future&& o) { Future_free(self); self = o.self; memset(&o, 0, sizeof(Future)); return *this; }
4443         LDKFuture* operator &() { return &self; }
4444         LDKFuture* operator ->() { return &self; }
4445         const LDKFuture* operator &() const { return &self; }
4446         const LDKFuture* operator ->() const { return &self; }
4447 };
4448 class Sleeper {
4449 private:
4450         LDKSleeper self;
4451 public:
4452         Sleeper(const Sleeper&) = delete;
4453         Sleeper(Sleeper&& o) : self(o.self) { memset(&o, 0, sizeof(Sleeper)); }
4454         Sleeper(LDKSleeper&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSleeper)); }
4455         operator LDKSleeper() && { LDKSleeper res = self; memset(&self, 0, sizeof(LDKSleeper)); return res; }
4456         ~Sleeper() { Sleeper_free(self); }
4457         Sleeper& operator=(Sleeper&& o) { Sleeper_free(self); self = o.self; memset(&o, 0, sizeof(Sleeper)); return *this; }
4458         LDKSleeper* operator &() { return &self; }
4459         LDKSleeper* operator ->() { return &self; }
4460         const LDKSleeper* operator &() const { return &self; }
4461         const LDKSleeper* operator ->() const { return &self; }
4462 };
4463 class OffersMessageHandler {
4464 private:
4465         LDKOffersMessageHandler self;
4466 public:
4467         OffersMessageHandler(const OffersMessageHandler&) = delete;
4468         OffersMessageHandler(OffersMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(OffersMessageHandler)); }
4469         OffersMessageHandler(LDKOffersMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffersMessageHandler)); }
4470         operator LDKOffersMessageHandler() && { LDKOffersMessageHandler res = self; memset(&self, 0, sizeof(LDKOffersMessageHandler)); return res; }
4471         ~OffersMessageHandler() { OffersMessageHandler_free(self); }
4472         OffersMessageHandler& operator=(OffersMessageHandler&& o) { OffersMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(OffersMessageHandler)); return *this; }
4473         LDKOffersMessageHandler* operator &() { return &self; }
4474         LDKOffersMessageHandler* operator ->() { return &self; }
4475         const LDKOffersMessageHandler* operator &() const { return &self; }
4476         const LDKOffersMessageHandler* operator ->() const { return &self; }
4477         /**
4478          *  Handles the given message by either responding with an [`Bolt12Invoice`], sending a payment,
4479          *  or replying with an error.
4480          *
4481          *  The returned [`OffersMessage`], if any, is enqueued to be sent by [`OnionMessenger`].
4482          *
4483          *  [`OnionMessenger`]: crate::onion_message::OnionMessenger
4484          */
4485         inline LDK::COption_OffersMessageZ handle_message(struct LDKOffersMessage message);
4486         /**
4487          *  Releases any [`OffersMessage`]s that need to be sent.
4488          *
4489          *  Typically, this is used for messages initiating a payment flow rather than in response to
4490          *  another message. The latter should use the return value of [`Self::handle_message`].
4491          */
4492         inline LDK::CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ release_pending_messages();
4493 };
4494 class OffersMessage {
4495 private:
4496         LDKOffersMessage self;
4497 public:
4498         OffersMessage(const OffersMessage&) = delete;
4499         OffersMessage(OffersMessage&& o) : self(o.self) { memset(&o, 0, sizeof(OffersMessage)); }
4500         OffersMessage(LDKOffersMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffersMessage)); }
4501         operator LDKOffersMessage() && { LDKOffersMessage res = self; memset(&self, 0, sizeof(LDKOffersMessage)); return res; }
4502         ~OffersMessage() { OffersMessage_free(self); }
4503         OffersMessage& operator=(OffersMessage&& o) { OffersMessage_free(self); self = o.self; memset(&o, 0, sizeof(OffersMessage)); return *this; }
4504         LDKOffersMessage* operator &() { return &self; }
4505         LDKOffersMessage* operator ->() { return &self; }
4506         const LDKOffersMessage* operator &() const { return &self; }
4507         const LDKOffersMessage* operator ->() const { return &self; }
4508 };
4509 class HTLCClaim {
4510 private:
4511         LDKHTLCClaim self;
4512 public:
4513         HTLCClaim(const HTLCClaim&) = delete;
4514         HTLCClaim(HTLCClaim&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCClaim)); }
4515         HTLCClaim(LDKHTLCClaim&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCClaim)); }
4516         operator LDKHTLCClaim() && { LDKHTLCClaim res = self; memset(&self, 0, sizeof(LDKHTLCClaim)); return res; }
4517         HTLCClaim& operator=(HTLCClaim&& o) { self = o.self; memset(&o, 0, sizeof(HTLCClaim)); return *this; }
4518         LDKHTLCClaim* operator &() { return &self; }
4519         LDKHTLCClaim* operator ->() { return &self; }
4520         const LDKHTLCClaim* operator &() const { return &self; }
4521         const LDKHTLCClaim* operator ->() const { return &self; }
4522 };
4523 class CounterpartyCommitmentSecrets {
4524 private:
4525         LDKCounterpartyCommitmentSecrets self;
4526 public:
4527         CounterpartyCommitmentSecrets(const CounterpartyCommitmentSecrets&) = delete;
4528         CounterpartyCommitmentSecrets(CounterpartyCommitmentSecrets&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); }
4529         CounterpartyCommitmentSecrets(LDKCounterpartyCommitmentSecrets&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); }
4530         operator LDKCounterpartyCommitmentSecrets() && { LDKCounterpartyCommitmentSecrets res = self; memset(&self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); return res; }
4531         ~CounterpartyCommitmentSecrets() { CounterpartyCommitmentSecrets_free(self); }
4532         CounterpartyCommitmentSecrets& operator=(CounterpartyCommitmentSecrets&& o) { CounterpartyCommitmentSecrets_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); return *this; }
4533         LDKCounterpartyCommitmentSecrets* operator &() { return &self; }
4534         LDKCounterpartyCommitmentSecrets* operator ->() { return &self; }
4535         const LDKCounterpartyCommitmentSecrets* operator &() const { return &self; }
4536         const LDKCounterpartyCommitmentSecrets* operator ->() const { return &self; }
4537 };
4538 class TxCreationKeys {
4539 private:
4540         LDKTxCreationKeys self;
4541 public:
4542         TxCreationKeys(const TxCreationKeys&) = delete;
4543         TxCreationKeys(TxCreationKeys&& o) : self(o.self) { memset(&o, 0, sizeof(TxCreationKeys)); }
4544         TxCreationKeys(LDKTxCreationKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxCreationKeys)); }
4545         operator LDKTxCreationKeys() && { LDKTxCreationKeys res = self; memset(&self, 0, sizeof(LDKTxCreationKeys)); return res; }
4546         ~TxCreationKeys() { TxCreationKeys_free(self); }
4547         TxCreationKeys& operator=(TxCreationKeys&& o) { TxCreationKeys_free(self); self = o.self; memset(&o, 0, sizeof(TxCreationKeys)); return *this; }
4548         LDKTxCreationKeys* operator &() { return &self; }
4549         LDKTxCreationKeys* operator ->() { return &self; }
4550         const LDKTxCreationKeys* operator &() const { return &self; }
4551         const LDKTxCreationKeys* operator ->() const { return &self; }
4552 };
4553 class ChannelPublicKeys {
4554 private:
4555         LDKChannelPublicKeys self;
4556 public:
4557         ChannelPublicKeys(const ChannelPublicKeys&) = delete;
4558         ChannelPublicKeys(ChannelPublicKeys&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelPublicKeys)); }
4559         ChannelPublicKeys(LDKChannelPublicKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelPublicKeys)); }
4560         operator LDKChannelPublicKeys() && { LDKChannelPublicKeys res = self; memset(&self, 0, sizeof(LDKChannelPublicKeys)); return res; }
4561         ~ChannelPublicKeys() { ChannelPublicKeys_free(self); }
4562         ChannelPublicKeys& operator=(ChannelPublicKeys&& o) { ChannelPublicKeys_free(self); self = o.self; memset(&o, 0, sizeof(ChannelPublicKeys)); return *this; }
4563         LDKChannelPublicKeys* operator &() { return &self; }
4564         LDKChannelPublicKeys* operator ->() { return &self; }
4565         const LDKChannelPublicKeys* operator &() const { return &self; }
4566         const LDKChannelPublicKeys* operator ->() const { return &self; }
4567 };
4568 class HTLCOutputInCommitment {
4569 private:
4570         LDKHTLCOutputInCommitment self;
4571 public:
4572         HTLCOutputInCommitment(const HTLCOutputInCommitment&) = delete;
4573         HTLCOutputInCommitment(HTLCOutputInCommitment&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCOutputInCommitment)); }
4574         HTLCOutputInCommitment(LDKHTLCOutputInCommitment&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCOutputInCommitment)); }
4575         operator LDKHTLCOutputInCommitment() && { LDKHTLCOutputInCommitment res = self; memset(&self, 0, sizeof(LDKHTLCOutputInCommitment)); return res; }
4576         ~HTLCOutputInCommitment() { HTLCOutputInCommitment_free(self); }
4577         HTLCOutputInCommitment& operator=(HTLCOutputInCommitment&& o) { HTLCOutputInCommitment_free(self); self = o.self; memset(&o, 0, sizeof(HTLCOutputInCommitment)); return *this; }
4578         LDKHTLCOutputInCommitment* operator &() { return &self; }
4579         LDKHTLCOutputInCommitment* operator ->() { return &self; }
4580         const LDKHTLCOutputInCommitment* operator &() const { return &self; }
4581         const LDKHTLCOutputInCommitment* operator ->() const { return &self; }
4582 };
4583 class ChannelTransactionParameters {
4584 private:
4585         LDKChannelTransactionParameters self;
4586 public:
4587         ChannelTransactionParameters(const ChannelTransactionParameters&) = delete;
4588         ChannelTransactionParameters(ChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTransactionParameters)); }
4589         ChannelTransactionParameters(LDKChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTransactionParameters)); }
4590         operator LDKChannelTransactionParameters() && { LDKChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKChannelTransactionParameters)); return res; }
4591         ~ChannelTransactionParameters() { ChannelTransactionParameters_free(self); }
4592         ChannelTransactionParameters& operator=(ChannelTransactionParameters&& o) { ChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTransactionParameters)); return *this; }
4593         LDKChannelTransactionParameters* operator &() { return &self; }
4594         LDKChannelTransactionParameters* operator ->() { return &self; }
4595         const LDKChannelTransactionParameters* operator &() const { return &self; }
4596         const LDKChannelTransactionParameters* operator ->() const { return &self; }
4597 };
4598 class CounterpartyChannelTransactionParameters {
4599 private:
4600         LDKCounterpartyChannelTransactionParameters self;
4601 public:
4602         CounterpartyChannelTransactionParameters(const CounterpartyChannelTransactionParameters&) = delete;
4603         CounterpartyChannelTransactionParameters(CounterpartyChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyChannelTransactionParameters)); }
4604         CounterpartyChannelTransactionParameters(LDKCounterpartyChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyChannelTransactionParameters)); }
4605         operator LDKCounterpartyChannelTransactionParameters() && { LDKCounterpartyChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKCounterpartyChannelTransactionParameters)); return res; }
4606         ~CounterpartyChannelTransactionParameters() { CounterpartyChannelTransactionParameters_free(self); }
4607         CounterpartyChannelTransactionParameters& operator=(CounterpartyChannelTransactionParameters&& o) { CounterpartyChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyChannelTransactionParameters)); return *this; }
4608         LDKCounterpartyChannelTransactionParameters* operator &() { return &self; }
4609         LDKCounterpartyChannelTransactionParameters* operator ->() { return &self; }
4610         const LDKCounterpartyChannelTransactionParameters* operator &() const { return &self; }
4611         const LDKCounterpartyChannelTransactionParameters* operator ->() const { return &self; }
4612 };
4613 class DirectedChannelTransactionParameters {
4614 private:
4615         LDKDirectedChannelTransactionParameters self;
4616 public:
4617         DirectedChannelTransactionParameters(const DirectedChannelTransactionParameters&) = delete;
4618         DirectedChannelTransactionParameters(DirectedChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(DirectedChannelTransactionParameters)); }
4619         DirectedChannelTransactionParameters(LDKDirectedChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectedChannelTransactionParameters)); }
4620         operator LDKDirectedChannelTransactionParameters() && { LDKDirectedChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKDirectedChannelTransactionParameters)); return res; }
4621         ~DirectedChannelTransactionParameters() { DirectedChannelTransactionParameters_free(self); }
4622         DirectedChannelTransactionParameters& operator=(DirectedChannelTransactionParameters&& o) { DirectedChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(DirectedChannelTransactionParameters)); return *this; }
4623         LDKDirectedChannelTransactionParameters* operator &() { return &self; }
4624         LDKDirectedChannelTransactionParameters* operator ->() { return &self; }
4625         const LDKDirectedChannelTransactionParameters* operator &() const { return &self; }
4626         const LDKDirectedChannelTransactionParameters* operator ->() const { return &self; }
4627 };
4628 class HolderCommitmentTransaction {
4629 private:
4630         LDKHolderCommitmentTransaction self;
4631 public:
4632         HolderCommitmentTransaction(const HolderCommitmentTransaction&) = delete;
4633         HolderCommitmentTransaction(HolderCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(HolderCommitmentTransaction)); }
4634         HolderCommitmentTransaction(LDKHolderCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHolderCommitmentTransaction)); }
4635         operator LDKHolderCommitmentTransaction() && { LDKHolderCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKHolderCommitmentTransaction)); return res; }
4636         ~HolderCommitmentTransaction() { HolderCommitmentTransaction_free(self); }
4637         HolderCommitmentTransaction& operator=(HolderCommitmentTransaction&& o) { HolderCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(HolderCommitmentTransaction)); return *this; }
4638         LDKHolderCommitmentTransaction* operator &() { return &self; }
4639         LDKHolderCommitmentTransaction* operator ->() { return &self; }
4640         const LDKHolderCommitmentTransaction* operator &() const { return &self; }
4641         const LDKHolderCommitmentTransaction* operator ->() const { return &self; }
4642 };
4643 class BuiltCommitmentTransaction {
4644 private:
4645         LDKBuiltCommitmentTransaction self;
4646 public:
4647         BuiltCommitmentTransaction(const BuiltCommitmentTransaction&) = delete;
4648         BuiltCommitmentTransaction(BuiltCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(BuiltCommitmentTransaction)); }
4649         BuiltCommitmentTransaction(LDKBuiltCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBuiltCommitmentTransaction)); }
4650         operator LDKBuiltCommitmentTransaction() && { LDKBuiltCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKBuiltCommitmentTransaction)); return res; }
4651         ~BuiltCommitmentTransaction() { BuiltCommitmentTransaction_free(self); }
4652         BuiltCommitmentTransaction& operator=(BuiltCommitmentTransaction&& o) { BuiltCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(BuiltCommitmentTransaction)); return *this; }
4653         LDKBuiltCommitmentTransaction* operator &() { return &self; }
4654         LDKBuiltCommitmentTransaction* operator ->() { return &self; }
4655         const LDKBuiltCommitmentTransaction* operator &() const { return &self; }
4656         const LDKBuiltCommitmentTransaction* operator ->() const { return &self; }
4657 };
4658 class ClosingTransaction {
4659 private:
4660         LDKClosingTransaction self;
4661 public:
4662         ClosingTransaction(const ClosingTransaction&) = delete;
4663         ClosingTransaction(ClosingTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingTransaction)); }
4664         ClosingTransaction(LDKClosingTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingTransaction)); }
4665         operator LDKClosingTransaction() && { LDKClosingTransaction res = self; memset(&self, 0, sizeof(LDKClosingTransaction)); return res; }
4666         ~ClosingTransaction() { ClosingTransaction_free(self); }
4667         ClosingTransaction& operator=(ClosingTransaction&& o) { ClosingTransaction_free(self); self = o.self; memset(&o, 0, sizeof(ClosingTransaction)); return *this; }
4668         LDKClosingTransaction* operator &() { return &self; }
4669         LDKClosingTransaction* operator ->() { return &self; }
4670         const LDKClosingTransaction* operator &() const { return &self; }
4671         const LDKClosingTransaction* operator ->() const { return &self; }
4672 };
4673 class TrustedClosingTransaction {
4674 private:
4675         LDKTrustedClosingTransaction self;
4676 public:
4677         TrustedClosingTransaction(const TrustedClosingTransaction&) = delete;
4678         TrustedClosingTransaction(TrustedClosingTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(TrustedClosingTransaction)); }
4679         TrustedClosingTransaction(LDKTrustedClosingTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrustedClosingTransaction)); }
4680         operator LDKTrustedClosingTransaction() && { LDKTrustedClosingTransaction res = self; memset(&self, 0, sizeof(LDKTrustedClosingTransaction)); return res; }
4681         ~TrustedClosingTransaction() { TrustedClosingTransaction_free(self); }
4682         TrustedClosingTransaction& operator=(TrustedClosingTransaction&& o) { TrustedClosingTransaction_free(self); self = o.self; memset(&o, 0, sizeof(TrustedClosingTransaction)); return *this; }
4683         LDKTrustedClosingTransaction* operator &() { return &self; }
4684         LDKTrustedClosingTransaction* operator ->() { return &self; }
4685         const LDKTrustedClosingTransaction* operator &() const { return &self; }
4686         const LDKTrustedClosingTransaction* operator ->() const { return &self; }
4687 };
4688 class CommitmentTransaction {
4689 private:
4690         LDKCommitmentTransaction self;
4691 public:
4692         CommitmentTransaction(const CommitmentTransaction&) = delete;
4693         CommitmentTransaction(CommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentTransaction)); }
4694         CommitmentTransaction(LDKCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentTransaction)); }
4695         operator LDKCommitmentTransaction() && { LDKCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKCommitmentTransaction)); return res; }
4696         ~CommitmentTransaction() { CommitmentTransaction_free(self); }
4697         CommitmentTransaction& operator=(CommitmentTransaction&& o) { CommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentTransaction)); return *this; }
4698         LDKCommitmentTransaction* operator &() { return &self; }
4699         LDKCommitmentTransaction* operator ->() { return &self; }
4700         const LDKCommitmentTransaction* operator &() const { return &self; }
4701         const LDKCommitmentTransaction* operator ->() const { return &self; }
4702 };
4703 class TrustedCommitmentTransaction {
4704 private:
4705         LDKTrustedCommitmentTransaction self;
4706 public:
4707         TrustedCommitmentTransaction(const TrustedCommitmentTransaction&) = delete;
4708         TrustedCommitmentTransaction(TrustedCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(TrustedCommitmentTransaction)); }
4709         TrustedCommitmentTransaction(LDKTrustedCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrustedCommitmentTransaction)); }
4710         operator LDKTrustedCommitmentTransaction() && { LDKTrustedCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKTrustedCommitmentTransaction)); return res; }
4711         ~TrustedCommitmentTransaction() { TrustedCommitmentTransaction_free(self); }
4712         TrustedCommitmentTransaction& operator=(TrustedCommitmentTransaction&& o) { TrustedCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(TrustedCommitmentTransaction)); return *this; }
4713         LDKTrustedCommitmentTransaction* operator &() { return &self; }
4714         LDKTrustedCommitmentTransaction* operator ->() { return &self; }
4715         const LDKTrustedCommitmentTransaction* operator &() const { return &self; }
4716         const LDKTrustedCommitmentTransaction* operator ->() const { return &self; }
4717 };
4718 class ShutdownScript {
4719 private:
4720         LDKShutdownScript self;
4721 public:
4722         ShutdownScript(const ShutdownScript&) = delete;
4723         ShutdownScript(ShutdownScript&& o) : self(o.self) { memset(&o, 0, sizeof(ShutdownScript)); }
4724         ShutdownScript(LDKShutdownScript&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdownScript)); }
4725         operator LDKShutdownScript() && { LDKShutdownScript res = self; memset(&self, 0, sizeof(LDKShutdownScript)); return res; }
4726         ~ShutdownScript() { ShutdownScript_free(self); }
4727         ShutdownScript& operator=(ShutdownScript&& o) { ShutdownScript_free(self); self = o.self; memset(&o, 0, sizeof(ShutdownScript)); return *this; }
4728         LDKShutdownScript* operator &() { return &self; }
4729         LDKShutdownScript* operator ->() { return &self; }
4730         const LDKShutdownScript* operator &() const { return &self; }
4731         const LDKShutdownScript* operator ->() const { return &self; }
4732 };
4733 class InvalidShutdownScript {
4734 private:
4735         LDKInvalidShutdownScript self;
4736 public:
4737         InvalidShutdownScript(const InvalidShutdownScript&) = delete;
4738         InvalidShutdownScript(InvalidShutdownScript&& o) : self(o.self) { memset(&o, 0, sizeof(InvalidShutdownScript)); }
4739         InvalidShutdownScript(LDKInvalidShutdownScript&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvalidShutdownScript)); }
4740         operator LDKInvalidShutdownScript() && { LDKInvalidShutdownScript res = self; memset(&self, 0, sizeof(LDKInvalidShutdownScript)); return res; }
4741         ~InvalidShutdownScript() { InvalidShutdownScript_free(self); }
4742         InvalidShutdownScript& operator=(InvalidShutdownScript&& o) { InvalidShutdownScript_free(self); self = o.self; memset(&o, 0, sizeof(InvalidShutdownScript)); return *this; }
4743         LDKInvalidShutdownScript* operator &() { return &self; }
4744         LDKInvalidShutdownScript* operator ->() { return &self; }
4745         const LDKInvalidShutdownScript* operator &() const { return &self; }
4746         const LDKInvalidShutdownScript* operator ->() const { return &self; }
4747 };
4748 class Bolt12ParseError {
4749 private:
4750         LDKBolt12ParseError self;
4751 public:
4752         Bolt12ParseError(const Bolt12ParseError&) = delete;
4753         Bolt12ParseError(Bolt12ParseError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12ParseError)); }
4754         Bolt12ParseError(LDKBolt12ParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12ParseError)); }
4755         operator LDKBolt12ParseError() && { LDKBolt12ParseError res = self; memset(&self, 0, sizeof(LDKBolt12ParseError)); return res; }
4756         ~Bolt12ParseError() { Bolt12ParseError_free(self); }
4757         Bolt12ParseError& operator=(Bolt12ParseError&& o) { Bolt12ParseError_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12ParseError)); return *this; }
4758         LDKBolt12ParseError* operator &() { return &self; }
4759         LDKBolt12ParseError* operator ->() { return &self; }
4760         const LDKBolt12ParseError* operator &() const { return &self; }
4761         const LDKBolt12ParseError* operator ->() const { return &self; }
4762 };
4763 class Bolt12SemanticError {
4764 private:
4765         LDKBolt12SemanticError self;
4766 public:
4767         Bolt12SemanticError(const Bolt12SemanticError&) = delete;
4768         Bolt12SemanticError(Bolt12SemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12SemanticError)); }
4769         Bolt12SemanticError(LDKBolt12SemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12SemanticError)); }
4770         operator LDKBolt12SemanticError() && { LDKBolt12SemanticError res = self; memset(&self, 0, sizeof(LDKBolt12SemanticError)); return res; }
4771         Bolt12SemanticError& operator=(Bolt12SemanticError&& o) { self = o.self; memset(&o, 0, sizeof(Bolt12SemanticError)); return *this; }
4772         LDKBolt12SemanticError* operator &() { return &self; }
4773         LDKBolt12SemanticError* operator ->() { return &self; }
4774         const LDKBolt12SemanticError* operator &() const { return &self; }
4775         const LDKBolt12SemanticError* operator ->() const { return &self; }
4776 };
4777 class BroadcasterInterface {
4778 private:
4779         LDKBroadcasterInterface self;
4780 public:
4781         BroadcasterInterface(const BroadcasterInterface&) = delete;
4782         BroadcasterInterface(BroadcasterInterface&& o) : self(o.self) { memset(&o, 0, sizeof(BroadcasterInterface)); }
4783         BroadcasterInterface(LDKBroadcasterInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBroadcasterInterface)); }
4784         operator LDKBroadcasterInterface() && { LDKBroadcasterInterface res = self; memset(&self, 0, sizeof(LDKBroadcasterInterface)); return res; }
4785         ~BroadcasterInterface() { BroadcasterInterface_free(self); }
4786         BroadcasterInterface& operator=(BroadcasterInterface&& o) { BroadcasterInterface_free(self); self = o.self; memset(&o, 0, sizeof(BroadcasterInterface)); return *this; }
4787         LDKBroadcasterInterface* operator &() { return &self; }
4788         LDKBroadcasterInterface* operator ->() { return &self; }
4789         const LDKBroadcasterInterface* operator &() const { return &self; }
4790         const LDKBroadcasterInterface* operator ->() const { return &self; }
4791         /**
4792          *  Sends a list of transactions out to (hopefully) be mined.
4793          *  This only needs to handle the actual broadcasting of transactions, LDK will automatically
4794          *  rebroadcast transactions that haven't made it into a block.
4795          *
4796          *  In some cases LDK may attempt to broadcast a transaction which double-spends another
4797          *  and this isn't a bug and can be safely ignored.
4798          *
4799          *  If more than one transaction is given, these transactions should be considered to be a
4800          *  package and broadcast together. Some of the transactions may or may not depend on each other,
4801          *  be sure to manage both cases correctly.
4802          *
4803          *  Bitcoin transaction packages are defined in BIP 331 and here:
4804          *  https://github.com/bitcoin/bitcoin/blob/master/doc/policy/packages.md
4805          */
4806         inline void broadcast_transactions(struct LDKCVec_TransactionZ txs);
4807 };
4808 class ConfirmationTarget {
4809 private:
4810         LDKConfirmationTarget self;
4811 public:
4812         ConfirmationTarget(const ConfirmationTarget&) = delete;
4813         ConfirmationTarget(ConfirmationTarget&& o) : self(o.self) { memset(&o, 0, sizeof(ConfirmationTarget)); }
4814         ConfirmationTarget(LDKConfirmationTarget&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirmationTarget)); }
4815         operator LDKConfirmationTarget() && { LDKConfirmationTarget res = self; memset(&self, 0, sizeof(LDKConfirmationTarget)); return res; }
4816         ConfirmationTarget& operator=(ConfirmationTarget&& o) { self = o.self; memset(&o, 0, sizeof(ConfirmationTarget)); return *this; }
4817         LDKConfirmationTarget* operator &() { return &self; }
4818         LDKConfirmationTarget* operator ->() { return &self; }
4819         const LDKConfirmationTarget* operator &() const { return &self; }
4820         const LDKConfirmationTarget* operator ->() const { return &self; }
4821 };
4822 class FeeEstimator {
4823 private:
4824         LDKFeeEstimator self;
4825 public:
4826         FeeEstimator(const FeeEstimator&) = delete;
4827         FeeEstimator(FeeEstimator&& o) : self(o.self) { memset(&o, 0, sizeof(FeeEstimator)); }
4828         FeeEstimator(LDKFeeEstimator&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFeeEstimator)); }
4829         operator LDKFeeEstimator() && { LDKFeeEstimator res = self; memset(&self, 0, sizeof(LDKFeeEstimator)); return res; }
4830         ~FeeEstimator() { FeeEstimator_free(self); }
4831         FeeEstimator& operator=(FeeEstimator&& o) { FeeEstimator_free(self); self = o.self; memset(&o, 0, sizeof(FeeEstimator)); return *this; }
4832         LDKFeeEstimator* operator &() { return &self; }
4833         LDKFeeEstimator* operator ->() { return &self; }
4834         const LDKFeeEstimator* operator &() const { return &self; }
4835         const LDKFeeEstimator* operator ->() const { return &self; }
4836         /**
4837          *  Gets estimated satoshis of fee required per 1000 Weight-Units.
4838          *
4839          *  LDK will wrap this method and ensure that the value returned is no smaller than 253
4840          *  (ie 1 satoshi-per-byte rounded up to ensure later round-downs don't put us below 1 satoshi-per-byte).
4841          *
4842          *  The following unit conversions can be used to convert to sats/KW:
4843          *   * satoshis-per-byte * 250
4844          *   * satoshis-per-kbyte / 4
4845          */
4846         inline uint32_t get_est_sat_per_1000_weight(enum LDKConfirmationTarget confirmation_target);
4847 };
4848 class Packet {
4849 private:
4850         LDKPacket self;
4851 public:
4852         Packet(const Packet&) = delete;
4853         Packet(Packet&& o) : self(o.self) { memset(&o, 0, sizeof(Packet)); }
4854         Packet(LDKPacket&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPacket)); }
4855         operator LDKPacket() && { LDKPacket res = self; memset(&self, 0, sizeof(LDKPacket)); return res; }
4856         ~Packet() { Packet_free(self); }
4857         Packet& operator=(Packet&& o) { Packet_free(self); self = o.self; memset(&o, 0, sizeof(Packet)); return *this; }
4858         LDKPacket* operator &() { return &self; }
4859         LDKPacket* operator ->() { return &self; }
4860         const LDKPacket* operator &() const { return &self; }
4861         const LDKPacket* operator ->() const { return &self; }
4862 };
4863 class ParsedOnionMessageContents {
4864 private:
4865         LDKParsedOnionMessageContents self;
4866 public:
4867         ParsedOnionMessageContents(const ParsedOnionMessageContents&) = delete;
4868         ParsedOnionMessageContents(ParsedOnionMessageContents&& o) : self(o.self) { memset(&o, 0, sizeof(ParsedOnionMessageContents)); }
4869         ParsedOnionMessageContents(LDKParsedOnionMessageContents&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKParsedOnionMessageContents)); }
4870         operator LDKParsedOnionMessageContents() && { LDKParsedOnionMessageContents res = self; memset(&self, 0, sizeof(LDKParsedOnionMessageContents)); return res; }
4871         ~ParsedOnionMessageContents() { ParsedOnionMessageContents_free(self); }
4872         ParsedOnionMessageContents& operator=(ParsedOnionMessageContents&& o) { ParsedOnionMessageContents_free(self); self = o.self; memset(&o, 0, sizeof(ParsedOnionMessageContents)); return *this; }
4873         LDKParsedOnionMessageContents* operator &() { return &self; }
4874         LDKParsedOnionMessageContents* operator ->() { return &self; }
4875         const LDKParsedOnionMessageContents* operator &() const { return &self; }
4876         const LDKParsedOnionMessageContents* operator ->() const { return &self; }
4877 };
4878 class OnionMessageContents {
4879 private:
4880         LDKOnionMessageContents self;
4881 public:
4882         OnionMessageContents(const OnionMessageContents&) = delete;
4883         OnionMessageContents(OnionMessageContents&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageContents)); }
4884         OnionMessageContents(LDKOnionMessageContents&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageContents)); }
4885         operator LDKOnionMessageContents() && { LDKOnionMessageContents res = self; memset(&self, 0, sizeof(LDKOnionMessageContents)); return res; }
4886         ~OnionMessageContents() { OnionMessageContents_free(self); }
4887         OnionMessageContents& operator=(OnionMessageContents&& o) { OnionMessageContents_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageContents)); return *this; }
4888         LDKOnionMessageContents* operator &() { return &self; }
4889         LDKOnionMessageContents* operator ->() { return &self; }
4890         const LDKOnionMessageContents* operator &() const { return &self; }
4891         const LDKOnionMessageContents* operator ->() const { return &self; }
4892         /**
4893          *  Returns the TLV type identifying the message contents. MUST be >= 64.
4894          */
4895         inline uint64_t tlv_type();
4896 };
4897 class PaymentPurpose {
4898 private:
4899         LDKPaymentPurpose self;
4900 public:
4901         PaymentPurpose(const PaymentPurpose&) = delete;
4902         PaymentPurpose(PaymentPurpose&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentPurpose)); }
4903         PaymentPurpose(LDKPaymentPurpose&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentPurpose)); }
4904         operator LDKPaymentPurpose() && { LDKPaymentPurpose res = self; memset(&self, 0, sizeof(LDKPaymentPurpose)); return res; }
4905         ~PaymentPurpose() { PaymentPurpose_free(self); }
4906         PaymentPurpose& operator=(PaymentPurpose&& o) { PaymentPurpose_free(self); self = o.self; memset(&o, 0, sizeof(PaymentPurpose)); return *this; }
4907         LDKPaymentPurpose* operator &() { return &self; }
4908         LDKPaymentPurpose* operator ->() { return &self; }
4909         const LDKPaymentPurpose* operator &() const { return &self; }
4910         const LDKPaymentPurpose* operator ->() const { return &self; }
4911 };
4912 class ClaimedHTLC {
4913 private:
4914         LDKClaimedHTLC self;
4915 public:
4916         ClaimedHTLC(const ClaimedHTLC&) = delete;
4917         ClaimedHTLC(ClaimedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(ClaimedHTLC)); }
4918         ClaimedHTLC(LDKClaimedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClaimedHTLC)); }
4919         operator LDKClaimedHTLC() && { LDKClaimedHTLC res = self; memset(&self, 0, sizeof(LDKClaimedHTLC)); return res; }
4920         ~ClaimedHTLC() { ClaimedHTLC_free(self); }
4921         ClaimedHTLC& operator=(ClaimedHTLC&& o) { ClaimedHTLC_free(self); self = o.self; memset(&o, 0, sizeof(ClaimedHTLC)); return *this; }
4922         LDKClaimedHTLC* operator &() { return &self; }
4923         LDKClaimedHTLC* operator ->() { return &self; }
4924         const LDKClaimedHTLC* operator &() const { return &self; }
4925         const LDKClaimedHTLC* operator ->() const { return &self; }
4926 };
4927 class PathFailure {
4928 private:
4929         LDKPathFailure self;
4930 public:
4931         PathFailure(const PathFailure&) = delete;
4932         PathFailure(PathFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PathFailure)); }
4933         PathFailure(LDKPathFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPathFailure)); }
4934         operator LDKPathFailure() && { LDKPathFailure res = self; memset(&self, 0, sizeof(LDKPathFailure)); return res; }
4935         ~PathFailure() { PathFailure_free(self); }
4936         PathFailure& operator=(PathFailure&& o) { PathFailure_free(self); self = o.self; memset(&o, 0, sizeof(PathFailure)); return *this; }
4937         LDKPathFailure* operator &() { return &self; }
4938         LDKPathFailure* operator ->() { return &self; }
4939         const LDKPathFailure* operator &() const { return &self; }
4940         const LDKPathFailure* operator ->() const { return &self; }
4941 };
4942 class ClosureReason {
4943 private:
4944         LDKClosureReason self;
4945 public:
4946         ClosureReason(const ClosureReason&) = delete;
4947         ClosureReason(ClosureReason&& o) : self(o.self) { memset(&o, 0, sizeof(ClosureReason)); }
4948         ClosureReason(LDKClosureReason&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosureReason)); }
4949         operator LDKClosureReason() && { LDKClosureReason res = self; memset(&self, 0, sizeof(LDKClosureReason)); return res; }
4950         ~ClosureReason() { ClosureReason_free(self); }
4951         ClosureReason& operator=(ClosureReason&& o) { ClosureReason_free(self); self = o.self; memset(&o, 0, sizeof(ClosureReason)); return *this; }
4952         LDKClosureReason* operator &() { return &self; }
4953         LDKClosureReason* operator ->() { return &self; }
4954         const LDKClosureReason* operator &() const { return &self; }
4955         const LDKClosureReason* operator ->() const { return &self; }
4956 };
4957 class HTLCDestination {
4958 private:
4959         LDKHTLCDestination self;
4960 public:
4961         HTLCDestination(const HTLCDestination&) = delete;
4962         HTLCDestination(HTLCDestination&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCDestination)); }
4963         HTLCDestination(LDKHTLCDestination&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCDestination)); }
4964         operator LDKHTLCDestination() && { LDKHTLCDestination res = self; memset(&self, 0, sizeof(LDKHTLCDestination)); return res; }
4965         ~HTLCDestination() { HTLCDestination_free(self); }
4966         HTLCDestination& operator=(HTLCDestination&& o) { HTLCDestination_free(self); self = o.self; memset(&o, 0, sizeof(HTLCDestination)); return *this; }
4967         LDKHTLCDestination* operator &() { return &self; }
4968         LDKHTLCDestination* operator ->() { return &self; }
4969         const LDKHTLCDestination* operator &() const { return &self; }
4970         const LDKHTLCDestination* operator ->() const { return &self; }
4971 };
4972 class PaymentFailureReason {
4973 private:
4974         LDKPaymentFailureReason self;
4975 public:
4976         PaymentFailureReason(const PaymentFailureReason&) = delete;
4977         PaymentFailureReason(PaymentFailureReason&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentFailureReason)); }
4978         PaymentFailureReason(LDKPaymentFailureReason&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentFailureReason)); }
4979         operator LDKPaymentFailureReason() && { LDKPaymentFailureReason res = self; memset(&self, 0, sizeof(LDKPaymentFailureReason)); return res; }
4980         PaymentFailureReason& operator=(PaymentFailureReason&& o) { self = o.self; memset(&o, 0, sizeof(PaymentFailureReason)); return *this; }
4981         LDKPaymentFailureReason* operator &() { return &self; }
4982         LDKPaymentFailureReason* operator ->() { return &self; }
4983         const LDKPaymentFailureReason* operator &() const { return &self; }
4984         const LDKPaymentFailureReason* operator ->() const { return &self; }
4985 };
4986 class Event {
4987 private:
4988         LDKEvent self;
4989 public:
4990         Event(const Event&) = delete;
4991         Event(Event&& o) : self(o.self) { memset(&o, 0, sizeof(Event)); }
4992         Event(LDKEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEvent)); }
4993         operator LDKEvent() && { LDKEvent res = self; memset(&self, 0, sizeof(LDKEvent)); return res; }
4994         ~Event() { Event_free(self); }
4995         Event& operator=(Event&& o) { Event_free(self); self = o.self; memset(&o, 0, sizeof(Event)); return *this; }
4996         LDKEvent* operator &() { return &self; }
4997         LDKEvent* operator ->() { return &self; }
4998         const LDKEvent* operator &() const { return &self; }
4999         const LDKEvent* operator ->() const { return &self; }
5000 };
5001 class MessageSendEvent {
5002 private:
5003         LDKMessageSendEvent self;
5004 public:
5005         MessageSendEvent(const MessageSendEvent&) = delete;
5006         MessageSendEvent(MessageSendEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEvent)); }
5007         MessageSendEvent(LDKMessageSendEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEvent)); }
5008         operator LDKMessageSendEvent() && { LDKMessageSendEvent res = self; memset(&self, 0, sizeof(LDKMessageSendEvent)); return res; }
5009         ~MessageSendEvent() { MessageSendEvent_free(self); }
5010         MessageSendEvent& operator=(MessageSendEvent&& o) { MessageSendEvent_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEvent)); return *this; }
5011         LDKMessageSendEvent* operator &() { return &self; }
5012         LDKMessageSendEvent* operator ->() { return &self; }
5013         const LDKMessageSendEvent* operator &() const { return &self; }
5014         const LDKMessageSendEvent* operator ->() const { return &self; }
5015 };
5016 class MessageSendEventsProvider {
5017 private:
5018         LDKMessageSendEventsProvider self;
5019 public:
5020         MessageSendEventsProvider(const MessageSendEventsProvider&) = delete;
5021         MessageSendEventsProvider(MessageSendEventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEventsProvider)); }
5022         MessageSendEventsProvider(LDKMessageSendEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEventsProvider)); }
5023         operator LDKMessageSendEventsProvider() && { LDKMessageSendEventsProvider res = self; memset(&self, 0, sizeof(LDKMessageSendEventsProvider)); return res; }
5024         ~MessageSendEventsProvider() { MessageSendEventsProvider_free(self); }
5025         MessageSendEventsProvider& operator=(MessageSendEventsProvider&& o) { MessageSendEventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEventsProvider)); return *this; }
5026         LDKMessageSendEventsProvider* operator &() { return &self; }
5027         LDKMessageSendEventsProvider* operator ->() { return &self; }
5028         const LDKMessageSendEventsProvider* operator &() const { return &self; }
5029         const LDKMessageSendEventsProvider* operator ->() const { return &self; }
5030         /**
5031          *  Gets the list of pending events which were generated by previous actions, clearing the list
5032          *  in the process.
5033          */
5034         inline LDK::CVec_MessageSendEventZ get_and_clear_pending_msg_events();
5035 };
5036 class EventsProvider {
5037 private:
5038         LDKEventsProvider self;
5039 public:
5040         EventsProvider(const EventsProvider&) = delete;
5041         EventsProvider(EventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(EventsProvider)); }
5042         EventsProvider(LDKEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventsProvider)); }
5043         operator LDKEventsProvider() && { LDKEventsProvider res = self; memset(&self, 0, sizeof(LDKEventsProvider)); return res; }
5044         ~EventsProvider() { EventsProvider_free(self); }
5045         EventsProvider& operator=(EventsProvider&& o) { EventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(EventsProvider)); return *this; }
5046         LDKEventsProvider* operator &() { return &self; }
5047         LDKEventsProvider* operator ->() { return &self; }
5048         const LDKEventsProvider* operator &() const { return &self; }
5049         const LDKEventsProvider* operator ->() const { return &self; }
5050         /**
5051          *  Processes any events generated since the last call using the given event handler.
5052          *
5053          *  See the trait-level documentation for requirements.
5054          */
5055         inline void process_pending_events(struct LDKEventHandler handler);
5056 };
5057 class EventHandler {
5058 private:
5059         LDKEventHandler self;
5060 public:
5061         EventHandler(const EventHandler&) = delete;
5062         EventHandler(EventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(EventHandler)); }
5063         EventHandler(LDKEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventHandler)); }
5064         operator LDKEventHandler() && { LDKEventHandler res = self; memset(&self, 0, sizeof(LDKEventHandler)); return res; }
5065         ~EventHandler() { EventHandler_free(self); }
5066         EventHandler& operator=(EventHandler&& o) { EventHandler_free(self); self = o.self; memset(&o, 0, sizeof(EventHandler)); return *this; }
5067         LDKEventHandler* operator &() { return &self; }
5068         LDKEventHandler* operator ->() { return &self; }
5069         const LDKEventHandler* operator &() const { return &self; }
5070         const LDKEventHandler* operator ->() const { return &self; }
5071         /**
5072          *  Handles the given [`Event`].
5073          *
5074          *  See [`EventsProvider`] for details that must be considered when implementing this method.
5075          */
5076         inline void handle_event(struct LDKEvent event);
5077 };
5078 class Bolt11ParseError {
5079 private:
5080         LDKBolt11ParseError self;
5081 public:
5082         Bolt11ParseError(const Bolt11ParseError&) = delete;
5083         Bolt11ParseError(Bolt11ParseError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11ParseError)); }
5084         Bolt11ParseError(LDKBolt11ParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11ParseError)); }
5085         operator LDKBolt11ParseError() && { LDKBolt11ParseError res = self; memset(&self, 0, sizeof(LDKBolt11ParseError)); return res; }
5086         ~Bolt11ParseError() { Bolt11ParseError_free(self); }
5087         Bolt11ParseError& operator=(Bolt11ParseError&& o) { Bolt11ParseError_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11ParseError)); return *this; }
5088         LDKBolt11ParseError* operator &() { return &self; }
5089         LDKBolt11ParseError* operator ->() { return &self; }
5090         const LDKBolt11ParseError* operator &() const { return &self; }
5091         const LDKBolt11ParseError* operator ->() const { return &self; }
5092 };
5093 class ParseOrSemanticError {
5094 private:
5095         LDKParseOrSemanticError self;
5096 public:
5097         ParseOrSemanticError(const ParseOrSemanticError&) = delete;
5098         ParseOrSemanticError(ParseOrSemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(ParseOrSemanticError)); }
5099         ParseOrSemanticError(LDKParseOrSemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKParseOrSemanticError)); }
5100         operator LDKParseOrSemanticError() && { LDKParseOrSemanticError res = self; memset(&self, 0, sizeof(LDKParseOrSemanticError)); return res; }
5101         ~ParseOrSemanticError() { ParseOrSemanticError_free(self); }
5102         ParseOrSemanticError& operator=(ParseOrSemanticError&& o) { ParseOrSemanticError_free(self); self = o.self; memset(&o, 0, sizeof(ParseOrSemanticError)); return *this; }
5103         LDKParseOrSemanticError* operator &() { return &self; }
5104         LDKParseOrSemanticError* operator ->() { return &self; }
5105         const LDKParseOrSemanticError* operator &() const { return &self; }
5106         const LDKParseOrSemanticError* operator ->() const { return &self; }
5107 };
5108 class Bolt11Invoice {
5109 private:
5110         LDKBolt11Invoice self;
5111 public:
5112         Bolt11Invoice(const Bolt11Invoice&) = delete;
5113         Bolt11Invoice(Bolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11Invoice)); }
5114         Bolt11Invoice(LDKBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11Invoice)); }
5115         operator LDKBolt11Invoice() && { LDKBolt11Invoice res = self; memset(&self, 0, sizeof(LDKBolt11Invoice)); return res; }
5116         ~Bolt11Invoice() { Bolt11Invoice_free(self); }
5117         Bolt11Invoice& operator=(Bolt11Invoice&& o) { Bolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11Invoice)); return *this; }
5118         LDKBolt11Invoice* operator &() { return &self; }
5119         LDKBolt11Invoice* operator ->() { return &self; }
5120         const LDKBolt11Invoice* operator &() const { return &self; }
5121         const LDKBolt11Invoice* operator ->() const { return &self; }
5122 };
5123 class SignedRawBolt11Invoice {
5124 private:
5125         LDKSignedRawBolt11Invoice self;
5126 public:
5127         SignedRawBolt11Invoice(const SignedRawBolt11Invoice&) = delete;
5128         SignedRawBolt11Invoice(SignedRawBolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(SignedRawBolt11Invoice)); }
5129         SignedRawBolt11Invoice(LDKSignedRawBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignedRawBolt11Invoice)); }
5130         operator LDKSignedRawBolt11Invoice() && { LDKSignedRawBolt11Invoice res = self; memset(&self, 0, sizeof(LDKSignedRawBolt11Invoice)); return res; }
5131         ~SignedRawBolt11Invoice() { SignedRawBolt11Invoice_free(self); }
5132         SignedRawBolt11Invoice& operator=(SignedRawBolt11Invoice&& o) { SignedRawBolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(SignedRawBolt11Invoice)); return *this; }
5133         LDKSignedRawBolt11Invoice* operator &() { return &self; }
5134         LDKSignedRawBolt11Invoice* operator ->() { return &self; }
5135         const LDKSignedRawBolt11Invoice* operator &() const { return &self; }
5136         const LDKSignedRawBolt11Invoice* operator ->() const { return &self; }
5137 };
5138 class RawBolt11Invoice {
5139 private:
5140         LDKRawBolt11Invoice self;
5141 public:
5142         RawBolt11Invoice(const RawBolt11Invoice&) = delete;
5143         RawBolt11Invoice(RawBolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(RawBolt11Invoice)); }
5144         RawBolt11Invoice(LDKRawBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawBolt11Invoice)); }
5145         operator LDKRawBolt11Invoice() && { LDKRawBolt11Invoice res = self; memset(&self, 0, sizeof(LDKRawBolt11Invoice)); return res; }
5146         ~RawBolt11Invoice() { RawBolt11Invoice_free(self); }
5147         RawBolt11Invoice& operator=(RawBolt11Invoice&& o) { RawBolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(RawBolt11Invoice)); return *this; }
5148         LDKRawBolt11Invoice* operator &() { return &self; }
5149         LDKRawBolt11Invoice* operator ->() { return &self; }
5150         const LDKRawBolt11Invoice* operator &() const { return &self; }
5151         const LDKRawBolt11Invoice* operator ->() const { return &self; }
5152 };
5153 class RawDataPart {
5154 private:
5155         LDKRawDataPart self;
5156 public:
5157         RawDataPart(const RawDataPart&) = delete;
5158         RawDataPart(RawDataPart&& o) : self(o.self) { memset(&o, 0, sizeof(RawDataPart)); }
5159         RawDataPart(LDKRawDataPart&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawDataPart)); }
5160         operator LDKRawDataPart() && { LDKRawDataPart res = self; memset(&self, 0, sizeof(LDKRawDataPart)); return res; }
5161         ~RawDataPart() { RawDataPart_free(self); }
5162         RawDataPart& operator=(RawDataPart&& o) { RawDataPart_free(self); self = o.self; memset(&o, 0, sizeof(RawDataPart)); return *this; }
5163         LDKRawDataPart* operator &() { return &self; }
5164         LDKRawDataPart* operator ->() { return &self; }
5165         const LDKRawDataPart* operator &() const { return &self; }
5166         const LDKRawDataPart* operator ->() const { return &self; }
5167 };
5168 class PositiveTimestamp {
5169 private:
5170         LDKPositiveTimestamp self;
5171 public:
5172         PositiveTimestamp(const PositiveTimestamp&) = delete;
5173         PositiveTimestamp(PositiveTimestamp&& o) : self(o.self) { memset(&o, 0, sizeof(PositiveTimestamp)); }
5174         PositiveTimestamp(LDKPositiveTimestamp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPositiveTimestamp)); }
5175         operator LDKPositiveTimestamp() && { LDKPositiveTimestamp res = self; memset(&self, 0, sizeof(LDKPositiveTimestamp)); return res; }
5176         ~PositiveTimestamp() { PositiveTimestamp_free(self); }
5177         PositiveTimestamp& operator=(PositiveTimestamp&& o) { PositiveTimestamp_free(self); self = o.self; memset(&o, 0, sizeof(PositiveTimestamp)); return *this; }
5178         LDKPositiveTimestamp* operator &() { return &self; }
5179         LDKPositiveTimestamp* operator ->() { return &self; }
5180         const LDKPositiveTimestamp* operator &() const { return &self; }
5181         const LDKPositiveTimestamp* operator ->() const { return &self; }
5182 };
5183 class SiPrefix {
5184 private:
5185         LDKSiPrefix self;
5186 public:
5187         SiPrefix(const SiPrefix&) = delete;
5188         SiPrefix(SiPrefix&& o) : self(o.self) { memset(&o, 0, sizeof(SiPrefix)); }
5189         SiPrefix(LDKSiPrefix&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSiPrefix)); }
5190         operator LDKSiPrefix() && { LDKSiPrefix res = self; memset(&self, 0, sizeof(LDKSiPrefix)); return res; }
5191         SiPrefix& operator=(SiPrefix&& o) { self = o.self; memset(&o, 0, sizeof(SiPrefix)); return *this; }
5192         LDKSiPrefix* operator &() { return &self; }
5193         LDKSiPrefix* operator ->() { return &self; }
5194         const LDKSiPrefix* operator &() const { return &self; }
5195         const LDKSiPrefix* operator ->() const { return &self; }
5196 };
5197 class Currency {
5198 private:
5199         LDKCurrency self;
5200 public:
5201         Currency(const Currency&) = delete;
5202         Currency(Currency&& o) : self(o.self) { memset(&o, 0, sizeof(Currency)); }
5203         Currency(LDKCurrency&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCurrency)); }
5204         operator LDKCurrency() && { LDKCurrency res = self; memset(&self, 0, sizeof(LDKCurrency)); return res; }
5205         Currency& operator=(Currency&& o) { self = o.self; memset(&o, 0, sizeof(Currency)); return *this; }
5206         LDKCurrency* operator &() { return &self; }
5207         LDKCurrency* operator ->() { return &self; }
5208         const LDKCurrency* operator &() const { return &self; }
5209         const LDKCurrency* operator ->() const { return &self; }
5210 };
5211 class Sha256 {
5212 private:
5213         LDKSha256 self;
5214 public:
5215         Sha256(const Sha256&) = delete;
5216         Sha256(Sha256&& o) : self(o.self) { memset(&o, 0, sizeof(Sha256)); }
5217         Sha256(LDKSha256&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSha256)); }
5218         operator LDKSha256() && { LDKSha256 res = self; memset(&self, 0, sizeof(LDKSha256)); return res; }
5219         ~Sha256() { Sha256_free(self); }
5220         Sha256& operator=(Sha256&& o) { Sha256_free(self); self = o.self; memset(&o, 0, sizeof(Sha256)); return *this; }
5221         LDKSha256* operator &() { return &self; }
5222         LDKSha256* operator ->() { return &self; }
5223         const LDKSha256* operator &() const { return &self; }
5224         const LDKSha256* operator ->() const { return &self; }
5225 };
5226 class Description {
5227 private:
5228         LDKDescription self;
5229 public:
5230         Description(const Description&) = delete;
5231         Description(Description&& o) : self(o.self) { memset(&o, 0, sizeof(Description)); }
5232         Description(LDKDescription&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDescription)); }
5233         operator LDKDescription() && { LDKDescription res = self; memset(&self, 0, sizeof(LDKDescription)); return res; }
5234         ~Description() { Description_free(self); }
5235         Description& operator=(Description&& o) { Description_free(self); self = o.self; memset(&o, 0, sizeof(Description)); return *this; }
5236         LDKDescription* operator &() { return &self; }
5237         LDKDescription* operator ->() { return &self; }
5238         const LDKDescription* operator &() const { return &self; }
5239         const LDKDescription* operator ->() const { return &self; }
5240 };
5241 class PayeePubKey {
5242 private:
5243         LDKPayeePubKey self;
5244 public:
5245         PayeePubKey(const PayeePubKey&) = delete;
5246         PayeePubKey(PayeePubKey&& o) : self(o.self) { memset(&o, 0, sizeof(PayeePubKey)); }
5247         PayeePubKey(LDKPayeePubKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayeePubKey)); }
5248         operator LDKPayeePubKey() && { LDKPayeePubKey res = self; memset(&self, 0, sizeof(LDKPayeePubKey)); return res; }
5249         ~PayeePubKey() { PayeePubKey_free(self); }
5250         PayeePubKey& operator=(PayeePubKey&& o) { PayeePubKey_free(self); self = o.self; memset(&o, 0, sizeof(PayeePubKey)); return *this; }
5251         LDKPayeePubKey* operator &() { return &self; }
5252         LDKPayeePubKey* operator ->() { return &self; }
5253         const LDKPayeePubKey* operator &() const { return &self; }
5254         const LDKPayeePubKey* operator ->() const { return &self; }
5255 };
5256 class ExpiryTime {
5257 private:
5258         LDKExpiryTime self;
5259 public:
5260         ExpiryTime(const ExpiryTime&) = delete;
5261         ExpiryTime(ExpiryTime&& o) : self(o.self) { memset(&o, 0, sizeof(ExpiryTime)); }
5262         ExpiryTime(LDKExpiryTime&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpiryTime)); }
5263         operator LDKExpiryTime() && { LDKExpiryTime res = self; memset(&self, 0, sizeof(LDKExpiryTime)); return res; }
5264         ~ExpiryTime() { ExpiryTime_free(self); }
5265         ExpiryTime& operator=(ExpiryTime&& o) { ExpiryTime_free(self); self = o.self; memset(&o, 0, sizeof(ExpiryTime)); return *this; }
5266         LDKExpiryTime* operator &() { return &self; }
5267         LDKExpiryTime* operator ->() { return &self; }
5268         const LDKExpiryTime* operator &() const { return &self; }
5269         const LDKExpiryTime* operator ->() const { return &self; }
5270 };
5271 class MinFinalCltvExpiryDelta {
5272 private:
5273         LDKMinFinalCltvExpiryDelta self;
5274 public:
5275         MinFinalCltvExpiryDelta(const MinFinalCltvExpiryDelta&) = delete;
5276         MinFinalCltvExpiryDelta(MinFinalCltvExpiryDelta&& o) : self(o.self) { memset(&o, 0, sizeof(MinFinalCltvExpiryDelta)); }
5277         MinFinalCltvExpiryDelta(LDKMinFinalCltvExpiryDelta&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMinFinalCltvExpiryDelta)); }
5278         operator LDKMinFinalCltvExpiryDelta() && { LDKMinFinalCltvExpiryDelta res = self; memset(&self, 0, sizeof(LDKMinFinalCltvExpiryDelta)); return res; }
5279         ~MinFinalCltvExpiryDelta() { MinFinalCltvExpiryDelta_free(self); }
5280         MinFinalCltvExpiryDelta& operator=(MinFinalCltvExpiryDelta&& o) { MinFinalCltvExpiryDelta_free(self); self = o.self; memset(&o, 0, sizeof(MinFinalCltvExpiryDelta)); return *this; }
5281         LDKMinFinalCltvExpiryDelta* operator &() { return &self; }
5282         LDKMinFinalCltvExpiryDelta* operator ->() { return &self; }
5283         const LDKMinFinalCltvExpiryDelta* operator &() const { return &self; }
5284         const LDKMinFinalCltvExpiryDelta* operator ->() const { return &self; }
5285 };
5286 class Fallback {
5287 private:
5288         LDKFallback self;
5289 public:
5290         Fallback(const Fallback&) = delete;
5291         Fallback(Fallback&& o) : self(o.self) { memset(&o, 0, sizeof(Fallback)); }
5292         Fallback(LDKFallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFallback)); }
5293         operator LDKFallback() && { LDKFallback res = self; memset(&self, 0, sizeof(LDKFallback)); return res; }
5294         ~Fallback() { Fallback_free(self); }
5295         Fallback& operator=(Fallback&& o) { Fallback_free(self); self = o.self; memset(&o, 0, sizeof(Fallback)); return *this; }
5296         LDKFallback* operator &() { return &self; }
5297         LDKFallback* operator ->() { return &self; }
5298         const LDKFallback* operator &() const { return &self; }
5299         const LDKFallback* operator ->() const { return &self; }
5300 };
5301 class Bolt11InvoiceSignature {
5302 private:
5303         LDKBolt11InvoiceSignature self;
5304 public:
5305         Bolt11InvoiceSignature(const Bolt11InvoiceSignature&) = delete;
5306         Bolt11InvoiceSignature(Bolt11InvoiceSignature&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11InvoiceSignature)); }
5307         Bolt11InvoiceSignature(LDKBolt11InvoiceSignature&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11InvoiceSignature)); }
5308         operator LDKBolt11InvoiceSignature() && { LDKBolt11InvoiceSignature res = self; memset(&self, 0, sizeof(LDKBolt11InvoiceSignature)); return res; }
5309         ~Bolt11InvoiceSignature() { Bolt11InvoiceSignature_free(self); }
5310         Bolt11InvoiceSignature& operator=(Bolt11InvoiceSignature&& o) { Bolt11InvoiceSignature_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11InvoiceSignature)); return *this; }
5311         LDKBolt11InvoiceSignature* operator &() { return &self; }
5312         LDKBolt11InvoiceSignature* operator ->() { return &self; }
5313         const LDKBolt11InvoiceSignature* operator &() const { return &self; }
5314         const LDKBolt11InvoiceSignature* operator ->() const { return &self; }
5315 };
5316 class PrivateRoute {
5317 private:
5318         LDKPrivateRoute self;
5319 public:
5320         PrivateRoute(const PrivateRoute&) = delete;
5321         PrivateRoute(PrivateRoute&& o) : self(o.self) { memset(&o, 0, sizeof(PrivateRoute)); }
5322         PrivateRoute(LDKPrivateRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrivateRoute)); }
5323         operator LDKPrivateRoute() && { LDKPrivateRoute res = self; memset(&self, 0, sizeof(LDKPrivateRoute)); return res; }
5324         ~PrivateRoute() { PrivateRoute_free(self); }
5325         PrivateRoute& operator=(PrivateRoute&& o) { PrivateRoute_free(self); self = o.self; memset(&o, 0, sizeof(PrivateRoute)); return *this; }
5326         LDKPrivateRoute* operator &() { return &self; }
5327         LDKPrivateRoute* operator ->() { return &self; }
5328         const LDKPrivateRoute* operator &() const { return &self; }
5329         const LDKPrivateRoute* operator ->() const { return &self; }
5330 };
5331 class CreationError {
5332 private:
5333         LDKCreationError self;
5334 public:
5335         CreationError(const CreationError&) = delete;
5336         CreationError(CreationError&& o) : self(o.self) { memset(&o, 0, sizeof(CreationError)); }
5337         CreationError(LDKCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCreationError)); }
5338         operator LDKCreationError() && { LDKCreationError res = self; memset(&self, 0, sizeof(LDKCreationError)); return res; }
5339         CreationError& operator=(CreationError&& o) { self = o.self; memset(&o, 0, sizeof(CreationError)); return *this; }
5340         LDKCreationError* operator &() { return &self; }
5341         LDKCreationError* operator ->() { return &self; }
5342         const LDKCreationError* operator &() const { return &self; }
5343         const LDKCreationError* operator ->() const { return &self; }
5344 };
5345 class Bolt11SemanticError {
5346 private:
5347         LDKBolt11SemanticError self;
5348 public:
5349         Bolt11SemanticError(const Bolt11SemanticError&) = delete;
5350         Bolt11SemanticError(Bolt11SemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11SemanticError)); }
5351         Bolt11SemanticError(LDKBolt11SemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11SemanticError)); }
5352         operator LDKBolt11SemanticError() && { LDKBolt11SemanticError res = self; memset(&self, 0, sizeof(LDKBolt11SemanticError)); return res; }
5353         Bolt11SemanticError& operator=(Bolt11SemanticError&& o) { self = o.self; memset(&o, 0, sizeof(Bolt11SemanticError)); return *this; }
5354         LDKBolt11SemanticError* operator &() { return &self; }
5355         LDKBolt11SemanticError* operator ->() { return &self; }
5356         const LDKBolt11SemanticError* operator &() const { return &self; }
5357         const LDKBolt11SemanticError* operator ->() const { return &self; }
5358 };
5359 class SignOrCreationError {
5360 private:
5361         LDKSignOrCreationError self;
5362 public:
5363         SignOrCreationError(const SignOrCreationError&) = delete;
5364         SignOrCreationError(SignOrCreationError&& o) : self(o.self) { memset(&o, 0, sizeof(SignOrCreationError)); }
5365         SignOrCreationError(LDKSignOrCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignOrCreationError)); }
5366         operator LDKSignOrCreationError() && { LDKSignOrCreationError res = self; memset(&self, 0, sizeof(LDKSignOrCreationError)); return res; }
5367         ~SignOrCreationError() { SignOrCreationError_free(self); }
5368         SignOrCreationError& operator=(SignOrCreationError&& o) { SignOrCreationError_free(self); self = o.self; memset(&o, 0, sizeof(SignOrCreationError)); return *this; }
5369         LDKSignOrCreationError* operator &() { return &self; }
5370         LDKSignOrCreationError* operator ->() { return &self; }
5371         const LDKSignOrCreationError* operator &() const { return &self; }
5372         const LDKSignOrCreationError* operator ->() const { return &self; }
5373 };
5374 class OutPoint {
5375 private:
5376         LDKOutPoint self;
5377 public:
5378         OutPoint(const OutPoint&) = delete;
5379         OutPoint(OutPoint&& o) : self(o.self) { memset(&o, 0, sizeof(OutPoint)); }
5380         OutPoint(LDKOutPoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutPoint)); }
5381         operator LDKOutPoint() && { LDKOutPoint res = self; memset(&self, 0, sizeof(LDKOutPoint)); return res; }
5382         ~OutPoint() { OutPoint_free(self); }
5383         OutPoint& operator=(OutPoint&& o) { OutPoint_free(self); self = o.self; memset(&o, 0, sizeof(OutPoint)); return *this; }
5384         LDKOutPoint* operator &() { return &self; }
5385         LDKOutPoint* operator ->() { return &self; }
5386         const LDKOutPoint* operator &() const { return &self; }
5387         const LDKOutPoint* operator ->() const { return &self; }
5388 };
5389 class BigSize {
5390 private:
5391         LDKBigSize self;
5392 public:
5393         BigSize(const BigSize&) = delete;
5394         BigSize(BigSize&& o) : self(o.self) { memset(&o, 0, sizeof(BigSize)); }
5395         BigSize(LDKBigSize&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBigSize)); }
5396         operator LDKBigSize() && { LDKBigSize res = self; memset(&self, 0, sizeof(LDKBigSize)); return res; }
5397         ~BigSize() { BigSize_free(self); }
5398         BigSize& operator=(BigSize&& o) { BigSize_free(self); self = o.self; memset(&o, 0, sizeof(BigSize)); return *this; }
5399         LDKBigSize* operator &() { return &self; }
5400         LDKBigSize* operator ->() { return &self; }
5401         const LDKBigSize* operator &() const { return &self; }
5402         const LDKBigSize* operator ->() const { return &self; }
5403 };
5404 class Hostname {
5405 private:
5406         LDKHostname self;
5407 public:
5408         Hostname(const Hostname&) = delete;
5409         Hostname(Hostname&& o) : self(o.self) { memset(&o, 0, sizeof(Hostname)); }
5410         Hostname(LDKHostname&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHostname)); }
5411         operator LDKHostname() && { LDKHostname res = self; memset(&self, 0, sizeof(LDKHostname)); return res; }
5412         ~Hostname() { Hostname_free(self); }
5413         Hostname& operator=(Hostname&& o) { Hostname_free(self); self = o.self; memset(&o, 0, sizeof(Hostname)); return *this; }
5414         LDKHostname* operator &() { return &self; }
5415         LDKHostname* operator ->() { return &self; }
5416         const LDKHostname* operator &() const { return &self; }
5417         const LDKHostname* operator ->() const { return &self; }
5418 };
5419 class TransactionU16LenLimited {
5420 private:
5421         LDKTransactionU16LenLimited self;
5422 public:
5423         TransactionU16LenLimited(const TransactionU16LenLimited&) = delete;
5424         TransactionU16LenLimited(TransactionU16LenLimited&& o) : self(o.self) { memset(&o, 0, sizeof(TransactionU16LenLimited)); }
5425         TransactionU16LenLimited(LDKTransactionU16LenLimited&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTransactionU16LenLimited)); }
5426         operator LDKTransactionU16LenLimited() && { LDKTransactionU16LenLimited res = self; memset(&self, 0, sizeof(LDKTransactionU16LenLimited)); return res; }
5427         ~TransactionU16LenLimited() { TransactionU16LenLimited_free(self); }
5428         TransactionU16LenLimited& operator=(TransactionU16LenLimited&& o) { TransactionU16LenLimited_free(self); self = o.self; memset(&o, 0, sizeof(TransactionU16LenLimited)); return *this; }
5429         LDKTransactionU16LenLimited* operator &() { return &self; }
5430         LDKTransactionU16LenLimited* operator ->() { return &self; }
5431         const LDKTransactionU16LenLimited* operator &() const { return &self; }
5432         const LDKTransactionU16LenLimited* operator ->() const { return &self; }
5433 };
5434 class UntrustedString {
5435 private:
5436         LDKUntrustedString self;
5437 public:
5438         UntrustedString(const UntrustedString&) = delete;
5439         UntrustedString(UntrustedString&& o) : self(o.self) { memset(&o, 0, sizeof(UntrustedString)); }
5440         UntrustedString(LDKUntrustedString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUntrustedString)); }
5441         operator LDKUntrustedString() && { LDKUntrustedString res = self; memset(&self, 0, sizeof(LDKUntrustedString)); return res; }
5442         ~UntrustedString() { UntrustedString_free(self); }
5443         UntrustedString& operator=(UntrustedString&& o) { UntrustedString_free(self); self = o.self; memset(&o, 0, sizeof(UntrustedString)); return *this; }
5444         LDKUntrustedString* operator &() { return &self; }
5445         LDKUntrustedString* operator ->() { return &self; }
5446         const LDKUntrustedString* operator &() const { return &self; }
5447         const LDKUntrustedString* operator ->() const { return &self; }
5448 };
5449 class PrintableString {
5450 private:
5451         LDKPrintableString self;
5452 public:
5453         PrintableString(const PrintableString&) = delete;
5454         PrintableString(PrintableString&& o) : self(o.self) { memset(&o, 0, sizeof(PrintableString)); }
5455         PrintableString(LDKPrintableString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrintableString)); }
5456         operator LDKPrintableString() && { LDKPrintableString res = self; memset(&self, 0, sizeof(LDKPrintableString)); return res; }
5457         ~PrintableString() { PrintableString_free(self); }
5458         PrintableString& operator=(PrintableString&& o) { PrintableString_free(self); self = o.self; memset(&o, 0, sizeof(PrintableString)); return *this; }
5459         LDKPrintableString* operator &() { return &self; }
5460         LDKPrintableString* operator ->() { return &self; }
5461         const LDKPrintableString* operator &() const { return &self; }
5462         const LDKPrintableString* operator ->() const { return &self; }
5463 };
5464 class CustomMessageReader {
5465 private:
5466         LDKCustomMessageReader self;
5467 public:
5468         CustomMessageReader(const CustomMessageReader&) = delete;
5469         CustomMessageReader(CustomMessageReader&& o) : self(o.self) { memset(&o, 0, sizeof(CustomMessageReader)); }
5470         CustomMessageReader(LDKCustomMessageReader&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomMessageReader)); }
5471         operator LDKCustomMessageReader() && { LDKCustomMessageReader res = self; memset(&self, 0, sizeof(LDKCustomMessageReader)); return res; }
5472         ~CustomMessageReader() { CustomMessageReader_free(self); }
5473         CustomMessageReader& operator=(CustomMessageReader&& o) { CustomMessageReader_free(self); self = o.self; memset(&o, 0, sizeof(CustomMessageReader)); return *this; }
5474         LDKCustomMessageReader* operator &() { return &self; }
5475         LDKCustomMessageReader* operator ->() { return &self; }
5476         const LDKCustomMessageReader* operator &() const { return &self; }
5477         const LDKCustomMessageReader* operator ->() const { return &self; }
5478         /**
5479          *  Decodes a custom message to `CustomMessageType`. If the given message type is known to the
5480          *  implementation and the message could be decoded, must return `Ok(Some(message))`. If the
5481          *  message type is unknown to the implementation, must return `Ok(None)`. If a decoding error
5482          *  occur, must return `Err(DecodeError::X)` where `X` details the encountered error.
5483          */
5484         inline LDK::CResult_COption_TypeZDecodeErrorZ read(uint16_t message_type, struct LDKu8slice buffer);
5485 };
5486 class Type {
5487 private:
5488         LDKType self;
5489 public:
5490         Type(const Type&) = delete;
5491         Type(Type&& o) : self(o.self) { memset(&o, 0, sizeof(Type)); }
5492         Type(LDKType&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKType)); }
5493         operator LDKType() && { LDKType res = self; memset(&self, 0, sizeof(LDKType)); return res; }
5494         ~Type() { Type_free(self); }
5495         Type& operator=(Type&& o) { Type_free(self); self = o.self; memset(&o, 0, sizeof(Type)); return *this; }
5496         LDKType* operator &() { return &self; }
5497         LDKType* operator ->() { return &self; }
5498         const LDKType* operator &() const { return &self; }
5499         const LDKType* operator ->() const { return &self; }
5500         /**
5501          *  Returns the type identifying the message payload.
5502          */
5503         inline uint16_t type_id();
5504         /**
5505          * Return a human-readable "debug" string describing this object
5506          */
5507         inline LDK::Str debug_str();
5508 };
5509 class ForwardNode {
5510 private:
5511         LDKForwardNode self;
5512 public:
5513         ForwardNode(const ForwardNode&) = delete;
5514         ForwardNode(ForwardNode&& o) : self(o.self) { memset(&o, 0, sizeof(ForwardNode)); }
5515         ForwardNode(LDKForwardNode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKForwardNode)); }
5516         operator LDKForwardNode() && { LDKForwardNode res = self; memset(&self, 0, sizeof(LDKForwardNode)); return res; }
5517         ~ForwardNode() { ForwardNode_free(self); }
5518         ForwardNode& operator=(ForwardNode&& o) { ForwardNode_free(self); self = o.self; memset(&o, 0, sizeof(ForwardNode)); return *this; }
5519         LDKForwardNode* operator &() { return &self; }
5520         LDKForwardNode* operator ->() { return &self; }
5521         const LDKForwardNode* operator &() const { return &self; }
5522         const LDKForwardNode* operator ->() const { return &self; }
5523 };
5524 class ForwardTlvs {
5525 private:
5526         LDKForwardTlvs self;
5527 public:
5528         ForwardTlvs(const ForwardTlvs&) = delete;
5529         ForwardTlvs(ForwardTlvs&& o) : self(o.self) { memset(&o, 0, sizeof(ForwardTlvs)); }
5530         ForwardTlvs(LDKForwardTlvs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKForwardTlvs)); }
5531         operator LDKForwardTlvs() && { LDKForwardTlvs res = self; memset(&self, 0, sizeof(LDKForwardTlvs)); return res; }
5532         ~ForwardTlvs() { ForwardTlvs_free(self); }
5533         ForwardTlvs& operator=(ForwardTlvs&& o) { ForwardTlvs_free(self); self = o.self; memset(&o, 0, sizeof(ForwardTlvs)); return *this; }
5534         LDKForwardTlvs* operator &() { return &self; }
5535         LDKForwardTlvs* operator ->() { return &self; }
5536         const LDKForwardTlvs* operator &() const { return &self; }
5537         const LDKForwardTlvs* operator ->() const { return &self; }
5538 };
5539 class ReceiveTlvs {
5540 private:
5541         LDKReceiveTlvs self;
5542 public:
5543         ReceiveTlvs(const ReceiveTlvs&) = delete;
5544         ReceiveTlvs(ReceiveTlvs&& o) : self(o.self) { memset(&o, 0, sizeof(ReceiveTlvs)); }
5545         ReceiveTlvs(LDKReceiveTlvs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReceiveTlvs)); }
5546         operator LDKReceiveTlvs() && { LDKReceiveTlvs res = self; memset(&self, 0, sizeof(LDKReceiveTlvs)); return res; }
5547         ~ReceiveTlvs() { ReceiveTlvs_free(self); }
5548         ReceiveTlvs& operator=(ReceiveTlvs&& o) { ReceiveTlvs_free(self); self = o.self; memset(&o, 0, sizeof(ReceiveTlvs)); return *this; }
5549         LDKReceiveTlvs* operator &() { return &self; }
5550         LDKReceiveTlvs* operator ->() { return &self; }
5551         const LDKReceiveTlvs* operator &() const { return &self; }
5552         const LDKReceiveTlvs* operator ->() const { return &self; }
5553 };
5554 class PaymentRelay {
5555 private:
5556         LDKPaymentRelay self;
5557 public:
5558         PaymentRelay(const PaymentRelay&) = delete;
5559         PaymentRelay(PaymentRelay&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentRelay)); }
5560         PaymentRelay(LDKPaymentRelay&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentRelay)); }
5561         operator LDKPaymentRelay() && { LDKPaymentRelay res = self; memset(&self, 0, sizeof(LDKPaymentRelay)); return res; }
5562         ~PaymentRelay() { PaymentRelay_free(self); }
5563         PaymentRelay& operator=(PaymentRelay&& o) { PaymentRelay_free(self); self = o.self; memset(&o, 0, sizeof(PaymentRelay)); return *this; }
5564         LDKPaymentRelay* operator &() { return &self; }
5565         LDKPaymentRelay* operator ->() { return &self; }
5566         const LDKPaymentRelay* operator &() const { return &self; }
5567         const LDKPaymentRelay* operator ->() const { return &self; }
5568 };
5569 class PaymentConstraints {
5570 private:
5571         LDKPaymentConstraints self;
5572 public:
5573         PaymentConstraints(const PaymentConstraints&) = delete;
5574         PaymentConstraints(PaymentConstraints&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentConstraints)); }
5575         PaymentConstraints(LDKPaymentConstraints&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentConstraints)); }
5576         operator LDKPaymentConstraints() && { LDKPaymentConstraints res = self; memset(&self, 0, sizeof(LDKPaymentConstraints)); return res; }
5577         ~PaymentConstraints() { PaymentConstraints_free(self); }
5578         PaymentConstraints& operator=(PaymentConstraints&& o) { PaymentConstraints_free(self); self = o.self; memset(&o, 0, sizeof(PaymentConstraints)); return *this; }
5579         LDKPaymentConstraints* operator &() { return &self; }
5580         LDKPaymentConstraints* operator ->() { return &self; }
5581         const LDKPaymentConstraints* operator &() const { return &self; }
5582         const LDKPaymentConstraints* operator ->() const { return &self; }
5583 };
5584 class PaymentError {
5585 private:
5586         LDKPaymentError self;
5587 public:
5588         PaymentError(const PaymentError&) = delete;
5589         PaymentError(PaymentError&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentError)); }
5590         PaymentError(LDKPaymentError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentError)); }
5591         operator LDKPaymentError() && { LDKPaymentError res = self; memset(&self, 0, sizeof(LDKPaymentError)); return res; }
5592         ~PaymentError() { PaymentError_free(self); }
5593         PaymentError& operator=(PaymentError&& o) { PaymentError_free(self); self = o.self; memset(&o, 0, sizeof(PaymentError)); return *this; }
5594         LDKPaymentError* operator &() { return &self; }
5595         LDKPaymentError* operator ->() { return &self; }
5596         const LDKPaymentError* operator &() const { return &self; }
5597         const LDKPaymentError* operator ->() const { return &self; }
5598 };
5599 class ProbingError {
5600 private:
5601         LDKProbingError self;
5602 public:
5603         ProbingError(const ProbingError&) = delete;
5604         ProbingError(ProbingError&& o) : self(o.self) { memset(&o, 0, sizeof(ProbingError)); }
5605         ProbingError(LDKProbingError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbingError)); }
5606         operator LDKProbingError() && { LDKProbingError res = self; memset(&self, 0, sizeof(LDKProbingError)); return res; }
5607         ~ProbingError() { ProbingError_free(self); }
5608         ProbingError& operator=(ProbingError&& o) { ProbingError_free(self); self = o.self; memset(&o, 0, sizeof(ProbingError)); return *this; }
5609         LDKProbingError* operator &() { return &self; }
5610         LDKProbingError* operator ->() { return &self; }
5611         const LDKProbingError* operator &() const { return &self; }
5612         const LDKProbingError* operator ->() const { return &self; }
5613 };
5614 class UtxoLookupError {
5615 private:
5616         LDKUtxoLookupError self;
5617 public:
5618         UtxoLookupError(const UtxoLookupError&) = delete;
5619         UtxoLookupError(UtxoLookupError&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoLookupError)); }
5620         UtxoLookupError(LDKUtxoLookupError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoLookupError)); }
5621         operator LDKUtxoLookupError() && { LDKUtxoLookupError res = self; memset(&self, 0, sizeof(LDKUtxoLookupError)); return res; }
5622         UtxoLookupError& operator=(UtxoLookupError&& o) { self = o.self; memset(&o, 0, sizeof(UtxoLookupError)); return *this; }
5623         LDKUtxoLookupError* operator &() { return &self; }
5624         LDKUtxoLookupError* operator ->() { return &self; }
5625         const LDKUtxoLookupError* operator &() const { return &self; }
5626         const LDKUtxoLookupError* operator ->() const { return &self; }
5627 };
5628 class UtxoResult {
5629 private:
5630         LDKUtxoResult self;
5631 public:
5632         UtxoResult(const UtxoResult&) = delete;
5633         UtxoResult(UtxoResult&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoResult)); }
5634         UtxoResult(LDKUtxoResult&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoResult)); }
5635         operator LDKUtxoResult() && { LDKUtxoResult res = self; memset(&self, 0, sizeof(LDKUtxoResult)); return res; }
5636         ~UtxoResult() { UtxoResult_free(self); }
5637         UtxoResult& operator=(UtxoResult&& o) { UtxoResult_free(self); self = o.self; memset(&o, 0, sizeof(UtxoResult)); return *this; }
5638         LDKUtxoResult* operator &() { return &self; }
5639         LDKUtxoResult* operator ->() { return &self; }
5640         const LDKUtxoResult* operator &() const { return &self; }
5641         const LDKUtxoResult* operator ->() const { return &self; }
5642 };
5643 class UtxoLookup {
5644 private:
5645         LDKUtxoLookup self;
5646 public:
5647         UtxoLookup(const UtxoLookup&) = delete;
5648         UtxoLookup(UtxoLookup&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoLookup)); }
5649         UtxoLookup(LDKUtxoLookup&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoLookup)); }
5650         operator LDKUtxoLookup() && { LDKUtxoLookup res = self; memset(&self, 0, sizeof(LDKUtxoLookup)); return res; }
5651         ~UtxoLookup() { UtxoLookup_free(self); }
5652         UtxoLookup& operator=(UtxoLookup&& o) { UtxoLookup_free(self); self = o.self; memset(&o, 0, sizeof(UtxoLookup)); return *this; }
5653         LDKUtxoLookup* operator &() { return &self; }
5654         LDKUtxoLookup* operator ->() { return &self; }
5655         const LDKUtxoLookup* operator &() const { return &self; }
5656         const LDKUtxoLookup* operator ->() const { return &self; }
5657         /**
5658          *  Returns the transaction output of a funding transaction encoded by [`short_channel_id`].
5659          *  Returns an error if `chain_hash` is for a different chain or if such a transaction output is
5660          *  unknown.
5661          *
5662          *  [`short_channel_id`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#definition-of-short_channel_id
5663          */
5664         inline LDK::UtxoResult get_utxo(const uint8_t (*chain_hash)[32], uint64_t short_channel_id);
5665 };
5666 class UtxoFuture {
5667 private:
5668         LDKUtxoFuture self;
5669 public:
5670         UtxoFuture(const UtxoFuture&) = delete;
5671         UtxoFuture(UtxoFuture&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoFuture)); }
5672         UtxoFuture(LDKUtxoFuture&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoFuture)); }
5673         operator LDKUtxoFuture() && { LDKUtxoFuture res = self; memset(&self, 0, sizeof(LDKUtxoFuture)); return res; }
5674         ~UtxoFuture() { UtxoFuture_free(self); }
5675         UtxoFuture& operator=(UtxoFuture&& o) { UtxoFuture_free(self); self = o.self; memset(&o, 0, sizeof(UtxoFuture)); return *this; }
5676         LDKUtxoFuture* operator &() { return &self; }
5677         LDKUtxoFuture* operator ->() { return &self; }
5678         const LDKUtxoFuture* operator &() const { return &self; }
5679         const LDKUtxoFuture* operator ->() const { return &self; }
5680 };
5681 class OnionMessenger {
5682 private:
5683         LDKOnionMessenger self;
5684 public:
5685         OnionMessenger(const OnionMessenger&) = delete;
5686         OnionMessenger(OnionMessenger&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessenger)); }
5687         OnionMessenger(LDKOnionMessenger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessenger)); }
5688         operator LDKOnionMessenger() && { LDKOnionMessenger res = self; memset(&self, 0, sizeof(LDKOnionMessenger)); return res; }
5689         ~OnionMessenger() { OnionMessenger_free(self); }
5690         OnionMessenger& operator=(OnionMessenger&& o) { OnionMessenger_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessenger)); return *this; }
5691         LDKOnionMessenger* operator &() { return &self; }
5692         LDKOnionMessenger* operator ->() { return &self; }
5693         const LDKOnionMessenger* operator &() const { return &self; }
5694         const LDKOnionMessenger* operator ->() const { return &self; }
5695 };
5696 class MessageRouter {
5697 private:
5698         LDKMessageRouter self;
5699 public:
5700         MessageRouter(const MessageRouter&) = delete;
5701         MessageRouter(MessageRouter&& o) : self(o.self) { memset(&o, 0, sizeof(MessageRouter)); }
5702         MessageRouter(LDKMessageRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageRouter)); }
5703         operator LDKMessageRouter() && { LDKMessageRouter res = self; memset(&self, 0, sizeof(LDKMessageRouter)); return res; }
5704         ~MessageRouter() { MessageRouter_free(self); }
5705         MessageRouter& operator=(MessageRouter&& o) { MessageRouter_free(self); self = o.self; memset(&o, 0, sizeof(MessageRouter)); return *this; }
5706         LDKMessageRouter* operator &() { return &self; }
5707         LDKMessageRouter* operator ->() { return &self; }
5708         const LDKMessageRouter* operator &() const { return &self; }
5709         const LDKMessageRouter* operator ->() const { return &self; }
5710         /**
5711          *  Returns a route for sending an [`OnionMessage`] to the given [`Destination`].
5712          */
5713         inline LDK::CResult_OnionMessagePathNoneZ find_path(struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination);
5714 };
5715 class DefaultMessageRouter {
5716 private:
5717         LDKDefaultMessageRouter self;
5718 public:
5719         DefaultMessageRouter(const DefaultMessageRouter&) = delete;
5720         DefaultMessageRouter(DefaultMessageRouter&& o) : self(o.self) { memset(&o, 0, sizeof(DefaultMessageRouter)); }
5721         DefaultMessageRouter(LDKDefaultMessageRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDefaultMessageRouter)); }
5722         operator LDKDefaultMessageRouter() && { LDKDefaultMessageRouter res = self; memset(&self, 0, sizeof(LDKDefaultMessageRouter)); return res; }
5723         ~DefaultMessageRouter() { DefaultMessageRouter_free(self); }
5724         DefaultMessageRouter& operator=(DefaultMessageRouter&& o) { DefaultMessageRouter_free(self); self = o.self; memset(&o, 0, sizeof(DefaultMessageRouter)); return *this; }
5725         LDKDefaultMessageRouter* operator &() { return &self; }
5726         LDKDefaultMessageRouter* operator ->() { return &self; }
5727         const LDKDefaultMessageRouter* operator &() const { return &self; }
5728         const LDKDefaultMessageRouter* operator ->() const { return &self; }
5729 };
5730 class OnionMessagePath {
5731 private:
5732         LDKOnionMessagePath self;
5733 public:
5734         OnionMessagePath(const OnionMessagePath&) = delete;
5735         OnionMessagePath(OnionMessagePath&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessagePath)); }
5736         OnionMessagePath(LDKOnionMessagePath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessagePath)); }
5737         operator LDKOnionMessagePath() && { LDKOnionMessagePath res = self; memset(&self, 0, sizeof(LDKOnionMessagePath)); return res; }
5738         ~OnionMessagePath() { OnionMessagePath_free(self); }
5739         OnionMessagePath& operator=(OnionMessagePath&& o) { OnionMessagePath_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessagePath)); return *this; }
5740         LDKOnionMessagePath* operator &() { return &self; }
5741         LDKOnionMessagePath* operator ->() { return &self; }
5742         const LDKOnionMessagePath* operator &() const { return &self; }
5743         const LDKOnionMessagePath* operator ->() const { return &self; }
5744 };
5745 class Destination {
5746 private:
5747         LDKDestination self;
5748 public:
5749         Destination(const Destination&) = delete;
5750         Destination(Destination&& o) : self(o.self) { memset(&o, 0, sizeof(Destination)); }
5751         Destination(LDKDestination&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDestination)); }
5752         operator LDKDestination() && { LDKDestination res = self; memset(&self, 0, sizeof(LDKDestination)); return res; }
5753         ~Destination() { Destination_free(self); }
5754         Destination& operator=(Destination&& o) { Destination_free(self); self = o.self; memset(&o, 0, sizeof(Destination)); return *this; }
5755         LDKDestination* operator &() { return &self; }
5756         LDKDestination* operator ->() { return &self; }
5757         const LDKDestination* operator &() const { return &self; }
5758         const LDKDestination* operator ->() const { return &self; }
5759 };
5760 class SendError {
5761 private:
5762         LDKSendError self;
5763 public:
5764         SendError(const SendError&) = delete;
5765         SendError(SendError&& o) : self(o.self) { memset(&o, 0, sizeof(SendError)); }
5766         SendError(LDKSendError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSendError)); }
5767         operator LDKSendError() && { LDKSendError res = self; memset(&self, 0, sizeof(LDKSendError)); return res; }
5768         ~SendError() { SendError_free(self); }
5769         SendError& operator=(SendError&& o) { SendError_free(self); self = o.self; memset(&o, 0, sizeof(SendError)); return *this; }
5770         LDKSendError* operator &() { return &self; }
5771         LDKSendError* operator ->() { return &self; }
5772         const LDKSendError* operator &() const { return &self; }
5773         const LDKSendError* operator ->() const { return &self; }
5774 };
5775 class CustomOnionMessageHandler {
5776 private:
5777         LDKCustomOnionMessageHandler self;
5778 public:
5779         CustomOnionMessageHandler(const CustomOnionMessageHandler&) = delete;
5780         CustomOnionMessageHandler(CustomOnionMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(CustomOnionMessageHandler)); }
5781         CustomOnionMessageHandler(LDKCustomOnionMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomOnionMessageHandler)); }
5782         operator LDKCustomOnionMessageHandler() && { LDKCustomOnionMessageHandler res = self; memset(&self, 0, sizeof(LDKCustomOnionMessageHandler)); return res; }
5783         ~CustomOnionMessageHandler() { CustomOnionMessageHandler_free(self); }
5784         CustomOnionMessageHandler& operator=(CustomOnionMessageHandler&& o) { CustomOnionMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(CustomOnionMessageHandler)); return *this; }
5785         LDKCustomOnionMessageHandler* operator &() { return &self; }
5786         LDKCustomOnionMessageHandler* operator ->() { return &self; }
5787         const LDKCustomOnionMessageHandler* operator &() const { return &self; }
5788         const LDKCustomOnionMessageHandler* operator ->() const { return &self; }
5789         /**
5790          *  Called with the custom message that was received, returning a response to send, if any.
5791          *
5792          *  The returned [`Self::CustomMessage`], if any, is enqueued to be sent by [`OnionMessenger`].
5793          */
5794         inline LDK::COption_OnionMessageContentsZ handle_custom_message(struct LDKOnionMessageContents msg);
5795         /**
5796          *  Read a custom message of type `message_type` from `buffer`, returning `Ok(None)` if the
5797          *  message type is unknown.
5798          */
5799         inline LDK::CResult_COption_OnionMessageContentsZDecodeErrorZ read_custom_message(uint64_t message_type, struct LDKu8slice buffer);
5800         /**
5801          *  Releases any [`Self::CustomMessage`]s that need to be sent.
5802          *
5803          *  Typically, this is used for messages initiating a message flow rather than in response to
5804          *  another message. The latter should use the return value of [`Self::handle_custom_message`].
5805          */
5806         inline LDK::CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ release_pending_custom_messages();
5807 };
5808 class PeeledOnion {
5809 private:
5810         LDKPeeledOnion self;
5811 public:
5812         PeeledOnion(const PeeledOnion&) = delete;
5813         PeeledOnion(PeeledOnion&& o) : self(o.self) { memset(&o, 0, sizeof(PeeledOnion)); }
5814         PeeledOnion(LDKPeeledOnion&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeeledOnion)); }
5815         operator LDKPeeledOnion() && { LDKPeeledOnion res = self; memset(&self, 0, sizeof(LDKPeeledOnion)); return res; }
5816         ~PeeledOnion() { PeeledOnion_free(self); }
5817         PeeledOnion& operator=(PeeledOnion&& o) { PeeledOnion_free(self); self = o.self; memset(&o, 0, sizeof(PeeledOnion)); return *this; }
5818         LDKPeeledOnion* operator &() { return &self; }
5819         LDKPeeledOnion* operator ->() { return &self; }
5820         const LDKPeeledOnion* operator &() const { return &self; }
5821         const LDKPeeledOnion* operator ->() const { return &self; }
5822 };
5823 class FilesystemStore {
5824 private:
5825         LDKFilesystemStore self;
5826 public:
5827         FilesystemStore(const FilesystemStore&) = delete;
5828         FilesystemStore(FilesystemStore&& o) : self(o.self) { memset(&o, 0, sizeof(FilesystemStore)); }
5829         FilesystemStore(LDKFilesystemStore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilesystemStore)); }
5830         operator LDKFilesystemStore() && { LDKFilesystemStore res = self; memset(&self, 0, sizeof(LDKFilesystemStore)); return res; }
5831         ~FilesystemStore() { FilesystemStore_free(self); }
5832         FilesystemStore& operator=(FilesystemStore&& o) { FilesystemStore_free(self); self = o.self; memset(&o, 0, sizeof(FilesystemStore)); return *this; }
5833         LDKFilesystemStore* operator &() { return &self; }
5834         LDKFilesystemStore* operator ->() { return &self; }
5835         const LDKFilesystemStore* operator &() const { return &self; }
5836         const LDKFilesystemStore* operator ->() const { return &self; }
5837 };
5838 class BlindedPath {
5839 private:
5840         LDKBlindedPath self;
5841 public:
5842         BlindedPath(const BlindedPath&) = delete;
5843         BlindedPath(BlindedPath&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPath)); }
5844         BlindedPath(LDKBlindedPath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPath)); }
5845         operator LDKBlindedPath() && { LDKBlindedPath res = self; memset(&self, 0, sizeof(LDKBlindedPath)); return res; }
5846         ~BlindedPath() { BlindedPath_free(self); }
5847         BlindedPath& operator=(BlindedPath&& o) { BlindedPath_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPath)); return *this; }
5848         LDKBlindedPath* operator &() { return &self; }
5849         LDKBlindedPath* operator ->() { return &self; }
5850         const LDKBlindedPath* operator &() const { return &self; }
5851         const LDKBlindedPath* operator ->() const { return &self; }
5852 };
5853 class BlindedHop {
5854 private:
5855         LDKBlindedHop self;
5856 public:
5857         BlindedHop(const BlindedHop&) = delete;
5858         BlindedHop(BlindedHop&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedHop)); }
5859         BlindedHop(LDKBlindedHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedHop)); }
5860         operator LDKBlindedHop() && { LDKBlindedHop res = self; memset(&self, 0, sizeof(LDKBlindedHop)); return res; }
5861         ~BlindedHop() { BlindedHop_free(self); }
5862         BlindedHop& operator=(BlindedHop&& o) { BlindedHop_free(self); self = o.self; memset(&o, 0, sizeof(BlindedHop)); return *this; }
5863         LDKBlindedHop* operator &() { return &self; }
5864         LDKBlindedHop* operator ->() { return &self; }
5865         const LDKBlindedHop* operator &() const { return &self; }
5866         const LDKBlindedHop* operator ->() const { return &self; }
5867 };
5868 class GraphSyncError {
5869 private:
5870         LDKGraphSyncError self;
5871 public:
5872         GraphSyncError(const GraphSyncError&) = delete;
5873         GraphSyncError(GraphSyncError&& o) : self(o.self) { memset(&o, 0, sizeof(GraphSyncError)); }
5874         GraphSyncError(LDKGraphSyncError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGraphSyncError)); }
5875         operator LDKGraphSyncError() && { LDKGraphSyncError res = self; memset(&self, 0, sizeof(LDKGraphSyncError)); return res; }
5876         ~GraphSyncError() { GraphSyncError_free(self); }
5877         GraphSyncError& operator=(GraphSyncError&& o) { GraphSyncError_free(self); self = o.self; memset(&o, 0, sizeof(GraphSyncError)); return *this; }
5878         LDKGraphSyncError* operator &() { return &self; }
5879         LDKGraphSyncError* operator ->() { return &self; }
5880         const LDKGraphSyncError* operator &() const { return &self; }
5881         const LDKGraphSyncError* operator ->() const { return &self; }
5882 };
5883 class InvoiceError {
5884 private:
5885         LDKInvoiceError self;
5886 public:
5887         InvoiceError(const InvoiceError&) = delete;
5888         InvoiceError(InvoiceError&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceError)); }
5889         InvoiceError(LDKInvoiceError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceError)); }
5890         operator LDKInvoiceError() && { LDKInvoiceError res = self; memset(&self, 0, sizeof(LDKInvoiceError)); return res; }
5891         ~InvoiceError() { InvoiceError_free(self); }
5892         InvoiceError& operator=(InvoiceError&& o) { InvoiceError_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceError)); return *this; }
5893         LDKInvoiceError* operator &() { return &self; }
5894         LDKInvoiceError* operator ->() { return &self; }
5895         const LDKInvoiceError* operator &() const { return &self; }
5896         const LDKInvoiceError* operator ->() const { return &self; }
5897 };
5898 class ErroneousField {
5899 private:
5900         LDKErroneousField self;
5901 public:
5902         ErroneousField(const ErroneousField&) = delete;
5903         ErroneousField(ErroneousField&& o) : self(o.self) { memset(&o, 0, sizeof(ErroneousField)); }
5904         ErroneousField(LDKErroneousField&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroneousField)); }
5905         operator LDKErroneousField() && { LDKErroneousField res = self; memset(&self, 0, sizeof(LDKErroneousField)); return res; }
5906         ~ErroneousField() { ErroneousField_free(self); }
5907         ErroneousField& operator=(ErroneousField&& o) { ErroneousField_free(self); self = o.self; memset(&o, 0, sizeof(ErroneousField)); return *this; }
5908         LDKErroneousField* operator &() { return &self; }
5909         LDKErroneousField* operator ->() { return &self; }
5910         const LDKErroneousField* operator &() const { return &self; }
5911         const LDKErroneousField* operator ->() const { return &self; }
5912 };
5913 class MonitorUpdateId {
5914 private:
5915         LDKMonitorUpdateId self;
5916 public:
5917         MonitorUpdateId(const MonitorUpdateId&) = delete;
5918         MonitorUpdateId(MonitorUpdateId&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdateId)); }
5919         MonitorUpdateId(LDKMonitorUpdateId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdateId)); }
5920         operator LDKMonitorUpdateId() && { LDKMonitorUpdateId res = self; memset(&self, 0, sizeof(LDKMonitorUpdateId)); return res; }
5921         ~MonitorUpdateId() { MonitorUpdateId_free(self); }
5922         MonitorUpdateId& operator=(MonitorUpdateId&& o) { MonitorUpdateId_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdateId)); return *this; }
5923         LDKMonitorUpdateId* operator &() { return &self; }
5924         LDKMonitorUpdateId* operator ->() { return &self; }
5925         const LDKMonitorUpdateId* operator &() const { return &self; }
5926         const LDKMonitorUpdateId* operator ->() const { return &self; }
5927 };
5928 class Persist {
5929 private:
5930         LDKPersist self;
5931 public:
5932         Persist(const Persist&) = delete;
5933         Persist(Persist&& o) : self(o.self) { memset(&o, 0, sizeof(Persist)); }
5934         Persist(LDKPersist&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersist)); }
5935         operator LDKPersist() && { LDKPersist res = self; memset(&self, 0, sizeof(LDKPersist)); return res; }
5936         ~Persist() { Persist_free(self); }
5937         Persist& operator=(Persist&& o) { Persist_free(self); self = o.self; memset(&o, 0, sizeof(Persist)); return *this; }
5938         LDKPersist* operator &() { return &self; }
5939         LDKPersist* operator ->() { return &self; }
5940         const LDKPersist* operator &() const { return &self; }
5941         const LDKPersist* operator ->() const { return &self; }
5942         /**
5943          *  Persist a new channel's data in response to a [`chain::Watch::watch_channel`] call. This is
5944          *  called by [`ChannelManager`] for new channels, or may be called directly, e.g. on startup.
5945          *
5946          *  The data can be stored any way you want, but the identifier provided by LDK is the
5947          *  channel's outpoint (and it is up to you to maintain a correct mapping between the outpoint
5948          *  and the stored channel data). Note that you **must** persist every new monitor to disk.
5949          *
5950          *  The `update_id` is used to identify this call to [`ChainMonitor::channel_monitor_updated`],
5951          *  if you return [`ChannelMonitorUpdateStatus::InProgress`].
5952          *
5953          *  See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`
5954          *  and [`ChannelMonitorUpdateStatus`] for requirements when returning errors.
5955          *
5956          *  [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
5957          *  [`Writeable::write`]: crate::util::ser::Writeable::write
5958          */
5959         inline LDK::ChannelMonitorUpdateStatus persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
5960         /**
5961          *  Update one channel's data. The provided [`ChannelMonitor`] has already applied the given
5962          *  update.
5963          *
5964          *  Note that on every update, you **must** persist either the [`ChannelMonitorUpdate`] or the
5965          *  updated monitor itself to disk/backups. See the [`Persist`] trait documentation for more
5966          *  details.
5967          *
5968          *  During blockchain synchronization operations, and in some rare cases, this may be called with
5969          *  no [`ChannelMonitorUpdate`], in which case the full [`ChannelMonitor`] needs to be persisted.
5970          *  Note that after the full [`ChannelMonitor`] is persisted any previous
5971          *  [`ChannelMonitorUpdate`]s which were persisted should be discarded - they can no longer be
5972          *  applied to the persisted [`ChannelMonitor`] as they were already applied.
5973          *
5974          *  If an implementer chooses to persist the updates only, they need to make
5975          *  sure that all the updates are applied to the `ChannelMonitors` *before*
5976          *  the set of channel monitors is given to the `ChannelManager`
5977          *  deserialization routine. See [`ChannelMonitor::update_monitor`] for
5978          *  applying a monitor update to a monitor. If full `ChannelMonitors` are
5979          *  persisted, then there is no need to persist individual updates.
5980          *
5981          *  Note that there could be a performance tradeoff between persisting complete
5982          *  channel monitors on every update vs. persisting only updates and applying
5983          *  them in batches. The size of each monitor grows `O(number of state updates)`
5984          *  whereas updates are small and `O(1)`.
5985          *
5986          *  The `update_id` is used to identify this call to [`ChainMonitor::channel_monitor_updated`],
5987          *  if you return [`ChannelMonitorUpdateStatus::InProgress`].
5988          *
5989          *  See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`,
5990          *  [`Writeable::write`] on [`ChannelMonitorUpdate`] for writing out an update, and
5991          *  [`ChannelMonitorUpdateStatus`] for requirements when returning errors.
5992          *
5993          *  [`Writeable::write`]: crate::util::ser::Writeable::write
5994          *
5995          *  Note that update (or a relevant inner pointer) may be NULL or all-0s to represent None
5996          */
5997         inline LDK::ChannelMonitorUpdateStatus update_persisted_channel(struct LDKOutPoint channel_id, struct LDKChannelMonitorUpdate update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
5998 };
5999 class LockedChannelMonitor {
6000 private:
6001         LDKLockedChannelMonitor self;
6002 public:
6003         LockedChannelMonitor(const LockedChannelMonitor&) = delete;
6004         LockedChannelMonitor(LockedChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(LockedChannelMonitor)); }
6005         LockedChannelMonitor(LDKLockedChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockedChannelMonitor)); }
6006         operator LDKLockedChannelMonitor() && { LDKLockedChannelMonitor res = self; memset(&self, 0, sizeof(LDKLockedChannelMonitor)); return res; }
6007         ~LockedChannelMonitor() { LockedChannelMonitor_free(self); }
6008         LockedChannelMonitor& operator=(LockedChannelMonitor&& o) { LockedChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(LockedChannelMonitor)); return *this; }
6009         LDKLockedChannelMonitor* operator &() { return &self; }
6010         LDKLockedChannelMonitor* operator ->() { return &self; }
6011         const LDKLockedChannelMonitor* operator &() const { return &self; }
6012         const LDKLockedChannelMonitor* operator ->() const { return &self; }
6013 };
6014 class ChainMonitor {
6015 private:
6016         LDKChainMonitor self;
6017 public:
6018         ChainMonitor(const ChainMonitor&) = delete;
6019         ChainMonitor(ChainMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChainMonitor)); }
6020         ChainMonitor(LDKChainMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainMonitor)); }
6021         operator LDKChainMonitor() && { LDKChainMonitor res = self; memset(&self, 0, sizeof(LDKChainMonitor)); return res; }
6022         ~ChainMonitor() { ChainMonitor_free(self); }
6023         ChainMonitor& operator=(ChainMonitor&& o) { ChainMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChainMonitor)); return *this; }
6024         LDKChainMonitor* operator &() { return &self; }
6025         LDKChainMonitor* operator ->() { return &self; }
6026         const LDKChainMonitor* operator &() const { return &self; }
6027         const LDKChainMonitor* operator ->() const { return &self; }
6028 };
6029 class CResult_LockedChannelMonitorNoneZ {
6030 private:
6031         LDKCResult_LockedChannelMonitorNoneZ self;
6032 public:
6033         CResult_LockedChannelMonitorNoneZ(const CResult_LockedChannelMonitorNoneZ&) = delete;
6034         CResult_LockedChannelMonitorNoneZ(CResult_LockedChannelMonitorNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); }
6035         CResult_LockedChannelMonitorNoneZ(LDKCResult_LockedChannelMonitorNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); }
6036         operator LDKCResult_LockedChannelMonitorNoneZ() && { LDKCResult_LockedChannelMonitorNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); return res; }
6037         ~CResult_LockedChannelMonitorNoneZ() { CResult_LockedChannelMonitorNoneZ_free(self); }
6038         CResult_LockedChannelMonitorNoneZ& operator=(CResult_LockedChannelMonitorNoneZ&& o) { CResult_LockedChannelMonitorNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); return *this; }
6039         LDKCResult_LockedChannelMonitorNoneZ* operator &() { return &self; }
6040         LDKCResult_LockedChannelMonitorNoneZ* operator ->() { return &self; }
6041         const LDKCResult_LockedChannelMonitorNoneZ* operator &() const { return &self; }
6042         const LDKCResult_LockedChannelMonitorNoneZ* operator ->() const { return &self; }
6043 };
6044 class CResult_TransactionU16LenLimitedNoneZ {
6045 private:
6046         LDKCResult_TransactionU16LenLimitedNoneZ self;
6047 public:
6048         CResult_TransactionU16LenLimitedNoneZ(const CResult_TransactionU16LenLimitedNoneZ&) = delete;
6049         CResult_TransactionU16LenLimitedNoneZ(CResult_TransactionU16LenLimitedNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedNoneZ)); }
6050         CResult_TransactionU16LenLimitedNoneZ(LDKCResult_TransactionU16LenLimitedNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionU16LenLimitedNoneZ)); }
6051         operator LDKCResult_TransactionU16LenLimitedNoneZ() && { LDKCResult_TransactionU16LenLimitedNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionU16LenLimitedNoneZ)); return res; }
6052         ~CResult_TransactionU16LenLimitedNoneZ() { CResult_TransactionU16LenLimitedNoneZ_free(self); }
6053         CResult_TransactionU16LenLimitedNoneZ& operator=(CResult_TransactionU16LenLimitedNoneZ&& o) { CResult_TransactionU16LenLimitedNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedNoneZ)); return *this; }
6054         LDKCResult_TransactionU16LenLimitedNoneZ* operator &() { return &self; }
6055         LDKCResult_TransactionU16LenLimitedNoneZ* operator ->() { return &self; }
6056         const LDKCResult_TransactionU16LenLimitedNoneZ* operator &() const { return &self; }
6057         const LDKCResult_TransactionU16LenLimitedNoneZ* operator ->() const { return &self; }
6058 };
6059 class CVec_C2Tuple_BlindedPayInfoBlindedPathZZ {
6060 private:
6061         LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ self;
6062 public:
6063         CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(const CVec_C2Tuple_BlindedPayInfoBlindedPathZZ&) = delete;
6064         CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); }
6065         CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); }
6066         operator LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ() && { LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); return res; }
6067         ~CVec_C2Tuple_BlindedPayInfoBlindedPathZZ() { CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(self); }
6068         CVec_C2Tuple_BlindedPayInfoBlindedPathZZ& operator=(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ&& o) { CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); return *this; }
6069         LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator &() { return &self; }
6070         LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator ->() { return &self; }
6071         const LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator &() const { return &self; }
6072         const LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator ->() const { return &self; }
6073 };
6074 class CResult_PhantomRouteHintsDecodeErrorZ {
6075 private:
6076         LDKCResult_PhantomRouteHintsDecodeErrorZ self;
6077 public:
6078         CResult_PhantomRouteHintsDecodeErrorZ(const CResult_PhantomRouteHintsDecodeErrorZ&) = delete;
6079         CResult_PhantomRouteHintsDecodeErrorZ(CResult_PhantomRouteHintsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); }
6080         CResult_PhantomRouteHintsDecodeErrorZ(LDKCResult_PhantomRouteHintsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); }
6081         operator LDKCResult_PhantomRouteHintsDecodeErrorZ() && { LDKCResult_PhantomRouteHintsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); return res; }
6082         ~CResult_PhantomRouteHintsDecodeErrorZ() { CResult_PhantomRouteHintsDecodeErrorZ_free(self); }
6083         CResult_PhantomRouteHintsDecodeErrorZ& operator=(CResult_PhantomRouteHintsDecodeErrorZ&& o) { CResult_PhantomRouteHintsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); return *this; }
6084         LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() { return &self; }
6085         LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() { return &self; }
6086         const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() const { return &self; }
6087         const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() const { return &self; }
6088 };
6089 class CResult_FundingCreatedDecodeErrorZ {
6090 private:
6091         LDKCResult_FundingCreatedDecodeErrorZ self;
6092 public:
6093         CResult_FundingCreatedDecodeErrorZ(const CResult_FundingCreatedDecodeErrorZ&) = delete;
6094         CResult_FundingCreatedDecodeErrorZ(CResult_FundingCreatedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); }
6095         CResult_FundingCreatedDecodeErrorZ(LDKCResult_FundingCreatedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); }
6096         operator LDKCResult_FundingCreatedDecodeErrorZ() && { LDKCResult_FundingCreatedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); return res; }
6097         ~CResult_FundingCreatedDecodeErrorZ() { CResult_FundingCreatedDecodeErrorZ_free(self); }
6098         CResult_FundingCreatedDecodeErrorZ& operator=(CResult_FundingCreatedDecodeErrorZ&& o) { CResult_FundingCreatedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); return *this; }
6099         LDKCResult_FundingCreatedDecodeErrorZ* operator &() { return &self; }
6100         LDKCResult_FundingCreatedDecodeErrorZ* operator ->() { return &self; }
6101         const LDKCResult_FundingCreatedDecodeErrorZ* operator &() const { return &self; }
6102         const LDKCResult_FundingCreatedDecodeErrorZ* operator ->() const { return &self; }
6103 };
6104 class CVec_C2Tuple_u32TxOutZZ {
6105 private:
6106         LDKCVec_C2Tuple_u32TxOutZZ self;
6107 public:
6108         CVec_C2Tuple_u32TxOutZZ(const CVec_C2Tuple_u32TxOutZZ&) = delete;
6109         CVec_C2Tuple_u32TxOutZZ(CVec_C2Tuple_u32TxOutZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32TxOutZZ)); }
6110         CVec_C2Tuple_u32TxOutZZ(LDKCVec_C2Tuple_u32TxOutZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); }
6111         operator LDKCVec_C2Tuple_u32TxOutZZ() && { LDKCVec_C2Tuple_u32TxOutZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); return res; }
6112         ~CVec_C2Tuple_u32TxOutZZ() { CVec_C2Tuple_u32TxOutZZ_free(self); }
6113         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; }
6114         LDKCVec_C2Tuple_u32TxOutZZ* operator &() { return &self; }
6115         LDKCVec_C2Tuple_u32TxOutZZ* operator ->() { return &self; }
6116         const LDKCVec_C2Tuple_u32TxOutZZ* operator &() const { return &self; }
6117         const LDKCVec_C2Tuple_u32TxOutZZ* operator ->() const { return &self; }
6118 };
6119 class CResult_RetryDecodeErrorZ {
6120 private:
6121         LDKCResult_RetryDecodeErrorZ self;
6122 public:
6123         CResult_RetryDecodeErrorZ(const CResult_RetryDecodeErrorZ&) = delete;
6124         CResult_RetryDecodeErrorZ(CResult_RetryDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RetryDecodeErrorZ)); }
6125         CResult_RetryDecodeErrorZ(LDKCResult_RetryDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RetryDecodeErrorZ)); }
6126         operator LDKCResult_RetryDecodeErrorZ() && { LDKCResult_RetryDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RetryDecodeErrorZ)); return res; }
6127         ~CResult_RetryDecodeErrorZ() { CResult_RetryDecodeErrorZ_free(self); }
6128         CResult_RetryDecodeErrorZ& operator=(CResult_RetryDecodeErrorZ&& o) { CResult_RetryDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RetryDecodeErrorZ)); return *this; }
6129         LDKCResult_RetryDecodeErrorZ* operator &() { return &self; }
6130         LDKCResult_RetryDecodeErrorZ* operator ->() { return &self; }
6131         const LDKCResult_RetryDecodeErrorZ* operator &() const { return &self; }
6132         const LDKCResult_RetryDecodeErrorZ* operator ->() const { return &self; }
6133 };
6134 class CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ {
6135 private:
6136         LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ self;
6137 public:
6138         CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ(const CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ&) = delete;
6139         CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ(CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ)); }
6140         CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ)); }
6141         operator LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ() && { LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ)); return res; }
6142         ~CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ() { CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_free(self); }
6143         CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ& operator=(CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ&& o) { CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ)); return *this; }
6144         LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* operator &() { return &self; }
6145         LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* operator ->() { return &self; }
6146         const LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* operator &() const { return &self; }
6147         const LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* operator ->() const { return &self; }
6148 };
6149 class CResult_ChannelInfoDecodeErrorZ {
6150 private:
6151         LDKCResult_ChannelInfoDecodeErrorZ self;
6152 public:
6153         CResult_ChannelInfoDecodeErrorZ(const CResult_ChannelInfoDecodeErrorZ&) = delete;
6154         CResult_ChannelInfoDecodeErrorZ(CResult_ChannelInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); }
6155         CResult_ChannelInfoDecodeErrorZ(LDKCResult_ChannelInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); }
6156         operator LDKCResult_ChannelInfoDecodeErrorZ() && { LDKCResult_ChannelInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); return res; }
6157         ~CResult_ChannelInfoDecodeErrorZ() { CResult_ChannelInfoDecodeErrorZ_free(self); }
6158         CResult_ChannelInfoDecodeErrorZ& operator=(CResult_ChannelInfoDecodeErrorZ&& o) { CResult_ChannelInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); return *this; }
6159         LDKCResult_ChannelInfoDecodeErrorZ* operator &() { return &self; }
6160         LDKCResult_ChannelInfoDecodeErrorZ* operator ->() { return &self; }
6161         const LDKCResult_ChannelInfoDecodeErrorZ* operator &() const { return &self; }
6162         const LDKCResult_ChannelInfoDecodeErrorZ* operator ->() const { return &self; }
6163 };
6164 class COption_MaxDustHTLCExposureZ {
6165 private:
6166         LDKCOption_MaxDustHTLCExposureZ self;
6167 public:
6168         COption_MaxDustHTLCExposureZ(const COption_MaxDustHTLCExposureZ&) = delete;
6169         COption_MaxDustHTLCExposureZ(COption_MaxDustHTLCExposureZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MaxDustHTLCExposureZ)); }
6170         COption_MaxDustHTLCExposureZ(LDKCOption_MaxDustHTLCExposureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MaxDustHTLCExposureZ)); }
6171         operator LDKCOption_MaxDustHTLCExposureZ() && { LDKCOption_MaxDustHTLCExposureZ res = self; memset(&self, 0, sizeof(LDKCOption_MaxDustHTLCExposureZ)); return res; }
6172         ~COption_MaxDustHTLCExposureZ() { COption_MaxDustHTLCExposureZ_free(self); }
6173         COption_MaxDustHTLCExposureZ& operator=(COption_MaxDustHTLCExposureZ&& o) { COption_MaxDustHTLCExposureZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MaxDustHTLCExposureZ)); return *this; }
6174         LDKCOption_MaxDustHTLCExposureZ* operator &() { return &self; }
6175         LDKCOption_MaxDustHTLCExposureZ* operator ->() { return &self; }
6176         const LDKCOption_MaxDustHTLCExposureZ* operator &() const { return &self; }
6177         const LDKCOption_MaxDustHTLCExposureZ* operator ->() const { return &self; }
6178 };
6179 class CResult_NoneSendErrorZ {
6180 private:
6181         LDKCResult_NoneSendErrorZ self;
6182 public:
6183         CResult_NoneSendErrorZ(const CResult_NoneSendErrorZ&) = delete;
6184         CResult_NoneSendErrorZ(CResult_NoneSendErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneSendErrorZ)); }
6185         CResult_NoneSendErrorZ(LDKCResult_NoneSendErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneSendErrorZ)); }
6186         operator LDKCResult_NoneSendErrorZ() && { LDKCResult_NoneSendErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneSendErrorZ)); return res; }
6187         ~CResult_NoneSendErrorZ() { CResult_NoneSendErrorZ_free(self); }
6188         CResult_NoneSendErrorZ& operator=(CResult_NoneSendErrorZ&& o) { CResult_NoneSendErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneSendErrorZ)); return *this; }
6189         LDKCResult_NoneSendErrorZ* operator &() { return &self; }
6190         LDKCResult_NoneSendErrorZ* operator ->() { return &self; }
6191         const LDKCResult_NoneSendErrorZ* operator &() const { return &self; }
6192         const LDKCResult_NoneSendErrorZ* operator ->() const { return &self; }
6193 };
6194 class C2Tuple_CVec_u8ZusizeZ {
6195 private:
6196         LDKC2Tuple_CVec_u8ZusizeZ self;
6197 public:
6198         C2Tuple_CVec_u8ZusizeZ(const C2Tuple_CVec_u8ZusizeZ&) = delete;
6199         C2Tuple_CVec_u8ZusizeZ(C2Tuple_CVec_u8ZusizeZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_CVec_u8ZusizeZ)); }
6200         C2Tuple_CVec_u8ZusizeZ(LDKC2Tuple_CVec_u8ZusizeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_CVec_u8ZusizeZ)); }
6201         operator LDKC2Tuple_CVec_u8ZusizeZ() && { LDKC2Tuple_CVec_u8ZusizeZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_CVec_u8ZusizeZ)); return res; }
6202         ~C2Tuple_CVec_u8ZusizeZ() { C2Tuple_CVec_u8ZusizeZ_free(self); }
6203         C2Tuple_CVec_u8ZusizeZ& operator=(C2Tuple_CVec_u8ZusizeZ&& o) { C2Tuple_CVec_u8ZusizeZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_CVec_u8ZusizeZ)); return *this; }
6204         LDKC2Tuple_CVec_u8ZusizeZ* operator &() { return &self; }
6205         LDKC2Tuple_CVec_u8ZusizeZ* operator ->() { return &self; }
6206         const LDKC2Tuple_CVec_u8ZusizeZ* operator &() const { return &self; }
6207         const LDKC2Tuple_CVec_u8ZusizeZ* operator ->() const { return &self; }
6208 };
6209 class COption_OffersMessageZ {
6210 private:
6211         LDKCOption_OffersMessageZ self;
6212 public:
6213         COption_OffersMessageZ(const COption_OffersMessageZ&) = delete;
6214         COption_OffersMessageZ(COption_OffersMessageZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_OffersMessageZ)); }
6215         COption_OffersMessageZ(LDKCOption_OffersMessageZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_OffersMessageZ)); }
6216         operator LDKCOption_OffersMessageZ() && { LDKCOption_OffersMessageZ res = self; memset(&self, 0, sizeof(LDKCOption_OffersMessageZ)); return res; }
6217         ~COption_OffersMessageZ() { COption_OffersMessageZ_free(self); }
6218         COption_OffersMessageZ& operator=(COption_OffersMessageZ&& o) { COption_OffersMessageZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_OffersMessageZ)); return *this; }
6219         LDKCOption_OffersMessageZ* operator &() { return &self; }
6220         LDKCOption_OffersMessageZ* operator ->() { return &self; }
6221         const LDKCOption_OffersMessageZ* operator &() const { return &self; }
6222         const LDKCOption_OffersMessageZ* operator ->() const { return &self; }
6223 };
6224 class COption_NetworkUpdateZ {
6225 private:
6226         LDKCOption_NetworkUpdateZ self;
6227 public:
6228         COption_NetworkUpdateZ(const COption_NetworkUpdateZ&) = delete;
6229         COption_NetworkUpdateZ(COption_NetworkUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NetworkUpdateZ)); }
6230         COption_NetworkUpdateZ(LDKCOption_NetworkUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NetworkUpdateZ)); }
6231         operator LDKCOption_NetworkUpdateZ() && { LDKCOption_NetworkUpdateZ res = self; memset(&self, 0, sizeof(LDKCOption_NetworkUpdateZ)); return res; }
6232         ~COption_NetworkUpdateZ() { COption_NetworkUpdateZ_free(self); }
6233         COption_NetworkUpdateZ& operator=(COption_NetworkUpdateZ&& o) { COption_NetworkUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NetworkUpdateZ)); return *this; }
6234         LDKCOption_NetworkUpdateZ* operator &() { return &self; }
6235         LDKCOption_NetworkUpdateZ* operator ->() { return &self; }
6236         const LDKCOption_NetworkUpdateZ* operator &() const { return &self; }
6237         const LDKCOption_NetworkUpdateZ* operator ->() const { return &self; }
6238 };
6239 class COption_u64Z {
6240 private:
6241         LDKCOption_u64Z self;
6242 public:
6243         COption_u64Z(const COption_u64Z&) = delete;
6244         COption_u64Z(COption_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u64Z)); }
6245         COption_u64Z(LDKCOption_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u64Z)); }
6246         operator LDKCOption_u64Z() && { LDKCOption_u64Z res = self; memset(&self, 0, sizeof(LDKCOption_u64Z)); return res; }
6247         ~COption_u64Z() { COption_u64Z_free(self); }
6248         COption_u64Z& operator=(COption_u64Z&& o) { COption_u64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u64Z)); return *this; }
6249         LDKCOption_u64Z* operator &() { return &self; }
6250         LDKCOption_u64Z* operator ->() { return &self; }
6251         const LDKCOption_u64Z* operator &() const { return &self; }
6252         const LDKCOption_u64Z* operator ->() const { return &self; }
6253 };
6254 class CResult_CVec_u8ZPeerHandleErrorZ {
6255 private:
6256         LDKCResult_CVec_u8ZPeerHandleErrorZ self;
6257 public:
6258         CResult_CVec_u8ZPeerHandleErrorZ(const CResult_CVec_u8ZPeerHandleErrorZ&) = delete;
6259         CResult_CVec_u8ZPeerHandleErrorZ(CResult_CVec_u8ZPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); }
6260         CResult_CVec_u8ZPeerHandleErrorZ(LDKCResult_CVec_u8ZPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); }
6261         operator LDKCResult_CVec_u8ZPeerHandleErrorZ() && { LDKCResult_CVec_u8ZPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); return res; }
6262         ~CResult_CVec_u8ZPeerHandleErrorZ() { CResult_CVec_u8ZPeerHandleErrorZ_free(self); }
6263         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; }
6264         LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() { return &self; }
6265         LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() { return &self; }
6266         const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() const { return &self; }
6267         const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() const { return &self; }
6268 };
6269 class CResult_GossipTimestampFilterDecodeErrorZ {
6270 private:
6271         LDKCResult_GossipTimestampFilterDecodeErrorZ self;
6272 public:
6273         CResult_GossipTimestampFilterDecodeErrorZ(const CResult_GossipTimestampFilterDecodeErrorZ&) = delete;
6274         CResult_GossipTimestampFilterDecodeErrorZ(CResult_GossipTimestampFilterDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); }
6275         CResult_GossipTimestampFilterDecodeErrorZ(LDKCResult_GossipTimestampFilterDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); }
6276         operator LDKCResult_GossipTimestampFilterDecodeErrorZ() && { LDKCResult_GossipTimestampFilterDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); return res; }
6277         ~CResult_GossipTimestampFilterDecodeErrorZ() { CResult_GossipTimestampFilterDecodeErrorZ_free(self); }
6278         CResult_GossipTimestampFilterDecodeErrorZ& operator=(CResult_GossipTimestampFilterDecodeErrorZ&& o) { CResult_GossipTimestampFilterDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); return *this; }
6279         LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() { return &self; }
6280         LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() { return &self; }
6281         const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() const { return &self; }
6282         const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() const { return &self; }
6283 };
6284 class CResult_RouteHintDecodeErrorZ {
6285 private:
6286         LDKCResult_RouteHintDecodeErrorZ self;
6287 public:
6288         CResult_RouteHintDecodeErrorZ(const CResult_RouteHintDecodeErrorZ&) = delete;
6289         CResult_RouteHintDecodeErrorZ(CResult_RouteHintDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); }
6290         CResult_RouteHintDecodeErrorZ(LDKCResult_RouteHintDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); }
6291         operator LDKCResult_RouteHintDecodeErrorZ() && { LDKCResult_RouteHintDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); return res; }
6292         ~CResult_RouteHintDecodeErrorZ() { CResult_RouteHintDecodeErrorZ_free(self); }
6293         CResult_RouteHintDecodeErrorZ& operator=(CResult_RouteHintDecodeErrorZ&& o) { CResult_RouteHintDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); return *this; }
6294         LDKCResult_RouteHintDecodeErrorZ* operator &() { return &self; }
6295         LDKCResult_RouteHintDecodeErrorZ* operator ->() { return &self; }
6296         const LDKCResult_RouteHintDecodeErrorZ* operator &() const { return &self; }
6297         const LDKCResult_RouteHintDecodeErrorZ* operator ->() const { return &self; }
6298 };
6299 class COption_FilterZ {
6300 private:
6301         LDKCOption_FilterZ self;
6302 public:
6303         COption_FilterZ(const COption_FilterZ&) = delete;
6304         COption_FilterZ(COption_FilterZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_FilterZ)); }
6305         COption_FilterZ(LDKCOption_FilterZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_FilterZ)); }
6306         operator LDKCOption_FilterZ() && { LDKCOption_FilterZ res = self; memset(&self, 0, sizeof(LDKCOption_FilterZ)); return res; }
6307         ~COption_FilterZ() { COption_FilterZ_free(self); }
6308         COption_FilterZ& operator=(COption_FilterZ&& o) { COption_FilterZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_FilterZ)); return *this; }
6309         LDKCOption_FilterZ* operator &() { return &self; }
6310         LDKCOption_FilterZ* operator ->() { return &self; }
6311         const LDKCOption_FilterZ* operator &() const { return &self; }
6312         const LDKCOption_FilterZ* operator ->() const { return &self; }
6313 };
6314 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ {
6315 private:
6316         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ self;
6317 public:
6318         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ(const C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ&) = delete;
6319         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ)); }
6320         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ)); }
6321         operator LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ() && { LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ)); return res; }
6322         ~C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ() { C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(self); }
6323         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ& operator=(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ&& o) { C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ)); return *this; }
6324         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator &() { return &self; }
6325         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator ->() { return &self; }
6326         const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator &() const { return &self; }
6327         const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator ->() const { return &self; }
6328 };
6329 class COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
6330 private:
6331         LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ self;
6332 public:
6333         COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(const COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&) = delete;
6334         COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
6335         COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
6336         operator LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() && { LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ res = self; memset(&self, 0, sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return res; }
6337         ~COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() { COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); }
6338         COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ& operator=(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) { COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return *this; }
6339         LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() { return &self; }
6340         LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() { return &self; }
6341         const LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() const { return &self; }
6342         const LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() const { return &self; }
6343 };
6344 class CResult_COption_APIErrorZDecodeErrorZ {
6345 private:
6346         LDKCResult_COption_APIErrorZDecodeErrorZ self;
6347 public:
6348         CResult_COption_APIErrorZDecodeErrorZ(const CResult_COption_APIErrorZDecodeErrorZ&) = delete;
6349         CResult_COption_APIErrorZDecodeErrorZ(CResult_COption_APIErrorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_APIErrorZDecodeErrorZ)); }
6350         CResult_COption_APIErrorZDecodeErrorZ(LDKCResult_COption_APIErrorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ)); }
6351         operator LDKCResult_COption_APIErrorZDecodeErrorZ() && { LDKCResult_COption_APIErrorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ)); return res; }
6352         ~CResult_COption_APIErrorZDecodeErrorZ() { CResult_COption_APIErrorZDecodeErrorZ_free(self); }
6353         CResult_COption_APIErrorZDecodeErrorZ& operator=(CResult_COption_APIErrorZDecodeErrorZ&& o) { CResult_COption_APIErrorZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_APIErrorZDecodeErrorZ)); return *this; }
6354         LDKCResult_COption_APIErrorZDecodeErrorZ* operator &() { return &self; }
6355         LDKCResult_COption_APIErrorZDecodeErrorZ* operator ->() { return &self; }
6356         const LDKCResult_COption_APIErrorZDecodeErrorZ* operator &() const { return &self; }
6357         const LDKCResult_COption_APIErrorZDecodeErrorZ* operator ->() const { return &self; }
6358 };
6359 class CVec_UpdateAddHTLCZ {
6360 private:
6361         LDKCVec_UpdateAddHTLCZ self;
6362 public:
6363         CVec_UpdateAddHTLCZ(const CVec_UpdateAddHTLCZ&) = delete;
6364         CVec_UpdateAddHTLCZ(CVec_UpdateAddHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); }
6365         CVec_UpdateAddHTLCZ(LDKCVec_UpdateAddHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); }
6366         operator LDKCVec_UpdateAddHTLCZ() && { LDKCVec_UpdateAddHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); return res; }
6367         ~CVec_UpdateAddHTLCZ() { CVec_UpdateAddHTLCZ_free(self); }
6368         CVec_UpdateAddHTLCZ& operator=(CVec_UpdateAddHTLCZ&& o) { CVec_UpdateAddHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); return *this; }
6369         LDKCVec_UpdateAddHTLCZ* operator &() { return &self; }
6370         LDKCVec_UpdateAddHTLCZ* operator ->() { return &self; }
6371         const LDKCVec_UpdateAddHTLCZ* operator &() const { return &self; }
6372         const LDKCVec_UpdateAddHTLCZ* operator ->() const { return &self; }
6373 };
6374 class CResult_TxAbortDecodeErrorZ {
6375 private:
6376         LDKCResult_TxAbortDecodeErrorZ self;
6377 public:
6378         CResult_TxAbortDecodeErrorZ(const CResult_TxAbortDecodeErrorZ&) = delete;
6379         CResult_TxAbortDecodeErrorZ(CResult_TxAbortDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAbortDecodeErrorZ)); }
6380         CResult_TxAbortDecodeErrorZ(LDKCResult_TxAbortDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAbortDecodeErrorZ)); }
6381         operator LDKCResult_TxAbortDecodeErrorZ() && { LDKCResult_TxAbortDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAbortDecodeErrorZ)); return res; }
6382         ~CResult_TxAbortDecodeErrorZ() { CResult_TxAbortDecodeErrorZ_free(self); }
6383         CResult_TxAbortDecodeErrorZ& operator=(CResult_TxAbortDecodeErrorZ&& o) { CResult_TxAbortDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAbortDecodeErrorZ)); return *this; }
6384         LDKCResult_TxAbortDecodeErrorZ* operator &() { return &self; }
6385         LDKCResult_TxAbortDecodeErrorZ* operator ->() { return &self; }
6386         const LDKCResult_TxAbortDecodeErrorZ* operator &() const { return &self; }
6387         const LDKCResult_TxAbortDecodeErrorZ* operator ->() const { return &self; }
6388 };
6389 class CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
6390 private:
6391         LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ self;
6392 public:
6393         CResult_StaticPaymentOutputDescriptorDecodeErrorZ(const CResult_StaticPaymentOutputDescriptorDecodeErrorZ&) = delete;
6394         CResult_StaticPaymentOutputDescriptorDecodeErrorZ(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
6395         CResult_StaticPaymentOutputDescriptorDecodeErrorZ(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
6396         operator LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return res; }
6397         ~CResult_StaticPaymentOutputDescriptorDecodeErrorZ() { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); }
6398         CResult_StaticPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return *this; }
6399         LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
6400         LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
6401         const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
6402         const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
6403 };
6404 class COption_u32Z {
6405 private:
6406         LDKCOption_u32Z self;
6407 public:
6408         COption_u32Z(const COption_u32Z&) = delete;
6409         COption_u32Z(COption_u32Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u32Z)); }
6410         COption_u32Z(LDKCOption_u32Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u32Z)); }
6411         operator LDKCOption_u32Z() && { LDKCOption_u32Z res = self; memset(&self, 0, sizeof(LDKCOption_u32Z)); return res; }
6412         ~COption_u32Z() { COption_u32Z_free(self); }
6413         COption_u32Z& operator=(COption_u32Z&& o) { COption_u32Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u32Z)); return *this; }
6414         LDKCOption_u32Z* operator &() { return &self; }
6415         LDKCOption_u32Z* operator ->() { return &self; }
6416         const LDKCOption_u32Z* operator &() const { return &self; }
6417         const LDKCOption_u32Z* operator ->() const { return &self; }
6418 };
6419 class CResult_RecipientOnionFieldsNoneZ {
6420 private:
6421         LDKCResult_RecipientOnionFieldsNoneZ self;
6422 public:
6423         CResult_RecipientOnionFieldsNoneZ(const CResult_RecipientOnionFieldsNoneZ&) = delete;
6424         CResult_RecipientOnionFieldsNoneZ(CResult_RecipientOnionFieldsNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecipientOnionFieldsNoneZ)); }
6425         CResult_RecipientOnionFieldsNoneZ(LDKCResult_RecipientOnionFieldsNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecipientOnionFieldsNoneZ)); }
6426         operator LDKCResult_RecipientOnionFieldsNoneZ() && { LDKCResult_RecipientOnionFieldsNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_RecipientOnionFieldsNoneZ)); return res; }
6427         ~CResult_RecipientOnionFieldsNoneZ() { CResult_RecipientOnionFieldsNoneZ_free(self); }
6428         CResult_RecipientOnionFieldsNoneZ& operator=(CResult_RecipientOnionFieldsNoneZ&& o) { CResult_RecipientOnionFieldsNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecipientOnionFieldsNoneZ)); return *this; }
6429         LDKCResult_RecipientOnionFieldsNoneZ* operator &() { return &self; }
6430         LDKCResult_RecipientOnionFieldsNoneZ* operator ->() { return &self; }
6431         const LDKCResult_RecipientOnionFieldsNoneZ* operator &() const { return &self; }
6432         const LDKCResult_RecipientOnionFieldsNoneZ* operator ->() const { return &self; }
6433 };
6434 class C2Tuple__u1632_u1632Z {
6435 private:
6436         LDKC2Tuple__u1632_u1632Z self;
6437 public:
6438         C2Tuple__u1632_u1632Z(const C2Tuple__u1632_u1632Z&) = delete;
6439         C2Tuple__u1632_u1632Z(C2Tuple__u1632_u1632Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple__u1632_u1632Z)); }
6440         C2Tuple__u1632_u1632Z(LDKC2Tuple__u1632_u1632Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple__u1632_u1632Z)); }
6441         operator LDKC2Tuple__u1632_u1632Z() && { LDKC2Tuple__u1632_u1632Z res = self; memset(&self, 0, sizeof(LDKC2Tuple__u1632_u1632Z)); return res; }
6442         ~C2Tuple__u1632_u1632Z() { C2Tuple__u1632_u1632Z_free(self); }
6443         C2Tuple__u1632_u1632Z& operator=(C2Tuple__u1632_u1632Z&& o) { C2Tuple__u1632_u1632Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple__u1632_u1632Z)); return *this; }
6444         LDKC2Tuple__u1632_u1632Z* operator &() { return &self; }
6445         LDKC2Tuple__u1632_u1632Z* operator ->() { return &self; }
6446         const LDKC2Tuple__u1632_u1632Z* operator &() const { return &self; }
6447         const LDKC2Tuple__u1632_u1632Z* operator ->() const { return &self; }
6448 };
6449 class CResult_CVec_StrZIOErrorZ {
6450 private:
6451         LDKCResult_CVec_StrZIOErrorZ self;
6452 public:
6453         CResult_CVec_StrZIOErrorZ(const CResult_CVec_StrZIOErrorZ&) = delete;
6454         CResult_CVec_StrZIOErrorZ(CResult_CVec_StrZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_StrZIOErrorZ)); }
6455         CResult_CVec_StrZIOErrorZ(LDKCResult_CVec_StrZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_StrZIOErrorZ)); }
6456         operator LDKCResult_CVec_StrZIOErrorZ() && { LDKCResult_CVec_StrZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_StrZIOErrorZ)); return res; }
6457         ~CResult_CVec_StrZIOErrorZ() { CResult_CVec_StrZIOErrorZ_free(self); }
6458         CResult_CVec_StrZIOErrorZ& operator=(CResult_CVec_StrZIOErrorZ&& o) { CResult_CVec_StrZIOErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_StrZIOErrorZ)); return *this; }
6459         LDKCResult_CVec_StrZIOErrorZ* operator &() { return &self; }
6460         LDKCResult_CVec_StrZIOErrorZ* operator ->() { return &self; }
6461         const LDKCResult_CVec_StrZIOErrorZ* operator &() const { return &self; }
6462         const LDKCResult_CVec_StrZIOErrorZ* operator ->() const { return &self; }
6463 };
6464 class CResult_ClosingSignedFeeRangeDecodeErrorZ {
6465 private:
6466         LDKCResult_ClosingSignedFeeRangeDecodeErrorZ self;
6467 public:
6468         CResult_ClosingSignedFeeRangeDecodeErrorZ(const CResult_ClosingSignedFeeRangeDecodeErrorZ&) = delete;
6469         CResult_ClosingSignedFeeRangeDecodeErrorZ(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); }
6470         CResult_ClosingSignedFeeRangeDecodeErrorZ(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); }
6471         operator LDKCResult_ClosingSignedFeeRangeDecodeErrorZ() && { LDKCResult_ClosingSignedFeeRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); return res; }
6472         ~CResult_ClosingSignedFeeRangeDecodeErrorZ() { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); }
6473         CResult_ClosingSignedFeeRangeDecodeErrorZ& operator=(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); return *this; }
6474         LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() { return &self; }
6475         LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() { return &self; }
6476         const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() const { return &self; }
6477         const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() const { return &self; }
6478 };
6479 class CResult_TransactionNoneZ {
6480 private:
6481         LDKCResult_TransactionNoneZ self;
6482 public:
6483         CResult_TransactionNoneZ(const CResult_TransactionNoneZ&) = delete;
6484         CResult_TransactionNoneZ(CResult_TransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionNoneZ)); }
6485         CResult_TransactionNoneZ(LDKCResult_TransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionNoneZ)); }
6486         operator LDKCResult_TransactionNoneZ() && { LDKCResult_TransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionNoneZ)); return res; }
6487         ~CResult_TransactionNoneZ() { CResult_TransactionNoneZ_free(self); }
6488         CResult_TransactionNoneZ& operator=(CResult_TransactionNoneZ&& o) { CResult_TransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionNoneZ)); return *this; }
6489         LDKCResult_TransactionNoneZ* operator &() { return &self; }
6490         LDKCResult_TransactionNoneZ* operator ->() { return &self; }
6491         const LDKCResult_TransactionNoneZ* operator &() const { return &self; }
6492         const LDKCResult_TransactionNoneZ* operator ->() const { return &self; }
6493 };
6494 class CResult_CommitmentSignedDecodeErrorZ {
6495 private:
6496         LDKCResult_CommitmentSignedDecodeErrorZ self;
6497 public:
6498         CResult_CommitmentSignedDecodeErrorZ(const CResult_CommitmentSignedDecodeErrorZ&) = delete;
6499         CResult_CommitmentSignedDecodeErrorZ(CResult_CommitmentSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); }
6500         CResult_CommitmentSignedDecodeErrorZ(LDKCResult_CommitmentSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); }
6501         operator LDKCResult_CommitmentSignedDecodeErrorZ() && { LDKCResult_CommitmentSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); return res; }
6502         ~CResult_CommitmentSignedDecodeErrorZ() { CResult_CommitmentSignedDecodeErrorZ_free(self); }
6503         CResult_CommitmentSignedDecodeErrorZ& operator=(CResult_CommitmentSignedDecodeErrorZ&& o) { CResult_CommitmentSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); return *this; }
6504         LDKCResult_CommitmentSignedDecodeErrorZ* operator &() { return &self; }
6505         LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() { return &self; }
6506         const LDKCResult_CommitmentSignedDecodeErrorZ* operator &() const { return &self; }
6507         const LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() const { return &self; }
6508 };
6509 class CResult_CommitmentTransactionDecodeErrorZ {
6510 private:
6511         LDKCResult_CommitmentTransactionDecodeErrorZ self;
6512 public:
6513         CResult_CommitmentTransactionDecodeErrorZ(const CResult_CommitmentTransactionDecodeErrorZ&) = delete;
6514         CResult_CommitmentTransactionDecodeErrorZ(CResult_CommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); }
6515         CResult_CommitmentTransactionDecodeErrorZ(LDKCResult_CommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); }
6516         operator LDKCResult_CommitmentTransactionDecodeErrorZ() && { LDKCResult_CommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); return res; }
6517         ~CResult_CommitmentTransactionDecodeErrorZ() { CResult_CommitmentTransactionDecodeErrorZ_free(self); }
6518         CResult_CommitmentTransactionDecodeErrorZ& operator=(CResult_CommitmentTransactionDecodeErrorZ&& o) { CResult_CommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); return *this; }
6519         LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() { return &self; }
6520         LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
6521         const LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
6522         const LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
6523 };
6524 class CResult_ErrorMessageDecodeErrorZ {
6525 private:
6526         LDKCResult_ErrorMessageDecodeErrorZ self;
6527 public:
6528         CResult_ErrorMessageDecodeErrorZ(const CResult_ErrorMessageDecodeErrorZ&) = delete;
6529         CResult_ErrorMessageDecodeErrorZ(CResult_ErrorMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); }
6530         CResult_ErrorMessageDecodeErrorZ(LDKCResult_ErrorMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); }
6531         operator LDKCResult_ErrorMessageDecodeErrorZ() && { LDKCResult_ErrorMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); return res; }
6532         ~CResult_ErrorMessageDecodeErrorZ() { CResult_ErrorMessageDecodeErrorZ_free(self); }
6533         CResult_ErrorMessageDecodeErrorZ& operator=(CResult_ErrorMessageDecodeErrorZ&& o) { CResult_ErrorMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); return *this; }
6534         LDKCResult_ErrorMessageDecodeErrorZ* operator &() { return &self; }
6535         LDKCResult_ErrorMessageDecodeErrorZ* operator ->() { return &self; }
6536         const LDKCResult_ErrorMessageDecodeErrorZ* operator &() const { return &self; }
6537         const LDKCResult_ErrorMessageDecodeErrorZ* operator ->() const { return &self; }
6538 };
6539 class CResult_OpenChannelDecodeErrorZ {
6540 private:
6541         LDKCResult_OpenChannelDecodeErrorZ self;
6542 public:
6543         CResult_OpenChannelDecodeErrorZ(const CResult_OpenChannelDecodeErrorZ&) = delete;
6544         CResult_OpenChannelDecodeErrorZ(CResult_OpenChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); }
6545         CResult_OpenChannelDecodeErrorZ(LDKCResult_OpenChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); }
6546         operator LDKCResult_OpenChannelDecodeErrorZ() && { LDKCResult_OpenChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); return res; }
6547         ~CResult_OpenChannelDecodeErrorZ() { CResult_OpenChannelDecodeErrorZ_free(self); }
6548         CResult_OpenChannelDecodeErrorZ& operator=(CResult_OpenChannelDecodeErrorZ&& o) { CResult_OpenChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); return *this; }
6549         LDKCResult_OpenChannelDecodeErrorZ* operator &() { return &self; }
6550         LDKCResult_OpenChannelDecodeErrorZ* operator ->() { return &self; }
6551         const LDKCResult_OpenChannelDecodeErrorZ* operator &() const { return &self; }
6552         const LDKCResult_OpenChannelDecodeErrorZ* operator ->() const { return &self; }
6553 };
6554 class COption_APIErrorZ {
6555 private:
6556         LDKCOption_APIErrorZ self;
6557 public:
6558         COption_APIErrorZ(const COption_APIErrorZ&) = delete;
6559         COption_APIErrorZ(COption_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_APIErrorZ)); }
6560         COption_APIErrorZ(LDKCOption_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_APIErrorZ)); }
6561         operator LDKCOption_APIErrorZ() && { LDKCOption_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCOption_APIErrorZ)); return res; }
6562         ~COption_APIErrorZ() { COption_APIErrorZ_free(self); }
6563         COption_APIErrorZ& operator=(COption_APIErrorZ&& o) { COption_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_APIErrorZ)); return *this; }
6564         LDKCOption_APIErrorZ* operator &() { return &self; }
6565         LDKCOption_APIErrorZ* operator ->() { return &self; }
6566         const LDKCOption_APIErrorZ* operator &() const { return &self; }
6567         const LDKCOption_APIErrorZ* operator ->() const { return &self; }
6568 };
6569 class CResult_QueryChannelRangeDecodeErrorZ {
6570 private:
6571         LDKCResult_QueryChannelRangeDecodeErrorZ self;
6572 public:
6573         CResult_QueryChannelRangeDecodeErrorZ(const CResult_QueryChannelRangeDecodeErrorZ&) = delete;
6574         CResult_QueryChannelRangeDecodeErrorZ(CResult_QueryChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); }
6575         CResult_QueryChannelRangeDecodeErrorZ(LDKCResult_QueryChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); }
6576         operator LDKCResult_QueryChannelRangeDecodeErrorZ() && { LDKCResult_QueryChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); return res; }
6577         ~CResult_QueryChannelRangeDecodeErrorZ() { CResult_QueryChannelRangeDecodeErrorZ_free(self); }
6578         CResult_QueryChannelRangeDecodeErrorZ& operator=(CResult_QueryChannelRangeDecodeErrorZ&& o) { CResult_QueryChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); return *this; }
6579         LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() { return &self; }
6580         LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() { return &self; }
6581         const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
6582         const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
6583 };
6584 class CVec_TransactionZ {
6585 private:
6586         LDKCVec_TransactionZ self;
6587 public:
6588         CVec_TransactionZ(const CVec_TransactionZ&) = delete;
6589         CVec_TransactionZ(CVec_TransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionZ)); }
6590         CVec_TransactionZ(LDKCVec_TransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionZ)); }
6591         operator LDKCVec_TransactionZ() && { LDKCVec_TransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionZ)); return res; }
6592         ~CVec_TransactionZ() { CVec_TransactionZ_free(self); }
6593         CVec_TransactionZ& operator=(CVec_TransactionZ&& o) { CVec_TransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionZ)); return *this; }
6594         LDKCVec_TransactionZ* operator &() { return &self; }
6595         LDKCVec_TransactionZ* operator ->() { return &self; }
6596         const LDKCVec_TransactionZ* operator &() const { return &self; }
6597         const LDKCVec_TransactionZ* operator ->() const { return &self; }
6598 };
6599 class CVec_InputZ {
6600 private:
6601         LDKCVec_InputZ self;
6602 public:
6603         CVec_InputZ(const CVec_InputZ&) = delete;
6604         CVec_InputZ(CVec_InputZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_InputZ)); }
6605         CVec_InputZ(LDKCVec_InputZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_InputZ)); }
6606         operator LDKCVec_InputZ() && { LDKCVec_InputZ res = self; memset(&self, 0, sizeof(LDKCVec_InputZ)); return res; }
6607         ~CVec_InputZ() { CVec_InputZ_free(self); }
6608         CVec_InputZ& operator=(CVec_InputZ&& o) { CVec_InputZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_InputZ)); return *this; }
6609         LDKCVec_InputZ* operator &() { return &self; }
6610         LDKCVec_InputZ* operator ->() { return &self; }
6611         const LDKCVec_InputZ* operator &() const { return &self; }
6612         const LDKCVec_InputZ* operator ->() const { return &self; }
6613 };
6614 class CResult_ChannelFeaturesDecodeErrorZ {
6615 private:
6616         LDKCResult_ChannelFeaturesDecodeErrorZ self;
6617 public:
6618         CResult_ChannelFeaturesDecodeErrorZ(const CResult_ChannelFeaturesDecodeErrorZ&) = delete;
6619         CResult_ChannelFeaturesDecodeErrorZ(CResult_ChannelFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); }
6620         CResult_ChannelFeaturesDecodeErrorZ(LDKCResult_ChannelFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); }
6621         operator LDKCResult_ChannelFeaturesDecodeErrorZ() && { LDKCResult_ChannelFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); return res; }
6622         ~CResult_ChannelFeaturesDecodeErrorZ() { CResult_ChannelFeaturesDecodeErrorZ_free(self); }
6623         CResult_ChannelFeaturesDecodeErrorZ& operator=(CResult_ChannelFeaturesDecodeErrorZ&& o) { CResult_ChannelFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); return *this; }
6624         LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() { return &self; }
6625         LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() { return &self; }
6626         const LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() const { return &self; }
6627         const LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() const { return &self; }
6628 };
6629 class CResult_ChannelReadyDecodeErrorZ {
6630 private:
6631         LDKCResult_ChannelReadyDecodeErrorZ self;
6632 public:
6633         CResult_ChannelReadyDecodeErrorZ(const CResult_ChannelReadyDecodeErrorZ&) = delete;
6634         CResult_ChannelReadyDecodeErrorZ(CResult_ChannelReadyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelReadyDecodeErrorZ)); }
6635         CResult_ChannelReadyDecodeErrorZ(LDKCResult_ChannelReadyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelReadyDecodeErrorZ)); }
6636         operator LDKCResult_ChannelReadyDecodeErrorZ() && { LDKCResult_ChannelReadyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelReadyDecodeErrorZ)); return res; }
6637         ~CResult_ChannelReadyDecodeErrorZ() { CResult_ChannelReadyDecodeErrorZ_free(self); }
6638         CResult_ChannelReadyDecodeErrorZ& operator=(CResult_ChannelReadyDecodeErrorZ&& o) { CResult_ChannelReadyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelReadyDecodeErrorZ)); return *this; }
6639         LDKCResult_ChannelReadyDecodeErrorZ* operator &() { return &self; }
6640         LDKCResult_ChannelReadyDecodeErrorZ* operator ->() { return &self; }
6641         const LDKCResult_ChannelReadyDecodeErrorZ* operator &() const { return &self; }
6642         const LDKCResult_ChannelReadyDecodeErrorZ* operator ->() const { return &self; }
6643 };
6644 class CResult_UpdateFeeDecodeErrorZ {
6645 private:
6646         LDKCResult_UpdateFeeDecodeErrorZ self;
6647 public:
6648         CResult_UpdateFeeDecodeErrorZ(const CResult_UpdateFeeDecodeErrorZ&) = delete;
6649         CResult_UpdateFeeDecodeErrorZ(CResult_UpdateFeeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); }
6650         CResult_UpdateFeeDecodeErrorZ(LDKCResult_UpdateFeeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); }
6651         operator LDKCResult_UpdateFeeDecodeErrorZ() && { LDKCResult_UpdateFeeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); return res; }
6652         ~CResult_UpdateFeeDecodeErrorZ() { CResult_UpdateFeeDecodeErrorZ_free(self); }
6653         CResult_UpdateFeeDecodeErrorZ& operator=(CResult_UpdateFeeDecodeErrorZ&& o) { CResult_UpdateFeeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); return *this; }
6654         LDKCResult_UpdateFeeDecodeErrorZ* operator &() { return &self; }
6655         LDKCResult_UpdateFeeDecodeErrorZ* operator ->() { return &self; }
6656         const LDKCResult_UpdateFeeDecodeErrorZ* operator &() const { return &self; }
6657         const LDKCResult_UpdateFeeDecodeErrorZ* operator ->() const { return &self; }
6658 };
6659 class CResult_NoneBolt11SemanticErrorZ {
6660 private:
6661         LDKCResult_NoneBolt11SemanticErrorZ self;
6662 public:
6663         CResult_NoneBolt11SemanticErrorZ(const CResult_NoneBolt11SemanticErrorZ&) = delete;
6664         CResult_NoneBolt11SemanticErrorZ(CResult_NoneBolt11SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneBolt11SemanticErrorZ)); }
6665         CResult_NoneBolt11SemanticErrorZ(LDKCResult_NoneBolt11SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneBolt11SemanticErrorZ)); }
6666         operator LDKCResult_NoneBolt11SemanticErrorZ() && { LDKCResult_NoneBolt11SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneBolt11SemanticErrorZ)); return res; }
6667         ~CResult_NoneBolt11SemanticErrorZ() { CResult_NoneBolt11SemanticErrorZ_free(self); }
6668         CResult_NoneBolt11SemanticErrorZ& operator=(CResult_NoneBolt11SemanticErrorZ&& o) { CResult_NoneBolt11SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneBolt11SemanticErrorZ)); return *this; }
6669         LDKCResult_NoneBolt11SemanticErrorZ* operator &() { return &self; }
6670         LDKCResult_NoneBolt11SemanticErrorZ* operator ->() { return &self; }
6671         const LDKCResult_NoneBolt11SemanticErrorZ* operator &() const { return &self; }
6672         const LDKCResult_NoneBolt11SemanticErrorZ* operator ->() const { return &self; }
6673 };
6674 class COption_OnionMessageContentsZ {
6675 private:
6676         LDKCOption_OnionMessageContentsZ self;
6677 public:
6678         COption_OnionMessageContentsZ(const COption_OnionMessageContentsZ&) = delete;
6679         COption_OnionMessageContentsZ(COption_OnionMessageContentsZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_OnionMessageContentsZ)); }
6680         COption_OnionMessageContentsZ(LDKCOption_OnionMessageContentsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_OnionMessageContentsZ)); }
6681         operator LDKCOption_OnionMessageContentsZ() && { LDKCOption_OnionMessageContentsZ res = self; memset(&self, 0, sizeof(LDKCOption_OnionMessageContentsZ)); return res; }
6682         ~COption_OnionMessageContentsZ() { COption_OnionMessageContentsZ_free(self); }
6683         COption_OnionMessageContentsZ& operator=(COption_OnionMessageContentsZ&& o) { COption_OnionMessageContentsZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_OnionMessageContentsZ)); return *this; }
6684         LDKCOption_OnionMessageContentsZ* operator &() { return &self; }
6685         LDKCOption_OnionMessageContentsZ* operator ->() { return &self; }
6686         const LDKCOption_OnionMessageContentsZ* operator &() const { return &self; }
6687         const LDKCOption_OnionMessageContentsZ* operator ->() const { return &self; }
6688 };
6689 class CResult_NoneRetryableSendFailureZ {
6690 private:
6691         LDKCResult_NoneRetryableSendFailureZ self;
6692 public:
6693         CResult_NoneRetryableSendFailureZ(const CResult_NoneRetryableSendFailureZ&) = delete;
6694         CResult_NoneRetryableSendFailureZ(CResult_NoneRetryableSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneRetryableSendFailureZ)); }
6695         CResult_NoneRetryableSendFailureZ(LDKCResult_NoneRetryableSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneRetryableSendFailureZ)); }
6696         operator LDKCResult_NoneRetryableSendFailureZ() && { LDKCResult_NoneRetryableSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneRetryableSendFailureZ)); return res; }
6697         ~CResult_NoneRetryableSendFailureZ() { CResult_NoneRetryableSendFailureZ_free(self); }
6698         CResult_NoneRetryableSendFailureZ& operator=(CResult_NoneRetryableSendFailureZ&& o) { CResult_NoneRetryableSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneRetryableSendFailureZ)); return *this; }
6699         LDKCResult_NoneRetryableSendFailureZ* operator &() { return &self; }
6700         LDKCResult_NoneRetryableSendFailureZ* operator ->() { return &self; }
6701         const LDKCResult_NoneRetryableSendFailureZ* operator &() const { return &self; }
6702         const LDKCResult_NoneRetryableSendFailureZ* operator ->() const { return &self; }
6703 };
6704 class CResult_boolLightningErrorZ {
6705 private:
6706         LDKCResult_boolLightningErrorZ self;
6707 public:
6708         CResult_boolLightningErrorZ(const CResult_boolLightningErrorZ&) = delete;
6709         CResult_boolLightningErrorZ(CResult_boolLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); }
6710         CResult_boolLightningErrorZ(LDKCResult_boolLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolLightningErrorZ)); }
6711         operator LDKCResult_boolLightningErrorZ() && { LDKCResult_boolLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolLightningErrorZ)); return res; }
6712         ~CResult_boolLightningErrorZ() { CResult_boolLightningErrorZ_free(self); }
6713         CResult_boolLightningErrorZ& operator=(CResult_boolLightningErrorZ&& o) { CResult_boolLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); return *this; }
6714         LDKCResult_boolLightningErrorZ* operator &() { return &self; }
6715         LDKCResult_boolLightningErrorZ* operator ->() { return &self; }
6716         const LDKCResult_boolLightningErrorZ* operator &() const { return &self; }
6717         const LDKCResult_boolLightningErrorZ* operator ->() const { return &self; }
6718 };
6719 class CResult_NodeIdDecodeErrorZ {
6720 private:
6721         LDKCResult_NodeIdDecodeErrorZ self;
6722 public:
6723         CResult_NodeIdDecodeErrorZ(const CResult_NodeIdDecodeErrorZ&) = delete;
6724         CResult_NodeIdDecodeErrorZ(CResult_NodeIdDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); }
6725         CResult_NodeIdDecodeErrorZ(LDKCResult_NodeIdDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); }
6726         operator LDKCResult_NodeIdDecodeErrorZ() && { LDKCResult_NodeIdDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); return res; }
6727         ~CResult_NodeIdDecodeErrorZ() { CResult_NodeIdDecodeErrorZ_free(self); }
6728         CResult_NodeIdDecodeErrorZ& operator=(CResult_NodeIdDecodeErrorZ&& o) { CResult_NodeIdDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); return *this; }
6729         LDKCResult_NodeIdDecodeErrorZ* operator &() { return &self; }
6730         LDKCResult_NodeIdDecodeErrorZ* operator ->() { return &self; }
6731         const LDKCResult_NodeIdDecodeErrorZ* operator &() const { return &self; }
6732         const LDKCResult_NodeIdDecodeErrorZ* operator ->() const { return &self; }
6733 };
6734 class CResult_ChannelShutdownStateDecodeErrorZ {
6735 private:
6736         LDKCResult_ChannelShutdownStateDecodeErrorZ self;
6737 public:
6738         CResult_ChannelShutdownStateDecodeErrorZ(const CResult_ChannelShutdownStateDecodeErrorZ&) = delete;
6739         CResult_ChannelShutdownStateDecodeErrorZ(CResult_ChannelShutdownStateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelShutdownStateDecodeErrorZ)); }
6740         CResult_ChannelShutdownStateDecodeErrorZ(LDKCResult_ChannelShutdownStateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelShutdownStateDecodeErrorZ)); }
6741         operator LDKCResult_ChannelShutdownStateDecodeErrorZ() && { LDKCResult_ChannelShutdownStateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelShutdownStateDecodeErrorZ)); return res; }
6742         ~CResult_ChannelShutdownStateDecodeErrorZ() { CResult_ChannelShutdownStateDecodeErrorZ_free(self); }
6743         CResult_ChannelShutdownStateDecodeErrorZ& operator=(CResult_ChannelShutdownStateDecodeErrorZ&& o) { CResult_ChannelShutdownStateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelShutdownStateDecodeErrorZ)); return *this; }
6744         LDKCResult_ChannelShutdownStateDecodeErrorZ* operator &() { return &self; }
6745         LDKCResult_ChannelShutdownStateDecodeErrorZ* operator ->() { return &self; }
6746         const LDKCResult_ChannelShutdownStateDecodeErrorZ* operator &() const { return &self; }
6747         const LDKCResult_ChannelShutdownStateDecodeErrorZ* operator ->() const { return &self; }
6748 };
6749 class CResult_HTLCOutputInCommitmentDecodeErrorZ {
6750 private:
6751         LDKCResult_HTLCOutputInCommitmentDecodeErrorZ self;
6752 public:
6753         CResult_HTLCOutputInCommitmentDecodeErrorZ(const CResult_HTLCOutputInCommitmentDecodeErrorZ&) = delete;
6754         CResult_HTLCOutputInCommitmentDecodeErrorZ(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); }
6755         CResult_HTLCOutputInCommitmentDecodeErrorZ(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); }
6756         operator LDKCResult_HTLCOutputInCommitmentDecodeErrorZ() && { LDKCResult_HTLCOutputInCommitmentDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); return res; }
6757         ~CResult_HTLCOutputInCommitmentDecodeErrorZ() { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); }
6758         CResult_HTLCOutputInCommitmentDecodeErrorZ& operator=(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); return *this; }
6759         LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() { return &self; }
6760         LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() { return &self; }
6761         const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() const { return &self; }
6762         const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() const { return &self; }
6763 };
6764 class CResult_NodeAnnouncementInfoDecodeErrorZ {
6765 private:
6766         LDKCResult_NodeAnnouncementInfoDecodeErrorZ self;
6767 public:
6768         CResult_NodeAnnouncementInfoDecodeErrorZ(const CResult_NodeAnnouncementInfoDecodeErrorZ&) = delete;
6769         CResult_NodeAnnouncementInfoDecodeErrorZ(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); }
6770         CResult_NodeAnnouncementInfoDecodeErrorZ(LDKCResult_NodeAnnouncementInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); }
6771         operator LDKCResult_NodeAnnouncementInfoDecodeErrorZ() && { LDKCResult_NodeAnnouncementInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); return res; }
6772         ~CResult_NodeAnnouncementInfoDecodeErrorZ() { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); }
6773         CResult_NodeAnnouncementInfoDecodeErrorZ& operator=(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); return *this; }
6774         LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() { return &self; }
6775         LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() { return &self; }
6776         const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() const { return &self; }
6777         const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() const { return &self; }
6778 };
6779 class CResult_ShutdownScriptInvalidShutdownScriptZ {
6780 private:
6781         LDKCResult_ShutdownScriptInvalidShutdownScriptZ self;
6782 public:
6783         CResult_ShutdownScriptInvalidShutdownScriptZ(const CResult_ShutdownScriptInvalidShutdownScriptZ&) = delete;
6784         CResult_ShutdownScriptInvalidShutdownScriptZ(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); }
6785         CResult_ShutdownScriptInvalidShutdownScriptZ(LDKCResult_ShutdownScriptInvalidShutdownScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); }
6786         operator LDKCResult_ShutdownScriptInvalidShutdownScriptZ() && { LDKCResult_ShutdownScriptInvalidShutdownScriptZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); return res; }
6787         ~CResult_ShutdownScriptInvalidShutdownScriptZ() { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); }
6788         CResult_ShutdownScriptInvalidShutdownScriptZ& operator=(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); return *this; }
6789         LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() { return &self; }
6790         LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() { return &self; }
6791         const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() const { return &self; }
6792         const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() const { return &self; }
6793 };
6794 class CResult_COption_NetworkUpdateZDecodeErrorZ {
6795 private:
6796         LDKCResult_COption_NetworkUpdateZDecodeErrorZ self;
6797 public:
6798         CResult_COption_NetworkUpdateZDecodeErrorZ(const CResult_COption_NetworkUpdateZDecodeErrorZ&) = delete;
6799         CResult_COption_NetworkUpdateZDecodeErrorZ(CResult_COption_NetworkUpdateZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_NetworkUpdateZDecodeErrorZ)); }
6800         CResult_COption_NetworkUpdateZDecodeErrorZ(LDKCResult_COption_NetworkUpdateZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); }
6801         operator LDKCResult_COption_NetworkUpdateZDecodeErrorZ() && { LDKCResult_COption_NetworkUpdateZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); return res; }
6802         ~CResult_COption_NetworkUpdateZDecodeErrorZ() { CResult_COption_NetworkUpdateZDecodeErrorZ_free(self); }
6803         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; }
6804         LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() { return &self; }
6805         LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() { return &self; }
6806         const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() const { return &self; }
6807         const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() const { return &self; }
6808 };
6809 class CVec_UpdateFailMalformedHTLCZ {
6810 private:
6811         LDKCVec_UpdateFailMalformedHTLCZ self;
6812 public:
6813         CVec_UpdateFailMalformedHTLCZ(const CVec_UpdateFailMalformedHTLCZ&) = delete;
6814         CVec_UpdateFailMalformedHTLCZ(CVec_UpdateFailMalformedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); }
6815         CVec_UpdateFailMalformedHTLCZ(LDKCVec_UpdateFailMalformedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); }
6816         operator LDKCVec_UpdateFailMalformedHTLCZ() && { LDKCVec_UpdateFailMalformedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); return res; }
6817         ~CVec_UpdateFailMalformedHTLCZ() { CVec_UpdateFailMalformedHTLCZ_free(self); }
6818         CVec_UpdateFailMalformedHTLCZ& operator=(CVec_UpdateFailMalformedHTLCZ&& o) { CVec_UpdateFailMalformedHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); return *this; }
6819         LDKCVec_UpdateFailMalformedHTLCZ* operator &() { return &self; }
6820         LDKCVec_UpdateFailMalformedHTLCZ* operator ->() { return &self; }
6821         const LDKCVec_UpdateFailMalformedHTLCZ* operator &() const { return &self; }
6822         const LDKCVec_UpdateFailMalformedHTLCZ* operator ->() const { return &self; }
6823 };
6824 class CResult_ShutdownScriptNoneZ {
6825 private:
6826         LDKCResult_ShutdownScriptNoneZ self;
6827 public:
6828         CResult_ShutdownScriptNoneZ(const CResult_ShutdownScriptNoneZ&) = delete;
6829         CResult_ShutdownScriptNoneZ(CResult_ShutdownScriptNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptNoneZ)); }
6830         CResult_ShutdownScriptNoneZ(LDKCResult_ShutdownScriptNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptNoneZ)); }
6831         operator LDKCResult_ShutdownScriptNoneZ() && { LDKCResult_ShutdownScriptNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptNoneZ)); return res; }
6832         ~CResult_ShutdownScriptNoneZ() { CResult_ShutdownScriptNoneZ_free(self); }
6833         CResult_ShutdownScriptNoneZ& operator=(CResult_ShutdownScriptNoneZ&& o) { CResult_ShutdownScriptNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptNoneZ)); return *this; }
6834         LDKCResult_ShutdownScriptNoneZ* operator &() { return &self; }
6835         LDKCResult_ShutdownScriptNoneZ* operator ->() { return &self; }
6836         const LDKCResult_ShutdownScriptNoneZ* operator &() const { return &self; }
6837         const LDKCResult_ShutdownScriptNoneZ* operator ->() const { return &self; }
6838 };
6839 class COption_HTLCDestinationZ {
6840 private:
6841         LDKCOption_HTLCDestinationZ self;
6842 public:
6843         COption_HTLCDestinationZ(const COption_HTLCDestinationZ&) = delete;
6844         COption_HTLCDestinationZ(COption_HTLCDestinationZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_HTLCDestinationZ)); }
6845         COption_HTLCDestinationZ(LDKCOption_HTLCDestinationZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_HTLCDestinationZ)); }
6846         operator LDKCOption_HTLCDestinationZ() && { LDKCOption_HTLCDestinationZ res = self; memset(&self, 0, sizeof(LDKCOption_HTLCDestinationZ)); return res; }
6847         ~COption_HTLCDestinationZ() { COption_HTLCDestinationZ_free(self); }
6848         COption_HTLCDestinationZ& operator=(COption_HTLCDestinationZ&& o) { COption_HTLCDestinationZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_HTLCDestinationZ)); return *this; }
6849         LDKCOption_HTLCDestinationZ* operator &() { return &self; }
6850         LDKCOption_HTLCDestinationZ* operator ->() { return &self; }
6851         const LDKCOption_HTLCDestinationZ* operator &() const { return &self; }
6852         const LDKCOption_HTLCDestinationZ* operator ->() const { return &self; }
6853 };
6854 class CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ {
6855 private:
6856         LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ self;
6857 public:
6858         CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(const CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&) = delete;
6859         CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); }
6860         CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); }
6861         operator LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ() && { LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); return res; }
6862         ~CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ() { CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(self); }
6863         CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ& operator=(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& o) { CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); return *this; }
6864         LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator &() { return &self; }
6865         LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator ->() { return &self; }
6866         const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator &() const { return &self; }
6867         const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator ->() const { return &self; }
6868 };
6869 class CVec_RouteHopZ {
6870 private:
6871         LDKCVec_RouteHopZ self;
6872 public:
6873         CVec_RouteHopZ(const CVec_RouteHopZ&) = delete;
6874         CVec_RouteHopZ(CVec_RouteHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHopZ)); }
6875         CVec_RouteHopZ(LDKCVec_RouteHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHopZ)); }
6876         operator LDKCVec_RouteHopZ() && { LDKCVec_RouteHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHopZ)); return res; }
6877         ~CVec_RouteHopZ() { CVec_RouteHopZ_free(self); }
6878         CVec_RouteHopZ& operator=(CVec_RouteHopZ&& o) { CVec_RouteHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHopZ)); return *this; }
6879         LDKCVec_RouteHopZ* operator &() { return &self; }
6880         LDKCVec_RouteHopZ* operator ->() { return &self; }
6881         const LDKCVec_RouteHopZ* operator &() const { return &self; }
6882         const LDKCVec_RouteHopZ* operator ->() const { return &self; }
6883 };
6884 class CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ {
6885 private:
6886         LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ self;
6887 public:
6888         CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ(const CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&) = delete;
6889         CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ(CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); }
6890         CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ(LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); }
6891         operator LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ() && { LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); return res; }
6892         ~CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ() { CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(self); }
6893         CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ& operator=(CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&& o) { CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); return *this; }
6894         LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator &() { return &self; }
6895         LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator ->() { return &self; }
6896         const LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator &() const { return &self; }
6897         const LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator ->() const { return &self; }
6898 };
6899 class CResult_CVec_UtxoZNoneZ {
6900 private:
6901         LDKCResult_CVec_UtxoZNoneZ self;
6902 public:
6903         CResult_CVec_UtxoZNoneZ(const CResult_CVec_UtxoZNoneZ&) = delete;
6904         CResult_CVec_UtxoZNoneZ(CResult_CVec_UtxoZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_UtxoZNoneZ)); }
6905         CResult_CVec_UtxoZNoneZ(LDKCResult_CVec_UtxoZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_UtxoZNoneZ)); }
6906         operator LDKCResult_CVec_UtxoZNoneZ() && { LDKCResult_CVec_UtxoZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_UtxoZNoneZ)); return res; }
6907         ~CResult_CVec_UtxoZNoneZ() { CResult_CVec_UtxoZNoneZ_free(self); }
6908         CResult_CVec_UtxoZNoneZ& operator=(CResult_CVec_UtxoZNoneZ&& o) { CResult_CVec_UtxoZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_UtxoZNoneZ)); return *this; }
6909         LDKCResult_CVec_UtxoZNoneZ* operator &() { return &self; }
6910         LDKCResult_CVec_UtxoZNoneZ* operator ->() { return &self; }
6911         const LDKCResult_CVec_UtxoZNoneZ* operator &() const { return &self; }
6912         const LDKCResult_CVec_UtxoZNoneZ* operator ->() const { return &self; }
6913 };
6914 class CResult_CVec_u8ZIOErrorZ {
6915 private:
6916         LDKCResult_CVec_u8ZIOErrorZ self;
6917 public:
6918         CResult_CVec_u8ZIOErrorZ(const CResult_CVec_u8ZIOErrorZ&) = delete;
6919         CResult_CVec_u8ZIOErrorZ(CResult_CVec_u8ZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZIOErrorZ)); }
6920         CResult_CVec_u8ZIOErrorZ(LDKCResult_CVec_u8ZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZIOErrorZ)); }
6921         operator LDKCResult_CVec_u8ZIOErrorZ() && { LDKCResult_CVec_u8ZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZIOErrorZ)); return res; }
6922         ~CResult_CVec_u8ZIOErrorZ() { CResult_CVec_u8ZIOErrorZ_free(self); }
6923         CResult_CVec_u8ZIOErrorZ& operator=(CResult_CVec_u8ZIOErrorZ&& o) { CResult_CVec_u8ZIOErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_u8ZIOErrorZ)); return *this; }
6924         LDKCResult_CVec_u8ZIOErrorZ* operator &() { return &self; }
6925         LDKCResult_CVec_u8ZIOErrorZ* operator ->() { return &self; }
6926         const LDKCResult_CVec_u8ZIOErrorZ* operator &() const { return &self; }
6927         const LDKCResult_CVec_u8ZIOErrorZ* operator ->() const { return &self; }
6928 };
6929 class C3Tuple_OffersMessageDestinationBlindedPathZ {
6930 private:
6931         LDKC3Tuple_OffersMessageDestinationBlindedPathZ self;
6932 public:
6933         C3Tuple_OffersMessageDestinationBlindedPathZ(const C3Tuple_OffersMessageDestinationBlindedPathZ&) = delete;
6934         C3Tuple_OffersMessageDestinationBlindedPathZ(C3Tuple_OffersMessageDestinationBlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_OffersMessageDestinationBlindedPathZ)); }
6935         C3Tuple_OffersMessageDestinationBlindedPathZ(LDKC3Tuple_OffersMessageDestinationBlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_OffersMessageDestinationBlindedPathZ)); }
6936         operator LDKC3Tuple_OffersMessageDestinationBlindedPathZ() && { LDKC3Tuple_OffersMessageDestinationBlindedPathZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_OffersMessageDestinationBlindedPathZ)); return res; }
6937         ~C3Tuple_OffersMessageDestinationBlindedPathZ() { C3Tuple_OffersMessageDestinationBlindedPathZ_free(self); }
6938         C3Tuple_OffersMessageDestinationBlindedPathZ& operator=(C3Tuple_OffersMessageDestinationBlindedPathZ&& o) { C3Tuple_OffersMessageDestinationBlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_OffersMessageDestinationBlindedPathZ)); return *this; }
6939         LDKC3Tuple_OffersMessageDestinationBlindedPathZ* operator &() { return &self; }
6940         LDKC3Tuple_OffersMessageDestinationBlindedPathZ* operator ->() { return &self; }
6941         const LDKC3Tuple_OffersMessageDestinationBlindedPathZ* operator &() const { return &self; }
6942         const LDKC3Tuple_OffersMessageDestinationBlindedPathZ* operator ->() const { return &self; }
6943 };
6944 class CVec_ThirtyTwoBytesZ {
6945 private:
6946         LDKCVec_ThirtyTwoBytesZ self;
6947 public:
6948         CVec_ThirtyTwoBytesZ(const CVec_ThirtyTwoBytesZ&) = delete;
6949         CVec_ThirtyTwoBytesZ(CVec_ThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); }
6950         CVec_ThirtyTwoBytesZ(LDKCVec_ThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); }
6951         operator LDKCVec_ThirtyTwoBytesZ() && { LDKCVec_ThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); return res; }
6952         ~CVec_ThirtyTwoBytesZ() { CVec_ThirtyTwoBytesZ_free(self); }
6953         CVec_ThirtyTwoBytesZ& operator=(CVec_ThirtyTwoBytesZ&& o) { CVec_ThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); return *this; }
6954         LDKCVec_ThirtyTwoBytesZ* operator &() { return &self; }
6955         LDKCVec_ThirtyTwoBytesZ* operator ->() { return &self; }
6956         const LDKCVec_ThirtyTwoBytesZ* operator &() const { return &self; }
6957         const LDKCVec_ThirtyTwoBytesZ* operator ->() const { return &self; }
6958 };
6959 class CResult_ChannelMonitorUpdateStatusNoneZ {
6960 private:
6961         LDKCResult_ChannelMonitorUpdateStatusNoneZ self;
6962 public:
6963         CResult_ChannelMonitorUpdateStatusNoneZ(const CResult_ChannelMonitorUpdateStatusNoneZ&) = delete;
6964         CResult_ChannelMonitorUpdateStatusNoneZ(CResult_ChannelMonitorUpdateStatusNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateStatusNoneZ)); }
6965         CResult_ChannelMonitorUpdateStatusNoneZ(LDKCResult_ChannelMonitorUpdateStatusNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateStatusNoneZ)); }
6966         operator LDKCResult_ChannelMonitorUpdateStatusNoneZ() && { LDKCResult_ChannelMonitorUpdateStatusNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateStatusNoneZ)); return res; }
6967         ~CResult_ChannelMonitorUpdateStatusNoneZ() { CResult_ChannelMonitorUpdateStatusNoneZ_free(self); }
6968         CResult_ChannelMonitorUpdateStatusNoneZ& operator=(CResult_ChannelMonitorUpdateStatusNoneZ&& o) { CResult_ChannelMonitorUpdateStatusNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateStatusNoneZ)); return *this; }
6969         LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator &() { return &self; }
6970         LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator ->() { return &self; }
6971         const LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator &() const { return &self; }
6972         const LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator ->() const { return &self; }
6973 };
6974 class CResult_ClosingSignedDecodeErrorZ {
6975 private:
6976         LDKCResult_ClosingSignedDecodeErrorZ self;
6977 public:
6978         CResult_ClosingSignedDecodeErrorZ(const CResult_ClosingSignedDecodeErrorZ&) = delete;
6979         CResult_ClosingSignedDecodeErrorZ(CResult_ClosingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); }
6980         CResult_ClosingSignedDecodeErrorZ(LDKCResult_ClosingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); }
6981         operator LDKCResult_ClosingSignedDecodeErrorZ() && { LDKCResult_ClosingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); return res; }
6982         ~CResult_ClosingSignedDecodeErrorZ() { CResult_ClosingSignedDecodeErrorZ_free(self); }
6983         CResult_ClosingSignedDecodeErrorZ& operator=(CResult_ClosingSignedDecodeErrorZ&& o) { CResult_ClosingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); return *this; }
6984         LDKCResult_ClosingSignedDecodeErrorZ* operator &() { return &self; }
6985         LDKCResult_ClosingSignedDecodeErrorZ* operator ->() { return &self; }
6986         const LDKCResult_ClosingSignedDecodeErrorZ* operator &() const { return &self; }
6987         const LDKCResult_ClosingSignedDecodeErrorZ* operator ->() const { return &self; }
6988 };
6989 class CResult_NonePaymentErrorZ {
6990 private:
6991         LDKCResult_NonePaymentErrorZ self;
6992 public:
6993         CResult_NonePaymentErrorZ(const CResult_NonePaymentErrorZ&) = delete;
6994         CResult_NonePaymentErrorZ(CResult_NonePaymentErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentErrorZ)); }
6995         CResult_NonePaymentErrorZ(LDKCResult_NonePaymentErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentErrorZ)); }
6996         operator LDKCResult_NonePaymentErrorZ() && { LDKCResult_NonePaymentErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentErrorZ)); return res; }
6997         ~CResult_NonePaymentErrorZ() { CResult_NonePaymentErrorZ_free(self); }
6998         CResult_NonePaymentErrorZ& operator=(CResult_NonePaymentErrorZ&& o) { CResult_NonePaymentErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentErrorZ)); return *this; }
6999         LDKCResult_NonePaymentErrorZ* operator &() { return &self; }
7000         LDKCResult_NonePaymentErrorZ* operator ->() { return &self; }
7001         const LDKCResult_NonePaymentErrorZ* operator &() const { return &self; }
7002         const LDKCResult_NonePaymentErrorZ* operator ->() const { return &self; }
7003 };
7004 class CVec_CResult_NoneAPIErrorZZ {
7005 private:
7006         LDKCVec_CResult_NoneAPIErrorZZ self;
7007 public:
7008         CVec_CResult_NoneAPIErrorZZ(const CVec_CResult_NoneAPIErrorZZ&) = delete;
7009         CVec_CResult_NoneAPIErrorZZ(CVec_CResult_NoneAPIErrorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CResult_NoneAPIErrorZZ)); }
7010         CVec_CResult_NoneAPIErrorZZ(LDKCVec_CResult_NoneAPIErrorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); }
7011         operator LDKCVec_CResult_NoneAPIErrorZZ() && { LDKCVec_CResult_NoneAPIErrorZZ res = self; memset(&self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); return res; }
7012         ~CVec_CResult_NoneAPIErrorZZ() { CVec_CResult_NoneAPIErrorZZ_free(self); }
7013         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; }
7014         LDKCVec_CResult_NoneAPIErrorZZ* operator &() { return &self; }
7015         LDKCVec_CResult_NoneAPIErrorZZ* operator ->() { return &self; }
7016         const LDKCVec_CResult_NoneAPIErrorZZ* operator &() const { return &self; }
7017         const LDKCVec_CResult_NoneAPIErrorZZ* operator ->() const { return &self; }
7018 };
7019 class CResult_SchnorrSignatureNoneZ {
7020 private:
7021         LDKCResult_SchnorrSignatureNoneZ self;
7022 public:
7023         CResult_SchnorrSignatureNoneZ(const CResult_SchnorrSignatureNoneZ&) = delete;
7024         CResult_SchnorrSignatureNoneZ(CResult_SchnorrSignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SchnorrSignatureNoneZ)); }
7025         CResult_SchnorrSignatureNoneZ(LDKCResult_SchnorrSignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SchnorrSignatureNoneZ)); }
7026         operator LDKCResult_SchnorrSignatureNoneZ() && { LDKCResult_SchnorrSignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SchnorrSignatureNoneZ)); return res; }
7027         ~CResult_SchnorrSignatureNoneZ() { CResult_SchnorrSignatureNoneZ_free(self); }
7028         CResult_SchnorrSignatureNoneZ& operator=(CResult_SchnorrSignatureNoneZ&& o) { CResult_SchnorrSignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SchnorrSignatureNoneZ)); return *this; }
7029         LDKCResult_SchnorrSignatureNoneZ* operator &() { return &self; }
7030         LDKCResult_SchnorrSignatureNoneZ* operator ->() { return &self; }
7031         const LDKCResult_SchnorrSignatureNoneZ* operator &() const { return &self; }
7032         const LDKCResult_SchnorrSignatureNoneZ* operator ->() const { return &self; }
7033 };
7034 class CResult_CounterpartyCommitmentSecretsDecodeErrorZ {
7035 private:
7036         LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ self;
7037 public:
7038         CResult_CounterpartyCommitmentSecretsDecodeErrorZ(const CResult_CounterpartyCommitmentSecretsDecodeErrorZ&) = delete;
7039         CResult_CounterpartyCommitmentSecretsDecodeErrorZ(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
7040         CResult_CounterpartyCommitmentSecretsDecodeErrorZ(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
7041         operator LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ() && { LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return res; }
7042         ~CResult_CounterpartyCommitmentSecretsDecodeErrorZ() { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); }
7043         CResult_CounterpartyCommitmentSecretsDecodeErrorZ& operator=(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return *this; }
7044         LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() { return &self; }
7045         LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() { return &self; }
7046         const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() const { return &self; }
7047         const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() const { return &self; }
7048 };
7049 class CResult_ReceiveTlvsDecodeErrorZ {
7050 private:
7051         LDKCResult_ReceiveTlvsDecodeErrorZ self;
7052 public:
7053         CResult_ReceiveTlvsDecodeErrorZ(const CResult_ReceiveTlvsDecodeErrorZ&) = delete;
7054         CResult_ReceiveTlvsDecodeErrorZ(CResult_ReceiveTlvsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReceiveTlvsDecodeErrorZ)); }
7055         CResult_ReceiveTlvsDecodeErrorZ(LDKCResult_ReceiveTlvsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReceiveTlvsDecodeErrorZ)); }
7056         operator LDKCResult_ReceiveTlvsDecodeErrorZ() && { LDKCResult_ReceiveTlvsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReceiveTlvsDecodeErrorZ)); return res; }
7057         ~CResult_ReceiveTlvsDecodeErrorZ() { CResult_ReceiveTlvsDecodeErrorZ_free(self); }
7058         CResult_ReceiveTlvsDecodeErrorZ& operator=(CResult_ReceiveTlvsDecodeErrorZ&& o) { CResult_ReceiveTlvsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReceiveTlvsDecodeErrorZ)); return *this; }
7059         LDKCResult_ReceiveTlvsDecodeErrorZ* operator &() { return &self; }
7060         LDKCResult_ReceiveTlvsDecodeErrorZ* operator ->() { return &self; }
7061         const LDKCResult_ReceiveTlvsDecodeErrorZ* operator &() const { return &self; }
7062         const LDKCResult_ReceiveTlvsDecodeErrorZ* operator ->() const { return &self; }
7063 };
7064 class CResult_HTLCDescriptorDecodeErrorZ {
7065 private:
7066         LDKCResult_HTLCDescriptorDecodeErrorZ self;
7067 public:
7068         CResult_HTLCDescriptorDecodeErrorZ(const CResult_HTLCDescriptorDecodeErrorZ&) = delete;
7069         CResult_HTLCDescriptorDecodeErrorZ(CResult_HTLCDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCDescriptorDecodeErrorZ)); }
7070         CResult_HTLCDescriptorDecodeErrorZ(LDKCResult_HTLCDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCDescriptorDecodeErrorZ)); }
7071         operator LDKCResult_HTLCDescriptorDecodeErrorZ() && { LDKCResult_HTLCDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCDescriptorDecodeErrorZ)); return res; }
7072         ~CResult_HTLCDescriptorDecodeErrorZ() { CResult_HTLCDescriptorDecodeErrorZ_free(self); }
7073         CResult_HTLCDescriptorDecodeErrorZ& operator=(CResult_HTLCDescriptorDecodeErrorZ&& o) { CResult_HTLCDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCDescriptorDecodeErrorZ)); return *this; }
7074         LDKCResult_HTLCDescriptorDecodeErrorZ* operator &() { return &self; }
7075         LDKCResult_HTLCDescriptorDecodeErrorZ* operator ->() { return &self; }
7076         const LDKCResult_HTLCDescriptorDecodeErrorZ* operator &() const { return &self; }
7077         const LDKCResult_HTLCDescriptorDecodeErrorZ* operator ->() const { return &self; }
7078 };
7079 class CVec_RecentPaymentDetailsZ {
7080 private:
7081         LDKCVec_RecentPaymentDetailsZ self;
7082 public:
7083         CVec_RecentPaymentDetailsZ(const CVec_RecentPaymentDetailsZ&) = delete;
7084         CVec_RecentPaymentDetailsZ(CVec_RecentPaymentDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RecentPaymentDetailsZ)); }
7085         CVec_RecentPaymentDetailsZ(LDKCVec_RecentPaymentDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RecentPaymentDetailsZ)); }
7086         operator LDKCVec_RecentPaymentDetailsZ() && { LDKCVec_RecentPaymentDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_RecentPaymentDetailsZ)); return res; }
7087         ~CVec_RecentPaymentDetailsZ() { CVec_RecentPaymentDetailsZ_free(self); }
7088         CVec_RecentPaymentDetailsZ& operator=(CVec_RecentPaymentDetailsZ&& o) { CVec_RecentPaymentDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RecentPaymentDetailsZ)); return *this; }
7089         LDKCVec_RecentPaymentDetailsZ* operator &() { return &self; }
7090         LDKCVec_RecentPaymentDetailsZ* operator ->() { return &self; }
7091         const LDKCVec_RecentPaymentDetailsZ* operator &() const { return &self; }
7092         const LDKCVec_RecentPaymentDetailsZ* operator ->() const { return &self; }
7093 };
7094 class CVec_RouteHintHopZ {
7095 private:
7096         LDKCVec_RouteHintHopZ self;
7097 public:
7098         CVec_RouteHintHopZ(const CVec_RouteHintHopZ&) = delete;
7099         CVec_RouteHintHopZ(CVec_RouteHintHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintHopZ)); }
7100         CVec_RouteHintHopZ(LDKCVec_RouteHintHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintHopZ)); }
7101         operator LDKCVec_RouteHintHopZ() && { LDKCVec_RouteHintHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintHopZ)); return res; }
7102         ~CVec_RouteHintHopZ() { CVec_RouteHintHopZ_free(self); }
7103         CVec_RouteHintHopZ& operator=(CVec_RouteHintHopZ&& o) { CVec_RouteHintHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintHopZ)); return *this; }
7104         LDKCVec_RouteHintHopZ* operator &() { return &self; }
7105         LDKCVec_RouteHintHopZ* operator ->() { return &self; }
7106         const LDKCVec_RouteHintHopZ* operator &() const { return &self; }
7107         const LDKCVec_RouteHintHopZ* operator ->() const { return &self; }
7108 };
7109 class CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ {
7110 private:
7111         LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ self;
7112 public:
7113         CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ(const CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ&) = delete;
7114         CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ(CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ)); }
7115         CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ(LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ)); }
7116         operator LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ() && { LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ)); return res; }
7117         ~CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ() { CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ_free(self); }
7118         CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ& operator=(CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ&& o) { CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ)); return *this; }
7119         LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ* operator &() { return &self; }
7120         LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ* operator ->() { return &self; }
7121         const LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ* operator &() const { return &self; }
7122         const LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ* operator ->() const { return &self; }
7123 };
7124 class CResult_UntrustedStringDecodeErrorZ {
7125 private:
7126         LDKCResult_UntrustedStringDecodeErrorZ self;
7127 public:
7128         CResult_UntrustedStringDecodeErrorZ(const CResult_UntrustedStringDecodeErrorZ&) = delete;
7129         CResult_UntrustedStringDecodeErrorZ(CResult_UntrustedStringDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UntrustedStringDecodeErrorZ)); }
7130         CResult_UntrustedStringDecodeErrorZ(LDKCResult_UntrustedStringDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UntrustedStringDecodeErrorZ)); }
7131         operator LDKCResult_UntrustedStringDecodeErrorZ() && { LDKCResult_UntrustedStringDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UntrustedStringDecodeErrorZ)); return res; }
7132         ~CResult_UntrustedStringDecodeErrorZ() { CResult_UntrustedStringDecodeErrorZ_free(self); }
7133         CResult_UntrustedStringDecodeErrorZ& operator=(CResult_UntrustedStringDecodeErrorZ&& o) { CResult_UntrustedStringDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UntrustedStringDecodeErrorZ)); return *this; }
7134         LDKCResult_UntrustedStringDecodeErrorZ* operator &() { return &self; }
7135         LDKCResult_UntrustedStringDecodeErrorZ* operator ->() { return &self; }
7136         const LDKCResult_UntrustedStringDecodeErrorZ* operator &() const { return &self; }
7137         const LDKCResult_UntrustedStringDecodeErrorZ* operator ->() const { return &self; }
7138 };
7139 class CVec_U5Z {
7140 private:
7141         LDKCVec_U5Z self;
7142 public:
7143         CVec_U5Z(const CVec_U5Z&) = delete;
7144         CVec_U5Z(CVec_U5Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_U5Z)); }
7145         CVec_U5Z(LDKCVec_U5Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_U5Z)); }
7146         operator LDKCVec_U5Z() && { LDKCVec_U5Z res = self; memset(&self, 0, sizeof(LDKCVec_U5Z)); return res; }
7147         ~CVec_U5Z() { CVec_U5Z_free(self); }
7148         CVec_U5Z& operator=(CVec_U5Z&& o) { CVec_U5Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_U5Z)); return *this; }
7149         LDKCVec_U5Z* operator &() { return &self; }
7150         LDKCVec_U5Z* operator ->() { return &self; }
7151         const LDKCVec_U5Z* operator &() const { return &self; }
7152         const LDKCVec_U5Z* operator ->() const { return &self; }
7153 };
7154 class CResult_PaymentParametersDecodeErrorZ {
7155 private:
7156         LDKCResult_PaymentParametersDecodeErrorZ self;
7157 public:
7158         CResult_PaymentParametersDecodeErrorZ(const CResult_PaymentParametersDecodeErrorZ&) = delete;
7159         CResult_PaymentParametersDecodeErrorZ(CResult_PaymentParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); }
7160         CResult_PaymentParametersDecodeErrorZ(LDKCResult_PaymentParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); }
7161         operator LDKCResult_PaymentParametersDecodeErrorZ() && { LDKCResult_PaymentParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); return res; }
7162         ~CResult_PaymentParametersDecodeErrorZ() { CResult_PaymentParametersDecodeErrorZ_free(self); }
7163         CResult_PaymentParametersDecodeErrorZ& operator=(CResult_PaymentParametersDecodeErrorZ&& o) { CResult_PaymentParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); return *this; }
7164         LDKCResult_PaymentParametersDecodeErrorZ* operator &() { return &self; }
7165         LDKCResult_PaymentParametersDecodeErrorZ* operator ->() { return &self; }
7166         const LDKCResult_PaymentParametersDecodeErrorZ* operator &() const { return &self; }
7167         const LDKCResult_PaymentParametersDecodeErrorZ* operator ->() const { return &self; }
7168 };
7169 class C2Tuple_ThirtyTwoBytesChannelMonitorZ {
7170 private:
7171         LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ self;
7172 public:
7173         C2Tuple_ThirtyTwoBytesChannelMonitorZ(const C2Tuple_ThirtyTwoBytesChannelMonitorZ&) = delete;
7174         C2Tuple_ThirtyTwoBytesChannelMonitorZ(C2Tuple_ThirtyTwoBytesChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelMonitorZ)); }
7175         C2Tuple_ThirtyTwoBytesChannelMonitorZ(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ)); }
7176         operator LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ() && { LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ)); return res; }
7177         ~C2Tuple_ThirtyTwoBytesChannelMonitorZ() { C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(self); }
7178         C2Tuple_ThirtyTwoBytesChannelMonitorZ& operator=(C2Tuple_ThirtyTwoBytesChannelMonitorZ&& o) { C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelMonitorZ)); return *this; }
7179         LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator &() { return &self; }
7180         LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator ->() { return &self; }
7181         const LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator &() const { return &self; }
7182         const LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator ->() const { return &self; }
7183 };
7184 class COption_U128Z {
7185 private:
7186         LDKCOption_U128Z self;
7187 public:
7188         COption_U128Z(const COption_U128Z&) = delete;
7189         COption_U128Z(COption_U128Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_U128Z)); }
7190         COption_U128Z(LDKCOption_U128Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_U128Z)); }
7191         operator LDKCOption_U128Z() && { LDKCOption_U128Z res = self; memset(&self, 0, sizeof(LDKCOption_U128Z)); return res; }
7192         ~COption_U128Z() { COption_U128Z_free(self); }
7193         COption_U128Z& operator=(COption_U128Z&& o) { COption_U128Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_U128Z)); return *this; }
7194         LDKCOption_U128Z* operator &() { return &self; }
7195         LDKCOption_U128Z* operator ->() { return &self; }
7196         const LDKCOption_U128Z* operator &() const { return &self; }
7197         const LDKCOption_U128Z* operator ->() const { return &self; }
7198 };
7199 class C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ {
7200 private:
7201         LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ self;
7202 public:
7203         C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(const C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&) = delete;
7204         C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); }
7205         C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); }
7206         operator LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ() && { LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); return res; }
7207         ~C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ() { C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(self); }
7208         C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ& operator=(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& o) { C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); return *this; }
7209         LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator &() { return &self; }
7210         LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator ->() { return &self; }
7211         const LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator &() const { return &self; }
7212         const LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator ->() const { return &self; }
7213 };
7214 class CResult_TxAckRbfDecodeErrorZ {
7215 private:
7216         LDKCResult_TxAckRbfDecodeErrorZ self;
7217 public:
7218         CResult_TxAckRbfDecodeErrorZ(const CResult_TxAckRbfDecodeErrorZ&) = delete;
7219         CResult_TxAckRbfDecodeErrorZ(CResult_TxAckRbfDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAckRbfDecodeErrorZ)); }
7220         CResult_TxAckRbfDecodeErrorZ(LDKCResult_TxAckRbfDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAckRbfDecodeErrorZ)); }
7221         operator LDKCResult_TxAckRbfDecodeErrorZ() && { LDKCResult_TxAckRbfDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAckRbfDecodeErrorZ)); return res; }
7222         ~CResult_TxAckRbfDecodeErrorZ() { CResult_TxAckRbfDecodeErrorZ_free(self); }
7223         CResult_TxAckRbfDecodeErrorZ& operator=(CResult_TxAckRbfDecodeErrorZ&& o) { CResult_TxAckRbfDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAckRbfDecodeErrorZ)); return *this; }
7224         LDKCResult_TxAckRbfDecodeErrorZ* operator &() { return &self; }
7225         LDKCResult_TxAckRbfDecodeErrorZ* operator ->() { return &self; }
7226         const LDKCResult_TxAckRbfDecodeErrorZ* operator &() const { return &self; }
7227         const LDKCResult_TxAckRbfDecodeErrorZ* operator ->() const { return &self; }
7228 };
7229 class CResult_Bolt11InvoiceBolt11SemanticErrorZ {
7230 private:
7231         LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ self;
7232 public:
7233         CResult_Bolt11InvoiceBolt11SemanticErrorZ(const CResult_Bolt11InvoiceBolt11SemanticErrorZ&) = delete;
7234         CResult_Bolt11InvoiceBolt11SemanticErrorZ(CResult_Bolt11InvoiceBolt11SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceBolt11SemanticErrorZ)); }
7235         CResult_Bolt11InvoiceBolt11SemanticErrorZ(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ)); }
7236         operator LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ() && { LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ)); return res; }
7237         ~CResult_Bolt11InvoiceBolt11SemanticErrorZ() { CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(self); }
7238         CResult_Bolt11InvoiceBolt11SemanticErrorZ& operator=(CResult_Bolt11InvoiceBolt11SemanticErrorZ&& o) { CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceBolt11SemanticErrorZ)); return *this; }
7239         LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator &() { return &self; }
7240         LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator ->() { return &self; }
7241         const LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator &() const { return &self; }
7242         const LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator ->() const { return &self; }
7243 };
7244 class COption_UtxoLookupZ {
7245 private:
7246         LDKCOption_UtxoLookupZ self;
7247 public:
7248         COption_UtxoLookupZ(const COption_UtxoLookupZ&) = delete;
7249         COption_UtxoLookupZ(COption_UtxoLookupZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_UtxoLookupZ)); }
7250         COption_UtxoLookupZ(LDKCOption_UtxoLookupZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_UtxoLookupZ)); }
7251         operator LDKCOption_UtxoLookupZ() && { LDKCOption_UtxoLookupZ res = self; memset(&self, 0, sizeof(LDKCOption_UtxoLookupZ)); return res; }
7252         ~COption_UtxoLookupZ() { COption_UtxoLookupZ_free(self); }
7253         COption_UtxoLookupZ& operator=(COption_UtxoLookupZ&& o) { COption_UtxoLookupZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_UtxoLookupZ)); return *this; }
7254         LDKCOption_UtxoLookupZ* operator &() { return &self; }
7255         LDKCOption_UtxoLookupZ* operator ->() { return &self; }
7256         const LDKCOption_UtxoLookupZ* operator &() const { return &self; }
7257         const LDKCOption_UtxoLookupZ* operator ->() const { return &self; }
7258 };
7259 class CResult_PongDecodeErrorZ {
7260 private:
7261         LDKCResult_PongDecodeErrorZ self;
7262 public:
7263         CResult_PongDecodeErrorZ(const CResult_PongDecodeErrorZ&) = delete;
7264         CResult_PongDecodeErrorZ(CResult_PongDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); }
7265         CResult_PongDecodeErrorZ(LDKCResult_PongDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); }
7266         operator LDKCResult_PongDecodeErrorZ() && { LDKCResult_PongDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); return res; }
7267         ~CResult_PongDecodeErrorZ() { CResult_PongDecodeErrorZ_free(self); }
7268         CResult_PongDecodeErrorZ& operator=(CResult_PongDecodeErrorZ&& o) { CResult_PongDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); return *this; }
7269         LDKCResult_PongDecodeErrorZ* operator &() { return &self; }
7270         LDKCResult_PongDecodeErrorZ* operator ->() { return &self; }
7271         const LDKCResult_PongDecodeErrorZ* operator &() const { return &self; }
7272         const LDKCResult_PongDecodeErrorZ* operator ->() const { return &self; }
7273 };
7274 class CResult_UnsignedChannelAnnouncementDecodeErrorZ {
7275 private:
7276         LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ self;
7277 public:
7278         CResult_UnsignedChannelAnnouncementDecodeErrorZ(const CResult_UnsignedChannelAnnouncementDecodeErrorZ&) = delete;
7279         CResult_UnsignedChannelAnnouncementDecodeErrorZ(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
7280         CResult_UnsignedChannelAnnouncementDecodeErrorZ(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
7281         operator LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); return res; }
7282         ~CResult_UnsignedChannelAnnouncementDecodeErrorZ() { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); }
7283         CResult_UnsignedChannelAnnouncementDecodeErrorZ& operator=(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); return *this; }
7284         LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
7285         LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
7286         const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
7287         const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
7288 };
7289 class C2Tuple_OutPointCVec_MonitorUpdateIdZZ {
7290 private:
7291         LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ self;
7292 public:
7293         C2Tuple_OutPointCVec_MonitorUpdateIdZZ(const C2Tuple_OutPointCVec_MonitorUpdateIdZZ&) = delete;
7294         C2Tuple_OutPointCVec_MonitorUpdateIdZZ(C2Tuple_OutPointCVec_MonitorUpdateIdZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointCVec_MonitorUpdateIdZZ)); }
7295         C2Tuple_OutPointCVec_MonitorUpdateIdZZ(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ)); }
7296         operator LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ() && { LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ)); return res; }
7297         ~C2Tuple_OutPointCVec_MonitorUpdateIdZZ() { C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(self); }
7298         C2Tuple_OutPointCVec_MonitorUpdateIdZZ& operator=(C2Tuple_OutPointCVec_MonitorUpdateIdZZ&& o) { C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OutPointCVec_MonitorUpdateIdZZ)); return *this; }
7299         LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator &() { return &self; }
7300         LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator ->() { return &self; }
7301         const LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator &() const { return &self; }
7302         const LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator ->() const { return &self; }
7303 };
7304 class CResult_CVec_u8ZNoneZ {
7305 private:
7306         LDKCResult_CVec_u8ZNoneZ self;
7307 public:
7308         CResult_CVec_u8ZNoneZ(const CResult_CVec_u8ZNoneZ&) = delete;
7309         CResult_CVec_u8ZNoneZ(CResult_CVec_u8ZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZNoneZ)); }
7310         CResult_CVec_u8ZNoneZ(LDKCResult_CVec_u8ZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZNoneZ)); }
7311         operator LDKCResult_CVec_u8ZNoneZ() && { LDKCResult_CVec_u8ZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZNoneZ)); return res; }
7312         ~CResult_CVec_u8ZNoneZ() { CResult_CVec_u8ZNoneZ_free(self); }
7313         CResult_CVec_u8ZNoneZ& operator=(CResult_CVec_u8ZNoneZ&& o) { CResult_CVec_u8ZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_u8ZNoneZ)); return *this; }
7314         LDKCResult_CVec_u8ZNoneZ* operator &() { return &self; }
7315         LDKCResult_CVec_u8ZNoneZ* operator ->() { return &self; }
7316         const LDKCResult_CVec_u8ZNoneZ* operator &() const { return &self; }
7317         const LDKCResult_CVec_u8ZNoneZ* operator ->() const { return &self; }
7318 };
7319 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ {
7320 private:
7321         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ self;
7322 public:
7323         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(const C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&) = delete;
7324         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); }
7325         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); }
7326         operator LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ() && { LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); return res; }
7327         ~C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ() { C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(self); }
7328         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ& operator=(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&& o) { C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); return *this; }
7329         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator &() { return &self; }
7330         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator ->() { return &self; }
7331         const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator &() const { return &self; }
7332         const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator ->() const { return &self; }
7333 };
7334 class CResult_ChannelTransactionParametersDecodeErrorZ {
7335 private:
7336         LDKCResult_ChannelTransactionParametersDecodeErrorZ self;
7337 public:
7338         CResult_ChannelTransactionParametersDecodeErrorZ(const CResult_ChannelTransactionParametersDecodeErrorZ&) = delete;
7339         CResult_ChannelTransactionParametersDecodeErrorZ(CResult_ChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); }
7340         CResult_ChannelTransactionParametersDecodeErrorZ(LDKCResult_ChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); }
7341         operator LDKCResult_ChannelTransactionParametersDecodeErrorZ() && { LDKCResult_ChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); return res; }
7342         ~CResult_ChannelTransactionParametersDecodeErrorZ() { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); }
7343         CResult_ChannelTransactionParametersDecodeErrorZ& operator=(CResult_ChannelTransactionParametersDecodeErrorZ&& o) { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); return *this; }
7344         LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
7345         LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
7346         const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
7347         const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
7348 };
7349 class CResult_WriteableEcdsaChannelSignerDecodeErrorZ {
7350 private:
7351         LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ self;
7352 public:
7353         CResult_WriteableEcdsaChannelSignerDecodeErrorZ(const CResult_WriteableEcdsaChannelSignerDecodeErrorZ&) = delete;
7354         CResult_WriteableEcdsaChannelSignerDecodeErrorZ(CResult_WriteableEcdsaChannelSignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WriteableEcdsaChannelSignerDecodeErrorZ)); }
7355         CResult_WriteableEcdsaChannelSignerDecodeErrorZ(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ)); }
7356         operator LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ() && { LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ)); return res; }
7357         ~CResult_WriteableEcdsaChannelSignerDecodeErrorZ() { CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(self); }
7358         CResult_WriteableEcdsaChannelSignerDecodeErrorZ& operator=(CResult_WriteableEcdsaChannelSignerDecodeErrorZ&& o) { CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WriteableEcdsaChannelSignerDecodeErrorZ)); return *this; }
7359         LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator &() { return &self; }
7360         LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator ->() { return &self; }
7361         const LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator &() const { return &self; }
7362         const LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator ->() const { return &self; }
7363 };
7364 class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
7365 private:
7366         LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ self;
7367 public:
7368         CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(const CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&) = delete;
7369         CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
7370         CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
7371         operator LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return res; }
7372         ~CResult_DelayedPaymentOutputDescriptorDecodeErrorZ() { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); }
7373         CResult_DelayedPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return *this; }
7374         LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
7375         LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
7376         const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
7377         const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
7378 };
7379 class CResult_InFlightHtlcsDecodeErrorZ {
7380 private:
7381         LDKCResult_InFlightHtlcsDecodeErrorZ self;
7382 public:
7383         CResult_InFlightHtlcsDecodeErrorZ(const CResult_InFlightHtlcsDecodeErrorZ&) = delete;
7384         CResult_InFlightHtlcsDecodeErrorZ(CResult_InFlightHtlcsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InFlightHtlcsDecodeErrorZ)); }
7385         CResult_InFlightHtlcsDecodeErrorZ(LDKCResult_InFlightHtlcsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ)); }
7386         operator LDKCResult_InFlightHtlcsDecodeErrorZ() && { LDKCResult_InFlightHtlcsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ)); return res; }
7387         ~CResult_InFlightHtlcsDecodeErrorZ() { CResult_InFlightHtlcsDecodeErrorZ_free(self); }
7388         CResult_InFlightHtlcsDecodeErrorZ& operator=(CResult_InFlightHtlcsDecodeErrorZ&& o) { CResult_InFlightHtlcsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InFlightHtlcsDecodeErrorZ)); return *this; }
7389         LDKCResult_InFlightHtlcsDecodeErrorZ* operator &() { return &self; }
7390         LDKCResult_InFlightHtlcsDecodeErrorZ* operator ->() { return &self; }
7391         const LDKCResult_InFlightHtlcsDecodeErrorZ* operator &() const { return &self; }
7392         const LDKCResult_InFlightHtlcsDecodeErrorZ* operator ->() const { return &self; }
7393 };
7394 class CResult_COption_HTLCDestinationZDecodeErrorZ {
7395 private:
7396         LDKCResult_COption_HTLCDestinationZDecodeErrorZ self;
7397 public:
7398         CResult_COption_HTLCDestinationZDecodeErrorZ(const CResult_COption_HTLCDestinationZDecodeErrorZ&) = delete;
7399         CResult_COption_HTLCDestinationZDecodeErrorZ(CResult_COption_HTLCDestinationZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_HTLCDestinationZDecodeErrorZ)); }
7400         CResult_COption_HTLCDestinationZDecodeErrorZ(LDKCResult_COption_HTLCDestinationZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ)); }
7401         operator LDKCResult_COption_HTLCDestinationZDecodeErrorZ() && { LDKCResult_COption_HTLCDestinationZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ)); return res; }
7402         ~CResult_COption_HTLCDestinationZDecodeErrorZ() { CResult_COption_HTLCDestinationZDecodeErrorZ_free(self); }
7403         CResult_COption_HTLCDestinationZDecodeErrorZ& operator=(CResult_COption_HTLCDestinationZDecodeErrorZ&& o) { CResult_COption_HTLCDestinationZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_HTLCDestinationZDecodeErrorZ)); return *this; }
7404         LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator &() { return &self; }
7405         LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator ->() { return &self; }
7406         const LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator &() const { return &self; }
7407         const LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator ->() const { return &self; }
7408 };
7409 class CResult_ThirtyTwoBytesNoneZ {
7410 private:
7411         LDKCResult_ThirtyTwoBytesNoneZ self;
7412 public:
7413         CResult_ThirtyTwoBytesNoneZ(const CResult_ThirtyTwoBytesNoneZ&) = delete;
7414         CResult_ThirtyTwoBytesNoneZ(CResult_ThirtyTwoBytesNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesNoneZ)); }
7415         CResult_ThirtyTwoBytesNoneZ(LDKCResult_ThirtyTwoBytesNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesNoneZ)); }
7416         operator LDKCResult_ThirtyTwoBytesNoneZ() && { LDKCResult_ThirtyTwoBytesNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesNoneZ)); return res; }
7417         ~CResult_ThirtyTwoBytesNoneZ() { CResult_ThirtyTwoBytesNoneZ_free(self); }
7418         CResult_ThirtyTwoBytesNoneZ& operator=(CResult_ThirtyTwoBytesNoneZ&& o) { CResult_ThirtyTwoBytesNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesNoneZ)); return *this; }
7419         LDKCResult_ThirtyTwoBytesNoneZ* operator &() { return &self; }
7420         LDKCResult_ThirtyTwoBytesNoneZ* operator ->() { return &self; }
7421         const LDKCResult_ThirtyTwoBytesNoneZ* operator &() const { return &self; }
7422         const LDKCResult_ThirtyTwoBytesNoneZ* operator ->() const { return &self; }
7423 };
7424 class C3Tuple_OnionMessageContentsDestinationBlindedPathZ {
7425 private:
7426         LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ self;
7427 public:
7428         C3Tuple_OnionMessageContentsDestinationBlindedPathZ(const C3Tuple_OnionMessageContentsDestinationBlindedPathZ&) = delete;
7429         C3Tuple_OnionMessageContentsDestinationBlindedPathZ(C3Tuple_OnionMessageContentsDestinationBlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_OnionMessageContentsDestinationBlindedPathZ)); }
7430         C3Tuple_OnionMessageContentsDestinationBlindedPathZ(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ)); }
7431         operator LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ() && { LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ)); return res; }
7432         ~C3Tuple_OnionMessageContentsDestinationBlindedPathZ() { C3Tuple_OnionMessageContentsDestinationBlindedPathZ_free(self); }
7433         C3Tuple_OnionMessageContentsDestinationBlindedPathZ& operator=(C3Tuple_OnionMessageContentsDestinationBlindedPathZ&& o) { C3Tuple_OnionMessageContentsDestinationBlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_OnionMessageContentsDestinationBlindedPathZ)); return *this; }
7434         LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ* operator &() { return &self; }
7435         LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ* operator ->() { return &self; }
7436         const LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ* operator &() const { return &self; }
7437         const LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ* operator ->() const { return &self; }
7438 };
7439 class C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ {
7440 private:
7441         LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ self;
7442 public:
7443         C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(const C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&) = delete;
7444         C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); }
7445         C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); }
7446         operator LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ() && { LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); return res; }
7447         ~C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ() { C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(self); }
7448         C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ& operator=(C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&& o) { C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); return *this; }
7449         LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator &() { return &self; }
7450         LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator ->() { return &self; }
7451         const LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator &() const { return &self; }
7452         const LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator ->() const { return &self; }
7453 };
7454 class CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ {
7455 private:
7456         LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ self;
7457 public:
7458         CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ(const CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ&) = delete;
7459         CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ(CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ)); }
7460         CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ(LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ)); }
7461         operator LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ() && { LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ)); return res; }
7462         ~CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ() { CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ_free(self); }
7463         CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ& operator=(CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ&& o) { CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ)); return *this; }
7464         LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator &() { return &self; }
7465         LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator ->() { return &self; }
7466         const LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator &() const { return &self; }
7467         const LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator ->() const { return &self; }
7468 };
7469 class CResult_BlindedHopDecodeErrorZ {
7470 private:
7471         LDKCResult_BlindedHopDecodeErrorZ self;
7472 public:
7473         CResult_BlindedHopDecodeErrorZ(const CResult_BlindedHopDecodeErrorZ&) = delete;
7474         CResult_BlindedHopDecodeErrorZ(CResult_BlindedHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedHopDecodeErrorZ)); }
7475         CResult_BlindedHopDecodeErrorZ(LDKCResult_BlindedHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedHopDecodeErrorZ)); }
7476         operator LDKCResult_BlindedHopDecodeErrorZ() && { LDKCResult_BlindedHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedHopDecodeErrorZ)); return res; }
7477         ~CResult_BlindedHopDecodeErrorZ() { CResult_BlindedHopDecodeErrorZ_free(self); }
7478         CResult_BlindedHopDecodeErrorZ& operator=(CResult_BlindedHopDecodeErrorZ&& o) { CResult_BlindedHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedHopDecodeErrorZ)); return *this; }
7479         LDKCResult_BlindedHopDecodeErrorZ* operator &() { return &self; }
7480         LDKCResult_BlindedHopDecodeErrorZ* operator ->() { return &self; }
7481         const LDKCResult_BlindedHopDecodeErrorZ* operator &() const { return &self; }
7482         const LDKCResult_BlindedHopDecodeErrorZ* operator ->() const { return &self; }
7483 };
7484 class C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ {
7485 private:
7486         LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ self;
7487 public:
7488         C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ(const C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ&) = delete;
7489         C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ(C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ)); }
7490         C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ)); }
7491         operator LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ() && { LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ)); return res; }
7492         ~C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ() { C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_free(self); }
7493         C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ& operator=(C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ&& o) { C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ)); return *this; }
7494         LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* operator &() { return &self; }
7495         LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* operator ->() { return &self; }
7496         const LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* operator &() const { return &self; }
7497         const LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* operator ->() const { return &self; }
7498 };
7499 class CResult_FixedPenaltyScorerDecodeErrorZ {
7500 private:
7501         LDKCResult_FixedPenaltyScorerDecodeErrorZ self;
7502 public:
7503         CResult_FixedPenaltyScorerDecodeErrorZ(const CResult_FixedPenaltyScorerDecodeErrorZ&) = delete;
7504         CResult_FixedPenaltyScorerDecodeErrorZ(CResult_FixedPenaltyScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); }
7505         CResult_FixedPenaltyScorerDecodeErrorZ(LDKCResult_FixedPenaltyScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); }
7506         operator LDKCResult_FixedPenaltyScorerDecodeErrorZ() && { LDKCResult_FixedPenaltyScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); return res; }
7507         ~CResult_FixedPenaltyScorerDecodeErrorZ() { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); }
7508         CResult_FixedPenaltyScorerDecodeErrorZ& operator=(CResult_FixedPenaltyScorerDecodeErrorZ&& o) { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); return *this; }
7509         LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() { return &self; }
7510         LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() { return &self; }
7511         const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() const { return &self; }
7512         const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() const { return &self; }
7513 };
7514 class CVec_BlindedPathZ {
7515 private:
7516         LDKCVec_BlindedPathZ self;
7517 public:
7518         CVec_BlindedPathZ(const CVec_BlindedPathZ&) = delete;
7519         CVec_BlindedPathZ(CVec_BlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BlindedPathZ)); }
7520         CVec_BlindedPathZ(LDKCVec_BlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BlindedPathZ)); }
7521         operator LDKCVec_BlindedPathZ() && { LDKCVec_BlindedPathZ res = self; memset(&self, 0, sizeof(LDKCVec_BlindedPathZ)); return res; }
7522         ~CVec_BlindedPathZ() { CVec_BlindedPathZ_free(self); }
7523         CVec_BlindedPathZ& operator=(CVec_BlindedPathZ&& o) { CVec_BlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BlindedPathZ)); return *this; }
7524         LDKCVec_BlindedPathZ* operator &() { return &self; }
7525         LDKCVec_BlindedPathZ* operator ->() { return &self; }
7526         const LDKCVec_BlindedPathZ* operator &() const { return &self; }
7527         const LDKCVec_BlindedPathZ* operator ->() const { return &self; }
7528 };
7529 class CResult_NoneLightningErrorZ {
7530 private:
7531         LDKCResult_NoneLightningErrorZ self;
7532 public:
7533         CResult_NoneLightningErrorZ(const CResult_NoneLightningErrorZ&) = delete;
7534         CResult_NoneLightningErrorZ(CResult_NoneLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); }
7535         CResult_NoneLightningErrorZ(LDKCResult_NoneLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); }
7536         operator LDKCResult_NoneLightningErrorZ() && { LDKCResult_NoneLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); return res; }
7537         ~CResult_NoneLightningErrorZ() { CResult_NoneLightningErrorZ_free(self); }
7538         CResult_NoneLightningErrorZ& operator=(CResult_NoneLightningErrorZ&& o) { CResult_NoneLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); return *this; }
7539         LDKCResult_NoneLightningErrorZ* operator &() { return &self; }
7540         LDKCResult_NoneLightningErrorZ* operator ->() { return &self; }
7541         const LDKCResult_NoneLightningErrorZ* operator &() const { return &self; }
7542         const LDKCResult_NoneLightningErrorZ* operator ->() const { return &self; }
7543 };
7544 class CResult_NonePeerHandleErrorZ {
7545 private:
7546         LDKCResult_NonePeerHandleErrorZ self;
7547 public:
7548         CResult_NonePeerHandleErrorZ(const CResult_NonePeerHandleErrorZ&) = delete;
7549         CResult_NonePeerHandleErrorZ(CResult_NonePeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); }
7550         CResult_NonePeerHandleErrorZ(LDKCResult_NonePeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); }
7551         operator LDKCResult_NonePeerHandleErrorZ() && { LDKCResult_NonePeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); return res; }
7552         ~CResult_NonePeerHandleErrorZ() { CResult_NonePeerHandleErrorZ_free(self); }
7553         CResult_NonePeerHandleErrorZ& operator=(CResult_NonePeerHandleErrorZ&& o) { CResult_NonePeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); return *this; }
7554         LDKCResult_NonePeerHandleErrorZ* operator &() { return &self; }
7555         LDKCResult_NonePeerHandleErrorZ* operator ->() { return &self; }
7556         const LDKCResult_NonePeerHandleErrorZ* operator &() const { return &self; }
7557         const LDKCResult_NonePeerHandleErrorZ* operator ->() const { return &self; }
7558 };
7559 class CResult_TrustedCommitmentTransactionNoneZ {
7560 private:
7561         LDKCResult_TrustedCommitmentTransactionNoneZ self;
7562 public:
7563         CResult_TrustedCommitmentTransactionNoneZ(const CResult_TrustedCommitmentTransactionNoneZ&) = delete;
7564         CResult_TrustedCommitmentTransactionNoneZ(CResult_TrustedCommitmentTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); }
7565         CResult_TrustedCommitmentTransactionNoneZ(LDKCResult_TrustedCommitmentTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); }
7566         operator LDKCResult_TrustedCommitmentTransactionNoneZ() && { LDKCResult_TrustedCommitmentTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); return res; }
7567         ~CResult_TrustedCommitmentTransactionNoneZ() { CResult_TrustedCommitmentTransactionNoneZ_free(self); }
7568         CResult_TrustedCommitmentTransactionNoneZ& operator=(CResult_TrustedCommitmentTransactionNoneZ&& o) { CResult_TrustedCommitmentTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); return *this; }
7569         LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() { return &self; }
7570         LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() { return &self; }
7571         const LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() const { return &self; }
7572         const LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() const { return &self; }
7573 };
7574 class CResult_COption_EventZDecodeErrorZ {
7575 private:
7576         LDKCResult_COption_EventZDecodeErrorZ self;
7577 public:
7578         CResult_COption_EventZDecodeErrorZ(const CResult_COption_EventZDecodeErrorZ&) = delete;
7579         CResult_COption_EventZDecodeErrorZ(CResult_COption_EventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_EventZDecodeErrorZ)); }
7580         CResult_COption_EventZDecodeErrorZ(LDKCResult_COption_EventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); }
7581         operator LDKCResult_COption_EventZDecodeErrorZ() && { LDKCResult_COption_EventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); return res; }
7582         ~CResult_COption_EventZDecodeErrorZ() { CResult_COption_EventZDecodeErrorZ_free(self); }
7583         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; }
7584         LDKCResult_COption_EventZDecodeErrorZ* operator &() { return &self; }
7585         LDKCResult_COption_EventZDecodeErrorZ* operator ->() { return &self; }
7586         const LDKCResult_COption_EventZDecodeErrorZ* operator &() const { return &self; }
7587         const LDKCResult_COption_EventZDecodeErrorZ* operator ->() const { return &self; }
7588 };
7589 class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ {
7590 private:
7591         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ self;
7592 public:
7593         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ(const CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ&) = delete;
7594         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ)); }
7595         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ)); }
7596         operator LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ() && { LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ)); return res; }
7597         ~CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ() { CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_free(self); }
7598         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ& operator=(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ&& o) { CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ)); return *this; }
7599         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* operator &() { return &self; }
7600         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* operator ->() { return &self; }
7601         const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* operator &() const { return &self; }
7602         const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* operator ->() const { return &self; }
7603 };
7604 class CResult_PaymentFailureReasonDecodeErrorZ {
7605 private:
7606         LDKCResult_PaymentFailureReasonDecodeErrorZ self;
7607 public:
7608         CResult_PaymentFailureReasonDecodeErrorZ(const CResult_PaymentFailureReasonDecodeErrorZ&) = delete;
7609         CResult_PaymentFailureReasonDecodeErrorZ(CResult_PaymentFailureReasonDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentFailureReasonDecodeErrorZ)); }
7610         CResult_PaymentFailureReasonDecodeErrorZ(LDKCResult_PaymentFailureReasonDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ)); }
7611         operator LDKCResult_PaymentFailureReasonDecodeErrorZ() && { LDKCResult_PaymentFailureReasonDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ)); return res; }
7612         ~CResult_PaymentFailureReasonDecodeErrorZ() { CResult_PaymentFailureReasonDecodeErrorZ_free(self); }
7613         CResult_PaymentFailureReasonDecodeErrorZ& operator=(CResult_PaymentFailureReasonDecodeErrorZ&& o) { CResult_PaymentFailureReasonDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentFailureReasonDecodeErrorZ)); return *this; }
7614         LDKCResult_PaymentFailureReasonDecodeErrorZ* operator &() { return &self; }
7615         LDKCResult_PaymentFailureReasonDecodeErrorZ* operator ->() { return &self; }
7616         const LDKCResult_PaymentFailureReasonDecodeErrorZ* operator &() const { return &self; }
7617         const LDKCResult_PaymentFailureReasonDecodeErrorZ* operator ->() const { return &self; }
7618 };
7619 class COption_SocketAddressZ {
7620 private:
7621         LDKCOption_SocketAddressZ self;
7622 public:
7623         COption_SocketAddressZ(const COption_SocketAddressZ&) = delete;
7624         COption_SocketAddressZ(COption_SocketAddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_SocketAddressZ)); }
7625         COption_SocketAddressZ(LDKCOption_SocketAddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_SocketAddressZ)); }
7626         operator LDKCOption_SocketAddressZ() && { LDKCOption_SocketAddressZ res = self; memset(&self, 0, sizeof(LDKCOption_SocketAddressZ)); return res; }
7627         ~COption_SocketAddressZ() { COption_SocketAddressZ_free(self); }
7628         COption_SocketAddressZ& operator=(COption_SocketAddressZ&& o) { COption_SocketAddressZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_SocketAddressZ)); return *this; }
7629         LDKCOption_SocketAddressZ* operator &() { return &self; }
7630         LDKCOption_SocketAddressZ* operator ->() { return &self; }
7631         const LDKCOption_SocketAddressZ* operator &() const { return &self; }
7632         const LDKCOption_SocketAddressZ* operator ->() const { return &self; }
7633 };
7634 class CResult_COption_MonitorEventZDecodeErrorZ {
7635 private:
7636         LDKCResult_COption_MonitorEventZDecodeErrorZ self;
7637 public:
7638         CResult_COption_MonitorEventZDecodeErrorZ(const CResult_COption_MonitorEventZDecodeErrorZ&) = delete;
7639         CResult_COption_MonitorEventZDecodeErrorZ(CResult_COption_MonitorEventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_MonitorEventZDecodeErrorZ)); }
7640         CResult_COption_MonitorEventZDecodeErrorZ(LDKCResult_COption_MonitorEventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); }
7641         operator LDKCResult_COption_MonitorEventZDecodeErrorZ() && { LDKCResult_COption_MonitorEventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); return res; }
7642         ~CResult_COption_MonitorEventZDecodeErrorZ() { CResult_COption_MonitorEventZDecodeErrorZ_free(self); }
7643         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; }
7644         LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() { return &self; }
7645         LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() { return &self; }
7646         const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() const { return &self; }
7647         const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() const { return &self; }
7648 };
7649 class COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ {
7650 private:
7651         LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ self;
7652 public:
7653         COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(const COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&) = delete;
7654         COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); }
7655         COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); }
7656         operator LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ() && { LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); return res; }
7657         ~COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ() { COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(self); }
7658         COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ& operator=(COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&& o) { COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); return *this; }
7659         LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator &() { return &self; }
7660         LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator ->() { return &self; }
7661         const LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator &() const { return &self; }
7662         const LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator ->() const { return &self; }
7663 };
7664 class CResult_DescriptionCreationErrorZ {
7665 private:
7666         LDKCResult_DescriptionCreationErrorZ self;
7667 public:
7668         CResult_DescriptionCreationErrorZ(const CResult_DescriptionCreationErrorZ&) = delete;
7669         CResult_DescriptionCreationErrorZ(CResult_DescriptionCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); }
7670         CResult_DescriptionCreationErrorZ(LDKCResult_DescriptionCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); }
7671         operator LDKCResult_DescriptionCreationErrorZ() && { LDKCResult_DescriptionCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); return res; }
7672         ~CResult_DescriptionCreationErrorZ() { CResult_DescriptionCreationErrorZ_free(self); }
7673         CResult_DescriptionCreationErrorZ& operator=(CResult_DescriptionCreationErrorZ&& o) { CResult_DescriptionCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); return *this; }
7674         LDKCResult_DescriptionCreationErrorZ* operator &() { return &self; }
7675         LDKCResult_DescriptionCreationErrorZ* operator ->() { return &self; }
7676         const LDKCResult_DescriptionCreationErrorZ* operator &() const { return &self; }
7677         const LDKCResult_DescriptionCreationErrorZ* operator ->() const { return &self; }
7678 };
7679 class CResult_RoutingFeesDecodeErrorZ {
7680 private:
7681         LDKCResult_RoutingFeesDecodeErrorZ self;
7682 public:
7683         CResult_RoutingFeesDecodeErrorZ(const CResult_RoutingFeesDecodeErrorZ&) = delete;
7684         CResult_RoutingFeesDecodeErrorZ(CResult_RoutingFeesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); }
7685         CResult_RoutingFeesDecodeErrorZ(LDKCResult_RoutingFeesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); }
7686         operator LDKCResult_RoutingFeesDecodeErrorZ() && { LDKCResult_RoutingFeesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); return res; }
7687         ~CResult_RoutingFeesDecodeErrorZ() { CResult_RoutingFeesDecodeErrorZ_free(self); }
7688         CResult_RoutingFeesDecodeErrorZ& operator=(CResult_RoutingFeesDecodeErrorZ&& o) { CResult_RoutingFeesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); return *this; }
7689         LDKCResult_RoutingFeesDecodeErrorZ* operator &() { return &self; }
7690         LDKCResult_RoutingFeesDecodeErrorZ* operator ->() { return &self; }
7691         const LDKCResult_RoutingFeesDecodeErrorZ* operator &() const { return &self; }
7692         const LDKCResult_RoutingFeesDecodeErrorZ* operator ->() const { return &self; }
7693 };
7694 class CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ {
7695 private:
7696         LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ self;
7697 public:
7698         CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ(const CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ&) = delete;
7699         CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ(CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ)); }
7700         CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ(LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ)); }
7701         operator LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ)); return res; }
7702         ~CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ() { CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(self); }
7703         CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ& operator=(CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ&& o) { CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ)); return *this; }
7704         LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator &() { return &self; }
7705         LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator ->() { return &self; }
7706         const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator &() const { return &self; }
7707         const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator ->() const { return &self; }
7708 };
7709 class CResult_PaymentRelayDecodeErrorZ {
7710 private:
7711         LDKCResult_PaymentRelayDecodeErrorZ self;
7712 public:
7713         CResult_PaymentRelayDecodeErrorZ(const CResult_PaymentRelayDecodeErrorZ&) = delete;
7714         CResult_PaymentRelayDecodeErrorZ(CResult_PaymentRelayDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentRelayDecodeErrorZ)); }
7715         CResult_PaymentRelayDecodeErrorZ(LDKCResult_PaymentRelayDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentRelayDecodeErrorZ)); }
7716         operator LDKCResult_PaymentRelayDecodeErrorZ() && { LDKCResult_PaymentRelayDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentRelayDecodeErrorZ)); return res; }
7717         ~CResult_PaymentRelayDecodeErrorZ() { CResult_PaymentRelayDecodeErrorZ_free(self); }
7718         CResult_PaymentRelayDecodeErrorZ& operator=(CResult_PaymentRelayDecodeErrorZ&& o) { CResult_PaymentRelayDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentRelayDecodeErrorZ)); return *this; }
7719         LDKCResult_PaymentRelayDecodeErrorZ* operator &() { return &self; }
7720         LDKCResult_PaymentRelayDecodeErrorZ* operator ->() { return &self; }
7721         const LDKCResult_PaymentRelayDecodeErrorZ* operator &() const { return &self; }
7722         const LDKCResult_PaymentRelayDecodeErrorZ* operator ->() const { return &self; }
7723 };
7724 class CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ {
7725 private:
7726         LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ self;
7727 public:
7728         CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(const CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&) = delete;
7729         CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); }
7730         CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); }
7731         operator LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ() && { LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); return res; }
7732         ~CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ() { CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(self); }
7733         CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ& operator=(CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&& o) { CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); return *this; }
7734         LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator &() { return &self; }
7735         LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator ->() { return &self; }
7736         const LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator &() const { return &self; }
7737         const LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator ->() const { return &self; }
7738 };
7739 class CResult_QueryShortChannelIdsDecodeErrorZ {
7740 private:
7741         LDKCResult_QueryShortChannelIdsDecodeErrorZ self;
7742 public:
7743         CResult_QueryShortChannelIdsDecodeErrorZ(const CResult_QueryShortChannelIdsDecodeErrorZ&) = delete;
7744         CResult_QueryShortChannelIdsDecodeErrorZ(CResult_QueryShortChannelIdsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); }
7745         CResult_QueryShortChannelIdsDecodeErrorZ(LDKCResult_QueryShortChannelIdsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); }
7746         operator LDKCResult_QueryShortChannelIdsDecodeErrorZ() && { LDKCResult_QueryShortChannelIdsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); return res; }
7747         ~CResult_QueryShortChannelIdsDecodeErrorZ() { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); }
7748         CResult_QueryShortChannelIdsDecodeErrorZ& operator=(CResult_QueryShortChannelIdsDecodeErrorZ&& o) { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); return *this; }
7749         LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() { return &self; }
7750         LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() { return &self; }
7751         const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() const { return &self; }
7752         const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() const { return &self; }
7753 };
7754 class CResult_VerifiedInvoiceRequestNoneZ {
7755 private:
7756         LDKCResult_VerifiedInvoiceRequestNoneZ self;
7757 public:
7758         CResult_VerifiedInvoiceRequestNoneZ(const CResult_VerifiedInvoiceRequestNoneZ&) = delete;
7759         CResult_VerifiedInvoiceRequestNoneZ(CResult_VerifiedInvoiceRequestNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_VerifiedInvoiceRequestNoneZ)); }
7760         CResult_VerifiedInvoiceRequestNoneZ(LDKCResult_VerifiedInvoiceRequestNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_VerifiedInvoiceRequestNoneZ)); }
7761         operator LDKCResult_VerifiedInvoiceRequestNoneZ() && { LDKCResult_VerifiedInvoiceRequestNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_VerifiedInvoiceRequestNoneZ)); return res; }
7762         ~CResult_VerifiedInvoiceRequestNoneZ() { CResult_VerifiedInvoiceRequestNoneZ_free(self); }
7763         CResult_VerifiedInvoiceRequestNoneZ& operator=(CResult_VerifiedInvoiceRequestNoneZ&& o) { CResult_VerifiedInvoiceRequestNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_VerifiedInvoiceRequestNoneZ)); return *this; }
7764         LDKCResult_VerifiedInvoiceRequestNoneZ* operator &() { return &self; }
7765         LDKCResult_VerifiedInvoiceRequestNoneZ* operator ->() { return &self; }
7766         const LDKCResult_VerifiedInvoiceRequestNoneZ* operator &() const { return &self; }
7767         const LDKCResult_VerifiedInvoiceRequestNoneZ* operator ->() const { return &self; }
7768 };
7769 class CResult_UpdateAddHTLCDecodeErrorZ {
7770 private:
7771         LDKCResult_UpdateAddHTLCDecodeErrorZ self;
7772 public:
7773         CResult_UpdateAddHTLCDecodeErrorZ(const CResult_UpdateAddHTLCDecodeErrorZ&) = delete;
7774         CResult_UpdateAddHTLCDecodeErrorZ(CResult_UpdateAddHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); }
7775         CResult_UpdateAddHTLCDecodeErrorZ(LDKCResult_UpdateAddHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); }
7776         operator LDKCResult_UpdateAddHTLCDecodeErrorZ() && { LDKCResult_UpdateAddHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); return res; }
7777         ~CResult_UpdateAddHTLCDecodeErrorZ() { CResult_UpdateAddHTLCDecodeErrorZ_free(self); }
7778         CResult_UpdateAddHTLCDecodeErrorZ& operator=(CResult_UpdateAddHTLCDecodeErrorZ&& o) { CResult_UpdateAddHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); return *this; }
7779         LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() { return &self; }
7780         LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() { return &self; }
7781         const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() const { return &self; }
7782         const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() const { return &self; }
7783 };
7784 class COption_MonitorEventZ {
7785 private:
7786         LDKCOption_MonitorEventZ self;
7787 public:
7788         COption_MonitorEventZ(const COption_MonitorEventZ&) = delete;
7789         COption_MonitorEventZ(COption_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MonitorEventZ)); }
7790         COption_MonitorEventZ(LDKCOption_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MonitorEventZ)); }
7791         operator LDKCOption_MonitorEventZ() && { LDKCOption_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCOption_MonitorEventZ)); return res; }
7792         ~COption_MonitorEventZ() { COption_MonitorEventZ_free(self); }
7793         COption_MonitorEventZ& operator=(COption_MonitorEventZ&& o) { COption_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MonitorEventZ)); return *this; }
7794         LDKCOption_MonitorEventZ* operator &() { return &self; }
7795         LDKCOption_MonitorEventZ* operator ->() { return &self; }
7796         const LDKCOption_MonitorEventZ* operator &() const { return &self; }
7797         const LDKCOption_MonitorEventZ* operator ->() const { return &self; }
7798 };
7799 class COption_TypeZ {
7800 private:
7801         LDKCOption_TypeZ self;
7802 public:
7803         COption_TypeZ(const COption_TypeZ&) = delete;
7804         COption_TypeZ(COption_TypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_TypeZ)); }
7805         COption_TypeZ(LDKCOption_TypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_TypeZ)); }
7806         operator LDKCOption_TypeZ() && { LDKCOption_TypeZ res = self; memset(&self, 0, sizeof(LDKCOption_TypeZ)); return res; }
7807         ~COption_TypeZ() { COption_TypeZ_free(self); }
7808         COption_TypeZ& operator=(COption_TypeZ&& o) { COption_TypeZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_TypeZ)); return *this; }
7809         LDKCOption_TypeZ* operator &() { return &self; }
7810         LDKCOption_TypeZ* operator ->() { return &self; }
7811         const LDKCOption_TypeZ* operator &() const { return &self; }
7812         const LDKCOption_TypeZ* operator ->() const { return &self; }
7813 };
7814 class CResult_COption_TypeZDecodeErrorZ {
7815 private:
7816         LDKCResult_COption_TypeZDecodeErrorZ self;
7817 public:
7818         CResult_COption_TypeZDecodeErrorZ(const CResult_COption_TypeZDecodeErrorZ&) = delete;
7819         CResult_COption_TypeZDecodeErrorZ(CResult_COption_TypeZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_TypeZDecodeErrorZ)); }
7820         CResult_COption_TypeZDecodeErrorZ(LDKCResult_COption_TypeZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); }
7821         operator LDKCResult_COption_TypeZDecodeErrorZ() && { LDKCResult_COption_TypeZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); return res; }
7822         ~CResult_COption_TypeZDecodeErrorZ() { CResult_COption_TypeZDecodeErrorZ_free(self); }
7823         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; }
7824         LDKCResult_COption_TypeZDecodeErrorZ* operator &() { return &self; }
7825         LDKCResult_COption_TypeZDecodeErrorZ* operator ->() { return &self; }
7826         const LDKCResult_COption_TypeZDecodeErrorZ* operator &() const { return &self; }
7827         const LDKCResult_COption_TypeZDecodeErrorZ* operator ->() const { return &self; }
7828 };
7829 class CResult_COption_PathFailureZDecodeErrorZ {
7830 private:
7831         LDKCResult_COption_PathFailureZDecodeErrorZ self;
7832 public:
7833         CResult_COption_PathFailureZDecodeErrorZ(const CResult_COption_PathFailureZDecodeErrorZ&) = delete;
7834         CResult_COption_PathFailureZDecodeErrorZ(CResult_COption_PathFailureZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_PathFailureZDecodeErrorZ)); }
7835         CResult_COption_PathFailureZDecodeErrorZ(LDKCResult_COption_PathFailureZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ)); }
7836         operator LDKCResult_COption_PathFailureZDecodeErrorZ() && { LDKCResult_COption_PathFailureZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ)); return res; }
7837         ~CResult_COption_PathFailureZDecodeErrorZ() { CResult_COption_PathFailureZDecodeErrorZ_free(self); }
7838         CResult_COption_PathFailureZDecodeErrorZ& operator=(CResult_COption_PathFailureZDecodeErrorZ&& o) { CResult_COption_PathFailureZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_PathFailureZDecodeErrorZ)); return *this; }
7839         LDKCResult_COption_PathFailureZDecodeErrorZ* operator &() { return &self; }
7840         LDKCResult_COption_PathFailureZDecodeErrorZ* operator ->() { return &self; }
7841         const LDKCResult_COption_PathFailureZDecodeErrorZ* operator &() const { return &self; }
7842         const LDKCResult_COption_PathFailureZDecodeErrorZ* operator ->() const { return &self; }
7843 };
7844 class CResult_Bolt11InvoiceSignOrCreationErrorZ {
7845 private:
7846         LDKCResult_Bolt11InvoiceSignOrCreationErrorZ self;
7847 public:
7848         CResult_Bolt11InvoiceSignOrCreationErrorZ(const CResult_Bolt11InvoiceSignOrCreationErrorZ&) = delete;
7849         CResult_Bolt11InvoiceSignOrCreationErrorZ(CResult_Bolt11InvoiceSignOrCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceSignOrCreationErrorZ)); }
7850         CResult_Bolt11InvoiceSignOrCreationErrorZ(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ)); }
7851         operator LDKCResult_Bolt11InvoiceSignOrCreationErrorZ() && { LDKCResult_Bolt11InvoiceSignOrCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ)); return res; }
7852         ~CResult_Bolt11InvoiceSignOrCreationErrorZ() { CResult_Bolt11InvoiceSignOrCreationErrorZ_free(self); }
7853         CResult_Bolt11InvoiceSignOrCreationErrorZ& operator=(CResult_Bolt11InvoiceSignOrCreationErrorZ&& o) { CResult_Bolt11InvoiceSignOrCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceSignOrCreationErrorZ)); return *this; }
7854         LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator &() { return &self; }
7855         LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator ->() { return &self; }
7856         const LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator &() const { return &self; }
7857         const LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator ->() const { return &self; }
7858 };
7859 class CResult_UpdateFailHTLCDecodeErrorZ {
7860 private:
7861         LDKCResult_UpdateFailHTLCDecodeErrorZ self;
7862 public:
7863         CResult_UpdateFailHTLCDecodeErrorZ(const CResult_UpdateFailHTLCDecodeErrorZ&) = delete;
7864         CResult_UpdateFailHTLCDecodeErrorZ(CResult_UpdateFailHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); }
7865         CResult_UpdateFailHTLCDecodeErrorZ(LDKCResult_UpdateFailHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); }
7866         operator LDKCResult_UpdateFailHTLCDecodeErrorZ() && { LDKCResult_UpdateFailHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); return res; }
7867         ~CResult_UpdateFailHTLCDecodeErrorZ() { CResult_UpdateFailHTLCDecodeErrorZ_free(self); }
7868         CResult_UpdateFailHTLCDecodeErrorZ& operator=(CResult_UpdateFailHTLCDecodeErrorZ&& o) { CResult_UpdateFailHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); return *this; }
7869         LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() { return &self; }
7870         LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() { return &self; }
7871         const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() const { return &self; }
7872         const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() const { return &self; }
7873 };
7874 class CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ {
7875 private:
7876         LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ self;
7877 public:
7878         CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(const CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&) = delete;
7879         CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); }
7880         CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); }
7881         operator LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); return res; }
7882         ~CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ() { CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(self); }
7883         CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ& operator=(CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&& o) { CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); return *this; }
7884         LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator &() { return &self; }
7885         LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator ->() { return &self; }
7886         const LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator &() const { return &self; }
7887         const LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator ->() const { return &self; }
7888 };
7889 class CResult_RevokeAndACKDecodeErrorZ {
7890 private:
7891         LDKCResult_RevokeAndACKDecodeErrorZ self;
7892 public:
7893         CResult_RevokeAndACKDecodeErrorZ(const CResult_RevokeAndACKDecodeErrorZ&) = delete;
7894         CResult_RevokeAndACKDecodeErrorZ(CResult_RevokeAndACKDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); }
7895         CResult_RevokeAndACKDecodeErrorZ(LDKCResult_RevokeAndACKDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); }
7896         operator LDKCResult_RevokeAndACKDecodeErrorZ() && { LDKCResult_RevokeAndACKDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); return res; }
7897         ~CResult_RevokeAndACKDecodeErrorZ() { CResult_RevokeAndACKDecodeErrorZ_free(self); }
7898         CResult_RevokeAndACKDecodeErrorZ& operator=(CResult_RevokeAndACKDecodeErrorZ&& o) { CResult_RevokeAndACKDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); return *this; }
7899         LDKCResult_RevokeAndACKDecodeErrorZ* operator &() { return &self; }
7900         LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() { return &self; }
7901         const LDKCResult_RevokeAndACKDecodeErrorZ* operator &() const { return &self; }
7902         const LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() const { return &self; }
7903 };
7904 class CResult_SpendableOutputDescriptorDecodeErrorZ {
7905 private:
7906         LDKCResult_SpendableOutputDescriptorDecodeErrorZ self;
7907 public:
7908         CResult_SpendableOutputDescriptorDecodeErrorZ(const CResult_SpendableOutputDescriptorDecodeErrorZ&) = delete;
7909         CResult_SpendableOutputDescriptorDecodeErrorZ(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); }
7910         CResult_SpendableOutputDescriptorDecodeErrorZ(LDKCResult_SpendableOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); }
7911         operator LDKCResult_SpendableOutputDescriptorDecodeErrorZ() && { LDKCResult_SpendableOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); return res; }
7912         ~CResult_SpendableOutputDescriptorDecodeErrorZ() { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); }
7913         CResult_SpendableOutputDescriptorDecodeErrorZ& operator=(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); return *this; }
7914         LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() { return &self; }
7915         LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
7916         const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
7917         const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
7918 };
7919 class C2Tuple_PublicKeyCOption_SocketAddressZZ {
7920 private:
7921         LDKC2Tuple_PublicKeyCOption_SocketAddressZZ self;
7922 public:
7923         C2Tuple_PublicKeyCOption_SocketAddressZZ(const C2Tuple_PublicKeyCOption_SocketAddressZZ&) = delete;
7924         C2Tuple_PublicKeyCOption_SocketAddressZZ(C2Tuple_PublicKeyCOption_SocketAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyCOption_SocketAddressZZ)); }
7925         C2Tuple_PublicKeyCOption_SocketAddressZZ(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ)); }
7926         operator LDKC2Tuple_PublicKeyCOption_SocketAddressZZ() && { LDKC2Tuple_PublicKeyCOption_SocketAddressZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ)); return res; }
7927         ~C2Tuple_PublicKeyCOption_SocketAddressZZ() { C2Tuple_PublicKeyCOption_SocketAddressZZ_free(self); }
7928         C2Tuple_PublicKeyCOption_SocketAddressZZ& operator=(C2Tuple_PublicKeyCOption_SocketAddressZZ&& o) { C2Tuple_PublicKeyCOption_SocketAddressZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyCOption_SocketAddressZZ)); return *this; }
7929         LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator &() { return &self; }
7930         LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator ->() { return &self; }
7931         const LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator &() const { return &self; }
7932         const LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator ->() const { return &self; }
7933 };
7934 class CResult_UnsignedChannelUpdateDecodeErrorZ {
7935 private:
7936         LDKCResult_UnsignedChannelUpdateDecodeErrorZ self;
7937 public:
7938         CResult_UnsignedChannelUpdateDecodeErrorZ(const CResult_UnsignedChannelUpdateDecodeErrorZ&) = delete;
7939         CResult_UnsignedChannelUpdateDecodeErrorZ(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); }
7940         CResult_UnsignedChannelUpdateDecodeErrorZ(LDKCResult_UnsignedChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); }
7941         operator LDKCResult_UnsignedChannelUpdateDecodeErrorZ() && { LDKCResult_UnsignedChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); return res; }
7942         ~CResult_UnsignedChannelUpdateDecodeErrorZ() { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); }
7943         CResult_UnsignedChannelUpdateDecodeErrorZ& operator=(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); return *this; }
7944         LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() { return &self; }
7945         LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() { return &self; }
7946         const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() const { return &self; }
7947         const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
7948 };
7949 class CResult_PayeePubKeySecp256k1ErrorZ {
7950 private:
7951         LDKCResult_PayeePubKeySecp256k1ErrorZ self;
7952 public:
7953         CResult_PayeePubKeySecp256k1ErrorZ(const CResult_PayeePubKeySecp256k1ErrorZ&) = delete;
7954         CResult_PayeePubKeySecp256k1ErrorZ(CResult_PayeePubKeySecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PayeePubKeySecp256k1ErrorZ)); }
7955         CResult_PayeePubKeySecp256k1ErrorZ(LDKCResult_PayeePubKeySecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PayeePubKeySecp256k1ErrorZ)); }
7956         operator LDKCResult_PayeePubKeySecp256k1ErrorZ() && { LDKCResult_PayeePubKeySecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PayeePubKeySecp256k1ErrorZ)); return res; }
7957         ~CResult_PayeePubKeySecp256k1ErrorZ() { CResult_PayeePubKeySecp256k1ErrorZ_free(self); }
7958         CResult_PayeePubKeySecp256k1ErrorZ& operator=(CResult_PayeePubKeySecp256k1ErrorZ&& o) { CResult_PayeePubKeySecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PayeePubKeySecp256k1ErrorZ)); return *this; }
7959         LDKCResult_PayeePubKeySecp256k1ErrorZ* operator &() { return &self; }
7960         LDKCResult_PayeePubKeySecp256k1ErrorZ* operator ->() { return &self; }
7961         const LDKCResult_PayeePubKeySecp256k1ErrorZ* operator &() const { return &self; }
7962         const LDKCResult_PayeePubKeySecp256k1ErrorZ* operator ->() const { return &self; }
7963 };
7964 class COption_BigEndianScalarZ {
7965 private:
7966         LDKCOption_BigEndianScalarZ self;
7967 public:
7968         COption_BigEndianScalarZ(const COption_BigEndianScalarZ&) = delete;
7969         COption_BigEndianScalarZ(COption_BigEndianScalarZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_BigEndianScalarZ)); }
7970         COption_BigEndianScalarZ(LDKCOption_BigEndianScalarZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_BigEndianScalarZ)); }
7971         operator LDKCOption_BigEndianScalarZ() && { LDKCOption_BigEndianScalarZ res = self; memset(&self, 0, sizeof(LDKCOption_BigEndianScalarZ)); return res; }
7972         ~COption_BigEndianScalarZ() { COption_BigEndianScalarZ_free(self); }
7973         COption_BigEndianScalarZ& operator=(COption_BigEndianScalarZ&& o) { COption_BigEndianScalarZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_BigEndianScalarZ)); return *this; }
7974         LDKCOption_BigEndianScalarZ* operator &() { return &self; }
7975         LDKCOption_BigEndianScalarZ* operator ->() { return &self; }
7976         const LDKCOption_BigEndianScalarZ* operator &() const { return &self; }
7977         const LDKCOption_BigEndianScalarZ* operator ->() const { return &self; }
7978 };
7979 class CResult_PublicKeySecp256k1ErrorZ {
7980 private:
7981         LDKCResult_PublicKeySecp256k1ErrorZ self;
7982 public:
7983         CResult_PublicKeySecp256k1ErrorZ(const CResult_PublicKeySecp256k1ErrorZ&) = delete;
7984         CResult_PublicKeySecp256k1ErrorZ(CResult_PublicKeySecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PublicKeySecp256k1ErrorZ)); }
7985         CResult_PublicKeySecp256k1ErrorZ(LDKCResult_PublicKeySecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PublicKeySecp256k1ErrorZ)); }
7986         operator LDKCResult_PublicKeySecp256k1ErrorZ() && { LDKCResult_PublicKeySecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PublicKeySecp256k1ErrorZ)); return res; }
7987         ~CResult_PublicKeySecp256k1ErrorZ() { CResult_PublicKeySecp256k1ErrorZ_free(self); }
7988         CResult_PublicKeySecp256k1ErrorZ& operator=(CResult_PublicKeySecp256k1ErrorZ&& o) { CResult_PublicKeySecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PublicKeySecp256k1ErrorZ)); return *this; }
7989         LDKCResult_PublicKeySecp256k1ErrorZ* operator &() { return &self; }
7990         LDKCResult_PublicKeySecp256k1ErrorZ* operator ->() { return &self; }
7991         const LDKCResult_PublicKeySecp256k1ErrorZ* operator &() const { return &self; }
7992         const LDKCResult_PublicKeySecp256k1ErrorZ* operator ->() const { return &self; }
7993 };
7994 class CResult_CVec_ECDSASignatureZNoneZ {
7995 private:
7996         LDKCResult_CVec_ECDSASignatureZNoneZ self;
7997 public:
7998         CResult_CVec_ECDSASignatureZNoneZ(const CResult_CVec_ECDSASignatureZNoneZ&) = delete;
7999         CResult_CVec_ECDSASignatureZNoneZ(CResult_CVec_ECDSASignatureZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_ECDSASignatureZNoneZ)); }
8000         CResult_CVec_ECDSASignatureZNoneZ(LDKCResult_CVec_ECDSASignatureZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ)); }
8001         operator LDKCResult_CVec_ECDSASignatureZNoneZ() && { LDKCResult_CVec_ECDSASignatureZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ)); return res; }
8002         ~CResult_CVec_ECDSASignatureZNoneZ() { CResult_CVec_ECDSASignatureZNoneZ_free(self); }
8003         CResult_CVec_ECDSASignatureZNoneZ& operator=(CResult_CVec_ECDSASignatureZNoneZ&& o) { CResult_CVec_ECDSASignatureZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_ECDSASignatureZNoneZ)); return *this; }
8004         LDKCResult_CVec_ECDSASignatureZNoneZ* operator &() { return &self; }
8005         LDKCResult_CVec_ECDSASignatureZNoneZ* operator ->() { return &self; }
8006         const LDKCResult_CVec_ECDSASignatureZNoneZ* operator &() const { return &self; }
8007         const LDKCResult_CVec_ECDSASignatureZNoneZ* operator ->() const { return &self; }
8008 };
8009 class CVec_BlindedHopZ {
8010 private:
8011         LDKCVec_BlindedHopZ self;
8012 public:
8013         CVec_BlindedHopZ(const CVec_BlindedHopZ&) = delete;
8014         CVec_BlindedHopZ(CVec_BlindedHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BlindedHopZ)); }
8015         CVec_BlindedHopZ(LDKCVec_BlindedHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BlindedHopZ)); }
8016         operator LDKCVec_BlindedHopZ() && { LDKCVec_BlindedHopZ res = self; memset(&self, 0, sizeof(LDKCVec_BlindedHopZ)); return res; }
8017         ~CVec_BlindedHopZ() { CVec_BlindedHopZ_free(self); }
8018         CVec_BlindedHopZ& operator=(CVec_BlindedHopZ&& o) { CVec_BlindedHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BlindedHopZ)); return *this; }
8019         LDKCVec_BlindedHopZ* operator &() { return &self; }
8020         LDKCVec_BlindedHopZ* operator ->() { return &self; }
8021         const LDKCVec_BlindedHopZ* operator &() const { return &self; }
8022         const LDKCVec_BlindedHopZ* operator ->() const { return &self; }
8023 };
8024 class CResult_COption_ClosureReasonZDecodeErrorZ {
8025 private:
8026         LDKCResult_COption_ClosureReasonZDecodeErrorZ self;
8027 public:
8028         CResult_COption_ClosureReasonZDecodeErrorZ(const CResult_COption_ClosureReasonZDecodeErrorZ&) = delete;
8029         CResult_COption_ClosureReasonZDecodeErrorZ(CResult_COption_ClosureReasonZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_ClosureReasonZDecodeErrorZ)); }
8030         CResult_COption_ClosureReasonZDecodeErrorZ(LDKCResult_COption_ClosureReasonZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); }
8031         operator LDKCResult_COption_ClosureReasonZDecodeErrorZ() && { LDKCResult_COption_ClosureReasonZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); return res; }
8032         ~CResult_COption_ClosureReasonZDecodeErrorZ() { CResult_COption_ClosureReasonZDecodeErrorZ_free(self); }
8033         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; }
8034         LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() { return &self; }
8035         LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() { return &self; }
8036         const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() const { return &self; }
8037         const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() const { return &self; }
8038 };
8039 class CResult_InvoiceErrorDecodeErrorZ {
8040 private:
8041         LDKCResult_InvoiceErrorDecodeErrorZ self;
8042 public:
8043         CResult_InvoiceErrorDecodeErrorZ(const CResult_InvoiceErrorDecodeErrorZ&) = delete;
8044         CResult_InvoiceErrorDecodeErrorZ(CResult_InvoiceErrorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceErrorDecodeErrorZ)); }
8045         CResult_InvoiceErrorDecodeErrorZ(LDKCResult_InvoiceErrorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceErrorDecodeErrorZ)); }
8046         operator LDKCResult_InvoiceErrorDecodeErrorZ() && { LDKCResult_InvoiceErrorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceErrorDecodeErrorZ)); return res; }
8047         ~CResult_InvoiceErrorDecodeErrorZ() { CResult_InvoiceErrorDecodeErrorZ_free(self); }
8048         CResult_InvoiceErrorDecodeErrorZ& operator=(CResult_InvoiceErrorDecodeErrorZ&& o) { CResult_InvoiceErrorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceErrorDecodeErrorZ)); return *this; }
8049         LDKCResult_InvoiceErrorDecodeErrorZ* operator &() { return &self; }
8050         LDKCResult_InvoiceErrorDecodeErrorZ* operator ->() { return &self; }
8051         const LDKCResult_InvoiceErrorDecodeErrorZ* operator &() const { return &self; }
8052         const LDKCResult_InvoiceErrorDecodeErrorZ* operator ->() const { return &self; }
8053 };
8054 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
8055 private:
8056         LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ self;
8057 public:
8058         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(const C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&) = delete;
8059         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
8060         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
8061         operator LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() && { LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return res; }
8062         ~C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); }
8063         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ& operator=(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return *this; }
8064         LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() { return &self; }
8065         LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() { return &self; }
8066         const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() const { return &self; }
8067         const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() const { return &self; }
8068 };
8069 class CResult_RouteParametersDecodeErrorZ {
8070 private:
8071         LDKCResult_RouteParametersDecodeErrorZ self;
8072 public:
8073         CResult_RouteParametersDecodeErrorZ(const CResult_RouteParametersDecodeErrorZ&) = delete;
8074         CResult_RouteParametersDecodeErrorZ(CResult_RouteParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); }
8075         CResult_RouteParametersDecodeErrorZ(LDKCResult_RouteParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); }
8076         operator LDKCResult_RouteParametersDecodeErrorZ() && { LDKCResult_RouteParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); return res; }
8077         ~CResult_RouteParametersDecodeErrorZ() { CResult_RouteParametersDecodeErrorZ_free(self); }
8078         CResult_RouteParametersDecodeErrorZ& operator=(CResult_RouteParametersDecodeErrorZ&& o) { CResult_RouteParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); return *this; }
8079         LDKCResult_RouteParametersDecodeErrorZ* operator &() { return &self; }
8080         LDKCResult_RouteParametersDecodeErrorZ* operator ->() { return &self; }
8081         const LDKCResult_RouteParametersDecodeErrorZ* operator &() const { return &self; }
8082         const LDKCResult_RouteParametersDecodeErrorZ* operator ->() const { return &self; }
8083 };
8084 class CResult_PrivateRouteCreationErrorZ {
8085 private:
8086         LDKCResult_PrivateRouteCreationErrorZ self;
8087 public:
8088         CResult_PrivateRouteCreationErrorZ(const CResult_PrivateRouteCreationErrorZ&) = delete;
8089         CResult_PrivateRouteCreationErrorZ(CResult_PrivateRouteCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); }
8090         CResult_PrivateRouteCreationErrorZ(LDKCResult_PrivateRouteCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); }
8091         operator LDKCResult_PrivateRouteCreationErrorZ() && { LDKCResult_PrivateRouteCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); return res; }
8092         ~CResult_PrivateRouteCreationErrorZ() { CResult_PrivateRouteCreationErrorZ_free(self); }
8093         CResult_PrivateRouteCreationErrorZ& operator=(CResult_PrivateRouteCreationErrorZ&& o) { CResult_PrivateRouteCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); return *this; }
8094         LDKCResult_PrivateRouteCreationErrorZ* operator &() { return &self; }
8095         LDKCResult_PrivateRouteCreationErrorZ* operator ->() { return &self; }
8096         const LDKCResult_PrivateRouteCreationErrorZ* operator &() const { return &self; }
8097         const LDKCResult_PrivateRouteCreationErrorZ* operator ->() const { return &self; }
8098 };
8099 class CResult_NodeAliasDecodeErrorZ {
8100 private:
8101         LDKCResult_NodeAliasDecodeErrorZ self;
8102 public:
8103         CResult_NodeAliasDecodeErrorZ(const CResult_NodeAliasDecodeErrorZ&) = delete;
8104         CResult_NodeAliasDecodeErrorZ(CResult_NodeAliasDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); }
8105         CResult_NodeAliasDecodeErrorZ(LDKCResult_NodeAliasDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); }
8106         operator LDKCResult_NodeAliasDecodeErrorZ() && { LDKCResult_NodeAliasDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); return res; }
8107         ~CResult_NodeAliasDecodeErrorZ() { CResult_NodeAliasDecodeErrorZ_free(self); }
8108         CResult_NodeAliasDecodeErrorZ& operator=(CResult_NodeAliasDecodeErrorZ&& o) { CResult_NodeAliasDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); return *this; }
8109         LDKCResult_NodeAliasDecodeErrorZ* operator &() { return &self; }
8110         LDKCResult_NodeAliasDecodeErrorZ* operator ->() { return &self; }
8111         const LDKCResult_NodeAliasDecodeErrorZ* operator &() const { return &self; }
8112         const LDKCResult_NodeAliasDecodeErrorZ* operator ->() const { return &self; }
8113 };
8114 class CVec_UpdateFulfillHTLCZ {
8115 private:
8116         LDKCVec_UpdateFulfillHTLCZ self;
8117 public:
8118         CVec_UpdateFulfillHTLCZ(const CVec_UpdateFulfillHTLCZ&) = delete;
8119         CVec_UpdateFulfillHTLCZ(CVec_UpdateFulfillHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); }
8120         CVec_UpdateFulfillHTLCZ(LDKCVec_UpdateFulfillHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); }
8121         operator LDKCVec_UpdateFulfillHTLCZ() && { LDKCVec_UpdateFulfillHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); return res; }
8122         ~CVec_UpdateFulfillHTLCZ() { CVec_UpdateFulfillHTLCZ_free(self); }
8123         CVec_UpdateFulfillHTLCZ& operator=(CVec_UpdateFulfillHTLCZ&& o) { CVec_UpdateFulfillHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); return *this; }
8124         LDKCVec_UpdateFulfillHTLCZ* operator &() { return &self; }
8125         LDKCVec_UpdateFulfillHTLCZ* operator ->() { return &self; }
8126         const LDKCVec_UpdateFulfillHTLCZ* operator &() const { return &self; }
8127         const LDKCVec_UpdateFulfillHTLCZ* operator ->() const { return &self; }
8128 };
8129 class CVec_C2Tuple_u32CVec_u8ZZZ {
8130 private:
8131         LDKCVec_C2Tuple_u32CVec_u8ZZZ self;
8132 public:
8133         CVec_C2Tuple_u32CVec_u8ZZZ(const CVec_C2Tuple_u32CVec_u8ZZZ&) = delete;
8134         CVec_C2Tuple_u32CVec_u8ZZZ(CVec_C2Tuple_u32CVec_u8ZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32CVec_u8ZZZ)); }
8135         CVec_C2Tuple_u32CVec_u8ZZZ(LDKCVec_C2Tuple_u32CVec_u8ZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32CVec_u8ZZZ)); }
8136         operator LDKCVec_C2Tuple_u32CVec_u8ZZZ() && { LDKCVec_C2Tuple_u32CVec_u8ZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32CVec_u8ZZZ)); return res; }
8137         ~CVec_C2Tuple_u32CVec_u8ZZZ() { CVec_C2Tuple_u32CVec_u8ZZZ_free(self); }
8138         CVec_C2Tuple_u32CVec_u8ZZZ& operator=(CVec_C2Tuple_u32CVec_u8ZZZ&& o) { CVec_C2Tuple_u32CVec_u8ZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_u32CVec_u8ZZZ)); return *this; }
8139         LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator &() { return &self; }
8140         LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator ->() { return &self; }
8141         const LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator &() const { return &self; }
8142         const LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator ->() const { return &self; }
8143 };
8144 class CResult_AnnouncementSignaturesDecodeErrorZ {
8145 private:
8146         LDKCResult_AnnouncementSignaturesDecodeErrorZ self;
8147 public:
8148         CResult_AnnouncementSignaturesDecodeErrorZ(const CResult_AnnouncementSignaturesDecodeErrorZ&) = delete;
8149         CResult_AnnouncementSignaturesDecodeErrorZ(CResult_AnnouncementSignaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); }
8150         CResult_AnnouncementSignaturesDecodeErrorZ(LDKCResult_AnnouncementSignaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); }
8151         operator LDKCResult_AnnouncementSignaturesDecodeErrorZ() && { LDKCResult_AnnouncementSignaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); return res; }
8152         ~CResult_AnnouncementSignaturesDecodeErrorZ() { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); }
8153         CResult_AnnouncementSignaturesDecodeErrorZ& operator=(CResult_AnnouncementSignaturesDecodeErrorZ&& o) { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); return *this; }
8154         LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() { return &self; }
8155         LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() { return &self; }
8156         const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() const { return &self; }
8157         const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() const { return &self; }
8158 };
8159 class CResult_UpdateFulfillHTLCDecodeErrorZ {
8160 private:
8161         LDKCResult_UpdateFulfillHTLCDecodeErrorZ self;
8162 public:
8163         CResult_UpdateFulfillHTLCDecodeErrorZ(const CResult_UpdateFulfillHTLCDecodeErrorZ&) = delete;
8164         CResult_UpdateFulfillHTLCDecodeErrorZ(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); }
8165         CResult_UpdateFulfillHTLCDecodeErrorZ(LDKCResult_UpdateFulfillHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); }
8166         operator LDKCResult_UpdateFulfillHTLCDecodeErrorZ() && { LDKCResult_UpdateFulfillHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); return res; }
8167         ~CResult_UpdateFulfillHTLCDecodeErrorZ() { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); }
8168         CResult_UpdateFulfillHTLCDecodeErrorZ& operator=(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); return *this; }
8169         LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() { return &self; }
8170         LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() { return &self; }
8171         const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() const { return &self; }
8172         const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() const { return &self; }
8173 };
8174 class CResult_TxCompleteDecodeErrorZ {
8175 private:
8176         LDKCResult_TxCompleteDecodeErrorZ self;
8177 public:
8178         CResult_TxCompleteDecodeErrorZ(const CResult_TxCompleteDecodeErrorZ&) = delete;
8179         CResult_TxCompleteDecodeErrorZ(CResult_TxCompleteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCompleteDecodeErrorZ)); }
8180         CResult_TxCompleteDecodeErrorZ(LDKCResult_TxCompleteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCompleteDecodeErrorZ)); }
8181         operator LDKCResult_TxCompleteDecodeErrorZ() && { LDKCResult_TxCompleteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCompleteDecodeErrorZ)); return res; }
8182         ~CResult_TxCompleteDecodeErrorZ() { CResult_TxCompleteDecodeErrorZ_free(self); }
8183         CResult_TxCompleteDecodeErrorZ& operator=(CResult_TxCompleteDecodeErrorZ&& o) { CResult_TxCompleteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCompleteDecodeErrorZ)); return *this; }
8184         LDKCResult_TxCompleteDecodeErrorZ* operator &() { return &self; }
8185         LDKCResult_TxCompleteDecodeErrorZ* operator ->() { return &self; }
8186         const LDKCResult_TxCompleteDecodeErrorZ* operator &() const { return &self; }
8187         const LDKCResult_TxCompleteDecodeErrorZ* operator ->() const { return &self; }
8188 };
8189 class CResult_StrSecp256k1ErrorZ {
8190 private:
8191         LDKCResult_StrSecp256k1ErrorZ self;
8192 public:
8193         CResult_StrSecp256k1ErrorZ(const CResult_StrSecp256k1ErrorZ&) = delete;
8194         CResult_StrSecp256k1ErrorZ(CResult_StrSecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StrSecp256k1ErrorZ)); }
8195         CResult_StrSecp256k1ErrorZ(LDKCResult_StrSecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StrSecp256k1ErrorZ)); }
8196         operator LDKCResult_StrSecp256k1ErrorZ() && { LDKCResult_StrSecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StrSecp256k1ErrorZ)); return res; }
8197         ~CResult_StrSecp256k1ErrorZ() { CResult_StrSecp256k1ErrorZ_free(self); }
8198         CResult_StrSecp256k1ErrorZ& operator=(CResult_StrSecp256k1ErrorZ&& o) { CResult_StrSecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StrSecp256k1ErrorZ)); return *this; }
8199         LDKCResult_StrSecp256k1ErrorZ* operator &() { return &self; }
8200         LDKCResult_StrSecp256k1ErrorZ* operator ->() { return &self; }
8201         const LDKCResult_StrSecp256k1ErrorZ* operator &() const { return &self; }
8202         const LDKCResult_StrSecp256k1ErrorZ* operator ->() const { return &self; }
8203 };
8204 class CResult_NodeFeaturesDecodeErrorZ {
8205 private:
8206         LDKCResult_NodeFeaturesDecodeErrorZ self;
8207 public:
8208         CResult_NodeFeaturesDecodeErrorZ(const CResult_NodeFeaturesDecodeErrorZ&) = delete;
8209         CResult_NodeFeaturesDecodeErrorZ(CResult_NodeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); }
8210         CResult_NodeFeaturesDecodeErrorZ(LDKCResult_NodeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); }
8211         operator LDKCResult_NodeFeaturesDecodeErrorZ() && { LDKCResult_NodeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); return res; }
8212         ~CResult_NodeFeaturesDecodeErrorZ() { CResult_NodeFeaturesDecodeErrorZ_free(self); }
8213         CResult_NodeFeaturesDecodeErrorZ& operator=(CResult_NodeFeaturesDecodeErrorZ&& o) { CResult_NodeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); return *this; }
8214         LDKCResult_NodeFeaturesDecodeErrorZ* operator &() { return &self; }
8215         LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() { return &self; }
8216         const LDKCResult_NodeFeaturesDecodeErrorZ* operator &() const { return &self; }
8217         const LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() const { return &self; }
8218 };
8219 class CResult_InMemorySignerDecodeErrorZ {
8220 private:
8221         LDKCResult_InMemorySignerDecodeErrorZ self;
8222 public:
8223         CResult_InMemorySignerDecodeErrorZ(const CResult_InMemorySignerDecodeErrorZ&) = delete;
8224         CResult_InMemorySignerDecodeErrorZ(CResult_InMemorySignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); }
8225         CResult_InMemorySignerDecodeErrorZ(LDKCResult_InMemorySignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); }
8226         operator LDKCResult_InMemorySignerDecodeErrorZ() && { LDKCResult_InMemorySignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); return res; }
8227         ~CResult_InMemorySignerDecodeErrorZ() { CResult_InMemorySignerDecodeErrorZ_free(self); }
8228         CResult_InMemorySignerDecodeErrorZ& operator=(CResult_InMemorySignerDecodeErrorZ&& o) { CResult_InMemorySignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); return *this; }
8229         LDKCResult_InMemorySignerDecodeErrorZ* operator &() { return &self; }
8230         LDKCResult_InMemorySignerDecodeErrorZ* operator ->() { return &self; }
8231         const LDKCResult_InMemorySignerDecodeErrorZ* operator &() const { return &self; }
8232         const LDKCResult_InMemorySignerDecodeErrorZ* operator ->() const { return &self; }
8233 };
8234 class CResult_TxSignaturesDecodeErrorZ {
8235 private:
8236         LDKCResult_TxSignaturesDecodeErrorZ self;
8237 public:
8238         CResult_TxSignaturesDecodeErrorZ(const CResult_TxSignaturesDecodeErrorZ&) = delete;
8239         CResult_TxSignaturesDecodeErrorZ(CResult_TxSignaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxSignaturesDecodeErrorZ)); }
8240         CResult_TxSignaturesDecodeErrorZ(LDKCResult_TxSignaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxSignaturesDecodeErrorZ)); }
8241         operator LDKCResult_TxSignaturesDecodeErrorZ() && { LDKCResult_TxSignaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxSignaturesDecodeErrorZ)); return res; }
8242         ~CResult_TxSignaturesDecodeErrorZ() { CResult_TxSignaturesDecodeErrorZ_free(self); }
8243         CResult_TxSignaturesDecodeErrorZ& operator=(CResult_TxSignaturesDecodeErrorZ&& o) { CResult_TxSignaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxSignaturesDecodeErrorZ)); return *this; }
8244         LDKCResult_TxSignaturesDecodeErrorZ* operator &() { return &self; }
8245         LDKCResult_TxSignaturesDecodeErrorZ* operator ->() { return &self; }
8246         const LDKCResult_TxSignaturesDecodeErrorZ* operator &() const { return &self; }
8247         const LDKCResult_TxSignaturesDecodeErrorZ* operator ->() const { return &self; }
8248 };
8249 class CVec_HTLCDescriptorZ {
8250 private:
8251         LDKCVec_HTLCDescriptorZ self;
8252 public:
8253         CVec_HTLCDescriptorZ(const CVec_HTLCDescriptorZ&) = delete;
8254         CVec_HTLCDescriptorZ(CVec_HTLCDescriptorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_HTLCDescriptorZ)); }
8255         CVec_HTLCDescriptorZ(LDKCVec_HTLCDescriptorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_HTLCDescriptorZ)); }
8256         operator LDKCVec_HTLCDescriptorZ() && { LDKCVec_HTLCDescriptorZ res = self; memset(&self, 0, sizeof(LDKCVec_HTLCDescriptorZ)); return res; }
8257         ~CVec_HTLCDescriptorZ() { CVec_HTLCDescriptorZ_free(self); }
8258         CVec_HTLCDescriptorZ& operator=(CVec_HTLCDescriptorZ&& o) { CVec_HTLCDescriptorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_HTLCDescriptorZ)); return *this; }
8259         LDKCVec_HTLCDescriptorZ* operator &() { return &self; }
8260         LDKCVec_HTLCDescriptorZ* operator ->() { return &self; }
8261         const LDKCVec_HTLCDescriptorZ* operator &() const { return &self; }
8262         const LDKCVec_HTLCDescriptorZ* operator ->() const { return &self; }
8263 };
8264 class CResult_ReplyShortChannelIdsEndDecodeErrorZ {
8265 private:
8266         LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ self;
8267 public:
8268         CResult_ReplyShortChannelIdsEndDecodeErrorZ(const CResult_ReplyShortChannelIdsEndDecodeErrorZ&) = delete;
8269         CResult_ReplyShortChannelIdsEndDecodeErrorZ(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
8270         CResult_ReplyShortChannelIdsEndDecodeErrorZ(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
8271         operator LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ() && { LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); return res; }
8272         ~CResult_ReplyShortChannelIdsEndDecodeErrorZ() { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); }
8273         CResult_ReplyShortChannelIdsEndDecodeErrorZ& operator=(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); return *this; }
8274         LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() { return &self; }
8275         LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() { return &self; }
8276         const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() const { return &self; }
8277         const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() const { return &self; }
8278 };
8279 class COption_PathFailureZ {
8280 private:
8281         LDKCOption_PathFailureZ self;
8282 public:
8283         COption_PathFailureZ(const COption_PathFailureZ&) = delete;
8284         COption_PathFailureZ(COption_PathFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_PathFailureZ)); }
8285         COption_PathFailureZ(LDKCOption_PathFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_PathFailureZ)); }
8286         operator LDKCOption_PathFailureZ() && { LDKCOption_PathFailureZ res = self; memset(&self, 0, sizeof(LDKCOption_PathFailureZ)); return res; }
8287         ~COption_PathFailureZ() { COption_PathFailureZ_free(self); }
8288         COption_PathFailureZ& operator=(COption_PathFailureZ&& o) { COption_PathFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_PathFailureZ)); return *this; }
8289         LDKCOption_PathFailureZ* operator &() { return &self; }
8290         LDKCOption_PathFailureZ* operator ->() { return &self; }
8291         const LDKCOption_PathFailureZ* operator &() const { return &self; }
8292         const LDKCOption_PathFailureZ* operator ->() const { return &self; }
8293 };
8294 class CVec_ECDSASignatureZ {
8295 private:
8296         LDKCVec_ECDSASignatureZ self;
8297 public:
8298         CVec_ECDSASignatureZ(const CVec_ECDSASignatureZ&) = delete;
8299         CVec_ECDSASignatureZ(CVec_ECDSASignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ECDSASignatureZ)); }
8300         CVec_ECDSASignatureZ(LDKCVec_ECDSASignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ECDSASignatureZ)); }
8301         operator LDKCVec_ECDSASignatureZ() && { LDKCVec_ECDSASignatureZ res = self; memset(&self, 0, sizeof(LDKCVec_ECDSASignatureZ)); return res; }
8302         ~CVec_ECDSASignatureZ() { CVec_ECDSASignatureZ_free(self); }
8303         CVec_ECDSASignatureZ& operator=(CVec_ECDSASignatureZ&& o) { CVec_ECDSASignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ECDSASignatureZ)); return *this; }
8304         LDKCVec_ECDSASignatureZ* operator &() { return &self; }
8305         LDKCVec_ECDSASignatureZ* operator ->() { return &self; }
8306         const LDKCVec_ECDSASignatureZ* operator &() const { return &self; }
8307         const LDKCVec_ECDSASignatureZ* operator ->() const { return &self; }
8308 };
8309 class CResult_ChannelUpdateInfoDecodeErrorZ {
8310 private:
8311         LDKCResult_ChannelUpdateInfoDecodeErrorZ self;
8312 public:
8313         CResult_ChannelUpdateInfoDecodeErrorZ(const CResult_ChannelUpdateInfoDecodeErrorZ&) = delete;
8314         CResult_ChannelUpdateInfoDecodeErrorZ(CResult_ChannelUpdateInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); }
8315         CResult_ChannelUpdateInfoDecodeErrorZ(LDKCResult_ChannelUpdateInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); }
8316         operator LDKCResult_ChannelUpdateInfoDecodeErrorZ() && { LDKCResult_ChannelUpdateInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); return res; }
8317         ~CResult_ChannelUpdateInfoDecodeErrorZ() { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); }
8318         CResult_ChannelUpdateInfoDecodeErrorZ& operator=(CResult_ChannelUpdateInfoDecodeErrorZ&& o) { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); return *this; }
8319         LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() { return &self; }
8320         LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() { return &self; }
8321         const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() const { return &self; }
8322         const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() const { return &self; }
8323 };
8324 class CVec_UpdateFailHTLCZ {
8325 private:
8326         LDKCVec_UpdateFailHTLCZ self;
8327 public:
8328         CVec_UpdateFailHTLCZ(const CVec_UpdateFailHTLCZ&) = delete;
8329         CVec_UpdateFailHTLCZ(CVec_UpdateFailHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); }
8330         CVec_UpdateFailHTLCZ(LDKCVec_UpdateFailHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); }
8331         operator LDKCVec_UpdateFailHTLCZ() && { LDKCVec_UpdateFailHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); return res; }
8332         ~CVec_UpdateFailHTLCZ() { CVec_UpdateFailHTLCZ_free(self); }
8333         CVec_UpdateFailHTLCZ& operator=(CVec_UpdateFailHTLCZ&& o) { CVec_UpdateFailHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); return *this; }
8334         LDKCVec_UpdateFailHTLCZ* operator &() { return &self; }
8335         LDKCVec_UpdateFailHTLCZ* operator ->() { return &self; }
8336         const LDKCVec_UpdateFailHTLCZ* operator &() const { return &self; }
8337         const LDKCVec_UpdateFailHTLCZ* operator ->() const { return &self; }
8338 };
8339 class CVec_TxOutZ {
8340 private:
8341         LDKCVec_TxOutZ self;
8342 public:
8343         CVec_TxOutZ(const CVec_TxOutZ&) = delete;
8344         CVec_TxOutZ(CVec_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TxOutZ)); }
8345         CVec_TxOutZ(LDKCVec_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TxOutZ)); }
8346         operator LDKCVec_TxOutZ() && { LDKCVec_TxOutZ res = self; memset(&self, 0, sizeof(LDKCVec_TxOutZ)); return res; }
8347         ~CVec_TxOutZ() { CVec_TxOutZ_free(self); }
8348         CVec_TxOutZ& operator=(CVec_TxOutZ&& o) { CVec_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TxOutZ)); return *this; }
8349         LDKCVec_TxOutZ* operator &() { return &self; }
8350         LDKCVec_TxOutZ* operator ->() { return &self; }
8351         const LDKCVec_TxOutZ* operator &() const { return &self; }
8352         const LDKCVec_TxOutZ* operator ->() const { return &self; }
8353 };
8354 class CResult_BuiltCommitmentTransactionDecodeErrorZ {
8355 private:
8356         LDKCResult_BuiltCommitmentTransactionDecodeErrorZ self;
8357 public:
8358         CResult_BuiltCommitmentTransactionDecodeErrorZ(const CResult_BuiltCommitmentTransactionDecodeErrorZ&) = delete;
8359         CResult_BuiltCommitmentTransactionDecodeErrorZ(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); }
8360         CResult_BuiltCommitmentTransactionDecodeErrorZ(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); }
8361         operator LDKCResult_BuiltCommitmentTransactionDecodeErrorZ() && { LDKCResult_BuiltCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); return res; }
8362         ~CResult_BuiltCommitmentTransactionDecodeErrorZ() { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); }
8363         CResult_BuiltCommitmentTransactionDecodeErrorZ& operator=(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); return *this; }
8364         LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
8365         LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
8366         const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
8367         const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
8368 };
8369 class CVec_SpendableOutputDescriptorZ {
8370 private:
8371         LDKCVec_SpendableOutputDescriptorZ self;
8372 public:
8373         CVec_SpendableOutputDescriptorZ(const CVec_SpendableOutputDescriptorZ&) = delete;
8374         CVec_SpendableOutputDescriptorZ(CVec_SpendableOutputDescriptorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SpendableOutputDescriptorZ)); }
8375         CVec_SpendableOutputDescriptorZ(LDKCVec_SpendableOutputDescriptorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SpendableOutputDescriptorZ)); }
8376         operator LDKCVec_SpendableOutputDescriptorZ() && { LDKCVec_SpendableOutputDescriptorZ res = self; memset(&self, 0, sizeof(LDKCVec_SpendableOutputDescriptorZ)); return res; }
8377         ~CVec_SpendableOutputDescriptorZ() { CVec_SpendableOutputDescriptorZ_free(self); }
8378         CVec_SpendableOutputDescriptorZ& operator=(CVec_SpendableOutputDescriptorZ&& o) { CVec_SpendableOutputDescriptorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_SpendableOutputDescriptorZ)); return *this; }
8379         LDKCVec_SpendableOutputDescriptorZ* operator &() { return &self; }
8380         LDKCVec_SpendableOutputDescriptorZ* operator ->() { return &self; }
8381         const LDKCVec_SpendableOutputDescriptorZ* operator &() const { return &self; }
8382         const LDKCVec_SpendableOutputDescriptorZ* operator ->() const { return &self; }
8383 };
8384 class C2Tuple_OutPointCVec_u8ZZ {
8385 private:
8386         LDKC2Tuple_OutPointCVec_u8ZZ self;
8387 public:
8388         C2Tuple_OutPointCVec_u8ZZ(const C2Tuple_OutPointCVec_u8ZZ&) = delete;
8389         C2Tuple_OutPointCVec_u8ZZ(C2Tuple_OutPointCVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointCVec_u8ZZ)); }
8390         C2Tuple_OutPointCVec_u8ZZ(LDKC2Tuple_OutPointCVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointCVec_u8ZZ)); }
8391         operator LDKC2Tuple_OutPointCVec_u8ZZ() && { LDKC2Tuple_OutPointCVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointCVec_u8ZZ)); return res; }
8392         ~C2Tuple_OutPointCVec_u8ZZ() { C2Tuple_OutPointCVec_u8ZZ_free(self); }
8393         C2Tuple_OutPointCVec_u8ZZ& operator=(C2Tuple_OutPointCVec_u8ZZ&& o) { C2Tuple_OutPointCVec_u8ZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OutPointCVec_u8ZZ)); return *this; }
8394         LDKC2Tuple_OutPointCVec_u8ZZ* operator &() { return &self; }
8395         LDKC2Tuple_OutPointCVec_u8ZZ* operator ->() { return &self; }
8396         const LDKC2Tuple_OutPointCVec_u8ZZ* operator &() const { return &self; }
8397         const LDKC2Tuple_OutPointCVec_u8ZZ* operator ->() const { return &self; }
8398 };
8399 class COption_C2Tuple_u64u64ZZ {
8400 private:
8401         LDKCOption_C2Tuple_u64u64ZZ self;
8402 public:
8403         COption_C2Tuple_u64u64ZZ(const COption_C2Tuple_u64u64ZZ&) = delete;
8404         COption_C2Tuple_u64u64ZZ(COption_C2Tuple_u64u64ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_u64u64ZZ)); }
8405         COption_C2Tuple_u64u64ZZ(LDKCOption_C2Tuple_u64u64ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_u64u64ZZ)); }
8406         operator LDKCOption_C2Tuple_u64u64ZZ() && { LDKCOption_C2Tuple_u64u64ZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_u64u64ZZ)); return res; }
8407         ~COption_C2Tuple_u64u64ZZ() { COption_C2Tuple_u64u64ZZ_free(self); }
8408         COption_C2Tuple_u64u64ZZ& operator=(COption_C2Tuple_u64u64ZZ&& o) { COption_C2Tuple_u64u64ZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C2Tuple_u64u64ZZ)); return *this; }
8409         LDKCOption_C2Tuple_u64u64ZZ* operator &() { return &self; }
8410         LDKCOption_C2Tuple_u64u64ZZ* operator ->() { return &self; }
8411         const LDKCOption_C2Tuple_u64u64ZZ* operator &() const { return &self; }
8412         const LDKCOption_C2Tuple_u64u64ZZ* operator ->() const { return &self; }
8413 };
8414 class CResult_ChannelAnnouncementDecodeErrorZ {
8415 private:
8416         LDKCResult_ChannelAnnouncementDecodeErrorZ self;
8417 public:
8418         CResult_ChannelAnnouncementDecodeErrorZ(const CResult_ChannelAnnouncementDecodeErrorZ&) = delete;
8419         CResult_ChannelAnnouncementDecodeErrorZ(CResult_ChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); }
8420         CResult_ChannelAnnouncementDecodeErrorZ(LDKCResult_ChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); }
8421         operator LDKCResult_ChannelAnnouncementDecodeErrorZ() && { LDKCResult_ChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); return res; }
8422         ~CResult_ChannelAnnouncementDecodeErrorZ() { CResult_ChannelAnnouncementDecodeErrorZ_free(self); }
8423         CResult_ChannelAnnouncementDecodeErrorZ& operator=(CResult_ChannelAnnouncementDecodeErrorZ&& o) { CResult_ChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); return *this; }
8424         LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
8425         LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
8426         const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
8427         const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
8428 };
8429 class CResult_PeeledOnionNoneZ {
8430 private:
8431         LDKCResult_PeeledOnionNoneZ self;
8432 public:
8433         CResult_PeeledOnionNoneZ(const CResult_PeeledOnionNoneZ&) = delete;
8434         CResult_PeeledOnionNoneZ(CResult_PeeledOnionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PeeledOnionNoneZ)); }
8435         CResult_PeeledOnionNoneZ(LDKCResult_PeeledOnionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PeeledOnionNoneZ)); }
8436         operator LDKCResult_PeeledOnionNoneZ() && { LDKCResult_PeeledOnionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_PeeledOnionNoneZ)); return res; }
8437         ~CResult_PeeledOnionNoneZ() { CResult_PeeledOnionNoneZ_free(self); }
8438         CResult_PeeledOnionNoneZ& operator=(CResult_PeeledOnionNoneZ&& o) { CResult_PeeledOnionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PeeledOnionNoneZ)); return *this; }
8439         LDKCResult_PeeledOnionNoneZ* operator &() { return &self; }
8440         LDKCResult_PeeledOnionNoneZ* operator ->() { return &self; }
8441         const LDKCResult_PeeledOnionNoneZ* operator &() const { return &self; }
8442         const LDKCResult_PeeledOnionNoneZ* operator ->() const { return &self; }
8443 };
8444 class CResult_HTLCUpdateDecodeErrorZ {
8445 private:
8446         LDKCResult_HTLCUpdateDecodeErrorZ self;
8447 public:
8448         CResult_HTLCUpdateDecodeErrorZ(const CResult_HTLCUpdateDecodeErrorZ&) = delete;
8449         CResult_HTLCUpdateDecodeErrorZ(CResult_HTLCUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCUpdateDecodeErrorZ)); }
8450         CResult_HTLCUpdateDecodeErrorZ(LDKCResult_HTLCUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCUpdateDecodeErrorZ)); }
8451         operator LDKCResult_HTLCUpdateDecodeErrorZ() && { LDKCResult_HTLCUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCUpdateDecodeErrorZ)); return res; }
8452         ~CResult_HTLCUpdateDecodeErrorZ() { CResult_HTLCUpdateDecodeErrorZ_free(self); }
8453         CResult_HTLCUpdateDecodeErrorZ& operator=(CResult_HTLCUpdateDecodeErrorZ&& o) { CResult_HTLCUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCUpdateDecodeErrorZ)); return *this; }
8454         LDKCResult_HTLCUpdateDecodeErrorZ* operator &() { return &self; }
8455         LDKCResult_HTLCUpdateDecodeErrorZ* operator ->() { return &self; }
8456         const LDKCResult_HTLCUpdateDecodeErrorZ* operator &() const { return &self; }
8457         const LDKCResult_HTLCUpdateDecodeErrorZ* operator ->() const { return &self; }
8458 };
8459 class CResult_TxAddInputDecodeErrorZ {
8460 private:
8461         LDKCResult_TxAddInputDecodeErrorZ self;
8462 public:
8463         CResult_TxAddInputDecodeErrorZ(const CResult_TxAddInputDecodeErrorZ&) = delete;
8464         CResult_TxAddInputDecodeErrorZ(CResult_TxAddInputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAddInputDecodeErrorZ)); }
8465         CResult_TxAddInputDecodeErrorZ(LDKCResult_TxAddInputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAddInputDecodeErrorZ)); }
8466         operator LDKCResult_TxAddInputDecodeErrorZ() && { LDKCResult_TxAddInputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAddInputDecodeErrorZ)); return res; }
8467         ~CResult_TxAddInputDecodeErrorZ() { CResult_TxAddInputDecodeErrorZ_free(self); }
8468         CResult_TxAddInputDecodeErrorZ& operator=(CResult_TxAddInputDecodeErrorZ&& o) { CResult_TxAddInputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAddInputDecodeErrorZ)); return *this; }
8469         LDKCResult_TxAddInputDecodeErrorZ* operator &() { return &self; }
8470         LDKCResult_TxAddInputDecodeErrorZ* operator ->() { return &self; }
8471         const LDKCResult_TxAddInputDecodeErrorZ* operator &() const { return &self; }
8472         const LDKCResult_TxAddInputDecodeErrorZ* operator ->() const { return &self; }
8473 };
8474 class CVec_OutPointZ {
8475 private:
8476         LDKCVec_OutPointZ self;
8477 public:
8478         CVec_OutPointZ(const CVec_OutPointZ&) = delete;
8479         CVec_OutPointZ(CVec_OutPointZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_OutPointZ)); }
8480         CVec_OutPointZ(LDKCVec_OutPointZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_OutPointZ)); }
8481         operator LDKCVec_OutPointZ() && { LDKCVec_OutPointZ res = self; memset(&self, 0, sizeof(LDKCVec_OutPointZ)); return res; }
8482         ~CVec_OutPointZ() { CVec_OutPointZ_free(self); }
8483         CVec_OutPointZ& operator=(CVec_OutPointZ&& o) { CVec_OutPointZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_OutPointZ)); return *this; }
8484         LDKCVec_OutPointZ* operator &() { return &self; }
8485         LDKCVec_OutPointZ* operator ->() { return &self; }
8486         const LDKCVec_OutPointZ* operator &() const { return &self; }
8487         const LDKCVec_OutPointZ* operator ->() const { return &self; }
8488 };
8489 class CResult_TxInitRbfDecodeErrorZ {
8490 private:
8491         LDKCResult_TxInitRbfDecodeErrorZ self;
8492 public:
8493         CResult_TxInitRbfDecodeErrorZ(const CResult_TxInitRbfDecodeErrorZ&) = delete;
8494         CResult_TxInitRbfDecodeErrorZ(CResult_TxInitRbfDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxInitRbfDecodeErrorZ)); }
8495         CResult_TxInitRbfDecodeErrorZ(LDKCResult_TxInitRbfDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxInitRbfDecodeErrorZ)); }
8496         operator LDKCResult_TxInitRbfDecodeErrorZ() && { LDKCResult_TxInitRbfDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxInitRbfDecodeErrorZ)); return res; }
8497         ~CResult_TxInitRbfDecodeErrorZ() { CResult_TxInitRbfDecodeErrorZ_free(self); }
8498         CResult_TxInitRbfDecodeErrorZ& operator=(CResult_TxInitRbfDecodeErrorZ&& o) { CResult_TxInitRbfDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxInitRbfDecodeErrorZ)); return *this; }
8499         LDKCResult_TxInitRbfDecodeErrorZ* operator &() { return &self; }
8500         LDKCResult_TxInitRbfDecodeErrorZ* operator ->() { return &self; }
8501         const LDKCResult_TxInitRbfDecodeErrorZ* operator &() const { return &self; }
8502         const LDKCResult_TxInitRbfDecodeErrorZ* operator ->() const { return &self; }
8503 };
8504 class COption_WriteableScoreZ {
8505 private:
8506         LDKCOption_WriteableScoreZ self;
8507 public:
8508         COption_WriteableScoreZ(const COption_WriteableScoreZ&) = delete;
8509         COption_WriteableScoreZ(COption_WriteableScoreZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_WriteableScoreZ)); }
8510         COption_WriteableScoreZ(LDKCOption_WriteableScoreZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_WriteableScoreZ)); }
8511         operator LDKCOption_WriteableScoreZ() && { LDKCOption_WriteableScoreZ res = self; memset(&self, 0, sizeof(LDKCOption_WriteableScoreZ)); return res; }
8512         ~COption_WriteableScoreZ() { COption_WriteableScoreZ_free(self); }
8513         COption_WriteableScoreZ& operator=(COption_WriteableScoreZ&& o) { COption_WriteableScoreZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_WriteableScoreZ)); return *this; }
8514         LDKCOption_WriteableScoreZ* operator &() { return &self; }
8515         LDKCOption_WriteableScoreZ* operator ->() { return &self; }
8516         const LDKCOption_WriteableScoreZ* operator &() const { return &self; }
8517         const LDKCOption_WriteableScoreZ* operator ->() const { return &self; }
8518 };
8519 class CVec_StrZ {
8520 private:
8521         LDKCVec_StrZ self;
8522 public:
8523         CVec_StrZ(const CVec_StrZ&) = delete;
8524         CVec_StrZ(CVec_StrZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_StrZ)); }
8525         CVec_StrZ(LDKCVec_StrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_StrZ)); }
8526         operator LDKCVec_StrZ() && { LDKCVec_StrZ res = self; memset(&self, 0, sizeof(LDKCVec_StrZ)); return res; }
8527         ~CVec_StrZ() { CVec_StrZ_free(self); }
8528         CVec_StrZ& operator=(CVec_StrZ&& o) { CVec_StrZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_StrZ)); return *this; }
8529         LDKCVec_StrZ* operator &() { return &self; }
8530         LDKCVec_StrZ* operator ->() { return &self; }
8531         const LDKCVec_StrZ* operator &() const { return &self; }
8532         const LDKCVec_StrZ* operator ->() const { return &self; }
8533 };
8534 class CResult_PositiveTimestampCreationErrorZ {
8535 private:
8536         LDKCResult_PositiveTimestampCreationErrorZ self;
8537 public:
8538         CResult_PositiveTimestampCreationErrorZ(const CResult_PositiveTimestampCreationErrorZ&) = delete;
8539         CResult_PositiveTimestampCreationErrorZ(CResult_PositiveTimestampCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PositiveTimestampCreationErrorZ)); }
8540         CResult_PositiveTimestampCreationErrorZ(LDKCResult_PositiveTimestampCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PositiveTimestampCreationErrorZ)); }
8541         operator LDKCResult_PositiveTimestampCreationErrorZ() && { LDKCResult_PositiveTimestampCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PositiveTimestampCreationErrorZ)); return res; }
8542         ~CResult_PositiveTimestampCreationErrorZ() { CResult_PositiveTimestampCreationErrorZ_free(self); }
8543         CResult_PositiveTimestampCreationErrorZ& operator=(CResult_PositiveTimestampCreationErrorZ&& o) { CResult_PositiveTimestampCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PositiveTimestampCreationErrorZ)); return *this; }
8544         LDKCResult_PositiveTimestampCreationErrorZ* operator &() { return &self; }
8545         LDKCResult_PositiveTimestampCreationErrorZ* operator ->() { return &self; }
8546         const LDKCResult_PositiveTimestampCreationErrorZ* operator &() const { return &self; }
8547         const LDKCResult_PositiveTimestampCreationErrorZ* operator ->() const { return &self; }
8548 };
8549 class CResult_ChannelMonitorUpdateDecodeErrorZ {
8550 private:
8551         LDKCResult_ChannelMonitorUpdateDecodeErrorZ self;
8552 public:
8553         CResult_ChannelMonitorUpdateDecodeErrorZ(const CResult_ChannelMonitorUpdateDecodeErrorZ&) = delete;
8554         CResult_ChannelMonitorUpdateDecodeErrorZ(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); }
8555         CResult_ChannelMonitorUpdateDecodeErrorZ(LDKCResult_ChannelMonitorUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); }
8556         operator LDKCResult_ChannelMonitorUpdateDecodeErrorZ() && { LDKCResult_ChannelMonitorUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); return res; }
8557         ~CResult_ChannelMonitorUpdateDecodeErrorZ() { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); }
8558         CResult_ChannelMonitorUpdateDecodeErrorZ& operator=(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); return *this; }
8559         LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() { return &self; }
8560         LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() { return &self; }
8561         const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() const { return &self; }
8562         const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() const { return &self; }
8563 };
8564 class C2Tuple_BlindedPayInfoBlindedPathZ {
8565 private:
8566         LDKC2Tuple_BlindedPayInfoBlindedPathZ self;
8567 public:
8568         C2Tuple_BlindedPayInfoBlindedPathZ(const C2Tuple_BlindedPayInfoBlindedPathZ&) = delete;
8569         C2Tuple_BlindedPayInfoBlindedPathZ(C2Tuple_BlindedPayInfoBlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BlindedPayInfoBlindedPathZ)); }
8570         C2Tuple_BlindedPayInfoBlindedPathZ(LDKC2Tuple_BlindedPayInfoBlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ)); }
8571         operator LDKC2Tuple_BlindedPayInfoBlindedPathZ() && { LDKC2Tuple_BlindedPayInfoBlindedPathZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ)); return res; }
8572         ~C2Tuple_BlindedPayInfoBlindedPathZ() { C2Tuple_BlindedPayInfoBlindedPathZ_free(self); }
8573         C2Tuple_BlindedPayInfoBlindedPathZ& operator=(C2Tuple_BlindedPayInfoBlindedPathZ&& o) { C2Tuple_BlindedPayInfoBlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BlindedPayInfoBlindedPathZ)); return *this; }
8574         LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator &() { return &self; }
8575         LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator ->() { return &self; }
8576         const LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator &() const { return &self; }
8577         const LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator ->() const { return &self; }
8578 };
8579 class CResult_ReplyChannelRangeDecodeErrorZ {
8580 private:
8581         LDKCResult_ReplyChannelRangeDecodeErrorZ self;
8582 public:
8583         CResult_ReplyChannelRangeDecodeErrorZ(const CResult_ReplyChannelRangeDecodeErrorZ&) = delete;
8584         CResult_ReplyChannelRangeDecodeErrorZ(CResult_ReplyChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); }
8585         CResult_ReplyChannelRangeDecodeErrorZ(LDKCResult_ReplyChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); }
8586         operator LDKCResult_ReplyChannelRangeDecodeErrorZ() && { LDKCResult_ReplyChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); return res; }
8587         ~CResult_ReplyChannelRangeDecodeErrorZ() { CResult_ReplyChannelRangeDecodeErrorZ_free(self); }
8588         CResult_ReplyChannelRangeDecodeErrorZ& operator=(CResult_ReplyChannelRangeDecodeErrorZ&& o) { CResult_ReplyChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); return *this; }
8589         LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() { return &self; }
8590         LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() { return &self; }
8591         const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() const { return &self; }
8592         const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() const { return &self; }
8593 };
8594 class CResult_UnsignedNodeAnnouncementDecodeErrorZ {
8595 private:
8596         LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ self;
8597 public:
8598         CResult_UnsignedNodeAnnouncementDecodeErrorZ(const CResult_UnsignedNodeAnnouncementDecodeErrorZ&) = delete;
8599         CResult_UnsignedNodeAnnouncementDecodeErrorZ(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
8600         CResult_UnsignedNodeAnnouncementDecodeErrorZ(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
8601         operator LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); return res; }
8602         ~CResult_UnsignedNodeAnnouncementDecodeErrorZ() { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); }
8603         CResult_UnsignedNodeAnnouncementDecodeErrorZ& operator=(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); return *this; }
8604         LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() { return &self; }
8605         LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
8606         const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
8607         const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
8608 };
8609 class CResult_TrustedClosingTransactionNoneZ {
8610 private:
8611         LDKCResult_TrustedClosingTransactionNoneZ self;
8612 public:
8613         CResult_TrustedClosingTransactionNoneZ(const CResult_TrustedClosingTransactionNoneZ&) = delete;
8614         CResult_TrustedClosingTransactionNoneZ(CResult_TrustedClosingTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedClosingTransactionNoneZ)); }
8615         CResult_TrustedClosingTransactionNoneZ(LDKCResult_TrustedClosingTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedClosingTransactionNoneZ)); }
8616         operator LDKCResult_TrustedClosingTransactionNoneZ() && { LDKCResult_TrustedClosingTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedClosingTransactionNoneZ)); return res; }
8617         ~CResult_TrustedClosingTransactionNoneZ() { CResult_TrustedClosingTransactionNoneZ_free(self); }
8618         CResult_TrustedClosingTransactionNoneZ& operator=(CResult_TrustedClosingTransactionNoneZ&& o) { CResult_TrustedClosingTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedClosingTransactionNoneZ)); return *this; }
8619         LDKCResult_TrustedClosingTransactionNoneZ* operator &() { return &self; }
8620         LDKCResult_TrustedClosingTransactionNoneZ* operator ->() { return &self; }
8621         const LDKCResult_TrustedClosingTransactionNoneZ* operator &() const { return &self; }
8622         const LDKCResult_TrustedClosingTransactionNoneZ* operator ->() const { return &self; }
8623 };
8624 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ {
8625 private:
8626         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ self;
8627 public:
8628         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(const CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&) = delete;
8629         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); }
8630         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); }
8631         operator LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); return res; }
8632         ~CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ() { CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(self); }
8633         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ& operator=(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&& o) { CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); return *this; }
8634         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator &() { return &self; }
8635         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator ->() { return &self; }
8636         const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator &() const { return &self; }
8637         const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator ->() const { return &self; }
8638 };
8639 class C2Tuple_PublicKeyTypeZ {
8640 private:
8641         LDKC2Tuple_PublicKeyTypeZ self;
8642 public:
8643         C2Tuple_PublicKeyTypeZ(const C2Tuple_PublicKeyTypeZ&) = delete;
8644         C2Tuple_PublicKeyTypeZ(C2Tuple_PublicKeyTypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyTypeZ)); }
8645         C2Tuple_PublicKeyTypeZ(LDKC2Tuple_PublicKeyTypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyTypeZ)); }
8646         operator LDKC2Tuple_PublicKeyTypeZ() && { LDKC2Tuple_PublicKeyTypeZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyTypeZ)); return res; }
8647         ~C2Tuple_PublicKeyTypeZ() { C2Tuple_PublicKeyTypeZ_free(self); }
8648         C2Tuple_PublicKeyTypeZ& operator=(C2Tuple_PublicKeyTypeZ&& o) { C2Tuple_PublicKeyTypeZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyTypeZ)); return *this; }
8649         LDKC2Tuple_PublicKeyTypeZ* operator &() { return &self; }
8650         LDKC2Tuple_PublicKeyTypeZ* operator ->() { return &self; }
8651         const LDKC2Tuple_PublicKeyTypeZ* operator &() const { return &self; }
8652         const LDKC2Tuple_PublicKeyTypeZ* operator ->() const { return &self; }
8653 };
8654 class CResult_TxRemoveOutputDecodeErrorZ {
8655 private:
8656         LDKCResult_TxRemoveOutputDecodeErrorZ self;
8657 public:
8658         CResult_TxRemoveOutputDecodeErrorZ(const CResult_TxRemoveOutputDecodeErrorZ&) = delete;
8659         CResult_TxRemoveOutputDecodeErrorZ(CResult_TxRemoveOutputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxRemoveOutputDecodeErrorZ)); }
8660         CResult_TxRemoveOutputDecodeErrorZ(LDKCResult_TxRemoveOutputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxRemoveOutputDecodeErrorZ)); }
8661         operator LDKCResult_TxRemoveOutputDecodeErrorZ() && { LDKCResult_TxRemoveOutputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxRemoveOutputDecodeErrorZ)); return res; }
8662         ~CResult_TxRemoveOutputDecodeErrorZ() { CResult_TxRemoveOutputDecodeErrorZ_free(self); }
8663         CResult_TxRemoveOutputDecodeErrorZ& operator=(CResult_TxRemoveOutputDecodeErrorZ&& o) { CResult_TxRemoveOutputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxRemoveOutputDecodeErrorZ)); return *this; }
8664         LDKCResult_TxRemoveOutputDecodeErrorZ* operator &() { return &self; }
8665         LDKCResult_TxRemoveOutputDecodeErrorZ* operator ->() { return &self; }
8666         const LDKCResult_TxRemoveOutputDecodeErrorZ* operator &() const { return &self; }
8667         const LDKCResult_TxRemoveOutputDecodeErrorZ* operator ->() const { return &self; }
8668 };
8669 class CResult_ChannelReestablishDecodeErrorZ {
8670 private:
8671         LDKCResult_ChannelReestablishDecodeErrorZ self;
8672 public:
8673         CResult_ChannelReestablishDecodeErrorZ(const CResult_ChannelReestablishDecodeErrorZ&) = delete;
8674         CResult_ChannelReestablishDecodeErrorZ(CResult_ChannelReestablishDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelReestablishDecodeErrorZ)); }
8675         CResult_ChannelReestablishDecodeErrorZ(LDKCResult_ChannelReestablishDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelReestablishDecodeErrorZ)); }
8676         operator LDKCResult_ChannelReestablishDecodeErrorZ() && { LDKCResult_ChannelReestablishDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelReestablishDecodeErrorZ)); return res; }
8677         ~CResult_ChannelReestablishDecodeErrorZ() { CResult_ChannelReestablishDecodeErrorZ_free(self); }
8678         CResult_ChannelReestablishDecodeErrorZ& operator=(CResult_ChannelReestablishDecodeErrorZ&& o) { CResult_ChannelReestablishDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelReestablishDecodeErrorZ)); return *this; }
8679         LDKCResult_ChannelReestablishDecodeErrorZ* operator &() { return &self; }
8680         LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() { return &self; }
8681         const LDKCResult_ChannelReestablishDecodeErrorZ* operator &() const { return &self; }
8682         const LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() const { return &self; }
8683 };
8684 class CResult_OnionMessageDecodeErrorZ {
8685 private:
8686         LDKCResult_OnionMessageDecodeErrorZ self;
8687 public:
8688         CResult_OnionMessageDecodeErrorZ(const CResult_OnionMessageDecodeErrorZ&) = delete;
8689         CResult_OnionMessageDecodeErrorZ(CResult_OnionMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionMessageDecodeErrorZ)); }
8690         CResult_OnionMessageDecodeErrorZ(LDKCResult_OnionMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionMessageDecodeErrorZ)); }
8691         operator LDKCResult_OnionMessageDecodeErrorZ() && { LDKCResult_OnionMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionMessageDecodeErrorZ)); return res; }
8692         ~CResult_OnionMessageDecodeErrorZ() { CResult_OnionMessageDecodeErrorZ_free(self); }
8693         CResult_OnionMessageDecodeErrorZ& operator=(CResult_OnionMessageDecodeErrorZ&& o) { CResult_OnionMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionMessageDecodeErrorZ)); return *this; }
8694         LDKCResult_OnionMessageDecodeErrorZ* operator &() { return &self; }
8695         LDKCResult_OnionMessageDecodeErrorZ* operator ->() { return &self; }
8696         const LDKCResult_OnionMessageDecodeErrorZ* operator &() const { return &self; }
8697         const LDKCResult_OnionMessageDecodeErrorZ* operator ->() const { return &self; }
8698 };
8699 class CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ {
8700 private:
8701         LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ self;
8702 public:
8703         CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ(const CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ&) = delete;
8704         CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ(CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ)); }
8705         CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ(LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ)); }
8706         operator LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ)); return res; }
8707         ~CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ() { CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_free(self); }
8708         CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ& operator=(CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ&& o) { CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ)); return *this; }
8709         LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ* operator &() { return &self; }
8710         LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ* operator ->() { return &self; }
8711         const LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ* operator &() const { return &self; }
8712         const LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ* operator ->() const { return &self; }
8713 };
8714 class CResult_C2Tuple_CVec_u8ZusizeZNoneZ {
8715 private:
8716         LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ self;
8717 public:
8718         CResult_C2Tuple_CVec_u8ZusizeZNoneZ(const CResult_C2Tuple_CVec_u8ZusizeZNoneZ&) = delete;
8719         CResult_C2Tuple_CVec_u8ZusizeZNoneZ(CResult_C2Tuple_CVec_u8ZusizeZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_CVec_u8ZusizeZNoneZ)); }
8720         CResult_C2Tuple_CVec_u8ZusizeZNoneZ(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ)); }
8721         operator LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ() && { LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ)); return res; }
8722         ~CResult_C2Tuple_CVec_u8ZusizeZNoneZ() { CResult_C2Tuple_CVec_u8ZusizeZNoneZ_free(self); }
8723         CResult_C2Tuple_CVec_u8ZusizeZNoneZ& operator=(CResult_C2Tuple_CVec_u8ZusizeZNoneZ&& o) { CResult_C2Tuple_CVec_u8ZusizeZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_CVec_u8ZusizeZNoneZ)); return *this; }
8724         LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* operator &() { return &self; }
8725         LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* operator ->() { return &self; }
8726         const LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* operator &() const { return &self; }
8727         const LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* operator ->() const { return &self; }
8728 };
8729 class CResult_Bolt11InvoiceParseOrSemanticErrorZ {
8730 private:
8731         LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ self;
8732 public:
8733         CResult_Bolt11InvoiceParseOrSemanticErrorZ(const CResult_Bolt11InvoiceParseOrSemanticErrorZ&) = delete;
8734         CResult_Bolt11InvoiceParseOrSemanticErrorZ(CResult_Bolt11InvoiceParseOrSemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceParseOrSemanticErrorZ)); }
8735         CResult_Bolt11InvoiceParseOrSemanticErrorZ(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ)); }
8736         operator LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ() && { LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ)); return res; }
8737         ~CResult_Bolt11InvoiceParseOrSemanticErrorZ() { CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(self); }
8738         CResult_Bolt11InvoiceParseOrSemanticErrorZ& operator=(CResult_Bolt11InvoiceParseOrSemanticErrorZ&& o) { CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceParseOrSemanticErrorZ)); return *this; }
8739         LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator &() { return &self; }
8740         LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator ->() { return &self; }
8741         const LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator &() const { return &self; }
8742         const LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator ->() const { return &self; }
8743 };
8744 class CResult_InitFeaturesDecodeErrorZ {
8745 private:
8746         LDKCResult_InitFeaturesDecodeErrorZ self;
8747 public:
8748         CResult_InitFeaturesDecodeErrorZ(const CResult_InitFeaturesDecodeErrorZ&) = delete;
8749         CResult_InitFeaturesDecodeErrorZ(CResult_InitFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); }
8750         CResult_InitFeaturesDecodeErrorZ(LDKCResult_InitFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); }
8751         operator LDKCResult_InitFeaturesDecodeErrorZ() && { LDKCResult_InitFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); return res; }
8752         ~CResult_InitFeaturesDecodeErrorZ() { CResult_InitFeaturesDecodeErrorZ_free(self); }
8753         CResult_InitFeaturesDecodeErrorZ& operator=(CResult_InitFeaturesDecodeErrorZ&& o) { CResult_InitFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); return *this; }
8754         LDKCResult_InitFeaturesDecodeErrorZ* operator &() { return &self; }
8755         LDKCResult_InitFeaturesDecodeErrorZ* operator ->() { return &self; }
8756         const LDKCResult_InitFeaturesDecodeErrorZ* operator &() const { return &self; }
8757         const LDKCResult_InitFeaturesDecodeErrorZ* operator ->() const { return &self; }
8758 };
8759 class CResult_PublicKeyNoneZ {
8760 private:
8761         LDKCResult_PublicKeyNoneZ self;
8762 public:
8763         CResult_PublicKeyNoneZ(const CResult_PublicKeyNoneZ&) = delete;
8764         CResult_PublicKeyNoneZ(CResult_PublicKeyNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PublicKeyNoneZ)); }
8765         CResult_PublicKeyNoneZ(LDKCResult_PublicKeyNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PublicKeyNoneZ)); }
8766         operator LDKCResult_PublicKeyNoneZ() && { LDKCResult_PublicKeyNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_PublicKeyNoneZ)); return res; }
8767         ~CResult_PublicKeyNoneZ() { CResult_PublicKeyNoneZ_free(self); }
8768         CResult_PublicKeyNoneZ& operator=(CResult_PublicKeyNoneZ&& o) { CResult_PublicKeyNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PublicKeyNoneZ)); return *this; }
8769         LDKCResult_PublicKeyNoneZ* operator &() { return &self; }
8770         LDKCResult_PublicKeyNoneZ* operator ->() { return &self; }
8771         const LDKCResult_PublicKeyNoneZ* operator &() const { return &self; }
8772         const LDKCResult_PublicKeyNoneZ* operator ->() const { return &self; }
8773 };
8774 class CResult_PingDecodeErrorZ {
8775 private:
8776         LDKCResult_PingDecodeErrorZ self;
8777 public:
8778         CResult_PingDecodeErrorZ(const CResult_PingDecodeErrorZ&) = delete;
8779         CResult_PingDecodeErrorZ(CResult_PingDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PingDecodeErrorZ)); }
8780         CResult_PingDecodeErrorZ(LDKCResult_PingDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PingDecodeErrorZ)); }
8781         operator LDKCResult_PingDecodeErrorZ() && { LDKCResult_PingDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PingDecodeErrorZ)); return res; }
8782         ~CResult_PingDecodeErrorZ() { CResult_PingDecodeErrorZ_free(self); }
8783         CResult_PingDecodeErrorZ& operator=(CResult_PingDecodeErrorZ&& o) { CResult_PingDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PingDecodeErrorZ)); return *this; }
8784         LDKCResult_PingDecodeErrorZ* operator &() { return &self; }
8785         LDKCResult_PingDecodeErrorZ* operator ->() { return &self; }
8786         const LDKCResult_PingDecodeErrorZ* operator &() const { return &self; }
8787         const LDKCResult_PingDecodeErrorZ* operator ->() const { return &self; }
8788 };
8789 class CResult_BlindedHopFeaturesDecodeErrorZ {
8790 private:
8791         LDKCResult_BlindedHopFeaturesDecodeErrorZ self;
8792 public:
8793         CResult_BlindedHopFeaturesDecodeErrorZ(const CResult_BlindedHopFeaturesDecodeErrorZ&) = delete;
8794         CResult_BlindedHopFeaturesDecodeErrorZ(CResult_BlindedHopFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedHopFeaturesDecodeErrorZ)); }
8795         CResult_BlindedHopFeaturesDecodeErrorZ(LDKCResult_BlindedHopFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ)); }
8796         operator LDKCResult_BlindedHopFeaturesDecodeErrorZ() && { LDKCResult_BlindedHopFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ)); return res; }
8797         ~CResult_BlindedHopFeaturesDecodeErrorZ() { CResult_BlindedHopFeaturesDecodeErrorZ_free(self); }
8798         CResult_BlindedHopFeaturesDecodeErrorZ& operator=(CResult_BlindedHopFeaturesDecodeErrorZ&& o) { CResult_BlindedHopFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedHopFeaturesDecodeErrorZ)); return *this; }
8799         LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator &() { return &self; }
8800         LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator ->() { return &self; }
8801         const LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator &() const { return &self; }
8802         const LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator ->() const { return &self; }
8803 };
8804 class CVec_TransactionOutputsZ {
8805 private:
8806         LDKCVec_TransactionOutputsZ self;
8807 public:
8808         CVec_TransactionOutputsZ(const CVec_TransactionOutputsZ&) = delete;
8809         CVec_TransactionOutputsZ(CVec_TransactionOutputsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionOutputsZ)); }
8810         CVec_TransactionOutputsZ(LDKCVec_TransactionOutputsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionOutputsZ)); }
8811         operator LDKCVec_TransactionOutputsZ() && { LDKCVec_TransactionOutputsZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionOutputsZ)); return res; }
8812         ~CVec_TransactionOutputsZ() { CVec_TransactionOutputsZ_free(self); }
8813         CVec_TransactionOutputsZ& operator=(CVec_TransactionOutputsZ&& o) { CVec_TransactionOutputsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionOutputsZ)); return *this; }
8814         LDKCVec_TransactionOutputsZ* operator &() { return &self; }
8815         LDKCVec_TransactionOutputsZ* operator ->() { return &self; }
8816         const LDKCVec_TransactionOutputsZ* operator &() const { return &self; }
8817         const LDKCVec_TransactionOutputsZ* operator ->() const { return &self; }
8818 };
8819 class COption_HTLCClaimZ {
8820 private:
8821         LDKCOption_HTLCClaimZ self;
8822 public:
8823         COption_HTLCClaimZ(const COption_HTLCClaimZ&) = delete;
8824         COption_HTLCClaimZ(COption_HTLCClaimZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_HTLCClaimZ)); }
8825         COption_HTLCClaimZ(LDKCOption_HTLCClaimZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_HTLCClaimZ)); }
8826         operator LDKCOption_HTLCClaimZ() && { LDKCOption_HTLCClaimZ res = self; memset(&self, 0, sizeof(LDKCOption_HTLCClaimZ)); return res; }
8827         ~COption_HTLCClaimZ() { COption_HTLCClaimZ_free(self); }
8828         COption_HTLCClaimZ& operator=(COption_HTLCClaimZ&& o) { COption_HTLCClaimZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_HTLCClaimZ)); return *this; }
8829         LDKCOption_HTLCClaimZ* operator &() { return &self; }
8830         LDKCOption_HTLCClaimZ* operator ->() { return &self; }
8831         const LDKCOption_HTLCClaimZ* operator &() const { return &self; }
8832         const LDKCOption_HTLCClaimZ* operator ->() const { return &self; }
8833 };
8834 class COption_boolZ {
8835 private:
8836         LDKCOption_boolZ self;
8837 public:
8838         COption_boolZ(const COption_boolZ&) = delete;
8839         COption_boolZ(COption_boolZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_boolZ)); }
8840         COption_boolZ(LDKCOption_boolZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_boolZ)); }
8841         operator LDKCOption_boolZ() && { LDKCOption_boolZ res = self; memset(&self, 0, sizeof(LDKCOption_boolZ)); return res; }
8842         ~COption_boolZ() { COption_boolZ_free(self); }
8843         COption_boolZ& operator=(COption_boolZ&& o) { COption_boolZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_boolZ)); return *this; }
8844         LDKCOption_boolZ* operator &() { return &self; }
8845         LDKCOption_boolZ* operator ->() { return &self; }
8846         const LDKCOption_boolZ* operator &() const { return &self; }
8847         const LDKCOption_boolZ* operator ->() const { return &self; }
8848 };
8849 class CVec_CVec_u8ZZ {
8850 private:
8851         LDKCVec_CVec_u8ZZ self;
8852 public:
8853         CVec_CVec_u8ZZ(const CVec_CVec_u8ZZ&) = delete;
8854         CVec_CVec_u8ZZ(CVec_CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CVec_u8ZZ)); }
8855         CVec_CVec_u8ZZ(LDKCVec_CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CVec_u8ZZ)); }
8856         operator LDKCVec_CVec_u8ZZ() && { LDKCVec_CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKCVec_CVec_u8ZZ)); return res; }
8857         ~CVec_CVec_u8ZZ() { CVec_CVec_u8ZZ_free(self); }
8858         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; }
8859         LDKCVec_CVec_u8ZZ* operator &() { return &self; }
8860         LDKCVec_CVec_u8ZZ* operator ->() { return &self; }
8861         const LDKCVec_CVec_u8ZZ* operator &() const { return &self; }
8862         const LDKCVec_CVec_u8ZZ* operator ->() const { return &self; }
8863 };
8864 class CResult_ProbabilisticScorerDecodeErrorZ {
8865 private:
8866         LDKCResult_ProbabilisticScorerDecodeErrorZ self;
8867 public:
8868         CResult_ProbabilisticScorerDecodeErrorZ(const CResult_ProbabilisticScorerDecodeErrorZ&) = delete;
8869         CResult_ProbabilisticScorerDecodeErrorZ(CResult_ProbabilisticScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ProbabilisticScorerDecodeErrorZ)); }
8870         CResult_ProbabilisticScorerDecodeErrorZ(LDKCResult_ProbabilisticScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ)); }
8871         operator LDKCResult_ProbabilisticScorerDecodeErrorZ() && { LDKCResult_ProbabilisticScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ)); return res; }
8872         ~CResult_ProbabilisticScorerDecodeErrorZ() { CResult_ProbabilisticScorerDecodeErrorZ_free(self); }
8873         CResult_ProbabilisticScorerDecodeErrorZ& operator=(CResult_ProbabilisticScorerDecodeErrorZ&& o) { CResult_ProbabilisticScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ProbabilisticScorerDecodeErrorZ)); return *this; }
8874         LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() { return &self; }
8875         LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() { return &self; }
8876         const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() const { return &self; }
8877         const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() const { return &self; }
8878 };
8879 class CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ {
8880 private:
8881         LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ self;
8882 public:
8883         CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ(const CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&) = delete;
8884         CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ(CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); }
8885         CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ(LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); }
8886         operator LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); return res; }
8887         ~CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ() { CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(self); }
8888         CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ& operator=(CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&& o) { CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); return *this; }
8889         LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator &() { return &self; }
8890         LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator ->() { return &self; }
8891         const LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator &() const { return &self; }
8892         const LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator ->() const { return &self; }
8893 };
8894 class COption_StrZ {
8895 private:
8896         LDKCOption_StrZ self;
8897 public:
8898         COption_StrZ(const COption_StrZ&) = delete;
8899         COption_StrZ(COption_StrZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_StrZ)); }
8900         COption_StrZ(LDKCOption_StrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_StrZ)); }
8901         operator LDKCOption_StrZ() && { LDKCOption_StrZ res = self; memset(&self, 0, sizeof(LDKCOption_StrZ)); return res; }
8902         ~COption_StrZ() { COption_StrZ_free(self); }
8903         COption_StrZ& operator=(COption_StrZ&& o) { COption_StrZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_StrZ)); return *this; }
8904         LDKCOption_StrZ* operator &() { return &self; }
8905         LDKCOption_StrZ* operator ->() { return &self; }
8906         const LDKCOption_StrZ* operator &() const { return &self; }
8907         const LDKCOption_StrZ* operator ->() const { return &self; }
8908 };
8909 class CResult_ShutdownScriptDecodeErrorZ {
8910 private:
8911         LDKCResult_ShutdownScriptDecodeErrorZ self;
8912 public:
8913         CResult_ShutdownScriptDecodeErrorZ(const CResult_ShutdownScriptDecodeErrorZ&) = delete;
8914         CResult_ShutdownScriptDecodeErrorZ(CResult_ShutdownScriptDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); }
8915         CResult_ShutdownScriptDecodeErrorZ(LDKCResult_ShutdownScriptDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); }
8916         operator LDKCResult_ShutdownScriptDecodeErrorZ() && { LDKCResult_ShutdownScriptDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); return res; }
8917         ~CResult_ShutdownScriptDecodeErrorZ() { CResult_ShutdownScriptDecodeErrorZ_free(self); }
8918         CResult_ShutdownScriptDecodeErrorZ& operator=(CResult_ShutdownScriptDecodeErrorZ&& o) { CResult_ShutdownScriptDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); return *this; }
8919         LDKCResult_ShutdownScriptDecodeErrorZ* operator &() { return &self; }
8920         LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() { return &self; }
8921         const LDKCResult_ShutdownScriptDecodeErrorZ* operator &() const { return &self; }
8922         const LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() const { return &self; }
8923 };
8924 class C2Tuple_usizeTransactionZ {
8925 private:
8926         LDKC2Tuple_usizeTransactionZ self;
8927 public:
8928         C2Tuple_usizeTransactionZ(const C2Tuple_usizeTransactionZ&) = delete;
8929         C2Tuple_usizeTransactionZ(C2Tuple_usizeTransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_usizeTransactionZ)); }
8930         C2Tuple_usizeTransactionZ(LDKC2Tuple_usizeTransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_usizeTransactionZ)); }
8931         operator LDKC2Tuple_usizeTransactionZ() && { LDKC2Tuple_usizeTransactionZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_usizeTransactionZ)); return res; }
8932         ~C2Tuple_usizeTransactionZ() { C2Tuple_usizeTransactionZ_free(self); }
8933         C2Tuple_usizeTransactionZ& operator=(C2Tuple_usizeTransactionZ&& o) { C2Tuple_usizeTransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_usizeTransactionZ)); return *this; }
8934         LDKC2Tuple_usizeTransactionZ* operator &() { return &self; }
8935         LDKC2Tuple_usizeTransactionZ* operator ->() { return &self; }
8936         const LDKC2Tuple_usizeTransactionZ* operator &() const { return &self; }
8937         const LDKC2Tuple_usizeTransactionZ* operator ->() const { return &self; }
8938 };
8939 class CResult_NodeAnnouncementDecodeErrorZ {
8940 private:
8941         LDKCResult_NodeAnnouncementDecodeErrorZ self;
8942 public:
8943         CResult_NodeAnnouncementDecodeErrorZ(const CResult_NodeAnnouncementDecodeErrorZ&) = delete;
8944         CResult_NodeAnnouncementDecodeErrorZ(CResult_NodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); }
8945         CResult_NodeAnnouncementDecodeErrorZ(LDKCResult_NodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); }
8946         operator LDKCResult_NodeAnnouncementDecodeErrorZ() && { LDKCResult_NodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); return res; }
8947         ~CResult_NodeAnnouncementDecodeErrorZ() { CResult_NodeAnnouncementDecodeErrorZ_free(self); }
8948         CResult_NodeAnnouncementDecodeErrorZ& operator=(CResult_NodeAnnouncementDecodeErrorZ&& o) { CResult_NodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); return *this; }
8949         LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() { return &self; }
8950         LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
8951         const LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
8952         const LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
8953 };
8954 class CVec_FutureZ {
8955 private:
8956         LDKCVec_FutureZ self;
8957 public:
8958         CVec_FutureZ(const CVec_FutureZ&) = delete;
8959         CVec_FutureZ(CVec_FutureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_FutureZ)); }
8960         CVec_FutureZ(LDKCVec_FutureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_FutureZ)); }
8961         operator LDKCVec_FutureZ() && { LDKCVec_FutureZ res = self; memset(&self, 0, sizeof(LDKCVec_FutureZ)); return res; }
8962         ~CVec_FutureZ() { CVec_FutureZ_free(self); }
8963         CVec_FutureZ& operator=(CVec_FutureZ&& o) { CVec_FutureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_FutureZ)); return *this; }
8964         LDKCVec_FutureZ* operator &() { return &self; }
8965         LDKCVec_FutureZ* operator ->() { return &self; }
8966         const LDKCVec_FutureZ* operator &() const { return &self; }
8967         const LDKCVec_FutureZ* operator ->() const { return &self; }
8968 };
8969 class CVec_ChannelMonitorZ {
8970 private:
8971         LDKCVec_ChannelMonitorZ self;
8972 public:
8973         CVec_ChannelMonitorZ(const CVec_ChannelMonitorZ&) = delete;
8974         CVec_ChannelMonitorZ(CVec_ChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); }
8975         CVec_ChannelMonitorZ(LDKCVec_ChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelMonitorZ)); }
8976         operator LDKCVec_ChannelMonitorZ() && { LDKCVec_ChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelMonitorZ)); return res; }
8977         ~CVec_ChannelMonitorZ() { CVec_ChannelMonitorZ_free(self); }
8978         CVec_ChannelMonitorZ& operator=(CVec_ChannelMonitorZ&& o) { CVec_ChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); return *this; }
8979         LDKCVec_ChannelMonitorZ* operator &() { return &self; }
8980         LDKCVec_ChannelMonitorZ* operator ->() { return &self; }
8981         const LDKCVec_ChannelMonitorZ* operator &() const { return &self; }
8982         const LDKCVec_ChannelMonitorZ* operator ->() const { return &self; }
8983 };
8984 class CResult_AcceptChannelV2DecodeErrorZ {
8985 private:
8986         LDKCResult_AcceptChannelV2DecodeErrorZ self;
8987 public:
8988         CResult_AcceptChannelV2DecodeErrorZ(const CResult_AcceptChannelV2DecodeErrorZ&) = delete;
8989         CResult_AcceptChannelV2DecodeErrorZ(CResult_AcceptChannelV2DecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AcceptChannelV2DecodeErrorZ)); }
8990         CResult_AcceptChannelV2DecodeErrorZ(LDKCResult_AcceptChannelV2DecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AcceptChannelV2DecodeErrorZ)); }
8991         operator LDKCResult_AcceptChannelV2DecodeErrorZ() && { LDKCResult_AcceptChannelV2DecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AcceptChannelV2DecodeErrorZ)); return res; }
8992         ~CResult_AcceptChannelV2DecodeErrorZ() { CResult_AcceptChannelV2DecodeErrorZ_free(self); }
8993         CResult_AcceptChannelV2DecodeErrorZ& operator=(CResult_AcceptChannelV2DecodeErrorZ&& o) { CResult_AcceptChannelV2DecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AcceptChannelV2DecodeErrorZ)); return *this; }
8994         LDKCResult_AcceptChannelV2DecodeErrorZ* operator &() { return &self; }
8995         LDKCResult_AcceptChannelV2DecodeErrorZ* operator ->() { return &self; }
8996         const LDKCResult_AcceptChannelV2DecodeErrorZ* operator &() const { return &self; }
8997         const LDKCResult_AcceptChannelV2DecodeErrorZ* operator ->() const { return &self; }
8998 };
8999 class CResult_TxCreationKeysDecodeErrorZ {
9000 private:
9001         LDKCResult_TxCreationKeysDecodeErrorZ self;
9002 public:
9003         CResult_TxCreationKeysDecodeErrorZ(const CResult_TxCreationKeysDecodeErrorZ&) = delete;
9004         CResult_TxCreationKeysDecodeErrorZ(CResult_TxCreationKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); }
9005         CResult_TxCreationKeysDecodeErrorZ(LDKCResult_TxCreationKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); }
9006         operator LDKCResult_TxCreationKeysDecodeErrorZ() && { LDKCResult_TxCreationKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); return res; }
9007         ~CResult_TxCreationKeysDecodeErrorZ() { CResult_TxCreationKeysDecodeErrorZ_free(self); }
9008         CResult_TxCreationKeysDecodeErrorZ& operator=(CResult_TxCreationKeysDecodeErrorZ&& o) { CResult_TxCreationKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); return *this; }
9009         LDKCResult_TxCreationKeysDecodeErrorZ* operator &() { return &self; }
9010         LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() { return &self; }
9011         const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
9012         const LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() const { return &self; }
9013 };
9014 class CResult_RouteHopDecodeErrorZ {
9015 private:
9016         LDKCResult_RouteHopDecodeErrorZ self;
9017 public:
9018         CResult_RouteHopDecodeErrorZ(const CResult_RouteHopDecodeErrorZ&) = delete;
9019         CResult_RouteHopDecodeErrorZ(CResult_RouteHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHopDecodeErrorZ)); }
9020         CResult_RouteHopDecodeErrorZ(LDKCResult_RouteHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHopDecodeErrorZ)); }
9021         operator LDKCResult_RouteHopDecodeErrorZ() && { LDKCResult_RouteHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHopDecodeErrorZ)); return res; }
9022         ~CResult_RouteHopDecodeErrorZ() { CResult_RouteHopDecodeErrorZ_free(self); }
9023         CResult_RouteHopDecodeErrorZ& operator=(CResult_RouteHopDecodeErrorZ&& o) { CResult_RouteHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHopDecodeErrorZ)); return *this; }
9024         LDKCResult_RouteHopDecodeErrorZ* operator &() { return &self; }
9025         LDKCResult_RouteHopDecodeErrorZ* operator ->() { return &self; }
9026         const LDKCResult_RouteHopDecodeErrorZ* operator &() const { return &self; }
9027         const LDKCResult_RouteHopDecodeErrorZ* operator ->() const { return &self; }
9028 };
9029 class CVec_HTLCOutputInCommitmentZ {
9030 private:
9031         LDKCVec_HTLCOutputInCommitmentZ self;
9032 public:
9033         CVec_HTLCOutputInCommitmentZ(const CVec_HTLCOutputInCommitmentZ&) = delete;
9034         CVec_HTLCOutputInCommitmentZ(CVec_HTLCOutputInCommitmentZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_HTLCOutputInCommitmentZ)); }
9035         CVec_HTLCOutputInCommitmentZ(LDKCVec_HTLCOutputInCommitmentZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_HTLCOutputInCommitmentZ)); }
9036         operator LDKCVec_HTLCOutputInCommitmentZ() && { LDKCVec_HTLCOutputInCommitmentZ res = self; memset(&self, 0, sizeof(LDKCVec_HTLCOutputInCommitmentZ)); return res; }
9037         ~CVec_HTLCOutputInCommitmentZ() { CVec_HTLCOutputInCommitmentZ_free(self); }
9038         CVec_HTLCOutputInCommitmentZ& operator=(CVec_HTLCOutputInCommitmentZ&& o) { CVec_HTLCOutputInCommitmentZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_HTLCOutputInCommitmentZ)); return *this; }
9039         LDKCVec_HTLCOutputInCommitmentZ* operator &() { return &self; }
9040         LDKCVec_HTLCOutputInCommitmentZ* operator ->() { return &self; }
9041         const LDKCVec_HTLCOutputInCommitmentZ* operator &() const { return &self; }
9042         const LDKCVec_HTLCOutputInCommitmentZ* operator ->() const { return &self; }
9043 };
9044 class CResult_CoinSelectionNoneZ {
9045 private:
9046         LDKCResult_CoinSelectionNoneZ self;
9047 public:
9048         CResult_CoinSelectionNoneZ(const CResult_CoinSelectionNoneZ&) = delete;
9049         CResult_CoinSelectionNoneZ(CResult_CoinSelectionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CoinSelectionNoneZ)); }
9050         CResult_CoinSelectionNoneZ(LDKCResult_CoinSelectionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CoinSelectionNoneZ)); }
9051         operator LDKCResult_CoinSelectionNoneZ() && { LDKCResult_CoinSelectionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CoinSelectionNoneZ)); return res; }
9052         ~CResult_CoinSelectionNoneZ() { CResult_CoinSelectionNoneZ_free(self); }
9053         CResult_CoinSelectionNoneZ& operator=(CResult_CoinSelectionNoneZ&& o) { CResult_CoinSelectionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CoinSelectionNoneZ)); return *this; }
9054         LDKCResult_CoinSelectionNoneZ* operator &() { return &self; }
9055         LDKCResult_CoinSelectionNoneZ* operator ->() { return &self; }
9056         const LDKCResult_CoinSelectionNoneZ* operator &() const { return &self; }
9057         const LDKCResult_CoinSelectionNoneZ* operator ->() const { return &self; }
9058 };
9059 class C2Tuple_ThirtyTwoBytesPublicKeyZ {
9060 private:
9061         LDKC2Tuple_ThirtyTwoBytesPublicKeyZ self;
9062 public:
9063         C2Tuple_ThirtyTwoBytesPublicKeyZ(const C2Tuple_ThirtyTwoBytesPublicKeyZ&) = delete;
9064         C2Tuple_ThirtyTwoBytesPublicKeyZ(C2Tuple_ThirtyTwoBytesPublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesPublicKeyZ)); }
9065         C2Tuple_ThirtyTwoBytesPublicKeyZ(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ)); }
9066         operator LDKC2Tuple_ThirtyTwoBytesPublicKeyZ() && { LDKC2Tuple_ThirtyTwoBytesPublicKeyZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ)); return res; }
9067         ~C2Tuple_ThirtyTwoBytesPublicKeyZ() { C2Tuple_ThirtyTwoBytesPublicKeyZ_free(self); }
9068         C2Tuple_ThirtyTwoBytesPublicKeyZ& operator=(C2Tuple_ThirtyTwoBytesPublicKeyZ&& o) { C2Tuple_ThirtyTwoBytesPublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesPublicKeyZ)); return *this; }
9069         LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator &() { return &self; }
9070         LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator ->() { return &self; }
9071         const LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator &() const { return &self; }
9072         const LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator ->() const { return &self; }
9073 };
9074 class CResult_SiPrefixBolt11ParseErrorZ {
9075 private:
9076         LDKCResult_SiPrefixBolt11ParseErrorZ self;
9077 public:
9078         CResult_SiPrefixBolt11ParseErrorZ(const CResult_SiPrefixBolt11ParseErrorZ&) = delete;
9079         CResult_SiPrefixBolt11ParseErrorZ(CResult_SiPrefixBolt11ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SiPrefixBolt11ParseErrorZ)); }
9080         CResult_SiPrefixBolt11ParseErrorZ(LDKCResult_SiPrefixBolt11ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ)); }
9081         operator LDKCResult_SiPrefixBolt11ParseErrorZ() && { LDKCResult_SiPrefixBolt11ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ)); return res; }
9082         ~CResult_SiPrefixBolt11ParseErrorZ() { CResult_SiPrefixBolt11ParseErrorZ_free(self); }
9083         CResult_SiPrefixBolt11ParseErrorZ& operator=(CResult_SiPrefixBolt11ParseErrorZ&& o) { CResult_SiPrefixBolt11ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SiPrefixBolt11ParseErrorZ)); return *this; }
9084         LDKCResult_SiPrefixBolt11ParseErrorZ* operator &() { return &self; }
9085         LDKCResult_SiPrefixBolt11ParseErrorZ* operator ->() { return &self; }
9086         const LDKCResult_SiPrefixBolt11ParseErrorZ* operator &() const { return &self; }
9087         const LDKCResult_SiPrefixBolt11ParseErrorZ* operator ->() const { return &self; }
9088 };
9089 class CResult_BlindedPathDecodeErrorZ {
9090 private:
9091         LDKCResult_BlindedPathDecodeErrorZ self;
9092 public:
9093         CResult_BlindedPathDecodeErrorZ(const CResult_BlindedPathDecodeErrorZ&) = delete;
9094         CResult_BlindedPathDecodeErrorZ(CResult_BlindedPathDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPathDecodeErrorZ)); }
9095         CResult_BlindedPathDecodeErrorZ(LDKCResult_BlindedPathDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPathDecodeErrorZ)); }
9096         operator LDKCResult_BlindedPathDecodeErrorZ() && { LDKCResult_BlindedPathDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPathDecodeErrorZ)); return res; }
9097         ~CResult_BlindedPathDecodeErrorZ() { CResult_BlindedPathDecodeErrorZ_free(self); }
9098         CResult_BlindedPathDecodeErrorZ& operator=(CResult_BlindedPathDecodeErrorZ&& o) { CResult_BlindedPathDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPathDecodeErrorZ)); return *this; }
9099         LDKCResult_BlindedPathDecodeErrorZ* operator &() { return &self; }
9100         LDKCResult_BlindedPathDecodeErrorZ* operator ->() { return &self; }
9101         const LDKCResult_BlindedPathDecodeErrorZ* operator &() const { return &self; }
9102         const LDKCResult_BlindedPathDecodeErrorZ* operator ->() const { return &self; }
9103 };
9104 class CVec_BalanceZ {
9105 private:
9106         LDKCVec_BalanceZ self;
9107 public:
9108         CVec_BalanceZ(const CVec_BalanceZ&) = delete;
9109         CVec_BalanceZ(CVec_BalanceZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BalanceZ)); }
9110         CVec_BalanceZ(LDKCVec_BalanceZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BalanceZ)); }
9111         operator LDKCVec_BalanceZ() && { LDKCVec_BalanceZ res = self; memset(&self, 0, sizeof(LDKCVec_BalanceZ)); return res; }
9112         ~CVec_BalanceZ() { CVec_BalanceZ_free(self); }
9113         CVec_BalanceZ& operator=(CVec_BalanceZ&& o) { CVec_BalanceZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BalanceZ)); return *this; }
9114         LDKCVec_BalanceZ* operator &() { return &self; }
9115         LDKCVec_BalanceZ* operator ->() { return &self; }
9116         const LDKCVec_BalanceZ* operator &() const { return &self; }
9117         const LDKCVec_BalanceZ* operator ->() const { return &self; }
9118 };
9119 class CResult_NoneIOErrorZ {
9120 private:
9121         LDKCResult_NoneIOErrorZ self;
9122 public:
9123         CResult_NoneIOErrorZ(const CResult_NoneIOErrorZ&) = delete;
9124         CResult_NoneIOErrorZ(CResult_NoneIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneIOErrorZ)); }
9125         CResult_NoneIOErrorZ(LDKCResult_NoneIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneIOErrorZ)); }
9126         operator LDKCResult_NoneIOErrorZ() && { LDKCResult_NoneIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneIOErrorZ)); return res; }
9127         ~CResult_NoneIOErrorZ() { CResult_NoneIOErrorZ_free(self); }
9128         CResult_NoneIOErrorZ& operator=(CResult_NoneIOErrorZ&& o) { CResult_NoneIOErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneIOErrorZ)); return *this; }
9129         LDKCResult_NoneIOErrorZ* operator &() { return &self; }
9130         LDKCResult_NoneIOErrorZ* operator ->() { return &self; }
9131         const LDKCResult_NoneIOErrorZ* operator &() const { return &self; }
9132         const LDKCResult_NoneIOErrorZ* operator ->() const { return &self; }
9133 };
9134 class CResult_MaxDustHTLCExposureDecodeErrorZ {
9135 private:
9136         LDKCResult_MaxDustHTLCExposureDecodeErrorZ self;
9137 public:
9138         CResult_MaxDustHTLCExposureDecodeErrorZ(const CResult_MaxDustHTLCExposureDecodeErrorZ&) = delete;
9139         CResult_MaxDustHTLCExposureDecodeErrorZ(CResult_MaxDustHTLCExposureDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_MaxDustHTLCExposureDecodeErrorZ)); }
9140         CResult_MaxDustHTLCExposureDecodeErrorZ(LDKCResult_MaxDustHTLCExposureDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_MaxDustHTLCExposureDecodeErrorZ)); }
9141         operator LDKCResult_MaxDustHTLCExposureDecodeErrorZ() && { LDKCResult_MaxDustHTLCExposureDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_MaxDustHTLCExposureDecodeErrorZ)); return res; }
9142         ~CResult_MaxDustHTLCExposureDecodeErrorZ() { CResult_MaxDustHTLCExposureDecodeErrorZ_free(self); }
9143         CResult_MaxDustHTLCExposureDecodeErrorZ& operator=(CResult_MaxDustHTLCExposureDecodeErrorZ&& o) { CResult_MaxDustHTLCExposureDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_MaxDustHTLCExposureDecodeErrorZ)); return *this; }
9144         LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator &() { return &self; }
9145         LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator ->() { return &self; }
9146         const LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator &() const { return &self; }
9147         const LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator ->() const { return &self; }
9148 };
9149 class CVec_CommitmentTransactionZ {
9150 private:
9151         LDKCVec_CommitmentTransactionZ self;
9152 public:
9153         CVec_CommitmentTransactionZ(const CVec_CommitmentTransactionZ&) = delete;
9154         CVec_CommitmentTransactionZ(CVec_CommitmentTransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CommitmentTransactionZ)); }
9155         CVec_CommitmentTransactionZ(LDKCVec_CommitmentTransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CommitmentTransactionZ)); }
9156         operator LDKCVec_CommitmentTransactionZ() && { LDKCVec_CommitmentTransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_CommitmentTransactionZ)); return res; }
9157         ~CVec_CommitmentTransactionZ() { CVec_CommitmentTransactionZ_free(self); }
9158         CVec_CommitmentTransactionZ& operator=(CVec_CommitmentTransactionZ&& o) { CVec_CommitmentTransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CommitmentTransactionZ)); return *this; }
9159         LDKCVec_CommitmentTransactionZ* operator &() { return &self; }
9160         LDKCVec_CommitmentTransactionZ* operator ->() { return &self; }
9161         const LDKCVec_CommitmentTransactionZ* operator &() const { return &self; }
9162         const LDKCVec_CommitmentTransactionZ* operator ->() const { return &self; }
9163 };
9164 class CResult_FundingSignedDecodeErrorZ {
9165 private:
9166         LDKCResult_FundingSignedDecodeErrorZ self;
9167 public:
9168         CResult_FundingSignedDecodeErrorZ(const CResult_FundingSignedDecodeErrorZ&) = delete;
9169         CResult_FundingSignedDecodeErrorZ(CResult_FundingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); }
9170         CResult_FundingSignedDecodeErrorZ(LDKCResult_FundingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); }
9171         operator LDKCResult_FundingSignedDecodeErrorZ() && { LDKCResult_FundingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); return res; }
9172         ~CResult_FundingSignedDecodeErrorZ() { CResult_FundingSignedDecodeErrorZ_free(self); }
9173         CResult_FundingSignedDecodeErrorZ& operator=(CResult_FundingSignedDecodeErrorZ&& o) { CResult_FundingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); return *this; }
9174         LDKCResult_FundingSignedDecodeErrorZ* operator &() { return &self; }
9175         LDKCResult_FundingSignedDecodeErrorZ* operator ->() { return &self; }
9176         const LDKCResult_FundingSignedDecodeErrorZ* operator &() const { return &self; }
9177         const LDKCResult_FundingSignedDecodeErrorZ* operator ->() const { return &self; }
9178 };
9179 class CResult_RecoverableSignatureNoneZ {
9180 private:
9181         LDKCResult_RecoverableSignatureNoneZ self;
9182 public:
9183         CResult_RecoverableSignatureNoneZ(const CResult_RecoverableSignatureNoneZ&) = delete;
9184         CResult_RecoverableSignatureNoneZ(CResult_RecoverableSignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecoverableSignatureNoneZ)); }
9185         CResult_RecoverableSignatureNoneZ(LDKCResult_RecoverableSignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecoverableSignatureNoneZ)); }
9186         operator LDKCResult_RecoverableSignatureNoneZ() && { LDKCResult_RecoverableSignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_RecoverableSignatureNoneZ)); return res; }
9187         ~CResult_RecoverableSignatureNoneZ() { CResult_RecoverableSignatureNoneZ_free(self); }
9188         CResult_RecoverableSignatureNoneZ& operator=(CResult_RecoverableSignatureNoneZ&& o) { CResult_RecoverableSignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecoverableSignatureNoneZ)); return *this; }
9189         LDKCResult_RecoverableSignatureNoneZ* operator &() { return &self; }
9190         LDKCResult_RecoverableSignatureNoneZ* operator ->() { return &self; }
9191         const LDKCResult_RecoverableSignatureNoneZ* operator &() const { return &self; }
9192         const LDKCResult_RecoverableSignatureNoneZ* operator ->() const { return &self; }
9193 };
9194 class CResult_SocketAddressDecodeErrorZ {
9195 private:
9196         LDKCResult_SocketAddressDecodeErrorZ self;
9197 public:
9198         CResult_SocketAddressDecodeErrorZ(const CResult_SocketAddressDecodeErrorZ&) = delete;
9199         CResult_SocketAddressDecodeErrorZ(CResult_SocketAddressDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SocketAddressDecodeErrorZ)); }
9200         CResult_SocketAddressDecodeErrorZ(LDKCResult_SocketAddressDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SocketAddressDecodeErrorZ)); }
9201         operator LDKCResult_SocketAddressDecodeErrorZ() && { LDKCResult_SocketAddressDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SocketAddressDecodeErrorZ)); return res; }
9202         ~CResult_SocketAddressDecodeErrorZ() { CResult_SocketAddressDecodeErrorZ_free(self); }
9203         CResult_SocketAddressDecodeErrorZ& operator=(CResult_SocketAddressDecodeErrorZ&& o) { CResult_SocketAddressDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SocketAddressDecodeErrorZ)); return *this; }
9204         LDKCResult_SocketAddressDecodeErrorZ* operator &() { return &self; }
9205         LDKCResult_SocketAddressDecodeErrorZ* operator ->() { return &self; }
9206         const LDKCResult_SocketAddressDecodeErrorZ* operator &() const { return &self; }
9207         const LDKCResult_SocketAddressDecodeErrorZ* operator ->() const { return &self; }
9208 };
9209 class C2Tuple_Z {
9210 private:
9211         LDKC2Tuple_Z self;
9212 public:
9213         C2Tuple_Z(const C2Tuple_Z&) = delete;
9214         C2Tuple_Z(C2Tuple_Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_Z)); }
9215         C2Tuple_Z(LDKC2Tuple_Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_Z)); }
9216         operator LDKC2Tuple_Z() && { LDKC2Tuple_Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_Z)); return res; }
9217         ~C2Tuple_Z() { C2Tuple_Z_free(self); }
9218         C2Tuple_Z& operator=(C2Tuple_Z&& o) { C2Tuple_Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_Z)); return *this; }
9219         LDKC2Tuple_Z* operator &() { return &self; }
9220         LDKC2Tuple_Z* operator ->() { return &self; }
9221         const LDKC2Tuple_Z* operator &() const { return &self; }
9222         const LDKC2Tuple_Z* operator ->() const { return &self; }
9223 };
9224 class C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ {
9225 private:
9226         LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ self;
9227 public:
9228         C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(const C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&) = delete;
9229         C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); }
9230         C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); }
9231         operator LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ() && { LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); return res; }
9232         ~C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ() { C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(self); }
9233         C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ& operator=(C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&& o) { C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); return *this; }
9234         LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator &() { return &self; }
9235         LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator ->() { return &self; }
9236         const LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator &() const { return &self; }
9237         const LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator ->() const { return &self; }
9238 };
9239 class CVec_PathZ {
9240 private:
9241         LDKCVec_PathZ self;
9242 public:
9243         CVec_PathZ(const CVec_PathZ&) = delete;
9244         CVec_PathZ(CVec_PathZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PathZ)); }
9245         CVec_PathZ(LDKCVec_PathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PathZ)); }
9246         operator LDKCVec_PathZ() && { LDKCVec_PathZ res = self; memset(&self, 0, sizeof(LDKCVec_PathZ)); return res; }
9247         ~CVec_PathZ() { CVec_PathZ_free(self); }
9248         CVec_PathZ& operator=(CVec_PathZ&& o) { CVec_PathZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PathZ)); return *this; }
9249         LDKCVec_PathZ* operator &() { return &self; }
9250         LDKCVec_PathZ* operator ->() { return &self; }
9251         const LDKCVec_PathZ* operator &() const { return &self; }
9252         const LDKCVec_PathZ* operator ->() const { return &self; }
9253 };
9254 class CResult_NetworkGraphDecodeErrorZ {
9255 private:
9256         LDKCResult_NetworkGraphDecodeErrorZ self;
9257 public:
9258         CResult_NetworkGraphDecodeErrorZ(const CResult_NetworkGraphDecodeErrorZ&) = delete;
9259         CResult_NetworkGraphDecodeErrorZ(CResult_NetworkGraphDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NetworkGraphDecodeErrorZ)); }
9260         CResult_NetworkGraphDecodeErrorZ(LDKCResult_NetworkGraphDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NetworkGraphDecodeErrorZ)); }
9261         operator LDKCResult_NetworkGraphDecodeErrorZ() && { LDKCResult_NetworkGraphDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NetworkGraphDecodeErrorZ)); return res; }
9262         ~CResult_NetworkGraphDecodeErrorZ() { CResult_NetworkGraphDecodeErrorZ_free(self); }
9263         CResult_NetworkGraphDecodeErrorZ& operator=(CResult_NetworkGraphDecodeErrorZ&& o) { CResult_NetworkGraphDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NetworkGraphDecodeErrorZ)); return *this; }
9264         LDKCResult_NetworkGraphDecodeErrorZ* operator &() { return &self; }
9265         LDKCResult_NetworkGraphDecodeErrorZ* operator ->() { return &self; }
9266         const LDKCResult_NetworkGraphDecodeErrorZ* operator &() const { return &self; }
9267         const LDKCResult_NetworkGraphDecodeErrorZ* operator ->() const { return &self; }
9268 };
9269 class CResult_NodeInfoDecodeErrorZ {
9270 private:
9271         LDKCResult_NodeInfoDecodeErrorZ self;
9272 public:
9273         CResult_NodeInfoDecodeErrorZ(const CResult_NodeInfoDecodeErrorZ&) = delete;
9274         CResult_NodeInfoDecodeErrorZ(CResult_NodeInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); }
9275         CResult_NodeInfoDecodeErrorZ(LDKCResult_NodeInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); }
9276         operator LDKCResult_NodeInfoDecodeErrorZ() && { LDKCResult_NodeInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); return res; }
9277         ~CResult_NodeInfoDecodeErrorZ() { CResult_NodeInfoDecodeErrorZ_free(self); }
9278         CResult_NodeInfoDecodeErrorZ& operator=(CResult_NodeInfoDecodeErrorZ&& o) { CResult_NodeInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); return *this; }
9279         LDKCResult_NodeInfoDecodeErrorZ* operator &() { return &self; }
9280         LDKCResult_NodeInfoDecodeErrorZ* operator ->() { return &self; }
9281         const LDKCResult_NodeInfoDecodeErrorZ* operator &() const { return &self; }
9282         const LDKCResult_NodeInfoDecodeErrorZ* operator ->() const { return &self; }
9283 };
9284 class CVec_NodeIdZ {
9285 private:
9286         LDKCVec_NodeIdZ self;
9287 public:
9288         CVec_NodeIdZ(const CVec_NodeIdZ&) = delete;
9289         CVec_NodeIdZ(CVec_NodeIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_NodeIdZ)); }
9290         CVec_NodeIdZ(LDKCVec_NodeIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_NodeIdZ)); }
9291         operator LDKCVec_NodeIdZ() && { LDKCVec_NodeIdZ res = self; memset(&self, 0, sizeof(LDKCVec_NodeIdZ)); return res; }
9292         ~CVec_NodeIdZ() { CVec_NodeIdZ_free(self); }
9293         CVec_NodeIdZ& operator=(CVec_NodeIdZ&& o) { CVec_NodeIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_NodeIdZ)); return *this; }
9294         LDKCVec_NodeIdZ* operator &() { return &self; }
9295         LDKCVec_NodeIdZ* operator ->() { return &self; }
9296         const LDKCVec_NodeIdZ* operator &() const { return &self; }
9297         const LDKCVec_NodeIdZ* operator ->() const { return &self; }
9298 };
9299 class CVec_u8Z {
9300 private:
9301         LDKCVec_u8Z self;
9302 public:
9303         CVec_u8Z(const CVec_u8Z&) = delete;
9304         CVec_u8Z(CVec_u8Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u8Z)); }
9305         CVec_u8Z(LDKCVec_u8Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u8Z)); }
9306         operator LDKCVec_u8Z() && { LDKCVec_u8Z res = self; memset(&self, 0, sizeof(LDKCVec_u8Z)); return res; }
9307         ~CVec_u8Z() { CVec_u8Z_free(self); }
9308         CVec_u8Z& operator=(CVec_u8Z&& o) { CVec_u8Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u8Z)); return *this; }
9309         LDKCVec_u8Z* operator &() { return &self; }
9310         LDKCVec_u8Z* operator ->() { return &self; }
9311         const LDKCVec_u8Z* operator &() const { return &self; }
9312         const LDKCVec_u8Z* operator ->() const { return &self; }
9313 };
9314 class CResult_RouteLightningErrorZ {
9315 private:
9316         LDKCResult_RouteLightningErrorZ self;
9317 public:
9318         CResult_RouteLightningErrorZ(const CResult_RouteLightningErrorZ&) = delete;
9319         CResult_RouteLightningErrorZ(CResult_RouteLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); }
9320         CResult_RouteLightningErrorZ(LDKCResult_RouteLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); }
9321         operator LDKCResult_RouteLightningErrorZ() && { LDKCResult_RouteLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); return res; }
9322         ~CResult_RouteLightningErrorZ() { CResult_RouteLightningErrorZ_free(self); }
9323         CResult_RouteLightningErrorZ& operator=(CResult_RouteLightningErrorZ&& o) { CResult_RouteLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); return *this; }
9324         LDKCResult_RouteLightningErrorZ* operator &() { return &self; }
9325         LDKCResult_RouteLightningErrorZ* operator ->() { return &self; }
9326         const LDKCResult_RouteLightningErrorZ* operator &() const { return &self; }
9327         const LDKCResult_RouteLightningErrorZ* operator ->() const { return &self; }
9328 };
9329 class CResult_NonePaymentSendFailureZ {
9330 private:
9331         LDKCResult_NonePaymentSendFailureZ self;
9332 public:
9333         CResult_NonePaymentSendFailureZ(const CResult_NonePaymentSendFailureZ&) = delete;
9334         CResult_NonePaymentSendFailureZ(CResult_NonePaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); }
9335         CResult_NonePaymentSendFailureZ(LDKCResult_NonePaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); }
9336         operator LDKCResult_NonePaymentSendFailureZ() && { LDKCResult_NonePaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); return res; }
9337         ~CResult_NonePaymentSendFailureZ() { CResult_NonePaymentSendFailureZ_free(self); }
9338         CResult_NonePaymentSendFailureZ& operator=(CResult_NonePaymentSendFailureZ&& o) { CResult_NonePaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); return *this; }
9339         LDKCResult_NonePaymentSendFailureZ* operator &() { return &self; }
9340         LDKCResult_NonePaymentSendFailureZ* operator ->() { return &self; }
9341         const LDKCResult_NonePaymentSendFailureZ* operator &() const { return &self; }
9342         const LDKCResult_NonePaymentSendFailureZ* operator ->() const { return &self; }
9343 };
9344 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ {
9345 private:
9346         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ self;
9347 public:
9348         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&) = delete;
9349         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); }
9350         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); }
9351         operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); return res; }
9352         ~CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(self); }
9353         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ& operator=(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&& o) { CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); return *this; }
9354         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator &() { return &self; }
9355         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator ->() { return &self; }
9356         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator &() const { return &self; }
9357         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator ->() const { return &self; }
9358 };
9359 class CResult_ChannelPublicKeysDecodeErrorZ {
9360 private:
9361         LDKCResult_ChannelPublicKeysDecodeErrorZ self;
9362 public:
9363         CResult_ChannelPublicKeysDecodeErrorZ(const CResult_ChannelPublicKeysDecodeErrorZ&) = delete;
9364         CResult_ChannelPublicKeysDecodeErrorZ(CResult_ChannelPublicKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelPublicKeysDecodeErrorZ)); }
9365         CResult_ChannelPublicKeysDecodeErrorZ(LDKCResult_ChannelPublicKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ)); }
9366         operator LDKCResult_ChannelPublicKeysDecodeErrorZ() && { LDKCResult_ChannelPublicKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ)); return res; }
9367         ~CResult_ChannelPublicKeysDecodeErrorZ() { CResult_ChannelPublicKeysDecodeErrorZ_free(self); }
9368         CResult_ChannelPublicKeysDecodeErrorZ& operator=(CResult_ChannelPublicKeysDecodeErrorZ&& o) { CResult_ChannelPublicKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelPublicKeysDecodeErrorZ)); return *this; }
9369         LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() { return &self; }
9370         LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() { return &self; }
9371         const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() const { return &self; }
9372         const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() const { return &self; }
9373 };
9374 class CVec_ClaimedHTLCZ {
9375 private:
9376         LDKCVec_ClaimedHTLCZ self;
9377 public:
9378         CVec_ClaimedHTLCZ(const CVec_ClaimedHTLCZ&) = delete;
9379         CVec_ClaimedHTLCZ(CVec_ClaimedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ClaimedHTLCZ)); }
9380         CVec_ClaimedHTLCZ(LDKCVec_ClaimedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ClaimedHTLCZ)); }
9381         operator LDKCVec_ClaimedHTLCZ() && { LDKCVec_ClaimedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_ClaimedHTLCZ)); return res; }
9382         ~CVec_ClaimedHTLCZ() { CVec_ClaimedHTLCZ_free(self); }
9383         CVec_ClaimedHTLCZ& operator=(CVec_ClaimedHTLCZ&& o) { CVec_ClaimedHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ClaimedHTLCZ)); return *this; }
9384         LDKCVec_ClaimedHTLCZ* operator &() { return &self; }
9385         LDKCVec_ClaimedHTLCZ* operator ->() { return &self; }
9386         const LDKCVec_ClaimedHTLCZ* operator &() const { return &self; }
9387         const LDKCVec_ClaimedHTLCZ* operator ->() const { return &self; }
9388 };
9389 class COption_CVec_ThirtyTwoBytesZZ {
9390 private:
9391         LDKCOption_CVec_ThirtyTwoBytesZZ self;
9392 public:
9393         COption_CVec_ThirtyTwoBytesZZ(const COption_CVec_ThirtyTwoBytesZZ&) = delete;
9394         COption_CVec_ThirtyTwoBytesZZ(COption_CVec_ThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_ThirtyTwoBytesZZ)); }
9395         COption_CVec_ThirtyTwoBytesZZ(LDKCOption_CVec_ThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ)); }
9396         operator LDKCOption_CVec_ThirtyTwoBytesZZ() && { LDKCOption_CVec_ThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ)); return res; }
9397         ~COption_CVec_ThirtyTwoBytesZZ() { COption_CVec_ThirtyTwoBytesZZ_free(self); }
9398         COption_CVec_ThirtyTwoBytesZZ& operator=(COption_CVec_ThirtyTwoBytesZZ&& o) { COption_CVec_ThirtyTwoBytesZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_CVec_ThirtyTwoBytesZZ)); return *this; }
9399         LDKCOption_CVec_ThirtyTwoBytesZZ* operator &() { return &self; }
9400         LDKCOption_CVec_ThirtyTwoBytesZZ* operator ->() { return &self; }
9401         const LDKCOption_CVec_ThirtyTwoBytesZZ* operator &() const { return &self; }
9402         const LDKCOption_CVec_ThirtyTwoBytesZZ* operator ->() const { return &self; }
9403 };
9404 class CVec_SocketAddressZ {
9405 private:
9406         LDKCVec_SocketAddressZ self;
9407 public:
9408         CVec_SocketAddressZ(const CVec_SocketAddressZ&) = delete;
9409         CVec_SocketAddressZ(CVec_SocketAddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SocketAddressZ)); }
9410         CVec_SocketAddressZ(LDKCVec_SocketAddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SocketAddressZ)); }
9411         operator LDKCVec_SocketAddressZ() && { LDKCVec_SocketAddressZ res = self; memset(&self, 0, sizeof(LDKCVec_SocketAddressZ)); return res; }
9412         ~CVec_SocketAddressZ() { CVec_SocketAddressZ_free(self); }
9413         CVec_SocketAddressZ& operator=(CVec_SocketAddressZ&& o) { CVec_SocketAddressZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_SocketAddressZ)); return *this; }
9414         LDKCVec_SocketAddressZ* operator &() { return &self; }
9415         LDKCVec_SocketAddressZ* operator ->() { return &self; }
9416         const LDKCVec_SocketAddressZ* operator &() const { return &self; }
9417         const LDKCVec_SocketAddressZ* operator ->() const { return &self; }
9418 };
9419 class CResult_ThirtyTwoBytesPaymentSendFailureZ {
9420 private:
9421         LDKCResult_ThirtyTwoBytesPaymentSendFailureZ self;
9422 public:
9423         CResult_ThirtyTwoBytesPaymentSendFailureZ(const CResult_ThirtyTwoBytesPaymentSendFailureZ&) = delete;
9424         CResult_ThirtyTwoBytesPaymentSendFailureZ(CResult_ThirtyTwoBytesPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentSendFailureZ)); }
9425         CResult_ThirtyTwoBytesPaymentSendFailureZ(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ)); }
9426         operator LDKCResult_ThirtyTwoBytesPaymentSendFailureZ() && { LDKCResult_ThirtyTwoBytesPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ)); return res; }
9427         ~CResult_ThirtyTwoBytesPaymentSendFailureZ() { CResult_ThirtyTwoBytesPaymentSendFailureZ_free(self); }
9428         CResult_ThirtyTwoBytesPaymentSendFailureZ& operator=(CResult_ThirtyTwoBytesPaymentSendFailureZ&& o) { CResult_ThirtyTwoBytesPaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentSendFailureZ)); return *this; }
9429         LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator &() { return &self; }
9430         LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator ->() { return &self; }
9431         const LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator &() const { return &self; }
9432         const LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator ->() const { return &self; }
9433 };
9434 class CResult_HolderCommitmentTransactionDecodeErrorZ {
9435 private:
9436         LDKCResult_HolderCommitmentTransactionDecodeErrorZ self;
9437 public:
9438         CResult_HolderCommitmentTransactionDecodeErrorZ(const CResult_HolderCommitmentTransactionDecodeErrorZ&) = delete;
9439         CResult_HolderCommitmentTransactionDecodeErrorZ(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); }
9440         CResult_HolderCommitmentTransactionDecodeErrorZ(LDKCResult_HolderCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); }
9441         operator LDKCResult_HolderCommitmentTransactionDecodeErrorZ() && { LDKCResult_HolderCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); return res; }
9442         ~CResult_HolderCommitmentTransactionDecodeErrorZ() { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); }
9443         CResult_HolderCommitmentTransactionDecodeErrorZ& operator=(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); return *this; }
9444         LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
9445         LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
9446         const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
9447         const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
9448 };
9449 class CResult_WarningMessageDecodeErrorZ {
9450 private:
9451         LDKCResult_WarningMessageDecodeErrorZ self;
9452 public:
9453         CResult_WarningMessageDecodeErrorZ(const CResult_WarningMessageDecodeErrorZ&) = delete;
9454         CResult_WarningMessageDecodeErrorZ(CResult_WarningMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WarningMessageDecodeErrorZ)); }
9455         CResult_WarningMessageDecodeErrorZ(LDKCResult_WarningMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WarningMessageDecodeErrorZ)); }
9456         operator LDKCResult_WarningMessageDecodeErrorZ() && { LDKCResult_WarningMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_WarningMessageDecodeErrorZ)); return res; }
9457         ~CResult_WarningMessageDecodeErrorZ() { CResult_WarningMessageDecodeErrorZ_free(self); }
9458         CResult_WarningMessageDecodeErrorZ& operator=(CResult_WarningMessageDecodeErrorZ&& o) { CResult_WarningMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WarningMessageDecodeErrorZ)); return *this; }
9459         LDKCResult_WarningMessageDecodeErrorZ* operator &() { return &self; }
9460         LDKCResult_WarningMessageDecodeErrorZ* operator ->() { return &self; }
9461         const LDKCResult_WarningMessageDecodeErrorZ* operator &() const { return &self; }
9462         const LDKCResult_WarningMessageDecodeErrorZ* operator ->() const { return &self; }
9463 };
9464 class CResult_ChannelCounterpartyDecodeErrorZ {
9465 private:
9466         LDKCResult_ChannelCounterpartyDecodeErrorZ self;
9467 public:
9468         CResult_ChannelCounterpartyDecodeErrorZ(const CResult_ChannelCounterpartyDecodeErrorZ&) = delete;
9469         CResult_ChannelCounterpartyDecodeErrorZ(CResult_ChannelCounterpartyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); }
9470         CResult_ChannelCounterpartyDecodeErrorZ(LDKCResult_ChannelCounterpartyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); }
9471         operator LDKCResult_ChannelCounterpartyDecodeErrorZ() && { LDKCResult_ChannelCounterpartyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); return res; }
9472         ~CResult_ChannelCounterpartyDecodeErrorZ() { CResult_ChannelCounterpartyDecodeErrorZ_free(self); }
9473         CResult_ChannelCounterpartyDecodeErrorZ& operator=(CResult_ChannelCounterpartyDecodeErrorZ&& o) { CResult_ChannelCounterpartyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); return *this; }
9474         LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() { return &self; }
9475         LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() { return &self; }
9476         const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() const { return &self; }
9477         const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() const { return &self; }
9478 };
9479 class CResult_InitDecodeErrorZ {
9480 private:
9481         LDKCResult_InitDecodeErrorZ self;
9482 public:
9483         CResult_InitDecodeErrorZ(const CResult_InitDecodeErrorZ&) = delete;
9484         CResult_InitDecodeErrorZ(CResult_InitDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); }
9485         CResult_InitDecodeErrorZ(LDKCResult_InitDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); }
9486         operator LDKCResult_InitDecodeErrorZ() && { LDKCResult_InitDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); return res; }
9487         ~CResult_InitDecodeErrorZ() { CResult_InitDecodeErrorZ_free(self); }
9488         CResult_InitDecodeErrorZ& operator=(CResult_InitDecodeErrorZ&& o) { CResult_InitDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); return *this; }
9489         LDKCResult_InitDecodeErrorZ* operator &() { return &self; }
9490         LDKCResult_InitDecodeErrorZ* operator ->() { return &self; }
9491         const LDKCResult_InitDecodeErrorZ* operator &() const { return &self; }
9492         const LDKCResult_InitDecodeErrorZ* operator ->() const { return &self; }
9493 };
9494 class CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ {
9495 private:
9496         LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ self;
9497 public:
9498         CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&) = delete;
9499         CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); }
9500         CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); }
9501         operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); return res; }
9502         ~CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(self); }
9503         CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ& operator=(CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&& o) { CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); return *this; }
9504         LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator &() { return &self; }
9505         LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator ->() { return &self; }
9506         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator &() const { return &self; }
9507         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator ->() const { return &self; }
9508 };
9509 class CResult_ClaimedHTLCDecodeErrorZ {
9510 private:
9511         LDKCResult_ClaimedHTLCDecodeErrorZ self;
9512 public:
9513         CResult_ClaimedHTLCDecodeErrorZ(const CResult_ClaimedHTLCDecodeErrorZ&) = delete;
9514         CResult_ClaimedHTLCDecodeErrorZ(CResult_ClaimedHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClaimedHTLCDecodeErrorZ)); }
9515         CResult_ClaimedHTLCDecodeErrorZ(LDKCResult_ClaimedHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ)); }
9516         operator LDKCResult_ClaimedHTLCDecodeErrorZ() && { LDKCResult_ClaimedHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ)); return res; }
9517         ~CResult_ClaimedHTLCDecodeErrorZ() { CResult_ClaimedHTLCDecodeErrorZ_free(self); }
9518         CResult_ClaimedHTLCDecodeErrorZ& operator=(CResult_ClaimedHTLCDecodeErrorZ&& o) { CResult_ClaimedHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClaimedHTLCDecodeErrorZ)); return *this; }
9519         LDKCResult_ClaimedHTLCDecodeErrorZ* operator &() { return &self; }
9520         LDKCResult_ClaimedHTLCDecodeErrorZ* operator ->() { return &self; }
9521         const LDKCResult_ClaimedHTLCDecodeErrorZ* operator &() const { return &self; }
9522         const LDKCResult_ClaimedHTLCDecodeErrorZ* operator ->() const { return &self; }
9523 };
9524 class CResult_PaymentPurposeDecodeErrorZ {
9525 private:
9526         LDKCResult_PaymentPurposeDecodeErrorZ self;
9527 public:
9528         CResult_PaymentPurposeDecodeErrorZ(const CResult_PaymentPurposeDecodeErrorZ&) = delete;
9529         CResult_PaymentPurposeDecodeErrorZ(CResult_PaymentPurposeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentPurposeDecodeErrorZ)); }
9530         CResult_PaymentPurposeDecodeErrorZ(LDKCResult_PaymentPurposeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentPurposeDecodeErrorZ)); }
9531         operator LDKCResult_PaymentPurposeDecodeErrorZ() && { LDKCResult_PaymentPurposeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentPurposeDecodeErrorZ)); return res; }
9532         ~CResult_PaymentPurposeDecodeErrorZ() { CResult_PaymentPurposeDecodeErrorZ_free(self); }
9533         CResult_PaymentPurposeDecodeErrorZ& operator=(CResult_PaymentPurposeDecodeErrorZ&& o) { CResult_PaymentPurposeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentPurposeDecodeErrorZ)); return *this; }
9534         LDKCResult_PaymentPurposeDecodeErrorZ* operator &() { return &self; }
9535         LDKCResult_PaymentPurposeDecodeErrorZ* operator ->() { return &self; }
9536         const LDKCResult_PaymentPurposeDecodeErrorZ* operator &() const { return &self; }
9537         const LDKCResult_PaymentPurposeDecodeErrorZ* operator ->() const { return &self; }
9538 };
9539 class CVec_MonitorUpdateIdZ {
9540 private:
9541         LDKCVec_MonitorUpdateIdZ self;
9542 public:
9543         CVec_MonitorUpdateIdZ(const CVec_MonitorUpdateIdZ&) = delete;
9544         CVec_MonitorUpdateIdZ(CVec_MonitorUpdateIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorUpdateIdZ)); }
9545         CVec_MonitorUpdateIdZ(LDKCVec_MonitorUpdateIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorUpdateIdZ)); }
9546         operator LDKCVec_MonitorUpdateIdZ() && { LDKCVec_MonitorUpdateIdZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorUpdateIdZ)); return res; }
9547         ~CVec_MonitorUpdateIdZ() { CVec_MonitorUpdateIdZ_free(self); }
9548         CVec_MonitorUpdateIdZ& operator=(CVec_MonitorUpdateIdZ&& o) { CVec_MonitorUpdateIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MonitorUpdateIdZ)); return *this; }
9549         LDKCVec_MonitorUpdateIdZ* operator &() { return &self; }
9550         LDKCVec_MonitorUpdateIdZ* operator ->() { return &self; }
9551         const LDKCVec_MonitorUpdateIdZ* operator &() const { return &self; }
9552         const LDKCVec_MonitorUpdateIdZ* operator ->() const { return &self; }
9553 };
9554 class CResult_OutPointDecodeErrorZ {
9555 private:
9556         LDKCResult_OutPointDecodeErrorZ self;
9557 public:
9558         CResult_OutPointDecodeErrorZ(const CResult_OutPointDecodeErrorZ&) = delete;
9559         CResult_OutPointDecodeErrorZ(CResult_OutPointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OutPointDecodeErrorZ)); }
9560         CResult_OutPointDecodeErrorZ(LDKCResult_OutPointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OutPointDecodeErrorZ)); }
9561         operator LDKCResult_OutPointDecodeErrorZ() && { LDKCResult_OutPointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OutPointDecodeErrorZ)); return res; }
9562         ~CResult_OutPointDecodeErrorZ() { CResult_OutPointDecodeErrorZ_free(self); }
9563         CResult_OutPointDecodeErrorZ& operator=(CResult_OutPointDecodeErrorZ&& o) { CResult_OutPointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OutPointDecodeErrorZ)); return *this; }
9564         LDKCResult_OutPointDecodeErrorZ* operator &() { return &self; }
9565         LDKCResult_OutPointDecodeErrorZ* operator ->() { return &self; }
9566         const LDKCResult_OutPointDecodeErrorZ* operator &() const { return &self; }
9567         const LDKCResult_OutPointDecodeErrorZ* operator ->() const { return &self; }
9568 };
9569 class CVec_ChannelDetailsZ {
9570 private:
9571         LDKCVec_ChannelDetailsZ self;
9572 public:
9573         CVec_ChannelDetailsZ(const CVec_ChannelDetailsZ&) = delete;
9574         CVec_ChannelDetailsZ(CVec_ChannelDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelDetailsZ)); }
9575         CVec_ChannelDetailsZ(LDKCVec_ChannelDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelDetailsZ)); }
9576         operator LDKCVec_ChannelDetailsZ() && { LDKCVec_ChannelDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelDetailsZ)); return res; }
9577         ~CVec_ChannelDetailsZ() { CVec_ChannelDetailsZ_free(self); }
9578         CVec_ChannelDetailsZ& operator=(CVec_ChannelDetailsZ&& o) { CVec_ChannelDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelDetailsZ)); return *this; }
9579         LDKCVec_ChannelDetailsZ* operator &() { return &self; }
9580         LDKCVec_ChannelDetailsZ* operator ->() { return &self; }
9581         const LDKCVec_ChannelDetailsZ* operator &() const { return &self; }
9582         const LDKCVec_ChannelDetailsZ* operator ->() const { return &self; }
9583 };
9584 class CResult_Bolt11InvoiceFeaturesDecodeErrorZ {
9585 private:
9586         LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ self;
9587 public:
9588         CResult_Bolt11InvoiceFeaturesDecodeErrorZ(const CResult_Bolt11InvoiceFeaturesDecodeErrorZ&) = delete;
9589         CResult_Bolt11InvoiceFeaturesDecodeErrorZ(CResult_Bolt11InvoiceFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceFeaturesDecodeErrorZ)); }
9590         CResult_Bolt11InvoiceFeaturesDecodeErrorZ(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ)); }
9591         operator LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ() && { LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ)); return res; }
9592         ~CResult_Bolt11InvoiceFeaturesDecodeErrorZ() { CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(self); }
9593         CResult_Bolt11InvoiceFeaturesDecodeErrorZ& operator=(CResult_Bolt11InvoiceFeaturesDecodeErrorZ&& o) { CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceFeaturesDecodeErrorZ)); return *this; }
9594         LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator &() { return &self; }
9595         LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator ->() { return &self; }
9596         const LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
9597         const LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
9598 };
9599 class CVec_MessageSendEventZ {
9600 private:
9601         LDKCVec_MessageSendEventZ self;
9602 public:
9603         CVec_MessageSendEventZ(const CVec_MessageSendEventZ&) = delete;
9604         CVec_MessageSendEventZ(CVec_MessageSendEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MessageSendEventZ)); }
9605         CVec_MessageSendEventZ(LDKCVec_MessageSendEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MessageSendEventZ)); }
9606         operator LDKCVec_MessageSendEventZ() && { LDKCVec_MessageSendEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MessageSendEventZ)); return res; }
9607         ~CVec_MessageSendEventZ() { CVec_MessageSendEventZ_free(self); }
9608         CVec_MessageSendEventZ& operator=(CVec_MessageSendEventZ&& o) { CVec_MessageSendEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MessageSendEventZ)); return *this; }
9609         LDKCVec_MessageSendEventZ* operator &() { return &self; }
9610         LDKCVec_MessageSendEventZ* operator ->() { return &self; }
9611         const LDKCVec_MessageSendEventZ* operator &() const { return &self; }
9612         const LDKCVec_MessageSendEventZ* operator ->() const { return &self; }
9613 };
9614 class CResult_RouteHintHopDecodeErrorZ {
9615 private:
9616         LDKCResult_RouteHintHopDecodeErrorZ self;
9617 public:
9618         CResult_RouteHintHopDecodeErrorZ(const CResult_RouteHintHopDecodeErrorZ&) = delete;
9619         CResult_RouteHintHopDecodeErrorZ(CResult_RouteHintHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHintHopDecodeErrorZ)); }
9620         CResult_RouteHintHopDecodeErrorZ(LDKCResult_RouteHintHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHintHopDecodeErrorZ)); }
9621         operator LDKCResult_RouteHintHopDecodeErrorZ() && { LDKCResult_RouteHintHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHintHopDecodeErrorZ)); return res; }
9622         ~CResult_RouteHintHopDecodeErrorZ() { CResult_RouteHintHopDecodeErrorZ_free(self); }
9623         CResult_RouteHintHopDecodeErrorZ& operator=(CResult_RouteHintHopDecodeErrorZ&& o) { CResult_RouteHintHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHintHopDecodeErrorZ)); return *this; }
9624         LDKCResult_RouteHintHopDecodeErrorZ* operator &() { return &self; }
9625         LDKCResult_RouteHintHopDecodeErrorZ* operator ->() { return &self; }
9626         const LDKCResult_RouteHintHopDecodeErrorZ* operator &() const { return &self; }
9627         const LDKCResult_RouteHintHopDecodeErrorZ* operator ->() const { return &self; }
9628 };
9629 class CResult_UpdateFailMalformedHTLCDecodeErrorZ {
9630 private:
9631         LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ self;
9632 public:
9633         CResult_UpdateFailMalformedHTLCDecodeErrorZ(const CResult_UpdateFailMalformedHTLCDecodeErrorZ&) = delete;
9634         CResult_UpdateFailMalformedHTLCDecodeErrorZ(CResult_UpdateFailMalformedHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFailMalformedHTLCDecodeErrorZ)); }
9635         CResult_UpdateFailMalformedHTLCDecodeErrorZ(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ)); }
9636         operator LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ() && { LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ)); return res; }
9637         ~CResult_UpdateFailMalformedHTLCDecodeErrorZ() { CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(self); }
9638         CResult_UpdateFailMalformedHTLCDecodeErrorZ& operator=(CResult_UpdateFailMalformedHTLCDecodeErrorZ&& o) { CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFailMalformedHTLCDecodeErrorZ)); return *this; }
9639         LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() { return &self; }
9640         LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() { return &self; }
9641         const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() const { return &self; }
9642         const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() const { return &self; }
9643 };
9644 class CResult_BlindedPayInfoDecodeErrorZ {
9645 private:
9646         LDKCResult_BlindedPayInfoDecodeErrorZ self;
9647 public:
9648         CResult_BlindedPayInfoDecodeErrorZ(const CResult_BlindedPayInfoDecodeErrorZ&) = delete;
9649         CResult_BlindedPayInfoDecodeErrorZ(CResult_BlindedPayInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPayInfoDecodeErrorZ)); }
9650         CResult_BlindedPayInfoDecodeErrorZ(LDKCResult_BlindedPayInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ)); }
9651         operator LDKCResult_BlindedPayInfoDecodeErrorZ() && { LDKCResult_BlindedPayInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ)); return res; }
9652         ~CResult_BlindedPayInfoDecodeErrorZ() { CResult_BlindedPayInfoDecodeErrorZ_free(self); }
9653         CResult_BlindedPayInfoDecodeErrorZ& operator=(CResult_BlindedPayInfoDecodeErrorZ&& o) { CResult_BlindedPayInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPayInfoDecodeErrorZ)); return *this; }
9654         LDKCResult_BlindedPayInfoDecodeErrorZ* operator &() { return &self; }
9655         LDKCResult_BlindedPayInfoDecodeErrorZ* operator ->() { return &self; }
9656         const LDKCResult_BlindedPayInfoDecodeErrorZ* operator &() const { return &self; }
9657         const LDKCResult_BlindedPayInfoDecodeErrorZ* operator ->() const { return &self; }
9658 };
9659 class CResult_ThirtyTwoBytesAPIErrorZ {
9660 private:
9661         LDKCResult_ThirtyTwoBytesAPIErrorZ self;
9662 public:
9663         CResult_ThirtyTwoBytesAPIErrorZ(const CResult_ThirtyTwoBytesAPIErrorZ&) = delete;
9664         CResult_ThirtyTwoBytesAPIErrorZ(CResult_ThirtyTwoBytesAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesAPIErrorZ)); }
9665         CResult_ThirtyTwoBytesAPIErrorZ(LDKCResult_ThirtyTwoBytesAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesAPIErrorZ)); }
9666         operator LDKCResult_ThirtyTwoBytesAPIErrorZ() && { LDKCResult_ThirtyTwoBytesAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesAPIErrorZ)); return res; }
9667         ~CResult_ThirtyTwoBytesAPIErrorZ() { CResult_ThirtyTwoBytesAPIErrorZ_free(self); }
9668         CResult_ThirtyTwoBytesAPIErrorZ& operator=(CResult_ThirtyTwoBytesAPIErrorZ&& o) { CResult_ThirtyTwoBytesAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesAPIErrorZ)); return *this; }
9669         LDKCResult_ThirtyTwoBytesAPIErrorZ* operator &() { return &self; }
9670         LDKCResult_ThirtyTwoBytesAPIErrorZ* operator ->() { return &self; }
9671         const LDKCResult_ThirtyTwoBytesAPIErrorZ* operator &() const { return &self; }
9672         const LDKCResult_ThirtyTwoBytesAPIErrorZ* operator ->() const { return &self; }
9673 };
9674 class COption_ChannelShutdownStateZ {
9675 private:
9676         LDKCOption_ChannelShutdownStateZ self;
9677 public:
9678         COption_ChannelShutdownStateZ(const COption_ChannelShutdownStateZ&) = delete;
9679         COption_ChannelShutdownStateZ(COption_ChannelShutdownStateZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ChannelShutdownStateZ)); }
9680         COption_ChannelShutdownStateZ(LDKCOption_ChannelShutdownStateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ChannelShutdownStateZ)); }
9681         operator LDKCOption_ChannelShutdownStateZ() && { LDKCOption_ChannelShutdownStateZ res = self; memset(&self, 0, sizeof(LDKCOption_ChannelShutdownStateZ)); return res; }
9682         ~COption_ChannelShutdownStateZ() { COption_ChannelShutdownStateZ_free(self); }
9683         COption_ChannelShutdownStateZ& operator=(COption_ChannelShutdownStateZ&& o) { COption_ChannelShutdownStateZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ChannelShutdownStateZ)); return *this; }
9684         LDKCOption_ChannelShutdownStateZ* operator &() { return &self; }
9685         LDKCOption_ChannelShutdownStateZ* operator ->() { return &self; }
9686         const LDKCOption_ChannelShutdownStateZ* operator &() const { return &self; }
9687         const LDKCOption_ChannelShutdownStateZ* operator ->() const { return &self; }
9688 };
9689 class CResult_CVec_CVec_u8ZZNoneZ {
9690 private:
9691         LDKCResult_CVec_CVec_u8ZZNoneZ self;
9692 public:
9693         CResult_CVec_CVec_u8ZZNoneZ(const CResult_CVec_CVec_u8ZZNoneZ&) = delete;
9694         CResult_CVec_CVec_u8ZZNoneZ(CResult_CVec_CVec_u8ZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_CVec_u8ZZNoneZ)); }
9695         CResult_CVec_CVec_u8ZZNoneZ(LDKCResult_CVec_CVec_u8ZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ)); }
9696         operator LDKCResult_CVec_CVec_u8ZZNoneZ() && { LDKCResult_CVec_CVec_u8ZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ)); return res; }
9697         ~CResult_CVec_CVec_u8ZZNoneZ() { CResult_CVec_CVec_u8ZZNoneZ_free(self); }
9698         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; }
9699         LDKCResult_CVec_CVec_u8ZZNoneZ* operator &() { return &self; }
9700         LDKCResult_CVec_CVec_u8ZZNoneZ* operator ->() { return &self; }
9701         const LDKCResult_CVec_CVec_u8ZZNoneZ* operator &() const { return &self; }
9702         const LDKCResult_CVec_CVec_u8ZZNoneZ* operator ->() const { return &self; }
9703 };
9704 class CResult_AcceptChannelDecodeErrorZ {
9705 private:
9706         LDKCResult_AcceptChannelDecodeErrorZ self;
9707 public:
9708         CResult_AcceptChannelDecodeErrorZ(const CResult_AcceptChannelDecodeErrorZ&) = delete;
9709         CResult_AcceptChannelDecodeErrorZ(CResult_AcceptChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); }
9710         CResult_AcceptChannelDecodeErrorZ(LDKCResult_AcceptChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); }
9711         operator LDKCResult_AcceptChannelDecodeErrorZ() && { LDKCResult_AcceptChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); return res; }
9712         ~CResult_AcceptChannelDecodeErrorZ() { CResult_AcceptChannelDecodeErrorZ_free(self); }
9713         CResult_AcceptChannelDecodeErrorZ& operator=(CResult_AcceptChannelDecodeErrorZ&& o) { CResult_AcceptChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); return *this; }
9714         LDKCResult_AcceptChannelDecodeErrorZ* operator &() { return &self; }
9715         LDKCResult_AcceptChannelDecodeErrorZ* operator ->() { return &self; }
9716         const LDKCResult_AcceptChannelDecodeErrorZ* operator &() const { return &self; }
9717         const LDKCResult_AcceptChannelDecodeErrorZ* operator ->() const { return &self; }
9718 };
9719 class CResult_HostnameDecodeErrorZ {
9720 private:
9721         LDKCResult_HostnameDecodeErrorZ self;
9722 public:
9723         CResult_HostnameDecodeErrorZ(const CResult_HostnameDecodeErrorZ&) = delete;
9724         CResult_HostnameDecodeErrorZ(CResult_HostnameDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HostnameDecodeErrorZ)); }
9725         CResult_HostnameDecodeErrorZ(LDKCResult_HostnameDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HostnameDecodeErrorZ)); }
9726         operator LDKCResult_HostnameDecodeErrorZ() && { LDKCResult_HostnameDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HostnameDecodeErrorZ)); return res; }
9727         ~CResult_HostnameDecodeErrorZ() { CResult_HostnameDecodeErrorZ_free(self); }
9728         CResult_HostnameDecodeErrorZ& operator=(CResult_HostnameDecodeErrorZ&& o) { CResult_HostnameDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HostnameDecodeErrorZ)); return *this; }
9729         LDKCResult_HostnameDecodeErrorZ* operator &() { return &self; }
9730         LDKCResult_HostnameDecodeErrorZ* operator ->() { return &self; }
9731         const LDKCResult_HostnameDecodeErrorZ* operator &() const { return &self; }
9732         const LDKCResult_HostnameDecodeErrorZ* operator ->() const { return &self; }
9733 };
9734 class C2Tuple_u64u16Z {
9735 private:
9736         LDKC2Tuple_u64u16Z self;
9737 public:
9738         C2Tuple_u64u16Z(const C2Tuple_u64u16Z&) = delete;
9739         C2Tuple_u64u16Z(C2Tuple_u64u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64u16Z)); }
9740         C2Tuple_u64u16Z(LDKC2Tuple_u64u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64u16Z)); }
9741         operator LDKC2Tuple_u64u16Z() && { LDKC2Tuple_u64u16Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64u16Z)); return res; }
9742         ~C2Tuple_u64u16Z() { C2Tuple_u64u16Z_free(self); }
9743         C2Tuple_u64u16Z& operator=(C2Tuple_u64u16Z&& o) { C2Tuple_u64u16Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u64u16Z)); return *this; }
9744         LDKC2Tuple_u64u16Z* operator &() { return &self; }
9745         LDKC2Tuple_u64u16Z* operator ->() { return &self; }
9746         const LDKC2Tuple_u64u16Z* operator &() const { return &self; }
9747         const LDKC2Tuple_u64u16Z* operator ->() const { return &self; }
9748 };
9749 class COption_ThirtyTwoBytesZ {
9750 private:
9751         LDKCOption_ThirtyTwoBytesZ self;
9752 public:
9753         COption_ThirtyTwoBytesZ(const COption_ThirtyTwoBytesZ&) = delete;
9754         COption_ThirtyTwoBytesZ(COption_ThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ThirtyTwoBytesZ)); }
9755         COption_ThirtyTwoBytesZ(LDKCOption_ThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ThirtyTwoBytesZ)); }
9756         operator LDKCOption_ThirtyTwoBytesZ() && { LDKCOption_ThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKCOption_ThirtyTwoBytesZ)); return res; }
9757         ~COption_ThirtyTwoBytesZ() { COption_ThirtyTwoBytesZ_free(self); }
9758         COption_ThirtyTwoBytesZ& operator=(COption_ThirtyTwoBytesZ&& o) { COption_ThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ThirtyTwoBytesZ)); return *this; }
9759         LDKCOption_ThirtyTwoBytesZ* operator &() { return &self; }
9760         LDKCOption_ThirtyTwoBytesZ* operator ->() { return &self; }
9761         const LDKCOption_ThirtyTwoBytesZ* operator &() const { return &self; }
9762         const LDKCOption_ThirtyTwoBytesZ* operator ->() const { return &self; }
9763 };
9764 class CVec_u64Z {
9765 private:
9766         LDKCVec_u64Z self;
9767 public:
9768         CVec_u64Z(const CVec_u64Z&) = delete;
9769         CVec_u64Z(CVec_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u64Z)); }
9770         CVec_u64Z(LDKCVec_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u64Z)); }
9771         operator LDKCVec_u64Z() && { LDKCVec_u64Z res = self; memset(&self, 0, sizeof(LDKCVec_u64Z)); return res; }
9772         ~CVec_u64Z() { CVec_u64Z_free(self); }
9773         CVec_u64Z& operator=(CVec_u64Z&& o) { CVec_u64Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u64Z)); return *this; }
9774         LDKCVec_u64Z* operator &() { return &self; }
9775         LDKCVec_u64Z* operator ->() { return &self; }
9776         const LDKCVec_u64Z* operator &() const { return &self; }
9777         const LDKCVec_u64Z* operator ->() const { return &self; }
9778 };
9779 class CResult_NoneBolt12SemanticErrorZ {
9780 private:
9781         LDKCResult_NoneBolt12SemanticErrorZ self;
9782 public:
9783         CResult_NoneBolt12SemanticErrorZ(const CResult_NoneBolt12SemanticErrorZ&) = delete;
9784         CResult_NoneBolt12SemanticErrorZ(CResult_NoneBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneBolt12SemanticErrorZ)); }
9785         CResult_NoneBolt12SemanticErrorZ(LDKCResult_NoneBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneBolt12SemanticErrorZ)); }
9786         operator LDKCResult_NoneBolt12SemanticErrorZ() && { LDKCResult_NoneBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneBolt12SemanticErrorZ)); return res; }
9787         ~CResult_NoneBolt12SemanticErrorZ() { CResult_NoneBolt12SemanticErrorZ_free(self); }
9788         CResult_NoneBolt12SemanticErrorZ& operator=(CResult_NoneBolt12SemanticErrorZ&& o) { CResult_NoneBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneBolt12SemanticErrorZ)); return *this; }
9789         LDKCResult_NoneBolt12SemanticErrorZ* operator &() { return &self; }
9790         LDKCResult_NoneBolt12SemanticErrorZ* operator ->() { return &self; }
9791         const LDKCResult_NoneBolt12SemanticErrorZ* operator &() const { return &self; }
9792         const LDKCResult_NoneBolt12SemanticErrorZ* operator ->() const { return &self; }
9793 };
9794 class COption_SecretKeyZ {
9795 private:
9796         LDKCOption_SecretKeyZ self;
9797 public:
9798         COption_SecretKeyZ(const COption_SecretKeyZ&) = delete;
9799         COption_SecretKeyZ(COption_SecretKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_SecretKeyZ)); }
9800         COption_SecretKeyZ(LDKCOption_SecretKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_SecretKeyZ)); }
9801         operator LDKCOption_SecretKeyZ() && { LDKCOption_SecretKeyZ res = self; memset(&self, 0, sizeof(LDKCOption_SecretKeyZ)); return res; }
9802         ~COption_SecretKeyZ() { COption_SecretKeyZ_free(self); }
9803         COption_SecretKeyZ& operator=(COption_SecretKeyZ&& o) { COption_SecretKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_SecretKeyZ)); return *this; }
9804         LDKCOption_SecretKeyZ* operator &() { return &self; }
9805         LDKCOption_SecretKeyZ* operator ->() { return &self; }
9806         const LDKCOption_SecretKeyZ* operator &() const { return &self; }
9807         const LDKCOption_SecretKeyZ* operator ->() const { return &self; }
9808 };
9809 class CResult_ThirtyTwoBytesPaymentErrorZ {
9810 private:
9811         LDKCResult_ThirtyTwoBytesPaymentErrorZ self;
9812 public:
9813         CResult_ThirtyTwoBytesPaymentErrorZ(const CResult_ThirtyTwoBytesPaymentErrorZ&) = delete;
9814         CResult_ThirtyTwoBytesPaymentErrorZ(CResult_ThirtyTwoBytesPaymentErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentErrorZ)); }
9815         CResult_ThirtyTwoBytesPaymentErrorZ(LDKCResult_ThirtyTwoBytesPaymentErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentErrorZ)); }
9816         operator LDKCResult_ThirtyTwoBytesPaymentErrorZ() && { LDKCResult_ThirtyTwoBytesPaymentErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentErrorZ)); return res; }
9817         ~CResult_ThirtyTwoBytesPaymentErrorZ() { CResult_ThirtyTwoBytesPaymentErrorZ_free(self); }
9818         CResult_ThirtyTwoBytesPaymentErrorZ& operator=(CResult_ThirtyTwoBytesPaymentErrorZ&& o) { CResult_ThirtyTwoBytesPaymentErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentErrorZ)); return *this; }
9819         LDKCResult_ThirtyTwoBytesPaymentErrorZ* operator &() { return &self; }
9820         LDKCResult_ThirtyTwoBytesPaymentErrorZ* operator ->() { return &self; }
9821         const LDKCResult_ThirtyTwoBytesPaymentErrorZ* operator &() const { return &self; }
9822         const LDKCResult_ThirtyTwoBytesPaymentErrorZ* operator ->() const { return &self; }
9823 };
9824 class COption_EventZ {
9825 private:
9826         LDKCOption_EventZ self;
9827 public:
9828         COption_EventZ(const COption_EventZ&) = delete;
9829         COption_EventZ(COption_EventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_EventZ)); }
9830         COption_EventZ(LDKCOption_EventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_EventZ)); }
9831         operator LDKCOption_EventZ() && { LDKCOption_EventZ res = self; memset(&self, 0, sizeof(LDKCOption_EventZ)); return res; }
9832         ~COption_EventZ() { COption_EventZ_free(self); }
9833         COption_EventZ& operator=(COption_EventZ&& o) { COption_EventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_EventZ)); return *this; }
9834         LDKCOption_EventZ* operator &() { return &self; }
9835         LDKCOption_EventZ* operator ->() { return &self; }
9836         const LDKCOption_EventZ* operator &() const { return &self; }
9837         const LDKCOption_EventZ* operator ->() const { return &self; }
9838 };
9839 class CResult_ChannelTypeFeaturesDecodeErrorZ {
9840 private:
9841         LDKCResult_ChannelTypeFeaturesDecodeErrorZ self;
9842 public:
9843         CResult_ChannelTypeFeaturesDecodeErrorZ(const CResult_ChannelTypeFeaturesDecodeErrorZ&) = delete;
9844         CResult_ChannelTypeFeaturesDecodeErrorZ(CResult_ChannelTypeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTypeFeaturesDecodeErrorZ)); }
9845         CResult_ChannelTypeFeaturesDecodeErrorZ(LDKCResult_ChannelTypeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ)); }
9846         operator LDKCResult_ChannelTypeFeaturesDecodeErrorZ() && { LDKCResult_ChannelTypeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ)); return res; }
9847         ~CResult_ChannelTypeFeaturesDecodeErrorZ() { CResult_ChannelTypeFeaturesDecodeErrorZ_free(self); }
9848         CResult_ChannelTypeFeaturesDecodeErrorZ& operator=(CResult_ChannelTypeFeaturesDecodeErrorZ&& o) { CResult_ChannelTypeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTypeFeaturesDecodeErrorZ)); return *this; }
9849         LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() { return &self; }
9850         LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() { return &self; }
9851         const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() const { return &self; }
9852         const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() const { return &self; }
9853 };
9854 class COption_CVec_SocketAddressZZ {
9855 private:
9856         LDKCOption_CVec_SocketAddressZZ self;
9857 public:
9858         COption_CVec_SocketAddressZZ(const COption_CVec_SocketAddressZZ&) = delete;
9859         COption_CVec_SocketAddressZZ(COption_CVec_SocketAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_SocketAddressZZ)); }
9860         COption_CVec_SocketAddressZZ(LDKCOption_CVec_SocketAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_SocketAddressZZ)); }
9861         operator LDKCOption_CVec_SocketAddressZZ() && { LDKCOption_CVec_SocketAddressZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_SocketAddressZZ)); return res; }
9862         ~COption_CVec_SocketAddressZZ() { COption_CVec_SocketAddressZZ_free(self); }
9863         COption_CVec_SocketAddressZZ& operator=(COption_CVec_SocketAddressZZ&& o) { COption_CVec_SocketAddressZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_CVec_SocketAddressZZ)); return *this; }
9864         LDKCOption_CVec_SocketAddressZZ* operator &() { return &self; }
9865         LDKCOption_CVec_SocketAddressZZ* operator ->() { return &self; }
9866         const LDKCOption_CVec_SocketAddressZZ* operator &() const { return &self; }
9867         const LDKCOption_CVec_SocketAddressZZ* operator ->() const { return &self; }
9868 };
9869 class CVec_RouteHintZ {
9870 private:
9871         LDKCVec_RouteHintZ self;
9872 public:
9873         CVec_RouteHintZ(const CVec_RouteHintZ&) = delete;
9874         CVec_RouteHintZ(CVec_RouteHintZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintZ)); }
9875         CVec_RouteHintZ(LDKCVec_RouteHintZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintZ)); }
9876         operator LDKCVec_RouteHintZ() && { LDKCVec_RouteHintZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintZ)); return res; }
9877         ~CVec_RouteHintZ() { CVec_RouteHintZ_free(self); }
9878         CVec_RouteHintZ& operator=(CVec_RouteHintZ&& o) { CVec_RouteHintZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintZ)); return *this; }
9879         LDKCVec_RouteHintZ* operator &() { return &self; }
9880         LDKCVec_RouteHintZ* operator ->() { return &self; }
9881         const LDKCVec_RouteHintZ* operator &() const { return &self; }
9882         const LDKCVec_RouteHintZ* operator ->() const { return &self; }
9883 };
9884 class COption_u16Z {
9885 private:
9886         LDKCOption_u16Z self;
9887 public:
9888         COption_u16Z(const COption_u16Z&) = delete;
9889         COption_u16Z(COption_u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u16Z)); }
9890         COption_u16Z(LDKCOption_u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u16Z)); }
9891         operator LDKCOption_u16Z() && { LDKCOption_u16Z res = self; memset(&self, 0, sizeof(LDKCOption_u16Z)); return res; }
9892         ~COption_u16Z() { COption_u16Z_free(self); }
9893         COption_u16Z& operator=(COption_u16Z&& o) { COption_u16Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u16Z)); return *this; }
9894         LDKCOption_u16Z* operator &() { return &self; }
9895         LDKCOption_u16Z* operator ->() { return &self; }
9896         const LDKCOption_u16Z* operator &() const { return &self; }
9897         const LDKCOption_u16Z* operator ->() const { return &self; }
9898 };
9899 class COption_PaymentFailureReasonZ {
9900 private:
9901         LDKCOption_PaymentFailureReasonZ self;
9902 public:
9903         COption_PaymentFailureReasonZ(const COption_PaymentFailureReasonZ&) = delete;
9904         COption_PaymentFailureReasonZ(COption_PaymentFailureReasonZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_PaymentFailureReasonZ)); }
9905         COption_PaymentFailureReasonZ(LDKCOption_PaymentFailureReasonZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_PaymentFailureReasonZ)); }
9906         operator LDKCOption_PaymentFailureReasonZ() && { LDKCOption_PaymentFailureReasonZ res = self; memset(&self, 0, sizeof(LDKCOption_PaymentFailureReasonZ)); return res; }
9907         ~COption_PaymentFailureReasonZ() { COption_PaymentFailureReasonZ_free(self); }
9908         COption_PaymentFailureReasonZ& operator=(COption_PaymentFailureReasonZ&& o) { COption_PaymentFailureReasonZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_PaymentFailureReasonZ)); return *this; }
9909         LDKCOption_PaymentFailureReasonZ* operator &() { return &self; }
9910         LDKCOption_PaymentFailureReasonZ* operator ->() { return &self; }
9911         const LDKCOption_PaymentFailureReasonZ* operator &() const { return &self; }
9912         const LDKCOption_PaymentFailureReasonZ* operator ->() const { return &self; }
9913 };
9914 class CResult_ECDSASignatureNoneZ {
9915 private:
9916         LDKCResult_ECDSASignatureNoneZ self;
9917 public:
9918         CResult_ECDSASignatureNoneZ(const CResult_ECDSASignatureNoneZ&) = delete;
9919         CResult_ECDSASignatureNoneZ(CResult_ECDSASignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ECDSASignatureNoneZ)); }
9920         CResult_ECDSASignatureNoneZ(LDKCResult_ECDSASignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ECDSASignatureNoneZ)); }
9921         operator LDKCResult_ECDSASignatureNoneZ() && { LDKCResult_ECDSASignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ECDSASignatureNoneZ)); return res; }
9922         ~CResult_ECDSASignatureNoneZ() { CResult_ECDSASignatureNoneZ_free(self); }
9923         CResult_ECDSASignatureNoneZ& operator=(CResult_ECDSASignatureNoneZ&& o) { CResult_ECDSASignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ECDSASignatureNoneZ)); return *this; }
9924         LDKCResult_ECDSASignatureNoneZ* operator &() { return &self; }
9925         LDKCResult_ECDSASignatureNoneZ* operator ->() { return &self; }
9926         const LDKCResult_ECDSASignatureNoneZ* operator &() const { return &self; }
9927         const LDKCResult_ECDSASignatureNoneZ* operator ->() const { return &self; }
9928 };
9929 class CVec_WitnessZ {
9930 private:
9931         LDKCVec_WitnessZ self;
9932 public:
9933         CVec_WitnessZ(const CVec_WitnessZ&) = delete;
9934         CVec_WitnessZ(CVec_WitnessZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_WitnessZ)); }
9935         CVec_WitnessZ(LDKCVec_WitnessZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_WitnessZ)); }
9936         operator LDKCVec_WitnessZ() && { LDKCVec_WitnessZ res = self; memset(&self, 0, sizeof(LDKCVec_WitnessZ)); return res; }
9937         ~CVec_WitnessZ() { CVec_WitnessZ_free(self); }
9938         CVec_WitnessZ& operator=(CVec_WitnessZ&& o) { CVec_WitnessZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_WitnessZ)); return *this; }
9939         LDKCVec_WitnessZ* operator &() { return &self; }
9940         LDKCVec_WitnessZ* operator ->() { return &self; }
9941         const LDKCVec_WitnessZ* operator &() const { return &self; }
9942         const LDKCVec_WitnessZ* operator ->() const { return &self; }
9943 };
9944 class CResult_BlindedTailDecodeErrorZ {
9945 private:
9946         LDKCResult_BlindedTailDecodeErrorZ self;
9947 public:
9948         CResult_BlindedTailDecodeErrorZ(const CResult_BlindedTailDecodeErrorZ&) = delete;
9949         CResult_BlindedTailDecodeErrorZ(CResult_BlindedTailDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedTailDecodeErrorZ)); }
9950         CResult_BlindedTailDecodeErrorZ(LDKCResult_BlindedTailDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedTailDecodeErrorZ)); }
9951         operator LDKCResult_BlindedTailDecodeErrorZ() && { LDKCResult_BlindedTailDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedTailDecodeErrorZ)); return res; }
9952         ~CResult_BlindedTailDecodeErrorZ() { CResult_BlindedTailDecodeErrorZ_free(self); }
9953         CResult_BlindedTailDecodeErrorZ& operator=(CResult_BlindedTailDecodeErrorZ&& o) { CResult_BlindedTailDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedTailDecodeErrorZ)); return *this; }
9954         LDKCResult_BlindedTailDecodeErrorZ* operator &() { return &self; }
9955         LDKCResult_BlindedTailDecodeErrorZ* operator ->() { return &self; }
9956         const LDKCResult_BlindedTailDecodeErrorZ* operator &() const { return &self; }
9957         const LDKCResult_BlindedTailDecodeErrorZ* operator ->() const { return &self; }
9958 };
9959 class CResult_SocketAddressSocketAddressParseErrorZ {
9960 private:
9961         LDKCResult_SocketAddressSocketAddressParseErrorZ self;
9962 public:
9963         CResult_SocketAddressSocketAddressParseErrorZ(const CResult_SocketAddressSocketAddressParseErrorZ&) = delete;
9964         CResult_SocketAddressSocketAddressParseErrorZ(CResult_SocketAddressSocketAddressParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SocketAddressSocketAddressParseErrorZ)); }
9965         CResult_SocketAddressSocketAddressParseErrorZ(LDKCResult_SocketAddressSocketAddressParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ)); }
9966         operator LDKCResult_SocketAddressSocketAddressParseErrorZ() && { LDKCResult_SocketAddressSocketAddressParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ)); return res; }
9967         ~CResult_SocketAddressSocketAddressParseErrorZ() { CResult_SocketAddressSocketAddressParseErrorZ_free(self); }
9968         CResult_SocketAddressSocketAddressParseErrorZ& operator=(CResult_SocketAddressSocketAddressParseErrorZ&& o) { CResult_SocketAddressSocketAddressParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SocketAddressSocketAddressParseErrorZ)); return *this; }
9969         LDKCResult_SocketAddressSocketAddressParseErrorZ* operator &() { return &self; }
9970         LDKCResult_SocketAddressSocketAddressParseErrorZ* operator ->() { return &self; }
9971         const LDKCResult_SocketAddressSocketAddressParseErrorZ* operator &() const { return &self; }
9972         const LDKCResult_SocketAddressSocketAddressParseErrorZ* operator ->() const { return &self; }
9973 };
9974 class COption_C2Tuple_u64u16ZZ {
9975 private:
9976         LDKCOption_C2Tuple_u64u16ZZ self;
9977 public:
9978         COption_C2Tuple_u64u16ZZ(const COption_C2Tuple_u64u16ZZ&) = delete;
9979         COption_C2Tuple_u64u16ZZ(COption_C2Tuple_u64u16ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_u64u16ZZ)); }
9980         COption_C2Tuple_u64u16ZZ(LDKCOption_C2Tuple_u64u16ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_u64u16ZZ)); }
9981         operator LDKCOption_C2Tuple_u64u16ZZ() && { LDKCOption_C2Tuple_u64u16ZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_u64u16ZZ)); return res; }
9982         ~COption_C2Tuple_u64u16ZZ() { COption_C2Tuple_u64u16ZZ_free(self); }
9983         COption_C2Tuple_u64u16ZZ& operator=(COption_C2Tuple_u64u16ZZ&& o) { COption_C2Tuple_u64u16ZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C2Tuple_u64u16ZZ)); return *this; }
9984         LDKCOption_C2Tuple_u64u16ZZ* operator &() { return &self; }
9985         LDKCOption_C2Tuple_u64u16ZZ* operator ->() { return &self; }
9986         const LDKCOption_C2Tuple_u64u16ZZ* operator &() const { return &self; }
9987         const LDKCOption_C2Tuple_u64u16ZZ* operator ->() const { return &self; }
9988 };
9989 class CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ {
9990 private:
9991         LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ self;
9992 public:
9993         CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(const CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&) = delete;
9994         CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); }
9995         CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); }
9996         operator LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ() && { LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); return res; }
9997         ~CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ() { CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(self); }
9998         CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ& operator=(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& o) { CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); return *this; }
9999         LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator &() { return &self; }
10000         LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator ->() { return &self; }
10001         const LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator &() const { return &self; }
10002         const LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator ->() const { return &self; }
10003 };
10004 class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ {
10005 private:
10006         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ self;
10007 public:
10008         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(const CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&) = delete;
10009         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); }
10010         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); }
10011         operator LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ() && { LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); return res; }
10012         ~CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ() { CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(self); }
10013         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ& operator=(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&& o) { CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); return *this; }
10014         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator &() { return &self; }
10015         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator ->() { return &self; }
10016         const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator &() const { return &self; }
10017         const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator ->() const { return &self; }
10018 };
10019 class CResult_ChannelDerivationParametersDecodeErrorZ {
10020 private:
10021         LDKCResult_ChannelDerivationParametersDecodeErrorZ self;
10022 public:
10023         CResult_ChannelDerivationParametersDecodeErrorZ(const CResult_ChannelDerivationParametersDecodeErrorZ&) = delete;
10024         CResult_ChannelDerivationParametersDecodeErrorZ(CResult_ChannelDerivationParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelDerivationParametersDecodeErrorZ)); }
10025         CResult_ChannelDerivationParametersDecodeErrorZ(LDKCResult_ChannelDerivationParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelDerivationParametersDecodeErrorZ)); }
10026         operator LDKCResult_ChannelDerivationParametersDecodeErrorZ() && { LDKCResult_ChannelDerivationParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelDerivationParametersDecodeErrorZ)); return res; }
10027         ~CResult_ChannelDerivationParametersDecodeErrorZ() { CResult_ChannelDerivationParametersDecodeErrorZ_free(self); }
10028         CResult_ChannelDerivationParametersDecodeErrorZ& operator=(CResult_ChannelDerivationParametersDecodeErrorZ&& o) { CResult_ChannelDerivationParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelDerivationParametersDecodeErrorZ)); return *this; }
10029         LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator &() { return &self; }
10030         LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator ->() { return &self; }
10031         const LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator &() const { return &self; }
10032         const LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator ->() const { return &self; }
10033 };
10034 class CResult_PaymentConstraintsDecodeErrorZ {
10035 private:
10036         LDKCResult_PaymentConstraintsDecodeErrorZ self;
10037 public:
10038         CResult_PaymentConstraintsDecodeErrorZ(const CResult_PaymentConstraintsDecodeErrorZ&) = delete;
10039         CResult_PaymentConstraintsDecodeErrorZ(CResult_PaymentConstraintsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentConstraintsDecodeErrorZ)); }
10040         CResult_PaymentConstraintsDecodeErrorZ(LDKCResult_PaymentConstraintsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ)); }
10041         operator LDKCResult_PaymentConstraintsDecodeErrorZ() && { LDKCResult_PaymentConstraintsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ)); return res; }
10042         ~CResult_PaymentConstraintsDecodeErrorZ() { CResult_PaymentConstraintsDecodeErrorZ_free(self); }
10043         CResult_PaymentConstraintsDecodeErrorZ& operator=(CResult_PaymentConstraintsDecodeErrorZ&& o) { CResult_PaymentConstraintsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentConstraintsDecodeErrorZ)); return *this; }
10044         LDKCResult_PaymentConstraintsDecodeErrorZ* operator &() { return &self; }
10045         LDKCResult_PaymentConstraintsDecodeErrorZ* operator ->() { return &self; }
10046         const LDKCResult_PaymentConstraintsDecodeErrorZ* operator &() const { return &self; }
10047         const LDKCResult_PaymentConstraintsDecodeErrorZ* operator ->() const { return &self; }
10048 };
10049 class C2Tuple_u32CVec_u8ZZ {
10050 private:
10051         LDKC2Tuple_u32CVec_u8ZZ self;
10052 public:
10053         C2Tuple_u32CVec_u8ZZ(const C2Tuple_u32CVec_u8ZZ&) = delete;
10054         C2Tuple_u32CVec_u8ZZ(C2Tuple_u32CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u32CVec_u8ZZ)); }
10055         C2Tuple_u32CVec_u8ZZ(LDKC2Tuple_u32CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u32CVec_u8ZZ)); }
10056         operator LDKC2Tuple_u32CVec_u8ZZ() && { LDKC2Tuple_u32CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u32CVec_u8ZZ)); return res; }
10057         ~C2Tuple_u32CVec_u8ZZ() { C2Tuple_u32CVec_u8ZZ_free(self); }
10058         C2Tuple_u32CVec_u8ZZ& operator=(C2Tuple_u32CVec_u8ZZ&& o) { C2Tuple_u32CVec_u8ZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u32CVec_u8ZZ)); return *this; }
10059         LDKC2Tuple_u32CVec_u8ZZ* operator &() { return &self; }
10060         LDKC2Tuple_u32CVec_u8ZZ* operator ->() { return &self; }
10061         const LDKC2Tuple_u32CVec_u8ZZ* operator &() const { return &self; }
10062         const LDKC2Tuple_u32CVec_u8ZZ* operator ->() const { return &self; }
10063 };
10064 class CVec_C2Tuple_PublicKeyTypeZZ {
10065 private:
10066         LDKCVec_C2Tuple_PublicKeyTypeZZ self;
10067 public:
10068         CVec_C2Tuple_PublicKeyTypeZZ(const CVec_C2Tuple_PublicKeyTypeZZ&) = delete;
10069         CVec_C2Tuple_PublicKeyTypeZZ(CVec_C2Tuple_PublicKeyTypeZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyTypeZZ)); }
10070         CVec_C2Tuple_PublicKeyTypeZZ(LDKCVec_C2Tuple_PublicKeyTypeZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ)); }
10071         operator LDKCVec_C2Tuple_PublicKeyTypeZZ() && { LDKCVec_C2Tuple_PublicKeyTypeZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ)); return res; }
10072         ~CVec_C2Tuple_PublicKeyTypeZZ() { CVec_C2Tuple_PublicKeyTypeZZ_free(self); }
10073         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; }
10074         LDKCVec_C2Tuple_PublicKeyTypeZZ* operator &() { return &self; }
10075         LDKCVec_C2Tuple_PublicKeyTypeZZ* operator ->() { return &self; }
10076         const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator &() const { return &self; }
10077         const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator ->() const { return &self; }
10078 };
10079 class CResult_OnionMessagePathNoneZ {
10080 private:
10081         LDKCResult_OnionMessagePathNoneZ self;
10082 public:
10083         CResult_OnionMessagePathNoneZ(const CResult_OnionMessagePathNoneZ&) = delete;
10084         CResult_OnionMessagePathNoneZ(CResult_OnionMessagePathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionMessagePathNoneZ)); }
10085         CResult_OnionMessagePathNoneZ(LDKCResult_OnionMessagePathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionMessagePathNoneZ)); }
10086         operator LDKCResult_OnionMessagePathNoneZ() && { LDKCResult_OnionMessagePathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionMessagePathNoneZ)); return res; }
10087         ~CResult_OnionMessagePathNoneZ() { CResult_OnionMessagePathNoneZ_free(self); }
10088         CResult_OnionMessagePathNoneZ& operator=(CResult_OnionMessagePathNoneZ&& o) { CResult_OnionMessagePathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionMessagePathNoneZ)); return *this; }
10089         LDKCResult_OnionMessagePathNoneZ* operator &() { return &self; }
10090         LDKCResult_OnionMessagePathNoneZ* operator ->() { return &self; }
10091         const LDKCResult_OnionMessagePathNoneZ* operator &() const { return &self; }
10092         const LDKCResult_OnionMessagePathNoneZ* operator ->() const { return &self; }
10093 };
10094 class CResult_RefundBolt12ParseErrorZ {
10095 private:
10096         LDKCResult_RefundBolt12ParseErrorZ self;
10097 public:
10098         CResult_RefundBolt12ParseErrorZ(const CResult_RefundBolt12ParseErrorZ&) = delete;
10099         CResult_RefundBolt12ParseErrorZ(CResult_RefundBolt12ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RefundBolt12ParseErrorZ)); }
10100         CResult_RefundBolt12ParseErrorZ(LDKCResult_RefundBolt12ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RefundBolt12ParseErrorZ)); }
10101         operator LDKCResult_RefundBolt12ParseErrorZ() && { LDKCResult_RefundBolt12ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RefundBolt12ParseErrorZ)); return res; }
10102         ~CResult_RefundBolt12ParseErrorZ() { CResult_RefundBolt12ParseErrorZ_free(self); }
10103         CResult_RefundBolt12ParseErrorZ& operator=(CResult_RefundBolt12ParseErrorZ&& o) { CResult_RefundBolt12ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RefundBolt12ParseErrorZ)); return *this; }
10104         LDKCResult_RefundBolt12ParseErrorZ* operator &() { return &self; }
10105         LDKCResult_RefundBolt12ParseErrorZ* operator ->() { return &self; }
10106         const LDKCResult_RefundBolt12ParseErrorZ* operator &() const { return &self; }
10107         const LDKCResult_RefundBolt12ParseErrorZ* operator ->() const { return &self; }
10108 };
10109 class C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ {
10110 private:
10111         LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ self;
10112 public:
10113         C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(const C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&) = delete;
10114         C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); }
10115         C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); }
10116         operator LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ() && { LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); return res; }
10117         ~C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ() { C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(self); }
10118         C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ& operator=(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& o) { C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); return *this; }
10119         LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator &() { return &self; }
10120         LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator ->() { return &self; }
10121         const LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator &() const { return &self; }
10122         const LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator ->() const { return &self; }
10123 };
10124 class CVec_C2Tuple_u64CVec_u8ZZZ {
10125 private:
10126         LDKCVec_C2Tuple_u64CVec_u8ZZZ self;
10127 public:
10128         CVec_C2Tuple_u64CVec_u8ZZZ(const CVec_C2Tuple_u64CVec_u8ZZZ&) = delete;
10129         CVec_C2Tuple_u64CVec_u8ZZZ(CVec_C2Tuple_u64CVec_u8ZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u64CVec_u8ZZZ)); }
10130         CVec_C2Tuple_u64CVec_u8ZZZ(LDKCVec_C2Tuple_u64CVec_u8ZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u64CVec_u8ZZZ)); }
10131         operator LDKCVec_C2Tuple_u64CVec_u8ZZZ() && { LDKCVec_C2Tuple_u64CVec_u8ZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u64CVec_u8ZZZ)); return res; }
10132         ~CVec_C2Tuple_u64CVec_u8ZZZ() { CVec_C2Tuple_u64CVec_u8ZZZ_free(self); }
10133         CVec_C2Tuple_u64CVec_u8ZZZ& operator=(CVec_C2Tuple_u64CVec_u8ZZZ&& o) { CVec_C2Tuple_u64CVec_u8ZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_u64CVec_u8ZZZ)); return *this; }
10134         LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator &() { return &self; }
10135         LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator ->() { return &self; }
10136         const LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator &() const { return &self; }
10137         const LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator ->() const { return &self; }
10138 };
10139 class CResult_u32GraphSyncErrorZ {
10140 private:
10141         LDKCResult_u32GraphSyncErrorZ self;
10142 public:
10143         CResult_u32GraphSyncErrorZ(const CResult_u32GraphSyncErrorZ&) = delete;
10144         CResult_u32GraphSyncErrorZ(CResult_u32GraphSyncErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); }
10145         CResult_u32GraphSyncErrorZ(LDKCResult_u32GraphSyncErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); }
10146         operator LDKCResult_u32GraphSyncErrorZ() && { LDKCResult_u32GraphSyncErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); return res; }
10147         ~CResult_u32GraphSyncErrorZ() { CResult_u32GraphSyncErrorZ_free(self); }
10148         CResult_u32GraphSyncErrorZ& operator=(CResult_u32GraphSyncErrorZ&& o) { CResult_u32GraphSyncErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); return *this; }
10149         LDKCResult_u32GraphSyncErrorZ* operator &() { return &self; }
10150         LDKCResult_u32GraphSyncErrorZ* operator ->() { return &self; }
10151         const LDKCResult_u32GraphSyncErrorZ* operator &() const { return &self; }
10152         const LDKCResult_u32GraphSyncErrorZ* operator ->() const { return &self; }
10153 };
10154 class CVec_PhantomRouteHintsZ {
10155 private:
10156         LDKCVec_PhantomRouteHintsZ self;
10157 public:
10158         CVec_PhantomRouteHintsZ(const CVec_PhantomRouteHintsZ&) = delete;
10159         CVec_PhantomRouteHintsZ(CVec_PhantomRouteHintsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); }
10160         CVec_PhantomRouteHintsZ(LDKCVec_PhantomRouteHintsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); }
10161         operator LDKCVec_PhantomRouteHintsZ() && { LDKCVec_PhantomRouteHintsZ res = self; memset(&self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); return res; }
10162         ~CVec_PhantomRouteHintsZ() { CVec_PhantomRouteHintsZ_free(self); }
10163         CVec_PhantomRouteHintsZ& operator=(CVec_PhantomRouteHintsZ&& o) { CVec_PhantomRouteHintsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); return *this; }
10164         LDKCVec_PhantomRouteHintsZ* operator &() { return &self; }
10165         LDKCVec_PhantomRouteHintsZ* operator ->() { return &self; }
10166         const LDKCVec_PhantomRouteHintsZ* operator &() const { return &self; }
10167         const LDKCVec_PhantomRouteHintsZ* operator ->() const { return &self; }
10168 };
10169 class CResult_NoneAPIErrorZ {
10170 private:
10171         LDKCResult_NoneAPIErrorZ self;
10172 public:
10173         CResult_NoneAPIErrorZ(const CResult_NoneAPIErrorZ&) = delete;
10174         CResult_NoneAPIErrorZ(CResult_NoneAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); }
10175         CResult_NoneAPIErrorZ(LDKCResult_NoneAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); }
10176         operator LDKCResult_NoneAPIErrorZ() && { LDKCResult_NoneAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); return res; }
10177         ~CResult_NoneAPIErrorZ() { CResult_NoneAPIErrorZ_free(self); }
10178         CResult_NoneAPIErrorZ& operator=(CResult_NoneAPIErrorZ&& o) { CResult_NoneAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); return *this; }
10179         LDKCResult_NoneAPIErrorZ* operator &() { return &self; }
10180         LDKCResult_NoneAPIErrorZ* operator ->() { return &self; }
10181         const LDKCResult_NoneAPIErrorZ* operator &() const { return &self; }
10182         const LDKCResult_NoneAPIErrorZ* operator ->() const { return &self; }
10183 };
10184 class CResult_Bolt12InvoiceFeaturesDecodeErrorZ {
10185 private:
10186         LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ self;
10187 public:
10188         CResult_Bolt12InvoiceFeaturesDecodeErrorZ(const CResult_Bolt12InvoiceFeaturesDecodeErrorZ&) = delete;
10189         CResult_Bolt12InvoiceFeaturesDecodeErrorZ(CResult_Bolt12InvoiceFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt12InvoiceFeaturesDecodeErrorZ)); }
10190         CResult_Bolt12InvoiceFeaturesDecodeErrorZ(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ)); }
10191         operator LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ() && { LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ)); return res; }
10192         ~CResult_Bolt12InvoiceFeaturesDecodeErrorZ() { CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(self); }
10193         CResult_Bolt12InvoiceFeaturesDecodeErrorZ& operator=(CResult_Bolt12InvoiceFeaturesDecodeErrorZ&& o) { CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt12InvoiceFeaturesDecodeErrorZ)); return *this; }
10194         LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator &() { return &self; }
10195         LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator ->() { return &self; }
10196         const LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
10197         const LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
10198 };
10199 class COption_f64Z {
10200 private:
10201         LDKCOption_f64Z self;
10202 public:
10203         COption_f64Z(const COption_f64Z&) = delete;
10204         COption_f64Z(COption_f64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_f64Z)); }
10205         COption_f64Z(LDKCOption_f64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_f64Z)); }
10206         operator LDKCOption_f64Z() && { LDKCOption_f64Z res = self; memset(&self, 0, sizeof(LDKCOption_f64Z)); return res; }
10207         ~COption_f64Z() { COption_f64Z_free(self); }
10208         COption_f64Z& operator=(COption_f64Z&& o) { COption_f64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_f64Z)); return *this; }
10209         LDKCOption_f64Z* operator &() { return &self; }
10210         LDKCOption_f64Z* operator ->() { return &self; }
10211         const LDKCOption_f64Z* operator &() const { return &self; }
10212         const LDKCOption_f64Z* operator ->() const { return &self; }
10213 };
10214 class CResult_ChannelDetailsDecodeErrorZ {
10215 private:
10216         LDKCResult_ChannelDetailsDecodeErrorZ self;
10217 public:
10218         CResult_ChannelDetailsDecodeErrorZ(const CResult_ChannelDetailsDecodeErrorZ&) = delete;
10219         CResult_ChannelDetailsDecodeErrorZ(CResult_ChannelDetailsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelDetailsDecodeErrorZ)); }
10220         CResult_ChannelDetailsDecodeErrorZ(LDKCResult_ChannelDetailsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelDetailsDecodeErrorZ)); }
10221         operator LDKCResult_ChannelDetailsDecodeErrorZ() && { LDKCResult_ChannelDetailsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelDetailsDecodeErrorZ)); return res; }
10222         ~CResult_ChannelDetailsDecodeErrorZ() { CResult_ChannelDetailsDecodeErrorZ_free(self); }
10223         CResult_ChannelDetailsDecodeErrorZ& operator=(CResult_ChannelDetailsDecodeErrorZ&& o) { CResult_ChannelDetailsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelDetailsDecodeErrorZ)); return *this; }
10224         LDKCResult_ChannelDetailsDecodeErrorZ* operator &() { return &self; }
10225         LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() { return &self; }
10226         const LDKCResult_ChannelDetailsDecodeErrorZ* operator &() const { return &self; }
10227         const LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() const { return &self; }
10228 };
10229 class CVec_PublicKeyZ {
10230 private:
10231         LDKCVec_PublicKeyZ self;
10232 public:
10233         CVec_PublicKeyZ(const CVec_PublicKeyZ&) = delete;
10234         CVec_PublicKeyZ(CVec_PublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PublicKeyZ)); }
10235         CVec_PublicKeyZ(LDKCVec_PublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PublicKeyZ)); }
10236         operator LDKCVec_PublicKeyZ() && { LDKCVec_PublicKeyZ res = self; memset(&self, 0, sizeof(LDKCVec_PublicKeyZ)); return res; }
10237         ~CVec_PublicKeyZ() { CVec_PublicKeyZ_free(self); }
10238         CVec_PublicKeyZ& operator=(CVec_PublicKeyZ&& o) { CVec_PublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PublicKeyZ)); return *this; }
10239         LDKCVec_PublicKeyZ* operator &() { return &self; }
10240         LDKCVec_PublicKeyZ* operator ->() { return &self; }
10241         const LDKCVec_PublicKeyZ* operator &() const { return &self; }
10242         const LDKCVec_PublicKeyZ* operator ->() const { return &self; }
10243 };
10244 class CVec_C2Tuple_usizeTransactionZZ {
10245 private:
10246         LDKCVec_C2Tuple_usizeTransactionZZ self;
10247 public:
10248         CVec_C2Tuple_usizeTransactionZZ(const CVec_C2Tuple_usizeTransactionZZ&) = delete;
10249         CVec_C2Tuple_usizeTransactionZZ(CVec_C2Tuple_usizeTransactionZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_usizeTransactionZZ)); }
10250         CVec_C2Tuple_usizeTransactionZZ(LDKCVec_C2Tuple_usizeTransactionZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_usizeTransactionZZ)); }
10251         operator LDKCVec_C2Tuple_usizeTransactionZZ() && { LDKCVec_C2Tuple_usizeTransactionZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_usizeTransactionZZ)); return res; }
10252         ~CVec_C2Tuple_usizeTransactionZZ() { CVec_C2Tuple_usizeTransactionZZ_free(self); }
10253         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; }
10254         LDKCVec_C2Tuple_usizeTransactionZZ* operator &() { return &self; }
10255         LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() { return &self; }
10256         const LDKCVec_C2Tuple_usizeTransactionZZ* operator &() const { return &self; }
10257         const LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() const { return &self; }
10258 };
10259 class CResult_TxRemoveInputDecodeErrorZ {
10260 private:
10261         LDKCResult_TxRemoveInputDecodeErrorZ self;
10262 public:
10263         CResult_TxRemoveInputDecodeErrorZ(const CResult_TxRemoveInputDecodeErrorZ&) = delete;
10264         CResult_TxRemoveInputDecodeErrorZ(CResult_TxRemoveInputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxRemoveInputDecodeErrorZ)); }
10265         CResult_TxRemoveInputDecodeErrorZ(LDKCResult_TxRemoveInputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxRemoveInputDecodeErrorZ)); }
10266         operator LDKCResult_TxRemoveInputDecodeErrorZ() && { LDKCResult_TxRemoveInputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxRemoveInputDecodeErrorZ)); return res; }
10267         ~CResult_TxRemoveInputDecodeErrorZ() { CResult_TxRemoveInputDecodeErrorZ_free(self); }
10268         CResult_TxRemoveInputDecodeErrorZ& operator=(CResult_TxRemoveInputDecodeErrorZ&& o) { CResult_TxRemoveInputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxRemoveInputDecodeErrorZ)); return *this; }
10269         LDKCResult_TxRemoveInputDecodeErrorZ* operator &() { return &self; }
10270         LDKCResult_TxRemoveInputDecodeErrorZ* operator ->() { return &self; }
10271         const LDKCResult_TxRemoveInputDecodeErrorZ* operator &() const { return &self; }
10272         const LDKCResult_TxRemoveInputDecodeErrorZ* operator ->() const { return &self; }
10273 };
10274 class CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ {
10275 private:
10276         LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ self;
10277 public:
10278         CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(const CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&) = delete;
10279         CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); }
10280         CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); }
10281         operator LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); return res; }
10282         ~CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ() { CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(self); }
10283         CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ& operator=(CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&& o) { CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); return *this; }
10284         LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator &() { return &self; }
10285         LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator ->() { return &self; }
10286         const LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator &() const { return &self; }
10287         const LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator ->() const { return &self; }
10288 };
10289 class CResult_OffersMessageDecodeErrorZ {
10290 private:
10291         LDKCResult_OffersMessageDecodeErrorZ self;
10292 public:
10293         CResult_OffersMessageDecodeErrorZ(const CResult_OffersMessageDecodeErrorZ&) = delete;
10294         CResult_OffersMessageDecodeErrorZ(CResult_OffersMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OffersMessageDecodeErrorZ)); }
10295         CResult_OffersMessageDecodeErrorZ(LDKCResult_OffersMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OffersMessageDecodeErrorZ)); }
10296         operator LDKCResult_OffersMessageDecodeErrorZ() && { LDKCResult_OffersMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OffersMessageDecodeErrorZ)); return res; }
10297         ~CResult_OffersMessageDecodeErrorZ() { CResult_OffersMessageDecodeErrorZ_free(self); }
10298         CResult_OffersMessageDecodeErrorZ& operator=(CResult_OffersMessageDecodeErrorZ&& o) { CResult_OffersMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OffersMessageDecodeErrorZ)); return *this; }
10299         LDKCResult_OffersMessageDecodeErrorZ* operator &() { return &self; }
10300         LDKCResult_OffersMessageDecodeErrorZ* operator ->() { return &self; }
10301         const LDKCResult_OffersMessageDecodeErrorZ* operator &() const { return &self; }
10302         const LDKCResult_OffersMessageDecodeErrorZ* operator ->() const { return &self; }
10303 };
10304 class C2Tuple_u64u64Z {
10305 private:
10306         LDKC2Tuple_u64u64Z self;
10307 public:
10308         C2Tuple_u64u64Z(const C2Tuple_u64u64Z&) = delete;
10309         C2Tuple_u64u64Z(C2Tuple_u64u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64u64Z)); }
10310         C2Tuple_u64u64Z(LDKC2Tuple_u64u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64u64Z)); }
10311         operator LDKC2Tuple_u64u64Z() && { LDKC2Tuple_u64u64Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64u64Z)); return res; }
10312         ~C2Tuple_u64u64Z() { C2Tuple_u64u64Z_free(self); }
10313         C2Tuple_u64u64Z& operator=(C2Tuple_u64u64Z&& o) { C2Tuple_u64u64Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u64u64Z)); return *this; }
10314         LDKC2Tuple_u64u64Z* operator &() { return &self; }
10315         LDKC2Tuple_u64u64Z* operator ->() { return &self; }
10316         const LDKC2Tuple_u64u64Z* operator &() const { return &self; }
10317         const LDKC2Tuple_u64u64Z* operator ->() const { return &self; }
10318 };
10319 class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
10320 private:
10321         LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ self;
10322 public:
10323         CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(const CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&) = delete;
10324         CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
10325         CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
10326         operator LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ() && { LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return res; }
10327         ~CResult_CounterpartyChannelTransactionParametersDecodeErrorZ() { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); }
10328         CResult_CounterpartyChannelTransactionParametersDecodeErrorZ& operator=(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return *this; }
10329         LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
10330         LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
10331         const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
10332         const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
10333 };
10334 class CResult_RecipientOnionFieldsDecodeErrorZ {
10335 private:
10336         LDKCResult_RecipientOnionFieldsDecodeErrorZ self;
10337 public:
10338         CResult_RecipientOnionFieldsDecodeErrorZ(const CResult_RecipientOnionFieldsDecodeErrorZ&) = delete;
10339         CResult_RecipientOnionFieldsDecodeErrorZ(CResult_RecipientOnionFieldsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecipientOnionFieldsDecodeErrorZ)); }
10340         CResult_RecipientOnionFieldsDecodeErrorZ(LDKCResult_RecipientOnionFieldsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ)); }
10341         operator LDKCResult_RecipientOnionFieldsDecodeErrorZ() && { LDKCResult_RecipientOnionFieldsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ)); return res; }
10342         ~CResult_RecipientOnionFieldsDecodeErrorZ() { CResult_RecipientOnionFieldsDecodeErrorZ_free(self); }
10343         CResult_RecipientOnionFieldsDecodeErrorZ& operator=(CResult_RecipientOnionFieldsDecodeErrorZ&& o) { CResult_RecipientOnionFieldsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecipientOnionFieldsDecodeErrorZ)); return *this; }
10344         LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator &() { return &self; }
10345         LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator ->() { return &self; }
10346         const LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator &() const { return &self; }
10347         const LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator ->() const { return &self; }
10348 };
10349 class C2Tuple_u32TxOutZ {
10350 private:
10351         LDKC2Tuple_u32TxOutZ self;
10352 public:
10353         C2Tuple_u32TxOutZ(const C2Tuple_u32TxOutZ&) = delete;
10354         C2Tuple_u32TxOutZ(C2Tuple_u32TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u32TxOutZ)); }
10355         C2Tuple_u32TxOutZ(LDKC2Tuple_u32TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u32TxOutZ)); }
10356         operator LDKC2Tuple_u32TxOutZ() && { LDKC2Tuple_u32TxOutZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u32TxOutZ)); return res; }
10357         ~C2Tuple_u32TxOutZ() { C2Tuple_u32TxOutZ_free(self); }
10358         C2Tuple_u32TxOutZ& operator=(C2Tuple_u32TxOutZ&& o) { C2Tuple_u32TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u32TxOutZ)); return *this; }
10359         LDKC2Tuple_u32TxOutZ* operator &() { return &self; }
10360         LDKC2Tuple_u32TxOutZ* operator ->() { return &self; }
10361         const LDKC2Tuple_u32TxOutZ* operator &() const { return &self; }
10362         const LDKC2Tuple_u32TxOutZ* operator ->() const { return &self; }
10363 };
10364 class CVec_UtxoZ {
10365 private:
10366         LDKCVec_UtxoZ self;
10367 public:
10368         CVec_UtxoZ(const CVec_UtxoZ&) = delete;
10369         CVec_UtxoZ(CVec_UtxoZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UtxoZ)); }
10370         CVec_UtxoZ(LDKCVec_UtxoZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UtxoZ)); }
10371         operator LDKCVec_UtxoZ() && { LDKCVec_UtxoZ res = self; memset(&self, 0, sizeof(LDKCVec_UtxoZ)); return res; }
10372         ~CVec_UtxoZ() { CVec_UtxoZ_free(self); }
10373         CVec_UtxoZ& operator=(CVec_UtxoZ&& o) { CVec_UtxoZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UtxoZ)); return *this; }
10374         LDKCVec_UtxoZ* operator &() { return &self; }
10375         LDKCVec_UtxoZ* operator ->() { return &self; }
10376         const LDKCVec_UtxoZ* operator &() const { return &self; }
10377         const LDKCVec_UtxoZ* operator ->() const { return &self; }
10378 };
10379 class CResult_ChannelConfigDecodeErrorZ {
10380 private:
10381         LDKCResult_ChannelConfigDecodeErrorZ self;
10382 public:
10383         CResult_ChannelConfigDecodeErrorZ(const CResult_ChannelConfigDecodeErrorZ&) = delete;
10384         CResult_ChannelConfigDecodeErrorZ(CResult_ChannelConfigDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelConfigDecodeErrorZ)); }
10385         CResult_ChannelConfigDecodeErrorZ(LDKCResult_ChannelConfigDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelConfigDecodeErrorZ)); }
10386         operator LDKCResult_ChannelConfigDecodeErrorZ() && { LDKCResult_ChannelConfigDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelConfigDecodeErrorZ)); return res; }
10387         ~CResult_ChannelConfigDecodeErrorZ() { CResult_ChannelConfigDecodeErrorZ_free(self); }
10388         CResult_ChannelConfigDecodeErrorZ& operator=(CResult_ChannelConfigDecodeErrorZ&& o) { CResult_ChannelConfigDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelConfigDecodeErrorZ)); return *this; }
10389         LDKCResult_ChannelConfigDecodeErrorZ* operator &() { return &self; }
10390         LDKCResult_ChannelConfigDecodeErrorZ* operator ->() { return &self; }
10391         const LDKCResult_ChannelConfigDecodeErrorZ* operator &() const { return &self; }
10392         const LDKCResult_ChannelConfigDecodeErrorZ* operator ->() const { return &self; }
10393 };
10394 class CVec_PrivateRouteZ {
10395 private:
10396         LDKCVec_PrivateRouteZ self;
10397 public:
10398         CVec_PrivateRouteZ(const CVec_PrivateRouteZ&) = delete;
10399         CVec_PrivateRouteZ(CVec_PrivateRouteZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PrivateRouteZ)); }
10400         CVec_PrivateRouteZ(LDKCVec_PrivateRouteZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PrivateRouteZ)); }
10401         operator LDKCVec_PrivateRouteZ() && { LDKCVec_PrivateRouteZ res = self; memset(&self, 0, sizeof(LDKCVec_PrivateRouteZ)); return res; }
10402         ~CVec_PrivateRouteZ() { CVec_PrivateRouteZ_free(self); }
10403         CVec_PrivateRouteZ& operator=(CVec_PrivateRouteZ&& o) { CVec_PrivateRouteZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PrivateRouteZ)); return *this; }
10404         LDKCVec_PrivateRouteZ* operator &() { return &self; }
10405         LDKCVec_PrivateRouteZ* operator ->() { return &self; }
10406         const LDKCVec_PrivateRouteZ* operator &() const { return &self; }
10407         const LDKCVec_PrivateRouteZ* operator ->() const { return &self; }
10408 };
10409 class COption_i64Z {
10410 private:
10411         LDKCOption_i64Z self;
10412 public:
10413         COption_i64Z(const COption_i64Z&) = delete;
10414         COption_i64Z(COption_i64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_i64Z)); }
10415         COption_i64Z(LDKCOption_i64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_i64Z)); }
10416         operator LDKCOption_i64Z() && { LDKCOption_i64Z res = self; memset(&self, 0, sizeof(LDKCOption_i64Z)); return res; }
10417         ~COption_i64Z() { COption_i64Z_free(self); }
10418         COption_i64Z& operator=(COption_i64Z&& o) { COption_i64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_i64Z)); return *this; }
10419         LDKCOption_i64Z* operator &() { return &self; }
10420         LDKCOption_i64Z* operator ->() { return &self; }
10421         const LDKCOption_i64Z* operator &() const { return &self; }
10422         const LDKCOption_i64Z* operator ->() const { return &self; }
10423 };
10424 class C2Tuple_ThirtyTwoBytesChannelManagerZ {
10425 private:
10426         LDKC2Tuple_ThirtyTwoBytesChannelManagerZ self;
10427 public:
10428         C2Tuple_ThirtyTwoBytesChannelManagerZ(const C2Tuple_ThirtyTwoBytesChannelManagerZ&) = delete;
10429         C2Tuple_ThirtyTwoBytesChannelManagerZ(C2Tuple_ThirtyTwoBytesChannelManagerZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelManagerZ)); }
10430         C2Tuple_ThirtyTwoBytesChannelManagerZ(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ)); }
10431         operator LDKC2Tuple_ThirtyTwoBytesChannelManagerZ() && { LDKC2Tuple_ThirtyTwoBytesChannelManagerZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ)); return res; }
10432         ~C2Tuple_ThirtyTwoBytesChannelManagerZ() { C2Tuple_ThirtyTwoBytesChannelManagerZ_free(self); }
10433         C2Tuple_ThirtyTwoBytesChannelManagerZ& operator=(C2Tuple_ThirtyTwoBytesChannelManagerZ&& o) { C2Tuple_ThirtyTwoBytesChannelManagerZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelManagerZ)); return *this; }
10434         LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator &() { return &self; }
10435         LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator ->() { return &self; }
10436         const LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator &() const { return &self; }
10437         const LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator ->() const { return &self; }
10438 };
10439 class CResult_COption_OnionMessageContentsZDecodeErrorZ {
10440 private:
10441         LDKCResult_COption_OnionMessageContentsZDecodeErrorZ self;
10442 public:
10443         CResult_COption_OnionMessageContentsZDecodeErrorZ(const CResult_COption_OnionMessageContentsZDecodeErrorZ&) = delete;
10444         CResult_COption_OnionMessageContentsZDecodeErrorZ(CResult_COption_OnionMessageContentsZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_OnionMessageContentsZDecodeErrorZ)); }
10445         CResult_COption_OnionMessageContentsZDecodeErrorZ(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ)); }
10446         operator LDKCResult_COption_OnionMessageContentsZDecodeErrorZ() && { LDKCResult_COption_OnionMessageContentsZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ)); return res; }
10447         ~CResult_COption_OnionMessageContentsZDecodeErrorZ() { CResult_COption_OnionMessageContentsZDecodeErrorZ_free(self); }
10448         CResult_COption_OnionMessageContentsZDecodeErrorZ& operator=(CResult_COption_OnionMessageContentsZDecodeErrorZ&& o) { CResult_COption_OnionMessageContentsZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_OnionMessageContentsZDecodeErrorZ)); return *this; }
10449         LDKCResult_COption_OnionMessageContentsZDecodeErrorZ* operator &() { return &self; }
10450         LDKCResult_COption_OnionMessageContentsZDecodeErrorZ* operator ->() { return &self; }
10451         const LDKCResult_COption_OnionMessageContentsZDecodeErrorZ* operator &() const { return &self; }
10452         const LDKCResult_COption_OnionMessageContentsZDecodeErrorZ* operator ->() const { return &self; }
10453 };
10454 class C2Tuple_u64CVec_u8ZZ {
10455 private:
10456         LDKC2Tuple_u64CVec_u8ZZ self;
10457 public:
10458         C2Tuple_u64CVec_u8ZZ(const C2Tuple_u64CVec_u8ZZ&) = delete;
10459         C2Tuple_u64CVec_u8ZZ(C2Tuple_u64CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64CVec_u8ZZ)); }
10460         C2Tuple_u64CVec_u8ZZ(LDKC2Tuple_u64CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64CVec_u8ZZ)); }
10461         operator LDKC2Tuple_u64CVec_u8ZZ() && { LDKC2Tuple_u64CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64CVec_u8ZZ)); return res; }
10462         ~C2Tuple_u64CVec_u8ZZ() { C2Tuple_u64CVec_u8ZZ_free(self); }
10463         C2Tuple_u64CVec_u8ZZ& operator=(C2Tuple_u64CVec_u8ZZ&& o) { C2Tuple_u64CVec_u8ZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u64CVec_u8ZZ)); return *this; }
10464         LDKC2Tuple_u64CVec_u8ZZ* operator &() { return &self; }
10465         LDKC2Tuple_u64CVec_u8ZZ* operator ->() { return &self; }
10466         const LDKC2Tuple_u64CVec_u8ZZ* operator &() const { return &self; }
10467         const LDKC2Tuple_u64CVec_u8ZZ* operator ->() const { return &self; }
10468 };
10469 class CResult_OfferBolt12ParseErrorZ {
10470 private:
10471         LDKCResult_OfferBolt12ParseErrorZ self;
10472 public:
10473         CResult_OfferBolt12ParseErrorZ(const CResult_OfferBolt12ParseErrorZ&) = delete;
10474         CResult_OfferBolt12ParseErrorZ(CResult_OfferBolt12ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OfferBolt12ParseErrorZ)); }
10475         CResult_OfferBolt12ParseErrorZ(LDKCResult_OfferBolt12ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OfferBolt12ParseErrorZ)); }
10476         operator LDKCResult_OfferBolt12ParseErrorZ() && { LDKCResult_OfferBolt12ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OfferBolt12ParseErrorZ)); return res; }
10477         ~CResult_OfferBolt12ParseErrorZ() { CResult_OfferBolt12ParseErrorZ_free(self); }
10478         CResult_OfferBolt12ParseErrorZ& operator=(CResult_OfferBolt12ParseErrorZ&& o) { CResult_OfferBolt12ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OfferBolt12ParseErrorZ)); return *this; }
10479         LDKCResult_OfferBolt12ParseErrorZ* operator &() { return &self; }
10480         LDKCResult_OfferBolt12ParseErrorZ* operator ->() { return &self; }
10481         const LDKCResult_OfferBolt12ParseErrorZ* operator &() const { return &self; }
10482         const LDKCResult_OfferBolt12ParseErrorZ* operator ->() const { return &self; }
10483 };
10484 class CResult_ThirtyTwoBytesRetryableSendFailureZ {
10485 private:
10486         LDKCResult_ThirtyTwoBytesRetryableSendFailureZ self;
10487 public:
10488         CResult_ThirtyTwoBytesRetryableSendFailureZ(const CResult_ThirtyTwoBytesRetryableSendFailureZ&) = delete;
10489         CResult_ThirtyTwoBytesRetryableSendFailureZ(CResult_ThirtyTwoBytesRetryableSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesRetryableSendFailureZ)); }
10490         CResult_ThirtyTwoBytesRetryableSendFailureZ(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ)); }
10491         operator LDKCResult_ThirtyTwoBytesRetryableSendFailureZ() && { LDKCResult_ThirtyTwoBytesRetryableSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ)); return res; }
10492         ~CResult_ThirtyTwoBytesRetryableSendFailureZ() { CResult_ThirtyTwoBytesRetryableSendFailureZ_free(self); }
10493         CResult_ThirtyTwoBytesRetryableSendFailureZ& operator=(CResult_ThirtyTwoBytesRetryableSendFailureZ&& o) { CResult_ThirtyTwoBytesRetryableSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesRetryableSendFailureZ)); return *this; }
10494         LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator &() { return &self; }
10495         LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator ->() { return &self; }
10496         const LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator &() const { return &self; }
10497         const LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator ->() const { return &self; }
10498 };
10499 class CVec_MonitorEventZ {
10500 private:
10501         LDKCVec_MonitorEventZ self;
10502 public:
10503         CVec_MonitorEventZ(const CVec_MonitorEventZ&) = delete;
10504         CVec_MonitorEventZ(CVec_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorEventZ)); }
10505         CVec_MonitorEventZ(LDKCVec_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorEventZ)); }
10506         operator LDKCVec_MonitorEventZ() && { LDKCVec_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorEventZ)); return res; }
10507         ~CVec_MonitorEventZ() { CVec_MonitorEventZ_free(self); }
10508         CVec_MonitorEventZ& operator=(CVec_MonitorEventZ&& o) { CVec_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MonitorEventZ)); return *this; }
10509         LDKCVec_MonitorEventZ* operator &() { return &self; }
10510         LDKCVec_MonitorEventZ* operator ->() { return &self; }
10511         const LDKCVec_MonitorEventZ* operator &() const { return &self; }
10512         const LDKCVec_MonitorEventZ* operator ->() const { return &self; }
10513 };
10514 class CResult_ShutdownDecodeErrorZ {
10515 private:
10516         LDKCResult_ShutdownDecodeErrorZ self;
10517 public:
10518         CResult_ShutdownDecodeErrorZ(const CResult_ShutdownDecodeErrorZ&) = delete;
10519         CResult_ShutdownDecodeErrorZ(CResult_ShutdownDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownDecodeErrorZ)); }
10520         CResult_ShutdownDecodeErrorZ(LDKCResult_ShutdownDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownDecodeErrorZ)); }
10521         operator LDKCResult_ShutdownDecodeErrorZ() && { LDKCResult_ShutdownDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownDecodeErrorZ)); return res; }
10522         ~CResult_ShutdownDecodeErrorZ() { CResult_ShutdownDecodeErrorZ_free(self); }
10523         CResult_ShutdownDecodeErrorZ& operator=(CResult_ShutdownDecodeErrorZ&& o) { CResult_ShutdownDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownDecodeErrorZ)); return *this; }
10524         LDKCResult_ShutdownDecodeErrorZ* operator &() { return &self; }
10525         LDKCResult_ShutdownDecodeErrorZ* operator ->() { return &self; }
10526         const LDKCResult_ShutdownDecodeErrorZ* operator &() const { return &self; }
10527         const LDKCResult_ShutdownDecodeErrorZ* operator ->() const { return &self; }
10528 };
10529 class CResult_BigSizeDecodeErrorZ {
10530 private:
10531         LDKCResult_BigSizeDecodeErrorZ self;
10532 public:
10533         CResult_BigSizeDecodeErrorZ(const CResult_BigSizeDecodeErrorZ&) = delete;
10534         CResult_BigSizeDecodeErrorZ(CResult_BigSizeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BigSizeDecodeErrorZ)); }
10535         CResult_BigSizeDecodeErrorZ(LDKCResult_BigSizeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BigSizeDecodeErrorZ)); }
10536         operator LDKCResult_BigSizeDecodeErrorZ() && { LDKCResult_BigSizeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BigSizeDecodeErrorZ)); return res; }
10537         ~CResult_BigSizeDecodeErrorZ() { CResult_BigSizeDecodeErrorZ_free(self); }
10538         CResult_BigSizeDecodeErrorZ& operator=(CResult_BigSizeDecodeErrorZ&& o) { CResult_BigSizeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BigSizeDecodeErrorZ)); return *this; }
10539         LDKCResult_BigSizeDecodeErrorZ* operator &() { return &self; }
10540         LDKCResult_BigSizeDecodeErrorZ* operator ->() { return &self; }
10541         const LDKCResult_BigSizeDecodeErrorZ* operator &() const { return &self; }
10542         const LDKCResult_BigSizeDecodeErrorZ* operator ->() const { return &self; }
10543 };
10544 class CResult_TxOutUtxoLookupErrorZ {
10545 private:
10546         LDKCResult_TxOutUtxoLookupErrorZ self;
10547 public:
10548         CResult_TxOutUtxoLookupErrorZ(const CResult_TxOutUtxoLookupErrorZ&) = delete;
10549         CResult_TxOutUtxoLookupErrorZ(CResult_TxOutUtxoLookupErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxOutUtxoLookupErrorZ)); }
10550         CResult_TxOutUtxoLookupErrorZ(LDKCResult_TxOutUtxoLookupErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxOutUtxoLookupErrorZ)); }
10551         operator LDKCResult_TxOutUtxoLookupErrorZ() && { LDKCResult_TxOutUtxoLookupErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxOutUtxoLookupErrorZ)); return res; }
10552         ~CResult_TxOutUtxoLookupErrorZ() { CResult_TxOutUtxoLookupErrorZ_free(self); }
10553         CResult_TxOutUtxoLookupErrorZ& operator=(CResult_TxOutUtxoLookupErrorZ&& o) { CResult_TxOutUtxoLookupErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxOutUtxoLookupErrorZ)); return *this; }
10554         LDKCResult_TxOutUtxoLookupErrorZ* operator &() { return &self; }
10555         LDKCResult_TxOutUtxoLookupErrorZ* operator ->() { return &self; }
10556         const LDKCResult_TxOutUtxoLookupErrorZ* operator &() const { return &self; }
10557         const LDKCResult_TxOutUtxoLookupErrorZ* operator ->() const { return &self; }
10558 };
10559 class CResult_BlindedPathNoneZ {
10560 private:
10561         LDKCResult_BlindedPathNoneZ self;
10562 public:
10563         CResult_BlindedPathNoneZ(const CResult_BlindedPathNoneZ&) = delete;
10564         CResult_BlindedPathNoneZ(CResult_BlindedPathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPathNoneZ)); }
10565         CResult_BlindedPathNoneZ(LDKCResult_BlindedPathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPathNoneZ)); }
10566         operator LDKCResult_BlindedPathNoneZ() && { LDKCResult_BlindedPathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPathNoneZ)); return res; }
10567         ~CResult_BlindedPathNoneZ() { CResult_BlindedPathNoneZ_free(self); }
10568         CResult_BlindedPathNoneZ& operator=(CResult_BlindedPathNoneZ&& o) { CResult_BlindedPathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPathNoneZ)); return *this; }
10569         LDKCResult_BlindedPathNoneZ* operator &() { return &self; }
10570         LDKCResult_BlindedPathNoneZ* operator ->() { return &self; }
10571         const LDKCResult_BlindedPathNoneZ* operator &() const { return &self; }
10572         const LDKCResult_BlindedPathNoneZ* operator ->() const { return &self; }
10573 };
10574 class COption_usizeZ {
10575 private:
10576         LDKCOption_usizeZ self;
10577 public:
10578         COption_usizeZ(const COption_usizeZ&) = delete;
10579         COption_usizeZ(COption_usizeZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_usizeZ)); }
10580         COption_usizeZ(LDKCOption_usizeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_usizeZ)); }
10581         operator LDKCOption_usizeZ() && { LDKCOption_usizeZ res = self; memset(&self, 0, sizeof(LDKCOption_usizeZ)); return res; }
10582         ~COption_usizeZ() { COption_usizeZ_free(self); }
10583         COption_usizeZ& operator=(COption_usizeZ&& o) { COption_usizeZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_usizeZ)); return *this; }
10584         LDKCOption_usizeZ* operator &() { return &self; }
10585         LDKCOption_usizeZ* operator ->() { return &self; }
10586         const LDKCOption_usizeZ* operator &() const { return &self; }
10587         const LDKCOption_usizeZ* operator ->() const { return &self; }
10588 };
10589 class CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ {
10590 private:
10591         LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ self;
10592 public:
10593         CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(const CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&) = delete;
10594         CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); }
10595         CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); }
10596         operator LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ() && { LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); return res; }
10597         ~CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ() { CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(self); }
10598         CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ& operator=(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& o) { CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); return *this; }
10599         LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator &() { return &self; }
10600         LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator ->() { return &self; }
10601         const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator &() const { return &self; }
10602         const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator ->() const { return &self; }
10603 };
10604 class CResult_NoneNoneZ {
10605 private:
10606         LDKCResult_NoneNoneZ self;
10607 public:
10608         CResult_NoneNoneZ(const CResult_NoneNoneZ&) = delete;
10609         CResult_NoneNoneZ(CResult_NoneNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneNoneZ)); }
10610         CResult_NoneNoneZ(LDKCResult_NoneNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneNoneZ)); }
10611         operator LDKCResult_NoneNoneZ() && { LDKCResult_NoneNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneNoneZ)); return res; }
10612         ~CResult_NoneNoneZ() { CResult_NoneNoneZ_free(self); }
10613         CResult_NoneNoneZ& operator=(CResult_NoneNoneZ&& o) { CResult_NoneNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneNoneZ)); return *this; }
10614         LDKCResult_NoneNoneZ* operator &() { return &self; }
10615         LDKCResult_NoneNoneZ* operator ->() { return &self; }
10616         const LDKCResult_NoneNoneZ* operator &() const { return &self; }
10617         const LDKCResult_NoneNoneZ* operator ->() const { return &self; }
10618 };
10619 class CResult_boolPeerHandleErrorZ {
10620 private:
10621         LDKCResult_boolPeerHandleErrorZ self;
10622 public:
10623         CResult_boolPeerHandleErrorZ(const CResult_boolPeerHandleErrorZ&) = delete;
10624         CResult_boolPeerHandleErrorZ(CResult_boolPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); }
10625         CResult_boolPeerHandleErrorZ(LDKCResult_boolPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); }
10626         operator LDKCResult_boolPeerHandleErrorZ() && { LDKCResult_boolPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); return res; }
10627         ~CResult_boolPeerHandleErrorZ() { CResult_boolPeerHandleErrorZ_free(self); }
10628         CResult_boolPeerHandleErrorZ& operator=(CResult_boolPeerHandleErrorZ&& o) { CResult_boolPeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); return *this; }
10629         LDKCResult_boolPeerHandleErrorZ* operator &() { return &self; }
10630         LDKCResult_boolPeerHandleErrorZ* operator ->() { return &self; }
10631         const LDKCResult_boolPeerHandleErrorZ* operator &() const { return &self; }
10632         const LDKCResult_boolPeerHandleErrorZ* operator ->() const { return &self; }
10633 };
10634 class CResult_ChannelUpdateDecodeErrorZ {
10635 private:
10636         LDKCResult_ChannelUpdateDecodeErrorZ self;
10637 public:
10638         CResult_ChannelUpdateDecodeErrorZ(const CResult_ChannelUpdateDecodeErrorZ&) = delete;
10639         CResult_ChannelUpdateDecodeErrorZ(CResult_ChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); }
10640         CResult_ChannelUpdateDecodeErrorZ(LDKCResult_ChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); }
10641         operator LDKCResult_ChannelUpdateDecodeErrorZ() && { LDKCResult_ChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); return res; }
10642         ~CResult_ChannelUpdateDecodeErrorZ() { CResult_ChannelUpdateDecodeErrorZ_free(self); }
10643         CResult_ChannelUpdateDecodeErrorZ& operator=(CResult_ChannelUpdateDecodeErrorZ&& o) { CResult_ChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); return *this; }
10644         LDKCResult_ChannelUpdateDecodeErrorZ* operator &() { return &self; }
10645         LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() { return &self; }
10646         const LDKCResult_ChannelUpdateDecodeErrorZ* operator &() const { return &self; }
10647         const LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
10648 };
10649 class CVec_APIErrorZ {
10650 private:
10651         LDKCVec_APIErrorZ self;
10652 public:
10653         CVec_APIErrorZ(const CVec_APIErrorZ&) = delete;
10654         CVec_APIErrorZ(CVec_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_APIErrorZ)); }
10655         CVec_APIErrorZ(LDKCVec_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_APIErrorZ)); }
10656         operator LDKCVec_APIErrorZ() && { LDKCVec_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCVec_APIErrorZ)); return res; }
10657         ~CVec_APIErrorZ() { CVec_APIErrorZ_free(self); }
10658         CVec_APIErrorZ& operator=(CVec_APIErrorZ&& o) { CVec_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_APIErrorZ)); return *this; }
10659         LDKCVec_APIErrorZ* operator &() { return &self; }
10660         LDKCVec_APIErrorZ* operator ->() { return &self; }
10661         const LDKCVec_APIErrorZ* operator &() const { return &self; }
10662         const LDKCVec_APIErrorZ* operator ->() const { return &self; }
10663 };
10664 class COption_TxOutZ {
10665 private:
10666         LDKCOption_TxOutZ self;
10667 public:
10668         COption_TxOutZ(const COption_TxOutZ&) = delete;
10669         COption_TxOutZ(COption_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_TxOutZ)); }
10670         COption_TxOutZ(LDKCOption_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_TxOutZ)); }
10671         operator LDKCOption_TxOutZ() && { LDKCOption_TxOutZ res = self; memset(&self, 0, sizeof(LDKCOption_TxOutZ)); return res; }
10672         ~COption_TxOutZ() { COption_TxOutZ_free(self); }
10673         COption_TxOutZ& operator=(COption_TxOutZ&& o) { COption_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_TxOutZ)); return *this; }
10674         LDKCOption_TxOutZ* operator &() { return &self; }
10675         LDKCOption_TxOutZ* operator ->() { return &self; }
10676         const LDKCOption_TxOutZ* operator &() const { return &self; }
10677         const LDKCOption_TxOutZ* operator ->() const { return &self; }
10678 };
10679 class COption_ClosureReasonZ {
10680 private:
10681         LDKCOption_ClosureReasonZ self;
10682 public:
10683         COption_ClosureReasonZ(const COption_ClosureReasonZ&) = delete;
10684         COption_ClosureReasonZ(COption_ClosureReasonZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ClosureReasonZ)); }
10685         COption_ClosureReasonZ(LDKCOption_ClosureReasonZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ClosureReasonZ)); }
10686         operator LDKCOption_ClosureReasonZ() && { LDKCOption_ClosureReasonZ res = self; memset(&self, 0, sizeof(LDKCOption_ClosureReasonZ)); return res; }
10687         ~COption_ClosureReasonZ() { COption_ClosureReasonZ_free(self); }
10688         COption_ClosureReasonZ& operator=(COption_ClosureReasonZ&& o) { COption_ClosureReasonZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ClosureReasonZ)); return *this; }
10689         LDKCOption_ClosureReasonZ* operator &() { return &self; }
10690         LDKCOption_ClosureReasonZ* operator ->() { return &self; }
10691         const LDKCOption_ClosureReasonZ* operator &() const { return &self; }
10692         const LDKCOption_ClosureReasonZ* operator ->() const { return &self; }
10693 };
10694 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ {
10695 private:
10696         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ self;
10697 public:
10698         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&) = delete;
10699         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); }
10700         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); }
10701         operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); return res; }
10702         ~CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(self); }
10703         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ& operator=(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&& o) { CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); return *this; }
10704         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator &() { return &self; }
10705         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator ->() { return &self; }
10706         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator &() const { return &self; }
10707         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator ->() const { return &self; }
10708 };
10709 class CResult_TransactionU16LenLimitedDecodeErrorZ {
10710 private:
10711         LDKCResult_TransactionU16LenLimitedDecodeErrorZ self;
10712 public:
10713         CResult_TransactionU16LenLimitedDecodeErrorZ(const CResult_TransactionU16LenLimitedDecodeErrorZ&) = delete;
10714         CResult_TransactionU16LenLimitedDecodeErrorZ(CResult_TransactionU16LenLimitedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedDecodeErrorZ)); }
10715         CResult_TransactionU16LenLimitedDecodeErrorZ(LDKCResult_TransactionU16LenLimitedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionU16LenLimitedDecodeErrorZ)); }
10716         operator LDKCResult_TransactionU16LenLimitedDecodeErrorZ() && { LDKCResult_TransactionU16LenLimitedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionU16LenLimitedDecodeErrorZ)); return res; }
10717         ~CResult_TransactionU16LenLimitedDecodeErrorZ() { CResult_TransactionU16LenLimitedDecodeErrorZ_free(self); }
10718         CResult_TransactionU16LenLimitedDecodeErrorZ& operator=(CResult_TransactionU16LenLimitedDecodeErrorZ&& o) { CResult_TransactionU16LenLimitedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedDecodeErrorZ)); return *this; }
10719         LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator &() { return &self; }
10720         LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator ->() { return &self; }
10721         const LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator &() const { return &self; }
10722         const LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator ->() const { return &self; }
10723 };
10724 class CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ {
10725 private:
10726         LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ self;
10727 public:
10728         CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(const CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&) = delete;
10729         CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); }
10730         CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); }
10731         operator LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ() && { LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); return res; }
10732         ~CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ() { CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(self); }
10733         CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ& operator=(CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&& o) { CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); return *this; }
10734         LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator &() { return &self; }
10735         LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator ->() { return &self; }
10736         const LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator &() const { return &self; }
10737         const LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator ->() const { return &self; }
10738 };
10739 class CResult_CounterpartyForwardingInfoDecodeErrorZ {
10740 private:
10741         LDKCResult_CounterpartyForwardingInfoDecodeErrorZ self;
10742 public:
10743         CResult_CounterpartyForwardingInfoDecodeErrorZ(const CResult_CounterpartyForwardingInfoDecodeErrorZ&) = delete;
10744         CResult_CounterpartyForwardingInfoDecodeErrorZ(CResult_CounterpartyForwardingInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyForwardingInfoDecodeErrorZ)); }
10745         CResult_CounterpartyForwardingInfoDecodeErrorZ(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ)); }
10746         operator LDKCResult_CounterpartyForwardingInfoDecodeErrorZ() && { LDKCResult_CounterpartyForwardingInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ)); return res; }
10747         ~CResult_CounterpartyForwardingInfoDecodeErrorZ() { CResult_CounterpartyForwardingInfoDecodeErrorZ_free(self); }
10748         CResult_CounterpartyForwardingInfoDecodeErrorZ& operator=(CResult_CounterpartyForwardingInfoDecodeErrorZ&& o) { CResult_CounterpartyForwardingInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyForwardingInfoDecodeErrorZ)); return *this; }
10749         LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator &() { return &self; }
10750         LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator ->() { return &self; }
10751         const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator &() const { return &self; }
10752         const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator ->() const { return &self; }
10753 };
10754 class CResult_OpenChannelV2DecodeErrorZ {
10755 private:
10756         LDKCResult_OpenChannelV2DecodeErrorZ self;
10757 public:
10758         CResult_OpenChannelV2DecodeErrorZ(const CResult_OpenChannelV2DecodeErrorZ&) = delete;
10759         CResult_OpenChannelV2DecodeErrorZ(CResult_OpenChannelV2DecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OpenChannelV2DecodeErrorZ)); }
10760         CResult_OpenChannelV2DecodeErrorZ(LDKCResult_OpenChannelV2DecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OpenChannelV2DecodeErrorZ)); }
10761         operator LDKCResult_OpenChannelV2DecodeErrorZ() && { LDKCResult_OpenChannelV2DecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OpenChannelV2DecodeErrorZ)); return res; }
10762         ~CResult_OpenChannelV2DecodeErrorZ() { CResult_OpenChannelV2DecodeErrorZ_free(self); }
10763         CResult_OpenChannelV2DecodeErrorZ& operator=(CResult_OpenChannelV2DecodeErrorZ&& o) { CResult_OpenChannelV2DecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OpenChannelV2DecodeErrorZ)); return *this; }
10764         LDKCResult_OpenChannelV2DecodeErrorZ* operator &() { return &self; }
10765         LDKCResult_OpenChannelV2DecodeErrorZ* operator ->() { return &self; }
10766         const LDKCResult_OpenChannelV2DecodeErrorZ* operator &() const { return &self; }
10767         const LDKCResult_OpenChannelV2DecodeErrorZ* operator ->() const { return &self; }
10768 };
10769 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ {
10770 private:
10771         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ self;
10772 public:
10773         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(const CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&) = delete;
10774         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); }
10775         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); }
10776         operator LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); return res; }
10777         ~CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ() { CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(self); }
10778         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ& operator=(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&& o) { CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); return *this; }
10779         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator &() { return &self; }
10780         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator ->() { return &self; }
10781         const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator &() const { return &self; }
10782         const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator ->() const { return &self; }
10783 };
10784 class C2Tuple_PublicKeyOnionMessageZ {
10785 private:
10786         LDKC2Tuple_PublicKeyOnionMessageZ self;
10787 public:
10788         C2Tuple_PublicKeyOnionMessageZ(const C2Tuple_PublicKeyOnionMessageZ&) = delete;
10789         C2Tuple_PublicKeyOnionMessageZ(C2Tuple_PublicKeyOnionMessageZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyOnionMessageZ)); }
10790         C2Tuple_PublicKeyOnionMessageZ(LDKC2Tuple_PublicKeyOnionMessageZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyOnionMessageZ)); }
10791         operator LDKC2Tuple_PublicKeyOnionMessageZ() && { LDKC2Tuple_PublicKeyOnionMessageZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyOnionMessageZ)); return res; }
10792         ~C2Tuple_PublicKeyOnionMessageZ() { C2Tuple_PublicKeyOnionMessageZ_free(self); }
10793         C2Tuple_PublicKeyOnionMessageZ& operator=(C2Tuple_PublicKeyOnionMessageZ&& o) { C2Tuple_PublicKeyOnionMessageZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyOnionMessageZ)); return *this; }
10794         LDKC2Tuple_PublicKeyOnionMessageZ* operator &() { return &self; }
10795         LDKC2Tuple_PublicKeyOnionMessageZ* operator ->() { return &self; }
10796         const LDKC2Tuple_PublicKeyOnionMessageZ* operator &() const { return &self; }
10797         const LDKC2Tuple_PublicKeyOnionMessageZ* operator ->() const { return &self; }
10798 };
10799 class CResult_RouteDecodeErrorZ {
10800 private:
10801         LDKCResult_RouteDecodeErrorZ self;
10802 public:
10803         CResult_RouteDecodeErrorZ(const CResult_RouteDecodeErrorZ&) = delete;
10804         CResult_RouteDecodeErrorZ(CResult_RouteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); }
10805         CResult_RouteDecodeErrorZ(LDKCResult_RouteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); }
10806         operator LDKCResult_RouteDecodeErrorZ() && { LDKCResult_RouteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); return res; }
10807         ~CResult_RouteDecodeErrorZ() { CResult_RouteDecodeErrorZ_free(self); }
10808         CResult_RouteDecodeErrorZ& operator=(CResult_RouteDecodeErrorZ&& o) { CResult_RouteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); return *this; }
10809         LDKCResult_RouteDecodeErrorZ* operator &() { return &self; }
10810         LDKCResult_RouteDecodeErrorZ* operator ->() { return &self; }
10811         const LDKCResult_RouteDecodeErrorZ* operator &() const { return &self; }
10812         const LDKCResult_RouteDecodeErrorZ* operator ->() const { return &self; }
10813 };
10814 class CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ {
10815 private:
10816         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ self;
10817 public:
10818         CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(const CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&) = delete;
10819         CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); }
10820         CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); }
10821         operator LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ() && { LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); return res; }
10822         ~CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ() { CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(self); }
10823         CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ& operator=(CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&& o) { CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); return *this; }
10824         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator &() { return &self; }
10825         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator ->() { return &self; }
10826         const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator &() const { return &self; }
10827         const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator ->() const { return &self; }
10828 };
10829 class COption_NoneZ {
10830 private:
10831         LDKCOption_NoneZ self;
10832 public:
10833         COption_NoneZ(const COption_NoneZ&) = delete;
10834         COption_NoneZ(COption_NoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NoneZ)); }
10835         COption_NoneZ(LDKCOption_NoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NoneZ)); }
10836         operator LDKCOption_NoneZ() && { LDKCOption_NoneZ res = self; memset(&self, 0, sizeof(LDKCOption_NoneZ)); return res; }
10837         ~COption_NoneZ() { COption_NoneZ_free(self); }
10838         COption_NoneZ& operator=(COption_NoneZ&& o) { COption_NoneZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NoneZ)); return *this; }
10839         LDKCOption_NoneZ* operator &() { return &self; }
10840         LDKCOption_NoneZ* operator ->() { return &self; }
10841         const LDKCOption_NoneZ* operator &() const { return &self; }
10842         const LDKCOption_NoneZ* operator ->() const { return &self; }
10843 };
10844 class CResult_TxAddOutputDecodeErrorZ {
10845 private:
10846         LDKCResult_TxAddOutputDecodeErrorZ self;
10847 public:
10848         CResult_TxAddOutputDecodeErrorZ(const CResult_TxAddOutputDecodeErrorZ&) = delete;
10849         CResult_TxAddOutputDecodeErrorZ(CResult_TxAddOutputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAddOutputDecodeErrorZ)); }
10850         CResult_TxAddOutputDecodeErrorZ(LDKCResult_TxAddOutputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAddOutputDecodeErrorZ)); }
10851         operator LDKCResult_TxAddOutputDecodeErrorZ() && { LDKCResult_TxAddOutputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAddOutputDecodeErrorZ)); return res; }
10852         ~CResult_TxAddOutputDecodeErrorZ() { CResult_TxAddOutputDecodeErrorZ_free(self); }
10853         CResult_TxAddOutputDecodeErrorZ& operator=(CResult_TxAddOutputDecodeErrorZ&& o) { CResult_TxAddOutputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAddOutputDecodeErrorZ)); return *this; }
10854         LDKCResult_TxAddOutputDecodeErrorZ* operator &() { return &self; }
10855         LDKCResult_TxAddOutputDecodeErrorZ* operator ->() { return &self; }
10856         const LDKCResult_TxAddOutputDecodeErrorZ* operator &() const { return &self; }
10857         const LDKCResult_TxAddOutputDecodeErrorZ* operator ->() const { return &self; }
10858 };
10859 class COption_CVec_u8ZZ {
10860 private:
10861         LDKCOption_CVec_u8ZZ self;
10862 public:
10863         COption_CVec_u8ZZ(const COption_CVec_u8ZZ&) = delete;
10864         COption_CVec_u8ZZ(COption_CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_u8ZZ)); }
10865         COption_CVec_u8ZZ(LDKCOption_CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_u8ZZ)); }
10866         operator LDKCOption_CVec_u8ZZ() && { LDKCOption_CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_u8ZZ)); return res; }
10867         ~COption_CVec_u8ZZ() { COption_CVec_u8ZZ_free(self); }
10868         COption_CVec_u8ZZ& operator=(COption_CVec_u8ZZ&& o) { COption_CVec_u8ZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_CVec_u8ZZ)); return *this; }
10869         LDKCOption_CVec_u8ZZ* operator &() { return &self; }
10870         LDKCOption_CVec_u8ZZ* operator ->() { return &self; }
10871         const LDKCOption_CVec_u8ZZ* operator &() const { return &self; }
10872         const LDKCOption_CVec_u8ZZ* operator ->() const { return &self; }
10873 };
10874
10875 inline LDKPublicKey ChannelSigner::get_per_commitment_point(uint64_t idx) {
10876         LDKPublicKey ret = (self.get_per_commitment_point)(self.this_arg, idx);
10877         return ret;
10878 }
10879 inline LDKThirtyTwoBytes ChannelSigner::release_commitment_secret(uint64_t idx) {
10880         LDKThirtyTwoBytes ret = (self.release_commitment_secret)(self.this_arg, idx);
10881         return ret;
10882 }
10883 inline LDK::CResult_NoneNoneZ ChannelSigner::validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ preimages) {
10884         LDK::CResult_NoneNoneZ ret = (self.validate_holder_commitment)(self.this_arg, holder_tx, preimages);
10885         return ret;
10886 }
10887 inline LDKThirtyTwoBytes ChannelSigner::channel_keys_id() {
10888         LDKThirtyTwoBytes ret = (self.channel_keys_id)(self.this_arg);
10889         return ret;
10890 }
10891 inline void ChannelSigner::provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters) {
10892         (self.provide_channel_parameters)(self.this_arg, channel_parameters);
10893 }
10894 inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ EcdsaChannelSigner::sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ preimages) {
10895         LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ ret = (self.sign_counterparty_commitment)(self.this_arg, commitment_tx, preimages);
10896         return ret;
10897 }
10898 inline LDK::CResult_NoneNoneZ EcdsaChannelSigner::validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]) {
10899         LDK::CResult_NoneNoneZ ret = (self.validate_counterparty_revocation)(self.this_arg, idx, secret);
10900         return ret;
10901 }
10902 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx) {
10903         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_commitment)(self.this_arg, commitment_tx);
10904         return ret;
10905 }
10906 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_justice_revoked_output(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]) {
10907         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_justice_revoked_output)(self.this_arg, justice_tx, input, amount, per_commitment_key);
10908         return ret;
10909 }
10910 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::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) {
10911         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_justice_revoked_htlc)(self.this_arg, justice_tx, input, amount, per_commitment_key, htlc);
10912         return ret;
10913 }
10914 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor) {
10915         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_htlc_transaction)(self.this_arg, htlc_tx, input, htlc_descriptor);
10916         return ret;
10917 }
10918 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::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) {
10919         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_counterparty_htlc_transaction)(self.this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
10920         return ret;
10921 }
10922 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx) {
10923         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_closing_transaction)(self.this_arg, closing_tx);
10924         return ret;
10925 }
10926 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input) {
10927         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_anchor_input)(self.this_arg, anchor_tx, input);
10928         return ret;
10929 }
10930 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg) {
10931         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_channel_announcement_with_funding_key)(self.this_arg, msg);
10932         return ret;
10933 }
10934 inline LDKThirtyTwoBytes EntropySource::get_secure_random_bytes() {
10935         LDKThirtyTwoBytes ret = (self.get_secure_random_bytes)(self.this_arg);
10936         return ret;
10937 }
10938 inline LDKThirtyTwoBytes NodeSigner::get_inbound_payment_key_material() {
10939         LDKThirtyTwoBytes ret = (self.get_inbound_payment_key_material)(self.this_arg);
10940         return ret;
10941 }
10942 inline LDK::CResult_PublicKeyNoneZ NodeSigner::get_node_id(enum LDKRecipient recipient) {
10943         LDK::CResult_PublicKeyNoneZ ret = (self.get_node_id)(self.this_arg, recipient);
10944         return ret;
10945 }
10946 inline LDK::CResult_ThirtyTwoBytesNoneZ NodeSigner::ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak) {
10947         LDK::CResult_ThirtyTwoBytesNoneZ ret = (self.ecdh)(self.this_arg, recipient, other_key, tweak);
10948         return ret;
10949 }
10950 inline LDK::CResult_RecoverableSignatureNoneZ NodeSigner::sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient) {
10951         LDK::CResult_RecoverableSignatureNoneZ ret = (self.sign_invoice)(self.this_arg, hrp_bytes, invoice_data, recipient);
10952         return ret;
10953 }
10954 inline LDK::CResult_SchnorrSignatureNoneZ NodeSigner::sign_bolt12_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR invoice_request) {
10955         LDK::CResult_SchnorrSignatureNoneZ ret = (self.sign_bolt12_invoice_request)(self.this_arg, invoice_request);
10956         return ret;
10957 }
10958 inline LDK::CResult_SchnorrSignatureNoneZ NodeSigner::sign_bolt12_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR invoice) {
10959         LDK::CResult_SchnorrSignatureNoneZ ret = (self.sign_bolt12_invoice)(self.this_arg, invoice);
10960         return ret;
10961 }
10962 inline LDK::CResult_ECDSASignatureNoneZ NodeSigner::sign_gossip_message(struct LDKUnsignedGossipMessage msg) {
10963         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_gossip_message)(self.this_arg, msg);
10964         return ret;
10965 }
10966 inline LDKThirtyTwoBytes SignerProvider::generate_channel_keys_id(bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id) {
10967         LDKThirtyTwoBytes ret = (self.generate_channel_keys_id)(self.this_arg, inbound, channel_value_satoshis, user_channel_id);
10968         return ret;
10969 }
10970 inline LDK::WriteableEcdsaChannelSigner SignerProvider::derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id) {
10971         LDK::WriteableEcdsaChannelSigner ret = (self.derive_channel_signer)(self.this_arg, channel_value_satoshis, channel_keys_id);
10972         return ret;
10973 }
10974 inline LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ SignerProvider::read_chan_signer(struct LDKu8slice reader) {
10975         LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ ret = (self.read_chan_signer)(self.this_arg, reader);
10976         return ret;
10977 }
10978 inline LDK::CResult_CVec_u8ZNoneZ SignerProvider::get_destination_script() {
10979         LDK::CResult_CVec_u8ZNoneZ ret = (self.get_destination_script)(self.this_arg);
10980         return ret;
10981 }
10982 inline LDK::CResult_ShutdownScriptNoneZ SignerProvider::get_shutdown_scriptpubkey() {
10983         LDK::CResult_ShutdownScriptNoneZ ret = (self.get_shutdown_scriptpubkey)(self.this_arg);
10984         return ret;
10985 }
10986 inline LDK::CResult_RouteLightningErrorZ Router::find_route(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKInFlightHtlcs inflight_htlcs) {
10987         LDK::CResult_RouteLightningErrorZ ret = (self.find_route)(self.this_arg, payer, route_params, first_hops, inflight_htlcs);
10988         return ret;
10989 }
10990 inline LDK::CResult_RouteLightningErrorZ Router::find_route_with_id(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKInFlightHtlcs inflight_htlcs, struct LDKThirtyTwoBytes _payment_hash, struct LDKThirtyTwoBytes _payment_id) {
10991         LDK::CResult_RouteLightningErrorZ ret = (self.find_route_with_id)(self.this_arg, payer, route_params, first_hops, inflight_htlcs, _payment_hash, _payment_id);
10992         return ret;
10993 }
10994 inline uint64_t ScoreLookUp::channel_penalty_msat(uint64_t short_channel_id, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params) {
10995         uint64_t ret = (self.channel_penalty_msat)(self.this_arg, short_channel_id, source, target, usage, score_params);
10996         return ret;
10997 }
10998 inline void ScoreUpdate::payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id) {
10999         (self.payment_path_failed)(self.this_arg, path, short_channel_id);
11000 }
11001 inline void ScoreUpdate::payment_path_successful(const struct LDKPath *NONNULL_PTR path) {
11002         (self.payment_path_successful)(self.this_arg, path);
11003 }
11004 inline void ScoreUpdate::probe_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id) {
11005         (self.probe_failed)(self.this_arg, path, short_channel_id);
11006 }
11007 inline void ScoreUpdate::probe_successful(const struct LDKPath *NONNULL_PTR path) {
11008         (self.probe_successful)(self.this_arg, path);
11009 }
11010 inline LDK::ScoreLookUp LockableScore::read_lock() {
11011         LDK::ScoreLookUp ret = (self.read_lock)(self.this_arg);
11012         return ret;
11013 }
11014 inline LDK::ScoreUpdate LockableScore::write_lock() {
11015         LDK::ScoreUpdate ret = (self.write_lock)(self.this_arg);
11016         return ret;
11017 }
11018 inline void Listen::filtered_block_connected(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
11019         (self.filtered_block_connected)(self.this_arg, header, txdata, height);
11020 }
11021 inline void Listen::block_connected(struct LDKu8slice block, uint32_t height) {
11022         (self.block_connected)(self.this_arg, block, height);
11023 }
11024 inline void Listen::block_disconnected(const uint8_t (*header)[80], uint32_t height) {
11025         (self.block_disconnected)(self.this_arg, header, height);
11026 }
11027 inline void Confirm::transactions_confirmed(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
11028         (self.transactions_confirmed)(self.this_arg, header, txdata, height);
11029 }
11030 inline void Confirm::transaction_unconfirmed(const uint8_t (*txid)[32]) {
11031         (self.transaction_unconfirmed)(self.this_arg, txid);
11032 }
11033 inline void Confirm::best_block_updated(const uint8_t (*header)[80], uint32_t height) {
11034         (self.best_block_updated)(self.this_arg, header, height);
11035 }
11036 inline LDK::CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ Confirm::get_relevant_txids() {
11037         LDK::CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ ret = (self.get_relevant_txids)(self.this_arg);
11038         return ret;
11039 }
11040 inline LDK::CResult_ChannelMonitorUpdateStatusNoneZ Watch::watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor) {
11041         LDK::CResult_ChannelMonitorUpdateStatusNoneZ ret = (self.watch_channel)(self.this_arg, funding_txo, monitor);
11042         return ret;
11043 }
11044 inline LDK::ChannelMonitorUpdateStatus Watch::update_channel(struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update) {
11045         LDK::ChannelMonitorUpdateStatus ret = (self.update_channel)(self.this_arg, funding_txo, update);
11046         return ret;
11047 }
11048 inline LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Watch::release_pending_monitor_events() {
11049         LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret = (self.release_pending_monitor_events)(self.this_arg);
11050         return ret;
11051 }
11052 inline void Filter::register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey) {
11053         (self.register_tx)(self.this_arg, txid, script_pubkey);
11054 }
11055 inline void Filter::register_output(struct LDKWatchedOutput output) {
11056         (self.register_output)(self.this_arg, output);
11057 }
11058 inline LDK::CResult_CoinSelectionNoneZ CoinSelectionSource::select_confirmed_utxos(struct LDKThirtyTwoBytes claim_id, struct LDKCVec_InputZ must_spend, struct LDKCVec_TxOutZ must_pay_to, uint32_t target_feerate_sat_per_1000_weight) {
11059         LDK::CResult_CoinSelectionNoneZ ret = (self.select_confirmed_utxos)(self.this_arg, claim_id, must_spend, must_pay_to, target_feerate_sat_per_1000_weight);
11060         return ret;
11061 }
11062 inline LDK::CResult_TransactionNoneZ CoinSelectionSource::sign_tx(struct LDKTransaction tx) {
11063         LDK::CResult_TransactionNoneZ ret = (self.sign_tx)(self.this_arg, tx);
11064         return ret;
11065 }
11066 inline LDK::CResult_CVec_UtxoZNoneZ WalletSource::list_confirmed_utxos() {
11067         LDK::CResult_CVec_UtxoZNoneZ ret = (self.list_confirmed_utxos)(self.this_arg);
11068         return ret;
11069 }
11070 inline LDK::CResult_CVec_u8ZNoneZ WalletSource::get_change_script() {
11071         LDK::CResult_CVec_u8ZNoneZ ret = (self.get_change_script)(self.this_arg);
11072         return ret;
11073 }
11074 inline LDK::CResult_TransactionNoneZ WalletSource::sign_tx(struct LDKTransaction tx) {
11075         LDK::CResult_TransactionNoneZ ret = (self.sign_tx)(self.this_arg, tx);
11076         return ret;
11077 }
11078 inline LDK::CResult_NoneLightningErrorZ CustomMessageHandler::handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id) {
11079         LDK::CResult_NoneLightningErrorZ ret = (self.handle_custom_message)(self.this_arg, msg, sender_node_id);
11080         return ret;
11081 }
11082 inline LDK::CVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler::get_and_clear_pending_msg() {
11083         LDK::CVec_C2Tuple_PublicKeyTypeZZ ret = (self.get_and_clear_pending_msg)(self.this_arg);
11084         return ret;
11085 }
11086 inline LDK::NodeFeatures CustomMessageHandler::provided_node_features() {
11087         LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
11088         return ret;
11089 }
11090 inline LDK::InitFeatures CustomMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
11091         LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
11092         return ret;
11093 }
11094 inline uintptr_t SocketDescriptor::send_data(struct LDKu8slice data, bool resume_read) {
11095         uintptr_t ret = (self.send_data)(self.this_arg, data, resume_read);
11096         return ret;
11097 }
11098 inline void SocketDescriptor::disconnect_socket() {
11099         (self.disconnect_socket)(self.this_arg);
11100 }
11101 inline bool SocketDescriptor::eq(const struct LDKSocketDescriptor *NONNULL_PTR other_arg) {
11102         bool ret = (self.eq)(self.this_arg, other_arg);
11103         return ret;
11104 }
11105 inline uint64_t SocketDescriptor::hash() {
11106         uint64_t ret = (self.hash)(self.this_arg);
11107         return ret;
11108 }
11109 inline LDK::CResult_CVec_u8ZIOErrorZ KVStore::read(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key) {
11110         LDK::CResult_CVec_u8ZIOErrorZ ret = (self.read)(self.this_arg, primary_namespace, secondary_namespace, key);
11111         return ret;
11112 }
11113 inline LDK::CResult_NoneIOErrorZ KVStore::write(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, struct LDKu8slice buf) {
11114         LDK::CResult_NoneIOErrorZ ret = (self.write)(self.this_arg, primary_namespace, secondary_namespace, key, buf);
11115         return ret;
11116 }
11117 inline LDK::CResult_NoneIOErrorZ KVStore::remove(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, bool lazy) {
11118         LDK::CResult_NoneIOErrorZ ret = (self.remove)(self.this_arg, primary_namespace, secondary_namespace, key, lazy);
11119         return ret;
11120 }
11121 inline LDK::CResult_CVec_StrZIOErrorZ KVStore::list(struct LDKStr primary_namespace, struct LDKStr secondary_namespace) {
11122         LDK::CResult_CVec_StrZIOErrorZ ret = (self.list)(self.this_arg, primary_namespace, secondary_namespace);
11123         return ret;
11124 }
11125 inline LDK::CResult_NoneIOErrorZ Persister::persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager) {
11126         LDK::CResult_NoneIOErrorZ ret = (self.persist_manager)(self.this_arg, channel_manager);
11127         return ret;
11128 }
11129 inline LDK::CResult_NoneIOErrorZ Persister::persist_graph(const struct LDKNetworkGraph *NONNULL_PTR network_graph) {
11130         LDK::CResult_NoneIOErrorZ ret = (self.persist_graph)(self.this_arg, network_graph);
11131         return ret;
11132 }
11133 inline LDK::CResult_NoneIOErrorZ Persister::persist_scorer(const struct LDKWriteableScore *NONNULL_PTR scorer) {
11134         LDK::CResult_NoneIOErrorZ ret = (self.persist_scorer)(self.this_arg, scorer);
11135         return ret;
11136 }
11137 inline void ChannelMessageHandler::handle_open_channel(struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg) {
11138         (self.handle_open_channel)(self.this_arg, their_node_id, msg);
11139 }
11140 inline void ChannelMessageHandler::handle_open_channel_v2(struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg) {
11141         (self.handle_open_channel_v2)(self.this_arg, their_node_id, msg);
11142 }
11143 inline void ChannelMessageHandler::handle_accept_channel(struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg) {
11144         (self.handle_accept_channel)(self.this_arg, their_node_id, msg);
11145 }
11146 inline void ChannelMessageHandler::handle_accept_channel_v2(struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg) {
11147         (self.handle_accept_channel_v2)(self.this_arg, their_node_id, msg);
11148 }
11149 inline void ChannelMessageHandler::handle_funding_created(struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg) {
11150         (self.handle_funding_created)(self.this_arg, their_node_id, msg);
11151 }
11152 inline void ChannelMessageHandler::handle_funding_signed(struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg) {
11153         (self.handle_funding_signed)(self.this_arg, their_node_id, msg);
11154 }
11155 inline void ChannelMessageHandler::handle_channel_ready(struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg) {
11156         (self.handle_channel_ready)(self.this_arg, their_node_id, msg);
11157 }
11158 inline void ChannelMessageHandler::handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg) {
11159         (self.handle_shutdown)(self.this_arg, their_node_id, msg);
11160 }
11161 inline void ChannelMessageHandler::handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg) {
11162         (self.handle_closing_signed)(self.this_arg, their_node_id, msg);
11163 }
11164 inline void ChannelMessageHandler::handle_tx_add_input(struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg) {
11165         (self.handle_tx_add_input)(self.this_arg, their_node_id, msg);
11166 }
11167 inline void ChannelMessageHandler::handle_tx_add_output(struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg) {
11168         (self.handle_tx_add_output)(self.this_arg, their_node_id, msg);
11169 }
11170 inline void ChannelMessageHandler::handle_tx_remove_input(struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg) {
11171         (self.handle_tx_remove_input)(self.this_arg, their_node_id, msg);
11172 }
11173 inline void ChannelMessageHandler::handle_tx_remove_output(struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg) {
11174         (self.handle_tx_remove_output)(self.this_arg, their_node_id, msg);
11175 }
11176 inline void ChannelMessageHandler::handle_tx_complete(struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg) {
11177         (self.handle_tx_complete)(self.this_arg, their_node_id, msg);
11178 }
11179 inline void ChannelMessageHandler::handle_tx_signatures(struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg) {
11180         (self.handle_tx_signatures)(self.this_arg, their_node_id, msg);
11181 }
11182 inline void ChannelMessageHandler::handle_tx_init_rbf(struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg) {
11183         (self.handle_tx_init_rbf)(self.this_arg, their_node_id, msg);
11184 }
11185 inline void ChannelMessageHandler::handle_tx_ack_rbf(struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg) {
11186         (self.handle_tx_ack_rbf)(self.this_arg, their_node_id, msg);
11187 }
11188 inline void ChannelMessageHandler::handle_tx_abort(struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg) {
11189         (self.handle_tx_abort)(self.this_arg, their_node_id, msg);
11190 }
11191 inline void ChannelMessageHandler::handle_update_add_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg) {
11192         (self.handle_update_add_htlc)(self.this_arg, their_node_id, msg);
11193 }
11194 inline void ChannelMessageHandler::handle_update_fulfill_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg) {
11195         (self.handle_update_fulfill_htlc)(self.this_arg, their_node_id, msg);
11196 }
11197 inline void ChannelMessageHandler::handle_update_fail_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg) {
11198         (self.handle_update_fail_htlc)(self.this_arg, their_node_id, msg);
11199 }
11200 inline void ChannelMessageHandler::handle_update_fail_malformed_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg) {
11201         (self.handle_update_fail_malformed_htlc)(self.this_arg, their_node_id, msg);
11202 }
11203 inline void ChannelMessageHandler::handle_commitment_signed(struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg) {
11204         (self.handle_commitment_signed)(self.this_arg, their_node_id, msg);
11205 }
11206 inline void ChannelMessageHandler::handle_revoke_and_ack(struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg) {
11207         (self.handle_revoke_and_ack)(self.this_arg, their_node_id, msg);
11208 }
11209 inline void ChannelMessageHandler::handle_update_fee(struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg) {
11210         (self.handle_update_fee)(self.this_arg, their_node_id, msg);
11211 }
11212 inline void ChannelMessageHandler::handle_announcement_signatures(struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg) {
11213         (self.handle_announcement_signatures)(self.this_arg, their_node_id, msg);
11214 }
11215 inline void ChannelMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id) {
11216         (self.peer_disconnected)(self.this_arg, their_node_id);
11217 }
11218 inline LDK::CResult_NoneNoneZ ChannelMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound) {
11219         LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, msg, inbound);
11220         return ret;
11221 }
11222 inline void ChannelMessageHandler::handle_channel_reestablish(struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg) {
11223         (self.handle_channel_reestablish)(self.this_arg, their_node_id, msg);
11224 }
11225 inline void ChannelMessageHandler::handle_channel_update(struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg) {
11226         (self.handle_channel_update)(self.this_arg, their_node_id, msg);
11227 }
11228 inline void ChannelMessageHandler::handle_error(struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg) {
11229         (self.handle_error)(self.this_arg, their_node_id, msg);
11230 }
11231 inline LDK::NodeFeatures ChannelMessageHandler::provided_node_features() {
11232         LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
11233         return ret;
11234 }
11235 inline LDK::InitFeatures ChannelMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
11236         LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
11237         return ret;
11238 }
11239 inline LDK::COption_CVec_ThirtyTwoBytesZZ ChannelMessageHandler::get_chain_hashes() {
11240         LDK::COption_CVec_ThirtyTwoBytesZZ ret = (self.get_chain_hashes)(self.this_arg);
11241         return ret;
11242 }
11243 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg) {
11244         LDK::CResult_boolLightningErrorZ ret = (self.handle_node_announcement)(self.this_arg, msg);
11245         return ret;
11246 }
11247 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg) {
11248         LDK::CResult_boolLightningErrorZ ret = (self.handle_channel_announcement)(self.this_arg, msg);
11249         return ret;
11250 }
11251 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_channel_update(const struct LDKChannelUpdate *NONNULL_PTR msg) {
11252         LDK::CResult_boolLightningErrorZ ret = (self.handle_channel_update)(self.this_arg, msg);
11253         return ret;
11254 }
11255 inline LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler::get_next_channel_announcement(uint64_t starting_point) {
11256         LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = (self.get_next_channel_announcement)(self.this_arg, starting_point);
11257         return ret;
11258 }
11259 inline LDK::NodeAnnouncement RoutingMessageHandler::get_next_node_announcement(struct LDKNodeId starting_point) {
11260         LDK::NodeAnnouncement ret = (self.get_next_node_announcement)(self.this_arg, starting_point);
11261         return ret;
11262 }
11263 inline LDK::CResult_NoneNoneZ RoutingMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound) {
11264         LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, init, inbound);
11265         return ret;
11266 }
11267 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_reply_channel_range(struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg) {
11268         LDK::CResult_NoneLightningErrorZ ret = (self.handle_reply_channel_range)(self.this_arg, their_node_id, msg);
11269         return ret;
11270 }
11271 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_reply_short_channel_ids_end(struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg) {
11272         LDK::CResult_NoneLightningErrorZ ret = (self.handle_reply_short_channel_ids_end)(self.this_arg, their_node_id, msg);
11273         return ret;
11274 }
11275 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_query_channel_range(struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg) {
11276         LDK::CResult_NoneLightningErrorZ ret = (self.handle_query_channel_range)(self.this_arg, their_node_id, msg);
11277         return ret;
11278 }
11279 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg) {
11280         LDK::CResult_NoneLightningErrorZ ret = (self.handle_query_short_channel_ids)(self.this_arg, their_node_id, msg);
11281         return ret;
11282 }
11283 inline bool RoutingMessageHandler::processing_queue_high() {
11284         bool ret = (self.processing_queue_high)(self.this_arg);
11285         return ret;
11286 }
11287 inline LDK::NodeFeatures RoutingMessageHandler::provided_node_features() {
11288         LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
11289         return ret;
11290 }
11291 inline LDK::InitFeatures RoutingMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
11292         LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
11293         return ret;
11294 }
11295 inline void OnionMessageHandler::handle_onion_message(struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg) {
11296         (self.handle_onion_message)(self.this_arg, peer_node_id, msg);
11297 }
11298 inline LDK::OnionMessage OnionMessageHandler::next_onion_message_for_peer(struct LDKPublicKey peer_node_id) {
11299         LDK::OnionMessage ret = (self.next_onion_message_for_peer)(self.this_arg, peer_node_id);
11300         return ret;
11301 }
11302 inline LDK::CResult_NoneNoneZ OnionMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound) {
11303         LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, init, inbound);
11304         return ret;
11305 }
11306 inline void OnionMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id) {
11307         (self.peer_disconnected)(self.this_arg, their_node_id);
11308 }
11309 inline LDK::NodeFeatures OnionMessageHandler::provided_node_features() {
11310         LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
11311         return ret;
11312 }
11313 inline LDK::InitFeatures OnionMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
11314         LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
11315         return ret;
11316 }
11317 inline void Logger::log(const struct LDKRecord *NONNULL_PTR record) {
11318         (self.log)(self.this_arg, record);
11319 }
11320 inline void FutureCallback::call() {
11321         (self.call)(self.this_arg);
11322 }
11323 inline LDK::COption_OffersMessageZ OffersMessageHandler::handle_message(struct LDKOffersMessage message) {
11324         LDK::COption_OffersMessageZ ret = (self.handle_message)(self.this_arg, message);
11325         return ret;
11326 }
11327 inline LDK::CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ OffersMessageHandler::release_pending_messages() {
11328         LDK::CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ ret = (self.release_pending_messages)(self.this_arg);
11329         return ret;
11330 }
11331 inline void BroadcasterInterface::broadcast_transactions(struct LDKCVec_TransactionZ txs) {
11332         (self.broadcast_transactions)(self.this_arg, txs);
11333 }
11334 inline uint32_t FeeEstimator::get_est_sat_per_1000_weight(enum LDKConfirmationTarget confirmation_target) {
11335         uint32_t ret = (self.get_est_sat_per_1000_weight)(self.this_arg, confirmation_target);
11336         return ret;
11337 }
11338 inline uint64_t OnionMessageContents::tlv_type() {
11339         uint64_t ret = (self.tlv_type)(self.this_arg);
11340         return ret;
11341 }
11342 inline LDK::CVec_MessageSendEventZ MessageSendEventsProvider::get_and_clear_pending_msg_events() {
11343         LDK::CVec_MessageSendEventZ ret = (self.get_and_clear_pending_msg_events)(self.this_arg);
11344         return ret;
11345 }
11346 inline void EventsProvider::process_pending_events(struct LDKEventHandler handler) {
11347         (self.process_pending_events)(self.this_arg, handler);
11348 }
11349 inline void EventHandler::handle_event(struct LDKEvent event) {
11350         (self.handle_event)(self.this_arg, event);
11351 }
11352 inline LDK::CResult_COption_TypeZDecodeErrorZ CustomMessageReader::read(uint16_t message_type, struct LDKu8slice buffer) {
11353         LDK::CResult_COption_TypeZDecodeErrorZ ret = (self.read)(self.this_arg, message_type, buffer);
11354         return ret;
11355 }
11356 inline uint16_t Type::type_id() {
11357         uint16_t ret = (self.type_id)(self.this_arg);
11358         return ret;
11359 }
11360 inline LDK::Str Type::debug_str() {
11361         LDK::Str ret = (self.debug_str)(self.this_arg);
11362         return ret;
11363 }
11364 inline LDK::UtxoResult UtxoLookup::get_utxo(const uint8_t (*chain_hash)[32], uint64_t short_channel_id) {
11365         LDK::UtxoResult ret = (self.get_utxo)(self.this_arg, chain_hash, short_channel_id);
11366         return ret;
11367 }
11368 inline LDK::CResult_OnionMessagePathNoneZ MessageRouter::find_path(struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination) {
11369         LDK::CResult_OnionMessagePathNoneZ ret = (self.find_path)(self.this_arg, sender, peers, destination);
11370         return ret;
11371 }
11372 inline LDK::COption_OnionMessageContentsZ CustomOnionMessageHandler::handle_custom_message(struct LDKOnionMessageContents msg) {
11373         LDK::COption_OnionMessageContentsZ ret = (self.handle_custom_message)(self.this_arg, msg);
11374         return ret;
11375 }
11376 inline LDK::CResult_COption_OnionMessageContentsZDecodeErrorZ CustomOnionMessageHandler::read_custom_message(uint64_t message_type, struct LDKu8slice buffer) {
11377         LDK::CResult_COption_OnionMessageContentsZDecodeErrorZ ret = (self.read_custom_message)(self.this_arg, message_type, buffer);
11378         return ret;
11379 }
11380 inline LDK::CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ CustomOnionMessageHandler::release_pending_custom_messages() {
11381         LDK::CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ ret = (self.release_pending_custom_messages)(self.this_arg);
11382         return ret;
11383 }
11384 inline LDK::ChannelMonitorUpdateStatus Persist::persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
11385         LDK::ChannelMonitorUpdateStatus ret = (self.persist_new_channel)(self.this_arg, channel_id, data, update_id);
11386         return ret;
11387 }
11388 inline LDK::ChannelMonitorUpdateStatus Persist::update_persisted_channel(struct LDKOutPoint channel_id, struct LDKChannelMonitorUpdate update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
11389         LDK::ChannelMonitorUpdateStatus ret = (self.update_persisted_channel)(self.this_arg, channel_id, update, data, update_id);
11390         return ret;
11391 }
11392 }