_ 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 Recipient;
  21 class EntropySource;
  22 class NodeSigner;
  23 class SignerProvider;
  24 class InMemorySigner;
  25 class KeysManager;
  26 class PhantomKeysManager;
  27 class BackgroundProcessor;
  28 class GossipSync;
  29 class DefaultRouter;
  30 class Router;
  31 class ScorerAccountingForInFlightHtlcs;
  32 class InFlightHtlcs;
  33 class RouteHop;
  34 class BlindedTail;
  35 class Path;
  36 class Route;
  37 class RouteParameters;
  38 class PaymentParameters;
  39 class Payee;
  40 class RouteHint;
  41 class RouteHintHop;
  42 class FirstHopCandidate;
  43 class PublicHopCandidate;
  44 class PrivateHopCandidate;
  45 class BlindedPathCandidate;
  46 class OneHopBlindedPathCandidate;
  47 class CandidateRouteHop;
  48 class ScoreLookUp;
  49 class ScoreUpdate;
  50 class Score;
  51 class LockableScore;
  52 class WriteableScore;
  53 class MultiThreadedLockableScore;
  54 class MultiThreadedScoreLockRead;
  55 class MultiThreadedScoreLockWrite;
  56 class ChannelUsage;
  57 class FixedPenaltyScorer;
  58 class ProbabilisticScorer;
  59 class ProbabilisticScoringFeeParameters;
  60 class ProbabilisticScoringDecayParameters;
  61 class BestBlock;
  62 class Listen;
  63 class Confirm;
  64 class ChannelMonitorUpdateStatus;
  65 class Watch;
  66 class Filter;
  67 class WatchedOutput;
  68 class InitFeatures;
  69 class NodeFeatures;
  70 class ChannelFeatures;
  71 class Bolt11InvoiceFeatures;
  72 class OfferFeatures;
  73 class InvoiceRequestFeatures;
  74 class Bolt12InvoiceFeatures;
  75 class BlindedHopFeatures;
  76 class ChannelTypeFeatures;
  77 class Offer;
  78 class Amount;
  79 class Quantity;
  80 class NodeId;
  81 class NetworkGraph;
  82 class ReadOnlyNetworkGraph;
  83 class NetworkUpdate;
  84 class P2PGossipSync;
  85 class ChannelUpdateInfo;
  86 class ChannelInfo;
  87 class DirectedChannelInfo;
  88 class EffectiveCapacity;
  89 class RoutingFees;
  90 class NodeAnnouncementInfo;
  91 class NodeAlias;
  92 class NodeInfo;
  93 class InboundHTLCErr;
  94 class AnchorDescriptor;
  95 class BumpTransactionEvent;
  96 class Input;
  97 class Utxo;
  98 class CoinSelection;
  99 class CoinSelectionSource;
 100 class WalletSource;
 101 class Wallet;
 102 class BumpTransactionEventHandler;
 103 class PendingHTLCRouting;
 104 class BlindedForward;
 105 class PendingHTLCInfo;
 106 class BlindedFailure;
 107 class FailureCode;
 108 class ChannelManager;
 109 class ChainParameters;
 110 class CounterpartyForwardingInfo;
 111 class ChannelCounterparty;
 112 class ChannelDetails;
 113 class ChannelShutdownState;
 114 class RecentPaymentDetails;
 115 class PhantomRouteHints;
 116 class ChannelManagerReadArgs;
 117 class ChannelHandshakeConfig;
 118 class ChannelHandshakeLimits;
 119 class MaxDustHTLCExposure;
 120 class ChannelConfig;
 121 class ChannelConfigUpdate;
 122 class UserConfig;
 123 class APIError;
 124 class TaggedHash;
 125 class EcdsaChannelSigner;
 126 class WriteableEcdsaChannelSigner;
 127 class ChannelMonitorUpdate;
 128 class MonitorEvent;
 129 class HTLCUpdate;
 130 class Balance;
 131 class ChannelMonitor;
 132 class ExpandedKey;
 133 class CustomMessageHandler;
 134 class IgnoringMessageHandler;
 135 class ErroringMessageHandler;
 136 class MessageHandler;
 137 class SocketDescriptor;
 138 class PeerHandleError;
 139 class PeerManager;
 140 class GraphSyncError;
 141 class RapidGossipSync;
 142 class KVStore;
 143 class Persister;
 144 class MonitorUpdatingPersister;
 145 class UnsignedInvoiceRequest;
 146 class InvoiceRequest;
 147 class VerifiedInvoiceRequest;
 148 class DecodeError;
 149 class Init;
 150 class ErrorMessage;
 151 class WarningMessage;
 152 class Ping;
 153 class Pong;
 154 class OpenChannel;
 155 class OpenChannelV2;
 156 class AcceptChannel;
 157 class AcceptChannelV2;
 158 class FundingCreated;
 159 class FundingSigned;
 160 class ChannelReady;
 161 class Stfu;
 162 class Splice;
 163 class SpliceAck;
 164 class SpliceLocked;
 165 class TxAddInput;
 166 class TxAddOutput;
 167 class TxRemoveInput;
 168 class TxRemoveOutput;
 169 class TxComplete;
 170 class TxSignatures;
 171 class TxInitRbf;
 172 class TxAckRbf;
 173 class TxAbort;
 174 class Shutdown;
 175 class ClosingSignedFeeRange;
 176 class ClosingSigned;
 177 class UpdateAddHTLC;
 178 class OnionMessage;
 179 class UpdateFulfillHTLC;
 180 class UpdateFailHTLC;
 181 class UpdateFailMalformedHTLC;
 182 class CommitmentSigned;
 183 class RevokeAndACK;
 184 class UpdateFee;
 185 class ChannelReestablish;
 186 class AnnouncementSignatures;
 187 class SocketAddress;
 188 class SocketAddressParseError;
 189 class UnsignedGossipMessage;
 190 class UnsignedNodeAnnouncement;
 191 class NodeAnnouncement;
 192 class UnsignedChannelAnnouncement;
 193 class ChannelAnnouncement;
 194 class UnsignedChannelUpdate;
 195 class ChannelUpdate;
 196 class QueryChannelRange;
 197 class ReplyChannelRange;
 198 class QueryShortChannelIds;
 199 class ReplyShortChannelIdsEnd;
 200 class GossipTimestampFilter;
 201 class ErrorAction;
 202 class LightningError;
 203 class CommitmentUpdate;
 204 class ChannelMessageHandler;
 205 class RoutingMessageHandler;
 206 class OnionMessageHandler;
 207 class FinalOnionHopData;
 208 class OnionPacket;
 209 class Level;
 210 class Record;
 211 class Logger;
 212 class FutureCallback;
 213 class Future;
 214 class Sleeper;
 215 class OffersMessageHandler;
 216 class OffersMessage;
 217 class HTLCClaim;
 218 class CounterpartyCommitmentSecrets;
 219 class TxCreationKeys;
 220 class ChannelPublicKeys;
 221 class HTLCOutputInCommitment;
 222 class ChannelTransactionParameters;
 223 class CounterpartyChannelTransactionParameters;
 224 class DirectedChannelTransactionParameters;
 225 class HolderCommitmentTransaction;
 226 class BuiltCommitmentTransaction;
 227 class ClosingTransaction;
 228 class TrustedClosingTransaction;
 229 class CommitmentTransaction;
 230 class TrustedCommitmentTransaction;
 231 class ShutdownScript;
 232 class InvalidShutdownScript;
 233 class Bolt12ParseError;
 234 class Bolt12SemanticError;
 235 class BroadcasterInterface;
 236 class ConfirmationTarget;
 237 class FeeEstimator;
 238 class Packet;
 239 class ParsedOnionMessageContents;
 240 class OnionMessageContents;
 241 class PaymentPurpose;
 242 class ClaimedHTLC;
 243 class PathFailure;
 244 class ClosureReason;
 245 class HTLCDestination;
 246 class PaymentFailureReason;
 247 class Event;
 248 class MessageSendEvent;
 249 class MessageSendEventsProvider;
 250 class EventsProvider;
 251 class EventHandler;
 252 class Bolt11ParseError;
 253 class ParseOrSemanticError;
 254 class Bolt11Invoice;
 255 class SignedRawBolt11Invoice;
 256 class RawBolt11Invoice;
 257 class RawDataPart;
 258 class PositiveTimestamp;
 259 class SiPrefix;
 260 class Currency;
 261 class Sha256;
 262 class Description;
 263 class PayeePubKey;
 264 class ExpiryTime;
 265 class MinFinalCltvExpiryDelta;
 266 class Fallback;
 267 class Bolt11InvoiceSignature;
 268 class PrivateRoute;
 269 class CreationError;
 270 class Bolt11SemanticError;
 271 class SignOrCreationError;
 272 class OutPoint;
 273 class BigSize;
 274 class Hostname;
 275 class TransactionU16LenLimited;
 276 class UntrustedString;
 277 class PrintableString;
 278 class CustomMessageReader;
 279 class Type;
 280 class ForwardNode;
 281 class ForwardTlvs;
 282 class ReceiveTlvs;
 283 class PaymentRelay;
 284 class PaymentConstraints;
 285 class UtxoLookupError;
 286 class UtxoResult;
 287 class UtxoLookup;
 288 class UtxoFuture;
 289 class OnionMessenger;
 290 class MessageRouter;
 291 class DefaultMessageRouter;
 292 class OnionMessagePath;
 293 class Destination;
 294 class SendSuccess;
 295 class SendError;
 296 class CustomOnionMessageHandler;
 297 class PeeledOnion;
 298 class FilesystemStore;
 299 class BlindedPath;
 300 class BlindedHop;
 301 class InvoiceError;
 302 class ErroneousField;
 303 class DelayedPaymentBasepoint;
 304 class DelayedPaymentKey;
 305 class HtlcBasepoint;
 306 class HtlcKey;
 307 class RevocationBasepoint;
 308 class RevocationKey;
 309 class MonitorUpdateId;
 310 class Persist;
 311 class LockedChannelMonitor;
 312 class ChainMonitor;
 313 class CResult_HtlcKeyDecodeErrorZ;
 314 class CResult_TransactionU16LenLimitedNoneZ;
 315 class CResult_LockedChannelMonitorNoneZ;
 316 class CVec_C2Tuple_BlindedPayInfoBlindedPathZZ;
 317 class CResult_PhantomRouteHintsDecodeErrorZ;
 318 class CResult_FundingCreatedDecodeErrorZ;
 319 class CVec_C2Tuple_u32TxOutZZ;
 320 class CResult_RetryDecodeErrorZ;
 321 class CResult_BlindedForwardDecodeErrorZ;
 322 class CResult_ChannelInfoDecodeErrorZ;
 323 class COption_MaxDustHTLCExposureZ;
 324 class COption_OffersMessageZ;
 325 class CResult_CVec_u8ZPeerHandleErrorZ;
 326 class COption_NetworkUpdateZ;
 327 class COption_u64Z;
 328 class CResult_OnionPacketDecodeErrorZ;
 329 class CResult_GossipTimestampFilterDecodeErrorZ;
 330 class CResult_RouteHintDecodeErrorZ;
 331 class COption_FilterZ;
 332 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ;
 333 class COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ;
 334 class CResult_COption_APIErrorZDecodeErrorZ;
 335 class CVec_UpdateAddHTLCZ;
 336 class CResult_TxAbortDecodeErrorZ;
 337 class CResult_StaticPaymentOutputDescriptorDecodeErrorZ;
 338 class COption_u32Z;
 339 class CResult_RecipientOnionFieldsNoneZ;
 340 class C2Tuple__u1632_u1632Z;
 341 class CResult_CVec_StrZIOErrorZ;
 342 class CResult_ClosingSignedFeeRangeDecodeErrorZ;
 343 class CResult_TransactionNoneZ;
 344 class CResult_CommitmentSignedDecodeErrorZ;
 345 class CResult_CommitmentTransactionDecodeErrorZ;
 346 class CResult_StfuDecodeErrorZ;
 347 class CResult_OpenChannelDecodeErrorZ;
 348 class CResult_ErrorMessageDecodeErrorZ;
 349 class COption_APIErrorZ;
 350 class CResult_QueryChannelRangeDecodeErrorZ;
 351 class CVec_TransactionZ;
 352 class CVec_InputZ;
 353 class CResult_ChannelFeaturesDecodeErrorZ;
 354 class CResult_ChannelReadyDecodeErrorZ;
 355 class CResult_RevocationBasepointDecodeErrorZ;
 356 class CResult_UpdateFeeDecodeErrorZ;
 357 class CResult_NoneBolt11SemanticErrorZ;
 358 class COption_OnionMessageContentsZ;
 359 class CResult_NoneRetryableSendFailureZ;
 360 class CResult_boolLightningErrorZ;
 361 class CResult_NodeIdDecodeErrorZ;
 362 class CResult_ChannelShutdownStateDecodeErrorZ;
 363 class CResult_HTLCOutputInCommitmentDecodeErrorZ;
 364 class CResult_NodeAnnouncementInfoDecodeErrorZ;
 365 class CResult_ShutdownScriptInvalidShutdownScriptZ;
 366 class CResult_COption_NetworkUpdateZDecodeErrorZ;
 367 class CVec_UpdateFailMalformedHTLCZ;
 368 class CResult_ShutdownScriptNoneZ;
 369 class CResult_PendingHTLCInfoInboundHTLCErrZ;
 370 class CResult_PendingHTLCInfoDecodeErrorZ;
 371 class COption_HTLCDestinationZ;
 372 class CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ;
 373 class CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ;
 374 class CVec_RouteHopZ;
 375 class C2Tuple_PublicKeyCVec_SocketAddressZZ;
 376 class CResult_CVec_UtxoZNoneZ;
 377 class CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ;
 378 class CResult_CVec_u8ZIOErrorZ;
 379 class C3Tuple_OffersMessageDestinationBlindedPathZ;
 380 class CVec_ThirtyTwoBytesZ;
 381 class CResult_ChannelMonitorUpdateStatusNoneZ;
 382 class CResult_ClosingSignedDecodeErrorZ;
 383 class CVec_CResult_NoneAPIErrorZZ;
 384 class CResult_SchnorrSignatureNoneZ;
 385 class CResult_CounterpartyCommitmentSecretsDecodeErrorZ;
 386 class CResult_HTLCDescriptorDecodeErrorZ;
 387 class CVec_RecentPaymentDetailsZ;
 388 class CVec_RouteHintHopZ;
 389 class CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ;
 390 class CResult_UntrustedStringDecodeErrorZ;
 391 class CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ;
 392 class CVec_U5Z;
 393 class CResult_PaymentParametersDecodeErrorZ;
 394 class C2Tuple_ThirtyTwoBytesChannelMonitorZ;
 395 class COption_U128Z;
 396 class CResult_DelayedPaymentBasepointDecodeErrorZ;
 397 class C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ;
 398 class CResult_TxAckRbfDecodeErrorZ;
 399 class CResult_Bolt11InvoiceBolt11SemanticErrorZ;
 400 class COption_UtxoLookupZ;
 401 class CResult_PongDecodeErrorZ;
 402 class CResult_UnsignedChannelAnnouncementDecodeErrorZ;
 403 class C2Tuple_OutPointCVec_MonitorUpdateIdZZ;
 404 class CResult_CVec_u8ZNoneZ;
 405 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ;
 406 class CResult_ChannelTransactionParametersDecodeErrorZ;
 407 class CResult_WriteableEcdsaChannelSignerDecodeErrorZ;
 408 class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ;
 409 class CResult_InFlightHtlcsDecodeErrorZ;
 410 class CResult_COption_HTLCDestinationZDecodeErrorZ;
 411 class CResult_ThirtyTwoBytesNoneZ;
 412 class C3Tuple_OnionMessageContentsDestinationBlindedPathZ;
 413 class C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ;
 414 class CResult_SendSuccessSendErrorZ;
 415 class CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ;
 416 class C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ;
 417 class CResult_BlindedHopDecodeErrorZ;
 418 class CResult_NoneLightningErrorZ;
 419 class CResult_FixedPenaltyScorerDecodeErrorZ;
 420 class CVec_BlindedPathZ;
 421 class CResult_NonePeerHandleErrorZ;
 422 class CResult_FinalOnionHopDataDecodeErrorZ;
 423 class CResult_TrustedCommitmentTransactionNoneZ;
 424 class CResult_COption_EventZDecodeErrorZ;
 425 class CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ;
 426 class CResult_PaymentFailureReasonDecodeErrorZ;
 427 class COption_SocketAddressZ;
 428 class CResult_COption_MonitorEventZDecodeErrorZ;
 429 class COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ;
 430 class CResult_DescriptionCreationErrorZ;
 431 class CResult_RoutingFeesDecodeErrorZ;
 432 class CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ;
 433 class CResult_PaymentRelayDecodeErrorZ;
 434 class CResult_QueryShortChannelIdsDecodeErrorZ;
 435 class CResult_VerifiedInvoiceRequestNoneZ;
 436 class CResult_UpdateAddHTLCDecodeErrorZ;
 437 class COption_MonitorEventZ;
 438 class COption_TypeZ;
 439 class CResult_COption_TypeZDecodeErrorZ;
 440 class CResult_COption_PathFailureZDecodeErrorZ;
 441 class CResult_Bolt11InvoiceSignOrCreationErrorZ;
 442 class CResult_UpdateFailHTLCDecodeErrorZ;
 443 class CResult_CVec_BlindedPathZNoneZ;
 444 class CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ;
 445 class CResult_RevokeAndACKDecodeErrorZ;
 446 class CResult_SpendableOutputDescriptorDecodeErrorZ;
 447 class C2Tuple_PublicKeyCOption_SocketAddressZZ;
 448 class CResult_UnsignedChannelUpdateDecodeErrorZ;
 449 class CResult_PayeePubKeySecp256k1ErrorZ;
 450 class C2Tuple__u832u16Z;
 451 class COption_BigEndianScalarZ;
 452 class CResult_PublicKeySecp256k1ErrorZ;
 453 class CResult_CVec_ECDSASignatureZNoneZ;
 454 class CVec_BlindedHopZ;
 455 class CResult_COption_ClosureReasonZDecodeErrorZ;
 456 class CResult_InvoiceErrorDecodeErrorZ;
 457 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
 458 class CResult_RouteParametersDecodeErrorZ;
 459 class CResult_PrivateRouteCreationErrorZ;
 460 class CResult_NodeAliasDecodeErrorZ;
 461 class CVec_UpdateFulfillHTLCZ;
 462 class CVec_C2Tuple_u32CVec_u8ZZZ;
 463 class C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ;
 464 class CResult_AnnouncementSignaturesDecodeErrorZ;
 465 class CResult_TxCompleteDecodeErrorZ;
 466 class CResult_UpdateFulfillHTLCDecodeErrorZ;
 467 class CResult_NodeFeaturesDecodeErrorZ;
 468 class CResult_InMemorySignerDecodeErrorZ;
 469 class CResult_TxSignaturesDecodeErrorZ;
 470 class CVec_HTLCDescriptorZ;
 471 class CResult_ReplyShortChannelIdsEndDecodeErrorZ;
 472 class COption_PathFailureZ;
 473 class CResult_StrSecp256k1ErrorZ;
 474 class CVec_ECDSASignatureZ;
 475 class CResult_ChannelUpdateInfoDecodeErrorZ;
 476 class CVec_UpdateFailHTLCZ;
 477 class CVec_TxOutZ;
 478 class CResult_BuiltCommitmentTransactionDecodeErrorZ;
 479 class CVec_SpendableOutputDescriptorZ;
 480 class C2Tuple_OutPointCVec_u8ZZ;
 481 class CResult_WitnessNoneZ;
 482 class COption_C2Tuple_u64u64ZZ;
 483 class CResult_ChannelAnnouncementDecodeErrorZ;
 484 class CResult_HTLCUpdateDecodeErrorZ;
 485 class CResult_TxAddInputDecodeErrorZ;
 486 class CResult_PeeledOnionNoneZ;
 487 class CResult_TxInitRbfDecodeErrorZ;
 488 class COption_WriteableScoreZ;
 489 class CVec_StrZ;
 490 class CVec_OutPointZ;
 491 class CResult_SpliceAckDecodeErrorZ;
 492 class CResult_PositiveTimestampCreationErrorZ;
 493 class CResult_ChannelMonitorUpdateDecodeErrorZ;
 494 class C2Tuple_BlindedPayInfoBlindedPathZ;
 495 class CResult_ReplyChannelRangeDecodeErrorZ;
 496 class CResult_UnsignedNodeAnnouncementDecodeErrorZ;
 497 class CResult_TrustedClosingTransactionNoneZ;
 498 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ;
 499 class C2Tuple_PublicKeyTypeZ;
 500 class CResult_TxRemoveOutputDecodeErrorZ;
 501 class CResult_ChannelReestablishDecodeErrorZ;
 502 class CResult_OnionMessageDecodeErrorZ;
 503 class CResult_Bolt11InvoiceParseOrSemanticErrorZ;
 504 class CResult_InitFeaturesDecodeErrorZ;
 505 class CResult_PublicKeyNoneZ;
 506 class CResult_PingDecodeErrorZ;
 507 class CResult_RevocationKeyDecodeErrorZ;
 508 class CResult_BlindedHopFeaturesDecodeErrorZ;
 509 class CVec_TransactionOutputsZ;
 510 class COption_HTLCClaimZ;
 511 class COption_boolZ;
 512 class CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ;
 513 class CResult_ProbabilisticScorerDecodeErrorZ;
 514 class COption_StrZ;
 515 class CResult_ShutdownScriptDecodeErrorZ;
 516 class CResult_SiPrefixBolt11ParseErrorZ;
 517 class C2Tuple_usizeTransactionZ;
 518 class CResult_NodeAnnouncementDecodeErrorZ;
 519 class CVec_FutureZ;
 520 class CVec_ChannelMonitorZ;
 521 class CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ;
 522 class CResult_AcceptChannelV2DecodeErrorZ;
 523 class CResult_RouteHopDecodeErrorZ;
 524 class CVec_HTLCOutputInCommitmentZ;
 525 class CResult_CoinSelectionNoneZ;
 526 class C2Tuple_ThirtyTwoBytesPublicKeyZ;
 527 class CResult_TxCreationKeysDecodeErrorZ;
 528 class CResult_BlindedPathDecodeErrorZ;
 529 class CVec_BalanceZ;
 530 class CResult_NoneIOErrorZ;
 531 class CResult_MaxDustHTLCExposureDecodeErrorZ;
 532 class CVec_CommitmentTransactionZ;
 533 class CResult_FundingSignedDecodeErrorZ;
 534 class CResult_RecoverableSignatureNoneZ;
 535 class CResult_SocketAddressDecodeErrorZ;
 536 class C2Tuple_Z;
 537 class C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ;
 538 class CVec_PathZ;
 539 class CResult_NetworkGraphDecodeErrorZ;
 540 class CResult_NodeInfoDecodeErrorZ;
 541 class CVec_NodeIdZ;
 542 class CVec_u8Z;
 543 class CResult_RouteLightningErrorZ;
 544 class CResult_NonePaymentSendFailureZ;
 545 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ;
 546 class CResult_ChannelPublicKeysDecodeErrorZ;
 547 class CVec_ClaimedHTLCZ;
 548 class COption_CVec_ThirtyTwoBytesZZ;
 549 class CVec_SocketAddressZ;
 550 class CResult_ThirtyTwoBytesPaymentSendFailureZ;
 551 class CResult_HolderCommitmentTransactionDecodeErrorZ;
 552 class CResult_WarningMessageDecodeErrorZ;
 553 class CResult_ChannelCounterpartyDecodeErrorZ;
 554 class CVec_ForwardNodeZ;
 555 class CResult_DelayedPaymentKeyDecodeErrorZ;
 556 class CResult_InitDecodeErrorZ;
 557 class CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ;
 558 class CResult_SpliceDecodeErrorZ;
 559 class CResult_PaymentPurposeDecodeErrorZ;
 560 class CResult_ClaimedHTLCDecodeErrorZ;
 561 class C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ;
 562 class CResult_OutPointDecodeErrorZ;
 563 class CVec_ChannelDetailsZ;
 564 class CVec_MonitorUpdateIdZ;
 565 class CResult_Bolt11InvoiceFeaturesDecodeErrorZ;
 566 class CVec_MessageSendEventZ;
 567 class CResult_RouteHintHopDecodeErrorZ;
 568 class CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ;
 569 class CResult_UpdateFailMalformedHTLCDecodeErrorZ;
 570 class CResult_BlindedPayInfoDecodeErrorZ;
 571 class CResult_ThirtyTwoBytesAPIErrorZ;
 572 class COption_ChannelShutdownStateZ;
 573 class CResult_AcceptChannelDecodeErrorZ;
 574 class CResult_HostnameDecodeErrorZ;
 575 class C2Tuple_u64u16Z;
 576 class COption_ThirtyTwoBytesZ;
 577 class CVec_u64Z;
 578 class CResult_NoneBolt12SemanticErrorZ;
 579 class COption_SecretKeyZ;
 580 class CResult_C2Tuple_CVec_u8Zu64ZNoneZ;
 581 class COption_EventZ;
 582 class CResult_ChannelTypeFeaturesDecodeErrorZ;
 583 class COption_CVec_SocketAddressZZ;
 584 class CVec_RouteHintZ;
 585 class COption_u16Z;
 586 class COption_PaymentFailureReasonZ;
 587 class CResult_ECDSASignatureNoneZ;
 588 class CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ;
 589 class CVec_WitnessZ;
 590 class CResult_BlindedTailDecodeErrorZ;
 591 class CResult_SocketAddressSocketAddressParseErrorZ;
 592 class COption_C2Tuple_u64u16ZZ;
 593 class CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ;
 594 class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ;
 595 class CResult_ChannelDerivationParametersDecodeErrorZ;
 596 class CResult_PaymentConstraintsDecodeErrorZ;
 597 class CResult_OnionMessagePathNoneZ;
 598 class C2Tuple_u32CVec_u8ZZ;
 599 class CVec_C2Tuple_PublicKeyTypeZZ;
 600 class CResult_RefundBolt12ParseErrorZ;
 601 class C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ;
 602 class CVec_C2Tuple_u64CVec_u8ZZZ;
 603 class CResult_u32GraphSyncErrorZ;
 604 class CVec_PhantomRouteHintsZ;
 605 class CResult_NoneAPIErrorZ;
 606 class CResult_Bolt12InvoiceFeaturesDecodeErrorZ;
 607 class COption_f64Z;
 608 class CResult_ChannelDetailsDecodeErrorZ;
 609 class CVec_PublicKeyZ;
 610 class C2Tuple_CVec_u8Zu64Z;
 611 class CVec_C2Tuple_usizeTransactionZZ;
 612 class CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ;
 613 class CResult_PendingHTLCRoutingDecodeErrorZ;
 614 class C2Tuple_u64u64Z;
 615 class CResult_TxRemoveInputDecodeErrorZ;
 616 class CResult_OffersMessageDecodeErrorZ;
 617 class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ;
 618 class CResult_RecipientOnionFieldsDecodeErrorZ;
 619 class C2Tuple_u32TxOutZ;
 620 class CVec_UtxoZ;
 621 class CResult_ChannelConfigDecodeErrorZ;
 622 class CVec_PrivateRouteZ;
 623 class COption_i64Z;
 624 class C2Tuple_ThirtyTwoBytesChannelManagerZ;
 625 class CResult_COption_OnionMessageContentsZDecodeErrorZ;
 626 class C2Tuple_u64CVec_u8ZZ;
 627 class CResult_OfferBolt12ParseErrorZ;
 628 class CResult_ThirtyTwoBytesRetryableSendFailureZ;
 629 class CVec_MonitorEventZ;
 630 class CResult_ShutdownDecodeErrorZ;
 631 class CResult_BigSizeDecodeErrorZ;
 632 class CResult_TxOutUtxoLookupErrorZ;
 633 class CResult_BlindedPathNoneZ;
 634 class COption_usizeZ;
 635 class CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ;
 636 class CResult_NoneNoneZ;
 637 class CResult_boolPeerHandleErrorZ;
 638 class CResult_ChannelUpdateDecodeErrorZ;
 639 class CVec_APIErrorZ;
 640 class COption_TxOutZ;
 641 class COption_ClosureReasonZ;
 642 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ;
 643 class CResult_TransactionU16LenLimitedDecodeErrorZ;
 644 class CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ;
 645 class CResult_CounterpartyForwardingInfoDecodeErrorZ;
 646 class CResult_OpenChannelV2DecodeErrorZ;
 647 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ;
 648 class CResult_HtlcBasepointDecodeErrorZ;
 649 class CResult_SpliceLockedDecodeErrorZ;
 650 class CResult_RouteDecodeErrorZ;
 651 class CResult_BlindedFailureDecodeErrorZ;
 652 class CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ;
 653 class COption_NoneZ;
 654 class CResult_TxAddOutputDecodeErrorZ;
 655 class COption_CVec_u8ZZ;
 656
 657 class Str {
 658 private:
 659         LDKStr self;
 660 public:
 661         Str(const Str&) = delete;
 662         Str(Str&& o) : self(o.self) { memset(&o, 0, sizeof(Str)); }
 663         Str(LDKStr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStr)); }
 664         operator LDKStr() && { LDKStr res = self; memset(&self, 0, sizeof(LDKStr)); return res; }
 665         ~Str() { Str_free(self); }
 666         Str& operator=(Str&& o) { Str_free(self); self = o.self; memset(&o, 0, sizeof(Str)); return *this; }
 667         LDKStr* operator &() { return &self; }
 668         LDKStr* operator ->() { return &self; }
 669         const LDKStr* operator &() const { return &self; }
 670         const LDKStr* operator ->() const { return &self; }
 671 };
 672 class Refund {
 673 private:
 674         LDKRefund self;
 675 public:
 676         Refund(const Refund&) = delete;
 677         Refund(Refund&& o) : self(o.self) { memset(&o, 0, sizeof(Refund)); }
 678         Refund(LDKRefund&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRefund)); }
 679         operator LDKRefund() && { LDKRefund res = self; memset(&self, 0, sizeof(LDKRefund)); return res; }
 680         ~Refund() { Refund_free(self); }
 681         Refund& operator=(Refund&& o) { Refund_free(self); self = o.self; memset(&o, 0, sizeof(Refund)); return *this; }
 682         LDKRefund* operator &() { return &self; }
 683         LDKRefund* operator ->() { return &self; }
 684         const LDKRefund* operator &() const { return &self; }
 685         const LDKRefund* operator ->() const { return &self; }
 686 };
 687 class Retry {
 688 private:
 689         LDKRetry self;
 690 public:
 691         Retry(const Retry&) = delete;
 692         Retry(Retry&& o) : self(o.self) { memset(&o, 0, sizeof(Retry)); }
 693         Retry(LDKRetry&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetry)); }
 694         operator LDKRetry() && { LDKRetry res = self; memset(&self, 0, sizeof(LDKRetry)); return res; }
 695         ~Retry() { Retry_free(self); }
 696         Retry& operator=(Retry&& o) { Retry_free(self); self = o.self; memset(&o, 0, sizeof(Retry)); return *this; }
 697         LDKRetry* operator &() { return &self; }
 698         LDKRetry* operator ->() { return &self; }
 699         const LDKRetry* operator &() const { return &self; }
 700         const LDKRetry* operator ->() const { return &self; }
 701 };
 702 class RetryableSendFailure {
 703 private:
 704         LDKRetryableSendFailure self;
 705 public:
 706         RetryableSendFailure(const RetryableSendFailure&) = delete;
 707         RetryableSendFailure(RetryableSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(RetryableSendFailure)); }
 708         RetryableSendFailure(LDKRetryableSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetryableSendFailure)); }
 709         operator LDKRetryableSendFailure() && { LDKRetryableSendFailure res = self; memset(&self, 0, sizeof(LDKRetryableSendFailure)); return res; }
 710         RetryableSendFailure& operator=(RetryableSendFailure&& o) { self = o.self; memset(&o, 0, sizeof(RetryableSendFailure)); return *this; }
 711         LDKRetryableSendFailure* operator &() { return &self; }
 712         LDKRetryableSendFailure* operator ->() { return &self; }
 713         const LDKRetryableSendFailure* operator &() const { return &self; }
 714         const LDKRetryableSendFailure* operator ->() const { return &self; }
 715 };
 716 class PaymentSendFailure {
 717 private:
 718         LDKPaymentSendFailure self;
 719 public:
 720         PaymentSendFailure(const PaymentSendFailure&) = delete;
 721         PaymentSendFailure(PaymentSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentSendFailure)); }
 722         PaymentSendFailure(LDKPaymentSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentSendFailure)); }
 723         operator LDKPaymentSendFailure() && { LDKPaymentSendFailure res = self; memset(&self, 0, sizeof(LDKPaymentSendFailure)); return res; }
 724         ~PaymentSendFailure() { PaymentSendFailure_free(self); }
 725         PaymentSendFailure& operator=(PaymentSendFailure&& o) { PaymentSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(PaymentSendFailure)); return *this; }
 726         LDKPaymentSendFailure* operator &() { return &self; }
 727         LDKPaymentSendFailure* operator ->() { return &self; }
 728         const LDKPaymentSendFailure* operator &() const { return &self; }
 729         const LDKPaymentSendFailure* operator ->() const { return &self; }
 730 };
 731 class ProbeSendFailure {
 732 private:
 733         LDKProbeSendFailure self;
 734 public:
 735         ProbeSendFailure(const ProbeSendFailure&) = delete;
 736         ProbeSendFailure(ProbeSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(ProbeSendFailure)); }
 737         ProbeSendFailure(LDKProbeSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbeSendFailure)); }
 738         operator LDKProbeSendFailure() && { LDKProbeSendFailure res = self; memset(&self, 0, sizeof(LDKProbeSendFailure)); return res; }
 739         ~ProbeSendFailure() { ProbeSendFailure_free(self); }
 740         ProbeSendFailure& operator=(ProbeSendFailure&& o) { ProbeSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(ProbeSendFailure)); return *this; }
 741         LDKProbeSendFailure* operator &() { return &self; }
 742         LDKProbeSendFailure* operator ->() { return &self; }
 743         const LDKProbeSendFailure* operator &() const { return &self; }
 744         const LDKProbeSendFailure* operator ->() const { return &self; }
 745 };
 746 class RecipientOnionFields {
 747 private:
 748         LDKRecipientOnionFields self;
 749 public:
 750         RecipientOnionFields(const RecipientOnionFields&) = delete;
 751         RecipientOnionFields(RecipientOnionFields&& o) : self(o.self) { memset(&o, 0, sizeof(RecipientOnionFields)); }
 752         RecipientOnionFields(LDKRecipientOnionFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecipientOnionFields)); }
 753         operator LDKRecipientOnionFields() && { LDKRecipientOnionFields res = self; memset(&self, 0, sizeof(LDKRecipientOnionFields)); return res; }
 754         ~RecipientOnionFields() { RecipientOnionFields_free(self); }
 755         RecipientOnionFields& operator=(RecipientOnionFields&& o) { RecipientOnionFields_free(self); self = o.self; memset(&o, 0, sizeof(RecipientOnionFields)); return *this; }
 756         LDKRecipientOnionFields* operator &() { return &self; }
 757         LDKRecipientOnionFields* operator ->() { return &self; }
 758         const LDKRecipientOnionFields* operator &() const { return &self; }
 759         const LDKRecipientOnionFields* operator ->() const { return &self; }
 760 };
 761 class UnsignedBolt12Invoice {
 762 private:
 763         LDKUnsignedBolt12Invoice self;
 764 public:
 765         UnsignedBolt12Invoice(const UnsignedBolt12Invoice&) = delete;
 766         UnsignedBolt12Invoice(UnsignedBolt12Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedBolt12Invoice)); }
 767         UnsignedBolt12Invoice(LDKUnsignedBolt12Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedBolt12Invoice)); }
 768         operator LDKUnsignedBolt12Invoice() && { LDKUnsignedBolt12Invoice res = self; memset(&self, 0, sizeof(LDKUnsignedBolt12Invoice)); return res; }
 769         ~UnsignedBolt12Invoice() { UnsignedBolt12Invoice_free(self); }
 770         UnsignedBolt12Invoice& operator=(UnsignedBolt12Invoice&& o) { UnsignedBolt12Invoice_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedBolt12Invoice)); return *this; }
 771         LDKUnsignedBolt12Invoice* operator &() { return &self; }
 772         LDKUnsignedBolt12Invoice* operator ->() { return &self; }
 773         const LDKUnsignedBolt12Invoice* operator &() const { return &self; }
 774         const LDKUnsignedBolt12Invoice* operator ->() const { return &self; }
 775 };
 776 class Bolt12Invoice {
 777 private:
 778         LDKBolt12Invoice self;
 779 public:
 780         Bolt12Invoice(const Bolt12Invoice&) = delete;
 781         Bolt12Invoice(Bolt12Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12Invoice)); }
 782         Bolt12Invoice(LDKBolt12Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12Invoice)); }
 783         operator LDKBolt12Invoice() && { LDKBolt12Invoice res = self; memset(&self, 0, sizeof(LDKBolt12Invoice)); return res; }
 784         ~Bolt12Invoice() { Bolt12Invoice_free(self); }
 785         Bolt12Invoice& operator=(Bolt12Invoice&& o) { Bolt12Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12Invoice)); return *this; }
 786         LDKBolt12Invoice* operator &() { return &self; }
 787         LDKBolt12Invoice* operator ->() { return &self; }
 788         const LDKBolt12Invoice* operator &() const { return &self; }
 789         const LDKBolt12Invoice* operator ->() const { return &self; }
 790 };
 791 class BlindedPayInfo {
 792 private:
 793         LDKBlindedPayInfo self;
 794 public:
 795         BlindedPayInfo(const BlindedPayInfo&) = delete;
 796         BlindedPayInfo(BlindedPayInfo&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPayInfo)); }
 797         BlindedPayInfo(LDKBlindedPayInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPayInfo)); }
 798         operator LDKBlindedPayInfo() && { LDKBlindedPayInfo res = self; memset(&self, 0, sizeof(LDKBlindedPayInfo)); return res; }
 799         ~BlindedPayInfo() { BlindedPayInfo_free(self); }
 800         BlindedPayInfo& operator=(BlindedPayInfo&& o) { BlindedPayInfo_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPayInfo)); return *this; }
 801         LDKBlindedPayInfo* operator &() { return &self; }
 802         LDKBlindedPayInfo* operator ->() { return &self; }
 803         const LDKBlindedPayInfo* operator &() const { return &self; }
 804         const LDKBlindedPayInfo* operator ->() const { return &self; }
 805 };
 806 class DelayedPaymentOutputDescriptor {
 807 private:
 808         LDKDelayedPaymentOutputDescriptor self;
 809 public:
 810         DelayedPaymentOutputDescriptor(const DelayedPaymentOutputDescriptor&) = delete;
 811         DelayedPaymentOutputDescriptor(DelayedPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); }
 812         DelayedPaymentOutputDescriptor(LDKDelayedPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); }
 813         operator LDKDelayedPaymentOutputDescriptor() && { LDKDelayedPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); return res; }
 814         ~DelayedPaymentOutputDescriptor() { DelayedPaymentOutputDescriptor_free(self); }
 815         DelayedPaymentOutputDescriptor& operator=(DelayedPaymentOutputDescriptor&& o) { DelayedPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); return *this; }
 816         LDKDelayedPaymentOutputDescriptor* operator &() { return &self; }
 817         LDKDelayedPaymentOutputDescriptor* operator ->() { return &self; }
 818         const LDKDelayedPaymentOutputDescriptor* operator &() const { return &self; }
 819         const LDKDelayedPaymentOutputDescriptor* operator ->() const { return &self; }
 820 };
 821 class StaticPaymentOutputDescriptor {
 822 private:
 823         LDKStaticPaymentOutputDescriptor self;
 824 public:
 825         StaticPaymentOutputDescriptor(const StaticPaymentOutputDescriptor&) = delete;
 826         StaticPaymentOutputDescriptor(StaticPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); }
 827         StaticPaymentOutputDescriptor(LDKStaticPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); }
 828         operator LDKStaticPaymentOutputDescriptor() && { LDKStaticPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); return res; }
 829         ~StaticPaymentOutputDescriptor() { StaticPaymentOutputDescriptor_free(self); }
 830         StaticPaymentOutputDescriptor& operator=(StaticPaymentOutputDescriptor&& o) { StaticPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); return *this; }
 831         LDKStaticPaymentOutputDescriptor* operator &() { return &self; }
 832         LDKStaticPaymentOutputDescriptor* operator ->() { return &self; }
 833         const LDKStaticPaymentOutputDescriptor* operator &() const { return &self; }
 834         const LDKStaticPaymentOutputDescriptor* operator ->() const { return &self; }
 835 };
 836 class SpendableOutputDescriptor {
 837 private:
 838         LDKSpendableOutputDescriptor self;
 839 public:
 840         SpendableOutputDescriptor(const SpendableOutputDescriptor&) = delete;
 841         SpendableOutputDescriptor(SpendableOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SpendableOutputDescriptor)); }
 842         SpendableOutputDescriptor(LDKSpendableOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendableOutputDescriptor)); }
 843         operator LDKSpendableOutputDescriptor() && { LDKSpendableOutputDescriptor res = self; memset(&self, 0, sizeof(LDKSpendableOutputDescriptor)); return res; }
 844         ~SpendableOutputDescriptor() { SpendableOutputDescriptor_free(self); }
 845         SpendableOutputDescriptor& operator=(SpendableOutputDescriptor&& o) { SpendableOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SpendableOutputDescriptor)); return *this; }
 846         LDKSpendableOutputDescriptor* operator &() { return &self; }
 847         LDKSpendableOutputDescriptor* operator ->() { return &self; }
 848         const LDKSpendableOutputDescriptor* operator &() const { return &self; }
 849         const LDKSpendableOutputDescriptor* operator ->() const { return &self; }
 850 };
 851 class ChannelDerivationParameters {
 852 private:
 853         LDKChannelDerivationParameters self;
 854 public:
 855         ChannelDerivationParameters(const ChannelDerivationParameters&) = delete;
 856         ChannelDerivationParameters(ChannelDerivationParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDerivationParameters)); }
 857         ChannelDerivationParameters(LDKChannelDerivationParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDerivationParameters)); }
 858         operator LDKChannelDerivationParameters() && { LDKChannelDerivationParameters res = self; memset(&self, 0, sizeof(LDKChannelDerivationParameters)); return res; }
 859         ~ChannelDerivationParameters() { ChannelDerivationParameters_free(self); }
 860         ChannelDerivationParameters& operator=(ChannelDerivationParameters&& o) { ChannelDerivationParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDerivationParameters)); return *this; }
 861         LDKChannelDerivationParameters* operator &() { return &self; }
 862         LDKChannelDerivationParameters* operator ->() { return &self; }
 863         const LDKChannelDerivationParameters* operator &() const { return &self; }
 864         const LDKChannelDerivationParameters* operator ->() const { return &self; }
 865 };
 866 class HTLCDescriptor {
 867 private:
 868         LDKHTLCDescriptor self;
 869 public:
 870         HTLCDescriptor(const HTLCDescriptor&) = delete;
 871         HTLCDescriptor(HTLCDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCDescriptor)); }
 872         HTLCDescriptor(LDKHTLCDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCDescriptor)); }
 873         operator LDKHTLCDescriptor() && { LDKHTLCDescriptor res = self; memset(&self, 0, sizeof(LDKHTLCDescriptor)); return res; }
 874         ~HTLCDescriptor() { HTLCDescriptor_free(self); }
 875         HTLCDescriptor& operator=(HTLCDescriptor&& o) { HTLCDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(HTLCDescriptor)); return *this; }
 876         LDKHTLCDescriptor* operator &() { return &self; }
 877         LDKHTLCDescriptor* operator ->() { return &self; }
 878         const LDKHTLCDescriptor* operator &() const { return &self; }
 879         const LDKHTLCDescriptor* operator ->() const { return &self; }
 880 };
 881 class ChannelSigner {
 882 private:
 883         LDKChannelSigner self;
 884 public:
 885         ChannelSigner(const ChannelSigner&) = delete;
 886         ChannelSigner(ChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelSigner)); }
 887         ChannelSigner(LDKChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelSigner)); }
 888         operator LDKChannelSigner() && { LDKChannelSigner res = self; memset(&self, 0, sizeof(LDKChannelSigner)); return res; }
 889         ~ChannelSigner() { ChannelSigner_free(self); }
 890         ChannelSigner& operator=(ChannelSigner&& o) { ChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(ChannelSigner)); return *this; }
 891         LDKChannelSigner* operator &() { return &self; }
 892         LDKChannelSigner* operator ->() { return &self; }
 893         const LDKChannelSigner* operator &() const { return &self; }
 894         const LDKChannelSigner* operator ->() const { return &self; }
 895         /**
 896          *  Gets the per-commitment point for a specific commitment number
 897          *
 898          *  Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.
 899          */
 900         inline LDKPublicKey get_per_commitment_point(uint64_t idx);
 901         /**
 902          *  Gets the commitment secret for a specific commitment number as part of the revocation process
 903          *
 904          *  An external signer implementation should error here if the commitment was already signed
 905          *  and should refuse to sign it in the future.
 906          *
 907          *  May be called more than once for the same index.
 908          *
 909          *  Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.
 910          */
 911         inline LDKThirtyTwoBytes release_commitment_secret(uint64_t idx);
 912         /**
 913          *  Validate the counterparty's signatures on the holder commitment transaction and HTLCs.
 914          *
 915          *  This is required in order for the signer to make sure that releasing a commitment
 916          *  secret won't leave us without a broadcastable holder transaction.
 917          *  Policy checks should be implemented in this function, including checking the amount
 918          *  sent to us and checking the HTLCs.
 919          *
 920          *  The preimages of outbound HTLCs that were fulfilled since the last commitment are provided.
 921          *  A validating signer should ensure that an HTLC output is removed only when the matching
 922          *  preimage is provided, or when the value to holder is restored.
 923          *
 924          *  Note that all the relevant preimages will be provided, but there may also be additional
 925          *  irrelevant or duplicate preimages.
 926          */
 927         inline LDK::CResult_NoneNoneZ validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages);
 928         /**
 929          *  Validate the counterparty's revocation.
 930          *
 931          *  This is required in order for the signer to make sure that the state has moved
 932          *  forward and it is safe to sign the next counterparty commitment.
 933          */
 934         inline LDK::CResult_NoneNoneZ validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]);
 935         /**
 936          *  Returns an arbitrary identifier describing the set of keys which are provided back to you in
 937          *  some [`SpendableOutputDescriptor`] types. This should be sufficient to identify this
 938          *  [`EcdsaChannelSigner`] object uniquely and lookup or re-derive its keys.
 939          */
 940         inline LDKThirtyTwoBytes channel_keys_id();
 941         /**
 942          *  Set the counterparty static channel data, including basepoints,
 943          *  `counterparty_selected`/`holder_selected_contest_delay` and funding outpoint.
 944          *
 945          *  This data is static, and will never change for a channel once set. For a given [`ChannelSigner`]
 946          *  instance, LDK will call this method exactly once - either immediately after construction
 947          *  (not including if done via [`SignerProvider::read_chan_signer`]) or when the funding
 948          *  information has been generated.
 949          *
 950          *  channel_parameters.is_populated() MUST be true.
 951          */
 952         inline void provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters);
 953 };
 954 class Recipient {
 955 private:
 956         LDKRecipient self;
 957 public:
 958         Recipient(const Recipient&) = delete;
 959         Recipient(Recipient&& o) : self(o.self) { memset(&o, 0, sizeof(Recipient)); }
 960         Recipient(LDKRecipient&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecipient)); }
 961         operator LDKRecipient() && { LDKRecipient res = self; memset(&self, 0, sizeof(LDKRecipient)); return res; }
 962         Recipient& operator=(Recipient&& o) { self = o.self; memset(&o, 0, sizeof(Recipient)); return *this; }
 963         LDKRecipient* operator &() { return &self; }
 964         LDKRecipient* operator ->() { return &self; }
 965         const LDKRecipient* operator &() const { return &self; }
 966         const LDKRecipient* operator ->() const { return &self; }
 967 };
 968 class EntropySource {
 969 private:
 970         LDKEntropySource self;
 971 public:
 972         EntropySource(const EntropySource&) = delete;
 973         EntropySource(EntropySource&& o) : self(o.self) { memset(&o, 0, sizeof(EntropySource)); }
 974         EntropySource(LDKEntropySource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEntropySource)); }
 975         operator LDKEntropySource() && { LDKEntropySource res = self; memset(&self, 0, sizeof(LDKEntropySource)); return res; }
 976         ~EntropySource() { EntropySource_free(self); }
 977         EntropySource& operator=(EntropySource&& o) { EntropySource_free(self); self = o.self; memset(&o, 0, sizeof(EntropySource)); return *this; }
 978         LDKEntropySource* operator &() { return &self; }
 979         LDKEntropySource* operator ->() { return &self; }
 980         const LDKEntropySource* operator &() const { return &self; }
 981         const LDKEntropySource* operator ->() const { return &self; }
 982         /**
 983          *  Gets a unique, cryptographically-secure, random 32-byte value. This method must return a
 984          *  different value each time it is called.
 985          */
 986         inline LDKThirtyTwoBytes get_secure_random_bytes();
 987 };
 988 class NodeSigner {
 989 private:
 990         LDKNodeSigner self;
 991 public:
 992         NodeSigner(const NodeSigner&) = delete;
 993         NodeSigner(NodeSigner&& o) : self(o.self) { memset(&o, 0, sizeof(NodeSigner)); }
 994         NodeSigner(LDKNodeSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeSigner)); }
 995         operator LDKNodeSigner() && { LDKNodeSigner res = self; memset(&self, 0, sizeof(LDKNodeSigner)); return res; }
 996         ~NodeSigner() { NodeSigner_free(self); }
 997         NodeSigner& operator=(NodeSigner&& o) { NodeSigner_free(self); self = o.self; memset(&o, 0, sizeof(NodeSigner)); return *this; }
 998         LDKNodeSigner* operator &() { return &self; }
 999         LDKNodeSigner* operator ->() { return &self; }
1000         const LDKNodeSigner* operator &() const { return &self; }
1001         const LDKNodeSigner* operator ->() const { return &self; }
1002         /**
1003          *  Get secret key material as bytes for use in encrypting and decrypting inbound payment data.
1004          *
1005          *  If the implementor of this trait supports [phantom node payments], then every node that is
1006          *  intended to be included in the phantom invoice route hints must return the same value from
1007          *  this method.
1008          *
1009          *  This method must return the same value each time it is called.
1010          *
1011          *  [phantom node payments]: PhantomKeysManager
1012          */
1013         inline LDKThirtyTwoBytes get_inbound_payment_key_material();
1014         /**
1015          *  Get node id based on the provided [`Recipient`].
1016          *
1017          *  This method must return the same value each time it is called with a given [`Recipient`]
1018          *  parameter.
1019          *
1020          *  Errors if the [`Recipient`] variant is not supported by the implementation.
1021          */
1022         inline LDK::CResult_PublicKeyNoneZ get_node_id(enum LDKRecipient recipient);
1023         /**
1024          *  Gets the ECDH shared secret of our node secret and `other_key`, multiplying by `tweak` if
1025          *  one is provided. Note that this tweak can be applied to `other_key` instead of our node
1026          *  secret, though this is less efficient.
1027          *
1028          *  Note that if this fails while attempting to forward an HTLC, LDK will panic. The error
1029          *  should be resolved to allow LDK to resume forwarding HTLCs.
1030          *
1031          *  Errors if the [`Recipient`] variant is not supported by the implementation.
1032          */
1033         inline LDK::CResult_ThirtyTwoBytesNoneZ ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak);
1034         /**
1035          *  Sign an invoice.
1036          *
1037          *  By parameterizing by the raw invoice bytes instead of the hash, we allow implementors of
1038          *  this trait to parse the invoice and make sure they're signing what they expect, rather than
1039          *  blindly signing the hash.
1040          *
1041          *  The `hrp_bytes` are ASCII bytes, while the `invoice_data` is base32.
1042          *
1043          *  The secret key used to sign the invoice is dependent on the [`Recipient`].
1044          *
1045          *  Errors if the [`Recipient`] variant is not supported by the implementation.
1046          */
1047         inline LDK::CResult_RecoverableSignatureNoneZ sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient);
1048         /**
1049          *  Signs the [`TaggedHash`] of a BOLT 12 invoice request.
1050          *
1051          *  May be called by a function passed to [`UnsignedInvoiceRequest::sign`] where
1052          *  `invoice_request` is the callee.
1053          *
1054          *  Implementors may check that the `invoice_request` is expected rather than blindly signing
1055          *  the tagged hash. An `Ok` result should sign `invoice_request.tagged_hash().as_digest()` with
1056          *  the node's signing key or an ephemeral key to preserve privacy, whichever is associated with
1057          *  [`UnsignedInvoiceRequest::payer_id`].
1058          *
1059          *  [`TaggedHash`]: crate::offers::merkle::TaggedHash
1060          */
1061         inline LDK::CResult_SchnorrSignatureNoneZ sign_bolt12_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR invoice_request);
1062         /**
1063          *  Signs the [`TaggedHash`] of a BOLT 12 invoice.
1064          *
1065          *  May be called by a function passed to [`UnsignedBolt12Invoice::sign`] where `invoice` is the
1066          *  callee.
1067          *
1068          *  Implementors may check that the `invoice` is expected rather than blindly signing the tagged
1069          *  hash. An `Ok` result should sign `invoice.tagged_hash().as_digest()` with the node's signing
1070          *  key or an ephemeral key to preserve privacy, whichever is associated with
1071          *  [`UnsignedBolt12Invoice::signing_pubkey`].
1072          *
1073          *  [`TaggedHash`]: crate::offers::merkle::TaggedHash
1074          */
1075         inline LDK::CResult_SchnorrSignatureNoneZ sign_bolt12_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR invoice);
1076         /**
1077          *  Sign a gossip message.
1078          *
1079          *  Note that if this fails, LDK may panic and the message will not be broadcast to the network
1080          *  or a possible channel counterparty. If LDK panics, the error should be resolved to allow the
1081          *  message to be broadcast, as otherwise it may prevent one from receiving funds over the
1082          *  corresponding channel.
1083          */
1084         inline LDK::CResult_ECDSASignatureNoneZ sign_gossip_message(struct LDKUnsignedGossipMessage msg);
1085 };
1086 class SignerProvider {
1087 private:
1088         LDKSignerProvider self;
1089 public:
1090         SignerProvider(const SignerProvider&) = delete;
1091         SignerProvider(SignerProvider&& o) : self(o.self) { memset(&o, 0, sizeof(SignerProvider)); }
1092         SignerProvider(LDKSignerProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignerProvider)); }
1093         operator LDKSignerProvider() && { LDKSignerProvider res = self; memset(&self, 0, sizeof(LDKSignerProvider)); return res; }
1094         ~SignerProvider() { SignerProvider_free(self); }
1095         SignerProvider& operator=(SignerProvider&& o) { SignerProvider_free(self); self = o.self; memset(&o, 0, sizeof(SignerProvider)); return *this; }
1096         LDKSignerProvider* operator &() { return &self; }
1097         LDKSignerProvider* operator ->() { return &self; }
1098         const LDKSignerProvider* operator &() const { return &self; }
1099         const LDKSignerProvider* operator ->() const { return &self; }
1100         /**
1101          *  Generates a unique `channel_keys_id` that can be used to obtain a [`Self::EcdsaSigner`] through
1102          *  [`SignerProvider::derive_channel_signer`]. The `user_channel_id` is provided to allow
1103          *  implementations of [`SignerProvider`] to maintain a mapping between itself and the generated
1104          *  `channel_keys_id`.
1105          *
1106          *  This method must return a different value each time it is called.
1107          */
1108         inline LDKThirtyTwoBytes generate_channel_keys_id(bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id);
1109         /**
1110          *  Derives the private key material backing a `Signer`.
1111          *
1112          *  To derive a new `Signer`, a fresh `channel_keys_id` should be obtained through
1113          *  [`SignerProvider::generate_channel_keys_id`]. Otherwise, an existing `Signer` can be
1114          *  re-derived from its `channel_keys_id`, which can be obtained through its trait method
1115          *  [`ChannelSigner::channel_keys_id`].
1116          */
1117         inline LDK::WriteableEcdsaChannelSigner derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id);
1118         /**
1119          *  Reads a [`Signer`] for this [`SignerProvider`] from the given input stream.
1120          *  This is only called during deserialization of other objects which contain
1121          *  [`WriteableEcdsaChannelSigner`]-implementing objects (i.e., [`ChannelMonitor`]s and [`ChannelManager`]s).
1122          *  The bytes are exactly those which `<Self::Signer as Writeable>::write()` writes, and
1123          *  contain no versioning scheme. You may wish to include your own version prefix and ensure
1124          *  you've read all of the provided bytes to ensure no corruption occurred.
1125          *
1126          *  This method is slowly being phased out -- it will only be called when reading objects
1127          *  written by LDK versions prior to 0.0.113.
1128          *
1129          *  [`Signer`]: Self::EcdsaSigner
1130          *  [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
1131          *  [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
1132          */
1133         inline LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ read_chan_signer(struct LDKu8slice reader);
1134         /**
1135          *  Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
1136          *
1137          *  If this function returns an error, this will result in a channel failing to open.
1138          *
1139          *  This method should return a different value each time it is called, to avoid linking
1140          *  on-chain funds across channels as controlled to the same user. `channel_keys_id` may be
1141          *  used to derive a unique value for each channel.
1142          */
1143         inline LDK::CResult_CVec_u8ZNoneZ get_destination_script(struct LDKThirtyTwoBytes channel_keys_id);
1144         /**
1145          *  Get a script pubkey which we will send funds to when closing a channel.
1146          *
1147          *  If this function returns an error, this will result in a channel failing to open or close.
1148          *  In the event of a failure when the counterparty is initiating a close, this can result in a
1149          *  channel force close.
1150          *
1151          *  This method should return a different value each time it is called, to avoid linking
1152          *  on-chain funds across channels as controlled to the same user.
1153          */
1154         inline LDK::CResult_ShutdownScriptNoneZ get_shutdown_scriptpubkey();
1155 };
1156 class InMemorySigner {
1157 private:
1158         LDKInMemorySigner self;
1159 public:
1160         InMemorySigner(const InMemorySigner&) = delete;
1161         InMemorySigner(InMemorySigner&& o) : self(o.self) { memset(&o, 0, sizeof(InMemorySigner)); }
1162         InMemorySigner(LDKInMemorySigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInMemorySigner)); }
1163         operator LDKInMemorySigner() && { LDKInMemorySigner res = self; memset(&self, 0, sizeof(LDKInMemorySigner)); return res; }
1164         ~InMemorySigner() { InMemorySigner_free(self); }
1165         InMemorySigner& operator=(InMemorySigner&& o) { InMemorySigner_free(self); self = o.self; memset(&o, 0, sizeof(InMemorySigner)); return *this; }
1166         LDKInMemorySigner* operator &() { return &self; }
1167         LDKInMemorySigner* operator ->() { return &self; }
1168         const LDKInMemorySigner* operator &() const { return &self; }
1169         const LDKInMemorySigner* operator ->() const { return &self; }
1170 };
1171 class KeysManager {
1172 private:
1173         LDKKeysManager self;
1174 public:
1175         KeysManager(const KeysManager&) = delete;
1176         KeysManager(KeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(KeysManager)); }
1177         KeysManager(LDKKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysManager)); }
1178         operator LDKKeysManager() && { LDKKeysManager res = self; memset(&self, 0, sizeof(LDKKeysManager)); return res; }
1179         ~KeysManager() { KeysManager_free(self); }
1180         KeysManager& operator=(KeysManager&& o) { KeysManager_free(self); self = o.self; memset(&o, 0, sizeof(KeysManager)); return *this; }
1181         LDKKeysManager* operator &() { return &self; }
1182         LDKKeysManager* operator ->() { return &self; }
1183         const LDKKeysManager* operator &() const { return &self; }
1184         const LDKKeysManager* operator ->() const { return &self; }
1185 };
1186 class PhantomKeysManager {
1187 private:
1188         LDKPhantomKeysManager self;
1189 public:
1190         PhantomKeysManager(const PhantomKeysManager&) = delete;
1191         PhantomKeysManager(PhantomKeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomKeysManager)); }
1192         PhantomKeysManager(LDKPhantomKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomKeysManager)); }
1193         operator LDKPhantomKeysManager() && { LDKPhantomKeysManager res = self; memset(&self, 0, sizeof(LDKPhantomKeysManager)); return res; }
1194         ~PhantomKeysManager() { PhantomKeysManager_free(self); }
1195         PhantomKeysManager& operator=(PhantomKeysManager&& o) { PhantomKeysManager_free(self); self = o.self; memset(&o, 0, sizeof(PhantomKeysManager)); return *this; }
1196         LDKPhantomKeysManager* operator &() { return &self; }
1197         LDKPhantomKeysManager* operator ->() { return &self; }
1198         const LDKPhantomKeysManager* operator &() const { return &self; }
1199         const LDKPhantomKeysManager* operator ->() const { return &self; }
1200 };
1201 class BackgroundProcessor {
1202 private:
1203         LDKBackgroundProcessor self;
1204 public:
1205         BackgroundProcessor(const BackgroundProcessor&) = delete;
1206         BackgroundProcessor(BackgroundProcessor&& o) : self(o.self) { memset(&o, 0, sizeof(BackgroundProcessor)); }
1207         BackgroundProcessor(LDKBackgroundProcessor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBackgroundProcessor)); }
1208         operator LDKBackgroundProcessor() && { LDKBackgroundProcessor res = self; memset(&self, 0, sizeof(LDKBackgroundProcessor)); return res; }
1209         ~BackgroundProcessor() { BackgroundProcessor_free(self); }
1210         BackgroundProcessor& operator=(BackgroundProcessor&& o) { BackgroundProcessor_free(self); self = o.self; memset(&o, 0, sizeof(BackgroundProcessor)); return *this; }
1211         LDKBackgroundProcessor* operator &() { return &self; }
1212         LDKBackgroundProcessor* operator ->() { return &self; }
1213         const LDKBackgroundProcessor* operator &() const { return &self; }
1214         const LDKBackgroundProcessor* operator ->() const { return &self; }
1215 };
1216 class GossipSync {
1217 private:
1218         LDKGossipSync self;
1219 public:
1220         GossipSync(const GossipSync&) = delete;
1221         GossipSync(GossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(GossipSync)); }
1222         GossipSync(LDKGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipSync)); }
1223         operator LDKGossipSync() && { LDKGossipSync res = self; memset(&self, 0, sizeof(LDKGossipSync)); return res; }
1224         ~GossipSync() { GossipSync_free(self); }
1225         GossipSync& operator=(GossipSync&& o) { GossipSync_free(self); self = o.self; memset(&o, 0, sizeof(GossipSync)); return *this; }
1226         LDKGossipSync* operator &() { return &self; }
1227         LDKGossipSync* operator ->() { return &self; }
1228         const LDKGossipSync* operator &() const { return &self; }
1229         const LDKGossipSync* operator ->() const { return &self; }
1230 };
1231 class DefaultRouter {
1232 private:
1233         LDKDefaultRouter self;
1234 public:
1235         DefaultRouter(const DefaultRouter&) = delete;
1236         DefaultRouter(DefaultRouter&& o) : self(o.self) { memset(&o, 0, sizeof(DefaultRouter)); }
1237         DefaultRouter(LDKDefaultRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDefaultRouter)); }
1238         operator LDKDefaultRouter() && { LDKDefaultRouter res = self; memset(&self, 0, sizeof(LDKDefaultRouter)); return res; }
1239         ~DefaultRouter() { DefaultRouter_free(self); }
1240         DefaultRouter& operator=(DefaultRouter&& o) { DefaultRouter_free(self); self = o.self; memset(&o, 0, sizeof(DefaultRouter)); return *this; }
1241         LDKDefaultRouter* operator &() { return &self; }
1242         LDKDefaultRouter* operator ->() { return &self; }
1243         const LDKDefaultRouter* operator &() const { return &self; }
1244         const LDKDefaultRouter* operator ->() const { return &self; }
1245 };
1246 class Router {
1247 private:
1248         LDKRouter self;
1249 public:
1250         Router(const Router&) = delete;
1251         Router(Router&& o) : self(o.self) { memset(&o, 0, sizeof(Router)); }
1252         Router(LDKRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouter)); }
1253         operator LDKRouter() && { LDKRouter res = self; memset(&self, 0, sizeof(LDKRouter)); return res; }
1254         ~Router() { Router_free(self); }
1255         Router& operator=(Router&& o) { Router_free(self); self = o.self; memset(&o, 0, sizeof(Router)); return *this; }
1256         LDKRouter* operator &() { return &self; }
1257         LDKRouter* operator ->() { return &self; }
1258         const LDKRouter* operator &() const { return &self; }
1259         const LDKRouter* operator ->() const { return &self; }
1260         /**
1261          *  Finds a [`Route`] for a payment between the given `payer` and a payee.
1262          *
1263          *  The `payee` and the payment's value are given in [`RouteParameters::payment_params`]
1264          *  and [`RouteParameters::final_value_msat`], respectively.
1265          *
1266          *  Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
1267          */
1268         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);
1269         /**
1270          *  Finds a [`Route`] for a payment between the given `payer` and a payee.
1271          *
1272          *  The `payee` and the payment's value are given in [`RouteParameters::payment_params`]
1273          *  and [`RouteParameters::final_value_msat`], respectively.
1274          *
1275          *  Includes a [`PaymentHash`] and a [`PaymentId`] to be able to correlate the request with a specific
1276          *  payment.
1277          *
1278          *  Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
1279          */
1280         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);
1281         /**
1282          *  Creates [`BlindedPath`]s for payment to the `recipient` node. The channels in `first_hops`
1283          *  are assumed to be with the `recipient`'s peers. The payment secret and any constraints are
1284          *  given in `tlvs`.
1285          */
1286         inline LDK::CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ create_blinded_payment_paths(struct LDKPublicKey recipient, struct LDKCVec_ChannelDetailsZ first_hops, struct LDKReceiveTlvs tlvs, uint64_t amount_msats);
1287 };
1288 class ScorerAccountingForInFlightHtlcs {
1289 private:
1290         LDKScorerAccountingForInFlightHtlcs self;
1291 public:
1292         ScorerAccountingForInFlightHtlcs(const ScorerAccountingForInFlightHtlcs&) = delete;
1293         ScorerAccountingForInFlightHtlcs(ScorerAccountingForInFlightHtlcs&& o) : self(o.self) { memset(&o, 0, sizeof(ScorerAccountingForInFlightHtlcs)); }
1294         ScorerAccountingForInFlightHtlcs(LDKScorerAccountingForInFlightHtlcs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScorerAccountingForInFlightHtlcs)); }
1295         operator LDKScorerAccountingForInFlightHtlcs() && { LDKScorerAccountingForInFlightHtlcs res = self; memset(&self, 0, sizeof(LDKScorerAccountingForInFlightHtlcs)); return res; }
1296         ~ScorerAccountingForInFlightHtlcs() { ScorerAccountingForInFlightHtlcs_free(self); }
1297         ScorerAccountingForInFlightHtlcs& operator=(ScorerAccountingForInFlightHtlcs&& o) { ScorerAccountingForInFlightHtlcs_free(self); self = o.self; memset(&o, 0, sizeof(ScorerAccountingForInFlightHtlcs)); return *this; }
1298         LDKScorerAccountingForInFlightHtlcs* operator &() { return &self; }
1299         LDKScorerAccountingForInFlightHtlcs* operator ->() { return &self; }
1300         const LDKScorerAccountingForInFlightHtlcs* operator &() const { return &self; }
1301         const LDKScorerAccountingForInFlightHtlcs* operator ->() const { return &self; }
1302 };
1303 class InFlightHtlcs {
1304 private:
1305         LDKInFlightHtlcs self;
1306 public:
1307         InFlightHtlcs(const InFlightHtlcs&) = delete;
1308         InFlightHtlcs(InFlightHtlcs&& o) : self(o.self) { memset(&o, 0, sizeof(InFlightHtlcs)); }
1309         InFlightHtlcs(LDKInFlightHtlcs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInFlightHtlcs)); }
1310         operator LDKInFlightHtlcs() && { LDKInFlightHtlcs res = self; memset(&self, 0, sizeof(LDKInFlightHtlcs)); return res; }
1311         ~InFlightHtlcs() { InFlightHtlcs_free(self); }
1312         InFlightHtlcs& operator=(InFlightHtlcs&& o) { InFlightHtlcs_free(self); self = o.self; memset(&o, 0, sizeof(InFlightHtlcs)); return *this; }
1313         LDKInFlightHtlcs* operator &() { return &self; }
1314         LDKInFlightHtlcs* operator ->() { return &self; }
1315         const LDKInFlightHtlcs* operator &() const { return &self; }
1316         const LDKInFlightHtlcs* operator ->() const { return &self; }
1317 };
1318 class RouteHop {
1319 private:
1320         LDKRouteHop self;
1321 public:
1322         RouteHop(const RouteHop&) = delete;
1323         RouteHop(RouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHop)); }
1324         RouteHop(LDKRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHop)); }
1325         operator LDKRouteHop() && { LDKRouteHop res = self; memset(&self, 0, sizeof(LDKRouteHop)); return res; }
1326         ~RouteHop() { RouteHop_free(self); }
1327         RouteHop& operator=(RouteHop&& o) { RouteHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHop)); return *this; }
1328         LDKRouteHop* operator &() { return &self; }
1329         LDKRouteHop* operator ->() { return &self; }
1330         const LDKRouteHop* operator &() const { return &self; }
1331         const LDKRouteHop* operator ->() const { return &self; }
1332 };
1333 class BlindedTail {
1334 private:
1335         LDKBlindedTail self;
1336 public:
1337         BlindedTail(const BlindedTail&) = delete;
1338         BlindedTail(BlindedTail&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedTail)); }
1339         BlindedTail(LDKBlindedTail&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedTail)); }
1340         operator LDKBlindedTail() && { LDKBlindedTail res = self; memset(&self, 0, sizeof(LDKBlindedTail)); return res; }
1341         ~BlindedTail() { BlindedTail_free(self); }
1342         BlindedTail& operator=(BlindedTail&& o) { BlindedTail_free(self); self = o.self; memset(&o, 0, sizeof(BlindedTail)); return *this; }
1343         LDKBlindedTail* operator &() { return &self; }
1344         LDKBlindedTail* operator ->() { return &self; }
1345         const LDKBlindedTail* operator &() const { return &self; }
1346         const LDKBlindedTail* operator ->() const { return &self; }
1347 };
1348 class Path {
1349 private:
1350         LDKPath self;
1351 public:
1352         Path(const Path&) = delete;
1353         Path(Path&& o) : self(o.self) { memset(&o, 0, sizeof(Path)); }
1354         Path(LDKPath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPath)); }
1355         operator LDKPath() && { LDKPath res = self; memset(&self, 0, sizeof(LDKPath)); return res; }
1356         ~Path() { Path_free(self); }
1357         Path& operator=(Path&& o) { Path_free(self); self = o.self; memset(&o, 0, sizeof(Path)); return *this; }
1358         LDKPath* operator &() { return &self; }
1359         LDKPath* operator ->() { return &self; }
1360         const LDKPath* operator &() const { return &self; }
1361         const LDKPath* operator ->() const { return &self; }
1362 };
1363 class Route {
1364 private:
1365         LDKRoute self;
1366 public:
1367         Route(const Route&) = delete;
1368         Route(Route&& o) : self(o.self) { memset(&o, 0, sizeof(Route)); }
1369         Route(LDKRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoute)); }
1370         operator LDKRoute() && { LDKRoute res = self; memset(&self, 0, sizeof(LDKRoute)); return res; }
1371         ~Route() { Route_free(self); }
1372         Route& operator=(Route&& o) { Route_free(self); self = o.self; memset(&o, 0, sizeof(Route)); return *this; }
1373         LDKRoute* operator &() { return &self; }
1374         LDKRoute* operator ->() { return &self; }
1375         const LDKRoute* operator &() const { return &self; }
1376         const LDKRoute* operator ->() const { return &self; }
1377 };
1378 class RouteParameters {
1379 private:
1380         LDKRouteParameters self;
1381 public:
1382         RouteParameters(const RouteParameters&) = delete;
1383         RouteParameters(RouteParameters&& o) : self(o.self) { memset(&o, 0, sizeof(RouteParameters)); }
1384         RouteParameters(LDKRouteParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteParameters)); }
1385         operator LDKRouteParameters() && { LDKRouteParameters res = self; memset(&self, 0, sizeof(LDKRouteParameters)); return res; }
1386         ~RouteParameters() { RouteParameters_free(self); }
1387         RouteParameters& operator=(RouteParameters&& o) { RouteParameters_free(self); self = o.self; memset(&o, 0, sizeof(RouteParameters)); return *this; }
1388         LDKRouteParameters* operator &() { return &self; }
1389         LDKRouteParameters* operator ->() { return &self; }
1390         const LDKRouteParameters* operator &() const { return &self; }
1391         const LDKRouteParameters* operator ->() const { return &self; }
1392 };
1393 class PaymentParameters {
1394 private:
1395         LDKPaymentParameters self;
1396 public:
1397         PaymentParameters(const PaymentParameters&) = delete;
1398         PaymentParameters(PaymentParameters&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentParameters)); }
1399         PaymentParameters(LDKPaymentParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentParameters)); }
1400         operator LDKPaymentParameters() && { LDKPaymentParameters res = self; memset(&self, 0, sizeof(LDKPaymentParameters)); return res; }
1401         ~PaymentParameters() { PaymentParameters_free(self); }
1402         PaymentParameters& operator=(PaymentParameters&& o) { PaymentParameters_free(self); self = o.self; memset(&o, 0, sizeof(PaymentParameters)); return *this; }
1403         LDKPaymentParameters* operator &() { return &self; }
1404         LDKPaymentParameters* operator ->() { return &self; }
1405         const LDKPaymentParameters* operator &() const { return &self; }
1406         const LDKPaymentParameters* operator ->() const { return &self; }
1407 };
1408 class Payee {
1409 private:
1410         LDKPayee self;
1411 public:
1412         Payee(const Payee&) = delete;
1413         Payee(Payee&& o) : self(o.self) { memset(&o, 0, sizeof(Payee)); }
1414         Payee(LDKPayee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayee)); }
1415         operator LDKPayee() && { LDKPayee res = self; memset(&self, 0, sizeof(LDKPayee)); return res; }
1416         ~Payee() { Payee_free(self); }
1417         Payee& operator=(Payee&& o) { Payee_free(self); self = o.self; memset(&o, 0, sizeof(Payee)); return *this; }
1418         LDKPayee* operator &() { return &self; }
1419         LDKPayee* operator ->() { return &self; }
1420         const LDKPayee* operator &() const { return &self; }
1421         const LDKPayee* operator ->() const { return &self; }
1422 };
1423 class RouteHint {
1424 private:
1425         LDKRouteHint self;
1426 public:
1427         RouteHint(const RouteHint&) = delete;
1428         RouteHint(RouteHint&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHint)); }
1429         RouteHint(LDKRouteHint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHint)); }
1430         operator LDKRouteHint() && { LDKRouteHint res = self; memset(&self, 0, sizeof(LDKRouteHint)); return res; }
1431         ~RouteHint() { RouteHint_free(self); }
1432         RouteHint& operator=(RouteHint&& o) { RouteHint_free(self); self = o.self; memset(&o, 0, sizeof(RouteHint)); return *this; }
1433         LDKRouteHint* operator &() { return &self; }
1434         LDKRouteHint* operator ->() { return &self; }
1435         const LDKRouteHint* operator &() const { return &self; }
1436         const LDKRouteHint* operator ->() const { return &self; }
1437 };
1438 class RouteHintHop {
1439 private:
1440         LDKRouteHintHop self;
1441 public:
1442         RouteHintHop(const RouteHintHop&) = delete;
1443         RouteHintHop(RouteHintHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHintHop)); }
1444         RouteHintHop(LDKRouteHintHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHintHop)); }
1445         operator LDKRouteHintHop() && { LDKRouteHintHop res = self; memset(&self, 0, sizeof(LDKRouteHintHop)); return res; }
1446         ~RouteHintHop() { RouteHintHop_free(self); }
1447         RouteHintHop& operator=(RouteHintHop&& o) { RouteHintHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHintHop)); return *this; }
1448         LDKRouteHintHop* operator &() { return &self; }
1449         LDKRouteHintHop* operator ->() { return &self; }
1450         const LDKRouteHintHop* operator &() const { return &self; }
1451         const LDKRouteHintHop* operator ->() const { return &self; }
1452 };
1453 class FirstHopCandidate {
1454 private:
1455         LDKFirstHopCandidate self;
1456 public:
1457         FirstHopCandidate(const FirstHopCandidate&) = delete;
1458         FirstHopCandidate(FirstHopCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(FirstHopCandidate)); }
1459         FirstHopCandidate(LDKFirstHopCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFirstHopCandidate)); }
1460         operator LDKFirstHopCandidate() && { LDKFirstHopCandidate res = self; memset(&self, 0, sizeof(LDKFirstHopCandidate)); return res; }
1461         ~FirstHopCandidate() { FirstHopCandidate_free(self); }
1462         FirstHopCandidate& operator=(FirstHopCandidate&& o) { FirstHopCandidate_free(self); self = o.self; memset(&o, 0, sizeof(FirstHopCandidate)); return *this; }
1463         LDKFirstHopCandidate* operator &() { return &self; }
1464         LDKFirstHopCandidate* operator ->() { return &self; }
1465         const LDKFirstHopCandidate* operator &() const { return &self; }
1466         const LDKFirstHopCandidate* operator ->() const { return &self; }
1467 };
1468 class PublicHopCandidate {
1469 private:
1470         LDKPublicHopCandidate self;
1471 public:
1472         PublicHopCandidate(const PublicHopCandidate&) = delete;
1473         PublicHopCandidate(PublicHopCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(PublicHopCandidate)); }
1474         PublicHopCandidate(LDKPublicHopCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPublicHopCandidate)); }
1475         operator LDKPublicHopCandidate() && { LDKPublicHopCandidate res = self; memset(&self, 0, sizeof(LDKPublicHopCandidate)); return res; }
1476         ~PublicHopCandidate() { PublicHopCandidate_free(self); }
1477         PublicHopCandidate& operator=(PublicHopCandidate&& o) { PublicHopCandidate_free(self); self = o.self; memset(&o, 0, sizeof(PublicHopCandidate)); return *this; }
1478         LDKPublicHopCandidate* operator &() { return &self; }
1479         LDKPublicHopCandidate* operator ->() { return &self; }
1480         const LDKPublicHopCandidate* operator &() const { return &self; }
1481         const LDKPublicHopCandidate* operator ->() const { return &self; }
1482 };
1483 class PrivateHopCandidate {
1484 private:
1485         LDKPrivateHopCandidate self;
1486 public:
1487         PrivateHopCandidate(const PrivateHopCandidate&) = delete;
1488         PrivateHopCandidate(PrivateHopCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(PrivateHopCandidate)); }
1489         PrivateHopCandidate(LDKPrivateHopCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrivateHopCandidate)); }
1490         operator LDKPrivateHopCandidate() && { LDKPrivateHopCandidate res = self; memset(&self, 0, sizeof(LDKPrivateHopCandidate)); return res; }
1491         ~PrivateHopCandidate() { PrivateHopCandidate_free(self); }
1492         PrivateHopCandidate& operator=(PrivateHopCandidate&& o) { PrivateHopCandidate_free(self); self = o.self; memset(&o, 0, sizeof(PrivateHopCandidate)); return *this; }
1493         LDKPrivateHopCandidate* operator &() { return &self; }
1494         LDKPrivateHopCandidate* operator ->() { return &self; }
1495         const LDKPrivateHopCandidate* operator &() const { return &self; }
1496         const LDKPrivateHopCandidate* operator ->() const { return &self; }
1497 };
1498 class BlindedPathCandidate {
1499 private:
1500         LDKBlindedPathCandidate self;
1501 public:
1502         BlindedPathCandidate(const BlindedPathCandidate&) = delete;
1503         BlindedPathCandidate(BlindedPathCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPathCandidate)); }
1504         BlindedPathCandidate(LDKBlindedPathCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPathCandidate)); }
1505         operator LDKBlindedPathCandidate() && { LDKBlindedPathCandidate res = self; memset(&self, 0, sizeof(LDKBlindedPathCandidate)); return res; }
1506         ~BlindedPathCandidate() { BlindedPathCandidate_free(self); }
1507         BlindedPathCandidate& operator=(BlindedPathCandidate&& o) { BlindedPathCandidate_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPathCandidate)); return *this; }
1508         LDKBlindedPathCandidate* operator &() { return &self; }
1509         LDKBlindedPathCandidate* operator ->() { return &self; }
1510         const LDKBlindedPathCandidate* operator &() const { return &self; }
1511         const LDKBlindedPathCandidate* operator ->() const { return &self; }
1512 };
1513 class OneHopBlindedPathCandidate {
1514 private:
1515         LDKOneHopBlindedPathCandidate self;
1516 public:
1517         OneHopBlindedPathCandidate(const OneHopBlindedPathCandidate&) = delete;
1518         OneHopBlindedPathCandidate(OneHopBlindedPathCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(OneHopBlindedPathCandidate)); }
1519         OneHopBlindedPathCandidate(LDKOneHopBlindedPathCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOneHopBlindedPathCandidate)); }
1520         operator LDKOneHopBlindedPathCandidate() && { LDKOneHopBlindedPathCandidate res = self; memset(&self, 0, sizeof(LDKOneHopBlindedPathCandidate)); return res; }
1521         ~OneHopBlindedPathCandidate() { OneHopBlindedPathCandidate_free(self); }
1522         OneHopBlindedPathCandidate& operator=(OneHopBlindedPathCandidate&& o) { OneHopBlindedPathCandidate_free(self); self = o.self; memset(&o, 0, sizeof(OneHopBlindedPathCandidate)); return *this; }
1523         LDKOneHopBlindedPathCandidate* operator &() { return &self; }
1524         LDKOneHopBlindedPathCandidate* operator ->() { return &self; }
1525         const LDKOneHopBlindedPathCandidate* operator &() const { return &self; }
1526         const LDKOneHopBlindedPathCandidate* operator ->() const { return &self; }
1527 };
1528 class CandidateRouteHop {
1529 private:
1530         LDKCandidateRouteHop self;
1531 public:
1532         CandidateRouteHop(const CandidateRouteHop&) = delete;
1533         CandidateRouteHop(CandidateRouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(CandidateRouteHop)); }
1534         CandidateRouteHop(LDKCandidateRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCandidateRouteHop)); }
1535         operator LDKCandidateRouteHop() && { LDKCandidateRouteHop res = self; memset(&self, 0, sizeof(LDKCandidateRouteHop)); return res; }
1536         ~CandidateRouteHop() { CandidateRouteHop_free(self); }
1537         CandidateRouteHop& operator=(CandidateRouteHop&& o) { CandidateRouteHop_free(self); self = o.self; memset(&o, 0, sizeof(CandidateRouteHop)); return *this; }
1538         LDKCandidateRouteHop* operator &() { return &self; }
1539         LDKCandidateRouteHop* operator ->() { return &self; }
1540         const LDKCandidateRouteHop* operator &() const { return &self; }
1541         const LDKCandidateRouteHop* operator ->() const { return &self; }
1542 };
1543 class ScoreLookUp {
1544 private:
1545         LDKScoreLookUp self;
1546 public:
1547         ScoreLookUp(const ScoreLookUp&) = delete;
1548         ScoreLookUp(ScoreLookUp&& o) : self(o.self) { memset(&o, 0, sizeof(ScoreLookUp)); }
1549         ScoreLookUp(LDKScoreLookUp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScoreLookUp)); }
1550         operator LDKScoreLookUp() && { LDKScoreLookUp res = self; memset(&self, 0, sizeof(LDKScoreLookUp)); return res; }
1551         ~ScoreLookUp() { ScoreLookUp_free(self); }
1552         ScoreLookUp& operator=(ScoreLookUp&& o) { ScoreLookUp_free(self); self = o.self; memset(&o, 0, sizeof(ScoreLookUp)); return *this; }
1553         LDKScoreLookUp* operator &() { return &self; }
1554         LDKScoreLookUp* operator ->() { return &self; }
1555         const LDKScoreLookUp* operator &() const { return &self; }
1556         const LDKScoreLookUp* operator ->() const { return &self; }
1557         /**
1558          *  Returns the fee in msats willing to be paid to avoid routing `send_amt_msat` through the
1559          *  given channel in the direction from `source` to `target`.
1560          *
1561          *  The channel's capacity (less any other MPP parts that are also being considered for use in
1562          *  the same payment) is given by `capacity_msat`. It may be determined from various sources
1563          *  such as a chain data, network gossip, or invoice hints. For invoice hints, a capacity near
1564          *  [`u64::max_value`] is given to indicate sufficient capacity for the invoice's full amount.
1565          *  Thus, implementations should be overflow-safe.
1566          */
1567         inline uint64_t channel_penalty_msat(const struct LDKCandidateRouteHop *NONNULL_PTR candidate, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params);
1568 };
1569 class ScoreUpdate {
1570 private:
1571         LDKScoreUpdate self;
1572 public:
1573         ScoreUpdate(const ScoreUpdate&) = delete;
1574         ScoreUpdate(ScoreUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ScoreUpdate)); }
1575         ScoreUpdate(LDKScoreUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScoreUpdate)); }
1576         operator LDKScoreUpdate() && { LDKScoreUpdate res = self; memset(&self, 0, sizeof(LDKScoreUpdate)); return res; }
1577         ~ScoreUpdate() { ScoreUpdate_free(self); }
1578         ScoreUpdate& operator=(ScoreUpdate&& o) { ScoreUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ScoreUpdate)); return *this; }
1579         LDKScoreUpdate* operator &() { return &self; }
1580         LDKScoreUpdate* operator ->() { return &self; }
1581         const LDKScoreUpdate* operator &() const { return &self; }
1582         const LDKScoreUpdate* operator ->() const { return &self; }
1583         /**
1584          *  Handles updating channel penalties after failing to route through a channel.
1585          */
1586         inline void payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch);
1587         /**
1588          *  Handles updating channel penalties after successfully routing along a path.
1589          */
1590         inline void payment_path_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch);
1591         /**
1592          *  Handles updating channel penalties after a probe over the given path failed.
1593          */
1594         inline void probe_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch);
1595         /**
1596          *  Handles updating channel penalties after a probe over the given path succeeded.
1597          */
1598         inline void probe_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch);
1599         /**
1600          *  Scorers may wish to reduce their certainty of channel liquidity information over time.
1601          *  Thus, this method is provided to allow scorers to observe the passage of time - the holder
1602          *  of this object should call this method regularly (generally via the
1603          *  `lightning-background-processor` crate).
1604          */
1605         inline void time_passed(uint64_t duration_since_epoch);
1606 };
1607 class Score {
1608 private:
1609         LDKScore self;
1610 public:
1611         Score(const Score&) = delete;
1612         Score(Score&& o) : self(o.self) { memset(&o, 0, sizeof(Score)); }
1613         Score(LDKScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScore)); }
1614         operator LDKScore() && { LDKScore res = self; memset(&self, 0, sizeof(LDKScore)); return res; }
1615         ~Score() { Score_free(self); }
1616         Score& operator=(Score&& o) { Score_free(self); self = o.self; memset(&o, 0, sizeof(Score)); return *this; }
1617         LDKScore* operator &() { return &self; }
1618         LDKScore* operator ->() { return &self; }
1619         const LDKScore* operator &() const { return &self; }
1620         const LDKScore* operator ->() const { return &self; }
1621 };
1622 class LockableScore {
1623 private:
1624         LDKLockableScore self;
1625 public:
1626         LockableScore(const LockableScore&) = delete;
1627         LockableScore(LockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(LockableScore)); }
1628         LockableScore(LDKLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockableScore)); }
1629         operator LDKLockableScore() && { LDKLockableScore res = self; memset(&self, 0, sizeof(LDKLockableScore)); return res; }
1630         ~LockableScore() { LockableScore_free(self); }
1631         LockableScore& operator=(LockableScore&& o) { LockableScore_free(self); self = o.self; memset(&o, 0, sizeof(LockableScore)); return *this; }
1632         LDKLockableScore* operator &() { return &self; }
1633         LDKLockableScore* operator ->() { return &self; }
1634         const LDKLockableScore* operator &() const { return &self; }
1635         const LDKLockableScore* operator ->() const { return &self; }
1636         /**
1637          *  Returns read locked scorer.
1638          */
1639         inline LDK::ScoreLookUp read_lock();
1640         /**
1641          *  Returns write locked scorer.
1642          */
1643         inline LDK::ScoreUpdate write_lock();
1644 };
1645 class WriteableScore {
1646 private:
1647         LDKWriteableScore self;
1648 public:
1649         WriteableScore(const WriteableScore&) = delete;
1650         WriteableScore(WriteableScore&& o) : self(o.self) { memset(&o, 0, sizeof(WriteableScore)); }
1651         WriteableScore(LDKWriteableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWriteableScore)); }
1652         operator LDKWriteableScore() && { LDKWriteableScore res = self; memset(&self, 0, sizeof(LDKWriteableScore)); return res; }
1653         ~WriteableScore() { WriteableScore_free(self); }
1654         WriteableScore& operator=(WriteableScore&& o) { WriteableScore_free(self); self = o.self; memset(&o, 0, sizeof(WriteableScore)); return *this; }
1655         LDKWriteableScore* operator &() { return &self; }
1656         LDKWriteableScore* operator ->() { return &self; }
1657         const LDKWriteableScore* operator &() const { return &self; }
1658         const LDKWriteableScore* operator ->() const { return &self; }
1659 };
1660 class MultiThreadedLockableScore {
1661 private:
1662         LDKMultiThreadedLockableScore self;
1663 public:
1664         MultiThreadedLockableScore(const MultiThreadedLockableScore&) = delete;
1665         MultiThreadedLockableScore(MultiThreadedLockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedLockableScore)); }
1666         MultiThreadedLockableScore(LDKMultiThreadedLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedLockableScore)); }
1667         operator LDKMultiThreadedLockableScore() && { LDKMultiThreadedLockableScore res = self; memset(&self, 0, sizeof(LDKMultiThreadedLockableScore)); return res; }
1668         ~MultiThreadedLockableScore() { MultiThreadedLockableScore_free(self); }
1669         MultiThreadedLockableScore& operator=(MultiThreadedLockableScore&& o) { MultiThreadedLockableScore_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedLockableScore)); return *this; }
1670         LDKMultiThreadedLockableScore* operator &() { return &self; }
1671         LDKMultiThreadedLockableScore* operator ->() { return &self; }
1672         const LDKMultiThreadedLockableScore* operator &() const { return &self; }
1673         const LDKMultiThreadedLockableScore* operator ->() const { return &self; }
1674 };
1675 class MultiThreadedScoreLockRead {
1676 private:
1677         LDKMultiThreadedScoreLockRead self;
1678 public:
1679         MultiThreadedScoreLockRead(const MultiThreadedScoreLockRead&) = delete;
1680         MultiThreadedScoreLockRead(MultiThreadedScoreLockRead&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedScoreLockRead)); }
1681         MultiThreadedScoreLockRead(LDKMultiThreadedScoreLockRead&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedScoreLockRead)); }
1682         operator LDKMultiThreadedScoreLockRead() && { LDKMultiThreadedScoreLockRead res = self; memset(&self, 0, sizeof(LDKMultiThreadedScoreLockRead)); return res; }
1683         ~MultiThreadedScoreLockRead() { MultiThreadedScoreLockRead_free(self); }
1684         MultiThreadedScoreLockRead& operator=(MultiThreadedScoreLockRead&& o) { MultiThreadedScoreLockRead_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedScoreLockRead)); return *this; }
1685         LDKMultiThreadedScoreLockRead* operator &() { return &self; }
1686         LDKMultiThreadedScoreLockRead* operator ->() { return &self; }
1687         const LDKMultiThreadedScoreLockRead* operator &() const { return &self; }
1688         const LDKMultiThreadedScoreLockRead* operator ->() const { return &self; }
1689 };
1690 class MultiThreadedScoreLockWrite {
1691 private:
1692         LDKMultiThreadedScoreLockWrite self;
1693 public:
1694         MultiThreadedScoreLockWrite(const MultiThreadedScoreLockWrite&) = delete;
1695         MultiThreadedScoreLockWrite(MultiThreadedScoreLockWrite&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedScoreLockWrite)); }
1696         MultiThreadedScoreLockWrite(LDKMultiThreadedScoreLockWrite&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedScoreLockWrite)); }
1697         operator LDKMultiThreadedScoreLockWrite() && { LDKMultiThreadedScoreLockWrite res = self; memset(&self, 0, sizeof(LDKMultiThreadedScoreLockWrite)); return res; }
1698         ~MultiThreadedScoreLockWrite() { MultiThreadedScoreLockWrite_free(self); }
1699         MultiThreadedScoreLockWrite& operator=(MultiThreadedScoreLockWrite&& o) { MultiThreadedScoreLockWrite_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedScoreLockWrite)); return *this; }
1700         LDKMultiThreadedScoreLockWrite* operator &() { return &self; }
1701         LDKMultiThreadedScoreLockWrite* operator ->() { return &self; }
1702         const LDKMultiThreadedScoreLockWrite* operator &() const { return &self; }
1703         const LDKMultiThreadedScoreLockWrite* operator ->() const { return &self; }
1704 };
1705 class ChannelUsage {
1706 private:
1707         LDKChannelUsage self;
1708 public:
1709         ChannelUsage(const ChannelUsage&) = delete;
1710         ChannelUsage(ChannelUsage&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUsage)); }
1711         ChannelUsage(LDKChannelUsage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUsage)); }
1712         operator LDKChannelUsage() && { LDKChannelUsage res = self; memset(&self, 0, sizeof(LDKChannelUsage)); return res; }
1713         ~ChannelUsage() { ChannelUsage_free(self); }
1714         ChannelUsage& operator=(ChannelUsage&& o) { ChannelUsage_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUsage)); return *this; }
1715         LDKChannelUsage* operator &() { return &self; }
1716         LDKChannelUsage* operator ->() { return &self; }
1717         const LDKChannelUsage* operator &() const { return &self; }
1718         const LDKChannelUsage* operator ->() const { return &self; }
1719 };
1720 class FixedPenaltyScorer {
1721 private:
1722         LDKFixedPenaltyScorer self;
1723 public:
1724         FixedPenaltyScorer(const FixedPenaltyScorer&) = delete;
1725         FixedPenaltyScorer(FixedPenaltyScorer&& o) : self(o.self) { memset(&o, 0, sizeof(FixedPenaltyScorer)); }
1726         FixedPenaltyScorer(LDKFixedPenaltyScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFixedPenaltyScorer)); }
1727         operator LDKFixedPenaltyScorer() && { LDKFixedPenaltyScorer res = self; memset(&self, 0, sizeof(LDKFixedPenaltyScorer)); return res; }
1728         ~FixedPenaltyScorer() { FixedPenaltyScorer_free(self); }
1729         FixedPenaltyScorer& operator=(FixedPenaltyScorer&& o) { FixedPenaltyScorer_free(self); self = o.self; memset(&o, 0, sizeof(FixedPenaltyScorer)); return *this; }
1730         LDKFixedPenaltyScorer* operator &() { return &self; }
1731         LDKFixedPenaltyScorer* operator ->() { return &self; }
1732         const LDKFixedPenaltyScorer* operator &() const { return &self; }
1733         const LDKFixedPenaltyScorer* operator ->() const { return &self; }
1734 };
1735 class ProbabilisticScorer {
1736 private:
1737         LDKProbabilisticScorer self;
1738 public:
1739         ProbabilisticScorer(const ProbabilisticScorer&) = delete;
1740         ProbabilisticScorer(ProbabilisticScorer&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScorer)); }
1741         ProbabilisticScorer(LDKProbabilisticScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScorer)); }
1742         operator LDKProbabilisticScorer() && { LDKProbabilisticScorer res = self; memset(&self, 0, sizeof(LDKProbabilisticScorer)); return res; }
1743         ~ProbabilisticScorer() { ProbabilisticScorer_free(self); }
1744         ProbabilisticScorer& operator=(ProbabilisticScorer&& o) { ProbabilisticScorer_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScorer)); return *this; }
1745         LDKProbabilisticScorer* operator &() { return &self; }
1746         LDKProbabilisticScorer* operator ->() { return &self; }
1747         const LDKProbabilisticScorer* operator &() const { return &self; }
1748         const LDKProbabilisticScorer* operator ->() const { return &self; }
1749 };
1750 class ProbabilisticScoringFeeParameters {
1751 private:
1752         LDKProbabilisticScoringFeeParameters self;
1753 public:
1754         ProbabilisticScoringFeeParameters(const ProbabilisticScoringFeeParameters&) = delete;
1755         ProbabilisticScoringFeeParameters(ProbabilisticScoringFeeParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScoringFeeParameters)); }
1756         ProbabilisticScoringFeeParameters(LDKProbabilisticScoringFeeParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScoringFeeParameters)); }
1757         operator LDKProbabilisticScoringFeeParameters() && { LDKProbabilisticScoringFeeParameters res = self; memset(&self, 0, sizeof(LDKProbabilisticScoringFeeParameters)); return res; }
1758         ~ProbabilisticScoringFeeParameters() { ProbabilisticScoringFeeParameters_free(self); }
1759         ProbabilisticScoringFeeParameters& operator=(ProbabilisticScoringFeeParameters&& o) { ProbabilisticScoringFeeParameters_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScoringFeeParameters)); return *this; }
1760         LDKProbabilisticScoringFeeParameters* operator &() { return &self; }
1761         LDKProbabilisticScoringFeeParameters* operator ->() { return &self; }
1762         const LDKProbabilisticScoringFeeParameters* operator &() const { return &self; }
1763         const LDKProbabilisticScoringFeeParameters* operator ->() const { return &self; }
1764 };
1765 class ProbabilisticScoringDecayParameters {
1766 private:
1767         LDKProbabilisticScoringDecayParameters self;
1768 public:
1769         ProbabilisticScoringDecayParameters(const ProbabilisticScoringDecayParameters&) = delete;
1770         ProbabilisticScoringDecayParameters(ProbabilisticScoringDecayParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScoringDecayParameters)); }
1771         ProbabilisticScoringDecayParameters(LDKProbabilisticScoringDecayParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScoringDecayParameters)); }
1772         operator LDKProbabilisticScoringDecayParameters() && { LDKProbabilisticScoringDecayParameters res = self; memset(&self, 0, sizeof(LDKProbabilisticScoringDecayParameters)); return res; }
1773         ~ProbabilisticScoringDecayParameters() { ProbabilisticScoringDecayParameters_free(self); }
1774         ProbabilisticScoringDecayParameters& operator=(ProbabilisticScoringDecayParameters&& o) { ProbabilisticScoringDecayParameters_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScoringDecayParameters)); return *this; }
1775         LDKProbabilisticScoringDecayParameters* operator &() { return &self; }
1776         LDKProbabilisticScoringDecayParameters* operator ->() { return &self; }
1777         const LDKProbabilisticScoringDecayParameters* operator &() const { return &self; }
1778         const LDKProbabilisticScoringDecayParameters* operator ->() const { return &self; }
1779 };
1780 class BestBlock {
1781 private:
1782         LDKBestBlock self;
1783 public:
1784         BestBlock(const BestBlock&) = delete;
1785         BestBlock(BestBlock&& o) : self(o.self) { memset(&o, 0, sizeof(BestBlock)); }
1786         BestBlock(LDKBestBlock&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBestBlock)); }
1787         operator LDKBestBlock() && { LDKBestBlock res = self; memset(&self, 0, sizeof(LDKBestBlock)); return res; }
1788         ~BestBlock() { BestBlock_free(self); }
1789         BestBlock& operator=(BestBlock&& o) { BestBlock_free(self); self = o.self; memset(&o, 0, sizeof(BestBlock)); return *this; }
1790         LDKBestBlock* operator &() { return &self; }
1791         LDKBestBlock* operator ->() { return &self; }
1792         const LDKBestBlock* operator &() const { return &self; }
1793         const LDKBestBlock* operator ->() const { return &self; }
1794 };
1795 class Listen {
1796 private:
1797         LDKListen self;
1798 public:
1799         Listen(const Listen&) = delete;
1800         Listen(Listen&& o) : self(o.self) { memset(&o, 0, sizeof(Listen)); }
1801         Listen(LDKListen&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKListen)); }
1802         operator LDKListen() && { LDKListen res = self; memset(&self, 0, sizeof(LDKListen)); return res; }
1803         ~Listen() { Listen_free(self); }
1804         Listen& operator=(Listen&& o) { Listen_free(self); self = o.self; memset(&o, 0, sizeof(Listen)); return *this; }
1805         LDKListen* operator &() { return &self; }
1806         LDKListen* operator ->() { return &self; }
1807         const LDKListen* operator &() const { return &self; }
1808         const LDKListen* operator ->() const { return &self; }
1809         /**
1810          *  Notifies the listener that a block was added at the given height, with the transaction data
1811          *  possibly filtered.
1812          */
1813         inline void filtered_block_connected(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
1814         /**
1815          *  Notifies the listener that a block was added at the given height.
1816          */
1817         inline void block_connected(struct LDKu8slice block, uint32_t height);
1818         /**
1819          *  Notifies the listener that a block was removed at the given height.
1820          */
1821         inline void block_disconnected(const uint8_t (*header)[80], uint32_t height);
1822 };
1823 class Confirm {
1824 private:
1825         LDKConfirm self;
1826 public:
1827         Confirm(const Confirm&) = delete;
1828         Confirm(Confirm&& o) : self(o.self) { memset(&o, 0, sizeof(Confirm)); }
1829         Confirm(LDKConfirm&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirm)); }
1830         operator LDKConfirm() && { LDKConfirm res = self; memset(&self, 0, sizeof(LDKConfirm)); return res; }
1831         ~Confirm() { Confirm_free(self); }
1832         Confirm& operator=(Confirm&& o) { Confirm_free(self); self = o.self; memset(&o, 0, sizeof(Confirm)); return *this; }
1833         LDKConfirm* operator &() { return &self; }
1834         LDKConfirm* operator ->() { return &self; }
1835         const LDKConfirm* operator &() const { return &self; }
1836         const LDKConfirm* operator ->() const { return &self; }
1837         /**
1838          *  Notifies LDK of transactions confirmed in a block with a given header and height.
1839          *
1840          *  Must be called for any transactions registered by [`Filter::register_tx`] or any
1841          *  transactions spending an output registered by [`Filter::register_output`]. Such transactions
1842          *  appearing in the same block do not need to be included in the same call; instead, multiple
1843          *  calls with additional transactions may be made so long as they are made in [chain order].
1844          *
1845          *  May be called before or after [`best_block_updated`] for the corresponding block. However,
1846          *  in the event of a chain reorganization, it must not be called with a `header` that is no
1847          *  longer in the chain as of the last call to [`best_block_updated`].
1848          *
1849          *  [chain order]: Confirm#order
1850          *  [`best_block_updated`]: Self::best_block_updated
1851          */
1852         inline void transactions_confirmed(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
1853         /**
1854          *  Notifies LDK of a transaction that is no longer confirmed as result of a chain reorganization.
1855          *
1856          *  Must be called for any transaction returned by [`get_relevant_txids`] if it has been
1857          *  reorganized out of the best chain or if it is no longer confirmed in the block with the
1858          *  given block hash. Once called, the given transaction will not be returned
1859          *  by [`get_relevant_txids`], unless it has been reconfirmed via [`transactions_confirmed`].
1860          *
1861          *  [`get_relevant_txids`]: Self::get_relevant_txids
1862          *  [`transactions_confirmed`]: Self::transactions_confirmed
1863          */
1864         inline void transaction_unconfirmed(const uint8_t (*txid)[32]);
1865         /**
1866          *  Notifies LDK of an update to the best header connected at the given height.
1867          *
1868          *  Must be called whenever a new chain tip becomes available. May be skipped for intermediary
1869          *  blocks.
1870          */
1871         inline void best_block_updated(const uint8_t (*header)[80], uint32_t height);
1872         /**
1873          *  Returns transactions that must be monitored for reorganization out of the chain along
1874          *  with the height and the hash of the block as part of which it had been previously confirmed.
1875          *
1876          *  Note that the returned `Option<BlockHash>` might be `None` for channels created with LDK
1877          *  0.0.112 and prior, in which case you need to manually track previous confirmations.
1878          *
1879          *  Will include any transactions passed to [`transactions_confirmed`] that have insufficient
1880          *  confirmations to be safe from a chain reorganization. Will not include any transactions
1881          *  passed to [`transaction_unconfirmed`], unless later reconfirmed.
1882          *
1883          *  Must be called to determine the subset of transactions that must be monitored for
1884          *  reorganization. Will be idempotent between calls but may change as a result of calls to the
1885          *  other interface methods. Thus, this is useful to determine which transactions must be
1886          *  given to [`transaction_unconfirmed`].
1887          *
1888          *  If any of the returned transactions are confirmed in a block other than the one with the
1889          *  given hash at the given height, they need to be unconfirmed and reconfirmed via
1890          *  [`transaction_unconfirmed`] and [`transactions_confirmed`], respectively.
1891          *
1892          *  [`transactions_confirmed`]: Self::transactions_confirmed
1893          *  [`transaction_unconfirmed`]: Self::transaction_unconfirmed
1894          */
1895         inline LDK::CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ get_relevant_txids();
1896 };
1897 class ChannelMonitorUpdateStatus {
1898 private:
1899         LDKChannelMonitorUpdateStatus self;
1900 public:
1901         ChannelMonitorUpdateStatus(const ChannelMonitorUpdateStatus&) = delete;
1902         ChannelMonitorUpdateStatus(ChannelMonitorUpdateStatus&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateStatus)); }
1903         ChannelMonitorUpdateStatus(LDKChannelMonitorUpdateStatus&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateStatus)); }
1904         operator LDKChannelMonitorUpdateStatus() && { LDKChannelMonitorUpdateStatus res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateStatus)); return res; }
1905         ChannelMonitorUpdateStatus& operator=(ChannelMonitorUpdateStatus&& o) { self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdateStatus)); return *this; }
1906         LDKChannelMonitorUpdateStatus* operator &() { return &self; }
1907         LDKChannelMonitorUpdateStatus* operator ->() { return &self; }
1908         const LDKChannelMonitorUpdateStatus* operator &() const { return &self; }
1909         const LDKChannelMonitorUpdateStatus* operator ->() const { return &self; }
1910 };
1911 class Watch {
1912 private:
1913         LDKWatch self;
1914 public:
1915         Watch(const Watch&) = delete;
1916         Watch(Watch&& o) : self(o.self) { memset(&o, 0, sizeof(Watch)); }
1917         Watch(LDKWatch&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatch)); }
1918         operator LDKWatch() && { LDKWatch res = self; memset(&self, 0, sizeof(LDKWatch)); return res; }
1919         ~Watch() { Watch_free(self); }
1920         Watch& operator=(Watch&& o) { Watch_free(self); self = o.self; memset(&o, 0, sizeof(Watch)); return *this; }
1921         LDKWatch* operator &() { return &self; }
1922         LDKWatch* operator ->() { return &self; }
1923         const LDKWatch* operator &() const { return &self; }
1924         const LDKWatch* operator ->() const { return &self; }
1925         /**
1926          *  Watches a channel identified by `funding_txo` using `monitor`.
1927          *
1928          *  Implementations are responsible for watching the chain for the funding transaction along
1929          *  with any spends of outputs returned by [`get_outputs_to_watch`]. In practice, this means
1930          *  calling [`block_connected`] and [`block_disconnected`] on the monitor.
1931          *
1932          *  A return of `Err(())` indicates that the channel should immediately be force-closed without
1933          *  broadcasting the funding transaction.
1934          *
1935          *  If the given `funding_txo` has previously been registered via `watch_channel`, `Err(())`
1936          *  must be returned.
1937          *
1938          *  [`get_outputs_to_watch`]: channelmonitor::ChannelMonitor::get_outputs_to_watch
1939          *  [`block_connected`]: channelmonitor::ChannelMonitor::block_connected
1940          *  [`block_disconnected`]: channelmonitor::ChannelMonitor::block_disconnected
1941          */
1942         inline LDK::CResult_ChannelMonitorUpdateStatusNoneZ watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor);
1943         /**
1944          *  Updates a channel identified by `funding_txo` by applying `update` to its monitor.
1945          *
1946          *  Implementations must call [`ChannelMonitor::update_monitor`] with the given update. This
1947          *  may fail (returning an `Err(())`), in which case this should return
1948          *  [`ChannelMonitorUpdateStatus::InProgress`] (and the update should never complete). This
1949          *  generally implies the channel has been closed (either by the funding outpoint being spent
1950          *  on-chain or the [`ChannelMonitor`] having decided to do so and broadcasted a transaction),
1951          *  and the [`ChannelManager`] state will be updated once it sees the funding spend on-chain.
1952          *
1953          *  In general, persistence failures should be retried after returning
1954          *  [`ChannelMonitorUpdateStatus::InProgress`] and eventually complete. If a failure truly
1955          *  cannot be retried, the node should shut down immediately after returning
1956          *  [`ChannelMonitorUpdateStatus::UnrecoverableError`], see its documentation for more info.
1957          *
1958          *  [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
1959          */
1960         inline LDK::ChannelMonitorUpdateStatus update_channel(struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update);
1961         /**
1962          *  Returns any monitor events since the last call. Subsequent calls must only return new
1963          *  events.
1964          *
1965          *  Note that after any block- or transaction-connection calls to a [`ChannelMonitor`], no
1966          *  further events may be returned here until the [`ChannelMonitor`] has been fully persisted
1967          *  to disk.
1968          *
1969          *  For details on asynchronous [`ChannelMonitor`] updating and returning
1970          *  [`MonitorEvent::Completed`] here, see [`ChannelMonitorUpdateStatus::InProgress`].
1971          */
1972         inline LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ release_pending_monitor_events();
1973 };
1974 class Filter {
1975 private:
1976         LDKFilter self;
1977 public:
1978         Filter(const Filter&) = delete;
1979         Filter(Filter&& o) : self(o.self) { memset(&o, 0, sizeof(Filter)); }
1980         Filter(LDKFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilter)); }
1981         operator LDKFilter() && { LDKFilter res = self; memset(&self, 0, sizeof(LDKFilter)); return res; }
1982         ~Filter() { Filter_free(self); }
1983         Filter& operator=(Filter&& o) { Filter_free(self); self = o.self; memset(&o, 0, sizeof(Filter)); return *this; }
1984         LDKFilter* operator &() { return &self; }
1985         LDKFilter* operator ->() { return &self; }
1986         const LDKFilter* operator &() const { return &self; }
1987         const LDKFilter* operator ->() const { return &self; }
1988         /**
1989          *  Registers interest in a transaction with `txid` and having an output with `script_pubkey` as
1990          *  a spending condition.
1991          */
1992         inline void register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey);
1993         /**
1994          *  Registers interest in spends of a transaction output.
1995          *
1996          *  Note that this method might be called during processing of a new block. You therefore need
1997          *  to ensure that also dependent output spents within an already connected block are correctly
1998          *  handled, e.g., by re-scanning the block in question whenever new outputs have been
1999          *  registered mid-processing.
2000          */
2001         inline void register_output(struct LDKWatchedOutput output);
2002 };
2003 class WatchedOutput {
2004 private:
2005         LDKWatchedOutput self;
2006 public:
2007         WatchedOutput(const WatchedOutput&) = delete;
2008         WatchedOutput(WatchedOutput&& o) : self(o.self) { memset(&o, 0, sizeof(WatchedOutput)); }
2009         WatchedOutput(LDKWatchedOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatchedOutput)); }
2010         operator LDKWatchedOutput() && { LDKWatchedOutput res = self; memset(&self, 0, sizeof(LDKWatchedOutput)); return res; }
2011         ~WatchedOutput() { WatchedOutput_free(self); }
2012         WatchedOutput& operator=(WatchedOutput&& o) { WatchedOutput_free(self); self = o.self; memset(&o, 0, sizeof(WatchedOutput)); return *this; }
2013         LDKWatchedOutput* operator &() { return &self; }
2014         LDKWatchedOutput* operator ->() { return &self; }
2015         const LDKWatchedOutput* operator &() const { return &self; }
2016         const LDKWatchedOutput* operator ->() const { return &self; }
2017 };
2018 class InitFeatures {
2019 private:
2020         LDKInitFeatures self;
2021 public:
2022         InitFeatures(const InitFeatures&) = delete;
2023         InitFeatures(InitFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InitFeatures)); }
2024         InitFeatures(LDKInitFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInitFeatures)); }
2025         operator LDKInitFeatures() && { LDKInitFeatures res = self; memset(&self, 0, sizeof(LDKInitFeatures)); return res; }
2026         ~InitFeatures() { InitFeatures_free(self); }
2027         InitFeatures& operator=(InitFeatures&& o) { InitFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InitFeatures)); return *this; }
2028         LDKInitFeatures* operator &() { return &self; }
2029         LDKInitFeatures* operator ->() { return &self; }
2030         const LDKInitFeatures* operator &() const { return &self; }
2031         const LDKInitFeatures* operator ->() const { return &self; }
2032 };
2033 class NodeFeatures {
2034 private:
2035         LDKNodeFeatures self;
2036 public:
2037         NodeFeatures(const NodeFeatures&) = delete;
2038         NodeFeatures(NodeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(NodeFeatures)); }
2039         NodeFeatures(LDKNodeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeFeatures)); }
2040         operator LDKNodeFeatures() && { LDKNodeFeatures res = self; memset(&self, 0, sizeof(LDKNodeFeatures)); return res; }
2041         ~NodeFeatures() { NodeFeatures_free(self); }
2042         NodeFeatures& operator=(NodeFeatures&& o) { NodeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(NodeFeatures)); return *this; }
2043         LDKNodeFeatures* operator &() { return &self; }
2044         LDKNodeFeatures* operator ->() { return &self; }
2045         const LDKNodeFeatures* operator &() const { return &self; }
2046         const LDKNodeFeatures* operator ->() const { return &self; }
2047 };
2048 class ChannelFeatures {
2049 private:
2050         LDKChannelFeatures self;
2051 public:
2052         ChannelFeatures(const ChannelFeatures&) = delete;
2053         ChannelFeatures(ChannelFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelFeatures)); }
2054         ChannelFeatures(LDKChannelFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelFeatures)); }
2055         operator LDKChannelFeatures() && { LDKChannelFeatures res = self; memset(&self, 0, sizeof(LDKChannelFeatures)); return res; }
2056         ~ChannelFeatures() { ChannelFeatures_free(self); }
2057         ChannelFeatures& operator=(ChannelFeatures&& o) { ChannelFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelFeatures)); return *this; }
2058         LDKChannelFeatures* operator &() { return &self; }
2059         LDKChannelFeatures* operator ->() { return &self; }
2060         const LDKChannelFeatures* operator &() const { return &self; }
2061         const LDKChannelFeatures* operator ->() const { return &self; }
2062 };
2063 class Bolt11InvoiceFeatures {
2064 private:
2065         LDKBolt11InvoiceFeatures self;
2066 public:
2067         Bolt11InvoiceFeatures(const Bolt11InvoiceFeatures&) = delete;
2068         Bolt11InvoiceFeatures(Bolt11InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11InvoiceFeatures)); }
2069         Bolt11InvoiceFeatures(LDKBolt11InvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11InvoiceFeatures)); }
2070         operator LDKBolt11InvoiceFeatures() && { LDKBolt11InvoiceFeatures res = self; memset(&self, 0, sizeof(LDKBolt11InvoiceFeatures)); return res; }
2071         ~Bolt11InvoiceFeatures() { Bolt11InvoiceFeatures_free(self); }
2072         Bolt11InvoiceFeatures& operator=(Bolt11InvoiceFeatures&& o) { Bolt11InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11InvoiceFeatures)); return *this; }
2073         LDKBolt11InvoiceFeatures* operator &() { return &self; }
2074         LDKBolt11InvoiceFeatures* operator ->() { return &self; }
2075         const LDKBolt11InvoiceFeatures* operator &() const { return &self; }
2076         const LDKBolt11InvoiceFeatures* operator ->() const { return &self; }
2077 };
2078 class OfferFeatures {
2079 private:
2080         LDKOfferFeatures self;
2081 public:
2082         OfferFeatures(const OfferFeatures&) = delete;
2083         OfferFeatures(OfferFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(OfferFeatures)); }
2084         OfferFeatures(LDKOfferFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferFeatures)); }
2085         operator LDKOfferFeatures() && { LDKOfferFeatures res = self; memset(&self, 0, sizeof(LDKOfferFeatures)); return res; }
2086         ~OfferFeatures() { OfferFeatures_free(self); }
2087         OfferFeatures& operator=(OfferFeatures&& o) { OfferFeatures_free(self); self = o.self; memset(&o, 0, sizeof(OfferFeatures)); return *this; }
2088         LDKOfferFeatures* operator &() { return &self; }
2089         LDKOfferFeatures* operator ->() { return &self; }
2090         const LDKOfferFeatures* operator &() const { return &self; }
2091         const LDKOfferFeatures* operator ->() const { return &self; }
2092 };
2093 class InvoiceRequestFeatures {
2094 private:
2095         LDKInvoiceRequestFeatures self;
2096 public:
2097         InvoiceRequestFeatures(const InvoiceRequestFeatures&) = delete;
2098         InvoiceRequestFeatures(InvoiceRequestFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestFeatures)); }
2099         InvoiceRequestFeatures(LDKInvoiceRequestFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestFeatures)); }
2100         operator LDKInvoiceRequestFeatures() && { LDKInvoiceRequestFeatures res = self; memset(&self, 0, sizeof(LDKInvoiceRequestFeatures)); return res; }
2101         ~InvoiceRequestFeatures() { InvoiceRequestFeatures_free(self); }
2102         InvoiceRequestFeatures& operator=(InvoiceRequestFeatures&& o) { InvoiceRequestFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestFeatures)); return *this; }
2103         LDKInvoiceRequestFeatures* operator &() { return &self; }
2104         LDKInvoiceRequestFeatures* operator ->() { return &self; }
2105         const LDKInvoiceRequestFeatures* operator &() const { return &self; }
2106         const LDKInvoiceRequestFeatures* operator ->() const { return &self; }
2107 };
2108 class Bolt12InvoiceFeatures {
2109 private:
2110         LDKBolt12InvoiceFeatures self;
2111 public:
2112         Bolt12InvoiceFeatures(const Bolt12InvoiceFeatures&) = delete;
2113         Bolt12InvoiceFeatures(Bolt12InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12InvoiceFeatures)); }
2114         Bolt12InvoiceFeatures(LDKBolt12InvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12InvoiceFeatures)); }
2115         operator LDKBolt12InvoiceFeatures() && { LDKBolt12InvoiceFeatures res = self; memset(&self, 0, sizeof(LDKBolt12InvoiceFeatures)); return res; }
2116         ~Bolt12InvoiceFeatures() { Bolt12InvoiceFeatures_free(self); }
2117         Bolt12InvoiceFeatures& operator=(Bolt12InvoiceFeatures&& o) { Bolt12InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12InvoiceFeatures)); return *this; }
2118         LDKBolt12InvoiceFeatures* operator &() { return &self; }
2119         LDKBolt12InvoiceFeatures* operator ->() { return &self; }
2120         const LDKBolt12InvoiceFeatures* operator &() const { return &self; }
2121         const LDKBolt12InvoiceFeatures* operator ->() const { return &self; }
2122 };
2123 class BlindedHopFeatures {
2124 private:
2125         LDKBlindedHopFeatures self;
2126 public:
2127         BlindedHopFeatures(const BlindedHopFeatures&) = delete;
2128         BlindedHopFeatures(BlindedHopFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedHopFeatures)); }
2129         BlindedHopFeatures(LDKBlindedHopFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedHopFeatures)); }
2130         operator LDKBlindedHopFeatures() && { LDKBlindedHopFeatures res = self; memset(&self, 0, sizeof(LDKBlindedHopFeatures)); return res; }
2131         ~BlindedHopFeatures() { BlindedHopFeatures_free(self); }
2132         BlindedHopFeatures& operator=(BlindedHopFeatures&& o) { BlindedHopFeatures_free(self); self = o.self; memset(&o, 0, sizeof(BlindedHopFeatures)); return *this; }
2133         LDKBlindedHopFeatures* operator &() { return &self; }
2134         LDKBlindedHopFeatures* operator ->() { return &self; }
2135         const LDKBlindedHopFeatures* operator &() const { return &self; }
2136         const LDKBlindedHopFeatures* operator ->() const { return &self; }
2137 };
2138 class ChannelTypeFeatures {
2139 private:
2140         LDKChannelTypeFeatures self;
2141 public:
2142         ChannelTypeFeatures(const ChannelTypeFeatures&) = delete;
2143         ChannelTypeFeatures(ChannelTypeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTypeFeatures)); }
2144         ChannelTypeFeatures(LDKChannelTypeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTypeFeatures)); }
2145         operator LDKChannelTypeFeatures() && { LDKChannelTypeFeatures res = self; memset(&self, 0, sizeof(LDKChannelTypeFeatures)); return res; }
2146         ~ChannelTypeFeatures() { ChannelTypeFeatures_free(self); }
2147         ChannelTypeFeatures& operator=(ChannelTypeFeatures&& o) { ChannelTypeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTypeFeatures)); return *this; }
2148         LDKChannelTypeFeatures* operator &() { return &self; }
2149         LDKChannelTypeFeatures* operator ->() { return &self; }
2150         const LDKChannelTypeFeatures* operator &() const { return &self; }
2151         const LDKChannelTypeFeatures* operator ->() const { return &self; }
2152 };
2153 class Offer {
2154 private:
2155         LDKOffer self;
2156 public:
2157         Offer(const Offer&) = delete;
2158         Offer(Offer&& o) : self(o.self) { memset(&o, 0, sizeof(Offer)); }
2159         Offer(LDKOffer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffer)); }
2160         operator LDKOffer() && { LDKOffer res = self; memset(&self, 0, sizeof(LDKOffer)); return res; }
2161         ~Offer() { Offer_free(self); }
2162         Offer& operator=(Offer&& o) { Offer_free(self); self = o.self; memset(&o, 0, sizeof(Offer)); return *this; }
2163         LDKOffer* operator &() { return &self; }
2164         LDKOffer* operator ->() { return &self; }
2165         const LDKOffer* operator &() const { return &self; }
2166         const LDKOffer* operator ->() const { return &self; }
2167 };
2168 class Amount {
2169 private:
2170         LDKAmount self;
2171 public:
2172         Amount(const Amount&) = delete;
2173         Amount(Amount&& o) : self(o.self) { memset(&o, 0, sizeof(Amount)); }
2174         Amount(LDKAmount&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAmount)); }
2175         operator LDKAmount() && { LDKAmount res = self; memset(&self, 0, sizeof(LDKAmount)); return res; }
2176         ~Amount() { Amount_free(self); }
2177         Amount& operator=(Amount&& o) { Amount_free(self); self = o.self; memset(&o, 0, sizeof(Amount)); return *this; }
2178         LDKAmount* operator &() { return &self; }
2179         LDKAmount* operator ->() { return &self; }
2180         const LDKAmount* operator &() const { return &self; }
2181         const LDKAmount* operator ->() const { return &self; }
2182 };
2183 class Quantity {
2184 private:
2185         LDKQuantity self;
2186 public:
2187         Quantity(const Quantity&) = delete;
2188         Quantity(Quantity&& o) : self(o.self) { memset(&o, 0, sizeof(Quantity)); }
2189         Quantity(LDKQuantity&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQuantity)); }
2190         operator LDKQuantity() && { LDKQuantity res = self; memset(&self, 0, sizeof(LDKQuantity)); return res; }
2191         ~Quantity() { Quantity_free(self); }
2192         Quantity& operator=(Quantity&& o) { Quantity_free(self); self = o.self; memset(&o, 0, sizeof(Quantity)); return *this; }
2193         LDKQuantity* operator &() { return &self; }
2194         LDKQuantity* operator ->() { return &self; }
2195         const LDKQuantity* operator &() const { return &self; }
2196         const LDKQuantity* operator ->() const { return &self; }
2197 };
2198 class NodeId {
2199 private:
2200         LDKNodeId self;
2201 public:
2202         NodeId(const NodeId&) = delete;
2203         NodeId(NodeId&& o) : self(o.self) { memset(&o, 0, sizeof(NodeId)); }
2204         NodeId(LDKNodeId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeId)); }
2205         operator LDKNodeId() && { LDKNodeId res = self; memset(&self, 0, sizeof(LDKNodeId)); return res; }
2206         ~NodeId() { NodeId_free(self); }
2207         NodeId& operator=(NodeId&& o) { NodeId_free(self); self = o.self; memset(&o, 0, sizeof(NodeId)); return *this; }
2208         LDKNodeId* operator &() { return &self; }
2209         LDKNodeId* operator ->() { return &self; }
2210         const LDKNodeId* operator &() const { return &self; }
2211         const LDKNodeId* operator ->() const { return &self; }
2212 };
2213 class NetworkGraph {
2214 private:
2215         LDKNetworkGraph self;
2216 public:
2217         NetworkGraph(const NetworkGraph&) = delete;
2218         NetworkGraph(NetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkGraph)); }
2219         NetworkGraph(LDKNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkGraph)); }
2220         operator LDKNetworkGraph() && { LDKNetworkGraph res = self; memset(&self, 0, sizeof(LDKNetworkGraph)); return res; }
2221         ~NetworkGraph() { NetworkGraph_free(self); }
2222         NetworkGraph& operator=(NetworkGraph&& o) { NetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(NetworkGraph)); return *this; }
2223         LDKNetworkGraph* operator &() { return &self; }
2224         LDKNetworkGraph* operator ->() { return &self; }
2225         const LDKNetworkGraph* operator &() const { return &self; }
2226         const LDKNetworkGraph* operator ->() const { return &self; }
2227 };
2228 class ReadOnlyNetworkGraph {
2229 private:
2230         LDKReadOnlyNetworkGraph self;
2231 public:
2232         ReadOnlyNetworkGraph(const ReadOnlyNetworkGraph&) = delete;
2233         ReadOnlyNetworkGraph(ReadOnlyNetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); }
2234         ReadOnlyNetworkGraph(LDKReadOnlyNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReadOnlyNetworkGraph)); }
2235         operator LDKReadOnlyNetworkGraph() && { LDKReadOnlyNetworkGraph res = self; memset(&self, 0, sizeof(LDKReadOnlyNetworkGraph)); return res; }
2236         ~ReadOnlyNetworkGraph() { ReadOnlyNetworkGraph_free(self); }
2237         ReadOnlyNetworkGraph& operator=(ReadOnlyNetworkGraph&& o) { ReadOnlyNetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); return *this; }
2238         LDKReadOnlyNetworkGraph* operator &() { return &self; }
2239         LDKReadOnlyNetworkGraph* operator ->() { return &self; }
2240         const LDKReadOnlyNetworkGraph* operator &() const { return &self; }
2241         const LDKReadOnlyNetworkGraph* operator ->() const { return &self; }
2242 };
2243 class NetworkUpdate {
2244 private:
2245         LDKNetworkUpdate self;
2246 public:
2247         NetworkUpdate(const NetworkUpdate&) = delete;
2248         NetworkUpdate(NetworkUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkUpdate)); }
2249         NetworkUpdate(LDKNetworkUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkUpdate)); }
2250         operator LDKNetworkUpdate() && { LDKNetworkUpdate res = self; memset(&self, 0, sizeof(LDKNetworkUpdate)); return res; }
2251         ~NetworkUpdate() { NetworkUpdate_free(self); }
2252         NetworkUpdate& operator=(NetworkUpdate&& o) { NetworkUpdate_free(self); self = o.self; memset(&o, 0, sizeof(NetworkUpdate)); return *this; }
2253         LDKNetworkUpdate* operator &() { return &self; }
2254         LDKNetworkUpdate* operator ->() { return &self; }
2255         const LDKNetworkUpdate* operator &() const { return &self; }
2256         const LDKNetworkUpdate* operator ->() const { return &self; }
2257 };
2258 class P2PGossipSync {
2259 private:
2260         LDKP2PGossipSync self;
2261 public:
2262         P2PGossipSync(const P2PGossipSync&) = delete;
2263         P2PGossipSync(P2PGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(P2PGossipSync)); }
2264         P2PGossipSync(LDKP2PGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKP2PGossipSync)); }
2265         operator LDKP2PGossipSync() && { LDKP2PGossipSync res = self; memset(&self, 0, sizeof(LDKP2PGossipSync)); return res; }
2266         ~P2PGossipSync() { P2PGossipSync_free(self); }
2267         P2PGossipSync& operator=(P2PGossipSync&& o) { P2PGossipSync_free(self); self = o.self; memset(&o, 0, sizeof(P2PGossipSync)); return *this; }
2268         LDKP2PGossipSync* operator &() { return &self; }
2269         LDKP2PGossipSync* operator ->() { return &self; }
2270         const LDKP2PGossipSync* operator &() const { return &self; }
2271         const LDKP2PGossipSync* operator ->() const { return &self; }
2272 };
2273 class ChannelUpdateInfo {
2274 private:
2275         LDKChannelUpdateInfo self;
2276 public:
2277         ChannelUpdateInfo(const ChannelUpdateInfo&) = delete;
2278         ChannelUpdateInfo(ChannelUpdateInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdateInfo)); }
2279         ChannelUpdateInfo(LDKChannelUpdateInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdateInfo)); }
2280         operator LDKChannelUpdateInfo() && { LDKChannelUpdateInfo res = self; memset(&self, 0, sizeof(LDKChannelUpdateInfo)); return res; }
2281         ~ChannelUpdateInfo() { ChannelUpdateInfo_free(self); }
2282         ChannelUpdateInfo& operator=(ChannelUpdateInfo&& o) { ChannelUpdateInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdateInfo)); return *this; }
2283         LDKChannelUpdateInfo* operator &() { return &self; }
2284         LDKChannelUpdateInfo* operator ->() { return &self; }
2285         const LDKChannelUpdateInfo* operator &() const { return &self; }
2286         const LDKChannelUpdateInfo* operator ->() const { return &self; }
2287 };
2288 class ChannelInfo {
2289 private:
2290         LDKChannelInfo self;
2291 public:
2292         ChannelInfo(const ChannelInfo&) = delete;
2293         ChannelInfo(ChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelInfo)); }
2294         ChannelInfo(LDKChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelInfo)); }
2295         operator LDKChannelInfo() && { LDKChannelInfo res = self; memset(&self, 0, sizeof(LDKChannelInfo)); return res; }
2296         ~ChannelInfo() { ChannelInfo_free(self); }
2297         ChannelInfo& operator=(ChannelInfo&& o) { ChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelInfo)); return *this; }
2298         LDKChannelInfo* operator &() { return &self; }
2299         LDKChannelInfo* operator ->() { return &self; }
2300         const LDKChannelInfo* operator &() const { return &self; }
2301         const LDKChannelInfo* operator ->() const { return &self; }
2302 };
2303 class DirectedChannelInfo {
2304 private:
2305         LDKDirectedChannelInfo self;
2306 public:
2307         DirectedChannelInfo(const DirectedChannelInfo&) = delete;
2308         DirectedChannelInfo(DirectedChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(DirectedChannelInfo)); }
2309         DirectedChannelInfo(LDKDirectedChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectedChannelInfo)); }
2310         operator LDKDirectedChannelInfo() && { LDKDirectedChannelInfo res = self; memset(&self, 0, sizeof(LDKDirectedChannelInfo)); return res; }
2311         ~DirectedChannelInfo() { DirectedChannelInfo_free(self); }
2312         DirectedChannelInfo& operator=(DirectedChannelInfo&& o) { DirectedChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(DirectedChannelInfo)); return *this; }
2313         LDKDirectedChannelInfo* operator &() { return &self; }
2314         LDKDirectedChannelInfo* operator ->() { return &self; }
2315         const LDKDirectedChannelInfo* operator &() const { return &self; }
2316         const LDKDirectedChannelInfo* operator ->() const { return &self; }
2317 };
2318 class EffectiveCapacity {
2319 private:
2320         LDKEffectiveCapacity self;
2321 public:
2322         EffectiveCapacity(const EffectiveCapacity&) = delete;
2323         EffectiveCapacity(EffectiveCapacity&& o) : self(o.self) { memset(&o, 0, sizeof(EffectiveCapacity)); }
2324         EffectiveCapacity(LDKEffectiveCapacity&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEffectiveCapacity)); }
2325         operator LDKEffectiveCapacity() && { LDKEffectiveCapacity res = self; memset(&self, 0, sizeof(LDKEffectiveCapacity)); return res; }
2326         ~EffectiveCapacity() { EffectiveCapacity_free(self); }
2327         EffectiveCapacity& operator=(EffectiveCapacity&& o) { EffectiveCapacity_free(self); self = o.self; memset(&o, 0, sizeof(EffectiveCapacity)); return *this; }
2328         LDKEffectiveCapacity* operator &() { return &self; }
2329         LDKEffectiveCapacity* operator ->() { return &self; }
2330         const LDKEffectiveCapacity* operator &() const { return &self; }
2331         const LDKEffectiveCapacity* operator ->() const { return &self; }
2332 };
2333 class RoutingFees {
2334 private:
2335         LDKRoutingFees self;
2336 public:
2337         RoutingFees(const RoutingFees&) = delete;
2338         RoutingFees(RoutingFees&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingFees)); }
2339         RoutingFees(LDKRoutingFees&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingFees)); }
2340         operator LDKRoutingFees() && { LDKRoutingFees res = self; memset(&self, 0, sizeof(LDKRoutingFees)); return res; }
2341         ~RoutingFees() { RoutingFees_free(self); }
2342         RoutingFees& operator=(RoutingFees&& o) { RoutingFees_free(self); self = o.self; memset(&o, 0, sizeof(RoutingFees)); return *this; }
2343         LDKRoutingFees* operator &() { return &self; }
2344         LDKRoutingFees* operator ->() { return &self; }
2345         const LDKRoutingFees* operator &() const { return &self; }
2346         const LDKRoutingFees* operator ->() const { return &self; }
2347 };
2348 class NodeAnnouncementInfo {
2349 private:
2350         LDKNodeAnnouncementInfo self;
2351 public:
2352         NodeAnnouncementInfo(const NodeAnnouncementInfo&) = delete;
2353         NodeAnnouncementInfo(NodeAnnouncementInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncementInfo)); }
2354         NodeAnnouncementInfo(LDKNodeAnnouncementInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncementInfo)); }
2355         operator LDKNodeAnnouncementInfo() && { LDKNodeAnnouncementInfo res = self; memset(&self, 0, sizeof(LDKNodeAnnouncementInfo)); return res; }
2356         ~NodeAnnouncementInfo() { NodeAnnouncementInfo_free(self); }
2357         NodeAnnouncementInfo& operator=(NodeAnnouncementInfo&& o) { NodeAnnouncementInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncementInfo)); return *this; }
2358         LDKNodeAnnouncementInfo* operator &() { return &self; }
2359         LDKNodeAnnouncementInfo* operator ->() { return &self; }
2360         const LDKNodeAnnouncementInfo* operator &() const { return &self; }
2361         const LDKNodeAnnouncementInfo* operator ->() const { return &self; }
2362 };
2363 class NodeAlias {
2364 private:
2365         LDKNodeAlias self;
2366 public:
2367         NodeAlias(const NodeAlias&) = delete;
2368         NodeAlias(NodeAlias&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAlias)); }
2369         NodeAlias(LDKNodeAlias&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAlias)); }
2370         operator LDKNodeAlias() && { LDKNodeAlias res = self; memset(&self, 0, sizeof(LDKNodeAlias)); return res; }
2371         ~NodeAlias() { NodeAlias_free(self); }
2372         NodeAlias& operator=(NodeAlias&& o) { NodeAlias_free(self); self = o.self; memset(&o, 0, sizeof(NodeAlias)); return *this; }
2373         LDKNodeAlias* operator &() { return &self; }
2374         LDKNodeAlias* operator ->() { return &self; }
2375         const LDKNodeAlias* operator &() const { return &self; }
2376         const LDKNodeAlias* operator ->() const { return &self; }
2377 };
2378 class NodeInfo {
2379 private:
2380         LDKNodeInfo self;
2381 public:
2382         NodeInfo(const NodeInfo&) = delete;
2383         NodeInfo(NodeInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeInfo)); }
2384         NodeInfo(LDKNodeInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeInfo)); }
2385         operator LDKNodeInfo() && { LDKNodeInfo res = self; memset(&self, 0, sizeof(LDKNodeInfo)); return res; }
2386         ~NodeInfo() { NodeInfo_free(self); }
2387         NodeInfo& operator=(NodeInfo&& o) { NodeInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeInfo)); return *this; }
2388         LDKNodeInfo* operator &() { return &self; }
2389         LDKNodeInfo* operator ->() { return &self; }
2390         const LDKNodeInfo* operator &() const { return &self; }
2391         const LDKNodeInfo* operator ->() const { return &self; }
2392 };
2393 class InboundHTLCErr {
2394 private:
2395         LDKInboundHTLCErr self;
2396 public:
2397         InboundHTLCErr(const InboundHTLCErr&) = delete;
2398         InboundHTLCErr(InboundHTLCErr&& o) : self(o.self) { memset(&o, 0, sizeof(InboundHTLCErr)); }
2399         InboundHTLCErr(LDKInboundHTLCErr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInboundHTLCErr)); }
2400         operator LDKInboundHTLCErr() && { LDKInboundHTLCErr res = self; memset(&self, 0, sizeof(LDKInboundHTLCErr)); return res; }
2401         ~InboundHTLCErr() { InboundHTLCErr_free(self); }
2402         InboundHTLCErr& operator=(InboundHTLCErr&& o) { InboundHTLCErr_free(self); self = o.self; memset(&o, 0, sizeof(InboundHTLCErr)); return *this; }
2403         LDKInboundHTLCErr* operator &() { return &self; }
2404         LDKInboundHTLCErr* operator ->() { return &self; }
2405         const LDKInboundHTLCErr* operator &() const { return &self; }
2406         const LDKInboundHTLCErr* operator ->() const { return &self; }
2407 };
2408 class AnchorDescriptor {
2409 private:
2410         LDKAnchorDescriptor self;
2411 public:
2412         AnchorDescriptor(const AnchorDescriptor&) = delete;
2413         AnchorDescriptor(AnchorDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(AnchorDescriptor)); }
2414         AnchorDescriptor(LDKAnchorDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnchorDescriptor)); }
2415         operator LDKAnchorDescriptor() && { LDKAnchorDescriptor res = self; memset(&self, 0, sizeof(LDKAnchorDescriptor)); return res; }
2416         ~AnchorDescriptor() { AnchorDescriptor_free(self); }
2417         AnchorDescriptor& operator=(AnchorDescriptor&& o) { AnchorDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(AnchorDescriptor)); return *this; }
2418         LDKAnchorDescriptor* operator &() { return &self; }
2419         LDKAnchorDescriptor* operator ->() { return &self; }
2420         const LDKAnchorDescriptor* operator &() const { return &self; }
2421         const LDKAnchorDescriptor* operator ->() const { return &self; }
2422 };
2423 class BumpTransactionEvent {
2424 private:
2425         LDKBumpTransactionEvent self;
2426 public:
2427         BumpTransactionEvent(const BumpTransactionEvent&) = delete;
2428         BumpTransactionEvent(BumpTransactionEvent&& o) : self(o.self) { memset(&o, 0, sizeof(BumpTransactionEvent)); }
2429         BumpTransactionEvent(LDKBumpTransactionEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBumpTransactionEvent)); }
2430         operator LDKBumpTransactionEvent() && { LDKBumpTransactionEvent res = self; memset(&self, 0, sizeof(LDKBumpTransactionEvent)); return res; }
2431         ~BumpTransactionEvent() { BumpTransactionEvent_free(self); }
2432         BumpTransactionEvent& operator=(BumpTransactionEvent&& o) { BumpTransactionEvent_free(self); self = o.self; memset(&o, 0, sizeof(BumpTransactionEvent)); return *this; }
2433         LDKBumpTransactionEvent* operator &() { return &self; }
2434         LDKBumpTransactionEvent* operator ->() { return &self; }
2435         const LDKBumpTransactionEvent* operator &() const { return &self; }
2436         const LDKBumpTransactionEvent* operator ->() const { return &self; }
2437 };
2438 class Input {
2439 private:
2440         LDKInput self;
2441 public:
2442         Input(const Input&) = delete;
2443         Input(Input&& o) : self(o.self) { memset(&o, 0, sizeof(Input)); }
2444         Input(LDKInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInput)); }
2445         operator LDKInput() && { LDKInput res = self; memset(&self, 0, sizeof(LDKInput)); return res; }
2446         ~Input() { Input_free(self); }
2447         Input& operator=(Input&& o) { Input_free(self); self = o.self; memset(&o, 0, sizeof(Input)); return *this; }
2448         LDKInput* operator &() { return &self; }
2449         LDKInput* operator ->() { return &self; }
2450         const LDKInput* operator &() const { return &self; }
2451         const LDKInput* operator ->() const { return &self; }
2452 };
2453 class Utxo {
2454 private:
2455         LDKUtxo self;
2456 public:
2457         Utxo(const Utxo&) = delete;
2458         Utxo(Utxo&& o) : self(o.self) { memset(&o, 0, sizeof(Utxo)); }
2459         Utxo(LDKUtxo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxo)); }
2460         operator LDKUtxo() && { LDKUtxo res = self; memset(&self, 0, sizeof(LDKUtxo)); return res; }
2461         ~Utxo() { Utxo_free(self); }
2462         Utxo& operator=(Utxo&& o) { Utxo_free(self); self = o.self; memset(&o, 0, sizeof(Utxo)); return *this; }
2463         LDKUtxo* operator &() { return &self; }
2464         LDKUtxo* operator ->() { return &self; }
2465         const LDKUtxo* operator &() const { return &self; }
2466         const LDKUtxo* operator ->() const { return &self; }
2467 };
2468 class CoinSelection {
2469 private:
2470         LDKCoinSelection self;
2471 public:
2472         CoinSelection(const CoinSelection&) = delete;
2473         CoinSelection(CoinSelection&& o) : self(o.self) { memset(&o, 0, sizeof(CoinSelection)); }
2474         CoinSelection(LDKCoinSelection&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCoinSelection)); }
2475         operator LDKCoinSelection() && { LDKCoinSelection res = self; memset(&self, 0, sizeof(LDKCoinSelection)); return res; }
2476         ~CoinSelection() { CoinSelection_free(self); }
2477         CoinSelection& operator=(CoinSelection&& o) { CoinSelection_free(self); self = o.self; memset(&o, 0, sizeof(CoinSelection)); return *this; }
2478         LDKCoinSelection* operator &() { return &self; }
2479         LDKCoinSelection* operator ->() { return &self; }
2480         const LDKCoinSelection* operator &() const { return &self; }
2481         const LDKCoinSelection* operator ->() const { return &self; }
2482 };
2483 class CoinSelectionSource {
2484 private:
2485         LDKCoinSelectionSource self;
2486 public:
2487         CoinSelectionSource(const CoinSelectionSource&) = delete;
2488         CoinSelectionSource(CoinSelectionSource&& o) : self(o.self) { memset(&o, 0, sizeof(CoinSelectionSource)); }
2489         CoinSelectionSource(LDKCoinSelectionSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCoinSelectionSource)); }
2490         operator LDKCoinSelectionSource() && { LDKCoinSelectionSource res = self; memset(&self, 0, sizeof(LDKCoinSelectionSource)); return res; }
2491         ~CoinSelectionSource() { CoinSelectionSource_free(self); }
2492         CoinSelectionSource& operator=(CoinSelectionSource&& o) { CoinSelectionSource_free(self); self = o.self; memset(&o, 0, sizeof(CoinSelectionSource)); return *this; }
2493         LDKCoinSelectionSource* operator &() { return &self; }
2494         LDKCoinSelectionSource* operator ->() { return &self; }
2495         const LDKCoinSelectionSource* operator &() const { return &self; }
2496         const LDKCoinSelectionSource* operator ->() const { return &self; }
2497         /**
2498          *  Performs coin selection of a set of UTXOs, with at least 1 confirmation each, that are
2499          *  available to spend. Implementations are free to pick their coin selection algorithm of
2500          *  choice, as long as the following requirements are met:
2501          *
2502          *  1. `must_spend` contains a set of [`Input`]s that must be included in the transaction
2503          *     throughout coin selection, but must not be returned as part of the result.
2504          *  2. `must_pay_to` contains a set of [`TxOut`]s that must be included in the transaction
2505          *     throughout coin selection. In some cases, like when funding an anchor transaction, this
2506          *     set is empty. Implementations should ensure they handle this correctly on their end,
2507          *     e.g., Bitcoin Core's `fundrawtransaction` RPC requires at least one output to be
2508          *     provided, in which case a zero-value empty OP_RETURN output can be used instead.
2509          *  3. Enough inputs must be selected/contributed for the resulting transaction (including the
2510          *     inputs and outputs noted above) to meet `target_feerate_sat_per_1000_weight`.
2511          *
2512          *  Implementations must take note that [`Input::satisfaction_weight`] only tracks the weight of
2513          *  the input's `script_sig` and `witness`. Some wallets, like Bitcoin Core's, may require
2514          *  providing the full input weight. Failing to do so may lead to underestimating fee bumps and
2515          *  delaying block inclusion.
2516          *
2517          *  The `claim_id` must map to the set of external UTXOs assigned to the claim, such that they
2518          *  can be re-used within new fee-bumped iterations of the original claiming transaction,
2519          *  ensuring that claims don't double spend each other. If a specific `claim_id` has never had a
2520          *  transaction associated with it, and all of the available UTXOs have already been assigned to
2521          *  other claims, implementations must be willing to double spend their UTXOs. The choice of
2522          *  which UTXOs to double spend is left to the implementation, but it must strive to keep the
2523          *  set of other claims being double spent to a minimum.
2524          */
2525         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);
2526         /**
2527          *  Signs and provides the full witness for all inputs within the transaction known to the
2528          *  trait (i.e., any provided via [`CoinSelectionSource::select_confirmed_utxos`]).
2529          *
2530          *  If your wallet does not support signing PSBTs you can call `psbt.extract_tx()` to get the
2531          *  unsigned transaction and then sign it with your wallet.
2532          */
2533         inline LDK::CResult_TransactionNoneZ sign_psbt(struct LDKCVec_u8Z psbt);
2534 };
2535 class WalletSource {
2536 private:
2537         LDKWalletSource self;
2538 public:
2539         WalletSource(const WalletSource&) = delete;
2540         WalletSource(WalletSource&& o) : self(o.self) { memset(&o, 0, sizeof(WalletSource)); }
2541         WalletSource(LDKWalletSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWalletSource)); }
2542         operator LDKWalletSource() && { LDKWalletSource res = self; memset(&self, 0, sizeof(LDKWalletSource)); return res; }
2543         ~WalletSource() { WalletSource_free(self); }
2544         WalletSource& operator=(WalletSource&& o) { WalletSource_free(self); self = o.self; memset(&o, 0, sizeof(WalletSource)); return *this; }
2545         LDKWalletSource* operator &() { return &self; }
2546         LDKWalletSource* operator ->() { return &self; }
2547         const LDKWalletSource* operator &() const { return &self; }
2548         const LDKWalletSource* operator ->() const { return &self; }
2549         /**
2550          *  Returns all UTXOs, with at least 1 confirmation each, that are available to spend.
2551          */
2552         inline LDK::CResult_CVec_UtxoZNoneZ list_confirmed_utxos();
2553         /**
2554          *  Returns a script to use for change above dust resulting from a successful coin selection
2555          *  attempt.
2556          */
2557         inline LDK::CResult_CVec_u8ZNoneZ get_change_script();
2558         /**
2559          *  Signs and provides the full [`TxIn::script_sig`] and [`TxIn::witness`] for all inputs within
2560          *  the transaction known to the wallet (i.e., any provided via
2561          *  [`WalletSource::list_confirmed_utxos`]).
2562          *
2563          *  If your wallet does not support signing PSBTs you can call `psbt.extract_tx()` to get the
2564          *  unsigned transaction and then sign it with your wallet.
2565          */
2566         inline LDK::CResult_TransactionNoneZ sign_psbt(struct LDKCVec_u8Z psbt);
2567 };
2568 class Wallet {
2569 private:
2570         LDKWallet self;
2571 public:
2572         Wallet(const Wallet&) = delete;
2573         Wallet(Wallet&& o) : self(o.self) { memset(&o, 0, sizeof(Wallet)); }
2574         Wallet(LDKWallet&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWallet)); }
2575         operator LDKWallet() && { LDKWallet res = self; memset(&self, 0, sizeof(LDKWallet)); return res; }
2576         ~Wallet() { Wallet_free(self); }
2577         Wallet& operator=(Wallet&& o) { Wallet_free(self); self = o.self; memset(&o, 0, sizeof(Wallet)); return *this; }
2578         LDKWallet* operator &() { return &self; }
2579         LDKWallet* operator ->() { return &self; }
2580         const LDKWallet* operator &() const { return &self; }
2581         const LDKWallet* operator ->() const { return &self; }
2582 };
2583 class BumpTransactionEventHandler {
2584 private:
2585         LDKBumpTransactionEventHandler self;
2586 public:
2587         BumpTransactionEventHandler(const BumpTransactionEventHandler&) = delete;
2588         BumpTransactionEventHandler(BumpTransactionEventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(BumpTransactionEventHandler)); }
2589         BumpTransactionEventHandler(LDKBumpTransactionEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBumpTransactionEventHandler)); }
2590         operator LDKBumpTransactionEventHandler() && { LDKBumpTransactionEventHandler res = self; memset(&self, 0, sizeof(LDKBumpTransactionEventHandler)); return res; }
2591         ~BumpTransactionEventHandler() { BumpTransactionEventHandler_free(self); }
2592         BumpTransactionEventHandler& operator=(BumpTransactionEventHandler&& o) { BumpTransactionEventHandler_free(self); self = o.self; memset(&o, 0, sizeof(BumpTransactionEventHandler)); return *this; }
2593         LDKBumpTransactionEventHandler* operator &() { return &self; }
2594         LDKBumpTransactionEventHandler* operator ->() { return &self; }
2595         const LDKBumpTransactionEventHandler* operator &() const { return &self; }
2596         const LDKBumpTransactionEventHandler* operator ->() const { return &self; }
2597 };
2598 class PendingHTLCRouting {
2599 private:
2600         LDKPendingHTLCRouting self;
2601 public:
2602         PendingHTLCRouting(const PendingHTLCRouting&) = delete;
2603         PendingHTLCRouting(PendingHTLCRouting&& o) : self(o.self) { memset(&o, 0, sizeof(PendingHTLCRouting)); }
2604         PendingHTLCRouting(LDKPendingHTLCRouting&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPendingHTLCRouting)); }
2605         operator LDKPendingHTLCRouting() && { LDKPendingHTLCRouting res = self; memset(&self, 0, sizeof(LDKPendingHTLCRouting)); return res; }
2606         ~PendingHTLCRouting() { PendingHTLCRouting_free(self); }
2607         PendingHTLCRouting& operator=(PendingHTLCRouting&& o) { PendingHTLCRouting_free(self); self = o.self; memset(&o, 0, sizeof(PendingHTLCRouting)); return *this; }
2608         LDKPendingHTLCRouting* operator &() { return &self; }
2609         LDKPendingHTLCRouting* operator ->() { return &self; }
2610         const LDKPendingHTLCRouting* operator &() const { return &self; }
2611         const LDKPendingHTLCRouting* operator ->() const { return &self; }
2612 };
2613 class BlindedForward {
2614 private:
2615         LDKBlindedForward self;
2616 public:
2617         BlindedForward(const BlindedForward&) = delete;
2618         BlindedForward(BlindedForward&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedForward)); }
2619         BlindedForward(LDKBlindedForward&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedForward)); }
2620         operator LDKBlindedForward() && { LDKBlindedForward res = self; memset(&self, 0, sizeof(LDKBlindedForward)); return res; }
2621         ~BlindedForward() { BlindedForward_free(self); }
2622         BlindedForward& operator=(BlindedForward&& o) { BlindedForward_free(self); self = o.self; memset(&o, 0, sizeof(BlindedForward)); return *this; }
2623         LDKBlindedForward* operator &() { return &self; }
2624         LDKBlindedForward* operator ->() { return &self; }
2625         const LDKBlindedForward* operator &() const { return &self; }
2626         const LDKBlindedForward* operator ->() const { return &self; }
2627 };
2628 class PendingHTLCInfo {
2629 private:
2630         LDKPendingHTLCInfo self;
2631 public:
2632         PendingHTLCInfo(const PendingHTLCInfo&) = delete;
2633         PendingHTLCInfo(PendingHTLCInfo&& o) : self(o.self) { memset(&o, 0, sizeof(PendingHTLCInfo)); }
2634         PendingHTLCInfo(LDKPendingHTLCInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPendingHTLCInfo)); }
2635         operator LDKPendingHTLCInfo() && { LDKPendingHTLCInfo res = self; memset(&self, 0, sizeof(LDKPendingHTLCInfo)); return res; }
2636         ~PendingHTLCInfo() { PendingHTLCInfo_free(self); }
2637         PendingHTLCInfo& operator=(PendingHTLCInfo&& o) { PendingHTLCInfo_free(self); self = o.self; memset(&o, 0, sizeof(PendingHTLCInfo)); return *this; }
2638         LDKPendingHTLCInfo* operator &() { return &self; }
2639         LDKPendingHTLCInfo* operator ->() { return &self; }
2640         const LDKPendingHTLCInfo* operator &() const { return &self; }
2641         const LDKPendingHTLCInfo* operator ->() const { return &self; }
2642 };
2643 class BlindedFailure {
2644 private:
2645         LDKBlindedFailure self;
2646 public:
2647         BlindedFailure(const BlindedFailure&) = delete;
2648         BlindedFailure(BlindedFailure&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedFailure)); }
2649         BlindedFailure(LDKBlindedFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedFailure)); }
2650         operator LDKBlindedFailure() && { LDKBlindedFailure res = self; memset(&self, 0, sizeof(LDKBlindedFailure)); return res; }
2651         BlindedFailure& operator=(BlindedFailure&& o) { self = o.self; memset(&o, 0, sizeof(BlindedFailure)); return *this; }
2652         LDKBlindedFailure* operator &() { return &self; }
2653         LDKBlindedFailure* operator ->() { return &self; }
2654         const LDKBlindedFailure* operator &() const { return &self; }
2655         const LDKBlindedFailure* operator ->() const { return &self; }
2656 };
2657 class FailureCode {
2658 private:
2659         LDKFailureCode self;
2660 public:
2661         FailureCode(const FailureCode&) = delete;
2662         FailureCode(FailureCode&& o) : self(o.self) { memset(&o, 0, sizeof(FailureCode)); }
2663         FailureCode(LDKFailureCode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFailureCode)); }
2664         operator LDKFailureCode() && { LDKFailureCode res = self; memset(&self, 0, sizeof(LDKFailureCode)); return res; }
2665         ~FailureCode() { FailureCode_free(self); }
2666         FailureCode& operator=(FailureCode&& o) { FailureCode_free(self); self = o.self; memset(&o, 0, sizeof(FailureCode)); return *this; }
2667         LDKFailureCode* operator &() { return &self; }
2668         LDKFailureCode* operator ->() { return &self; }
2669         const LDKFailureCode* operator &() const { return &self; }
2670         const LDKFailureCode* operator ->() const { return &self; }
2671 };
2672 class ChannelManager {
2673 private:
2674         LDKChannelManager self;
2675 public:
2676         ChannelManager(const ChannelManager&) = delete;
2677         ChannelManager(ChannelManager&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManager)); }
2678         ChannelManager(LDKChannelManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManager)); }
2679         operator LDKChannelManager() && { LDKChannelManager res = self; memset(&self, 0, sizeof(LDKChannelManager)); return res; }
2680         ~ChannelManager() { ChannelManager_free(self); }
2681         ChannelManager& operator=(ChannelManager&& o) { ChannelManager_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManager)); return *this; }
2682         LDKChannelManager* operator &() { return &self; }
2683         LDKChannelManager* operator ->() { return &self; }
2684         const LDKChannelManager* operator &() const { return &self; }
2685         const LDKChannelManager* operator ->() const { return &self; }
2686 };
2687 class ChainParameters {
2688 private:
2689         LDKChainParameters self;
2690 public:
2691         ChainParameters(const ChainParameters&) = delete;
2692         ChainParameters(ChainParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChainParameters)); }
2693         ChainParameters(LDKChainParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainParameters)); }
2694         operator LDKChainParameters() && { LDKChainParameters res = self; memset(&self, 0, sizeof(LDKChainParameters)); return res; }
2695         ~ChainParameters() { ChainParameters_free(self); }
2696         ChainParameters& operator=(ChainParameters&& o) { ChainParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChainParameters)); return *this; }
2697         LDKChainParameters* operator &() { return &self; }
2698         LDKChainParameters* operator ->() { return &self; }
2699         const LDKChainParameters* operator &() const { return &self; }
2700         const LDKChainParameters* operator ->() const { return &self; }
2701 };
2702 class CounterpartyForwardingInfo {
2703 private:
2704         LDKCounterpartyForwardingInfo self;
2705 public:
2706         CounterpartyForwardingInfo(const CounterpartyForwardingInfo&) = delete;
2707         CounterpartyForwardingInfo(CounterpartyForwardingInfo&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyForwardingInfo)); }
2708         CounterpartyForwardingInfo(LDKCounterpartyForwardingInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyForwardingInfo)); }
2709         operator LDKCounterpartyForwardingInfo() && { LDKCounterpartyForwardingInfo res = self; memset(&self, 0, sizeof(LDKCounterpartyForwardingInfo)); return res; }
2710         ~CounterpartyForwardingInfo() { CounterpartyForwardingInfo_free(self); }
2711         CounterpartyForwardingInfo& operator=(CounterpartyForwardingInfo&& o) { CounterpartyForwardingInfo_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyForwardingInfo)); return *this; }
2712         LDKCounterpartyForwardingInfo* operator &() { return &self; }
2713         LDKCounterpartyForwardingInfo* operator ->() { return &self; }
2714         const LDKCounterpartyForwardingInfo* operator &() const { return &self; }
2715         const LDKCounterpartyForwardingInfo* operator ->() const { return &self; }
2716 };
2717 class ChannelCounterparty {
2718 private:
2719         LDKChannelCounterparty self;
2720 public:
2721         ChannelCounterparty(const ChannelCounterparty&) = delete;
2722         ChannelCounterparty(ChannelCounterparty&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelCounterparty)); }
2723         ChannelCounterparty(LDKChannelCounterparty&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelCounterparty)); }
2724         operator LDKChannelCounterparty() && { LDKChannelCounterparty res = self; memset(&self, 0, sizeof(LDKChannelCounterparty)); return res; }
2725         ~ChannelCounterparty() { ChannelCounterparty_free(self); }
2726         ChannelCounterparty& operator=(ChannelCounterparty&& o) { ChannelCounterparty_free(self); self = o.self; memset(&o, 0, sizeof(ChannelCounterparty)); return *this; }
2727         LDKChannelCounterparty* operator &() { return &self; }
2728         LDKChannelCounterparty* operator ->() { return &self; }
2729         const LDKChannelCounterparty* operator &() const { return &self; }
2730         const LDKChannelCounterparty* operator ->() const { return &self; }
2731 };
2732 class ChannelDetails {
2733 private:
2734         LDKChannelDetails self;
2735 public:
2736         ChannelDetails(const ChannelDetails&) = delete;
2737         ChannelDetails(ChannelDetails&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDetails)); }
2738         ChannelDetails(LDKChannelDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDetails)); }
2739         operator LDKChannelDetails() && { LDKChannelDetails res = self; memset(&self, 0, sizeof(LDKChannelDetails)); return res; }
2740         ~ChannelDetails() { ChannelDetails_free(self); }
2741         ChannelDetails& operator=(ChannelDetails&& o) { ChannelDetails_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDetails)); return *this; }
2742         LDKChannelDetails* operator &() { return &self; }
2743         LDKChannelDetails* operator ->() { return &self; }
2744         const LDKChannelDetails* operator &() const { return &self; }
2745         const LDKChannelDetails* operator ->() const { return &self; }
2746 };
2747 class ChannelShutdownState {
2748 private:
2749         LDKChannelShutdownState self;
2750 public:
2751         ChannelShutdownState(const ChannelShutdownState&) = delete;
2752         ChannelShutdownState(ChannelShutdownState&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelShutdownState)); }
2753         ChannelShutdownState(LDKChannelShutdownState&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelShutdownState)); }
2754         operator LDKChannelShutdownState() && { LDKChannelShutdownState res = self; memset(&self, 0, sizeof(LDKChannelShutdownState)); return res; }
2755         ChannelShutdownState& operator=(ChannelShutdownState&& o) { self = o.self; memset(&o, 0, sizeof(ChannelShutdownState)); return *this; }
2756         LDKChannelShutdownState* operator &() { return &self; }
2757         LDKChannelShutdownState* operator ->() { return &self; }
2758         const LDKChannelShutdownState* operator &() const { return &self; }
2759         const LDKChannelShutdownState* operator ->() const { return &self; }
2760 };
2761 class RecentPaymentDetails {
2762 private:
2763         LDKRecentPaymentDetails self;
2764 public:
2765         RecentPaymentDetails(const RecentPaymentDetails&) = delete;
2766         RecentPaymentDetails(RecentPaymentDetails&& o) : self(o.self) { memset(&o, 0, sizeof(RecentPaymentDetails)); }
2767         RecentPaymentDetails(LDKRecentPaymentDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecentPaymentDetails)); }
2768         operator LDKRecentPaymentDetails() && { LDKRecentPaymentDetails res = self; memset(&self, 0, sizeof(LDKRecentPaymentDetails)); return res; }
2769         ~RecentPaymentDetails() { RecentPaymentDetails_free(self); }
2770         RecentPaymentDetails& operator=(RecentPaymentDetails&& o) { RecentPaymentDetails_free(self); self = o.self; memset(&o, 0, sizeof(RecentPaymentDetails)); return *this; }
2771         LDKRecentPaymentDetails* operator &() { return &self; }
2772         LDKRecentPaymentDetails* operator ->() { return &self; }
2773         const LDKRecentPaymentDetails* operator &() const { return &self; }
2774         const LDKRecentPaymentDetails* operator ->() const { return &self; }
2775 };
2776 class PhantomRouteHints {
2777 private:
2778         LDKPhantomRouteHints self;
2779 public:
2780         PhantomRouteHints(const PhantomRouteHints&) = delete;
2781         PhantomRouteHints(PhantomRouteHints&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomRouteHints)); }
2782         PhantomRouteHints(LDKPhantomRouteHints&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomRouteHints)); }
2783         operator LDKPhantomRouteHints() && { LDKPhantomRouteHints res = self; memset(&self, 0, sizeof(LDKPhantomRouteHints)); return res; }
2784         ~PhantomRouteHints() { PhantomRouteHints_free(self); }
2785         PhantomRouteHints& operator=(PhantomRouteHints&& o) { PhantomRouteHints_free(self); self = o.self; memset(&o, 0, sizeof(PhantomRouteHints)); return *this; }
2786         LDKPhantomRouteHints* operator &() { return &self; }
2787         LDKPhantomRouteHints* operator ->() { return &self; }
2788         const LDKPhantomRouteHints* operator &() const { return &self; }
2789         const LDKPhantomRouteHints* operator ->() const { return &self; }
2790 };
2791 class ChannelManagerReadArgs {
2792 private:
2793         LDKChannelManagerReadArgs self;
2794 public:
2795         ChannelManagerReadArgs(const ChannelManagerReadArgs&) = delete;
2796         ChannelManagerReadArgs(ChannelManagerReadArgs&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerReadArgs)); }
2797         ChannelManagerReadArgs(LDKChannelManagerReadArgs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerReadArgs)); }
2798         operator LDKChannelManagerReadArgs() && { LDKChannelManagerReadArgs res = self; memset(&self, 0, sizeof(LDKChannelManagerReadArgs)); return res; }
2799         ~ChannelManagerReadArgs() { ChannelManagerReadArgs_free(self); }
2800         ChannelManagerReadArgs& operator=(ChannelManagerReadArgs&& o) { ChannelManagerReadArgs_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManagerReadArgs)); return *this; }
2801         LDKChannelManagerReadArgs* operator &() { return &self; }
2802         LDKChannelManagerReadArgs* operator ->() { return &self; }
2803         const LDKChannelManagerReadArgs* operator &() const { return &self; }
2804         const LDKChannelManagerReadArgs* operator ->() const { return &self; }
2805 };
2806 class ChannelHandshakeConfig {
2807 private:
2808         LDKChannelHandshakeConfig self;
2809 public:
2810         ChannelHandshakeConfig(const ChannelHandshakeConfig&) = delete;
2811         ChannelHandshakeConfig(ChannelHandshakeConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeConfig)); }
2812         ChannelHandshakeConfig(LDKChannelHandshakeConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeConfig)); }
2813         operator LDKChannelHandshakeConfig() && { LDKChannelHandshakeConfig res = self; memset(&self, 0, sizeof(LDKChannelHandshakeConfig)); return res; }
2814         ~ChannelHandshakeConfig() { ChannelHandshakeConfig_free(self); }
2815         ChannelHandshakeConfig& operator=(ChannelHandshakeConfig&& o) { ChannelHandshakeConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeConfig)); return *this; }
2816         LDKChannelHandshakeConfig* operator &() { return &self; }
2817         LDKChannelHandshakeConfig* operator ->() { return &self; }
2818         const LDKChannelHandshakeConfig* operator &() const { return &self; }
2819         const LDKChannelHandshakeConfig* operator ->() const { return &self; }
2820 };
2821 class ChannelHandshakeLimits {
2822 private:
2823         LDKChannelHandshakeLimits self;
2824 public:
2825         ChannelHandshakeLimits(const ChannelHandshakeLimits&) = delete;
2826         ChannelHandshakeLimits(ChannelHandshakeLimits&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeLimits)); }
2827         ChannelHandshakeLimits(LDKChannelHandshakeLimits&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeLimits)); }
2828         operator LDKChannelHandshakeLimits() && { LDKChannelHandshakeLimits res = self; memset(&self, 0, sizeof(LDKChannelHandshakeLimits)); return res; }
2829         ~ChannelHandshakeLimits() { ChannelHandshakeLimits_free(self); }
2830         ChannelHandshakeLimits& operator=(ChannelHandshakeLimits&& o) { ChannelHandshakeLimits_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeLimits)); return *this; }
2831         LDKChannelHandshakeLimits* operator &() { return &self; }
2832         LDKChannelHandshakeLimits* operator ->() { return &self; }
2833         const LDKChannelHandshakeLimits* operator &() const { return &self; }
2834         const LDKChannelHandshakeLimits* operator ->() const { return &self; }
2835 };
2836 class MaxDustHTLCExposure {
2837 private:
2838         LDKMaxDustHTLCExposure self;
2839 public:
2840         MaxDustHTLCExposure(const MaxDustHTLCExposure&) = delete;
2841         MaxDustHTLCExposure(MaxDustHTLCExposure&& o) : self(o.self) { memset(&o, 0, sizeof(MaxDustHTLCExposure)); }
2842         MaxDustHTLCExposure(LDKMaxDustHTLCExposure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMaxDustHTLCExposure)); }
2843         operator LDKMaxDustHTLCExposure() && { LDKMaxDustHTLCExposure res = self; memset(&self, 0, sizeof(LDKMaxDustHTLCExposure)); return res; }
2844         ~MaxDustHTLCExposure() { MaxDustHTLCExposure_free(self); }
2845         MaxDustHTLCExposure& operator=(MaxDustHTLCExposure&& o) { MaxDustHTLCExposure_free(self); self = o.self; memset(&o, 0, sizeof(MaxDustHTLCExposure)); return *this; }
2846         LDKMaxDustHTLCExposure* operator &() { return &self; }
2847         LDKMaxDustHTLCExposure* operator ->() { return &self; }
2848         const LDKMaxDustHTLCExposure* operator &() const { return &self; }
2849         const LDKMaxDustHTLCExposure* operator ->() const { return &self; }
2850 };
2851 class ChannelConfig {
2852 private:
2853         LDKChannelConfig self;
2854 public:
2855         ChannelConfig(const ChannelConfig&) = delete;
2856         ChannelConfig(ChannelConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfig)); }
2857         ChannelConfig(LDKChannelConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfig)); }
2858         operator LDKChannelConfig() && { LDKChannelConfig res = self; memset(&self, 0, sizeof(LDKChannelConfig)); return res; }
2859         ~ChannelConfig() { ChannelConfig_free(self); }
2860         ChannelConfig& operator=(ChannelConfig&& o) { ChannelConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfig)); return *this; }
2861         LDKChannelConfig* operator &() { return &self; }
2862         LDKChannelConfig* operator ->() { return &self; }
2863         const LDKChannelConfig* operator &() const { return &self; }
2864         const LDKChannelConfig* operator ->() const { return &self; }
2865 };
2866 class ChannelConfigUpdate {
2867 private:
2868         LDKChannelConfigUpdate self;
2869 public:
2870         ChannelConfigUpdate(const ChannelConfigUpdate&) = delete;
2871         ChannelConfigUpdate(ChannelConfigUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfigUpdate)); }
2872         ChannelConfigUpdate(LDKChannelConfigUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfigUpdate)); }
2873         operator LDKChannelConfigUpdate() && { LDKChannelConfigUpdate res = self; memset(&self, 0, sizeof(LDKChannelConfigUpdate)); return res; }
2874         ~ChannelConfigUpdate() { ChannelConfigUpdate_free(self); }
2875         ChannelConfigUpdate& operator=(ChannelConfigUpdate&& o) { ChannelConfigUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfigUpdate)); return *this; }
2876         LDKChannelConfigUpdate* operator &() { return &self; }
2877         LDKChannelConfigUpdate* operator ->() { return &self; }
2878         const LDKChannelConfigUpdate* operator &() const { return &self; }
2879         const LDKChannelConfigUpdate* operator ->() const { return &self; }
2880 };
2881 class UserConfig {
2882 private:
2883         LDKUserConfig self;
2884 public:
2885         UserConfig(const UserConfig&) = delete;
2886         UserConfig(UserConfig&& o) : self(o.self) { memset(&o, 0, sizeof(UserConfig)); }
2887         UserConfig(LDKUserConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUserConfig)); }
2888         operator LDKUserConfig() && { LDKUserConfig res = self; memset(&self, 0, sizeof(LDKUserConfig)); return res; }
2889         ~UserConfig() { UserConfig_free(self); }
2890         UserConfig& operator=(UserConfig&& o) { UserConfig_free(self); self = o.self; memset(&o, 0, sizeof(UserConfig)); return *this; }
2891         LDKUserConfig* operator &() { return &self; }
2892         LDKUserConfig* operator ->() { return &self; }
2893         const LDKUserConfig* operator &() const { return &self; }
2894         const LDKUserConfig* operator ->() const { return &self; }
2895 };
2896 class APIError {
2897 private:
2898         LDKAPIError self;
2899 public:
2900         APIError(const APIError&) = delete;
2901         APIError(APIError&& o) : self(o.self) { memset(&o, 0, sizeof(APIError)); }
2902         APIError(LDKAPIError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAPIError)); }
2903         operator LDKAPIError() && { LDKAPIError res = self; memset(&self, 0, sizeof(LDKAPIError)); return res; }
2904         ~APIError() { APIError_free(self); }
2905         APIError& operator=(APIError&& o) { APIError_free(self); self = o.self; memset(&o, 0, sizeof(APIError)); return *this; }
2906         LDKAPIError* operator &() { return &self; }
2907         LDKAPIError* operator ->() { return &self; }
2908         const LDKAPIError* operator &() const { return &self; }
2909         const LDKAPIError* operator ->() const { return &self; }
2910 };
2911 class TaggedHash {
2912 private:
2913         LDKTaggedHash self;
2914 public:
2915         TaggedHash(const TaggedHash&) = delete;
2916         TaggedHash(TaggedHash&& o) : self(o.self) { memset(&o, 0, sizeof(TaggedHash)); }
2917         TaggedHash(LDKTaggedHash&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTaggedHash)); }
2918         operator LDKTaggedHash() && { LDKTaggedHash res = self; memset(&self, 0, sizeof(LDKTaggedHash)); return res; }
2919         ~TaggedHash() { TaggedHash_free(self); }
2920         TaggedHash& operator=(TaggedHash&& o) { TaggedHash_free(self); self = o.self; memset(&o, 0, sizeof(TaggedHash)); return *this; }
2921         LDKTaggedHash* operator &() { return &self; }
2922         LDKTaggedHash* operator ->() { return &self; }
2923         const LDKTaggedHash* operator &() const { return &self; }
2924         const LDKTaggedHash* operator ->() const { return &self; }
2925 };
2926 class EcdsaChannelSigner {
2927 private:
2928         LDKEcdsaChannelSigner self;
2929 public:
2930         EcdsaChannelSigner(const EcdsaChannelSigner&) = delete;
2931         EcdsaChannelSigner(EcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(EcdsaChannelSigner)); }
2932         EcdsaChannelSigner(LDKEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEcdsaChannelSigner)); }
2933         operator LDKEcdsaChannelSigner() && { LDKEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKEcdsaChannelSigner)); return res; }
2934         ~EcdsaChannelSigner() { EcdsaChannelSigner_free(self); }
2935         EcdsaChannelSigner& operator=(EcdsaChannelSigner&& o) { EcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(EcdsaChannelSigner)); return *this; }
2936         LDKEcdsaChannelSigner* operator &() { return &self; }
2937         LDKEcdsaChannelSigner* operator ->() { return &self; }
2938         const LDKEcdsaChannelSigner* operator &() const { return &self; }
2939         const LDKEcdsaChannelSigner* operator ->() const { return &self; }
2940         /**
2941          *  Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
2942          *
2943          *  Note that if signing fails or is rejected, the channel will be force-closed.
2944          *
2945          *  Policy checks should be implemented in this function, including checking the amount
2946          *  sent to us and checking the HTLCs.
2947          *
2948          *  The preimages of outbound and inbound HTLCs that were fulfilled since the last commitment
2949          *  are provided. A validating signer should ensure that an outbound HTLC output is removed
2950          *  only when the matching preimage is provided and after the corresponding inbound HTLC has
2951          *  been removed for forwarded payments.
2952          *
2953          *  Note that all the relevant preimages will be provided, but there may also be additional
2954          *  irrelevant or duplicate preimages.
2955          */
2956         inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ inbound_htlc_preimages, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages);
2957         /**
2958          *  Creates a signature for a holder's commitment transaction.
2959          *
2960          *  This will be called
2961          *  - with a non-revoked `commitment_tx`.
2962          *  - with the latest `commitment_tx` when we initiate a force-close.
2963          *
2964          *  This may be called multiple times for the same transaction.
2965          *
2966          *  An external signer implementation should check that the commitment has not been revoked.
2967          */
2968         inline LDK::CResult_ECDSASignatureNoneZ sign_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx);
2969         /**
2970          *  Create a signature for the given input in a transaction spending an HTLC transaction output
2971          *  or a commitment transaction `to_local` output when our counterparty broadcasts an old state.
2972          *
2973          *  A justice transaction may claim multiple outputs at the same time if timelocks are
2974          *  similar, but only a signature for the input at index `input` should be signed for here.
2975          *  It may be called multiple times for same output(s) if a fee-bump is needed with regards
2976          *  to an upcoming timelock expiration.
2977          *
2978          *  Amount is value of the output spent by this input, committed to in the BIP 143 signature.
2979          *
2980          *  `per_commitment_key` is revocation secret which was provided by our counterparty when they
2981          *  revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
2982          *  not allow the spending of any funds by itself (you need our holder `revocation_secret` to do
2983          *  so).
2984          */
2985         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]);
2986         /**
2987          *  Create a signature for the given input in a transaction spending a commitment transaction
2988          *  HTLC output when our counterparty broadcasts an old state.
2989          *
2990          *  A justice transaction may claim multiple outputs at the same time if timelocks are
2991          *  similar, but only a signature for the input at index `input` should be signed for here.
2992          *  It may be called multiple times for same output(s) if a fee-bump is needed with regards
2993          *  to an upcoming timelock expiration.
2994          *
2995          *  `amount` is the value of the output spent by this input, committed to in the BIP 143
2996          *  signature.
2997          *
2998          *  `per_commitment_key` is revocation secret which was provided by our counterparty when they
2999          *  revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
3000          *  not allow the spending of any funds by itself (you need our holder revocation_secret to do
3001          *  so).
3002          *
3003          *  `htlc` holds HTLC elements (hash, timelock), thus changing the format of the witness script
3004          *  (which is committed to in the BIP 143 signatures).
3005          */
3006         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);
3007         /**
3008          *  Computes the signature for a commitment transaction's HTLC output used as an input within
3009          *  `htlc_tx`, which spends the commitment transaction at index `input`. The signature returned
3010          *  must be be computed using [`EcdsaSighashType::All`].
3011          *
3012          *  Note that this may be called for HTLCs in the penultimate commitment transaction if a
3013          *  [`ChannelMonitor`] [replica](https://github.com/lightningdevkit/rust-lightning/blob/main/GLOSSARY.md#monitor-replicas)
3014          *  broadcasts it before receiving the update for the latest commitment transaction.
3015          *
3016          *  [`EcdsaSighashType::All`]: bitcoin::sighash::EcdsaSighashType::All
3017          *  [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
3018          */
3019         inline LDK::CResult_ECDSASignatureNoneZ sign_holder_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor);
3020         /**
3021          *  Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment
3022          *  transaction, either offered or received.
3023          *
3024          *  Such a transaction may claim multiples offered outputs at same time if we know the
3025          *  preimage for each when we create it, but only the input at index `input` should be
3026          *  signed for here. It may be called multiple times for same output(s) if a fee-bump is
3027          *  needed with regards to an upcoming timelock expiration.
3028          *
3029          *  `witness_script` is either an offered or received script as defined in BOLT3 for HTLC
3030          *  outputs.
3031          *
3032          *  `amount` is value of the output spent by this input, committed to in the BIP 143 signature.
3033          *
3034          *  `per_commitment_point` is the dynamic point corresponding to the channel state
3035          *  detected onchain. It has been generated by our counterparty and is used to derive
3036          *  channel state keys, which are then included in the witness script and committed to in the
3037          *  BIP 143 signature.
3038          */
3039         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);
3040         /**
3041          *  Create a signature for a (proposed) closing transaction.
3042          *
3043          *  Note that, due to rounding, there may be one "missing" satoshi, and either party may have
3044          *  chosen to forgo their output as dust.
3045          */
3046         inline LDK::CResult_ECDSASignatureNoneZ sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx);
3047         /**
3048          *  Computes the signature for a commitment transaction's anchor output used as an
3049          *  input within `anchor_tx`, which spends the commitment transaction, at index `input`.
3050          */
3051         inline LDK::CResult_ECDSASignatureNoneZ sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input);
3052         /**
3053          *  Signs a channel announcement message with our funding key proving it comes from one of the
3054          *  channel participants.
3055          *
3056          *  Channel announcements also require a signature from each node's network key. Our node
3057          *  signature is computed through [`NodeSigner::sign_gossip_message`].
3058          *
3059          *  Note that if this fails or is rejected, the channel will not be publicly announced and
3060          *  our counterparty may (though likely will not) close the channel on us for violating the
3061          *  protocol.
3062          *
3063          *  [`NodeSigner::sign_gossip_message`]: crate::sign::NodeSigner::sign_gossip_message
3064          */
3065         inline LDK::CResult_ECDSASignatureNoneZ sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
3066 };
3067 class WriteableEcdsaChannelSigner {
3068 private:
3069         LDKWriteableEcdsaChannelSigner self;
3070 public:
3071         WriteableEcdsaChannelSigner(const WriteableEcdsaChannelSigner&) = delete;
3072         WriteableEcdsaChannelSigner(WriteableEcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(WriteableEcdsaChannelSigner)); }
3073         WriteableEcdsaChannelSigner(LDKWriteableEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWriteableEcdsaChannelSigner)); }
3074         operator LDKWriteableEcdsaChannelSigner() && { LDKWriteableEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKWriteableEcdsaChannelSigner)); return res; }
3075         ~WriteableEcdsaChannelSigner() { WriteableEcdsaChannelSigner_free(self); }
3076         WriteableEcdsaChannelSigner& operator=(WriteableEcdsaChannelSigner&& o) { WriteableEcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(WriteableEcdsaChannelSigner)); return *this; }
3077         LDKWriteableEcdsaChannelSigner* operator &() { return &self; }
3078         LDKWriteableEcdsaChannelSigner* operator ->() { return &self; }
3079         const LDKWriteableEcdsaChannelSigner* operator &() const { return &self; }
3080         const LDKWriteableEcdsaChannelSigner* operator ->() const { return &self; }
3081 };
3082 class ChannelMonitorUpdate {
3083 private:
3084         LDKChannelMonitorUpdate self;
3085 public:
3086         ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete;
3087         ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); }
3088         ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); }
3089         operator LDKChannelMonitorUpdate() && { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; }
3090         ~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); }
3091         ChannelMonitorUpdate& operator=(ChannelMonitorUpdate&& o) { ChannelMonitorUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdate)); return *this; }
3092         LDKChannelMonitorUpdate* operator &() { return &self; }
3093         LDKChannelMonitorUpdate* operator ->() { return &self; }
3094         const LDKChannelMonitorUpdate* operator &() const { return &self; }
3095         const LDKChannelMonitorUpdate* operator ->() const { return &self; }
3096 };
3097 class MonitorEvent {
3098 private:
3099         LDKMonitorEvent self;
3100 public:
3101         MonitorEvent(const MonitorEvent&) = delete;
3102         MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); }
3103         MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); }
3104         operator LDKMonitorEvent() && { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; }
3105         ~MonitorEvent() { MonitorEvent_free(self); }
3106         MonitorEvent& operator=(MonitorEvent&& o) { MonitorEvent_free(self); self = o.self; memset(&o, 0, sizeof(MonitorEvent)); return *this; }
3107         LDKMonitorEvent* operator &() { return &self; }
3108         LDKMonitorEvent* operator ->() { return &self; }
3109         const LDKMonitorEvent* operator &() const { return &self; }
3110         const LDKMonitorEvent* operator ->() const { return &self; }
3111 };
3112 class HTLCUpdate {
3113 private:
3114         LDKHTLCUpdate self;
3115 public:
3116         HTLCUpdate(const HTLCUpdate&) = delete;
3117         HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); }
3118         HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); }
3119         operator LDKHTLCUpdate() && { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; }
3120         ~HTLCUpdate() { HTLCUpdate_free(self); }
3121         HTLCUpdate& operator=(HTLCUpdate&& o) { HTLCUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCUpdate)); return *this; }
3122         LDKHTLCUpdate* operator &() { return &self; }
3123         LDKHTLCUpdate* operator ->() { return &self; }
3124         const LDKHTLCUpdate* operator &() const { return &self; }
3125         const LDKHTLCUpdate* operator ->() const { return &self; }
3126 };
3127 class Balance {
3128 private:
3129         LDKBalance self;
3130 public:
3131         Balance(const Balance&) = delete;
3132         Balance(Balance&& o) : self(o.self) { memset(&o, 0, sizeof(Balance)); }
3133         Balance(LDKBalance&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBalance)); }
3134         operator LDKBalance() && { LDKBalance res = self; memset(&self, 0, sizeof(LDKBalance)); return res; }
3135         ~Balance() { Balance_free(self); }
3136         Balance& operator=(Balance&& o) { Balance_free(self); self = o.self; memset(&o, 0, sizeof(Balance)); return *this; }
3137         LDKBalance* operator &() { return &self; }
3138         LDKBalance* operator ->() { return &self; }
3139         const LDKBalance* operator &() const { return &self; }
3140         const LDKBalance* operator ->() const { return &self; }
3141 };
3142 class ChannelMonitor {
3143 private:
3144         LDKChannelMonitor self;
3145 public:
3146         ChannelMonitor(const ChannelMonitor&) = delete;
3147         ChannelMonitor(ChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitor)); }
3148         ChannelMonitor(LDKChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitor)); }
3149         operator LDKChannelMonitor() && { LDKChannelMonitor res = self; memset(&self, 0, sizeof(LDKChannelMonitor)); return res; }
3150         ~ChannelMonitor() { ChannelMonitor_free(self); }
3151         ChannelMonitor& operator=(ChannelMonitor&& o) { ChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitor)); return *this; }
3152         LDKChannelMonitor* operator &() { return &self; }
3153         LDKChannelMonitor* operator ->() { return &self; }
3154         const LDKChannelMonitor* operator &() const { return &self; }
3155         const LDKChannelMonitor* operator ->() const { return &self; }
3156 };
3157 class ExpandedKey {
3158 private:
3159         LDKExpandedKey self;
3160 public:
3161         ExpandedKey(const ExpandedKey&) = delete;
3162         ExpandedKey(ExpandedKey&& o) : self(o.self) { memset(&o, 0, sizeof(ExpandedKey)); }
3163         ExpandedKey(LDKExpandedKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpandedKey)); }
3164         operator LDKExpandedKey() && { LDKExpandedKey res = self; memset(&self, 0, sizeof(LDKExpandedKey)); return res; }
3165         ~ExpandedKey() { ExpandedKey_free(self); }
3166         ExpandedKey& operator=(ExpandedKey&& o) { ExpandedKey_free(self); self = o.self; memset(&o, 0, sizeof(ExpandedKey)); return *this; }
3167         LDKExpandedKey* operator &() { return &self; }
3168         LDKExpandedKey* operator ->() { return &self; }
3169         const LDKExpandedKey* operator &() const { return &self; }
3170         const LDKExpandedKey* operator ->() const { return &self; }
3171 };
3172 class CustomMessageHandler {
3173 private:
3174         LDKCustomMessageHandler self;
3175 public:
3176         CustomMessageHandler(const CustomMessageHandler&) = delete;
3177         CustomMessageHandler(CustomMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(CustomMessageHandler)); }
3178         CustomMessageHandler(LDKCustomMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomMessageHandler)); }
3179         operator LDKCustomMessageHandler() && { LDKCustomMessageHandler res = self; memset(&self, 0, sizeof(LDKCustomMessageHandler)); return res; }
3180         ~CustomMessageHandler() { CustomMessageHandler_free(self); }
3181         CustomMessageHandler& operator=(CustomMessageHandler&& o) { CustomMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(CustomMessageHandler)); return *this; }
3182         LDKCustomMessageHandler* operator &() { return &self; }
3183         LDKCustomMessageHandler* operator ->() { return &self; }
3184         const LDKCustomMessageHandler* operator &() const { return &self; }
3185         const LDKCustomMessageHandler* operator ->() const { return &self; }
3186         /**
3187          *  Handles the given message sent from `sender_node_id`, possibly producing messages for
3188          *  [`CustomMessageHandler::get_and_clear_pending_msg`] to return and thus for [`PeerManager`]
3189          *  to send.
3190          */
3191         inline LDK::CResult_NoneLightningErrorZ handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id);
3192         /**
3193          *  Returns the list of pending messages that were generated by the handler, clearing the list
3194          *  in the process. Each message is paired with the node id of the intended recipient. If no
3195          *  connection to the node exists, then the message is simply not sent.
3196          */
3197         inline LDK::CVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg();
3198         /**
3199          *  Gets the node feature flags which this handler itself supports. All available handlers are
3200          *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
3201          *  which are broadcasted in our [`NodeAnnouncement`] message.
3202          *
3203          *  [`NodeAnnouncement`]: crate::ln::msgs::NodeAnnouncement
3204          */
3205         inline LDK::NodeFeatures provided_node_features();
3206         /**
3207          *  Gets the init feature flags which should be sent to the given peer. All available handlers
3208          *  are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
3209          *  which are sent in our [`Init`] message.
3210          *
3211          *  [`Init`]: crate::ln::msgs::Init
3212          */
3213         inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
3214 };
3215 class IgnoringMessageHandler {
3216 private:
3217         LDKIgnoringMessageHandler self;
3218 public:
3219         IgnoringMessageHandler(const IgnoringMessageHandler&) = delete;
3220         IgnoringMessageHandler(IgnoringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(IgnoringMessageHandler)); }
3221         IgnoringMessageHandler(LDKIgnoringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKIgnoringMessageHandler)); }
3222         operator LDKIgnoringMessageHandler() && { LDKIgnoringMessageHandler res = self; memset(&self, 0, sizeof(LDKIgnoringMessageHandler)); return res; }
3223         ~IgnoringMessageHandler() { IgnoringMessageHandler_free(self); }
3224         IgnoringMessageHandler& operator=(IgnoringMessageHandler&& o) { IgnoringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(IgnoringMessageHandler)); return *this; }
3225         LDKIgnoringMessageHandler* operator &() { return &self; }
3226         LDKIgnoringMessageHandler* operator ->() { return &self; }
3227         const LDKIgnoringMessageHandler* operator &() const { return &self; }
3228         const LDKIgnoringMessageHandler* operator ->() const { return &self; }
3229 };
3230 class ErroringMessageHandler {
3231 private:
3232         LDKErroringMessageHandler self;
3233 public:
3234         ErroringMessageHandler(const ErroringMessageHandler&) = delete;
3235         ErroringMessageHandler(ErroringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ErroringMessageHandler)); }
3236         ErroringMessageHandler(LDKErroringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroringMessageHandler)); }
3237         operator LDKErroringMessageHandler() && { LDKErroringMessageHandler res = self; memset(&self, 0, sizeof(LDKErroringMessageHandler)); return res; }
3238         ~ErroringMessageHandler() { ErroringMessageHandler_free(self); }
3239         ErroringMessageHandler& operator=(ErroringMessageHandler&& o) { ErroringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ErroringMessageHandler)); return *this; }
3240         LDKErroringMessageHandler* operator &() { return &self; }
3241         LDKErroringMessageHandler* operator ->() { return &self; }
3242         const LDKErroringMessageHandler* operator &() const { return &self; }
3243         const LDKErroringMessageHandler* operator ->() const { return &self; }
3244 };
3245 class MessageHandler {
3246 private:
3247         LDKMessageHandler self;
3248 public:
3249         MessageHandler(const MessageHandler&) = delete;
3250         MessageHandler(MessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(MessageHandler)); }
3251         MessageHandler(LDKMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageHandler)); }
3252         operator LDKMessageHandler() && { LDKMessageHandler res = self; memset(&self, 0, sizeof(LDKMessageHandler)); return res; }
3253         ~MessageHandler() { MessageHandler_free(self); }
3254         MessageHandler& operator=(MessageHandler&& o) { MessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(MessageHandler)); return *this; }
3255         LDKMessageHandler* operator &() { return &self; }
3256         LDKMessageHandler* operator ->() { return &self; }
3257         const LDKMessageHandler* operator &() const { return &self; }
3258         const LDKMessageHandler* operator ->() const { return &self; }
3259 };
3260 class SocketDescriptor {
3261 private:
3262         LDKSocketDescriptor self;
3263 public:
3264         SocketDescriptor(const SocketDescriptor&) = delete;
3265         SocketDescriptor(SocketDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SocketDescriptor)); }
3266         SocketDescriptor(LDKSocketDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketDescriptor)); }
3267         operator LDKSocketDescriptor() && { LDKSocketDescriptor res = self; memset(&self, 0, sizeof(LDKSocketDescriptor)); return res; }
3268         ~SocketDescriptor() { SocketDescriptor_free(self); }
3269         SocketDescriptor& operator=(SocketDescriptor&& o) { SocketDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SocketDescriptor)); return *this; }
3270         LDKSocketDescriptor* operator &() { return &self; }
3271         LDKSocketDescriptor* operator ->() { return &self; }
3272         const LDKSocketDescriptor* operator &() const { return &self; }
3273         const LDKSocketDescriptor* operator ->() const { return &self; }
3274         /**
3275          *  Attempts to send some data from the given slice to the peer.
3276          *
3277          *  Returns the amount of data which was sent, possibly 0 if the socket has since disconnected.
3278          *  Note that in the disconnected case, [`PeerManager::socket_disconnected`] must still be
3279          *  called and further write attempts may occur until that time.
3280          *
3281          *  If the returned size is smaller than `data.len()`, a
3282          *  [`PeerManager::write_buffer_space_avail`] call must be made the next time more data can be
3283          *  written. Additionally, until a `send_data` event completes fully, no further
3284          *  [`PeerManager::read_event`] calls should be made for the same peer! Because this is to
3285          *  prevent denial-of-service issues, you should not read or buffer any data from the socket
3286          *  until then.
3287          *
3288          *  If a [`PeerManager::read_event`] call on this descriptor had previously returned true
3289          *  (indicating that read events should be paused to prevent DoS in the send buffer),
3290          *  `resume_read` may be set indicating that read events on this descriptor should resume. A
3291          *  `resume_read` of false carries no meaning, and should not cause any action.
3292          */
3293         inline uintptr_t send_data(struct LDKu8slice data, bool resume_read);
3294         /**
3295          *  Disconnect the socket pointed to by this SocketDescriptor.
3296          *
3297          *  You do *not* need to call [`PeerManager::socket_disconnected`] with this socket after this
3298          *  call (doing so is a noop).
3299          */
3300         inline void disconnect_socket();
3301         /** Checks if two objects are equal given this object's this_arg pointer and another object. */
3302         inline bool eq(const struct LDKSocketDescriptor *NONNULL_PTR other_arg);
3303         /**
3304          * Calculate a succinct non-cryptographic hash for an object given its this_arg pointer.
3305          * This is used, for example, for inclusion of this object in a hash map.
3306          */
3307         inline uint64_t hash();
3308 };
3309 class PeerHandleError {
3310 private:
3311         LDKPeerHandleError self;
3312 public:
3313         PeerHandleError(const PeerHandleError&) = delete;
3314         PeerHandleError(PeerHandleError&& o) : self(o.self) { memset(&o, 0, sizeof(PeerHandleError)); }
3315         PeerHandleError(LDKPeerHandleError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerHandleError)); }
3316         operator LDKPeerHandleError() && { LDKPeerHandleError res = self; memset(&self, 0, sizeof(LDKPeerHandleError)); return res; }
3317         ~PeerHandleError() { PeerHandleError_free(self); }
3318         PeerHandleError& operator=(PeerHandleError&& o) { PeerHandleError_free(self); self = o.self; memset(&o, 0, sizeof(PeerHandleError)); return *this; }
3319         LDKPeerHandleError* operator &() { return &self; }
3320         LDKPeerHandleError* operator ->() { return &self; }
3321         const LDKPeerHandleError* operator &() const { return &self; }
3322         const LDKPeerHandleError* operator ->() const { return &self; }
3323 };
3324 class PeerManager {
3325 private:
3326         LDKPeerManager self;
3327 public:
3328         PeerManager(const PeerManager&) = delete;
3329         PeerManager(PeerManager&& o) : self(o.self) { memset(&o, 0, sizeof(PeerManager)); }
3330         PeerManager(LDKPeerManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerManager)); }
3331         operator LDKPeerManager() && { LDKPeerManager res = self; memset(&self, 0, sizeof(LDKPeerManager)); return res; }
3332         ~PeerManager() { PeerManager_free(self); }
3333         PeerManager& operator=(PeerManager&& o) { PeerManager_free(self); self = o.self; memset(&o, 0, sizeof(PeerManager)); return *this; }
3334         LDKPeerManager* operator &() { return &self; }
3335         LDKPeerManager* operator ->() { return &self; }
3336         const LDKPeerManager* operator &() const { return &self; }
3337         const LDKPeerManager* operator ->() const { return &self; }
3338 };
3339 class GraphSyncError {
3340 private:
3341         LDKGraphSyncError self;
3342 public:
3343         GraphSyncError(const GraphSyncError&) = delete;
3344         GraphSyncError(GraphSyncError&& o) : self(o.self) { memset(&o, 0, sizeof(GraphSyncError)); }
3345         GraphSyncError(LDKGraphSyncError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGraphSyncError)); }
3346         operator LDKGraphSyncError() && { LDKGraphSyncError res = self; memset(&self, 0, sizeof(LDKGraphSyncError)); return res; }
3347         ~GraphSyncError() { GraphSyncError_free(self); }
3348         GraphSyncError& operator=(GraphSyncError&& o) { GraphSyncError_free(self); self = o.self; memset(&o, 0, sizeof(GraphSyncError)); return *this; }
3349         LDKGraphSyncError* operator &() { return &self; }
3350         LDKGraphSyncError* operator ->() { return &self; }
3351         const LDKGraphSyncError* operator &() const { return &self; }
3352         const LDKGraphSyncError* operator ->() const { return &self; }
3353 };
3354 class RapidGossipSync {
3355 private:
3356         LDKRapidGossipSync self;
3357 public:
3358         RapidGossipSync(const RapidGossipSync&) = delete;
3359         RapidGossipSync(RapidGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(RapidGossipSync)); }
3360         RapidGossipSync(LDKRapidGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRapidGossipSync)); }
3361         operator LDKRapidGossipSync() && { LDKRapidGossipSync res = self; memset(&self, 0, sizeof(LDKRapidGossipSync)); return res; }
3362         ~RapidGossipSync() { RapidGossipSync_free(self); }
3363         RapidGossipSync& operator=(RapidGossipSync&& o) { RapidGossipSync_free(self); self = o.self; memset(&o, 0, sizeof(RapidGossipSync)); return *this; }
3364         LDKRapidGossipSync* operator &() { return &self; }
3365         LDKRapidGossipSync* operator ->() { return &self; }
3366         const LDKRapidGossipSync* operator &() const { return &self; }
3367         const LDKRapidGossipSync* operator ->() const { return &self; }
3368 };
3369 class KVStore {
3370 private:
3371         LDKKVStore self;
3372 public:
3373         KVStore(const KVStore&) = delete;
3374         KVStore(KVStore&& o) : self(o.self) { memset(&o, 0, sizeof(KVStore)); }
3375         KVStore(LDKKVStore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKVStore)); }
3376         operator LDKKVStore() && { LDKKVStore res = self; memset(&self, 0, sizeof(LDKKVStore)); return res; }
3377         ~KVStore() { KVStore_free(self); }
3378         KVStore& operator=(KVStore&& o) { KVStore_free(self); self = o.self; memset(&o, 0, sizeof(KVStore)); return *this; }
3379         LDKKVStore* operator &() { return &self; }
3380         LDKKVStore* operator ->() { return &self; }
3381         const LDKKVStore* operator &() const { return &self; }
3382         const LDKKVStore* operator ->() const { return &self; }
3383         /**
3384          *  Returns the data stored for the given `primary_namespace`, `secondary_namespace`, and
3385          *  `key`.
3386          *
3387          *  Returns an [`ErrorKind::NotFound`] if the given `key` could not be found in the given
3388          *  `primary_namespace` and `secondary_namespace`.
3389          *
3390          *  [`ErrorKind::NotFound`]: io::ErrorKind::NotFound
3391          */
3392         inline LDK::CResult_CVec_u8ZIOErrorZ read(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key);
3393         /**
3394          *  Persists the given data under the given `key`.
3395          *
3396          *  Will create the given `primary_namespace` and `secondary_namespace` if not already present
3397          *  in the store.
3398          */
3399         inline LDK::CResult_NoneIOErrorZ write(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, struct LDKu8slice buf);
3400         /**
3401          *  Removes any data that had previously been persisted under the given `key`.
3402          *
3403          *  If the `lazy` flag is set to `true`, the backend implementation might choose to lazily
3404          *  remove the given `key` at some point in time after the method returns, e.g., as part of an
3405          *  eventual batch deletion of multiple keys. As a consequence, subsequent calls to
3406          *  [`KVStore::list`] might include the removed key until the changes are actually persisted.
3407          *
3408          *  Note that while setting the `lazy` flag reduces the I/O burden of multiple subsequent
3409          *  `remove` calls, it also influences the atomicity guarantees as lazy `remove`s could
3410          *  potentially get lost on crash after the method returns. Therefore, this flag should only be
3411          *  set for `remove` operations that can be safely replayed at a later time.
3412          *
3413          *  Returns successfully if no data will be stored for the given `primary_namespace`,
3414          *  `secondary_namespace`, and `key`, independently of whether it was present before its
3415          *  invokation or not.
3416          */
3417         inline LDK::CResult_NoneIOErrorZ remove(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, bool lazy);
3418         /**
3419          *  Returns a list of keys that are stored under the given `secondary_namespace` in
3420          *  `primary_namespace`.
3421          *
3422          *  Returns the keys in arbitrary order, so users requiring a particular order need to sort the
3423          *  returned keys. Returns an empty list if `primary_namespace` or `secondary_namespace` is unknown.
3424          */
3425         inline LDK::CResult_CVec_StrZIOErrorZ list(struct LDKStr primary_namespace, struct LDKStr secondary_namespace);
3426 };
3427 class Persister {
3428 private:
3429         LDKPersister self;
3430 public:
3431         Persister(const Persister&) = delete;
3432         Persister(Persister&& o) : self(o.self) { memset(&o, 0, sizeof(Persister)); }
3433         Persister(LDKPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersister)); }
3434         operator LDKPersister() && { LDKPersister res = self; memset(&self, 0, sizeof(LDKPersister)); return res; }
3435         ~Persister() { Persister_free(self); }
3436         Persister& operator=(Persister&& o) { Persister_free(self); self = o.self; memset(&o, 0, sizeof(Persister)); return *this; }
3437         LDKPersister* operator &() { return &self; }
3438         LDKPersister* operator ->() { return &self; }
3439         const LDKPersister* operator &() const { return &self; }
3440         const LDKPersister* operator ->() const { return &self; }
3441         /**
3442          *  Persist the given ['ChannelManager'] to disk, returning an error if persistence failed.
3443          */
3444         inline LDK::CResult_NoneIOErrorZ persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager);
3445         /**
3446          *  Persist the given [`NetworkGraph`] to disk, returning an error if persistence failed.
3447          */
3448         inline LDK::CResult_NoneIOErrorZ persist_graph(const struct LDKNetworkGraph *NONNULL_PTR network_graph);
3449         /**
3450          *  Persist the given [`WriteableScore`] to disk, returning an error if persistence failed.
3451          */
3452         inline LDK::CResult_NoneIOErrorZ persist_scorer(const struct LDKWriteableScore *NONNULL_PTR scorer);
3453 };
3454 class MonitorUpdatingPersister {
3455 private:
3456         LDKMonitorUpdatingPersister self;
3457 public:
3458         MonitorUpdatingPersister(const MonitorUpdatingPersister&) = delete;
3459         MonitorUpdatingPersister(MonitorUpdatingPersister&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdatingPersister)); }
3460         MonitorUpdatingPersister(LDKMonitorUpdatingPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdatingPersister)); }
3461         operator LDKMonitorUpdatingPersister() && { LDKMonitorUpdatingPersister res = self; memset(&self, 0, sizeof(LDKMonitorUpdatingPersister)); return res; }
3462         ~MonitorUpdatingPersister() { MonitorUpdatingPersister_free(self); }
3463         MonitorUpdatingPersister& operator=(MonitorUpdatingPersister&& o) { MonitorUpdatingPersister_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdatingPersister)); return *this; }
3464         LDKMonitorUpdatingPersister* operator &() { return &self; }
3465         LDKMonitorUpdatingPersister* operator ->() { return &self; }
3466         const LDKMonitorUpdatingPersister* operator &() const { return &self; }
3467         const LDKMonitorUpdatingPersister* operator ->() const { return &self; }
3468 };
3469 class UnsignedInvoiceRequest {
3470 private:
3471         LDKUnsignedInvoiceRequest self;
3472 public:
3473         UnsignedInvoiceRequest(const UnsignedInvoiceRequest&) = delete;
3474         UnsignedInvoiceRequest(UnsignedInvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedInvoiceRequest)); }
3475         UnsignedInvoiceRequest(LDKUnsignedInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedInvoiceRequest)); }
3476         operator LDKUnsignedInvoiceRequest() && { LDKUnsignedInvoiceRequest res = self; memset(&self, 0, sizeof(LDKUnsignedInvoiceRequest)); return res; }
3477         ~UnsignedInvoiceRequest() { UnsignedInvoiceRequest_free(self); }
3478         UnsignedInvoiceRequest& operator=(UnsignedInvoiceRequest&& o) { UnsignedInvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedInvoiceRequest)); return *this; }
3479         LDKUnsignedInvoiceRequest* operator &() { return &self; }
3480         LDKUnsignedInvoiceRequest* operator ->() { return &self; }
3481         const LDKUnsignedInvoiceRequest* operator &() const { return &self; }
3482         const LDKUnsignedInvoiceRequest* operator ->() const { return &self; }
3483 };
3484 class InvoiceRequest {
3485 private:
3486         LDKInvoiceRequest self;
3487 public:
3488         InvoiceRequest(const InvoiceRequest&) = delete;
3489         InvoiceRequest(InvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequest)); }
3490         InvoiceRequest(LDKInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequest)); }
3491         operator LDKInvoiceRequest() && { LDKInvoiceRequest res = self; memset(&self, 0, sizeof(LDKInvoiceRequest)); return res; }
3492         ~InvoiceRequest() { InvoiceRequest_free(self); }
3493         InvoiceRequest& operator=(InvoiceRequest&& o) { InvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequest)); return *this; }
3494         LDKInvoiceRequest* operator &() { return &self; }
3495         LDKInvoiceRequest* operator ->() { return &self; }
3496         const LDKInvoiceRequest* operator &() const { return &self; }
3497         const LDKInvoiceRequest* operator ->() const { return &self; }
3498 };
3499 class VerifiedInvoiceRequest {
3500 private:
3501         LDKVerifiedInvoiceRequest self;
3502 public:
3503         VerifiedInvoiceRequest(const VerifiedInvoiceRequest&) = delete;
3504         VerifiedInvoiceRequest(VerifiedInvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(VerifiedInvoiceRequest)); }
3505         VerifiedInvoiceRequest(LDKVerifiedInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKVerifiedInvoiceRequest)); }
3506         operator LDKVerifiedInvoiceRequest() && { LDKVerifiedInvoiceRequest res = self; memset(&self, 0, sizeof(LDKVerifiedInvoiceRequest)); return res; }
3507         ~VerifiedInvoiceRequest() { VerifiedInvoiceRequest_free(self); }
3508         VerifiedInvoiceRequest& operator=(VerifiedInvoiceRequest&& o) { VerifiedInvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(VerifiedInvoiceRequest)); return *this; }
3509         LDKVerifiedInvoiceRequest* operator &() { return &self; }
3510         LDKVerifiedInvoiceRequest* operator ->() { return &self; }
3511         const LDKVerifiedInvoiceRequest* operator &() const { return &self; }
3512         const LDKVerifiedInvoiceRequest* operator ->() const { return &self; }
3513 };
3514 class DecodeError {
3515 private:
3516         LDKDecodeError self;
3517 public:
3518         DecodeError(const DecodeError&) = delete;
3519         DecodeError(DecodeError&& o) : self(o.self) { memset(&o, 0, sizeof(DecodeError)); }
3520         DecodeError(LDKDecodeError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDecodeError)); }
3521         operator LDKDecodeError() && { LDKDecodeError res = self; memset(&self, 0, sizeof(LDKDecodeError)); return res; }
3522         ~DecodeError() { DecodeError_free(self); }
3523         DecodeError& operator=(DecodeError&& o) { DecodeError_free(self); self = o.self; memset(&o, 0, sizeof(DecodeError)); return *this; }
3524         LDKDecodeError* operator &() { return &self; }
3525         LDKDecodeError* operator ->() { return &self; }
3526         const LDKDecodeError* operator &() const { return &self; }
3527         const LDKDecodeError* operator ->() const { return &self; }
3528 };
3529 class Init {
3530 private:
3531         LDKInit self;
3532 public:
3533         Init(const Init&) = delete;
3534         Init(Init&& o) : self(o.self) { memset(&o, 0, sizeof(Init)); }
3535         Init(LDKInit&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInit)); }
3536         operator LDKInit() && { LDKInit res = self; memset(&self, 0, sizeof(LDKInit)); return res; }
3537         ~Init() { Init_free(self); }
3538         Init& operator=(Init&& o) { Init_free(self); self = o.self; memset(&o, 0, sizeof(Init)); return *this; }
3539         LDKInit* operator &() { return &self; }
3540         LDKInit* operator ->() { return &self; }
3541         const LDKInit* operator &() const { return &self; }
3542         const LDKInit* operator ->() const { return &self; }
3543 };
3544 class ErrorMessage {
3545 private:
3546         LDKErrorMessage self;
3547 public:
3548         ErrorMessage(const ErrorMessage&) = delete;
3549         ErrorMessage(ErrorMessage&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorMessage)); }
3550         ErrorMessage(LDKErrorMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorMessage)); }
3551         operator LDKErrorMessage() && { LDKErrorMessage res = self; memset(&self, 0, sizeof(LDKErrorMessage)); return res; }
3552         ~ErrorMessage() { ErrorMessage_free(self); }
3553         ErrorMessage& operator=(ErrorMessage&& o) { ErrorMessage_free(self); self = o.self; memset(&o, 0, sizeof(ErrorMessage)); return *this; }
3554         LDKErrorMessage* operator &() { return &self; }
3555         LDKErrorMessage* operator ->() { return &self; }
3556         const LDKErrorMessage* operator &() const { return &self; }
3557         const LDKErrorMessage* operator ->() const { return &self; }
3558 };
3559 class WarningMessage {
3560 private:
3561         LDKWarningMessage self;
3562 public:
3563         WarningMessage(const WarningMessage&) = delete;
3564         WarningMessage(WarningMessage&& o) : self(o.self) { memset(&o, 0, sizeof(WarningMessage)); }
3565         WarningMessage(LDKWarningMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWarningMessage)); }
3566         operator LDKWarningMessage() && { LDKWarningMessage res = self; memset(&self, 0, sizeof(LDKWarningMessage)); return res; }
3567         ~WarningMessage() { WarningMessage_free(self); }
3568         WarningMessage& operator=(WarningMessage&& o) { WarningMessage_free(self); self = o.self; memset(&o, 0, sizeof(WarningMessage)); return *this; }
3569         LDKWarningMessage* operator &() { return &self; }
3570         LDKWarningMessage* operator ->() { return &self; }
3571         const LDKWarningMessage* operator &() const { return &self; }
3572         const LDKWarningMessage* operator ->() const { return &self; }
3573 };
3574 class Ping {
3575 private:
3576         LDKPing self;
3577 public:
3578         Ping(const Ping&) = delete;
3579         Ping(Ping&& o) : self(o.self) { memset(&o, 0, sizeof(Ping)); }
3580         Ping(LDKPing&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPing)); }
3581         operator LDKPing() && { LDKPing res = self; memset(&self, 0, sizeof(LDKPing)); return res; }
3582         ~Ping() { Ping_free(self); }
3583         Ping& operator=(Ping&& o) { Ping_free(self); self = o.self; memset(&o, 0, sizeof(Ping)); return *this; }
3584         LDKPing* operator &() { return &self; }
3585         LDKPing* operator ->() { return &self; }
3586         const LDKPing* operator &() const { return &self; }
3587         const LDKPing* operator ->() const { return &self; }
3588 };
3589 class Pong {
3590 private:
3591         LDKPong self;
3592 public:
3593         Pong(const Pong&) = delete;
3594         Pong(Pong&& o) : self(o.self) { memset(&o, 0, sizeof(Pong)); }
3595         Pong(LDKPong&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPong)); }
3596         operator LDKPong() && { LDKPong res = self; memset(&self, 0, sizeof(LDKPong)); return res; }
3597         ~Pong() { Pong_free(self); }
3598         Pong& operator=(Pong&& o) { Pong_free(self); self = o.self; memset(&o, 0, sizeof(Pong)); return *this; }
3599         LDKPong* operator &() { return &self; }
3600         LDKPong* operator ->() { return &self; }
3601         const LDKPong* operator &() const { return &self; }
3602         const LDKPong* operator ->() const { return &self; }
3603 };
3604 class OpenChannel {
3605 private:
3606         LDKOpenChannel self;
3607 public:
3608         OpenChannel(const OpenChannel&) = delete;
3609         OpenChannel(OpenChannel&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannel)); }
3610         OpenChannel(LDKOpenChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannel)); }
3611         operator LDKOpenChannel() && { LDKOpenChannel res = self; memset(&self, 0, sizeof(LDKOpenChannel)); return res; }
3612         ~OpenChannel() { OpenChannel_free(self); }
3613         OpenChannel& operator=(OpenChannel&& o) { OpenChannel_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannel)); return *this; }
3614         LDKOpenChannel* operator &() { return &self; }
3615         LDKOpenChannel* operator ->() { return &self; }
3616         const LDKOpenChannel* operator &() const { return &self; }
3617         const LDKOpenChannel* operator ->() const { return &self; }
3618 };
3619 class OpenChannelV2 {
3620 private:
3621         LDKOpenChannelV2 self;
3622 public:
3623         OpenChannelV2(const OpenChannelV2&) = delete;
3624         OpenChannelV2(OpenChannelV2&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannelV2)); }
3625         OpenChannelV2(LDKOpenChannelV2&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannelV2)); }
3626         operator LDKOpenChannelV2() && { LDKOpenChannelV2 res = self; memset(&self, 0, sizeof(LDKOpenChannelV2)); return res; }
3627         ~OpenChannelV2() { OpenChannelV2_free(self); }
3628         OpenChannelV2& operator=(OpenChannelV2&& o) { OpenChannelV2_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannelV2)); return *this; }
3629         LDKOpenChannelV2* operator &() { return &self; }
3630         LDKOpenChannelV2* operator ->() { return &self; }
3631         const LDKOpenChannelV2* operator &() const { return &self; }
3632         const LDKOpenChannelV2* operator ->() const { return &self; }
3633 };
3634 class AcceptChannel {
3635 private:
3636         LDKAcceptChannel self;
3637 public:
3638         AcceptChannel(const AcceptChannel&) = delete;
3639         AcceptChannel(AcceptChannel&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannel)); }
3640         AcceptChannel(LDKAcceptChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannel)); }
3641         operator LDKAcceptChannel() && { LDKAcceptChannel res = self; memset(&self, 0, sizeof(LDKAcceptChannel)); return res; }
3642         ~AcceptChannel() { AcceptChannel_free(self); }
3643         AcceptChannel& operator=(AcceptChannel&& o) { AcceptChannel_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannel)); return *this; }
3644         LDKAcceptChannel* operator &() { return &self; }
3645         LDKAcceptChannel* operator ->() { return &self; }
3646         const LDKAcceptChannel* operator &() const { return &self; }
3647         const LDKAcceptChannel* operator ->() const { return &self; }
3648 };
3649 class AcceptChannelV2 {
3650 private:
3651         LDKAcceptChannelV2 self;
3652 public:
3653         AcceptChannelV2(const AcceptChannelV2&) = delete;
3654         AcceptChannelV2(AcceptChannelV2&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannelV2)); }
3655         AcceptChannelV2(LDKAcceptChannelV2&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannelV2)); }
3656         operator LDKAcceptChannelV2() && { LDKAcceptChannelV2 res = self; memset(&self, 0, sizeof(LDKAcceptChannelV2)); return res; }
3657         ~AcceptChannelV2() { AcceptChannelV2_free(self); }
3658         AcceptChannelV2& operator=(AcceptChannelV2&& o) { AcceptChannelV2_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannelV2)); return *this; }
3659         LDKAcceptChannelV2* operator &() { return &self; }
3660         LDKAcceptChannelV2* operator ->() { return &self; }
3661         const LDKAcceptChannelV2* operator &() const { return &self; }
3662         const LDKAcceptChannelV2* operator ->() const { return &self; }
3663 };
3664 class FundingCreated {
3665 private:
3666         LDKFundingCreated self;
3667 public:
3668         FundingCreated(const FundingCreated&) = delete;
3669         FundingCreated(FundingCreated&& o) : self(o.self) { memset(&o, 0, sizeof(FundingCreated)); }
3670         FundingCreated(LDKFundingCreated&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingCreated)); }
3671         operator LDKFundingCreated() && { LDKFundingCreated res = self; memset(&self, 0, sizeof(LDKFundingCreated)); return res; }
3672         ~FundingCreated() { FundingCreated_free(self); }
3673         FundingCreated& operator=(FundingCreated&& o) { FundingCreated_free(self); self = o.self; memset(&o, 0, sizeof(FundingCreated)); return *this; }
3674         LDKFundingCreated* operator &() { return &self; }
3675         LDKFundingCreated* operator ->() { return &self; }
3676         const LDKFundingCreated* operator &() const { return &self; }
3677         const LDKFundingCreated* operator ->() const { return &self; }
3678 };
3679 class FundingSigned {
3680 private:
3681         LDKFundingSigned self;
3682 public:
3683         FundingSigned(const FundingSigned&) = delete;
3684         FundingSigned(FundingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(FundingSigned)); }
3685         FundingSigned(LDKFundingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingSigned)); }
3686         operator LDKFundingSigned() && { LDKFundingSigned res = self; memset(&self, 0, sizeof(LDKFundingSigned)); return res; }
3687         ~FundingSigned() { FundingSigned_free(self); }
3688         FundingSigned& operator=(FundingSigned&& o) { FundingSigned_free(self); self = o.self; memset(&o, 0, sizeof(FundingSigned)); return *this; }
3689         LDKFundingSigned* operator &() { return &self; }
3690         LDKFundingSigned* operator ->() { return &self; }
3691         const LDKFundingSigned* operator &() const { return &self; }
3692         const LDKFundingSigned* operator ->() const { return &self; }
3693 };
3694 class ChannelReady {
3695 private:
3696         LDKChannelReady self;
3697 public:
3698         ChannelReady(const ChannelReady&) = delete;
3699         ChannelReady(ChannelReady&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReady)); }
3700         ChannelReady(LDKChannelReady&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReady)); }
3701         operator LDKChannelReady() && { LDKChannelReady res = self; memset(&self, 0, sizeof(LDKChannelReady)); return res; }
3702         ~ChannelReady() { ChannelReady_free(self); }
3703         ChannelReady& operator=(ChannelReady&& o) { ChannelReady_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReady)); return *this; }
3704         LDKChannelReady* operator &() { return &self; }
3705         LDKChannelReady* operator ->() { return &self; }
3706         const LDKChannelReady* operator &() const { return &self; }
3707         const LDKChannelReady* operator ->() const { return &self; }
3708 };
3709 class Stfu {
3710 private:
3711         LDKStfu self;
3712 public:
3713         Stfu(const Stfu&) = delete;
3714         Stfu(Stfu&& o) : self(o.self) { memset(&o, 0, sizeof(Stfu)); }
3715         Stfu(LDKStfu&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStfu)); }
3716         operator LDKStfu() && { LDKStfu res = self; memset(&self, 0, sizeof(LDKStfu)); return res; }
3717         ~Stfu() { Stfu_free(self); }
3718         Stfu& operator=(Stfu&& o) { Stfu_free(self); self = o.self; memset(&o, 0, sizeof(Stfu)); return *this; }
3719         LDKStfu* operator &() { return &self; }
3720         LDKStfu* operator ->() { return &self; }
3721         const LDKStfu* operator &() const { return &self; }
3722         const LDKStfu* operator ->() const { return &self; }
3723 };
3724 class Splice {
3725 private:
3726         LDKSplice self;
3727 public:
3728         Splice(const Splice&) = delete;
3729         Splice(Splice&& o) : self(o.self) { memset(&o, 0, sizeof(Splice)); }
3730         Splice(LDKSplice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSplice)); }
3731         operator LDKSplice() && { LDKSplice res = self; memset(&self, 0, sizeof(LDKSplice)); return res; }
3732         ~Splice() { Splice_free(self); }
3733         Splice& operator=(Splice&& o) { Splice_free(self); self = o.self; memset(&o, 0, sizeof(Splice)); return *this; }
3734         LDKSplice* operator &() { return &self; }
3735         LDKSplice* operator ->() { return &self; }
3736         const LDKSplice* operator &() const { return &self; }
3737         const LDKSplice* operator ->() const { return &self; }
3738 };
3739 class SpliceAck {
3740 private:
3741         LDKSpliceAck self;
3742 public:
3743         SpliceAck(const SpliceAck&) = delete;
3744         SpliceAck(SpliceAck&& o) : self(o.self) { memset(&o, 0, sizeof(SpliceAck)); }
3745         SpliceAck(LDKSpliceAck&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpliceAck)); }
3746         operator LDKSpliceAck() && { LDKSpliceAck res = self; memset(&self, 0, sizeof(LDKSpliceAck)); return res; }
3747         ~SpliceAck() { SpliceAck_free(self); }
3748         SpliceAck& operator=(SpliceAck&& o) { SpliceAck_free(self); self = o.self; memset(&o, 0, sizeof(SpliceAck)); return *this; }
3749         LDKSpliceAck* operator &() { return &self; }
3750         LDKSpliceAck* operator ->() { return &self; }
3751         const LDKSpliceAck* operator &() const { return &self; }
3752         const LDKSpliceAck* operator ->() const { return &self; }
3753 };
3754 class SpliceLocked {
3755 private:
3756         LDKSpliceLocked self;
3757 public:
3758         SpliceLocked(const SpliceLocked&) = delete;
3759         SpliceLocked(SpliceLocked&& o) : self(o.self) { memset(&o, 0, sizeof(SpliceLocked)); }
3760         SpliceLocked(LDKSpliceLocked&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpliceLocked)); }
3761         operator LDKSpliceLocked() && { LDKSpliceLocked res = self; memset(&self, 0, sizeof(LDKSpliceLocked)); return res; }
3762         ~SpliceLocked() { SpliceLocked_free(self); }
3763         SpliceLocked& operator=(SpliceLocked&& o) { SpliceLocked_free(self); self = o.self; memset(&o, 0, sizeof(SpliceLocked)); return *this; }
3764         LDKSpliceLocked* operator &() { return &self; }
3765         LDKSpliceLocked* operator ->() { return &self; }
3766         const LDKSpliceLocked* operator &() const { return &self; }
3767         const LDKSpliceLocked* operator ->() const { return &self; }
3768 };
3769 class TxAddInput {
3770 private:
3771         LDKTxAddInput self;
3772 public:
3773         TxAddInput(const TxAddInput&) = delete;
3774         TxAddInput(TxAddInput&& o) : self(o.self) { memset(&o, 0, sizeof(TxAddInput)); }
3775         TxAddInput(LDKTxAddInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAddInput)); }
3776         operator LDKTxAddInput() && { LDKTxAddInput res = self; memset(&self, 0, sizeof(LDKTxAddInput)); return res; }
3777         ~TxAddInput() { TxAddInput_free(self); }
3778         TxAddInput& operator=(TxAddInput&& o) { TxAddInput_free(self); self = o.self; memset(&o, 0, sizeof(TxAddInput)); return *this; }
3779         LDKTxAddInput* operator &() { return &self; }
3780         LDKTxAddInput* operator ->() { return &self; }
3781         const LDKTxAddInput* operator &() const { return &self; }
3782         const LDKTxAddInput* operator ->() const { return &self; }
3783 };
3784 class TxAddOutput {
3785 private:
3786         LDKTxAddOutput self;
3787 public:
3788         TxAddOutput(const TxAddOutput&) = delete;
3789         TxAddOutput(TxAddOutput&& o) : self(o.self) { memset(&o, 0, sizeof(TxAddOutput)); }
3790         TxAddOutput(LDKTxAddOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAddOutput)); }
3791         operator LDKTxAddOutput() && { LDKTxAddOutput res = self; memset(&self, 0, sizeof(LDKTxAddOutput)); return res; }
3792         ~TxAddOutput() { TxAddOutput_free(self); }
3793         TxAddOutput& operator=(TxAddOutput&& o) { TxAddOutput_free(self); self = o.self; memset(&o, 0, sizeof(TxAddOutput)); return *this; }
3794         LDKTxAddOutput* operator &() { return &self; }
3795         LDKTxAddOutput* operator ->() { return &self; }
3796         const LDKTxAddOutput* operator &() const { return &self; }
3797         const LDKTxAddOutput* operator ->() const { return &self; }
3798 };
3799 class TxRemoveInput {
3800 private:
3801         LDKTxRemoveInput self;
3802 public:
3803         TxRemoveInput(const TxRemoveInput&) = delete;
3804         TxRemoveInput(TxRemoveInput&& o) : self(o.self) { memset(&o, 0, sizeof(TxRemoveInput)); }
3805         TxRemoveInput(LDKTxRemoveInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxRemoveInput)); }
3806         operator LDKTxRemoveInput() && { LDKTxRemoveInput res = self; memset(&self, 0, sizeof(LDKTxRemoveInput)); return res; }
3807         ~TxRemoveInput() { TxRemoveInput_free(self); }
3808         TxRemoveInput& operator=(TxRemoveInput&& o) { TxRemoveInput_free(self); self = o.self; memset(&o, 0, sizeof(TxRemoveInput)); return *this; }
3809         LDKTxRemoveInput* operator &() { return &self; }
3810         LDKTxRemoveInput* operator ->() { return &self; }
3811         const LDKTxRemoveInput* operator &() const { return &self; }
3812         const LDKTxRemoveInput* operator ->() const { return &self; }
3813 };
3814 class TxRemoveOutput {
3815 private:
3816         LDKTxRemoveOutput self;
3817 public:
3818         TxRemoveOutput(const TxRemoveOutput&) = delete;
3819         TxRemoveOutput(TxRemoveOutput&& o) : self(o.self) { memset(&o, 0, sizeof(TxRemoveOutput)); }
3820         TxRemoveOutput(LDKTxRemoveOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxRemoveOutput)); }
3821         operator LDKTxRemoveOutput() && { LDKTxRemoveOutput res = self; memset(&self, 0, sizeof(LDKTxRemoveOutput)); return res; }
3822         ~TxRemoveOutput() { TxRemoveOutput_free(self); }
3823         TxRemoveOutput& operator=(TxRemoveOutput&& o) { TxRemoveOutput_free(self); self = o.self; memset(&o, 0, sizeof(TxRemoveOutput)); return *this; }
3824         LDKTxRemoveOutput* operator &() { return &self; }
3825         LDKTxRemoveOutput* operator ->() { return &self; }
3826         const LDKTxRemoveOutput* operator &() const { return &self; }
3827         const LDKTxRemoveOutput* operator ->() const { return &self; }
3828 };
3829 class TxComplete {
3830 private:
3831         LDKTxComplete self;
3832 public:
3833         TxComplete(const TxComplete&) = delete;
3834         TxComplete(TxComplete&& o) : self(o.self) { memset(&o, 0, sizeof(TxComplete)); }
3835         TxComplete(LDKTxComplete&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxComplete)); }
3836         operator LDKTxComplete() && { LDKTxComplete res = self; memset(&self, 0, sizeof(LDKTxComplete)); return res; }
3837         ~TxComplete() { TxComplete_free(self); }
3838         TxComplete& operator=(TxComplete&& o) { TxComplete_free(self); self = o.self; memset(&o, 0, sizeof(TxComplete)); return *this; }
3839         LDKTxComplete* operator &() { return &self; }
3840         LDKTxComplete* operator ->() { return &self; }
3841         const LDKTxComplete* operator &() const { return &self; }
3842         const LDKTxComplete* operator ->() const { return &self; }
3843 };
3844 class TxSignatures {
3845 private:
3846         LDKTxSignatures self;
3847 public:
3848         TxSignatures(const TxSignatures&) = delete;
3849         TxSignatures(TxSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(TxSignatures)); }
3850         TxSignatures(LDKTxSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxSignatures)); }
3851         operator LDKTxSignatures() && { LDKTxSignatures res = self; memset(&self, 0, sizeof(LDKTxSignatures)); return res; }
3852         ~TxSignatures() { TxSignatures_free(self); }
3853         TxSignatures& operator=(TxSignatures&& o) { TxSignatures_free(self); self = o.self; memset(&o, 0, sizeof(TxSignatures)); return *this; }
3854         LDKTxSignatures* operator &() { return &self; }
3855         LDKTxSignatures* operator ->() { return &self; }
3856         const LDKTxSignatures* operator &() const { return &self; }
3857         const LDKTxSignatures* operator ->() const { return &self; }
3858 };
3859 class TxInitRbf {
3860 private:
3861         LDKTxInitRbf self;
3862 public:
3863         TxInitRbf(const TxInitRbf&) = delete;
3864         TxInitRbf(TxInitRbf&& o) : self(o.self) { memset(&o, 0, sizeof(TxInitRbf)); }
3865         TxInitRbf(LDKTxInitRbf&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxInitRbf)); }
3866         operator LDKTxInitRbf() && { LDKTxInitRbf res = self; memset(&self, 0, sizeof(LDKTxInitRbf)); return res; }
3867         ~TxInitRbf() { TxInitRbf_free(self); }
3868         TxInitRbf& operator=(TxInitRbf&& o) { TxInitRbf_free(self); self = o.self; memset(&o, 0, sizeof(TxInitRbf)); return *this; }
3869         LDKTxInitRbf* operator &() { return &self; }
3870         LDKTxInitRbf* operator ->() { return &self; }
3871         const LDKTxInitRbf* operator &() const { return &self; }
3872         const LDKTxInitRbf* operator ->() const { return &self; }
3873 };
3874 class TxAckRbf {
3875 private:
3876         LDKTxAckRbf self;
3877 public:
3878         TxAckRbf(const TxAckRbf&) = delete;
3879         TxAckRbf(TxAckRbf&& o) : self(o.self) { memset(&o, 0, sizeof(TxAckRbf)); }
3880         TxAckRbf(LDKTxAckRbf&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAckRbf)); }
3881         operator LDKTxAckRbf() && { LDKTxAckRbf res = self; memset(&self, 0, sizeof(LDKTxAckRbf)); return res; }
3882         ~TxAckRbf() { TxAckRbf_free(self); }
3883         TxAckRbf& operator=(TxAckRbf&& o) { TxAckRbf_free(self); self = o.self; memset(&o, 0, sizeof(TxAckRbf)); return *this; }
3884         LDKTxAckRbf* operator &() { return &self; }
3885         LDKTxAckRbf* operator ->() { return &self; }
3886         const LDKTxAckRbf* operator &() const { return &self; }
3887         const LDKTxAckRbf* operator ->() const { return &self; }
3888 };
3889 class TxAbort {
3890 private:
3891         LDKTxAbort self;
3892 public:
3893         TxAbort(const TxAbort&) = delete;
3894         TxAbort(TxAbort&& o) : self(o.self) { memset(&o, 0, sizeof(TxAbort)); }
3895         TxAbort(LDKTxAbort&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAbort)); }
3896         operator LDKTxAbort() && { LDKTxAbort res = self; memset(&self, 0, sizeof(LDKTxAbort)); return res; }
3897         ~TxAbort() { TxAbort_free(self); }
3898         TxAbort& operator=(TxAbort&& o) { TxAbort_free(self); self = o.self; memset(&o, 0, sizeof(TxAbort)); return *this; }
3899         LDKTxAbort* operator &() { return &self; }
3900         LDKTxAbort* operator ->() { return &self; }
3901         const LDKTxAbort* operator &() const { return &self; }
3902         const LDKTxAbort* operator ->() const { return &self; }
3903 };
3904 class Shutdown {
3905 private:
3906         LDKShutdown self;
3907 public:
3908         Shutdown(const Shutdown&) = delete;
3909         Shutdown(Shutdown&& o) : self(o.self) { memset(&o, 0, sizeof(Shutdown)); }
3910         Shutdown(LDKShutdown&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdown)); }
3911         operator LDKShutdown() && { LDKShutdown res = self; memset(&self, 0, sizeof(LDKShutdown)); return res; }
3912         ~Shutdown() { Shutdown_free(self); }
3913         Shutdown& operator=(Shutdown&& o) { Shutdown_free(self); self = o.self; memset(&o, 0, sizeof(Shutdown)); return *this; }
3914         LDKShutdown* operator &() { return &self; }
3915         LDKShutdown* operator ->() { return &self; }
3916         const LDKShutdown* operator &() const { return &self; }
3917         const LDKShutdown* operator ->() const { return &self; }
3918 };
3919 class ClosingSignedFeeRange {
3920 private:
3921         LDKClosingSignedFeeRange self;
3922 public:
3923         ClosingSignedFeeRange(const ClosingSignedFeeRange&) = delete;
3924         ClosingSignedFeeRange(ClosingSignedFeeRange&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSignedFeeRange)); }
3925         ClosingSignedFeeRange(LDKClosingSignedFeeRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSignedFeeRange)); }
3926         operator LDKClosingSignedFeeRange() && { LDKClosingSignedFeeRange res = self; memset(&self, 0, sizeof(LDKClosingSignedFeeRange)); return res; }
3927         ~ClosingSignedFeeRange() { ClosingSignedFeeRange_free(self); }
3928         ClosingSignedFeeRange& operator=(ClosingSignedFeeRange&& o) { ClosingSignedFeeRange_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSignedFeeRange)); return *this; }
3929         LDKClosingSignedFeeRange* operator &() { return &self; }
3930         LDKClosingSignedFeeRange* operator ->() { return &self; }
3931         const LDKClosingSignedFeeRange* operator &() const { return &self; }
3932         const LDKClosingSignedFeeRange* operator ->() const { return &self; }
3933 };
3934 class ClosingSigned {
3935 private:
3936         LDKClosingSigned self;
3937 public:
3938         ClosingSigned(const ClosingSigned&) = delete;
3939         ClosingSigned(ClosingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSigned)); }
3940         ClosingSigned(LDKClosingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSigned)); }
3941         operator LDKClosingSigned() && { LDKClosingSigned res = self; memset(&self, 0, sizeof(LDKClosingSigned)); return res; }
3942         ~ClosingSigned() { ClosingSigned_free(self); }
3943         ClosingSigned& operator=(ClosingSigned&& o) { ClosingSigned_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSigned)); return *this; }
3944         LDKClosingSigned* operator &() { return &self; }
3945         LDKClosingSigned* operator ->() { return &self; }
3946         const LDKClosingSigned* operator &() const { return &self; }
3947         const LDKClosingSigned* operator ->() const { return &self; }
3948 };
3949 class UpdateAddHTLC {
3950 private:
3951         LDKUpdateAddHTLC self;
3952 public:
3953         UpdateAddHTLC(const UpdateAddHTLC&) = delete;
3954         UpdateAddHTLC(UpdateAddHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateAddHTLC)); }
3955         UpdateAddHTLC(LDKUpdateAddHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateAddHTLC)); }
3956         operator LDKUpdateAddHTLC() && { LDKUpdateAddHTLC res = self; memset(&self, 0, sizeof(LDKUpdateAddHTLC)); return res; }
3957         ~UpdateAddHTLC() { UpdateAddHTLC_free(self); }
3958         UpdateAddHTLC& operator=(UpdateAddHTLC&& o) { UpdateAddHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateAddHTLC)); return *this; }
3959         LDKUpdateAddHTLC* operator &() { return &self; }
3960         LDKUpdateAddHTLC* operator ->() { return &self; }
3961         const LDKUpdateAddHTLC* operator &() const { return &self; }
3962         const LDKUpdateAddHTLC* operator ->() const { return &self; }
3963 };
3964 class OnionMessage {
3965 private:
3966         LDKOnionMessage self;
3967 public:
3968         OnionMessage(const OnionMessage&) = delete;
3969         OnionMessage(OnionMessage&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessage)); }
3970         OnionMessage(LDKOnionMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessage)); }
3971         operator LDKOnionMessage() && { LDKOnionMessage res = self; memset(&self, 0, sizeof(LDKOnionMessage)); return res; }
3972         ~OnionMessage() { OnionMessage_free(self); }
3973         OnionMessage& operator=(OnionMessage&& o) { OnionMessage_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessage)); return *this; }
3974         LDKOnionMessage* operator &() { return &self; }
3975         LDKOnionMessage* operator ->() { return &self; }
3976         const LDKOnionMessage* operator &() const { return &self; }
3977         const LDKOnionMessage* operator ->() const { return &self; }
3978 };
3979 class UpdateFulfillHTLC {
3980 private:
3981         LDKUpdateFulfillHTLC self;
3982 public:
3983         UpdateFulfillHTLC(const UpdateFulfillHTLC&) = delete;
3984         UpdateFulfillHTLC(UpdateFulfillHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFulfillHTLC)); }
3985         UpdateFulfillHTLC(LDKUpdateFulfillHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFulfillHTLC)); }
3986         operator LDKUpdateFulfillHTLC() && { LDKUpdateFulfillHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFulfillHTLC)); return res; }
3987         ~UpdateFulfillHTLC() { UpdateFulfillHTLC_free(self); }
3988         UpdateFulfillHTLC& operator=(UpdateFulfillHTLC&& o) { UpdateFulfillHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFulfillHTLC)); return *this; }
3989         LDKUpdateFulfillHTLC* operator &() { return &self; }
3990         LDKUpdateFulfillHTLC* operator ->() { return &self; }
3991         const LDKUpdateFulfillHTLC* operator &() const { return &self; }
3992         const LDKUpdateFulfillHTLC* operator ->() const { return &self; }
3993 };
3994 class UpdateFailHTLC {
3995 private:
3996         LDKUpdateFailHTLC self;
3997 public:
3998         UpdateFailHTLC(const UpdateFailHTLC&) = delete;
3999         UpdateFailHTLC(UpdateFailHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailHTLC)); }
4000         UpdateFailHTLC(LDKUpdateFailHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailHTLC)); }
4001         operator LDKUpdateFailHTLC() && { LDKUpdateFailHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailHTLC)); return res; }
4002         ~UpdateFailHTLC() { UpdateFailHTLC_free(self); }
4003         UpdateFailHTLC& operator=(UpdateFailHTLC&& o) { UpdateFailHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailHTLC)); return *this; }
4004         LDKUpdateFailHTLC* operator &() { return &self; }
4005         LDKUpdateFailHTLC* operator ->() { return &self; }
4006         const LDKUpdateFailHTLC* operator &() const { return &self; }
4007         const LDKUpdateFailHTLC* operator ->() const { return &self; }
4008 };
4009 class UpdateFailMalformedHTLC {
4010 private:
4011         LDKUpdateFailMalformedHTLC self;
4012 public:
4013         UpdateFailMalformedHTLC(const UpdateFailMalformedHTLC&) = delete;
4014         UpdateFailMalformedHTLC(UpdateFailMalformedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); }
4015         UpdateFailMalformedHTLC(LDKUpdateFailMalformedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailMalformedHTLC)); }
4016         operator LDKUpdateFailMalformedHTLC() && { LDKUpdateFailMalformedHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailMalformedHTLC)); return res; }
4017         ~UpdateFailMalformedHTLC() { UpdateFailMalformedHTLC_free(self); }
4018         UpdateFailMalformedHTLC& operator=(UpdateFailMalformedHTLC&& o) { UpdateFailMalformedHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); return *this; }
4019         LDKUpdateFailMalformedHTLC* operator &() { return &self; }
4020         LDKUpdateFailMalformedHTLC* operator ->() { return &self; }
4021         const LDKUpdateFailMalformedHTLC* operator &() const { return &self; }
4022         const LDKUpdateFailMalformedHTLC* operator ->() const { return &self; }
4023 };
4024 class CommitmentSigned {
4025 private:
4026         LDKCommitmentSigned self;
4027 public:
4028         CommitmentSigned(const CommitmentSigned&) = delete;
4029         CommitmentSigned(CommitmentSigned&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentSigned)); }
4030         CommitmentSigned(LDKCommitmentSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentSigned)); }
4031         operator LDKCommitmentSigned() && { LDKCommitmentSigned res = self; memset(&self, 0, sizeof(LDKCommitmentSigned)); return res; }
4032         ~CommitmentSigned() { CommitmentSigned_free(self); }
4033         CommitmentSigned& operator=(CommitmentSigned&& o) { CommitmentSigned_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentSigned)); return *this; }
4034         LDKCommitmentSigned* operator &() { return &self; }
4035         LDKCommitmentSigned* operator ->() { return &self; }
4036         const LDKCommitmentSigned* operator &() const { return &self; }
4037         const LDKCommitmentSigned* operator ->() const { return &self; }
4038 };
4039 class RevokeAndACK {
4040 private:
4041         LDKRevokeAndACK self;
4042 public:
4043         RevokeAndACK(const RevokeAndACK&) = delete;
4044         RevokeAndACK(RevokeAndACK&& o) : self(o.self) { memset(&o, 0, sizeof(RevokeAndACK)); }
4045         RevokeAndACK(LDKRevokeAndACK&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevokeAndACK)); }
4046         operator LDKRevokeAndACK() && { LDKRevokeAndACK res = self; memset(&self, 0, sizeof(LDKRevokeAndACK)); return res; }
4047         ~RevokeAndACK() { RevokeAndACK_free(self); }
4048         RevokeAndACK& operator=(RevokeAndACK&& o) { RevokeAndACK_free(self); self = o.self; memset(&o, 0, sizeof(RevokeAndACK)); return *this; }
4049         LDKRevokeAndACK* operator &() { return &self; }
4050         LDKRevokeAndACK* operator ->() { return &self; }
4051         const LDKRevokeAndACK* operator &() const { return &self; }
4052         const LDKRevokeAndACK* operator ->() const { return &self; }
4053 };
4054 class UpdateFee {
4055 private:
4056         LDKUpdateFee self;
4057 public:
4058         UpdateFee(const UpdateFee&) = delete;
4059         UpdateFee(UpdateFee&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFee)); }
4060         UpdateFee(LDKUpdateFee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFee)); }
4061         operator LDKUpdateFee() && { LDKUpdateFee res = self; memset(&self, 0, sizeof(LDKUpdateFee)); return res; }
4062         ~UpdateFee() { UpdateFee_free(self); }
4063         UpdateFee& operator=(UpdateFee&& o) { UpdateFee_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFee)); return *this; }
4064         LDKUpdateFee* operator &() { return &self; }
4065         LDKUpdateFee* operator ->() { return &self; }
4066         const LDKUpdateFee* operator &() const { return &self; }
4067         const LDKUpdateFee* operator ->() const { return &self; }
4068 };
4069 class ChannelReestablish {
4070 private:
4071         LDKChannelReestablish self;
4072 public:
4073         ChannelReestablish(const ChannelReestablish&) = delete;
4074         ChannelReestablish(ChannelReestablish&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReestablish)); }
4075         ChannelReestablish(LDKChannelReestablish&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReestablish)); }
4076         operator LDKChannelReestablish() && { LDKChannelReestablish res = self; memset(&self, 0, sizeof(LDKChannelReestablish)); return res; }
4077         ~ChannelReestablish() { ChannelReestablish_free(self); }
4078         ChannelReestablish& operator=(ChannelReestablish&& o) { ChannelReestablish_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReestablish)); return *this; }
4079         LDKChannelReestablish* operator &() { return &self; }
4080         LDKChannelReestablish* operator ->() { return &self; }
4081         const LDKChannelReestablish* operator &() const { return &self; }
4082         const LDKChannelReestablish* operator ->() const { return &self; }
4083 };
4084 class AnnouncementSignatures {
4085 private:
4086         LDKAnnouncementSignatures self;
4087 public:
4088         AnnouncementSignatures(const AnnouncementSignatures&) = delete;
4089         AnnouncementSignatures(AnnouncementSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(AnnouncementSignatures)); }
4090         AnnouncementSignatures(LDKAnnouncementSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnnouncementSignatures)); }
4091         operator LDKAnnouncementSignatures() && { LDKAnnouncementSignatures res = self; memset(&self, 0, sizeof(LDKAnnouncementSignatures)); return res; }
4092         ~AnnouncementSignatures() { AnnouncementSignatures_free(self); }
4093         AnnouncementSignatures& operator=(AnnouncementSignatures&& o) { AnnouncementSignatures_free(self); self = o.self; memset(&o, 0, sizeof(AnnouncementSignatures)); return *this; }
4094         LDKAnnouncementSignatures* operator &() { return &self; }
4095         LDKAnnouncementSignatures* operator ->() { return &self; }
4096         const LDKAnnouncementSignatures* operator &() const { return &self; }
4097         const LDKAnnouncementSignatures* operator ->() const { return &self; }
4098 };
4099 class SocketAddress {
4100 private:
4101         LDKSocketAddress self;
4102 public:
4103         SocketAddress(const SocketAddress&) = delete;
4104         SocketAddress(SocketAddress&& o) : self(o.self) { memset(&o, 0, sizeof(SocketAddress)); }
4105         SocketAddress(LDKSocketAddress&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketAddress)); }
4106         operator LDKSocketAddress() && { LDKSocketAddress res = self; memset(&self, 0, sizeof(LDKSocketAddress)); return res; }
4107         ~SocketAddress() { SocketAddress_free(self); }
4108         SocketAddress& operator=(SocketAddress&& o) { SocketAddress_free(self); self = o.self; memset(&o, 0, sizeof(SocketAddress)); return *this; }
4109         LDKSocketAddress* operator &() { return &self; }
4110         LDKSocketAddress* operator ->() { return &self; }
4111         const LDKSocketAddress* operator &() const { return &self; }
4112         const LDKSocketAddress* operator ->() const { return &self; }
4113 };
4114 class SocketAddressParseError {
4115 private:
4116         LDKSocketAddressParseError self;
4117 public:
4118         SocketAddressParseError(const SocketAddressParseError&) = delete;
4119         SocketAddressParseError(SocketAddressParseError&& o) : self(o.self) { memset(&o, 0, sizeof(SocketAddressParseError)); }
4120         SocketAddressParseError(LDKSocketAddressParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketAddressParseError)); }
4121         operator LDKSocketAddressParseError() && { LDKSocketAddressParseError res = self; memset(&self, 0, sizeof(LDKSocketAddressParseError)); return res; }
4122         SocketAddressParseError& operator=(SocketAddressParseError&& o) { self = o.self; memset(&o, 0, sizeof(SocketAddressParseError)); return *this; }
4123         LDKSocketAddressParseError* operator &() { return &self; }
4124         LDKSocketAddressParseError* operator ->() { return &self; }
4125         const LDKSocketAddressParseError* operator &() const { return &self; }
4126         const LDKSocketAddressParseError* operator ->() const { return &self; }
4127 };
4128 class UnsignedGossipMessage {
4129 private:
4130         LDKUnsignedGossipMessage self;
4131 public:
4132         UnsignedGossipMessage(const UnsignedGossipMessage&) = delete;
4133         UnsignedGossipMessage(UnsignedGossipMessage&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedGossipMessage)); }
4134         UnsignedGossipMessage(LDKUnsignedGossipMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedGossipMessage)); }
4135         operator LDKUnsignedGossipMessage() && { LDKUnsignedGossipMessage res = self; memset(&self, 0, sizeof(LDKUnsignedGossipMessage)); return res; }
4136         ~UnsignedGossipMessage() { UnsignedGossipMessage_free(self); }
4137         UnsignedGossipMessage& operator=(UnsignedGossipMessage&& o) { UnsignedGossipMessage_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedGossipMessage)); return *this; }
4138         LDKUnsignedGossipMessage* operator &() { return &self; }
4139         LDKUnsignedGossipMessage* operator ->() { return &self; }
4140         const LDKUnsignedGossipMessage* operator &() const { return &self; }
4141         const LDKUnsignedGossipMessage* operator ->() const { return &self; }
4142 };
4143 class UnsignedNodeAnnouncement {
4144 private:
4145         LDKUnsignedNodeAnnouncement self;
4146 public:
4147         UnsignedNodeAnnouncement(const UnsignedNodeAnnouncement&) = delete;
4148         UnsignedNodeAnnouncement(UnsignedNodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); }
4149         UnsignedNodeAnnouncement(LDKUnsignedNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedNodeAnnouncement)); }
4150         operator LDKUnsignedNodeAnnouncement() && { LDKUnsignedNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedNodeAnnouncement)); return res; }
4151         ~UnsignedNodeAnnouncement() { UnsignedNodeAnnouncement_free(self); }
4152         UnsignedNodeAnnouncement& operator=(UnsignedNodeAnnouncement&& o) { UnsignedNodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); return *this; }
4153         LDKUnsignedNodeAnnouncement* operator &() { return &self; }
4154         LDKUnsignedNodeAnnouncement* operator ->() { return &self; }
4155         const LDKUnsignedNodeAnnouncement* operator &() const { return &self; }
4156         const LDKUnsignedNodeAnnouncement* operator ->() const { return &self; }
4157 };
4158 class NodeAnnouncement {
4159 private:
4160         LDKNodeAnnouncement self;
4161 public:
4162         NodeAnnouncement(const NodeAnnouncement&) = delete;
4163         NodeAnnouncement(NodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncement)); }
4164         NodeAnnouncement(LDKNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncement)); }
4165         operator LDKNodeAnnouncement() && { LDKNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKNodeAnnouncement)); return res; }
4166         ~NodeAnnouncement() { NodeAnnouncement_free(self); }
4167         NodeAnnouncement& operator=(NodeAnnouncement&& o) { NodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncement)); return *this; }
4168         LDKNodeAnnouncement* operator &() { return &self; }
4169         LDKNodeAnnouncement* operator ->() { return &self; }
4170         const LDKNodeAnnouncement* operator &() const { return &self; }
4171         const LDKNodeAnnouncement* operator ->() const { return &self; }
4172 };
4173 class UnsignedChannelAnnouncement {
4174 private:
4175         LDKUnsignedChannelAnnouncement self;
4176 public:
4177         UnsignedChannelAnnouncement(const UnsignedChannelAnnouncement&) = delete;
4178         UnsignedChannelAnnouncement(UnsignedChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); }
4179         UnsignedChannelAnnouncement(LDKUnsignedChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelAnnouncement)); }
4180         operator LDKUnsignedChannelAnnouncement() && { LDKUnsignedChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedChannelAnnouncement)); return res; }
4181         ~UnsignedChannelAnnouncement() { UnsignedChannelAnnouncement_free(self); }
4182         UnsignedChannelAnnouncement& operator=(UnsignedChannelAnnouncement&& o) { UnsignedChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); return *this; }
4183         LDKUnsignedChannelAnnouncement* operator &() { return &self; }
4184         LDKUnsignedChannelAnnouncement* operator ->() { return &self; }
4185         const LDKUnsignedChannelAnnouncement* operator &() const { return &self; }
4186         const LDKUnsignedChannelAnnouncement* operator ->() const { return &self; }
4187 };
4188 class ChannelAnnouncement {
4189 private:
4190         LDKChannelAnnouncement self;
4191 public:
4192         ChannelAnnouncement(const ChannelAnnouncement&) = delete;
4193         ChannelAnnouncement(ChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelAnnouncement)); }
4194         ChannelAnnouncement(LDKChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelAnnouncement)); }
4195         operator LDKChannelAnnouncement() && { LDKChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKChannelAnnouncement)); return res; }
4196         ~ChannelAnnouncement() { ChannelAnnouncement_free(self); }
4197         ChannelAnnouncement& operator=(ChannelAnnouncement&& o) { ChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(ChannelAnnouncement)); return *this; }
4198         LDKChannelAnnouncement* operator &() { return &self; }
4199         LDKChannelAnnouncement* operator ->() { return &self; }
4200         const LDKChannelAnnouncement* operator &() const { return &self; }
4201         const LDKChannelAnnouncement* operator ->() const { return &self; }
4202 };
4203 class UnsignedChannelUpdate {
4204 private:
4205         LDKUnsignedChannelUpdate self;
4206 public:
4207         UnsignedChannelUpdate(const UnsignedChannelUpdate&) = delete;
4208         UnsignedChannelUpdate(UnsignedChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelUpdate)); }
4209         UnsignedChannelUpdate(LDKUnsignedChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelUpdate)); }
4210         operator LDKUnsignedChannelUpdate() && { LDKUnsignedChannelUpdate res = self; memset(&self, 0, sizeof(LDKUnsignedChannelUpdate)); return res; }
4211         ~UnsignedChannelUpdate() { UnsignedChannelUpdate_free(self); }
4212         UnsignedChannelUpdate& operator=(UnsignedChannelUpdate&& o) { UnsignedChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelUpdate)); return *this; }
4213         LDKUnsignedChannelUpdate* operator &() { return &self; }
4214         LDKUnsignedChannelUpdate* operator ->() { return &self; }
4215         const LDKUnsignedChannelUpdate* operator &() const { return &self; }
4216         const LDKUnsignedChannelUpdate* operator ->() const { return &self; }
4217 };
4218 class ChannelUpdate {
4219 private:
4220         LDKChannelUpdate self;
4221 public:
4222         ChannelUpdate(const ChannelUpdate&) = delete;
4223         ChannelUpdate(ChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdate)); }
4224         ChannelUpdate(LDKChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdate)); }
4225         operator LDKChannelUpdate() && { LDKChannelUpdate res = self; memset(&self, 0, sizeof(LDKChannelUpdate)); return res; }
4226         ~ChannelUpdate() { ChannelUpdate_free(self); }
4227         ChannelUpdate& operator=(ChannelUpdate&& o) { ChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdate)); return *this; }
4228         LDKChannelUpdate* operator &() { return &self; }
4229         LDKChannelUpdate* operator ->() { return &self; }
4230         const LDKChannelUpdate* operator &() const { return &self; }
4231         const LDKChannelUpdate* operator ->() const { return &self; }
4232 };
4233 class QueryChannelRange {
4234 private:
4235         LDKQueryChannelRange self;
4236 public:
4237         QueryChannelRange(const QueryChannelRange&) = delete;
4238         QueryChannelRange(QueryChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(QueryChannelRange)); }
4239         QueryChannelRange(LDKQueryChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryChannelRange)); }
4240         operator LDKQueryChannelRange() && { LDKQueryChannelRange res = self; memset(&self, 0, sizeof(LDKQueryChannelRange)); return res; }
4241         ~QueryChannelRange() { QueryChannelRange_free(self); }
4242         QueryChannelRange& operator=(QueryChannelRange&& o) { QueryChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(QueryChannelRange)); return *this; }
4243         LDKQueryChannelRange* operator &() { return &self; }
4244         LDKQueryChannelRange* operator ->() { return &self; }
4245         const LDKQueryChannelRange* operator &() const { return &self; }
4246         const LDKQueryChannelRange* operator ->() const { return &self; }
4247 };
4248 class ReplyChannelRange {
4249 private:
4250         LDKReplyChannelRange self;
4251 public:
4252         ReplyChannelRange(const ReplyChannelRange&) = delete;
4253         ReplyChannelRange(ReplyChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyChannelRange)); }
4254         ReplyChannelRange(LDKReplyChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyChannelRange)); }
4255         operator LDKReplyChannelRange() && { LDKReplyChannelRange res = self; memset(&self, 0, sizeof(LDKReplyChannelRange)); return res; }
4256         ~ReplyChannelRange() { ReplyChannelRange_free(self); }
4257         ReplyChannelRange& operator=(ReplyChannelRange&& o) { ReplyChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(ReplyChannelRange)); return *this; }
4258         LDKReplyChannelRange* operator &() { return &self; }
4259         LDKReplyChannelRange* operator ->() { return &self; }
4260         const LDKReplyChannelRange* operator &() const { return &self; }
4261         const LDKReplyChannelRange* operator ->() const { return &self; }
4262 };
4263 class QueryShortChannelIds {
4264 private:
4265         LDKQueryShortChannelIds self;
4266 public:
4267         QueryShortChannelIds(const QueryShortChannelIds&) = delete;
4268         QueryShortChannelIds(QueryShortChannelIds&& o) : self(o.self) { memset(&o, 0, sizeof(QueryShortChannelIds)); }
4269         QueryShortChannelIds(LDKQueryShortChannelIds&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryShortChannelIds)); }
4270         operator LDKQueryShortChannelIds() && { LDKQueryShortChannelIds res = self; memset(&self, 0, sizeof(LDKQueryShortChannelIds)); return res; }
4271         ~QueryShortChannelIds() { QueryShortChannelIds_free(self); }
4272         QueryShortChannelIds& operator=(QueryShortChannelIds&& o) { QueryShortChannelIds_free(self); self = o.self; memset(&o, 0, sizeof(QueryShortChannelIds)); return *this; }
4273         LDKQueryShortChannelIds* operator &() { return &self; }
4274         LDKQueryShortChannelIds* operator ->() { return &self; }
4275         const LDKQueryShortChannelIds* operator &() const { return &self; }
4276         const LDKQueryShortChannelIds* operator ->() const { return &self; }
4277 };
4278 class ReplyShortChannelIdsEnd {
4279 private:
4280         LDKReplyShortChannelIdsEnd self;
4281 public:
4282         ReplyShortChannelIdsEnd(const ReplyShortChannelIdsEnd&) = delete;
4283         ReplyShortChannelIdsEnd(ReplyShortChannelIdsEnd&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); }
4284         ReplyShortChannelIdsEnd(LDKReplyShortChannelIdsEnd&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyShortChannelIdsEnd)); }
4285         operator LDKReplyShortChannelIdsEnd() && { LDKReplyShortChannelIdsEnd res = self; memset(&self, 0, sizeof(LDKReplyShortChannelIdsEnd)); return res; }
4286         ~ReplyShortChannelIdsEnd() { ReplyShortChannelIdsEnd_free(self); }
4287         ReplyShortChannelIdsEnd& operator=(ReplyShortChannelIdsEnd&& o) { ReplyShortChannelIdsEnd_free(self); self = o.self; memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); return *this; }
4288         LDKReplyShortChannelIdsEnd* operator &() { return &self; }
4289         LDKReplyShortChannelIdsEnd* operator ->() { return &self; }
4290         const LDKReplyShortChannelIdsEnd* operator &() const { return &self; }
4291         const LDKReplyShortChannelIdsEnd* operator ->() const { return &self; }
4292 };
4293 class GossipTimestampFilter {
4294 private:
4295         LDKGossipTimestampFilter self;
4296 public:
4297         GossipTimestampFilter(const GossipTimestampFilter&) = delete;
4298         GossipTimestampFilter(GossipTimestampFilter&& o) : self(o.self) { memset(&o, 0, sizeof(GossipTimestampFilter)); }
4299         GossipTimestampFilter(LDKGossipTimestampFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipTimestampFilter)); }
4300         operator LDKGossipTimestampFilter() && { LDKGossipTimestampFilter res = self; memset(&self, 0, sizeof(LDKGossipTimestampFilter)); return res; }
4301         ~GossipTimestampFilter() { GossipTimestampFilter_free(self); }
4302         GossipTimestampFilter& operator=(GossipTimestampFilter&& o) { GossipTimestampFilter_free(self); self = o.self; memset(&o, 0, sizeof(GossipTimestampFilter)); return *this; }
4303         LDKGossipTimestampFilter* operator &() { return &self; }
4304         LDKGossipTimestampFilter* operator ->() { return &self; }
4305         const LDKGossipTimestampFilter* operator &() const { return &self; }
4306         const LDKGossipTimestampFilter* operator ->() const { return &self; }
4307 };
4308 class ErrorAction {
4309 private:
4310         LDKErrorAction self;
4311 public:
4312         ErrorAction(const ErrorAction&) = delete;
4313         ErrorAction(ErrorAction&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorAction)); }
4314         ErrorAction(LDKErrorAction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorAction)); }
4315         operator LDKErrorAction() && { LDKErrorAction res = self; memset(&self, 0, sizeof(LDKErrorAction)); return res; }
4316         ~ErrorAction() { ErrorAction_free(self); }
4317         ErrorAction& operator=(ErrorAction&& o) { ErrorAction_free(self); self = o.self; memset(&o, 0, sizeof(ErrorAction)); return *this; }
4318         LDKErrorAction* operator &() { return &self; }
4319         LDKErrorAction* operator ->() { return &self; }
4320         const LDKErrorAction* operator &() const { return &self; }
4321         const LDKErrorAction* operator ->() const { return &self; }
4322 };
4323 class LightningError {
4324 private:
4325         LDKLightningError self;
4326 public:
4327         LightningError(const LightningError&) = delete;
4328         LightningError(LightningError&& o) : self(o.self) { memset(&o, 0, sizeof(LightningError)); }
4329         LightningError(LDKLightningError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLightningError)); }
4330         operator LDKLightningError() && { LDKLightningError res = self; memset(&self, 0, sizeof(LDKLightningError)); return res; }
4331         ~LightningError() { LightningError_free(self); }
4332         LightningError& operator=(LightningError&& o) { LightningError_free(self); self = o.self; memset(&o, 0, sizeof(LightningError)); return *this; }
4333         LDKLightningError* operator &() { return &self; }
4334         LDKLightningError* operator ->() { return &self; }
4335         const LDKLightningError* operator &() const { return &self; }
4336         const LDKLightningError* operator ->() const { return &self; }
4337 };
4338 class CommitmentUpdate {
4339 private:
4340         LDKCommitmentUpdate self;
4341 public:
4342         CommitmentUpdate(const CommitmentUpdate&) = delete;
4343         CommitmentUpdate(CommitmentUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentUpdate)); }
4344         CommitmentUpdate(LDKCommitmentUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentUpdate)); }
4345         operator LDKCommitmentUpdate() && { LDKCommitmentUpdate res = self; memset(&self, 0, sizeof(LDKCommitmentUpdate)); return res; }
4346         ~CommitmentUpdate() { CommitmentUpdate_free(self); }
4347         CommitmentUpdate& operator=(CommitmentUpdate&& o) { CommitmentUpdate_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentUpdate)); return *this; }
4348         LDKCommitmentUpdate* operator &() { return &self; }
4349         LDKCommitmentUpdate* operator ->() { return &self; }
4350         const LDKCommitmentUpdate* operator &() const { return &self; }
4351         const LDKCommitmentUpdate* operator ->() const { return &self; }
4352 };
4353 class ChannelMessageHandler {
4354 private:
4355         LDKChannelMessageHandler self;
4356 public:
4357         ChannelMessageHandler(const ChannelMessageHandler&) = delete;
4358         ChannelMessageHandler(ChannelMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMessageHandler)); }
4359         ChannelMessageHandler(LDKChannelMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMessageHandler)); }
4360         operator LDKChannelMessageHandler() && { LDKChannelMessageHandler res = self; memset(&self, 0, sizeof(LDKChannelMessageHandler)); return res; }
4361         ~ChannelMessageHandler() { ChannelMessageHandler_free(self); }
4362         ChannelMessageHandler& operator=(ChannelMessageHandler&& o) { ChannelMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMessageHandler)); return *this; }
4363         LDKChannelMessageHandler* operator &() { return &self; }
4364         LDKChannelMessageHandler* operator ->() { return &self; }
4365         const LDKChannelMessageHandler* operator &() const { return &self; }
4366         const LDKChannelMessageHandler* operator ->() const { return &self; }
4367         /**
4368          *  Handle an incoming `open_channel` message from the given peer.
4369          */
4370         inline void handle_open_channel(struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg);
4371         /**
4372          *  Handle an incoming `open_channel2` message from the given peer.
4373          */
4374         inline void handle_open_channel_v2(struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg);
4375         /**
4376          *  Handle an incoming `accept_channel` message from the given peer.
4377          */
4378         inline void handle_accept_channel(struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg);
4379         /**
4380          *  Handle an incoming `accept_channel2` message from the given peer.
4381          */
4382         inline void handle_accept_channel_v2(struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg);
4383         /**
4384          *  Handle an incoming `funding_created` message from the given peer.
4385          */
4386         inline void handle_funding_created(struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg);
4387         /**
4388          *  Handle an incoming `funding_signed` message from the given peer.
4389          */
4390         inline void handle_funding_signed(struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg);
4391         /**
4392          *  Handle an incoming `channel_ready` message from the given peer.
4393          */
4394         inline void handle_channel_ready(struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg);
4395         /**
4396          *  Handle an incoming `shutdown` message from the given peer.
4397          */
4398         inline void handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg);
4399         /**
4400          *  Handle an incoming `closing_signed` message from the given peer.
4401          */
4402         inline void handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg);
4403         /**
4404          *  Handle an incoming `stfu` message from the given peer.
4405          */
4406         inline void handle_stfu(struct LDKPublicKey their_node_id, const struct LDKStfu *NONNULL_PTR msg);
4407         /**
4408          *  Handle an incoming `splice` message from the given peer.
4409          */
4410         inline void handle_splice(struct LDKPublicKey their_node_id, const struct LDKSplice *NONNULL_PTR msg);
4411         /**
4412          *  Handle an incoming `splice_ack` message from the given peer.
4413          */
4414         inline void handle_splice_ack(struct LDKPublicKey their_node_id, const struct LDKSpliceAck *NONNULL_PTR msg);
4415         /**
4416          *  Handle an incoming `splice_locked` message from the given peer.
4417          */
4418         inline void handle_splice_locked(struct LDKPublicKey their_node_id, const struct LDKSpliceLocked *NONNULL_PTR msg);
4419         /**
4420          *  Handle an incoming `tx_add_input message` from the given peer.
4421          */
4422         inline void handle_tx_add_input(struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg);
4423         /**
4424          *  Handle an incoming `tx_add_output` message from the given peer.
4425          */
4426         inline void handle_tx_add_output(struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg);
4427         /**
4428          *  Handle an incoming `tx_remove_input` message from the given peer.
4429          */
4430         inline void handle_tx_remove_input(struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg);
4431         /**
4432          *  Handle an incoming `tx_remove_output` message from the given peer.
4433          */
4434         inline void handle_tx_remove_output(struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg);
4435         /**
4436          *  Handle an incoming `tx_complete message` from the given peer.
4437          */
4438         inline void handle_tx_complete(struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg);
4439         /**
4440          *  Handle an incoming `tx_signatures` message from the given peer.
4441          */
4442         inline void handle_tx_signatures(struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg);
4443         /**
4444          *  Handle an incoming `tx_init_rbf` message from the given peer.
4445          */
4446         inline void handle_tx_init_rbf(struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg);
4447         /**
4448          *  Handle an incoming `tx_ack_rbf` message from the given peer.
4449          */
4450         inline void handle_tx_ack_rbf(struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg);
4451         /**
4452          *  Handle an incoming `tx_abort message` from the given peer.
4453          */
4454         inline void handle_tx_abort(struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg);
4455         /**
4456          *  Handle an incoming `update_add_htlc` message from the given peer.
4457          */
4458         inline void handle_update_add_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg);
4459         /**
4460          *  Handle an incoming `update_fulfill_htlc` message from the given peer.
4461          */
4462         inline void handle_update_fulfill_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg);
4463         /**
4464          *  Handle an incoming `update_fail_htlc` message from the given peer.
4465          */
4466         inline void handle_update_fail_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg);
4467         /**
4468          *  Handle an incoming `update_fail_malformed_htlc` message from the given peer.
4469          */
4470         inline void handle_update_fail_malformed_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg);
4471         /**
4472          *  Handle an incoming `commitment_signed` message from the given peer.
4473          */
4474         inline void handle_commitment_signed(struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg);
4475         /**
4476          *  Handle an incoming `revoke_and_ack` message from the given peer.
4477          */
4478         inline void handle_revoke_and_ack(struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg);
4479         /**
4480          *  Handle an incoming `update_fee` message from the given peer.
4481          */
4482         inline void handle_update_fee(struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg);
4483         /**
4484          *  Handle an incoming `announcement_signatures` message from the given peer.
4485          */
4486         inline void handle_announcement_signatures(struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg);
4487         /**
4488          *  Indicates a connection to the peer failed/an existing connection was lost.
4489          */
4490         inline void peer_disconnected(struct LDKPublicKey their_node_id);
4491         /**
4492          *  Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
4493          *
4494          *  May return an `Err(())` if the features the peer supports are not sufficient to communicate
4495          *  with us. Implementors should be somewhat conservative about doing so, however, as other
4496          *  message handlers may still wish to communicate with this peer.
4497          */
4498         inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound);
4499         /**
4500          *  Handle an incoming `channel_reestablish` message from the given peer.
4501          */
4502         inline void handle_channel_reestablish(struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg);
4503         /**
4504          *  Handle an incoming `channel_update` message from the given peer.
4505          */
4506         inline void handle_channel_update(struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg);
4507         /**
4508          *  Handle an incoming `error` message from the given peer.
4509          */
4510         inline void handle_error(struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg);
4511         /**
4512          *  Gets the node feature flags which this handler itself supports. All available handlers are
4513          *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
4514          *  which are broadcasted in our [`NodeAnnouncement`] message.
4515          */
4516         inline LDK::NodeFeatures provided_node_features();
4517         /**
4518          *  Gets the init feature flags which should be sent to the given peer. All available handlers
4519          *  are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
4520          *  which are sent in our [`Init`] message.
4521          *
4522          *  Note that this method is called before [`Self::peer_connected`].
4523          */
4524         inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
4525         /**
4526          *  Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
4527          *
4528          *  If it's `None`, then no particular network chain hash compatibility will be enforced when
4529          *  connecting to peers.
4530          */
4531         inline LDK::COption_CVec_ThirtyTwoBytesZZ get_chain_hashes();
4532 };
4533 class RoutingMessageHandler {
4534 private:
4535         LDKRoutingMessageHandler self;
4536 public:
4537         RoutingMessageHandler(const RoutingMessageHandler&) = delete;
4538         RoutingMessageHandler(RoutingMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingMessageHandler)); }
4539         RoutingMessageHandler(LDKRoutingMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingMessageHandler)); }
4540         operator LDKRoutingMessageHandler() && { LDKRoutingMessageHandler res = self; memset(&self, 0, sizeof(LDKRoutingMessageHandler)); return res; }
4541         ~RoutingMessageHandler() { RoutingMessageHandler_free(self); }
4542         RoutingMessageHandler& operator=(RoutingMessageHandler&& o) { RoutingMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(RoutingMessageHandler)); return *this; }
4543         LDKRoutingMessageHandler* operator &() { return &self; }
4544         LDKRoutingMessageHandler* operator ->() { return &self; }
4545         const LDKRoutingMessageHandler* operator &() const { return &self; }
4546         const LDKRoutingMessageHandler* operator ->() const { return &self; }
4547         /**
4548          *  Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
4549          *  `false` or returning an `Err` otherwise.
4550          */
4551         inline LDK::CResult_boolLightningErrorZ handle_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg);
4552         /**
4553          *  Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
4554          *  or returning an `Err` otherwise.
4555          */
4556         inline LDK::CResult_boolLightningErrorZ handle_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg);
4557         /**
4558          *  Handle an incoming `channel_update` message, returning true if it should be forwarded on,
4559          *  `false` or returning an `Err` otherwise.
4560          */
4561         inline LDK::CResult_boolLightningErrorZ handle_channel_update(const struct LDKChannelUpdate *NONNULL_PTR msg);
4562         /**
4563          *  Gets channel announcements and updates required to dump our routing table to a remote node,
4564          *  starting at the `short_channel_id` indicated by `starting_point` and including announcements
4565          *  for a single channel.
4566          */
4567         inline LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcement(uint64_t starting_point);
4568         /**
4569          *  Gets a node announcement required to dump our routing table to a remote node, starting at
4570          *  the node *after* the provided pubkey and including up to one announcement immediately
4571          *  higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
4572          *  If `None` is provided for `starting_point`, we start at the first node.
4573          *
4574          *  Note that starting_point (or a relevant inner pointer) may be NULL or all-0s to represent None
4575          *  Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
4576          */
4577         inline LDK::NodeAnnouncement get_next_node_announcement(struct LDKNodeId starting_point);
4578         /**
4579          *  Called when a connection is established with a peer. This can be used to
4580          *  perform routing table synchronization using a strategy defined by the
4581          *  implementor.
4582          *
4583          *  May return an `Err(())` if the features the peer supports are not sufficient to communicate
4584          *  with us. Implementors should be somewhat conservative about doing so, however, as other
4585          *  message handlers may still wish to communicate with this peer.
4586          */
4587         inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound);
4588         /**
4589          *  Handles the reply of a query we initiated to learn about channels
4590          *  for a given range of blocks. We can expect to receive one or more
4591          *  replies to a single query.
4592          */
4593         inline LDK::CResult_NoneLightningErrorZ handle_reply_channel_range(struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg);
4594         /**
4595          *  Handles the reply of a query we initiated asking for routing gossip
4596          *  messages for a list of channels. We should receive this message when
4597          *  a node has completed its best effort to send us the pertaining routing
4598          *  gossip messages.
4599          */
4600         inline LDK::CResult_NoneLightningErrorZ handle_reply_short_channel_ids_end(struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg);
4601         /**
4602          *  Handles when a peer asks us to send a list of `short_channel_id`s
4603          *  for the requested range of blocks.
4604          */
4605         inline LDK::CResult_NoneLightningErrorZ handle_query_channel_range(struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg);
4606         /**
4607          *  Handles when a peer asks us to send routing gossip messages for a
4608          *  list of `short_channel_id`s.
4609          */
4610         inline LDK::CResult_NoneLightningErrorZ handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg);
4611         /**
4612          *  Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
4613          *  pending some async action. While there is no guarantee of the rate of future messages, the
4614          *  caller should seek to reduce the rate of new gossip messages handled, especially
4615          *  [`ChannelAnnouncement`]s.
4616          */
4617         inline bool processing_queue_high();
4618         /**
4619          *  Gets the node feature flags which this handler itself supports. All available handlers are
4620          *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
4621          *  which are broadcasted in our [`NodeAnnouncement`] message.
4622          */
4623         inline LDK::NodeFeatures provided_node_features();
4624         /**
4625          *  Gets the init feature flags which should be sent to the given peer. All available handlers
4626          *  are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
4627          *  which are sent in our [`Init`] message.
4628          *
4629          *  Note that this method is called before [`Self::peer_connected`].
4630          */
4631         inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
4632 };
4633 class OnionMessageHandler {
4634 private:
4635         LDKOnionMessageHandler self;
4636 public:
4637         OnionMessageHandler(const OnionMessageHandler&) = delete;
4638         OnionMessageHandler(OnionMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageHandler)); }
4639         OnionMessageHandler(LDKOnionMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageHandler)); }
4640         operator LDKOnionMessageHandler() && { LDKOnionMessageHandler res = self; memset(&self, 0, sizeof(LDKOnionMessageHandler)); return res; }
4641         ~OnionMessageHandler() { OnionMessageHandler_free(self); }
4642         OnionMessageHandler& operator=(OnionMessageHandler&& o) { OnionMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageHandler)); return *this; }
4643         LDKOnionMessageHandler* operator &() { return &self; }
4644         LDKOnionMessageHandler* operator ->() { return &self; }
4645         const LDKOnionMessageHandler* operator &() const { return &self; }
4646         const LDKOnionMessageHandler* operator ->() const { return &self; }
4647         /**
4648          *  Because much of the lightning network does not yet support forwarding onion messages, we
4649          *  may need to directly connect to a node which will forward a message for us. In such a case,
4650          *  this method will return the set of nodes which need connection by node_id and the
4651          *  corresponding socket addresses where they may accept incoming connections.
4652          *
4653          *  Thus, this method should be polled regularly to detect messages await such a direct
4654          *  connection.
4655          */
4656         inline LDK::CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ get_and_clear_connections_needed();
4657         /**
4658          *  Handle an incoming `onion_message` message from the given peer.
4659          */
4660         inline void handle_onion_message(struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg);
4661         /**
4662          *  Returns the next pending onion message for the peer with the given node id.
4663          *
4664          *  Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
4665          */
4666         inline LDK::OnionMessage next_onion_message_for_peer(struct LDKPublicKey peer_node_id);
4667         /**
4668          *  Called when a connection is established with a peer. Can be used to track which peers
4669          *  advertise onion message support and are online.
4670          *
4671          *  May return an `Err(())` if the features the peer supports are not sufficient to communicate
4672          *  with us. Implementors should be somewhat conservative about doing so, however, as other
4673          *  message handlers may still wish to communicate with this peer.
4674          */
4675         inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound);
4676         /**
4677          *  Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
4678          *  drop and refuse to forward onion messages to this peer.
4679          */
4680         inline void peer_disconnected(struct LDKPublicKey their_node_id);
4681         /**
4682          *  Performs actions that should happen roughly every ten seconds after startup. Allows handlers
4683          *  to drop any buffered onion messages intended for prospective peers.
4684          */
4685         inline void timer_tick_occurred();
4686         /**
4687          *  Gets the node feature flags which this handler itself supports. All available handlers are
4688          *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
4689          *  which are broadcasted in our [`NodeAnnouncement`] message.
4690          */
4691         inline LDK::NodeFeatures provided_node_features();
4692         /**
4693          *  Gets the init feature flags which should be sent to the given peer. All available handlers
4694          *  are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
4695          *  which are sent in our [`Init`] message.
4696          *
4697          *  Note that this method is called before [`Self::peer_connected`].
4698          */
4699         inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
4700 };
4701 class FinalOnionHopData {
4702 private:
4703         LDKFinalOnionHopData self;
4704 public:
4705         FinalOnionHopData(const FinalOnionHopData&) = delete;
4706         FinalOnionHopData(FinalOnionHopData&& o) : self(o.self) { memset(&o, 0, sizeof(FinalOnionHopData)); }
4707         FinalOnionHopData(LDKFinalOnionHopData&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFinalOnionHopData)); }
4708         operator LDKFinalOnionHopData() && { LDKFinalOnionHopData res = self; memset(&self, 0, sizeof(LDKFinalOnionHopData)); return res; }
4709         ~FinalOnionHopData() { FinalOnionHopData_free(self); }
4710         FinalOnionHopData& operator=(FinalOnionHopData&& o) { FinalOnionHopData_free(self); self = o.self; memset(&o, 0, sizeof(FinalOnionHopData)); return *this; }
4711         LDKFinalOnionHopData* operator &() { return &self; }
4712         LDKFinalOnionHopData* operator ->() { return &self; }
4713         const LDKFinalOnionHopData* operator &() const { return &self; }
4714         const LDKFinalOnionHopData* operator ->() const { return &self; }
4715 };
4716 class OnionPacket {
4717 private:
4718         LDKOnionPacket self;
4719 public:
4720         OnionPacket(const OnionPacket&) = delete;
4721         OnionPacket(OnionPacket&& o) : self(o.self) { memset(&o, 0, sizeof(OnionPacket)); }
4722         OnionPacket(LDKOnionPacket&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionPacket)); }
4723         operator LDKOnionPacket() && { LDKOnionPacket res = self; memset(&self, 0, sizeof(LDKOnionPacket)); return res; }
4724         ~OnionPacket() { OnionPacket_free(self); }
4725         OnionPacket& operator=(OnionPacket&& o) { OnionPacket_free(self); self = o.self; memset(&o, 0, sizeof(OnionPacket)); return *this; }
4726         LDKOnionPacket* operator &() { return &self; }
4727         LDKOnionPacket* operator ->() { return &self; }
4728         const LDKOnionPacket* operator &() const { return &self; }
4729         const LDKOnionPacket* operator ->() const { return &self; }
4730 };
4731 class Level {
4732 private:
4733         LDKLevel self;
4734 public:
4735         Level(const Level&) = delete;
4736         Level(Level&& o) : self(o.self) { memset(&o, 0, sizeof(Level)); }
4737         Level(LDKLevel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLevel)); }
4738         operator LDKLevel() && { LDKLevel res = self; memset(&self, 0, sizeof(LDKLevel)); return res; }
4739         Level& operator=(Level&& o) { self = o.self; memset(&o, 0, sizeof(Level)); return *this; }
4740         LDKLevel* operator &() { return &self; }
4741         LDKLevel* operator ->() { return &self; }
4742         const LDKLevel* operator &() const { return &self; }
4743         const LDKLevel* operator ->() const { return &self; }
4744 };
4745 class Record {
4746 private:
4747         LDKRecord self;
4748 public:
4749         Record(const Record&) = delete;
4750         Record(Record&& o) : self(o.self) { memset(&o, 0, sizeof(Record)); }
4751         Record(LDKRecord&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecord)); }
4752         operator LDKRecord() && { LDKRecord res = self; memset(&self, 0, sizeof(LDKRecord)); return res; }
4753         ~Record() { Record_free(self); }
4754         Record& operator=(Record&& o) { Record_free(self); self = o.self; memset(&o, 0, sizeof(Record)); return *this; }
4755         LDKRecord* operator &() { return &self; }
4756         LDKRecord* operator ->() { return &self; }
4757         const LDKRecord* operator &() const { return &self; }
4758         const LDKRecord* operator ->() const { return &self; }
4759 };
4760 class Logger {
4761 private:
4762         LDKLogger self;
4763 public:
4764         Logger(const Logger&) = delete;
4765         Logger(Logger&& o) : self(o.self) { memset(&o, 0, sizeof(Logger)); }
4766         Logger(LDKLogger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLogger)); }
4767         operator LDKLogger() && { LDKLogger res = self; memset(&self, 0, sizeof(LDKLogger)); return res; }
4768         ~Logger() { Logger_free(self); }
4769         Logger& operator=(Logger&& o) { Logger_free(self); self = o.self; memset(&o, 0, sizeof(Logger)); return *this; }
4770         LDKLogger* operator &() { return &self; }
4771         LDKLogger* operator ->() { return &self; }
4772         const LDKLogger* operator &() const { return &self; }
4773         const LDKLogger* operator ->() const { return &self; }
4774         /**
4775          *  Logs the [`Record`].
4776          */
4777         inline void log(struct LDKRecord record);
4778 };
4779 class FutureCallback {
4780 private:
4781         LDKFutureCallback self;
4782 public:
4783         FutureCallback(const FutureCallback&) = delete;
4784         FutureCallback(FutureCallback&& o) : self(o.self) { memset(&o, 0, sizeof(FutureCallback)); }
4785         FutureCallback(LDKFutureCallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFutureCallback)); }
4786         operator LDKFutureCallback() && { LDKFutureCallback res = self; memset(&self, 0, sizeof(LDKFutureCallback)); return res; }
4787         ~FutureCallback() { FutureCallback_free(self); }
4788         FutureCallback& operator=(FutureCallback&& o) { FutureCallback_free(self); self = o.self; memset(&o, 0, sizeof(FutureCallback)); return *this; }
4789         LDKFutureCallback* operator &() { return &self; }
4790         LDKFutureCallback* operator ->() { return &self; }
4791         const LDKFutureCallback* operator &() const { return &self; }
4792         const LDKFutureCallback* operator ->() const { return &self; }
4793         /**
4794          *  The method which is called.
4795          */
4796         inline void call();
4797 };
4798 class Future {
4799 private:
4800         LDKFuture self;
4801 public:
4802         Future(const Future&) = delete;
4803         Future(Future&& o) : self(o.self) { memset(&o, 0, sizeof(Future)); }
4804         Future(LDKFuture&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFuture)); }
4805         operator LDKFuture() && { LDKFuture res = self; memset(&self, 0, sizeof(LDKFuture)); return res; }
4806         ~Future() { Future_free(self); }
4807         Future& operator=(Future&& o) { Future_free(self); self = o.self; memset(&o, 0, sizeof(Future)); return *this; }
4808         LDKFuture* operator &() { return &self; }
4809         LDKFuture* operator ->() { return &self; }
4810         const LDKFuture* operator &() const { return &self; }
4811         const LDKFuture* operator ->() const { return &self; }
4812 };
4813 class Sleeper {
4814 private:
4815         LDKSleeper self;
4816 public:
4817         Sleeper(const Sleeper&) = delete;
4818         Sleeper(Sleeper&& o) : self(o.self) { memset(&o, 0, sizeof(Sleeper)); }
4819         Sleeper(LDKSleeper&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSleeper)); }
4820         operator LDKSleeper() && { LDKSleeper res = self; memset(&self, 0, sizeof(LDKSleeper)); return res; }
4821         ~Sleeper() { Sleeper_free(self); }
4822         Sleeper& operator=(Sleeper&& o) { Sleeper_free(self); self = o.self; memset(&o, 0, sizeof(Sleeper)); return *this; }
4823         LDKSleeper* operator &() { return &self; }
4824         LDKSleeper* operator ->() { return &self; }
4825         const LDKSleeper* operator &() const { return &self; }
4826         const LDKSleeper* operator ->() const { return &self; }
4827 };
4828 class OffersMessageHandler {
4829 private:
4830         LDKOffersMessageHandler self;
4831 public:
4832         OffersMessageHandler(const OffersMessageHandler&) = delete;
4833         OffersMessageHandler(OffersMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(OffersMessageHandler)); }
4834         OffersMessageHandler(LDKOffersMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffersMessageHandler)); }
4835         operator LDKOffersMessageHandler() && { LDKOffersMessageHandler res = self; memset(&self, 0, sizeof(LDKOffersMessageHandler)); return res; }
4836         ~OffersMessageHandler() { OffersMessageHandler_free(self); }
4837         OffersMessageHandler& operator=(OffersMessageHandler&& o) { OffersMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(OffersMessageHandler)); return *this; }
4838         LDKOffersMessageHandler* operator &() { return &self; }
4839         LDKOffersMessageHandler* operator ->() { return &self; }
4840         const LDKOffersMessageHandler* operator &() const { return &self; }
4841         const LDKOffersMessageHandler* operator ->() const { return &self; }
4842         /**
4843          *  Handles the given message by either responding with an [`Bolt12Invoice`], sending a payment,
4844          *  or replying with an error.
4845          *
4846          *  The returned [`OffersMessage`], if any, is enqueued to be sent by [`OnionMessenger`].
4847          *
4848          *  [`OnionMessenger`]: crate::onion_message::messenger::OnionMessenger
4849          */
4850         inline LDK::COption_OffersMessageZ handle_message(struct LDKOffersMessage message);
4851         /**
4852          *  Releases any [`OffersMessage`]s that need to be sent.
4853          *
4854          *  Typically, this is used for messages initiating a payment flow rather than in response to
4855          *  another message. The latter should use the return value of [`Self::handle_message`].
4856          */
4857         inline LDK::CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ release_pending_messages();
4858 };
4859 class OffersMessage {
4860 private:
4861         LDKOffersMessage self;
4862 public:
4863         OffersMessage(const OffersMessage&) = delete;
4864         OffersMessage(OffersMessage&& o) : self(o.self) { memset(&o, 0, sizeof(OffersMessage)); }
4865         OffersMessage(LDKOffersMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffersMessage)); }
4866         operator LDKOffersMessage() && { LDKOffersMessage res = self; memset(&self, 0, sizeof(LDKOffersMessage)); return res; }
4867         ~OffersMessage() { OffersMessage_free(self); }
4868         OffersMessage& operator=(OffersMessage&& o) { OffersMessage_free(self); self = o.self; memset(&o, 0, sizeof(OffersMessage)); return *this; }
4869         LDKOffersMessage* operator &() { return &self; }
4870         LDKOffersMessage* operator ->() { return &self; }
4871         const LDKOffersMessage* operator &() const { return &self; }
4872         const LDKOffersMessage* operator ->() const { return &self; }
4873 };
4874 class HTLCClaim {
4875 private:
4876         LDKHTLCClaim self;
4877 public:
4878         HTLCClaim(const HTLCClaim&) = delete;
4879         HTLCClaim(HTLCClaim&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCClaim)); }
4880         HTLCClaim(LDKHTLCClaim&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCClaim)); }
4881         operator LDKHTLCClaim() && { LDKHTLCClaim res = self; memset(&self, 0, sizeof(LDKHTLCClaim)); return res; }
4882         HTLCClaim& operator=(HTLCClaim&& o) { self = o.self; memset(&o, 0, sizeof(HTLCClaim)); return *this; }
4883         LDKHTLCClaim* operator &() { return &self; }
4884         LDKHTLCClaim* operator ->() { return &self; }
4885         const LDKHTLCClaim* operator &() const { return &self; }
4886         const LDKHTLCClaim* operator ->() const { return &self; }
4887 };
4888 class CounterpartyCommitmentSecrets {
4889 private:
4890         LDKCounterpartyCommitmentSecrets self;
4891 public:
4892         CounterpartyCommitmentSecrets(const CounterpartyCommitmentSecrets&) = delete;
4893         CounterpartyCommitmentSecrets(CounterpartyCommitmentSecrets&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); }
4894         CounterpartyCommitmentSecrets(LDKCounterpartyCommitmentSecrets&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); }
4895         operator LDKCounterpartyCommitmentSecrets() && { LDKCounterpartyCommitmentSecrets res = self; memset(&self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); return res; }
4896         ~CounterpartyCommitmentSecrets() { CounterpartyCommitmentSecrets_free(self); }
4897         CounterpartyCommitmentSecrets& operator=(CounterpartyCommitmentSecrets&& o) { CounterpartyCommitmentSecrets_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); return *this; }
4898         LDKCounterpartyCommitmentSecrets* operator &() { return &self; }
4899         LDKCounterpartyCommitmentSecrets* operator ->() { return &self; }
4900         const LDKCounterpartyCommitmentSecrets* operator &() const { return &self; }
4901         const LDKCounterpartyCommitmentSecrets* operator ->() const { return &self; }
4902 };
4903 class TxCreationKeys {
4904 private:
4905         LDKTxCreationKeys self;
4906 public:
4907         TxCreationKeys(const TxCreationKeys&) = delete;
4908         TxCreationKeys(TxCreationKeys&& o) : self(o.self) { memset(&o, 0, sizeof(TxCreationKeys)); }
4909         TxCreationKeys(LDKTxCreationKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxCreationKeys)); }
4910         operator LDKTxCreationKeys() && { LDKTxCreationKeys res = self; memset(&self, 0, sizeof(LDKTxCreationKeys)); return res; }
4911         ~TxCreationKeys() { TxCreationKeys_free(self); }
4912         TxCreationKeys& operator=(TxCreationKeys&& o) { TxCreationKeys_free(self); self = o.self; memset(&o, 0, sizeof(TxCreationKeys)); return *this; }
4913         LDKTxCreationKeys* operator &() { return &self; }
4914         LDKTxCreationKeys* operator ->() { return &self; }
4915         const LDKTxCreationKeys* operator &() const { return &self; }
4916         const LDKTxCreationKeys* operator ->() const { return &self; }
4917 };
4918 class ChannelPublicKeys {
4919 private:
4920         LDKChannelPublicKeys self;
4921 public:
4922         ChannelPublicKeys(const ChannelPublicKeys&) = delete;
4923         ChannelPublicKeys(ChannelPublicKeys&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelPublicKeys)); }
4924         ChannelPublicKeys(LDKChannelPublicKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelPublicKeys)); }
4925         operator LDKChannelPublicKeys() && { LDKChannelPublicKeys res = self; memset(&self, 0, sizeof(LDKChannelPublicKeys)); return res; }
4926         ~ChannelPublicKeys() { ChannelPublicKeys_free(self); }
4927         ChannelPublicKeys& operator=(ChannelPublicKeys&& o) { ChannelPublicKeys_free(self); self = o.self; memset(&o, 0, sizeof(ChannelPublicKeys)); return *this; }
4928         LDKChannelPublicKeys* operator &() { return &self; }
4929         LDKChannelPublicKeys* operator ->() { return &self; }
4930         const LDKChannelPublicKeys* operator &() const { return &self; }
4931         const LDKChannelPublicKeys* operator ->() const { return &self; }
4932 };
4933 class HTLCOutputInCommitment {
4934 private:
4935         LDKHTLCOutputInCommitment self;
4936 public:
4937         HTLCOutputInCommitment(const HTLCOutputInCommitment&) = delete;
4938         HTLCOutputInCommitment(HTLCOutputInCommitment&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCOutputInCommitment)); }
4939         HTLCOutputInCommitment(LDKHTLCOutputInCommitment&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCOutputInCommitment)); }
4940         operator LDKHTLCOutputInCommitment() && { LDKHTLCOutputInCommitment res = self; memset(&self, 0, sizeof(LDKHTLCOutputInCommitment)); return res; }
4941         ~HTLCOutputInCommitment() { HTLCOutputInCommitment_free(self); }
4942         HTLCOutputInCommitment& operator=(HTLCOutputInCommitment&& o) { HTLCOutputInCommitment_free(self); self = o.self; memset(&o, 0, sizeof(HTLCOutputInCommitment)); return *this; }
4943         LDKHTLCOutputInCommitment* operator &() { return &self; }
4944         LDKHTLCOutputInCommitment* operator ->() { return &self; }
4945         const LDKHTLCOutputInCommitment* operator &() const { return &self; }
4946         const LDKHTLCOutputInCommitment* operator ->() const { return &self; }
4947 };
4948 class ChannelTransactionParameters {
4949 private:
4950         LDKChannelTransactionParameters self;
4951 public:
4952         ChannelTransactionParameters(const ChannelTransactionParameters&) = delete;
4953         ChannelTransactionParameters(ChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTransactionParameters)); }
4954         ChannelTransactionParameters(LDKChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTransactionParameters)); }
4955         operator LDKChannelTransactionParameters() && { LDKChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKChannelTransactionParameters)); return res; }
4956         ~ChannelTransactionParameters() { ChannelTransactionParameters_free(self); }
4957         ChannelTransactionParameters& operator=(ChannelTransactionParameters&& o) { ChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTransactionParameters)); return *this; }
4958         LDKChannelTransactionParameters* operator &() { return &self; }
4959         LDKChannelTransactionParameters* operator ->() { return &self; }
4960         const LDKChannelTransactionParameters* operator &() const { return &self; }
4961         const LDKChannelTransactionParameters* operator ->() const { return &self; }
4962 };
4963 class CounterpartyChannelTransactionParameters {
4964 private:
4965         LDKCounterpartyChannelTransactionParameters self;
4966 public:
4967         CounterpartyChannelTransactionParameters(const CounterpartyChannelTransactionParameters&) = delete;
4968         CounterpartyChannelTransactionParameters(CounterpartyChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyChannelTransactionParameters)); }
4969         CounterpartyChannelTransactionParameters(LDKCounterpartyChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyChannelTransactionParameters)); }
4970         operator LDKCounterpartyChannelTransactionParameters() && { LDKCounterpartyChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKCounterpartyChannelTransactionParameters)); return res; }
4971         ~CounterpartyChannelTransactionParameters() { CounterpartyChannelTransactionParameters_free(self); }
4972         CounterpartyChannelTransactionParameters& operator=(CounterpartyChannelTransactionParameters&& o) { CounterpartyChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyChannelTransactionParameters)); return *this; }
4973         LDKCounterpartyChannelTransactionParameters* operator &() { return &self; }
4974         LDKCounterpartyChannelTransactionParameters* operator ->() { return &self; }
4975         const LDKCounterpartyChannelTransactionParameters* operator &() const { return &self; }
4976         const LDKCounterpartyChannelTransactionParameters* operator ->() const { return &self; }
4977 };
4978 class DirectedChannelTransactionParameters {
4979 private:
4980         LDKDirectedChannelTransactionParameters self;
4981 public:
4982         DirectedChannelTransactionParameters(const DirectedChannelTransactionParameters&) = delete;
4983         DirectedChannelTransactionParameters(DirectedChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(DirectedChannelTransactionParameters)); }
4984         DirectedChannelTransactionParameters(LDKDirectedChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectedChannelTransactionParameters)); }
4985         operator LDKDirectedChannelTransactionParameters() && { LDKDirectedChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKDirectedChannelTransactionParameters)); return res; }
4986         ~DirectedChannelTransactionParameters() { DirectedChannelTransactionParameters_free(self); }
4987         DirectedChannelTransactionParameters& operator=(DirectedChannelTransactionParameters&& o) { DirectedChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(DirectedChannelTransactionParameters)); return *this; }
4988         LDKDirectedChannelTransactionParameters* operator &() { return &self; }
4989         LDKDirectedChannelTransactionParameters* operator ->() { return &self; }
4990         const LDKDirectedChannelTransactionParameters* operator &() const { return &self; }
4991         const LDKDirectedChannelTransactionParameters* operator ->() const { return &self; }
4992 };
4993 class HolderCommitmentTransaction {
4994 private:
4995         LDKHolderCommitmentTransaction self;
4996 public:
4997         HolderCommitmentTransaction(const HolderCommitmentTransaction&) = delete;
4998         HolderCommitmentTransaction(HolderCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(HolderCommitmentTransaction)); }
4999         HolderCommitmentTransaction(LDKHolderCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHolderCommitmentTransaction)); }
5000         operator LDKHolderCommitmentTransaction() && { LDKHolderCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKHolderCommitmentTransaction)); return res; }
5001         ~HolderCommitmentTransaction() { HolderCommitmentTransaction_free(self); }
5002         HolderCommitmentTransaction& operator=(HolderCommitmentTransaction&& o) { HolderCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(HolderCommitmentTransaction)); return *this; }
5003         LDKHolderCommitmentTransaction* operator &() { return &self; }
5004         LDKHolderCommitmentTransaction* operator ->() { return &self; }
5005         const LDKHolderCommitmentTransaction* operator &() const { return &self; }
5006         const LDKHolderCommitmentTransaction* operator ->() const { return &self; }
5007 };
5008 class BuiltCommitmentTransaction {
5009 private:
5010         LDKBuiltCommitmentTransaction self;
5011 public:
5012         BuiltCommitmentTransaction(const BuiltCommitmentTransaction&) = delete;
5013         BuiltCommitmentTransaction(BuiltCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(BuiltCommitmentTransaction)); }
5014         BuiltCommitmentTransaction(LDKBuiltCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBuiltCommitmentTransaction)); }
5015         operator LDKBuiltCommitmentTransaction() && { LDKBuiltCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKBuiltCommitmentTransaction)); return res; }
5016         ~BuiltCommitmentTransaction() { BuiltCommitmentTransaction_free(self); }
5017         BuiltCommitmentTransaction& operator=(BuiltCommitmentTransaction&& o) { BuiltCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(BuiltCommitmentTransaction)); return *this; }
5018         LDKBuiltCommitmentTransaction* operator &() { return &self; }
5019         LDKBuiltCommitmentTransaction* operator ->() { return &self; }
5020         const LDKBuiltCommitmentTransaction* operator &() const { return &self; }
5021         const LDKBuiltCommitmentTransaction* operator ->() const { return &self; }
5022 };
5023 class ClosingTransaction {
5024 private:
5025         LDKClosingTransaction self;
5026 public:
5027         ClosingTransaction(const ClosingTransaction&) = delete;
5028         ClosingTransaction(ClosingTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingTransaction)); }
5029         ClosingTransaction(LDKClosingTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingTransaction)); }
5030         operator LDKClosingTransaction() && { LDKClosingTransaction res = self; memset(&self, 0, sizeof(LDKClosingTransaction)); return res; }
5031         ~ClosingTransaction() { ClosingTransaction_free(self); }
5032         ClosingTransaction& operator=(ClosingTransaction&& o) { ClosingTransaction_free(self); self = o.self; memset(&o, 0, sizeof(ClosingTransaction)); return *this; }
5033         LDKClosingTransaction* operator &() { return &self; }
5034         LDKClosingTransaction* operator ->() { return &self; }
5035         const LDKClosingTransaction* operator &() const { return &self; }
5036         const LDKClosingTransaction* operator ->() const { return &self; }
5037 };
5038 class TrustedClosingTransaction {
5039 private:
5040         LDKTrustedClosingTransaction self;
5041 public:
5042         TrustedClosingTransaction(const TrustedClosingTransaction&) = delete;
5043         TrustedClosingTransaction(TrustedClosingTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(TrustedClosingTransaction)); }
5044         TrustedClosingTransaction(LDKTrustedClosingTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrustedClosingTransaction)); }
5045         operator LDKTrustedClosingTransaction() && { LDKTrustedClosingTransaction res = self; memset(&self, 0, sizeof(LDKTrustedClosingTransaction)); return res; }
5046         ~TrustedClosingTransaction() { TrustedClosingTransaction_free(self); }
5047         TrustedClosingTransaction& operator=(TrustedClosingTransaction&& o) { TrustedClosingTransaction_free(self); self = o.self; memset(&o, 0, sizeof(TrustedClosingTransaction)); return *this; }
5048         LDKTrustedClosingTransaction* operator &() { return &self; }
5049         LDKTrustedClosingTransaction* operator ->() { return &self; }
5050         const LDKTrustedClosingTransaction* operator &() const { return &self; }
5051         const LDKTrustedClosingTransaction* operator ->() const { return &self; }
5052 };
5053 class CommitmentTransaction {
5054 private:
5055         LDKCommitmentTransaction self;
5056 public:
5057         CommitmentTransaction(const CommitmentTransaction&) = delete;
5058         CommitmentTransaction(CommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentTransaction)); }
5059         CommitmentTransaction(LDKCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentTransaction)); }
5060         operator LDKCommitmentTransaction() && { LDKCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKCommitmentTransaction)); return res; }
5061         ~CommitmentTransaction() { CommitmentTransaction_free(self); }
5062         CommitmentTransaction& operator=(CommitmentTransaction&& o) { CommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentTransaction)); return *this; }
5063         LDKCommitmentTransaction* operator &() { return &self; }
5064         LDKCommitmentTransaction* operator ->() { return &self; }
5065         const LDKCommitmentTransaction* operator &() const { return &self; }
5066         const LDKCommitmentTransaction* operator ->() const { return &self; }
5067 };
5068 class TrustedCommitmentTransaction {
5069 private:
5070         LDKTrustedCommitmentTransaction self;
5071 public:
5072         TrustedCommitmentTransaction(const TrustedCommitmentTransaction&) = delete;
5073         TrustedCommitmentTransaction(TrustedCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(TrustedCommitmentTransaction)); }
5074         TrustedCommitmentTransaction(LDKTrustedCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrustedCommitmentTransaction)); }
5075         operator LDKTrustedCommitmentTransaction() && { LDKTrustedCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKTrustedCommitmentTransaction)); return res; }
5076         ~TrustedCommitmentTransaction() { TrustedCommitmentTransaction_free(self); }
5077         TrustedCommitmentTransaction& operator=(TrustedCommitmentTransaction&& o) { TrustedCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(TrustedCommitmentTransaction)); return *this; }
5078         LDKTrustedCommitmentTransaction* operator &() { return &self; }
5079         LDKTrustedCommitmentTransaction* operator ->() { return &self; }
5080         const LDKTrustedCommitmentTransaction* operator &() const { return &self; }
5081         const LDKTrustedCommitmentTransaction* operator ->() const { return &self; }
5082 };
5083 class ShutdownScript {
5084 private:
5085         LDKShutdownScript self;
5086 public:
5087         ShutdownScript(const ShutdownScript&) = delete;
5088         ShutdownScript(ShutdownScript&& o) : self(o.self) { memset(&o, 0, sizeof(ShutdownScript)); }
5089         ShutdownScript(LDKShutdownScript&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdownScript)); }
5090         operator LDKShutdownScript() && { LDKShutdownScript res = self; memset(&self, 0, sizeof(LDKShutdownScript)); return res; }
5091         ~ShutdownScript() { ShutdownScript_free(self); }
5092         ShutdownScript& operator=(ShutdownScript&& o) { ShutdownScript_free(self); self = o.self; memset(&o, 0, sizeof(ShutdownScript)); return *this; }
5093         LDKShutdownScript* operator &() { return &self; }
5094         LDKShutdownScript* operator ->() { return &self; }
5095         const LDKShutdownScript* operator &() const { return &self; }
5096         const LDKShutdownScript* operator ->() const { return &self; }
5097 };
5098 class InvalidShutdownScript {
5099 private:
5100         LDKInvalidShutdownScript self;
5101 public:
5102         InvalidShutdownScript(const InvalidShutdownScript&) = delete;
5103         InvalidShutdownScript(InvalidShutdownScript&& o) : self(o.self) { memset(&o, 0, sizeof(InvalidShutdownScript)); }
5104         InvalidShutdownScript(LDKInvalidShutdownScript&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvalidShutdownScript)); }
5105         operator LDKInvalidShutdownScript() && { LDKInvalidShutdownScript res = self; memset(&self, 0, sizeof(LDKInvalidShutdownScript)); return res; }
5106         ~InvalidShutdownScript() { InvalidShutdownScript_free(self); }
5107         InvalidShutdownScript& operator=(InvalidShutdownScript&& o) { InvalidShutdownScript_free(self); self = o.self; memset(&o, 0, sizeof(InvalidShutdownScript)); return *this; }
5108         LDKInvalidShutdownScript* operator &() { return &self; }
5109         LDKInvalidShutdownScript* operator ->() { return &self; }
5110         const LDKInvalidShutdownScript* operator &() const { return &self; }
5111         const LDKInvalidShutdownScript* operator ->() const { return &self; }
5112 };
5113 class Bolt12ParseError {
5114 private:
5115         LDKBolt12ParseError self;
5116 public:
5117         Bolt12ParseError(const Bolt12ParseError&) = delete;
5118         Bolt12ParseError(Bolt12ParseError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12ParseError)); }
5119         Bolt12ParseError(LDKBolt12ParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12ParseError)); }
5120         operator LDKBolt12ParseError() && { LDKBolt12ParseError res = self; memset(&self, 0, sizeof(LDKBolt12ParseError)); return res; }
5121         ~Bolt12ParseError() { Bolt12ParseError_free(self); }
5122         Bolt12ParseError& operator=(Bolt12ParseError&& o) { Bolt12ParseError_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12ParseError)); return *this; }
5123         LDKBolt12ParseError* operator &() { return &self; }
5124         LDKBolt12ParseError* operator ->() { return &self; }
5125         const LDKBolt12ParseError* operator &() const { return &self; }
5126         const LDKBolt12ParseError* operator ->() const { return &self; }
5127 };
5128 class Bolt12SemanticError {
5129 private:
5130         LDKBolt12SemanticError self;
5131 public:
5132         Bolt12SemanticError(const Bolt12SemanticError&) = delete;
5133         Bolt12SemanticError(Bolt12SemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12SemanticError)); }
5134         Bolt12SemanticError(LDKBolt12SemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12SemanticError)); }
5135         operator LDKBolt12SemanticError() && { LDKBolt12SemanticError res = self; memset(&self, 0, sizeof(LDKBolt12SemanticError)); return res; }
5136         Bolt12SemanticError& operator=(Bolt12SemanticError&& o) { self = o.self; memset(&o, 0, sizeof(Bolt12SemanticError)); return *this; }
5137         LDKBolt12SemanticError* operator &() { return &self; }
5138         LDKBolt12SemanticError* operator ->() { return &self; }
5139         const LDKBolt12SemanticError* operator &() const { return &self; }
5140         const LDKBolt12SemanticError* operator ->() const { return &self; }
5141 };
5142 class BroadcasterInterface {
5143 private:
5144         LDKBroadcasterInterface self;
5145 public:
5146         BroadcasterInterface(const BroadcasterInterface&) = delete;
5147         BroadcasterInterface(BroadcasterInterface&& o) : self(o.self) { memset(&o, 0, sizeof(BroadcasterInterface)); }
5148         BroadcasterInterface(LDKBroadcasterInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBroadcasterInterface)); }
5149         operator LDKBroadcasterInterface() && { LDKBroadcasterInterface res = self; memset(&self, 0, sizeof(LDKBroadcasterInterface)); return res; }
5150         ~BroadcasterInterface() { BroadcasterInterface_free(self); }
5151         BroadcasterInterface& operator=(BroadcasterInterface&& o) { BroadcasterInterface_free(self); self = o.self; memset(&o, 0, sizeof(BroadcasterInterface)); return *this; }
5152         LDKBroadcasterInterface* operator &() { return &self; }
5153         LDKBroadcasterInterface* operator ->() { return &self; }
5154         const LDKBroadcasterInterface* operator &() const { return &self; }
5155         const LDKBroadcasterInterface* operator ->() const { return &self; }
5156         /**
5157          *  Sends a list of transactions out to (hopefully) be mined.
5158          *  This only needs to handle the actual broadcasting of transactions, LDK will automatically
5159          *  rebroadcast transactions that haven't made it into a block.
5160          *
5161          *  In some cases LDK may attempt to broadcast a transaction which double-spends another
5162          *  and this isn't a bug and can be safely ignored.
5163          *
5164          *  If more than one transaction is given, these transactions should be considered to be a
5165          *  package and broadcast together. Some of the transactions may or may not depend on each other,
5166          *  be sure to manage both cases correctly.
5167          *
5168          *  Bitcoin transaction packages are defined in BIP 331 and here:
5169          *  <https://github.com/bitcoin/bitcoin/blob/master/doc/policy/packages.md>
5170          */
5171         inline void broadcast_transactions(struct LDKCVec_TransactionZ txs);
5172 };
5173 class ConfirmationTarget {
5174 private:
5175         LDKConfirmationTarget self;
5176 public:
5177         ConfirmationTarget(const ConfirmationTarget&) = delete;
5178         ConfirmationTarget(ConfirmationTarget&& o) : self(o.self) { memset(&o, 0, sizeof(ConfirmationTarget)); }
5179         ConfirmationTarget(LDKConfirmationTarget&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirmationTarget)); }
5180         operator LDKConfirmationTarget() && { LDKConfirmationTarget res = self; memset(&self, 0, sizeof(LDKConfirmationTarget)); return res; }
5181         ConfirmationTarget& operator=(ConfirmationTarget&& o) { self = o.self; memset(&o, 0, sizeof(ConfirmationTarget)); return *this; }
5182         LDKConfirmationTarget* operator &() { return &self; }
5183         LDKConfirmationTarget* operator ->() { return &self; }
5184         const LDKConfirmationTarget* operator &() const { return &self; }
5185         const LDKConfirmationTarget* operator ->() const { return &self; }
5186 };
5187 class FeeEstimator {
5188 private:
5189         LDKFeeEstimator self;
5190 public:
5191         FeeEstimator(const FeeEstimator&) = delete;
5192         FeeEstimator(FeeEstimator&& o) : self(o.self) { memset(&o, 0, sizeof(FeeEstimator)); }
5193         FeeEstimator(LDKFeeEstimator&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFeeEstimator)); }
5194         operator LDKFeeEstimator() && { LDKFeeEstimator res = self; memset(&self, 0, sizeof(LDKFeeEstimator)); return res; }
5195         ~FeeEstimator() { FeeEstimator_free(self); }
5196         FeeEstimator& operator=(FeeEstimator&& o) { FeeEstimator_free(self); self = o.self; memset(&o, 0, sizeof(FeeEstimator)); return *this; }
5197         LDKFeeEstimator* operator &() { return &self; }
5198         LDKFeeEstimator* operator ->() { return &self; }
5199         const LDKFeeEstimator* operator &() const { return &self; }
5200         const LDKFeeEstimator* operator ->() const { return &self; }
5201         /**
5202          *  Gets estimated satoshis of fee required per 1000 Weight-Units.
5203          *
5204          *  LDK will wrap this method and ensure that the value returned is no smaller than 253
5205          *  (ie 1 satoshi-per-byte rounded up to ensure later round-downs don't put us below 1 satoshi-per-byte).
5206          *
5207          *  The following unit conversions can be used to convert to sats/KW:
5208          *   * satoshis-per-byte * 250
5209          *   * satoshis-per-kbyte / 4
5210          */
5211         inline uint32_t get_est_sat_per_1000_weight(enum LDKConfirmationTarget confirmation_target);
5212 };
5213 class Packet {
5214 private:
5215         LDKPacket self;
5216 public:
5217         Packet(const Packet&) = delete;
5218         Packet(Packet&& o) : self(o.self) { memset(&o, 0, sizeof(Packet)); }
5219         Packet(LDKPacket&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPacket)); }
5220         operator LDKPacket() && { LDKPacket res = self; memset(&self, 0, sizeof(LDKPacket)); return res; }
5221         ~Packet() { Packet_free(self); }
5222         Packet& operator=(Packet&& o) { Packet_free(self); self = o.self; memset(&o, 0, sizeof(Packet)); return *this; }
5223         LDKPacket* operator &() { return &self; }
5224         LDKPacket* operator ->() { return &self; }
5225         const LDKPacket* operator &() const { return &self; }
5226         const LDKPacket* operator ->() const { return &self; }
5227 };
5228 class ParsedOnionMessageContents {
5229 private:
5230         LDKParsedOnionMessageContents self;
5231 public:
5232         ParsedOnionMessageContents(const ParsedOnionMessageContents&) = delete;
5233         ParsedOnionMessageContents(ParsedOnionMessageContents&& o) : self(o.self) { memset(&o, 0, sizeof(ParsedOnionMessageContents)); }
5234         ParsedOnionMessageContents(LDKParsedOnionMessageContents&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKParsedOnionMessageContents)); }
5235         operator LDKParsedOnionMessageContents() && { LDKParsedOnionMessageContents res = self; memset(&self, 0, sizeof(LDKParsedOnionMessageContents)); return res; }
5236         ~ParsedOnionMessageContents() { ParsedOnionMessageContents_free(self); }
5237         ParsedOnionMessageContents& operator=(ParsedOnionMessageContents&& o) { ParsedOnionMessageContents_free(self); self = o.self; memset(&o, 0, sizeof(ParsedOnionMessageContents)); return *this; }
5238         LDKParsedOnionMessageContents* operator &() { return &self; }
5239         LDKParsedOnionMessageContents* operator ->() { return &self; }
5240         const LDKParsedOnionMessageContents* operator &() const { return &self; }
5241         const LDKParsedOnionMessageContents* operator ->() const { return &self; }
5242 };
5243 class OnionMessageContents {
5244 private:
5245         LDKOnionMessageContents self;
5246 public:
5247         OnionMessageContents(const OnionMessageContents&) = delete;
5248         OnionMessageContents(OnionMessageContents&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageContents)); }
5249         OnionMessageContents(LDKOnionMessageContents&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageContents)); }
5250         operator LDKOnionMessageContents() && { LDKOnionMessageContents res = self; memset(&self, 0, sizeof(LDKOnionMessageContents)); return res; }
5251         ~OnionMessageContents() { OnionMessageContents_free(self); }
5252         OnionMessageContents& operator=(OnionMessageContents&& o) { OnionMessageContents_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageContents)); return *this; }
5253         LDKOnionMessageContents* operator &() { return &self; }
5254         LDKOnionMessageContents* operator ->() { return &self; }
5255         const LDKOnionMessageContents* operator &() const { return &self; }
5256         const LDKOnionMessageContents* operator ->() const { return &self; }
5257         /**
5258          *  Returns the TLV type identifying the message contents. MUST be >= 64.
5259          */
5260         inline uint64_t tlv_type();
5261         /**
5262          * Return a human-readable "debug" string describing this object
5263          */
5264         inline LDK::Str debug_str();
5265 };
5266 class PaymentPurpose {
5267 private:
5268         LDKPaymentPurpose self;
5269 public:
5270         PaymentPurpose(const PaymentPurpose&) = delete;
5271         PaymentPurpose(PaymentPurpose&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentPurpose)); }
5272         PaymentPurpose(LDKPaymentPurpose&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentPurpose)); }
5273         operator LDKPaymentPurpose() && { LDKPaymentPurpose res = self; memset(&self, 0, sizeof(LDKPaymentPurpose)); return res; }
5274         ~PaymentPurpose() { PaymentPurpose_free(self); }
5275         PaymentPurpose& operator=(PaymentPurpose&& o) { PaymentPurpose_free(self); self = o.self; memset(&o, 0, sizeof(PaymentPurpose)); return *this; }
5276         LDKPaymentPurpose* operator &() { return &self; }
5277         LDKPaymentPurpose* operator ->() { return &self; }
5278         const LDKPaymentPurpose* operator &() const { return &self; }
5279         const LDKPaymentPurpose* operator ->() const { return &self; }
5280 };
5281 class ClaimedHTLC {
5282 private:
5283         LDKClaimedHTLC self;
5284 public:
5285         ClaimedHTLC(const ClaimedHTLC&) = delete;
5286         ClaimedHTLC(ClaimedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(ClaimedHTLC)); }
5287         ClaimedHTLC(LDKClaimedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClaimedHTLC)); }
5288         operator LDKClaimedHTLC() && { LDKClaimedHTLC res = self; memset(&self, 0, sizeof(LDKClaimedHTLC)); return res; }
5289         ~ClaimedHTLC() { ClaimedHTLC_free(self); }
5290         ClaimedHTLC& operator=(ClaimedHTLC&& o) { ClaimedHTLC_free(self); self = o.self; memset(&o, 0, sizeof(ClaimedHTLC)); return *this; }
5291         LDKClaimedHTLC* operator &() { return &self; }
5292         LDKClaimedHTLC* operator ->() { return &self; }
5293         const LDKClaimedHTLC* operator &() const { return &self; }
5294         const LDKClaimedHTLC* operator ->() const { return &self; }
5295 };
5296 class PathFailure {
5297 private:
5298         LDKPathFailure self;
5299 public:
5300         PathFailure(const PathFailure&) = delete;
5301         PathFailure(PathFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PathFailure)); }
5302         PathFailure(LDKPathFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPathFailure)); }
5303         operator LDKPathFailure() && { LDKPathFailure res = self; memset(&self, 0, sizeof(LDKPathFailure)); return res; }
5304         ~PathFailure() { PathFailure_free(self); }
5305         PathFailure& operator=(PathFailure&& o) { PathFailure_free(self); self = o.self; memset(&o, 0, sizeof(PathFailure)); return *this; }
5306         LDKPathFailure* operator &() { return &self; }
5307         LDKPathFailure* operator ->() { return &self; }
5308         const LDKPathFailure* operator &() const { return &self; }
5309         const LDKPathFailure* operator ->() const { return &self; }
5310 };
5311 class ClosureReason {
5312 private:
5313         LDKClosureReason self;
5314 public:
5315         ClosureReason(const ClosureReason&) = delete;
5316         ClosureReason(ClosureReason&& o) : self(o.self) { memset(&o, 0, sizeof(ClosureReason)); }
5317         ClosureReason(LDKClosureReason&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosureReason)); }
5318         operator LDKClosureReason() && { LDKClosureReason res = self; memset(&self, 0, sizeof(LDKClosureReason)); return res; }
5319         ~ClosureReason() { ClosureReason_free(self); }
5320         ClosureReason& operator=(ClosureReason&& o) { ClosureReason_free(self); self = o.self; memset(&o, 0, sizeof(ClosureReason)); return *this; }
5321         LDKClosureReason* operator &() { return &self; }
5322         LDKClosureReason* operator ->() { return &self; }
5323         const LDKClosureReason* operator &() const { return &self; }
5324         const LDKClosureReason* operator ->() const { return &self; }
5325 };
5326 class HTLCDestination {
5327 private:
5328         LDKHTLCDestination self;
5329 public:
5330         HTLCDestination(const HTLCDestination&) = delete;
5331         HTLCDestination(HTLCDestination&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCDestination)); }
5332         HTLCDestination(LDKHTLCDestination&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCDestination)); }
5333         operator LDKHTLCDestination() && { LDKHTLCDestination res = self; memset(&self, 0, sizeof(LDKHTLCDestination)); return res; }
5334         ~HTLCDestination() { HTLCDestination_free(self); }
5335         HTLCDestination& operator=(HTLCDestination&& o) { HTLCDestination_free(self); self = o.self; memset(&o, 0, sizeof(HTLCDestination)); return *this; }
5336         LDKHTLCDestination* operator &() { return &self; }
5337         LDKHTLCDestination* operator ->() { return &self; }
5338         const LDKHTLCDestination* operator &() const { return &self; }
5339         const LDKHTLCDestination* operator ->() const { return &self; }
5340 };
5341 class PaymentFailureReason {
5342 private:
5343         LDKPaymentFailureReason self;
5344 public:
5345         PaymentFailureReason(const PaymentFailureReason&) = delete;
5346         PaymentFailureReason(PaymentFailureReason&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentFailureReason)); }
5347         PaymentFailureReason(LDKPaymentFailureReason&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentFailureReason)); }
5348         operator LDKPaymentFailureReason() && { LDKPaymentFailureReason res = self; memset(&self, 0, sizeof(LDKPaymentFailureReason)); return res; }
5349         PaymentFailureReason& operator=(PaymentFailureReason&& o) { self = o.self; memset(&o, 0, sizeof(PaymentFailureReason)); return *this; }
5350         LDKPaymentFailureReason* operator &() { return &self; }
5351         LDKPaymentFailureReason* operator ->() { return &self; }
5352         const LDKPaymentFailureReason* operator &() const { return &self; }
5353         const LDKPaymentFailureReason* operator ->() const { return &self; }
5354 };
5355 class Event {
5356 private:
5357         LDKEvent self;
5358 public:
5359         Event(const Event&) = delete;
5360         Event(Event&& o) : self(o.self) { memset(&o, 0, sizeof(Event)); }
5361         Event(LDKEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEvent)); }
5362         operator LDKEvent() && { LDKEvent res = self; memset(&self, 0, sizeof(LDKEvent)); return res; }
5363         ~Event() { Event_free(self); }
5364         Event& operator=(Event&& o) { Event_free(self); self = o.self; memset(&o, 0, sizeof(Event)); return *this; }
5365         LDKEvent* operator &() { return &self; }
5366         LDKEvent* operator ->() { return &self; }
5367         const LDKEvent* operator &() const { return &self; }
5368         const LDKEvent* operator ->() const { return &self; }
5369 };
5370 class MessageSendEvent {
5371 private:
5372         LDKMessageSendEvent self;
5373 public:
5374         MessageSendEvent(const MessageSendEvent&) = delete;
5375         MessageSendEvent(MessageSendEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEvent)); }
5376         MessageSendEvent(LDKMessageSendEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEvent)); }
5377         operator LDKMessageSendEvent() && { LDKMessageSendEvent res = self; memset(&self, 0, sizeof(LDKMessageSendEvent)); return res; }
5378         ~MessageSendEvent() { MessageSendEvent_free(self); }
5379         MessageSendEvent& operator=(MessageSendEvent&& o) { MessageSendEvent_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEvent)); return *this; }
5380         LDKMessageSendEvent* operator &() { return &self; }
5381         LDKMessageSendEvent* operator ->() { return &self; }
5382         const LDKMessageSendEvent* operator &() const { return &self; }
5383         const LDKMessageSendEvent* operator ->() const { return &self; }
5384 };
5385 class MessageSendEventsProvider {
5386 private:
5387         LDKMessageSendEventsProvider self;
5388 public:
5389         MessageSendEventsProvider(const MessageSendEventsProvider&) = delete;
5390         MessageSendEventsProvider(MessageSendEventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEventsProvider)); }
5391         MessageSendEventsProvider(LDKMessageSendEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEventsProvider)); }
5392         operator LDKMessageSendEventsProvider() && { LDKMessageSendEventsProvider res = self; memset(&self, 0, sizeof(LDKMessageSendEventsProvider)); return res; }
5393         ~MessageSendEventsProvider() { MessageSendEventsProvider_free(self); }
5394         MessageSendEventsProvider& operator=(MessageSendEventsProvider&& o) { MessageSendEventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEventsProvider)); return *this; }
5395         LDKMessageSendEventsProvider* operator &() { return &self; }
5396         LDKMessageSendEventsProvider* operator ->() { return &self; }
5397         const LDKMessageSendEventsProvider* operator &() const { return &self; }
5398         const LDKMessageSendEventsProvider* operator ->() const { return &self; }
5399         /**
5400          *  Gets the list of pending events which were generated by previous actions, clearing the list
5401          *  in the process.
5402          */
5403         inline LDK::CVec_MessageSendEventZ get_and_clear_pending_msg_events();
5404 };
5405 class EventsProvider {
5406 private:
5407         LDKEventsProvider self;
5408 public:
5409         EventsProvider(const EventsProvider&) = delete;
5410         EventsProvider(EventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(EventsProvider)); }
5411         EventsProvider(LDKEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventsProvider)); }
5412         operator LDKEventsProvider() && { LDKEventsProvider res = self; memset(&self, 0, sizeof(LDKEventsProvider)); return res; }
5413         ~EventsProvider() { EventsProvider_free(self); }
5414         EventsProvider& operator=(EventsProvider&& o) { EventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(EventsProvider)); return *this; }
5415         LDKEventsProvider* operator &() { return &self; }
5416         LDKEventsProvider* operator ->() { return &self; }
5417         const LDKEventsProvider* operator &() const { return &self; }
5418         const LDKEventsProvider* operator ->() const { return &self; }
5419         /**
5420          *  Processes any events generated since the last call using the given event handler.
5421          *
5422          *  See the trait-level documentation for requirements.
5423          */
5424         inline void process_pending_events(struct LDKEventHandler handler);
5425 };
5426 class EventHandler {
5427 private:
5428         LDKEventHandler self;
5429 public:
5430         EventHandler(const EventHandler&) = delete;
5431         EventHandler(EventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(EventHandler)); }
5432         EventHandler(LDKEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventHandler)); }
5433         operator LDKEventHandler() && { LDKEventHandler res = self; memset(&self, 0, sizeof(LDKEventHandler)); return res; }
5434         ~EventHandler() { EventHandler_free(self); }
5435         EventHandler& operator=(EventHandler&& o) { EventHandler_free(self); self = o.self; memset(&o, 0, sizeof(EventHandler)); return *this; }
5436         LDKEventHandler* operator &() { return &self; }
5437         LDKEventHandler* operator ->() { return &self; }
5438         const LDKEventHandler* operator &() const { return &self; }
5439         const LDKEventHandler* operator ->() const { return &self; }
5440         /**
5441          *  Handles the given [`Event`].
5442          *
5443          *  See [`EventsProvider`] for details that must be considered when implementing this method.
5444          */
5445         inline void handle_event(struct LDKEvent event);
5446 };
5447 class Bolt11ParseError {
5448 private:
5449         LDKBolt11ParseError self;
5450 public:
5451         Bolt11ParseError(const Bolt11ParseError&) = delete;
5452         Bolt11ParseError(Bolt11ParseError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11ParseError)); }
5453         Bolt11ParseError(LDKBolt11ParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11ParseError)); }
5454         operator LDKBolt11ParseError() && { LDKBolt11ParseError res = self; memset(&self, 0, sizeof(LDKBolt11ParseError)); return res; }
5455         ~Bolt11ParseError() { Bolt11ParseError_free(self); }
5456         Bolt11ParseError& operator=(Bolt11ParseError&& o) { Bolt11ParseError_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11ParseError)); return *this; }
5457         LDKBolt11ParseError* operator &() { return &self; }
5458         LDKBolt11ParseError* operator ->() { return &self; }
5459         const LDKBolt11ParseError* operator &() const { return &self; }
5460         const LDKBolt11ParseError* operator ->() const { return &self; }
5461 };
5462 class ParseOrSemanticError {
5463 private:
5464         LDKParseOrSemanticError self;
5465 public:
5466         ParseOrSemanticError(const ParseOrSemanticError&) = delete;
5467         ParseOrSemanticError(ParseOrSemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(ParseOrSemanticError)); }
5468         ParseOrSemanticError(LDKParseOrSemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKParseOrSemanticError)); }
5469         operator LDKParseOrSemanticError() && { LDKParseOrSemanticError res = self; memset(&self, 0, sizeof(LDKParseOrSemanticError)); return res; }
5470         ~ParseOrSemanticError() { ParseOrSemanticError_free(self); }
5471         ParseOrSemanticError& operator=(ParseOrSemanticError&& o) { ParseOrSemanticError_free(self); self = o.self; memset(&o, 0, sizeof(ParseOrSemanticError)); return *this; }
5472         LDKParseOrSemanticError* operator &() { return &self; }
5473         LDKParseOrSemanticError* operator ->() { return &self; }
5474         const LDKParseOrSemanticError* operator &() const { return &self; }
5475         const LDKParseOrSemanticError* operator ->() const { return &self; }
5476 };
5477 class Bolt11Invoice {
5478 private:
5479         LDKBolt11Invoice self;
5480 public:
5481         Bolt11Invoice(const Bolt11Invoice&) = delete;
5482         Bolt11Invoice(Bolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11Invoice)); }
5483         Bolt11Invoice(LDKBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11Invoice)); }
5484         operator LDKBolt11Invoice() && { LDKBolt11Invoice res = self; memset(&self, 0, sizeof(LDKBolt11Invoice)); return res; }
5485         ~Bolt11Invoice() { Bolt11Invoice_free(self); }
5486         Bolt11Invoice& operator=(Bolt11Invoice&& o) { Bolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11Invoice)); return *this; }
5487         LDKBolt11Invoice* operator &() { return &self; }
5488         LDKBolt11Invoice* operator ->() { return &self; }
5489         const LDKBolt11Invoice* operator &() const { return &self; }
5490         const LDKBolt11Invoice* operator ->() const { return &self; }
5491 };
5492 class SignedRawBolt11Invoice {
5493 private:
5494         LDKSignedRawBolt11Invoice self;
5495 public:
5496         SignedRawBolt11Invoice(const SignedRawBolt11Invoice&) = delete;
5497         SignedRawBolt11Invoice(SignedRawBolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(SignedRawBolt11Invoice)); }
5498         SignedRawBolt11Invoice(LDKSignedRawBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignedRawBolt11Invoice)); }
5499         operator LDKSignedRawBolt11Invoice() && { LDKSignedRawBolt11Invoice res = self; memset(&self, 0, sizeof(LDKSignedRawBolt11Invoice)); return res; }
5500         ~SignedRawBolt11Invoice() { SignedRawBolt11Invoice_free(self); }
5501         SignedRawBolt11Invoice& operator=(SignedRawBolt11Invoice&& o) { SignedRawBolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(SignedRawBolt11Invoice)); return *this; }
5502         LDKSignedRawBolt11Invoice* operator &() { return &self; }
5503         LDKSignedRawBolt11Invoice* operator ->() { return &self; }
5504         const LDKSignedRawBolt11Invoice* operator &() const { return &self; }
5505         const LDKSignedRawBolt11Invoice* operator ->() const { return &self; }
5506 };
5507 class RawBolt11Invoice {
5508 private:
5509         LDKRawBolt11Invoice self;
5510 public:
5511         RawBolt11Invoice(const RawBolt11Invoice&) = delete;
5512         RawBolt11Invoice(RawBolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(RawBolt11Invoice)); }
5513         RawBolt11Invoice(LDKRawBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawBolt11Invoice)); }
5514         operator LDKRawBolt11Invoice() && { LDKRawBolt11Invoice res = self; memset(&self, 0, sizeof(LDKRawBolt11Invoice)); return res; }
5515         ~RawBolt11Invoice() { RawBolt11Invoice_free(self); }
5516         RawBolt11Invoice& operator=(RawBolt11Invoice&& o) { RawBolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(RawBolt11Invoice)); return *this; }
5517         LDKRawBolt11Invoice* operator &() { return &self; }
5518         LDKRawBolt11Invoice* operator ->() { return &self; }
5519         const LDKRawBolt11Invoice* operator &() const { return &self; }
5520         const LDKRawBolt11Invoice* operator ->() const { return &self; }
5521 };
5522 class RawDataPart {
5523 private:
5524         LDKRawDataPart self;
5525 public:
5526         RawDataPart(const RawDataPart&) = delete;
5527         RawDataPart(RawDataPart&& o) : self(o.self) { memset(&o, 0, sizeof(RawDataPart)); }
5528         RawDataPart(LDKRawDataPart&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawDataPart)); }
5529         operator LDKRawDataPart() && { LDKRawDataPart res = self; memset(&self, 0, sizeof(LDKRawDataPart)); return res; }
5530         ~RawDataPart() { RawDataPart_free(self); }
5531         RawDataPart& operator=(RawDataPart&& o) { RawDataPart_free(self); self = o.self; memset(&o, 0, sizeof(RawDataPart)); return *this; }
5532         LDKRawDataPart* operator &() { return &self; }
5533         LDKRawDataPart* operator ->() { return &self; }
5534         const LDKRawDataPart* operator &() const { return &self; }
5535         const LDKRawDataPart* operator ->() const { return &self; }
5536 };
5537 class PositiveTimestamp {
5538 private:
5539         LDKPositiveTimestamp self;
5540 public:
5541         PositiveTimestamp(const PositiveTimestamp&) = delete;
5542         PositiveTimestamp(PositiveTimestamp&& o) : self(o.self) { memset(&o, 0, sizeof(PositiveTimestamp)); }
5543         PositiveTimestamp(LDKPositiveTimestamp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPositiveTimestamp)); }
5544         operator LDKPositiveTimestamp() && { LDKPositiveTimestamp res = self; memset(&self, 0, sizeof(LDKPositiveTimestamp)); return res; }
5545         ~PositiveTimestamp() { PositiveTimestamp_free(self); }
5546         PositiveTimestamp& operator=(PositiveTimestamp&& o) { PositiveTimestamp_free(self); self = o.self; memset(&o, 0, sizeof(PositiveTimestamp)); return *this; }
5547         LDKPositiveTimestamp* operator &() { return &self; }
5548         LDKPositiveTimestamp* operator ->() { return &self; }
5549         const LDKPositiveTimestamp* operator &() const { return &self; }
5550         const LDKPositiveTimestamp* operator ->() const { return &self; }
5551 };
5552 class SiPrefix {
5553 private:
5554         LDKSiPrefix self;
5555 public:
5556         SiPrefix(const SiPrefix&) = delete;
5557         SiPrefix(SiPrefix&& o) : self(o.self) { memset(&o, 0, sizeof(SiPrefix)); }
5558         SiPrefix(LDKSiPrefix&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSiPrefix)); }
5559         operator LDKSiPrefix() && { LDKSiPrefix res = self; memset(&self, 0, sizeof(LDKSiPrefix)); return res; }
5560         SiPrefix& operator=(SiPrefix&& o) { self = o.self; memset(&o, 0, sizeof(SiPrefix)); return *this; }
5561         LDKSiPrefix* operator &() { return &self; }
5562         LDKSiPrefix* operator ->() { return &self; }
5563         const LDKSiPrefix* operator &() const { return &self; }
5564         const LDKSiPrefix* operator ->() const { return &self; }
5565 };
5566 class Currency {
5567 private:
5568         LDKCurrency self;
5569 public:
5570         Currency(const Currency&) = delete;
5571         Currency(Currency&& o) : self(o.self) { memset(&o, 0, sizeof(Currency)); }
5572         Currency(LDKCurrency&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCurrency)); }
5573         operator LDKCurrency() && { LDKCurrency res = self; memset(&self, 0, sizeof(LDKCurrency)); return res; }
5574         Currency& operator=(Currency&& o) { self = o.self; memset(&o, 0, sizeof(Currency)); return *this; }
5575         LDKCurrency* operator &() { return &self; }
5576         LDKCurrency* operator ->() { return &self; }
5577         const LDKCurrency* operator &() const { return &self; }
5578         const LDKCurrency* operator ->() const { return &self; }
5579 };
5580 class Sha256 {
5581 private:
5582         LDKSha256 self;
5583 public:
5584         Sha256(const Sha256&) = delete;
5585         Sha256(Sha256&& o) : self(o.self) { memset(&o, 0, sizeof(Sha256)); }
5586         Sha256(LDKSha256&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSha256)); }
5587         operator LDKSha256() && { LDKSha256 res = self; memset(&self, 0, sizeof(LDKSha256)); return res; }
5588         ~Sha256() { Sha256_free(self); }
5589         Sha256& operator=(Sha256&& o) { Sha256_free(self); self = o.self; memset(&o, 0, sizeof(Sha256)); return *this; }
5590         LDKSha256* operator &() { return &self; }
5591         LDKSha256* operator ->() { return &self; }
5592         const LDKSha256* operator &() const { return &self; }
5593         const LDKSha256* operator ->() const { return &self; }
5594 };
5595 class Description {
5596 private:
5597         LDKDescription self;
5598 public:
5599         Description(const Description&) = delete;
5600         Description(Description&& o) : self(o.self) { memset(&o, 0, sizeof(Description)); }
5601         Description(LDKDescription&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDescription)); }
5602         operator LDKDescription() && { LDKDescription res = self; memset(&self, 0, sizeof(LDKDescription)); return res; }
5603         ~Description() { Description_free(self); }
5604         Description& operator=(Description&& o) { Description_free(self); self = o.self; memset(&o, 0, sizeof(Description)); return *this; }
5605         LDKDescription* operator &() { return &self; }
5606         LDKDescription* operator ->() { return &self; }
5607         const LDKDescription* operator &() const { return &self; }
5608         const LDKDescription* operator ->() const { return &self; }
5609 };
5610 class PayeePubKey {
5611 private:
5612         LDKPayeePubKey self;
5613 public:
5614         PayeePubKey(const PayeePubKey&) = delete;
5615         PayeePubKey(PayeePubKey&& o) : self(o.self) { memset(&o, 0, sizeof(PayeePubKey)); }
5616         PayeePubKey(LDKPayeePubKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayeePubKey)); }
5617         operator LDKPayeePubKey() && { LDKPayeePubKey res = self; memset(&self, 0, sizeof(LDKPayeePubKey)); return res; }
5618         ~PayeePubKey() { PayeePubKey_free(self); }
5619         PayeePubKey& operator=(PayeePubKey&& o) { PayeePubKey_free(self); self = o.self; memset(&o, 0, sizeof(PayeePubKey)); return *this; }
5620         LDKPayeePubKey* operator &() { return &self; }
5621         LDKPayeePubKey* operator ->() { return &self; }
5622         const LDKPayeePubKey* operator &() const { return &self; }
5623         const LDKPayeePubKey* operator ->() const { return &self; }
5624 };
5625 class ExpiryTime {
5626 private:
5627         LDKExpiryTime self;
5628 public:
5629         ExpiryTime(const ExpiryTime&) = delete;
5630         ExpiryTime(ExpiryTime&& o) : self(o.self) { memset(&o, 0, sizeof(ExpiryTime)); }
5631         ExpiryTime(LDKExpiryTime&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpiryTime)); }
5632         operator LDKExpiryTime() && { LDKExpiryTime res = self; memset(&self, 0, sizeof(LDKExpiryTime)); return res; }
5633         ~ExpiryTime() { ExpiryTime_free(self); }
5634         ExpiryTime& operator=(ExpiryTime&& o) { ExpiryTime_free(self); self = o.self; memset(&o, 0, sizeof(ExpiryTime)); return *this; }
5635         LDKExpiryTime* operator &() { return &self; }
5636         LDKExpiryTime* operator ->() { return &self; }
5637         const LDKExpiryTime* operator &() const { return &self; }
5638         const LDKExpiryTime* operator ->() const { return &self; }
5639 };
5640 class MinFinalCltvExpiryDelta {
5641 private:
5642         LDKMinFinalCltvExpiryDelta self;
5643 public:
5644         MinFinalCltvExpiryDelta(const MinFinalCltvExpiryDelta&) = delete;
5645         MinFinalCltvExpiryDelta(MinFinalCltvExpiryDelta&& o) : self(o.self) { memset(&o, 0, sizeof(MinFinalCltvExpiryDelta)); }
5646         MinFinalCltvExpiryDelta(LDKMinFinalCltvExpiryDelta&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMinFinalCltvExpiryDelta)); }
5647         operator LDKMinFinalCltvExpiryDelta() && { LDKMinFinalCltvExpiryDelta res = self; memset(&self, 0, sizeof(LDKMinFinalCltvExpiryDelta)); return res; }
5648         ~MinFinalCltvExpiryDelta() { MinFinalCltvExpiryDelta_free(self); }
5649         MinFinalCltvExpiryDelta& operator=(MinFinalCltvExpiryDelta&& o) { MinFinalCltvExpiryDelta_free(self); self = o.self; memset(&o, 0, sizeof(MinFinalCltvExpiryDelta)); return *this; }
5650         LDKMinFinalCltvExpiryDelta* operator &() { return &self; }
5651         LDKMinFinalCltvExpiryDelta* operator ->() { return &self; }
5652         const LDKMinFinalCltvExpiryDelta* operator &() const { return &self; }
5653         const LDKMinFinalCltvExpiryDelta* operator ->() const { return &self; }
5654 };
5655 class Fallback {
5656 private:
5657         LDKFallback self;
5658 public:
5659         Fallback(const Fallback&) = delete;
5660         Fallback(Fallback&& o) : self(o.self) { memset(&o, 0, sizeof(Fallback)); }
5661         Fallback(LDKFallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFallback)); }
5662         operator LDKFallback() && { LDKFallback res = self; memset(&self, 0, sizeof(LDKFallback)); return res; }
5663         ~Fallback() { Fallback_free(self); }
5664         Fallback& operator=(Fallback&& o) { Fallback_free(self); self = o.self; memset(&o, 0, sizeof(Fallback)); return *this; }
5665         LDKFallback* operator &() { return &self; }
5666         LDKFallback* operator ->() { return &self; }
5667         const LDKFallback* operator &() const { return &self; }
5668         const LDKFallback* operator ->() const { return &self; }
5669 };
5670 class Bolt11InvoiceSignature {
5671 private:
5672         LDKBolt11InvoiceSignature self;
5673 public:
5674         Bolt11InvoiceSignature(const Bolt11InvoiceSignature&) = delete;
5675         Bolt11InvoiceSignature(Bolt11InvoiceSignature&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11InvoiceSignature)); }
5676         Bolt11InvoiceSignature(LDKBolt11InvoiceSignature&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11InvoiceSignature)); }
5677         operator LDKBolt11InvoiceSignature() && { LDKBolt11InvoiceSignature res = self; memset(&self, 0, sizeof(LDKBolt11InvoiceSignature)); return res; }
5678         ~Bolt11InvoiceSignature() { Bolt11InvoiceSignature_free(self); }
5679         Bolt11InvoiceSignature& operator=(Bolt11InvoiceSignature&& o) { Bolt11InvoiceSignature_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11InvoiceSignature)); return *this; }
5680         LDKBolt11InvoiceSignature* operator &() { return &self; }
5681         LDKBolt11InvoiceSignature* operator ->() { return &self; }
5682         const LDKBolt11InvoiceSignature* operator &() const { return &self; }
5683         const LDKBolt11InvoiceSignature* operator ->() const { return &self; }
5684 };
5685 class PrivateRoute {
5686 private:
5687         LDKPrivateRoute self;
5688 public:
5689         PrivateRoute(const PrivateRoute&) = delete;
5690         PrivateRoute(PrivateRoute&& o) : self(o.self) { memset(&o, 0, sizeof(PrivateRoute)); }
5691         PrivateRoute(LDKPrivateRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrivateRoute)); }
5692         operator LDKPrivateRoute() && { LDKPrivateRoute res = self; memset(&self, 0, sizeof(LDKPrivateRoute)); return res; }
5693         ~PrivateRoute() { PrivateRoute_free(self); }
5694         PrivateRoute& operator=(PrivateRoute&& o) { PrivateRoute_free(self); self = o.self; memset(&o, 0, sizeof(PrivateRoute)); return *this; }
5695         LDKPrivateRoute* operator &() { return &self; }
5696         LDKPrivateRoute* operator ->() { return &self; }
5697         const LDKPrivateRoute* operator &() const { return &self; }
5698         const LDKPrivateRoute* operator ->() const { return &self; }
5699 };
5700 class CreationError {
5701 private:
5702         LDKCreationError self;
5703 public:
5704         CreationError(const CreationError&) = delete;
5705         CreationError(CreationError&& o) : self(o.self) { memset(&o, 0, sizeof(CreationError)); }
5706         CreationError(LDKCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCreationError)); }
5707         operator LDKCreationError() && { LDKCreationError res = self; memset(&self, 0, sizeof(LDKCreationError)); return res; }
5708         CreationError& operator=(CreationError&& o) { self = o.self; memset(&o, 0, sizeof(CreationError)); return *this; }
5709         LDKCreationError* operator &() { return &self; }
5710         LDKCreationError* operator ->() { return &self; }
5711         const LDKCreationError* operator &() const { return &self; }
5712         const LDKCreationError* operator ->() const { return &self; }
5713 };
5714 class Bolt11SemanticError {
5715 private:
5716         LDKBolt11SemanticError self;
5717 public:
5718         Bolt11SemanticError(const Bolt11SemanticError&) = delete;
5719         Bolt11SemanticError(Bolt11SemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11SemanticError)); }
5720         Bolt11SemanticError(LDKBolt11SemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11SemanticError)); }
5721         operator LDKBolt11SemanticError() && { LDKBolt11SemanticError res = self; memset(&self, 0, sizeof(LDKBolt11SemanticError)); return res; }
5722         Bolt11SemanticError& operator=(Bolt11SemanticError&& o) { self = o.self; memset(&o, 0, sizeof(Bolt11SemanticError)); return *this; }
5723         LDKBolt11SemanticError* operator &() { return &self; }
5724         LDKBolt11SemanticError* operator ->() { return &self; }
5725         const LDKBolt11SemanticError* operator &() const { return &self; }
5726         const LDKBolt11SemanticError* operator ->() const { return &self; }
5727 };
5728 class SignOrCreationError {
5729 private:
5730         LDKSignOrCreationError self;
5731 public:
5732         SignOrCreationError(const SignOrCreationError&) = delete;
5733         SignOrCreationError(SignOrCreationError&& o) : self(o.self) { memset(&o, 0, sizeof(SignOrCreationError)); }
5734         SignOrCreationError(LDKSignOrCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignOrCreationError)); }
5735         operator LDKSignOrCreationError() && { LDKSignOrCreationError res = self; memset(&self, 0, sizeof(LDKSignOrCreationError)); return res; }
5736         ~SignOrCreationError() { SignOrCreationError_free(self); }
5737         SignOrCreationError& operator=(SignOrCreationError&& o) { SignOrCreationError_free(self); self = o.self; memset(&o, 0, sizeof(SignOrCreationError)); return *this; }
5738         LDKSignOrCreationError* operator &() { return &self; }
5739         LDKSignOrCreationError* operator ->() { return &self; }
5740         const LDKSignOrCreationError* operator &() const { return &self; }
5741         const LDKSignOrCreationError* operator ->() const { return &self; }
5742 };
5743 class OutPoint {
5744 private:
5745         LDKOutPoint self;
5746 public:
5747         OutPoint(const OutPoint&) = delete;
5748         OutPoint(OutPoint&& o) : self(o.self) { memset(&o, 0, sizeof(OutPoint)); }
5749         OutPoint(LDKOutPoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutPoint)); }
5750         operator LDKOutPoint() && { LDKOutPoint res = self; memset(&self, 0, sizeof(LDKOutPoint)); return res; }
5751         ~OutPoint() { OutPoint_free(self); }
5752         OutPoint& operator=(OutPoint&& o) { OutPoint_free(self); self = o.self; memset(&o, 0, sizeof(OutPoint)); return *this; }
5753         LDKOutPoint* operator &() { return &self; }
5754         LDKOutPoint* operator ->() { return &self; }
5755         const LDKOutPoint* operator &() const { return &self; }
5756         const LDKOutPoint* operator ->() const { return &self; }
5757 };
5758 class BigSize {
5759 private:
5760         LDKBigSize self;
5761 public:
5762         BigSize(const BigSize&) = delete;
5763         BigSize(BigSize&& o) : self(o.self) { memset(&o, 0, sizeof(BigSize)); }
5764         BigSize(LDKBigSize&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBigSize)); }
5765         operator LDKBigSize() && { LDKBigSize res = self; memset(&self, 0, sizeof(LDKBigSize)); return res; }
5766         ~BigSize() { BigSize_free(self); }
5767         BigSize& operator=(BigSize&& o) { BigSize_free(self); self = o.self; memset(&o, 0, sizeof(BigSize)); return *this; }
5768         LDKBigSize* operator &() { return &self; }
5769         LDKBigSize* operator ->() { return &self; }
5770         const LDKBigSize* operator &() const { return &self; }
5771         const LDKBigSize* operator ->() const { return &self; }
5772 };
5773 class Hostname {
5774 private:
5775         LDKHostname self;
5776 public:
5777         Hostname(const Hostname&) = delete;
5778         Hostname(Hostname&& o) : self(o.self) { memset(&o, 0, sizeof(Hostname)); }
5779         Hostname(LDKHostname&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHostname)); }
5780         operator LDKHostname() && { LDKHostname res = self; memset(&self, 0, sizeof(LDKHostname)); return res; }
5781         ~Hostname() { Hostname_free(self); }
5782         Hostname& operator=(Hostname&& o) { Hostname_free(self); self = o.self; memset(&o, 0, sizeof(Hostname)); return *this; }
5783         LDKHostname* operator &() { return &self; }
5784         LDKHostname* operator ->() { return &self; }
5785         const LDKHostname* operator &() const { return &self; }
5786         const LDKHostname* operator ->() const { return &self; }
5787 };
5788 class TransactionU16LenLimited {
5789 private:
5790         LDKTransactionU16LenLimited self;
5791 public:
5792         TransactionU16LenLimited(const TransactionU16LenLimited&) = delete;
5793         TransactionU16LenLimited(TransactionU16LenLimited&& o) : self(o.self) { memset(&o, 0, sizeof(TransactionU16LenLimited)); }
5794         TransactionU16LenLimited(LDKTransactionU16LenLimited&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTransactionU16LenLimited)); }
5795         operator LDKTransactionU16LenLimited() && { LDKTransactionU16LenLimited res = self; memset(&self, 0, sizeof(LDKTransactionU16LenLimited)); return res; }
5796         ~TransactionU16LenLimited() { TransactionU16LenLimited_free(self); }
5797         TransactionU16LenLimited& operator=(TransactionU16LenLimited&& o) { TransactionU16LenLimited_free(self); self = o.self; memset(&o, 0, sizeof(TransactionU16LenLimited)); return *this; }
5798         LDKTransactionU16LenLimited* operator &() { return &self; }
5799         LDKTransactionU16LenLimited* operator ->() { return &self; }
5800         const LDKTransactionU16LenLimited* operator &() const { return &self; }
5801         const LDKTransactionU16LenLimited* operator ->() const { return &self; }
5802 };
5803 class UntrustedString {
5804 private:
5805         LDKUntrustedString self;
5806 public:
5807         UntrustedString(const UntrustedString&) = delete;
5808         UntrustedString(UntrustedString&& o) : self(o.self) { memset(&o, 0, sizeof(UntrustedString)); }
5809         UntrustedString(LDKUntrustedString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUntrustedString)); }
5810         operator LDKUntrustedString() && { LDKUntrustedString res = self; memset(&self, 0, sizeof(LDKUntrustedString)); return res; }
5811         ~UntrustedString() { UntrustedString_free(self); }
5812         UntrustedString& operator=(UntrustedString&& o) { UntrustedString_free(self); self = o.self; memset(&o, 0, sizeof(UntrustedString)); return *this; }
5813         LDKUntrustedString* operator &() { return &self; }
5814         LDKUntrustedString* operator ->() { return &self; }
5815         const LDKUntrustedString* operator &() const { return &self; }
5816         const LDKUntrustedString* operator ->() const { return &self; }
5817 };
5818 class PrintableString {
5819 private:
5820         LDKPrintableString self;
5821 public:
5822         PrintableString(const PrintableString&) = delete;
5823         PrintableString(PrintableString&& o) : self(o.self) { memset(&o, 0, sizeof(PrintableString)); }
5824         PrintableString(LDKPrintableString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrintableString)); }
5825         operator LDKPrintableString() && { LDKPrintableString res = self; memset(&self, 0, sizeof(LDKPrintableString)); return res; }
5826         ~PrintableString() { PrintableString_free(self); }
5827         PrintableString& operator=(PrintableString&& o) { PrintableString_free(self); self = o.self; memset(&o, 0, sizeof(PrintableString)); return *this; }
5828         LDKPrintableString* operator &() { return &self; }
5829         LDKPrintableString* operator ->() { return &self; }
5830         const LDKPrintableString* operator &() const { return &self; }
5831         const LDKPrintableString* operator ->() const { return &self; }
5832 };
5833 class CustomMessageReader {
5834 private:
5835         LDKCustomMessageReader self;
5836 public:
5837         CustomMessageReader(const CustomMessageReader&) = delete;
5838         CustomMessageReader(CustomMessageReader&& o) : self(o.self) { memset(&o, 0, sizeof(CustomMessageReader)); }
5839         CustomMessageReader(LDKCustomMessageReader&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomMessageReader)); }
5840         operator LDKCustomMessageReader() && { LDKCustomMessageReader res = self; memset(&self, 0, sizeof(LDKCustomMessageReader)); return res; }
5841         ~CustomMessageReader() { CustomMessageReader_free(self); }
5842         CustomMessageReader& operator=(CustomMessageReader&& o) { CustomMessageReader_free(self); self = o.self; memset(&o, 0, sizeof(CustomMessageReader)); return *this; }
5843         LDKCustomMessageReader* operator &() { return &self; }
5844         LDKCustomMessageReader* operator ->() { return &self; }
5845         const LDKCustomMessageReader* operator &() const { return &self; }
5846         const LDKCustomMessageReader* operator ->() const { return &self; }
5847         /**
5848          *  Decodes a custom message to `CustomMessageType`. If the given message type is known to the
5849          *  implementation and the message could be decoded, must return `Ok(Some(message))`. If the
5850          *  message type is unknown to the implementation, must return `Ok(None)`. If a decoding error
5851          *  occur, must return `Err(DecodeError::X)` where `X` details the encountered error.
5852          */
5853         inline LDK::CResult_COption_TypeZDecodeErrorZ read(uint16_t message_type, struct LDKu8slice buffer);
5854 };
5855 class Type {
5856 private:
5857         LDKType self;
5858 public:
5859         Type(const Type&) = delete;
5860         Type(Type&& o) : self(o.self) { memset(&o, 0, sizeof(Type)); }
5861         Type(LDKType&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKType)); }
5862         operator LDKType() && { LDKType res = self; memset(&self, 0, sizeof(LDKType)); return res; }
5863         ~Type() { Type_free(self); }
5864         Type& operator=(Type&& o) { Type_free(self); self = o.self; memset(&o, 0, sizeof(Type)); return *this; }
5865         LDKType* operator &() { return &self; }
5866         LDKType* operator ->() { return &self; }
5867         const LDKType* operator &() const { return &self; }
5868         const LDKType* operator ->() const { return &self; }
5869         /**
5870          *  Returns the type identifying the message payload.
5871          */
5872         inline uint16_t type_id();
5873         /**
5874          * Return a human-readable "debug" string describing this object
5875          */
5876         inline LDK::Str debug_str();
5877 };
5878 class ForwardNode {
5879 private:
5880         LDKForwardNode self;
5881 public:
5882         ForwardNode(const ForwardNode&) = delete;
5883         ForwardNode(ForwardNode&& o) : self(o.self) { memset(&o, 0, sizeof(ForwardNode)); }
5884         ForwardNode(LDKForwardNode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKForwardNode)); }
5885         operator LDKForwardNode() && { LDKForwardNode res = self; memset(&self, 0, sizeof(LDKForwardNode)); return res; }
5886         ~ForwardNode() { ForwardNode_free(self); }
5887         ForwardNode& operator=(ForwardNode&& o) { ForwardNode_free(self); self = o.self; memset(&o, 0, sizeof(ForwardNode)); return *this; }
5888         LDKForwardNode* operator &() { return &self; }
5889         LDKForwardNode* operator ->() { return &self; }
5890         const LDKForwardNode* operator &() const { return &self; }
5891         const LDKForwardNode* operator ->() const { return &self; }
5892 };
5893 class ForwardTlvs {
5894 private:
5895         LDKForwardTlvs self;
5896 public:
5897         ForwardTlvs(const ForwardTlvs&) = delete;
5898         ForwardTlvs(ForwardTlvs&& o) : self(o.self) { memset(&o, 0, sizeof(ForwardTlvs)); }
5899         ForwardTlvs(LDKForwardTlvs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKForwardTlvs)); }
5900         operator LDKForwardTlvs() && { LDKForwardTlvs res = self; memset(&self, 0, sizeof(LDKForwardTlvs)); return res; }
5901         ~ForwardTlvs() { ForwardTlvs_free(self); }
5902         ForwardTlvs& operator=(ForwardTlvs&& o) { ForwardTlvs_free(self); self = o.self; memset(&o, 0, sizeof(ForwardTlvs)); return *this; }
5903         LDKForwardTlvs* operator &() { return &self; }
5904         LDKForwardTlvs* operator ->() { return &self; }
5905         const LDKForwardTlvs* operator &() const { return &self; }
5906         const LDKForwardTlvs* operator ->() const { return &self; }
5907 };
5908 class ReceiveTlvs {
5909 private:
5910         LDKReceiveTlvs self;
5911 public:
5912         ReceiveTlvs(const ReceiveTlvs&) = delete;
5913         ReceiveTlvs(ReceiveTlvs&& o) : self(o.self) { memset(&o, 0, sizeof(ReceiveTlvs)); }
5914         ReceiveTlvs(LDKReceiveTlvs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReceiveTlvs)); }
5915         operator LDKReceiveTlvs() && { LDKReceiveTlvs res = self; memset(&self, 0, sizeof(LDKReceiveTlvs)); return res; }
5916         ~ReceiveTlvs() { ReceiveTlvs_free(self); }
5917         ReceiveTlvs& operator=(ReceiveTlvs&& o) { ReceiveTlvs_free(self); self = o.self; memset(&o, 0, sizeof(ReceiveTlvs)); return *this; }
5918         LDKReceiveTlvs* operator &() { return &self; }
5919         LDKReceiveTlvs* operator ->() { return &self; }
5920         const LDKReceiveTlvs* operator &() const { return &self; }
5921         const LDKReceiveTlvs* operator ->() const { return &self; }
5922 };
5923 class PaymentRelay {
5924 private:
5925         LDKPaymentRelay self;
5926 public:
5927         PaymentRelay(const PaymentRelay&) = delete;
5928         PaymentRelay(PaymentRelay&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentRelay)); }
5929         PaymentRelay(LDKPaymentRelay&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentRelay)); }
5930         operator LDKPaymentRelay() && { LDKPaymentRelay res = self; memset(&self, 0, sizeof(LDKPaymentRelay)); return res; }
5931         ~PaymentRelay() { PaymentRelay_free(self); }
5932         PaymentRelay& operator=(PaymentRelay&& o) { PaymentRelay_free(self); self = o.self; memset(&o, 0, sizeof(PaymentRelay)); return *this; }
5933         LDKPaymentRelay* operator &() { return &self; }
5934         LDKPaymentRelay* operator ->() { return &self; }
5935         const LDKPaymentRelay* operator &() const { return &self; }
5936         const LDKPaymentRelay* operator ->() const { return &self; }
5937 };
5938 class PaymentConstraints {
5939 private:
5940         LDKPaymentConstraints self;
5941 public:
5942         PaymentConstraints(const PaymentConstraints&) = delete;
5943         PaymentConstraints(PaymentConstraints&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentConstraints)); }
5944         PaymentConstraints(LDKPaymentConstraints&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentConstraints)); }
5945         operator LDKPaymentConstraints() && { LDKPaymentConstraints res = self; memset(&self, 0, sizeof(LDKPaymentConstraints)); return res; }
5946         ~PaymentConstraints() { PaymentConstraints_free(self); }
5947         PaymentConstraints& operator=(PaymentConstraints&& o) { PaymentConstraints_free(self); self = o.self; memset(&o, 0, sizeof(PaymentConstraints)); return *this; }
5948         LDKPaymentConstraints* operator &() { return &self; }
5949         LDKPaymentConstraints* operator ->() { return &self; }
5950         const LDKPaymentConstraints* operator &() const { return &self; }
5951         const LDKPaymentConstraints* operator ->() const { return &self; }
5952 };
5953 class UtxoLookupError {
5954 private:
5955         LDKUtxoLookupError self;
5956 public:
5957         UtxoLookupError(const UtxoLookupError&) = delete;
5958         UtxoLookupError(UtxoLookupError&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoLookupError)); }
5959         UtxoLookupError(LDKUtxoLookupError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoLookupError)); }
5960         operator LDKUtxoLookupError() && { LDKUtxoLookupError res = self; memset(&self, 0, sizeof(LDKUtxoLookupError)); return res; }
5961         UtxoLookupError& operator=(UtxoLookupError&& o) { self = o.self; memset(&o, 0, sizeof(UtxoLookupError)); return *this; }
5962         LDKUtxoLookupError* operator &() { return &self; }
5963         LDKUtxoLookupError* operator ->() { return &self; }
5964         const LDKUtxoLookupError* operator &() const { return &self; }
5965         const LDKUtxoLookupError* operator ->() const { return &self; }
5966 };
5967 class UtxoResult {
5968 private:
5969         LDKUtxoResult self;
5970 public:
5971         UtxoResult(const UtxoResult&) = delete;
5972         UtxoResult(UtxoResult&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoResult)); }
5973         UtxoResult(LDKUtxoResult&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoResult)); }
5974         operator LDKUtxoResult() && { LDKUtxoResult res = self; memset(&self, 0, sizeof(LDKUtxoResult)); return res; }
5975         ~UtxoResult() { UtxoResult_free(self); }
5976         UtxoResult& operator=(UtxoResult&& o) { UtxoResult_free(self); self = o.self; memset(&o, 0, sizeof(UtxoResult)); return *this; }
5977         LDKUtxoResult* operator &() { return &self; }
5978         LDKUtxoResult* operator ->() { return &self; }
5979         const LDKUtxoResult* operator &() const { return &self; }
5980         const LDKUtxoResult* operator ->() const { return &self; }
5981 };
5982 class UtxoLookup {
5983 private:
5984         LDKUtxoLookup self;
5985 public:
5986         UtxoLookup(const UtxoLookup&) = delete;
5987         UtxoLookup(UtxoLookup&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoLookup)); }
5988         UtxoLookup(LDKUtxoLookup&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoLookup)); }
5989         operator LDKUtxoLookup() && { LDKUtxoLookup res = self; memset(&self, 0, sizeof(LDKUtxoLookup)); return res; }
5990         ~UtxoLookup() { UtxoLookup_free(self); }
5991         UtxoLookup& operator=(UtxoLookup&& o) { UtxoLookup_free(self); self = o.self; memset(&o, 0, sizeof(UtxoLookup)); return *this; }
5992         LDKUtxoLookup* operator &() { return &self; }
5993         LDKUtxoLookup* operator ->() { return &self; }
5994         const LDKUtxoLookup* operator &() const { return &self; }
5995         const LDKUtxoLookup* operator ->() const { return &self; }
5996         /**
5997          *  Returns the transaction output of a funding transaction encoded by [`short_channel_id`].
5998          *  Returns an error if `chain_hash` is for a different chain or if such a transaction output is
5999          *  unknown.
6000          *
6001          *  [`short_channel_id`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#definition-of-short_channel_id
6002          */
6003         inline LDK::UtxoResult get_utxo(const uint8_t (*chain_hash)[32], uint64_t short_channel_id);
6004 };
6005 class UtxoFuture {
6006 private:
6007         LDKUtxoFuture self;
6008 public:
6009         UtxoFuture(const UtxoFuture&) = delete;
6010         UtxoFuture(UtxoFuture&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoFuture)); }
6011         UtxoFuture(LDKUtxoFuture&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoFuture)); }
6012         operator LDKUtxoFuture() && { LDKUtxoFuture res = self; memset(&self, 0, sizeof(LDKUtxoFuture)); return res; }
6013         ~UtxoFuture() { UtxoFuture_free(self); }
6014         UtxoFuture& operator=(UtxoFuture&& o) { UtxoFuture_free(self); self = o.self; memset(&o, 0, sizeof(UtxoFuture)); return *this; }
6015         LDKUtxoFuture* operator &() { return &self; }
6016         LDKUtxoFuture* operator ->() { return &self; }
6017         const LDKUtxoFuture* operator &() const { return &self; }
6018         const LDKUtxoFuture* operator ->() const { return &self; }
6019 };
6020 class OnionMessenger {
6021 private:
6022         LDKOnionMessenger self;
6023 public:
6024         OnionMessenger(const OnionMessenger&) = delete;
6025         OnionMessenger(OnionMessenger&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessenger)); }
6026         OnionMessenger(LDKOnionMessenger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessenger)); }
6027         operator LDKOnionMessenger() && { LDKOnionMessenger res = self; memset(&self, 0, sizeof(LDKOnionMessenger)); return res; }
6028         ~OnionMessenger() { OnionMessenger_free(self); }
6029         OnionMessenger& operator=(OnionMessenger&& o) { OnionMessenger_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessenger)); return *this; }
6030         LDKOnionMessenger* operator &() { return &self; }
6031         LDKOnionMessenger* operator ->() { return &self; }
6032         const LDKOnionMessenger* operator &() const { return &self; }
6033         const LDKOnionMessenger* operator ->() const { return &self; }
6034 };
6035 class MessageRouter {
6036 private:
6037         LDKMessageRouter self;
6038 public:
6039         MessageRouter(const MessageRouter&) = delete;
6040         MessageRouter(MessageRouter&& o) : self(o.self) { memset(&o, 0, sizeof(MessageRouter)); }
6041         MessageRouter(LDKMessageRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageRouter)); }
6042         operator LDKMessageRouter() && { LDKMessageRouter res = self; memset(&self, 0, sizeof(LDKMessageRouter)); return res; }
6043         ~MessageRouter() { MessageRouter_free(self); }
6044         MessageRouter& operator=(MessageRouter&& o) { MessageRouter_free(self); self = o.self; memset(&o, 0, sizeof(MessageRouter)); return *this; }
6045         LDKMessageRouter* operator &() { return &self; }
6046         LDKMessageRouter* operator ->() { return &self; }
6047         const LDKMessageRouter* operator &() const { return &self; }
6048         const LDKMessageRouter* operator ->() const { return &self; }
6049         /**
6050          *  Returns a route for sending an [`OnionMessage`] to the given [`Destination`].
6051          */
6052         inline LDK::CResult_OnionMessagePathNoneZ find_path(struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination);
6053         /**
6054          *  Creates [`BlindedPath`]s to the `recipient` node. The nodes in `peers` are assumed to be
6055          *  direct peers with the `recipient`.
6056          */
6057         inline LDK::CResult_CVec_BlindedPathZNoneZ create_blinded_paths(struct LDKPublicKey recipient, struct LDKCVec_PublicKeyZ peers);
6058 };
6059 class DefaultMessageRouter {
6060 private:
6061         LDKDefaultMessageRouter self;
6062 public:
6063         DefaultMessageRouter(const DefaultMessageRouter&) = delete;
6064         DefaultMessageRouter(DefaultMessageRouter&& o) : self(o.self) { memset(&o, 0, sizeof(DefaultMessageRouter)); }
6065         DefaultMessageRouter(LDKDefaultMessageRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDefaultMessageRouter)); }
6066         operator LDKDefaultMessageRouter() && { LDKDefaultMessageRouter res = self; memset(&self, 0, sizeof(LDKDefaultMessageRouter)); return res; }
6067         ~DefaultMessageRouter() { DefaultMessageRouter_free(self); }
6068         DefaultMessageRouter& operator=(DefaultMessageRouter&& o) { DefaultMessageRouter_free(self); self = o.self; memset(&o, 0, sizeof(DefaultMessageRouter)); return *this; }
6069         LDKDefaultMessageRouter* operator &() { return &self; }
6070         LDKDefaultMessageRouter* operator ->() { return &self; }
6071         const LDKDefaultMessageRouter* operator &() const { return &self; }
6072         const LDKDefaultMessageRouter* operator ->() const { return &self; }
6073 };
6074 class OnionMessagePath {
6075 private:
6076         LDKOnionMessagePath self;
6077 public:
6078         OnionMessagePath(const OnionMessagePath&) = delete;
6079         OnionMessagePath(OnionMessagePath&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessagePath)); }
6080         OnionMessagePath(LDKOnionMessagePath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessagePath)); }
6081         operator LDKOnionMessagePath() && { LDKOnionMessagePath res = self; memset(&self, 0, sizeof(LDKOnionMessagePath)); return res; }
6082         ~OnionMessagePath() { OnionMessagePath_free(self); }
6083         OnionMessagePath& operator=(OnionMessagePath&& o) { OnionMessagePath_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessagePath)); return *this; }
6084         LDKOnionMessagePath* operator &() { return &self; }
6085         LDKOnionMessagePath* operator ->() { return &self; }
6086         const LDKOnionMessagePath* operator &() const { return &self; }
6087         const LDKOnionMessagePath* operator ->() const { return &self; }
6088 };
6089 class Destination {
6090 private:
6091         LDKDestination self;
6092 public:
6093         Destination(const Destination&) = delete;
6094         Destination(Destination&& o) : self(o.self) { memset(&o, 0, sizeof(Destination)); }
6095         Destination(LDKDestination&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDestination)); }
6096         operator LDKDestination() && { LDKDestination res = self; memset(&self, 0, sizeof(LDKDestination)); return res; }
6097         ~Destination() { Destination_free(self); }
6098         Destination& operator=(Destination&& o) { Destination_free(self); self = o.self; memset(&o, 0, sizeof(Destination)); return *this; }
6099         LDKDestination* operator &() { return &self; }
6100         LDKDestination* operator ->() { return &self; }
6101         const LDKDestination* operator &() const { return &self; }
6102         const LDKDestination* operator ->() const { return &self; }
6103 };
6104 class SendSuccess {
6105 private:
6106         LDKSendSuccess self;
6107 public:
6108         SendSuccess(const SendSuccess&) = delete;
6109         SendSuccess(SendSuccess&& o) : self(o.self) { memset(&o, 0, sizeof(SendSuccess)); }
6110         SendSuccess(LDKSendSuccess&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSendSuccess)); }
6111         operator LDKSendSuccess() && { LDKSendSuccess res = self; memset(&self, 0, sizeof(LDKSendSuccess)); return res; }
6112         ~SendSuccess() { SendSuccess_free(self); }
6113         SendSuccess& operator=(SendSuccess&& o) { SendSuccess_free(self); self = o.self; memset(&o, 0, sizeof(SendSuccess)); return *this; }
6114         LDKSendSuccess* operator &() { return &self; }
6115         LDKSendSuccess* operator ->() { return &self; }
6116         const LDKSendSuccess* operator &() const { return &self; }
6117         const LDKSendSuccess* operator ->() const { return &self; }
6118 };
6119 class SendError {
6120 private:
6121         LDKSendError self;
6122 public:
6123         SendError(const SendError&) = delete;
6124         SendError(SendError&& o) : self(o.self) { memset(&o, 0, sizeof(SendError)); }
6125         SendError(LDKSendError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSendError)); }
6126         operator LDKSendError() && { LDKSendError res = self; memset(&self, 0, sizeof(LDKSendError)); return res; }
6127         ~SendError() { SendError_free(self); }
6128         SendError& operator=(SendError&& o) { SendError_free(self); self = o.self; memset(&o, 0, sizeof(SendError)); return *this; }
6129         LDKSendError* operator &() { return &self; }
6130         LDKSendError* operator ->() { return &self; }
6131         const LDKSendError* operator &() const { return &self; }
6132         const LDKSendError* operator ->() const { return &self; }
6133 };
6134 class CustomOnionMessageHandler {
6135 private:
6136         LDKCustomOnionMessageHandler self;
6137 public:
6138         CustomOnionMessageHandler(const CustomOnionMessageHandler&) = delete;
6139         CustomOnionMessageHandler(CustomOnionMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(CustomOnionMessageHandler)); }
6140         CustomOnionMessageHandler(LDKCustomOnionMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomOnionMessageHandler)); }
6141         operator LDKCustomOnionMessageHandler() && { LDKCustomOnionMessageHandler res = self; memset(&self, 0, sizeof(LDKCustomOnionMessageHandler)); return res; }
6142         ~CustomOnionMessageHandler() { CustomOnionMessageHandler_free(self); }
6143         CustomOnionMessageHandler& operator=(CustomOnionMessageHandler&& o) { CustomOnionMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(CustomOnionMessageHandler)); return *this; }
6144         LDKCustomOnionMessageHandler* operator &() { return &self; }
6145         LDKCustomOnionMessageHandler* operator ->() { return &self; }
6146         const LDKCustomOnionMessageHandler* operator &() const { return &self; }
6147         const LDKCustomOnionMessageHandler* operator ->() const { return &self; }
6148         /**
6149          *  Called with the custom message that was received, returning a response to send, if any.
6150          *
6151          *  The returned [`Self::CustomMessage`], if any, is enqueued to be sent by [`OnionMessenger`].
6152          */
6153         inline LDK::COption_OnionMessageContentsZ handle_custom_message(struct LDKOnionMessageContents msg);
6154         /**
6155          *  Read a custom message of type `message_type` from `buffer`, returning `Ok(None)` if the
6156          *  message type is unknown.
6157          */
6158         inline LDK::CResult_COption_OnionMessageContentsZDecodeErrorZ read_custom_message(uint64_t message_type, struct LDKu8slice buffer);
6159         /**
6160          *  Releases any [`Self::CustomMessage`]s that need to be sent.
6161          *
6162          *  Typically, this is used for messages initiating a message flow rather than in response to
6163          *  another message. The latter should use the return value of [`Self::handle_custom_message`].
6164          */
6165         inline LDK::CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ release_pending_custom_messages();
6166 };
6167 class PeeledOnion {
6168 private:
6169         LDKPeeledOnion self;
6170 public:
6171         PeeledOnion(const PeeledOnion&) = delete;
6172         PeeledOnion(PeeledOnion&& o) : self(o.self) { memset(&o, 0, sizeof(PeeledOnion)); }
6173         PeeledOnion(LDKPeeledOnion&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeeledOnion)); }
6174         operator LDKPeeledOnion() && { LDKPeeledOnion res = self; memset(&self, 0, sizeof(LDKPeeledOnion)); return res; }
6175         ~PeeledOnion() { PeeledOnion_free(self); }
6176         PeeledOnion& operator=(PeeledOnion&& o) { PeeledOnion_free(self); self = o.self; memset(&o, 0, sizeof(PeeledOnion)); return *this; }
6177         LDKPeeledOnion* operator &() { return &self; }
6178         LDKPeeledOnion* operator ->() { return &self; }
6179         const LDKPeeledOnion* operator &() const { return &self; }
6180         const LDKPeeledOnion* operator ->() const { return &self; }
6181 };
6182 class FilesystemStore {
6183 private:
6184         LDKFilesystemStore self;
6185 public:
6186         FilesystemStore(const FilesystemStore&) = delete;
6187         FilesystemStore(FilesystemStore&& o) : self(o.self) { memset(&o, 0, sizeof(FilesystemStore)); }
6188         FilesystemStore(LDKFilesystemStore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilesystemStore)); }
6189         operator LDKFilesystemStore() && { LDKFilesystemStore res = self; memset(&self, 0, sizeof(LDKFilesystemStore)); return res; }
6190         ~FilesystemStore() { FilesystemStore_free(self); }
6191         FilesystemStore& operator=(FilesystemStore&& o) { FilesystemStore_free(self); self = o.self; memset(&o, 0, sizeof(FilesystemStore)); return *this; }
6192         LDKFilesystemStore* operator &() { return &self; }
6193         LDKFilesystemStore* operator ->() { return &self; }
6194         const LDKFilesystemStore* operator &() const { return &self; }
6195         const LDKFilesystemStore* operator ->() const { return &self; }
6196 };
6197 class BlindedPath {
6198 private:
6199         LDKBlindedPath self;
6200 public:
6201         BlindedPath(const BlindedPath&) = delete;
6202         BlindedPath(BlindedPath&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPath)); }
6203         BlindedPath(LDKBlindedPath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPath)); }
6204         operator LDKBlindedPath() && { LDKBlindedPath res = self; memset(&self, 0, sizeof(LDKBlindedPath)); return res; }
6205         ~BlindedPath() { BlindedPath_free(self); }
6206         BlindedPath& operator=(BlindedPath&& o) { BlindedPath_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPath)); return *this; }
6207         LDKBlindedPath* operator &() { return &self; }
6208         LDKBlindedPath* operator ->() { return &self; }
6209         const LDKBlindedPath* operator &() const { return &self; }
6210         const LDKBlindedPath* operator ->() const { return &self; }
6211 };
6212 class BlindedHop {
6213 private:
6214         LDKBlindedHop self;
6215 public:
6216         BlindedHop(const BlindedHop&) = delete;
6217         BlindedHop(BlindedHop&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedHop)); }
6218         BlindedHop(LDKBlindedHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedHop)); }
6219         operator LDKBlindedHop() && { LDKBlindedHop res = self; memset(&self, 0, sizeof(LDKBlindedHop)); return res; }
6220         ~BlindedHop() { BlindedHop_free(self); }
6221         BlindedHop& operator=(BlindedHop&& o) { BlindedHop_free(self); self = o.self; memset(&o, 0, sizeof(BlindedHop)); return *this; }
6222         LDKBlindedHop* operator &() { return &self; }
6223         LDKBlindedHop* operator ->() { return &self; }
6224         const LDKBlindedHop* operator &() const { return &self; }
6225         const LDKBlindedHop* operator ->() const { return &self; }
6226 };
6227 class InvoiceError {
6228 private:
6229         LDKInvoiceError self;
6230 public:
6231         InvoiceError(const InvoiceError&) = delete;
6232         InvoiceError(InvoiceError&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceError)); }
6233         InvoiceError(LDKInvoiceError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceError)); }
6234         operator LDKInvoiceError() && { LDKInvoiceError res = self; memset(&self, 0, sizeof(LDKInvoiceError)); return res; }
6235         ~InvoiceError() { InvoiceError_free(self); }
6236         InvoiceError& operator=(InvoiceError&& o) { InvoiceError_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceError)); return *this; }
6237         LDKInvoiceError* operator &() { return &self; }
6238         LDKInvoiceError* operator ->() { return &self; }
6239         const LDKInvoiceError* operator &() const { return &self; }
6240         const LDKInvoiceError* operator ->() const { return &self; }
6241 };
6242 class ErroneousField {
6243 private:
6244         LDKErroneousField self;
6245 public:
6246         ErroneousField(const ErroneousField&) = delete;
6247         ErroneousField(ErroneousField&& o) : self(o.self) { memset(&o, 0, sizeof(ErroneousField)); }
6248         ErroneousField(LDKErroneousField&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroneousField)); }
6249         operator LDKErroneousField() && { LDKErroneousField res = self; memset(&self, 0, sizeof(LDKErroneousField)); return res; }
6250         ~ErroneousField() { ErroneousField_free(self); }
6251         ErroneousField& operator=(ErroneousField&& o) { ErroneousField_free(self); self = o.self; memset(&o, 0, sizeof(ErroneousField)); return *this; }
6252         LDKErroneousField* operator &() { return &self; }
6253         LDKErroneousField* operator ->() { return &self; }
6254         const LDKErroneousField* operator &() const { return &self; }
6255         const LDKErroneousField* operator ->() const { return &self; }
6256 };
6257 class DelayedPaymentBasepoint {
6258 private:
6259         LDKDelayedPaymentBasepoint self;
6260 public:
6261         DelayedPaymentBasepoint(const DelayedPaymentBasepoint&) = delete;
6262         DelayedPaymentBasepoint(DelayedPaymentBasepoint&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentBasepoint)); }
6263         DelayedPaymentBasepoint(LDKDelayedPaymentBasepoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentBasepoint)); }
6264         operator LDKDelayedPaymentBasepoint() && { LDKDelayedPaymentBasepoint res = self; memset(&self, 0, sizeof(LDKDelayedPaymentBasepoint)); return res; }
6265         ~DelayedPaymentBasepoint() { DelayedPaymentBasepoint_free(self); }
6266         DelayedPaymentBasepoint& operator=(DelayedPaymentBasepoint&& o) { DelayedPaymentBasepoint_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentBasepoint)); return *this; }
6267         LDKDelayedPaymentBasepoint* operator &() { return &self; }
6268         LDKDelayedPaymentBasepoint* operator ->() { return &self; }
6269         const LDKDelayedPaymentBasepoint* operator &() const { return &self; }
6270         const LDKDelayedPaymentBasepoint* operator ->() const { return &self; }
6271 };
6272 class DelayedPaymentKey {
6273 private:
6274         LDKDelayedPaymentKey self;
6275 public:
6276         DelayedPaymentKey(const DelayedPaymentKey&) = delete;
6277         DelayedPaymentKey(DelayedPaymentKey&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentKey)); }
6278         DelayedPaymentKey(LDKDelayedPaymentKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentKey)); }
6279         operator LDKDelayedPaymentKey() && { LDKDelayedPaymentKey res = self; memset(&self, 0, sizeof(LDKDelayedPaymentKey)); return res; }
6280         ~DelayedPaymentKey() { DelayedPaymentKey_free(self); }
6281         DelayedPaymentKey& operator=(DelayedPaymentKey&& o) { DelayedPaymentKey_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentKey)); return *this; }
6282         LDKDelayedPaymentKey* operator &() { return &self; }
6283         LDKDelayedPaymentKey* operator ->() { return &self; }
6284         const LDKDelayedPaymentKey* operator &() const { return &self; }
6285         const LDKDelayedPaymentKey* operator ->() const { return &self; }
6286 };
6287 class HtlcBasepoint {
6288 private:
6289         LDKHtlcBasepoint self;
6290 public:
6291         HtlcBasepoint(const HtlcBasepoint&) = delete;
6292         HtlcBasepoint(HtlcBasepoint&& o) : self(o.self) { memset(&o, 0, sizeof(HtlcBasepoint)); }
6293         HtlcBasepoint(LDKHtlcBasepoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHtlcBasepoint)); }
6294         operator LDKHtlcBasepoint() && { LDKHtlcBasepoint res = self; memset(&self, 0, sizeof(LDKHtlcBasepoint)); return res; }
6295         ~HtlcBasepoint() { HtlcBasepoint_free(self); }
6296         HtlcBasepoint& operator=(HtlcBasepoint&& o) { HtlcBasepoint_free(self); self = o.self; memset(&o, 0, sizeof(HtlcBasepoint)); return *this; }
6297         LDKHtlcBasepoint* operator &() { return &self; }
6298         LDKHtlcBasepoint* operator ->() { return &self; }
6299         const LDKHtlcBasepoint* operator &() const { return &self; }
6300         const LDKHtlcBasepoint* operator ->() const { return &self; }
6301 };
6302 class HtlcKey {
6303 private:
6304         LDKHtlcKey self;
6305 public:
6306         HtlcKey(const HtlcKey&) = delete;
6307         HtlcKey(HtlcKey&& o) : self(o.self) { memset(&o, 0, sizeof(HtlcKey)); }
6308         HtlcKey(LDKHtlcKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHtlcKey)); }
6309         operator LDKHtlcKey() && { LDKHtlcKey res = self; memset(&self, 0, sizeof(LDKHtlcKey)); return res; }
6310         ~HtlcKey() { HtlcKey_free(self); }
6311         HtlcKey& operator=(HtlcKey&& o) { HtlcKey_free(self); self = o.self; memset(&o, 0, sizeof(HtlcKey)); return *this; }
6312         LDKHtlcKey* operator &() { return &self; }
6313         LDKHtlcKey* operator ->() { return &self; }
6314         const LDKHtlcKey* operator &() const { return &self; }
6315         const LDKHtlcKey* operator ->() const { return &self; }
6316 };
6317 class RevocationBasepoint {
6318 private:
6319         LDKRevocationBasepoint self;
6320 public:
6321         RevocationBasepoint(const RevocationBasepoint&) = delete;
6322         RevocationBasepoint(RevocationBasepoint&& o) : self(o.self) { memset(&o, 0, sizeof(RevocationBasepoint)); }
6323         RevocationBasepoint(LDKRevocationBasepoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevocationBasepoint)); }
6324         operator LDKRevocationBasepoint() && { LDKRevocationBasepoint res = self; memset(&self, 0, sizeof(LDKRevocationBasepoint)); return res; }
6325         ~RevocationBasepoint() { RevocationBasepoint_free(self); }
6326         RevocationBasepoint& operator=(RevocationBasepoint&& o) { RevocationBasepoint_free(self); self = o.self; memset(&o, 0, sizeof(RevocationBasepoint)); return *this; }
6327         LDKRevocationBasepoint* operator &() { return &self; }
6328         LDKRevocationBasepoint* operator ->() { return &self; }
6329         const LDKRevocationBasepoint* operator &() const { return &self; }
6330         const LDKRevocationBasepoint* operator ->() const { return &self; }
6331 };
6332 class RevocationKey {
6333 private:
6334         LDKRevocationKey self;
6335 public:
6336         RevocationKey(const RevocationKey&) = delete;
6337         RevocationKey(RevocationKey&& o) : self(o.self) { memset(&o, 0, sizeof(RevocationKey)); }
6338         RevocationKey(LDKRevocationKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevocationKey)); }
6339         operator LDKRevocationKey() && { LDKRevocationKey res = self; memset(&self, 0, sizeof(LDKRevocationKey)); return res; }
6340         ~RevocationKey() { RevocationKey_free(self); }
6341         RevocationKey& operator=(RevocationKey&& o) { RevocationKey_free(self); self = o.self; memset(&o, 0, sizeof(RevocationKey)); return *this; }
6342         LDKRevocationKey* operator &() { return &self; }
6343         LDKRevocationKey* operator ->() { return &self; }
6344         const LDKRevocationKey* operator &() const { return &self; }
6345         const LDKRevocationKey* operator ->() const { return &self; }
6346 };
6347 class MonitorUpdateId {
6348 private:
6349         LDKMonitorUpdateId self;
6350 public:
6351         MonitorUpdateId(const MonitorUpdateId&) = delete;
6352         MonitorUpdateId(MonitorUpdateId&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdateId)); }
6353         MonitorUpdateId(LDKMonitorUpdateId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdateId)); }
6354         operator LDKMonitorUpdateId() && { LDKMonitorUpdateId res = self; memset(&self, 0, sizeof(LDKMonitorUpdateId)); return res; }
6355         ~MonitorUpdateId() { MonitorUpdateId_free(self); }
6356         MonitorUpdateId& operator=(MonitorUpdateId&& o) { MonitorUpdateId_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdateId)); return *this; }
6357         LDKMonitorUpdateId* operator &() { return &self; }
6358         LDKMonitorUpdateId* operator ->() { return &self; }
6359         const LDKMonitorUpdateId* operator &() const { return &self; }
6360         const LDKMonitorUpdateId* operator ->() const { return &self; }
6361 };
6362 class Persist {
6363 private:
6364         LDKPersist self;
6365 public:
6366         Persist(const Persist&) = delete;
6367         Persist(Persist&& o) : self(o.self) { memset(&o, 0, sizeof(Persist)); }
6368         Persist(LDKPersist&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersist)); }
6369         operator LDKPersist() && { LDKPersist res = self; memset(&self, 0, sizeof(LDKPersist)); return res; }
6370         ~Persist() { Persist_free(self); }
6371         Persist& operator=(Persist&& o) { Persist_free(self); self = o.self; memset(&o, 0, sizeof(Persist)); return *this; }
6372         LDKPersist* operator &() { return &self; }
6373         LDKPersist* operator ->() { return &self; }
6374         const LDKPersist* operator &() const { return &self; }
6375         const LDKPersist* operator ->() const { return &self; }
6376         /**
6377          *  Persist a new channel's data in response to a [`chain::Watch::watch_channel`] call. This is
6378          *  called by [`ChannelManager`] for new channels, or may be called directly, e.g. on startup.
6379          *
6380          *  The data can be stored any way you want, but the identifier provided by LDK is the
6381          *  channel's outpoint (and it is up to you to maintain a correct mapping between the outpoint
6382          *  and the stored channel data). Note that you **must** persist every new monitor to disk.
6383          *
6384          *  The `update_id` is used to identify this call to [`ChainMonitor::channel_monitor_updated`],
6385          *  if you return [`ChannelMonitorUpdateStatus::InProgress`].
6386          *
6387          *  See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`
6388          *  and [`ChannelMonitorUpdateStatus`] for requirements when returning errors.
6389          *
6390          *  [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
6391          *  [`Writeable::write`]: crate::util::ser::Writeable::write
6392          */
6393         inline LDK::ChannelMonitorUpdateStatus persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
6394         /**
6395          *  Update one channel's data. The provided [`ChannelMonitor`] has already applied the given
6396          *  update.
6397          *
6398          *  Note that on every update, you **must** persist either the [`ChannelMonitorUpdate`] or the
6399          *  updated monitor itself to disk/backups. See the [`Persist`] trait documentation for more
6400          *  details.
6401          *
6402          *  During blockchain synchronization operations, and in some rare cases, this may be called with
6403          *  no [`ChannelMonitorUpdate`], in which case the full [`ChannelMonitor`] needs to be persisted.
6404          *  Note that after the full [`ChannelMonitor`] is persisted any previous
6405          *  [`ChannelMonitorUpdate`]s which were persisted should be discarded - they can no longer be
6406          *  applied to the persisted [`ChannelMonitor`] as they were already applied.
6407          *
6408          *  If an implementer chooses to persist the updates only, they need to make
6409          *  sure that all the updates are applied to the `ChannelMonitors` *before*
6410          *  the set of channel monitors is given to the `ChannelManager`
6411          *  deserialization routine. See [`ChannelMonitor::update_monitor`] for
6412          *  applying a monitor update to a monitor. If full `ChannelMonitors` are
6413          *  persisted, then there is no need to persist individual updates.
6414          *
6415          *  Note that there could be a performance tradeoff between persisting complete
6416          *  channel monitors on every update vs. persisting only updates and applying
6417          *  them in batches. The size of each monitor grows `O(number of state updates)`
6418          *  whereas updates are small and `O(1)`.
6419          *
6420          *  The `update_id` is used to identify this call to [`ChainMonitor::channel_monitor_updated`],
6421          *  if you return [`ChannelMonitorUpdateStatus::InProgress`].
6422          *
6423          *  See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`,
6424          *  [`Writeable::write`] on [`ChannelMonitorUpdate`] for writing out an update, and
6425          *  [`ChannelMonitorUpdateStatus`] for requirements when returning errors.
6426          *
6427          *  [`Writeable::write`]: crate::util::ser::Writeable::write
6428          *
6429          *  Note that update (or a relevant inner pointer) may be NULL or all-0s to represent None
6430          */
6431         inline LDK::ChannelMonitorUpdateStatus update_persisted_channel(struct LDKOutPoint channel_id, struct LDKChannelMonitorUpdate update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
6432 };
6433 class LockedChannelMonitor {
6434 private:
6435         LDKLockedChannelMonitor self;
6436 public:
6437         LockedChannelMonitor(const LockedChannelMonitor&) = delete;
6438         LockedChannelMonitor(LockedChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(LockedChannelMonitor)); }
6439         LockedChannelMonitor(LDKLockedChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockedChannelMonitor)); }
6440         operator LDKLockedChannelMonitor() && { LDKLockedChannelMonitor res = self; memset(&self, 0, sizeof(LDKLockedChannelMonitor)); return res; }
6441         ~LockedChannelMonitor() { LockedChannelMonitor_free(self); }
6442         LockedChannelMonitor& operator=(LockedChannelMonitor&& o) { LockedChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(LockedChannelMonitor)); return *this; }
6443         LDKLockedChannelMonitor* operator &() { return &self; }
6444         LDKLockedChannelMonitor* operator ->() { return &self; }
6445         const LDKLockedChannelMonitor* operator &() const { return &self; }
6446         const LDKLockedChannelMonitor* operator ->() const { return &self; }
6447 };
6448 class ChainMonitor {
6449 private:
6450         LDKChainMonitor self;
6451 public:
6452         ChainMonitor(const ChainMonitor&) = delete;
6453         ChainMonitor(ChainMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChainMonitor)); }
6454         ChainMonitor(LDKChainMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainMonitor)); }
6455         operator LDKChainMonitor() && { LDKChainMonitor res = self; memset(&self, 0, sizeof(LDKChainMonitor)); return res; }
6456         ~ChainMonitor() { ChainMonitor_free(self); }
6457         ChainMonitor& operator=(ChainMonitor&& o) { ChainMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChainMonitor)); return *this; }
6458         LDKChainMonitor* operator &() { return &self; }
6459         LDKChainMonitor* operator ->() { return &self; }
6460         const LDKChainMonitor* operator &() const { return &self; }
6461         const LDKChainMonitor* operator ->() const { return &self; }
6462 };
6463 class CResult_HtlcKeyDecodeErrorZ {
6464 private:
6465         LDKCResult_HtlcKeyDecodeErrorZ self;
6466 public:
6467         CResult_HtlcKeyDecodeErrorZ(const CResult_HtlcKeyDecodeErrorZ&) = delete;
6468         CResult_HtlcKeyDecodeErrorZ(CResult_HtlcKeyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HtlcKeyDecodeErrorZ)); }
6469         CResult_HtlcKeyDecodeErrorZ(LDKCResult_HtlcKeyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HtlcKeyDecodeErrorZ)); }
6470         operator LDKCResult_HtlcKeyDecodeErrorZ() && { LDKCResult_HtlcKeyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HtlcKeyDecodeErrorZ)); return res; }
6471         ~CResult_HtlcKeyDecodeErrorZ() { CResult_HtlcKeyDecodeErrorZ_free(self); }
6472         CResult_HtlcKeyDecodeErrorZ& operator=(CResult_HtlcKeyDecodeErrorZ&& o) { CResult_HtlcKeyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HtlcKeyDecodeErrorZ)); return *this; }
6473         LDKCResult_HtlcKeyDecodeErrorZ* operator &() { return &self; }
6474         LDKCResult_HtlcKeyDecodeErrorZ* operator ->() { return &self; }
6475         const LDKCResult_HtlcKeyDecodeErrorZ* operator &() const { return &self; }
6476         const LDKCResult_HtlcKeyDecodeErrorZ* operator ->() const { return &self; }
6477 };
6478 class CResult_TransactionU16LenLimitedNoneZ {
6479 private:
6480         LDKCResult_TransactionU16LenLimitedNoneZ self;
6481 public:
6482         CResult_TransactionU16LenLimitedNoneZ(const CResult_TransactionU16LenLimitedNoneZ&) = delete;
6483         CResult_TransactionU16LenLimitedNoneZ(CResult_TransactionU16LenLimitedNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedNoneZ)); }
6484         CResult_TransactionU16LenLimitedNoneZ(LDKCResult_TransactionU16LenLimitedNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionU16LenLimitedNoneZ)); }
6485         operator LDKCResult_TransactionU16LenLimitedNoneZ() && { LDKCResult_TransactionU16LenLimitedNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionU16LenLimitedNoneZ)); return res; }
6486         ~CResult_TransactionU16LenLimitedNoneZ() { CResult_TransactionU16LenLimitedNoneZ_free(self); }
6487         CResult_TransactionU16LenLimitedNoneZ& operator=(CResult_TransactionU16LenLimitedNoneZ&& o) { CResult_TransactionU16LenLimitedNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedNoneZ)); return *this; }
6488         LDKCResult_TransactionU16LenLimitedNoneZ* operator &() { return &self; }
6489         LDKCResult_TransactionU16LenLimitedNoneZ* operator ->() { return &self; }
6490         const LDKCResult_TransactionU16LenLimitedNoneZ* operator &() const { return &self; }
6491         const LDKCResult_TransactionU16LenLimitedNoneZ* operator ->() const { return &self; }
6492 };
6493 class CResult_LockedChannelMonitorNoneZ {
6494 private:
6495         LDKCResult_LockedChannelMonitorNoneZ self;
6496 public:
6497         CResult_LockedChannelMonitorNoneZ(const CResult_LockedChannelMonitorNoneZ&) = delete;
6498         CResult_LockedChannelMonitorNoneZ(CResult_LockedChannelMonitorNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); }
6499         CResult_LockedChannelMonitorNoneZ(LDKCResult_LockedChannelMonitorNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); }
6500         operator LDKCResult_LockedChannelMonitorNoneZ() && { LDKCResult_LockedChannelMonitorNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); return res; }
6501         ~CResult_LockedChannelMonitorNoneZ() { CResult_LockedChannelMonitorNoneZ_free(self); }
6502         CResult_LockedChannelMonitorNoneZ& operator=(CResult_LockedChannelMonitorNoneZ&& o) { CResult_LockedChannelMonitorNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); return *this; }
6503         LDKCResult_LockedChannelMonitorNoneZ* operator &() { return &self; }
6504         LDKCResult_LockedChannelMonitorNoneZ* operator ->() { return &self; }
6505         const LDKCResult_LockedChannelMonitorNoneZ* operator &() const { return &self; }
6506         const LDKCResult_LockedChannelMonitorNoneZ* operator ->() const { return &self; }
6507 };
6508 class CVec_C2Tuple_BlindedPayInfoBlindedPathZZ {
6509 private:
6510         LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ self;
6511 public:
6512         CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(const CVec_C2Tuple_BlindedPayInfoBlindedPathZZ&) = delete;
6513         CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); }
6514         CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); }
6515         operator LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ() && { LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); return res; }
6516         ~CVec_C2Tuple_BlindedPayInfoBlindedPathZZ() { CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(self); }
6517         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; }
6518         LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator &() { return &self; }
6519         LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator ->() { return &self; }
6520         const LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator &() const { return &self; }
6521         const LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator ->() const { return &self; }
6522 };
6523 class CResult_PhantomRouteHintsDecodeErrorZ {
6524 private:
6525         LDKCResult_PhantomRouteHintsDecodeErrorZ self;
6526 public:
6527         CResult_PhantomRouteHintsDecodeErrorZ(const CResult_PhantomRouteHintsDecodeErrorZ&) = delete;
6528         CResult_PhantomRouteHintsDecodeErrorZ(CResult_PhantomRouteHintsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); }
6529         CResult_PhantomRouteHintsDecodeErrorZ(LDKCResult_PhantomRouteHintsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); }
6530         operator LDKCResult_PhantomRouteHintsDecodeErrorZ() && { LDKCResult_PhantomRouteHintsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); return res; }
6531         ~CResult_PhantomRouteHintsDecodeErrorZ() { CResult_PhantomRouteHintsDecodeErrorZ_free(self); }
6532         CResult_PhantomRouteHintsDecodeErrorZ& operator=(CResult_PhantomRouteHintsDecodeErrorZ&& o) { CResult_PhantomRouteHintsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); return *this; }
6533         LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() { return &self; }
6534         LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() { return &self; }
6535         const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() const { return &self; }
6536         const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() const { return &self; }
6537 };
6538 class CResult_FundingCreatedDecodeErrorZ {
6539 private:
6540         LDKCResult_FundingCreatedDecodeErrorZ self;
6541 public:
6542         CResult_FundingCreatedDecodeErrorZ(const CResult_FundingCreatedDecodeErrorZ&) = delete;
6543         CResult_FundingCreatedDecodeErrorZ(CResult_FundingCreatedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); }
6544         CResult_FundingCreatedDecodeErrorZ(LDKCResult_FundingCreatedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); }
6545         operator LDKCResult_FundingCreatedDecodeErrorZ() && { LDKCResult_FundingCreatedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); return res; }
6546         ~CResult_FundingCreatedDecodeErrorZ() { CResult_FundingCreatedDecodeErrorZ_free(self); }
6547         CResult_FundingCreatedDecodeErrorZ& operator=(CResult_FundingCreatedDecodeErrorZ&& o) { CResult_FundingCreatedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); return *this; }
6548         LDKCResult_FundingCreatedDecodeErrorZ* operator &() { return &self; }
6549         LDKCResult_FundingCreatedDecodeErrorZ* operator ->() { return &self; }
6550         const LDKCResult_FundingCreatedDecodeErrorZ* operator &() const { return &self; }
6551         const LDKCResult_FundingCreatedDecodeErrorZ* operator ->() const { return &self; }
6552 };
6553 class CVec_C2Tuple_u32TxOutZZ {
6554 private:
6555         LDKCVec_C2Tuple_u32TxOutZZ self;
6556 public:
6557         CVec_C2Tuple_u32TxOutZZ(const CVec_C2Tuple_u32TxOutZZ&) = delete;
6558         CVec_C2Tuple_u32TxOutZZ(CVec_C2Tuple_u32TxOutZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32TxOutZZ)); }
6559         CVec_C2Tuple_u32TxOutZZ(LDKCVec_C2Tuple_u32TxOutZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); }
6560         operator LDKCVec_C2Tuple_u32TxOutZZ() && { LDKCVec_C2Tuple_u32TxOutZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); return res; }
6561         ~CVec_C2Tuple_u32TxOutZZ() { CVec_C2Tuple_u32TxOutZZ_free(self); }
6562         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; }
6563         LDKCVec_C2Tuple_u32TxOutZZ* operator &() { return &self; }
6564         LDKCVec_C2Tuple_u32TxOutZZ* operator ->() { return &self; }
6565         const LDKCVec_C2Tuple_u32TxOutZZ* operator &() const { return &self; }
6566         const LDKCVec_C2Tuple_u32TxOutZZ* operator ->() const { return &self; }
6567 };
6568 class CResult_RetryDecodeErrorZ {
6569 private:
6570         LDKCResult_RetryDecodeErrorZ self;
6571 public:
6572         CResult_RetryDecodeErrorZ(const CResult_RetryDecodeErrorZ&) = delete;
6573         CResult_RetryDecodeErrorZ(CResult_RetryDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RetryDecodeErrorZ)); }
6574         CResult_RetryDecodeErrorZ(LDKCResult_RetryDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RetryDecodeErrorZ)); }
6575         operator LDKCResult_RetryDecodeErrorZ() && { LDKCResult_RetryDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RetryDecodeErrorZ)); return res; }
6576         ~CResult_RetryDecodeErrorZ() { CResult_RetryDecodeErrorZ_free(self); }
6577         CResult_RetryDecodeErrorZ& operator=(CResult_RetryDecodeErrorZ&& o) { CResult_RetryDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RetryDecodeErrorZ)); return *this; }
6578         LDKCResult_RetryDecodeErrorZ* operator &() { return &self; }
6579         LDKCResult_RetryDecodeErrorZ* operator ->() { return &self; }
6580         const LDKCResult_RetryDecodeErrorZ* operator &() const { return &self; }
6581         const LDKCResult_RetryDecodeErrorZ* operator ->() const { return &self; }
6582 };
6583 class CResult_BlindedForwardDecodeErrorZ {
6584 private:
6585         LDKCResult_BlindedForwardDecodeErrorZ self;
6586 public:
6587         CResult_BlindedForwardDecodeErrorZ(const CResult_BlindedForwardDecodeErrorZ&) = delete;
6588         CResult_BlindedForwardDecodeErrorZ(CResult_BlindedForwardDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedForwardDecodeErrorZ)); }
6589         CResult_BlindedForwardDecodeErrorZ(LDKCResult_BlindedForwardDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedForwardDecodeErrorZ)); }
6590         operator LDKCResult_BlindedForwardDecodeErrorZ() && { LDKCResult_BlindedForwardDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedForwardDecodeErrorZ)); return res; }
6591         ~CResult_BlindedForwardDecodeErrorZ() { CResult_BlindedForwardDecodeErrorZ_free(self); }
6592         CResult_BlindedForwardDecodeErrorZ& operator=(CResult_BlindedForwardDecodeErrorZ&& o) { CResult_BlindedForwardDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedForwardDecodeErrorZ)); return *this; }
6593         LDKCResult_BlindedForwardDecodeErrorZ* operator &() { return &self; }
6594         LDKCResult_BlindedForwardDecodeErrorZ* operator ->() { return &self; }
6595         const LDKCResult_BlindedForwardDecodeErrorZ* operator &() const { return &self; }
6596         const LDKCResult_BlindedForwardDecodeErrorZ* operator ->() const { return &self; }
6597 };
6598 class CResult_ChannelInfoDecodeErrorZ {
6599 private:
6600         LDKCResult_ChannelInfoDecodeErrorZ self;
6601 public:
6602         CResult_ChannelInfoDecodeErrorZ(const CResult_ChannelInfoDecodeErrorZ&) = delete;
6603         CResult_ChannelInfoDecodeErrorZ(CResult_ChannelInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); }
6604         CResult_ChannelInfoDecodeErrorZ(LDKCResult_ChannelInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); }
6605         operator LDKCResult_ChannelInfoDecodeErrorZ() && { LDKCResult_ChannelInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); return res; }
6606         ~CResult_ChannelInfoDecodeErrorZ() { CResult_ChannelInfoDecodeErrorZ_free(self); }
6607         CResult_ChannelInfoDecodeErrorZ& operator=(CResult_ChannelInfoDecodeErrorZ&& o) { CResult_ChannelInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); return *this; }
6608         LDKCResult_ChannelInfoDecodeErrorZ* operator &() { return &self; }
6609         LDKCResult_ChannelInfoDecodeErrorZ* operator ->() { return &self; }
6610         const LDKCResult_ChannelInfoDecodeErrorZ* operator &() const { return &self; }
6611         const LDKCResult_ChannelInfoDecodeErrorZ* operator ->() const { return &self; }
6612 };
6613 class COption_MaxDustHTLCExposureZ {
6614 private:
6615         LDKCOption_MaxDustHTLCExposureZ self;
6616 public:
6617         COption_MaxDustHTLCExposureZ(const COption_MaxDustHTLCExposureZ&) = delete;
6618         COption_MaxDustHTLCExposureZ(COption_MaxDustHTLCExposureZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MaxDustHTLCExposureZ)); }
6619         COption_MaxDustHTLCExposureZ(LDKCOption_MaxDustHTLCExposureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MaxDustHTLCExposureZ)); }
6620         operator LDKCOption_MaxDustHTLCExposureZ() && { LDKCOption_MaxDustHTLCExposureZ res = self; memset(&self, 0, sizeof(LDKCOption_MaxDustHTLCExposureZ)); return res; }
6621         ~COption_MaxDustHTLCExposureZ() { COption_MaxDustHTLCExposureZ_free(self); }
6622         COption_MaxDustHTLCExposureZ& operator=(COption_MaxDustHTLCExposureZ&& o) { COption_MaxDustHTLCExposureZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MaxDustHTLCExposureZ)); return *this; }
6623         LDKCOption_MaxDustHTLCExposureZ* operator &() { return &self; }
6624         LDKCOption_MaxDustHTLCExposureZ* operator ->() { return &self; }
6625         const LDKCOption_MaxDustHTLCExposureZ* operator &() const { return &self; }
6626         const LDKCOption_MaxDustHTLCExposureZ* operator ->() const { return &self; }
6627 };
6628 class COption_OffersMessageZ {
6629 private:
6630         LDKCOption_OffersMessageZ self;
6631 public:
6632         COption_OffersMessageZ(const COption_OffersMessageZ&) = delete;
6633         COption_OffersMessageZ(COption_OffersMessageZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_OffersMessageZ)); }
6634         COption_OffersMessageZ(LDKCOption_OffersMessageZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_OffersMessageZ)); }
6635         operator LDKCOption_OffersMessageZ() && { LDKCOption_OffersMessageZ res = self; memset(&self, 0, sizeof(LDKCOption_OffersMessageZ)); return res; }
6636         ~COption_OffersMessageZ() { COption_OffersMessageZ_free(self); }
6637         COption_OffersMessageZ& operator=(COption_OffersMessageZ&& o) { COption_OffersMessageZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_OffersMessageZ)); return *this; }
6638         LDKCOption_OffersMessageZ* operator &() { return &self; }
6639         LDKCOption_OffersMessageZ* operator ->() { return &self; }
6640         const LDKCOption_OffersMessageZ* operator &() const { return &self; }
6641         const LDKCOption_OffersMessageZ* operator ->() const { return &self; }
6642 };
6643 class CResult_CVec_u8ZPeerHandleErrorZ {
6644 private:
6645         LDKCResult_CVec_u8ZPeerHandleErrorZ self;
6646 public:
6647         CResult_CVec_u8ZPeerHandleErrorZ(const CResult_CVec_u8ZPeerHandleErrorZ&) = delete;
6648         CResult_CVec_u8ZPeerHandleErrorZ(CResult_CVec_u8ZPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); }
6649         CResult_CVec_u8ZPeerHandleErrorZ(LDKCResult_CVec_u8ZPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); }
6650         operator LDKCResult_CVec_u8ZPeerHandleErrorZ() && { LDKCResult_CVec_u8ZPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); return res; }
6651         ~CResult_CVec_u8ZPeerHandleErrorZ() { CResult_CVec_u8ZPeerHandleErrorZ_free(self); }
6652         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; }
6653         LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() { return &self; }
6654         LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() { return &self; }
6655         const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() const { return &self; }
6656         const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() const { return &self; }
6657 };
6658 class COption_NetworkUpdateZ {
6659 private:
6660         LDKCOption_NetworkUpdateZ self;
6661 public:
6662         COption_NetworkUpdateZ(const COption_NetworkUpdateZ&) = delete;
6663         COption_NetworkUpdateZ(COption_NetworkUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NetworkUpdateZ)); }
6664         COption_NetworkUpdateZ(LDKCOption_NetworkUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NetworkUpdateZ)); }
6665         operator LDKCOption_NetworkUpdateZ() && { LDKCOption_NetworkUpdateZ res = self; memset(&self, 0, sizeof(LDKCOption_NetworkUpdateZ)); return res; }
6666         ~COption_NetworkUpdateZ() { COption_NetworkUpdateZ_free(self); }
6667         COption_NetworkUpdateZ& operator=(COption_NetworkUpdateZ&& o) { COption_NetworkUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NetworkUpdateZ)); return *this; }
6668         LDKCOption_NetworkUpdateZ* operator &() { return &self; }
6669         LDKCOption_NetworkUpdateZ* operator ->() { return &self; }
6670         const LDKCOption_NetworkUpdateZ* operator &() const { return &self; }
6671         const LDKCOption_NetworkUpdateZ* operator ->() const { return &self; }
6672 };
6673 class COption_u64Z {
6674 private:
6675         LDKCOption_u64Z self;
6676 public:
6677         COption_u64Z(const COption_u64Z&) = delete;
6678         COption_u64Z(COption_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u64Z)); }
6679         COption_u64Z(LDKCOption_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u64Z)); }
6680         operator LDKCOption_u64Z() && { LDKCOption_u64Z res = self; memset(&self, 0, sizeof(LDKCOption_u64Z)); return res; }
6681         ~COption_u64Z() { COption_u64Z_free(self); }
6682         COption_u64Z& operator=(COption_u64Z&& o) { COption_u64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u64Z)); return *this; }
6683         LDKCOption_u64Z* operator &() { return &self; }
6684         LDKCOption_u64Z* operator ->() { return &self; }
6685         const LDKCOption_u64Z* operator &() const { return &self; }
6686         const LDKCOption_u64Z* operator ->() const { return &self; }
6687 };
6688 class CResult_OnionPacketDecodeErrorZ {
6689 private:
6690         LDKCResult_OnionPacketDecodeErrorZ self;
6691 public:
6692         CResult_OnionPacketDecodeErrorZ(const CResult_OnionPacketDecodeErrorZ&) = delete;
6693         CResult_OnionPacketDecodeErrorZ(CResult_OnionPacketDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionPacketDecodeErrorZ)); }
6694         CResult_OnionPacketDecodeErrorZ(LDKCResult_OnionPacketDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionPacketDecodeErrorZ)); }
6695         operator LDKCResult_OnionPacketDecodeErrorZ() && { LDKCResult_OnionPacketDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionPacketDecodeErrorZ)); return res; }
6696         ~CResult_OnionPacketDecodeErrorZ() { CResult_OnionPacketDecodeErrorZ_free(self); }
6697         CResult_OnionPacketDecodeErrorZ& operator=(CResult_OnionPacketDecodeErrorZ&& o) { CResult_OnionPacketDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionPacketDecodeErrorZ)); return *this; }
6698         LDKCResult_OnionPacketDecodeErrorZ* operator &() { return &self; }
6699         LDKCResult_OnionPacketDecodeErrorZ* operator ->() { return &self; }
6700         const LDKCResult_OnionPacketDecodeErrorZ* operator &() const { return &self; }
6701         const LDKCResult_OnionPacketDecodeErrorZ* operator ->() const { return &self; }
6702 };
6703 class CResult_GossipTimestampFilterDecodeErrorZ {
6704 private:
6705         LDKCResult_GossipTimestampFilterDecodeErrorZ self;
6706 public:
6707         CResult_GossipTimestampFilterDecodeErrorZ(const CResult_GossipTimestampFilterDecodeErrorZ&) = delete;
6708         CResult_GossipTimestampFilterDecodeErrorZ(CResult_GossipTimestampFilterDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); }
6709         CResult_GossipTimestampFilterDecodeErrorZ(LDKCResult_GossipTimestampFilterDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); }
6710         operator LDKCResult_GossipTimestampFilterDecodeErrorZ() && { LDKCResult_GossipTimestampFilterDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); return res; }
6711         ~CResult_GossipTimestampFilterDecodeErrorZ() { CResult_GossipTimestampFilterDecodeErrorZ_free(self); }
6712         CResult_GossipTimestampFilterDecodeErrorZ& operator=(CResult_GossipTimestampFilterDecodeErrorZ&& o) { CResult_GossipTimestampFilterDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); return *this; }
6713         LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() { return &self; }
6714         LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() { return &self; }
6715         const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() const { return &self; }
6716         const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() const { return &self; }
6717 };
6718 class CResult_RouteHintDecodeErrorZ {
6719 private:
6720         LDKCResult_RouteHintDecodeErrorZ self;
6721 public:
6722         CResult_RouteHintDecodeErrorZ(const CResult_RouteHintDecodeErrorZ&) = delete;
6723         CResult_RouteHintDecodeErrorZ(CResult_RouteHintDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); }
6724         CResult_RouteHintDecodeErrorZ(LDKCResult_RouteHintDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); }
6725         operator LDKCResult_RouteHintDecodeErrorZ() && { LDKCResult_RouteHintDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); return res; }
6726         ~CResult_RouteHintDecodeErrorZ() { CResult_RouteHintDecodeErrorZ_free(self); }
6727         CResult_RouteHintDecodeErrorZ& operator=(CResult_RouteHintDecodeErrorZ&& o) { CResult_RouteHintDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); return *this; }
6728         LDKCResult_RouteHintDecodeErrorZ* operator &() { return &self; }
6729         LDKCResult_RouteHintDecodeErrorZ* operator ->() { return &self; }
6730         const LDKCResult_RouteHintDecodeErrorZ* operator &() const { return &self; }
6731         const LDKCResult_RouteHintDecodeErrorZ* operator ->() const { return &self; }
6732 };
6733 class COption_FilterZ {
6734 private:
6735         LDKCOption_FilterZ self;
6736 public:
6737         COption_FilterZ(const COption_FilterZ&) = delete;
6738         COption_FilterZ(COption_FilterZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_FilterZ)); }
6739         COption_FilterZ(LDKCOption_FilterZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_FilterZ)); }
6740         operator LDKCOption_FilterZ() && { LDKCOption_FilterZ res = self; memset(&self, 0, sizeof(LDKCOption_FilterZ)); return res; }
6741         ~COption_FilterZ() { COption_FilterZ_free(self); }
6742         COption_FilterZ& operator=(COption_FilterZ&& o) { COption_FilterZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_FilterZ)); return *this; }
6743         LDKCOption_FilterZ* operator &() { return &self; }
6744         LDKCOption_FilterZ* operator ->() { return &self; }
6745         const LDKCOption_FilterZ* operator &() const { return &self; }
6746         const LDKCOption_FilterZ* operator ->() const { return &self; }
6747 };
6748 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ {
6749 private:
6750         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ self;
6751 public:
6752         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ(const C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ&) = delete;
6753         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ)); }
6754         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)); }
6755         operator LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ() && { LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ)); return res; }
6756         ~C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ() { C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(self); }
6757         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; }
6758         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator &() { return &self; }
6759         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator ->() { return &self; }
6760         const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator &() const { return &self; }
6761         const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator ->() const { return &self; }
6762 };
6763 class COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
6764 private:
6765         LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ self;
6766 public:
6767         COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(const COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&) = delete;
6768         COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
6769         COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
6770         operator LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() && { LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ res = self; memset(&self, 0, sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return res; }
6771         ~COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() { COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); }
6772         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; }
6773         LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() { return &self; }
6774         LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() { return &self; }
6775         const LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() const { return &self; }
6776         const LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() const { return &self; }
6777 };
6778 class CResult_COption_APIErrorZDecodeErrorZ {
6779 private:
6780         LDKCResult_COption_APIErrorZDecodeErrorZ self;
6781 public:
6782         CResult_COption_APIErrorZDecodeErrorZ(const CResult_COption_APIErrorZDecodeErrorZ&) = delete;
6783         CResult_COption_APIErrorZDecodeErrorZ(CResult_COption_APIErrorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_APIErrorZDecodeErrorZ)); }
6784         CResult_COption_APIErrorZDecodeErrorZ(LDKCResult_COption_APIErrorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ)); }
6785         operator LDKCResult_COption_APIErrorZDecodeErrorZ() && { LDKCResult_COption_APIErrorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ)); return res; }
6786         ~CResult_COption_APIErrorZDecodeErrorZ() { CResult_COption_APIErrorZDecodeErrorZ_free(self); }
6787         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; }
6788         LDKCResult_COption_APIErrorZDecodeErrorZ* operator &() { return &self; }
6789         LDKCResult_COption_APIErrorZDecodeErrorZ* operator ->() { return &self; }
6790         const LDKCResult_COption_APIErrorZDecodeErrorZ* operator &() const { return &self; }
6791         const LDKCResult_COption_APIErrorZDecodeErrorZ* operator ->() const { return &self; }
6792 };
6793 class CVec_UpdateAddHTLCZ {
6794 private:
6795         LDKCVec_UpdateAddHTLCZ self;
6796 public:
6797         CVec_UpdateAddHTLCZ(const CVec_UpdateAddHTLCZ&) = delete;
6798         CVec_UpdateAddHTLCZ(CVec_UpdateAddHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); }
6799         CVec_UpdateAddHTLCZ(LDKCVec_UpdateAddHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); }
6800         operator LDKCVec_UpdateAddHTLCZ() && { LDKCVec_UpdateAddHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); return res; }
6801         ~CVec_UpdateAddHTLCZ() { CVec_UpdateAddHTLCZ_free(self); }
6802         CVec_UpdateAddHTLCZ& operator=(CVec_UpdateAddHTLCZ&& o) { CVec_UpdateAddHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); return *this; }
6803         LDKCVec_UpdateAddHTLCZ* operator &() { return &self; }
6804         LDKCVec_UpdateAddHTLCZ* operator ->() { return &self; }
6805         const LDKCVec_UpdateAddHTLCZ* operator &() const { return &self; }
6806         const LDKCVec_UpdateAddHTLCZ* operator ->() const { return &self; }
6807 };
6808 class CResult_TxAbortDecodeErrorZ {
6809 private:
6810         LDKCResult_TxAbortDecodeErrorZ self;
6811 public:
6812         CResult_TxAbortDecodeErrorZ(const CResult_TxAbortDecodeErrorZ&) = delete;
6813         CResult_TxAbortDecodeErrorZ(CResult_TxAbortDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAbortDecodeErrorZ)); }
6814         CResult_TxAbortDecodeErrorZ(LDKCResult_TxAbortDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAbortDecodeErrorZ)); }
6815         operator LDKCResult_TxAbortDecodeErrorZ() && { LDKCResult_TxAbortDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAbortDecodeErrorZ)); return res; }
6816         ~CResult_TxAbortDecodeErrorZ() { CResult_TxAbortDecodeErrorZ_free(self); }
6817         CResult_TxAbortDecodeErrorZ& operator=(CResult_TxAbortDecodeErrorZ&& o) { CResult_TxAbortDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAbortDecodeErrorZ)); return *this; }
6818         LDKCResult_TxAbortDecodeErrorZ* operator &() { return &self; }
6819         LDKCResult_TxAbortDecodeErrorZ* operator ->() { return &self; }
6820         const LDKCResult_TxAbortDecodeErrorZ* operator &() const { return &self; }
6821         const LDKCResult_TxAbortDecodeErrorZ* operator ->() const { return &self; }
6822 };
6823 class CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
6824 private:
6825         LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ self;
6826 public:
6827         CResult_StaticPaymentOutputDescriptorDecodeErrorZ(const CResult_StaticPaymentOutputDescriptorDecodeErrorZ&) = delete;
6828         CResult_StaticPaymentOutputDescriptorDecodeErrorZ(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
6829         CResult_StaticPaymentOutputDescriptorDecodeErrorZ(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
6830         operator LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return res; }
6831         ~CResult_StaticPaymentOutputDescriptorDecodeErrorZ() { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); }
6832         CResult_StaticPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return *this; }
6833         LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
6834         LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
6835         const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
6836         const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
6837 };
6838 class COption_u32Z {
6839 private:
6840         LDKCOption_u32Z self;
6841 public:
6842         COption_u32Z(const COption_u32Z&) = delete;
6843         COption_u32Z(COption_u32Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u32Z)); }
6844         COption_u32Z(LDKCOption_u32Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u32Z)); }
6845         operator LDKCOption_u32Z() && { LDKCOption_u32Z res = self; memset(&self, 0, sizeof(LDKCOption_u32Z)); return res; }
6846         ~COption_u32Z() { COption_u32Z_free(self); }
6847         COption_u32Z& operator=(COption_u32Z&& o) { COption_u32Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u32Z)); return *this; }
6848         LDKCOption_u32Z* operator &() { return &self; }
6849         LDKCOption_u32Z* operator ->() { return &self; }
6850         const LDKCOption_u32Z* operator &() const { return &self; }
6851         const LDKCOption_u32Z* operator ->() const { return &self; }
6852 };
6853 class CResult_RecipientOnionFieldsNoneZ {
6854 private:
6855         LDKCResult_RecipientOnionFieldsNoneZ self;
6856 public:
6857         CResult_RecipientOnionFieldsNoneZ(const CResult_RecipientOnionFieldsNoneZ&) = delete;
6858         CResult_RecipientOnionFieldsNoneZ(CResult_RecipientOnionFieldsNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecipientOnionFieldsNoneZ)); }
6859         CResult_RecipientOnionFieldsNoneZ(LDKCResult_RecipientOnionFieldsNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecipientOnionFieldsNoneZ)); }
6860         operator LDKCResult_RecipientOnionFieldsNoneZ() && { LDKCResult_RecipientOnionFieldsNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_RecipientOnionFieldsNoneZ)); return res; }
6861         ~CResult_RecipientOnionFieldsNoneZ() { CResult_RecipientOnionFieldsNoneZ_free(self); }
6862         CResult_RecipientOnionFieldsNoneZ& operator=(CResult_RecipientOnionFieldsNoneZ&& o) { CResult_RecipientOnionFieldsNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecipientOnionFieldsNoneZ)); return *this; }
6863         LDKCResult_RecipientOnionFieldsNoneZ* operator &() { return &self; }
6864         LDKCResult_RecipientOnionFieldsNoneZ* operator ->() { return &self; }
6865         const LDKCResult_RecipientOnionFieldsNoneZ* operator &() const { return &self; }
6866         const LDKCResult_RecipientOnionFieldsNoneZ* operator ->() const { return &self; }
6867 };
6868 class C2Tuple__u1632_u1632Z {
6869 private:
6870         LDKC2Tuple__u1632_u1632Z self;
6871 public:
6872         C2Tuple__u1632_u1632Z(const C2Tuple__u1632_u1632Z&) = delete;
6873         C2Tuple__u1632_u1632Z(C2Tuple__u1632_u1632Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple__u1632_u1632Z)); }
6874         C2Tuple__u1632_u1632Z(LDKC2Tuple__u1632_u1632Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple__u1632_u1632Z)); }
6875         operator LDKC2Tuple__u1632_u1632Z() && { LDKC2Tuple__u1632_u1632Z res = self; memset(&self, 0, sizeof(LDKC2Tuple__u1632_u1632Z)); return res; }
6876         ~C2Tuple__u1632_u1632Z() { C2Tuple__u1632_u1632Z_free(self); }
6877         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; }
6878         LDKC2Tuple__u1632_u1632Z* operator &() { return &self; }
6879         LDKC2Tuple__u1632_u1632Z* operator ->() { return &self; }
6880         const LDKC2Tuple__u1632_u1632Z* operator &() const { return &self; }
6881         const LDKC2Tuple__u1632_u1632Z* operator ->() const { return &self; }
6882 };
6883 class CResult_CVec_StrZIOErrorZ {
6884 private:
6885         LDKCResult_CVec_StrZIOErrorZ self;
6886 public:
6887         CResult_CVec_StrZIOErrorZ(const CResult_CVec_StrZIOErrorZ&) = delete;
6888         CResult_CVec_StrZIOErrorZ(CResult_CVec_StrZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_StrZIOErrorZ)); }
6889         CResult_CVec_StrZIOErrorZ(LDKCResult_CVec_StrZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_StrZIOErrorZ)); }
6890         operator LDKCResult_CVec_StrZIOErrorZ() && { LDKCResult_CVec_StrZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_StrZIOErrorZ)); return res; }
6891         ~CResult_CVec_StrZIOErrorZ() { CResult_CVec_StrZIOErrorZ_free(self); }
6892         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; }
6893         LDKCResult_CVec_StrZIOErrorZ* operator &() { return &self; }
6894         LDKCResult_CVec_StrZIOErrorZ* operator ->() { return &self; }
6895         const LDKCResult_CVec_StrZIOErrorZ* operator &() const { return &self; }
6896         const LDKCResult_CVec_StrZIOErrorZ* operator ->() const { return &self; }
6897 };
6898 class CResult_ClosingSignedFeeRangeDecodeErrorZ {
6899 private:
6900         LDKCResult_ClosingSignedFeeRangeDecodeErrorZ self;
6901 public:
6902         CResult_ClosingSignedFeeRangeDecodeErrorZ(const CResult_ClosingSignedFeeRangeDecodeErrorZ&) = delete;
6903         CResult_ClosingSignedFeeRangeDecodeErrorZ(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); }
6904         CResult_ClosingSignedFeeRangeDecodeErrorZ(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); }
6905         operator LDKCResult_ClosingSignedFeeRangeDecodeErrorZ() && { LDKCResult_ClosingSignedFeeRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); return res; }
6906         ~CResult_ClosingSignedFeeRangeDecodeErrorZ() { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); }
6907         CResult_ClosingSignedFeeRangeDecodeErrorZ& operator=(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); return *this; }
6908         LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() { return &self; }
6909         LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() { return &self; }
6910         const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() const { return &self; }
6911         const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() const { return &self; }
6912 };
6913 class CResult_TransactionNoneZ {
6914 private:
6915         LDKCResult_TransactionNoneZ self;
6916 public:
6917         CResult_TransactionNoneZ(const CResult_TransactionNoneZ&) = delete;
6918         CResult_TransactionNoneZ(CResult_TransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionNoneZ)); }
6919         CResult_TransactionNoneZ(LDKCResult_TransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionNoneZ)); }
6920         operator LDKCResult_TransactionNoneZ() && { LDKCResult_TransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionNoneZ)); return res; }
6921         ~CResult_TransactionNoneZ() { CResult_TransactionNoneZ_free(self); }
6922         CResult_TransactionNoneZ& operator=(CResult_TransactionNoneZ&& o) { CResult_TransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionNoneZ)); return *this; }
6923         LDKCResult_TransactionNoneZ* operator &() { return &self; }
6924         LDKCResult_TransactionNoneZ* operator ->() { return &self; }
6925         const LDKCResult_TransactionNoneZ* operator &() const { return &self; }
6926         const LDKCResult_TransactionNoneZ* operator ->() const { return &self; }
6927 };
6928 class CResult_CommitmentSignedDecodeErrorZ {
6929 private:
6930         LDKCResult_CommitmentSignedDecodeErrorZ self;
6931 public:
6932         CResult_CommitmentSignedDecodeErrorZ(const CResult_CommitmentSignedDecodeErrorZ&) = delete;
6933         CResult_CommitmentSignedDecodeErrorZ(CResult_CommitmentSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); }
6934         CResult_CommitmentSignedDecodeErrorZ(LDKCResult_CommitmentSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); }
6935         operator LDKCResult_CommitmentSignedDecodeErrorZ() && { LDKCResult_CommitmentSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); return res; }
6936         ~CResult_CommitmentSignedDecodeErrorZ() { CResult_CommitmentSignedDecodeErrorZ_free(self); }
6937         CResult_CommitmentSignedDecodeErrorZ& operator=(CResult_CommitmentSignedDecodeErrorZ&& o) { CResult_CommitmentSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); return *this; }
6938         LDKCResult_CommitmentSignedDecodeErrorZ* operator &() { return &self; }
6939         LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() { return &self; }
6940         const LDKCResult_CommitmentSignedDecodeErrorZ* operator &() const { return &self; }
6941         const LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() const { return &self; }
6942 };
6943 class CResult_CommitmentTransactionDecodeErrorZ {
6944 private:
6945         LDKCResult_CommitmentTransactionDecodeErrorZ self;
6946 public:
6947         CResult_CommitmentTransactionDecodeErrorZ(const CResult_CommitmentTransactionDecodeErrorZ&) = delete;
6948         CResult_CommitmentTransactionDecodeErrorZ(CResult_CommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); }
6949         CResult_CommitmentTransactionDecodeErrorZ(LDKCResult_CommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); }
6950         operator LDKCResult_CommitmentTransactionDecodeErrorZ() && { LDKCResult_CommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); return res; }
6951         ~CResult_CommitmentTransactionDecodeErrorZ() { CResult_CommitmentTransactionDecodeErrorZ_free(self); }
6952         CResult_CommitmentTransactionDecodeErrorZ& operator=(CResult_CommitmentTransactionDecodeErrorZ&& o) { CResult_CommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); return *this; }
6953         LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() { return &self; }
6954         LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
6955         const LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
6956         const LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
6957 };
6958 class CResult_StfuDecodeErrorZ {
6959 private:
6960         LDKCResult_StfuDecodeErrorZ self;
6961 public:
6962         CResult_StfuDecodeErrorZ(const CResult_StfuDecodeErrorZ&) = delete;
6963         CResult_StfuDecodeErrorZ(CResult_StfuDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StfuDecodeErrorZ)); }
6964         CResult_StfuDecodeErrorZ(LDKCResult_StfuDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StfuDecodeErrorZ)); }
6965         operator LDKCResult_StfuDecodeErrorZ() && { LDKCResult_StfuDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StfuDecodeErrorZ)); return res; }
6966         ~CResult_StfuDecodeErrorZ() { CResult_StfuDecodeErrorZ_free(self); }
6967         CResult_StfuDecodeErrorZ& operator=(CResult_StfuDecodeErrorZ&& o) { CResult_StfuDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StfuDecodeErrorZ)); return *this; }
6968         LDKCResult_StfuDecodeErrorZ* operator &() { return &self; }
6969         LDKCResult_StfuDecodeErrorZ* operator ->() { return &self; }
6970         const LDKCResult_StfuDecodeErrorZ* operator &() const { return &self; }
6971         const LDKCResult_StfuDecodeErrorZ* operator ->() const { return &self; }
6972 };
6973 class CResult_OpenChannelDecodeErrorZ {
6974 private:
6975         LDKCResult_OpenChannelDecodeErrorZ self;
6976 public:
6977         CResult_OpenChannelDecodeErrorZ(const CResult_OpenChannelDecodeErrorZ&) = delete;
6978         CResult_OpenChannelDecodeErrorZ(CResult_OpenChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); }
6979         CResult_OpenChannelDecodeErrorZ(LDKCResult_OpenChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); }
6980         operator LDKCResult_OpenChannelDecodeErrorZ() && { LDKCResult_OpenChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); return res; }
6981         ~CResult_OpenChannelDecodeErrorZ() { CResult_OpenChannelDecodeErrorZ_free(self); }
6982         CResult_OpenChannelDecodeErrorZ& operator=(CResult_OpenChannelDecodeErrorZ&& o) { CResult_OpenChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); return *this; }
6983         LDKCResult_OpenChannelDecodeErrorZ* operator &() { return &self; }
6984         LDKCResult_OpenChannelDecodeErrorZ* operator ->() { return &self; }
6985         const LDKCResult_OpenChannelDecodeErrorZ* operator &() const { return &self; }
6986         const LDKCResult_OpenChannelDecodeErrorZ* operator ->() const { return &self; }
6987 };
6988 class CResult_ErrorMessageDecodeErrorZ {
6989 private:
6990         LDKCResult_ErrorMessageDecodeErrorZ self;
6991 public:
6992         CResult_ErrorMessageDecodeErrorZ(const CResult_ErrorMessageDecodeErrorZ&) = delete;
6993         CResult_ErrorMessageDecodeErrorZ(CResult_ErrorMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); }
6994         CResult_ErrorMessageDecodeErrorZ(LDKCResult_ErrorMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); }
6995         operator LDKCResult_ErrorMessageDecodeErrorZ() && { LDKCResult_ErrorMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); return res; }
6996         ~CResult_ErrorMessageDecodeErrorZ() { CResult_ErrorMessageDecodeErrorZ_free(self); }
6997         CResult_ErrorMessageDecodeErrorZ& operator=(CResult_ErrorMessageDecodeErrorZ&& o) { CResult_ErrorMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); return *this; }
6998         LDKCResult_ErrorMessageDecodeErrorZ* operator &() { return &self; }
6999         LDKCResult_ErrorMessageDecodeErrorZ* operator ->() { return &self; }
7000         const LDKCResult_ErrorMessageDecodeErrorZ* operator &() const { return &self; }
7001         const LDKCResult_ErrorMessageDecodeErrorZ* operator ->() const { return &self; }
7002 };
7003 class COption_APIErrorZ {
7004 private:
7005         LDKCOption_APIErrorZ self;
7006 public:
7007         COption_APIErrorZ(const COption_APIErrorZ&) = delete;
7008         COption_APIErrorZ(COption_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_APIErrorZ)); }
7009         COption_APIErrorZ(LDKCOption_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_APIErrorZ)); }
7010         operator LDKCOption_APIErrorZ() && { LDKCOption_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCOption_APIErrorZ)); return res; }
7011         ~COption_APIErrorZ() { COption_APIErrorZ_free(self); }
7012         COption_APIErrorZ& operator=(COption_APIErrorZ&& o) { COption_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_APIErrorZ)); return *this; }
7013         LDKCOption_APIErrorZ* operator &() { return &self; }
7014         LDKCOption_APIErrorZ* operator ->() { return &self; }
7015         const LDKCOption_APIErrorZ* operator &() const { return &self; }
7016         const LDKCOption_APIErrorZ* operator ->() const { return &self; }
7017 };
7018 class CResult_QueryChannelRangeDecodeErrorZ {
7019 private:
7020         LDKCResult_QueryChannelRangeDecodeErrorZ self;
7021 public:
7022         CResult_QueryChannelRangeDecodeErrorZ(const CResult_QueryChannelRangeDecodeErrorZ&) = delete;
7023         CResult_QueryChannelRangeDecodeErrorZ(CResult_QueryChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); }
7024         CResult_QueryChannelRangeDecodeErrorZ(LDKCResult_QueryChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); }
7025         operator LDKCResult_QueryChannelRangeDecodeErrorZ() && { LDKCResult_QueryChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); return res; }
7026         ~CResult_QueryChannelRangeDecodeErrorZ() { CResult_QueryChannelRangeDecodeErrorZ_free(self); }
7027         CResult_QueryChannelRangeDecodeErrorZ& operator=(CResult_QueryChannelRangeDecodeErrorZ&& o) { CResult_QueryChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); return *this; }
7028         LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() { return &self; }
7029         LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() { return &self; }
7030         const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
7031         const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
7032 };
7033 class CVec_TransactionZ {
7034 private:
7035         LDKCVec_TransactionZ self;
7036 public:
7037         CVec_TransactionZ(const CVec_TransactionZ&) = delete;
7038         CVec_TransactionZ(CVec_TransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionZ)); }
7039         CVec_TransactionZ(LDKCVec_TransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionZ)); }
7040         operator LDKCVec_TransactionZ() && { LDKCVec_TransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionZ)); return res; }
7041         ~CVec_TransactionZ() { CVec_TransactionZ_free(self); }
7042         CVec_TransactionZ& operator=(CVec_TransactionZ&& o) { CVec_TransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionZ)); return *this; }
7043         LDKCVec_TransactionZ* operator &() { return &self; }
7044         LDKCVec_TransactionZ* operator ->() { return &self; }
7045         const LDKCVec_TransactionZ* operator &() const { return &self; }
7046         const LDKCVec_TransactionZ* operator ->() const { return &self; }
7047 };
7048 class CVec_InputZ {
7049 private:
7050         LDKCVec_InputZ self;
7051 public:
7052         CVec_InputZ(const CVec_InputZ&) = delete;
7053         CVec_InputZ(CVec_InputZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_InputZ)); }
7054         CVec_InputZ(LDKCVec_InputZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_InputZ)); }
7055         operator LDKCVec_InputZ() && { LDKCVec_InputZ res = self; memset(&self, 0, sizeof(LDKCVec_InputZ)); return res; }
7056         ~CVec_InputZ() { CVec_InputZ_free(self); }
7057         CVec_InputZ& operator=(CVec_InputZ&& o) { CVec_InputZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_InputZ)); return *this; }
7058         LDKCVec_InputZ* operator &() { return &self; }
7059         LDKCVec_InputZ* operator ->() { return &self; }
7060         const LDKCVec_InputZ* operator &() const { return &self; }
7061         const LDKCVec_InputZ* operator ->() const { return &self; }
7062 };
7063 class CResult_ChannelFeaturesDecodeErrorZ {
7064 private:
7065         LDKCResult_ChannelFeaturesDecodeErrorZ self;
7066 public:
7067         CResult_ChannelFeaturesDecodeErrorZ(const CResult_ChannelFeaturesDecodeErrorZ&) = delete;
7068         CResult_ChannelFeaturesDecodeErrorZ(CResult_ChannelFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); }
7069         CResult_ChannelFeaturesDecodeErrorZ(LDKCResult_ChannelFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); }
7070         operator LDKCResult_ChannelFeaturesDecodeErrorZ() && { LDKCResult_ChannelFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); return res; }
7071         ~CResult_ChannelFeaturesDecodeErrorZ() { CResult_ChannelFeaturesDecodeErrorZ_free(self); }
7072         CResult_ChannelFeaturesDecodeErrorZ& operator=(CResult_ChannelFeaturesDecodeErrorZ&& o) { CResult_ChannelFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); return *this; }
7073         LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() { return &self; }
7074         LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() { return &self; }
7075         const LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() const { return &self; }
7076         const LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() const { return &self; }
7077 };
7078 class CResult_ChannelReadyDecodeErrorZ {
7079 private:
7080         LDKCResult_ChannelReadyDecodeErrorZ self;
7081 public:
7082         CResult_ChannelReadyDecodeErrorZ(const CResult_ChannelReadyDecodeErrorZ&) = delete;
7083         CResult_ChannelReadyDecodeErrorZ(CResult_ChannelReadyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelReadyDecodeErrorZ)); }
7084         CResult_ChannelReadyDecodeErrorZ(LDKCResult_ChannelReadyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelReadyDecodeErrorZ)); }
7085         operator LDKCResult_ChannelReadyDecodeErrorZ() && { LDKCResult_ChannelReadyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelReadyDecodeErrorZ)); return res; }
7086         ~CResult_ChannelReadyDecodeErrorZ() { CResult_ChannelReadyDecodeErrorZ_free(self); }
7087         CResult_ChannelReadyDecodeErrorZ& operator=(CResult_ChannelReadyDecodeErrorZ&& o) { CResult_ChannelReadyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelReadyDecodeErrorZ)); return *this; }
7088         LDKCResult_ChannelReadyDecodeErrorZ* operator &() { return &self; }
7089         LDKCResult_ChannelReadyDecodeErrorZ* operator ->() { return &self; }
7090         const LDKCResult_ChannelReadyDecodeErrorZ* operator &() const { return &self; }
7091         const LDKCResult_ChannelReadyDecodeErrorZ* operator ->() const { return &self; }
7092 };
7093 class CResult_RevocationBasepointDecodeErrorZ {
7094 private:
7095         LDKCResult_RevocationBasepointDecodeErrorZ self;
7096 public:
7097         CResult_RevocationBasepointDecodeErrorZ(const CResult_RevocationBasepointDecodeErrorZ&) = delete;
7098         CResult_RevocationBasepointDecodeErrorZ(CResult_RevocationBasepointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevocationBasepointDecodeErrorZ)); }
7099         CResult_RevocationBasepointDecodeErrorZ(LDKCResult_RevocationBasepointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevocationBasepointDecodeErrorZ)); }
7100         operator LDKCResult_RevocationBasepointDecodeErrorZ() && { LDKCResult_RevocationBasepointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevocationBasepointDecodeErrorZ)); return res; }
7101         ~CResult_RevocationBasepointDecodeErrorZ() { CResult_RevocationBasepointDecodeErrorZ_free(self); }
7102         CResult_RevocationBasepointDecodeErrorZ& operator=(CResult_RevocationBasepointDecodeErrorZ&& o) { CResult_RevocationBasepointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevocationBasepointDecodeErrorZ)); return *this; }
7103         LDKCResult_RevocationBasepointDecodeErrorZ* operator &() { return &self; }
7104         LDKCResult_RevocationBasepointDecodeErrorZ* operator ->() { return &self; }
7105         const LDKCResult_RevocationBasepointDecodeErrorZ* operator &() const { return &self; }
7106         const LDKCResult_RevocationBasepointDecodeErrorZ* operator ->() const { return &self; }
7107 };
7108 class CResult_UpdateFeeDecodeErrorZ {
7109 private:
7110         LDKCResult_UpdateFeeDecodeErrorZ self;
7111 public:
7112         CResult_UpdateFeeDecodeErrorZ(const CResult_UpdateFeeDecodeErrorZ&) = delete;
7113         CResult_UpdateFeeDecodeErrorZ(CResult_UpdateFeeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); }
7114         CResult_UpdateFeeDecodeErrorZ(LDKCResult_UpdateFeeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); }
7115         operator LDKCResult_UpdateFeeDecodeErrorZ() && { LDKCResult_UpdateFeeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); return res; }
7116         ~CResult_UpdateFeeDecodeErrorZ() { CResult_UpdateFeeDecodeErrorZ_free(self); }
7117         CResult_UpdateFeeDecodeErrorZ& operator=(CResult_UpdateFeeDecodeErrorZ&& o) { CResult_UpdateFeeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); return *this; }
7118         LDKCResult_UpdateFeeDecodeErrorZ* operator &() { return &self; }
7119         LDKCResult_UpdateFeeDecodeErrorZ* operator ->() { return &self; }
7120         const LDKCResult_UpdateFeeDecodeErrorZ* operator &() const { return &self; }
7121         const LDKCResult_UpdateFeeDecodeErrorZ* operator ->() const { return &self; }
7122 };
7123 class CResult_NoneBolt11SemanticErrorZ {
7124 private:
7125         LDKCResult_NoneBolt11SemanticErrorZ self;
7126 public:
7127         CResult_NoneBolt11SemanticErrorZ(const CResult_NoneBolt11SemanticErrorZ&) = delete;
7128         CResult_NoneBolt11SemanticErrorZ(CResult_NoneBolt11SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneBolt11SemanticErrorZ)); }
7129         CResult_NoneBolt11SemanticErrorZ(LDKCResult_NoneBolt11SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneBolt11SemanticErrorZ)); }
7130         operator LDKCResult_NoneBolt11SemanticErrorZ() && { LDKCResult_NoneBolt11SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneBolt11SemanticErrorZ)); return res; }
7131         ~CResult_NoneBolt11SemanticErrorZ() { CResult_NoneBolt11SemanticErrorZ_free(self); }
7132         CResult_NoneBolt11SemanticErrorZ& operator=(CResult_NoneBolt11SemanticErrorZ&& o) { CResult_NoneBolt11SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneBolt11SemanticErrorZ)); return *this; }
7133         LDKCResult_NoneBolt11SemanticErrorZ* operator &() { return &self; }
7134         LDKCResult_NoneBolt11SemanticErrorZ* operator ->() { return &self; }
7135         const LDKCResult_NoneBolt11SemanticErrorZ* operator &() const { return &self; }
7136         const LDKCResult_NoneBolt11SemanticErrorZ* operator ->() const { return &self; }
7137 };
7138 class COption_OnionMessageContentsZ {
7139 private:
7140         LDKCOption_OnionMessageContentsZ self;
7141 public:
7142         COption_OnionMessageContentsZ(const COption_OnionMessageContentsZ&) = delete;
7143         COption_OnionMessageContentsZ(COption_OnionMessageContentsZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_OnionMessageContentsZ)); }
7144         COption_OnionMessageContentsZ(LDKCOption_OnionMessageContentsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_OnionMessageContentsZ)); }
7145         operator LDKCOption_OnionMessageContentsZ() && { LDKCOption_OnionMessageContentsZ res = self; memset(&self, 0, sizeof(LDKCOption_OnionMessageContentsZ)); return res; }
7146         ~COption_OnionMessageContentsZ() { COption_OnionMessageContentsZ_free(self); }
7147         COption_OnionMessageContentsZ& operator=(COption_OnionMessageContentsZ&& o) { COption_OnionMessageContentsZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_OnionMessageContentsZ)); return *this; }
7148         LDKCOption_OnionMessageContentsZ* operator &() { return &self; }
7149         LDKCOption_OnionMessageContentsZ* operator ->() { return &self; }
7150         const LDKCOption_OnionMessageContentsZ* operator &() const { return &self; }
7151         const LDKCOption_OnionMessageContentsZ* operator ->() const { return &self; }
7152 };
7153 class CResult_NoneRetryableSendFailureZ {
7154 private:
7155         LDKCResult_NoneRetryableSendFailureZ self;
7156 public:
7157         CResult_NoneRetryableSendFailureZ(const CResult_NoneRetryableSendFailureZ&) = delete;
7158         CResult_NoneRetryableSendFailureZ(CResult_NoneRetryableSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneRetryableSendFailureZ)); }
7159         CResult_NoneRetryableSendFailureZ(LDKCResult_NoneRetryableSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneRetryableSendFailureZ)); }
7160         operator LDKCResult_NoneRetryableSendFailureZ() && { LDKCResult_NoneRetryableSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneRetryableSendFailureZ)); return res; }
7161         ~CResult_NoneRetryableSendFailureZ() { CResult_NoneRetryableSendFailureZ_free(self); }
7162         CResult_NoneRetryableSendFailureZ& operator=(CResult_NoneRetryableSendFailureZ&& o) { CResult_NoneRetryableSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneRetryableSendFailureZ)); return *this; }
7163         LDKCResult_NoneRetryableSendFailureZ* operator &() { return &self; }
7164         LDKCResult_NoneRetryableSendFailureZ* operator ->() { return &self; }
7165         const LDKCResult_NoneRetryableSendFailureZ* operator &() const { return &self; }
7166         const LDKCResult_NoneRetryableSendFailureZ* operator ->() const { return &self; }
7167 };
7168 class CResult_boolLightningErrorZ {
7169 private:
7170         LDKCResult_boolLightningErrorZ self;
7171 public:
7172         CResult_boolLightningErrorZ(const CResult_boolLightningErrorZ&) = delete;
7173         CResult_boolLightningErrorZ(CResult_boolLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); }
7174         CResult_boolLightningErrorZ(LDKCResult_boolLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolLightningErrorZ)); }
7175         operator LDKCResult_boolLightningErrorZ() && { LDKCResult_boolLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolLightningErrorZ)); return res; }
7176         ~CResult_boolLightningErrorZ() { CResult_boolLightningErrorZ_free(self); }
7177         CResult_boolLightningErrorZ& operator=(CResult_boolLightningErrorZ&& o) { CResult_boolLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); return *this; }
7178         LDKCResult_boolLightningErrorZ* operator &() { return &self; }
7179         LDKCResult_boolLightningErrorZ* operator ->() { return &self; }
7180         const LDKCResult_boolLightningErrorZ* operator &() const { return &self; }
7181         const LDKCResult_boolLightningErrorZ* operator ->() const { return &self; }
7182 };
7183 class CResult_NodeIdDecodeErrorZ {
7184 private:
7185         LDKCResult_NodeIdDecodeErrorZ self;
7186 public:
7187         CResult_NodeIdDecodeErrorZ(const CResult_NodeIdDecodeErrorZ&) = delete;
7188         CResult_NodeIdDecodeErrorZ(CResult_NodeIdDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); }
7189         CResult_NodeIdDecodeErrorZ(LDKCResult_NodeIdDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); }
7190         operator LDKCResult_NodeIdDecodeErrorZ() && { LDKCResult_NodeIdDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); return res; }
7191         ~CResult_NodeIdDecodeErrorZ() { CResult_NodeIdDecodeErrorZ_free(self); }
7192         CResult_NodeIdDecodeErrorZ& operator=(CResult_NodeIdDecodeErrorZ&& o) { CResult_NodeIdDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); return *this; }
7193         LDKCResult_NodeIdDecodeErrorZ* operator &() { return &self; }
7194         LDKCResult_NodeIdDecodeErrorZ* operator ->() { return &self; }
7195         const LDKCResult_NodeIdDecodeErrorZ* operator &() const { return &self; }
7196         const LDKCResult_NodeIdDecodeErrorZ* operator ->() const { return &self; }
7197 };
7198 class CResult_ChannelShutdownStateDecodeErrorZ {
7199 private:
7200         LDKCResult_ChannelShutdownStateDecodeErrorZ self;
7201 public:
7202         CResult_ChannelShutdownStateDecodeErrorZ(const CResult_ChannelShutdownStateDecodeErrorZ&) = delete;
7203         CResult_ChannelShutdownStateDecodeErrorZ(CResult_ChannelShutdownStateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelShutdownStateDecodeErrorZ)); }
7204         CResult_ChannelShutdownStateDecodeErrorZ(LDKCResult_ChannelShutdownStateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelShutdownStateDecodeErrorZ)); }
7205         operator LDKCResult_ChannelShutdownStateDecodeErrorZ() && { LDKCResult_ChannelShutdownStateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelShutdownStateDecodeErrorZ)); return res; }
7206         ~CResult_ChannelShutdownStateDecodeErrorZ() { CResult_ChannelShutdownStateDecodeErrorZ_free(self); }
7207         CResult_ChannelShutdownStateDecodeErrorZ& operator=(CResult_ChannelShutdownStateDecodeErrorZ&& o) { CResult_ChannelShutdownStateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelShutdownStateDecodeErrorZ)); return *this; }
7208         LDKCResult_ChannelShutdownStateDecodeErrorZ* operator &() { return &self; }
7209         LDKCResult_ChannelShutdownStateDecodeErrorZ* operator ->() { return &self; }
7210         const LDKCResult_ChannelShutdownStateDecodeErrorZ* operator &() const { return &self; }
7211         const LDKCResult_ChannelShutdownStateDecodeErrorZ* operator ->() const { return &self; }
7212 };
7213 class CResult_HTLCOutputInCommitmentDecodeErrorZ {
7214 private:
7215         LDKCResult_HTLCOutputInCommitmentDecodeErrorZ self;
7216 public:
7217         CResult_HTLCOutputInCommitmentDecodeErrorZ(const CResult_HTLCOutputInCommitmentDecodeErrorZ&) = delete;
7218         CResult_HTLCOutputInCommitmentDecodeErrorZ(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); }
7219         CResult_HTLCOutputInCommitmentDecodeErrorZ(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); }
7220         operator LDKCResult_HTLCOutputInCommitmentDecodeErrorZ() && { LDKCResult_HTLCOutputInCommitmentDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); return res; }
7221         ~CResult_HTLCOutputInCommitmentDecodeErrorZ() { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); }
7222         CResult_HTLCOutputInCommitmentDecodeErrorZ& operator=(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); return *this; }
7223         LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() { return &self; }
7224         LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() { return &self; }
7225         const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() const { return &self; }
7226         const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() const { return &self; }
7227 };
7228 class CResult_NodeAnnouncementInfoDecodeErrorZ {
7229 private:
7230         LDKCResult_NodeAnnouncementInfoDecodeErrorZ self;
7231 public:
7232         CResult_NodeAnnouncementInfoDecodeErrorZ(const CResult_NodeAnnouncementInfoDecodeErrorZ&) = delete;
7233         CResult_NodeAnnouncementInfoDecodeErrorZ(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); }
7234         CResult_NodeAnnouncementInfoDecodeErrorZ(LDKCResult_NodeAnnouncementInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); }
7235         operator LDKCResult_NodeAnnouncementInfoDecodeErrorZ() && { LDKCResult_NodeAnnouncementInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); return res; }
7236         ~CResult_NodeAnnouncementInfoDecodeErrorZ() { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); }
7237         CResult_NodeAnnouncementInfoDecodeErrorZ& operator=(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); return *this; }
7238         LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() { return &self; }
7239         LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() { return &self; }
7240         const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() const { return &self; }
7241         const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() const { return &self; }
7242 };
7243 class CResult_ShutdownScriptInvalidShutdownScriptZ {
7244 private:
7245         LDKCResult_ShutdownScriptInvalidShutdownScriptZ self;
7246 public:
7247         CResult_ShutdownScriptInvalidShutdownScriptZ(const CResult_ShutdownScriptInvalidShutdownScriptZ&) = delete;
7248         CResult_ShutdownScriptInvalidShutdownScriptZ(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); }
7249         CResult_ShutdownScriptInvalidShutdownScriptZ(LDKCResult_ShutdownScriptInvalidShutdownScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); }
7250         operator LDKCResult_ShutdownScriptInvalidShutdownScriptZ() && { LDKCResult_ShutdownScriptInvalidShutdownScriptZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); return res; }
7251         ~CResult_ShutdownScriptInvalidShutdownScriptZ() { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); }
7252         CResult_ShutdownScriptInvalidShutdownScriptZ& operator=(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); return *this; }
7253         LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() { return &self; }
7254         LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() { return &self; }
7255         const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() const { return &self; }
7256         const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() const { return &self; }
7257 };
7258 class CResult_COption_NetworkUpdateZDecodeErrorZ {
7259 private:
7260         LDKCResult_COption_NetworkUpdateZDecodeErrorZ self;
7261 public:
7262         CResult_COption_NetworkUpdateZDecodeErrorZ(const CResult_COption_NetworkUpdateZDecodeErrorZ&) = delete;
7263         CResult_COption_NetworkUpdateZDecodeErrorZ(CResult_COption_NetworkUpdateZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_NetworkUpdateZDecodeErrorZ)); }
7264         CResult_COption_NetworkUpdateZDecodeErrorZ(LDKCResult_COption_NetworkUpdateZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); }
7265         operator LDKCResult_COption_NetworkUpdateZDecodeErrorZ() && { LDKCResult_COption_NetworkUpdateZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); return res; }
7266         ~CResult_COption_NetworkUpdateZDecodeErrorZ() { CResult_COption_NetworkUpdateZDecodeErrorZ_free(self); }
7267         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; }
7268         LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() { return &self; }
7269         LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() { return &self; }
7270         const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() const { return &self; }
7271         const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() const { return &self; }
7272 };
7273 class CVec_UpdateFailMalformedHTLCZ {
7274 private:
7275         LDKCVec_UpdateFailMalformedHTLCZ self;
7276 public:
7277         CVec_UpdateFailMalformedHTLCZ(const CVec_UpdateFailMalformedHTLCZ&) = delete;
7278         CVec_UpdateFailMalformedHTLCZ(CVec_UpdateFailMalformedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); }
7279         CVec_UpdateFailMalformedHTLCZ(LDKCVec_UpdateFailMalformedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); }
7280         operator LDKCVec_UpdateFailMalformedHTLCZ() && { LDKCVec_UpdateFailMalformedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); return res; }
7281         ~CVec_UpdateFailMalformedHTLCZ() { CVec_UpdateFailMalformedHTLCZ_free(self); }
7282         CVec_UpdateFailMalformedHTLCZ& operator=(CVec_UpdateFailMalformedHTLCZ&& o) { CVec_UpdateFailMalformedHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); return *this; }
7283         LDKCVec_UpdateFailMalformedHTLCZ* operator &() { return &self; }
7284         LDKCVec_UpdateFailMalformedHTLCZ* operator ->() { return &self; }
7285         const LDKCVec_UpdateFailMalformedHTLCZ* operator &() const { return &self; }
7286         const LDKCVec_UpdateFailMalformedHTLCZ* operator ->() const { return &self; }
7287 };
7288 class CResult_ShutdownScriptNoneZ {
7289 private:
7290         LDKCResult_ShutdownScriptNoneZ self;
7291 public:
7292         CResult_ShutdownScriptNoneZ(const CResult_ShutdownScriptNoneZ&) = delete;
7293         CResult_ShutdownScriptNoneZ(CResult_ShutdownScriptNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptNoneZ)); }
7294         CResult_ShutdownScriptNoneZ(LDKCResult_ShutdownScriptNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptNoneZ)); }
7295         operator LDKCResult_ShutdownScriptNoneZ() && { LDKCResult_ShutdownScriptNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptNoneZ)); return res; }
7296         ~CResult_ShutdownScriptNoneZ() { CResult_ShutdownScriptNoneZ_free(self); }
7297         CResult_ShutdownScriptNoneZ& operator=(CResult_ShutdownScriptNoneZ&& o) { CResult_ShutdownScriptNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptNoneZ)); return *this; }
7298         LDKCResult_ShutdownScriptNoneZ* operator &() { return &self; }
7299         LDKCResult_ShutdownScriptNoneZ* operator ->() { return &self; }
7300         const LDKCResult_ShutdownScriptNoneZ* operator &() const { return &self; }
7301         const LDKCResult_ShutdownScriptNoneZ* operator ->() const { return &self; }
7302 };
7303 class CResult_PendingHTLCInfoInboundHTLCErrZ {
7304 private:
7305         LDKCResult_PendingHTLCInfoInboundHTLCErrZ self;
7306 public:
7307         CResult_PendingHTLCInfoInboundHTLCErrZ(const CResult_PendingHTLCInfoInboundHTLCErrZ&) = delete;
7308         CResult_PendingHTLCInfoInboundHTLCErrZ(CResult_PendingHTLCInfoInboundHTLCErrZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PendingHTLCInfoInboundHTLCErrZ)); }
7309         CResult_PendingHTLCInfoInboundHTLCErrZ(LDKCResult_PendingHTLCInfoInboundHTLCErrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PendingHTLCInfoInboundHTLCErrZ)); }
7310         operator LDKCResult_PendingHTLCInfoInboundHTLCErrZ() && { LDKCResult_PendingHTLCInfoInboundHTLCErrZ res = self; memset(&self, 0, sizeof(LDKCResult_PendingHTLCInfoInboundHTLCErrZ)); return res; }
7311         ~CResult_PendingHTLCInfoInboundHTLCErrZ() { CResult_PendingHTLCInfoInboundHTLCErrZ_free(self); }
7312         CResult_PendingHTLCInfoInboundHTLCErrZ& operator=(CResult_PendingHTLCInfoInboundHTLCErrZ&& o) { CResult_PendingHTLCInfoInboundHTLCErrZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PendingHTLCInfoInboundHTLCErrZ)); return *this; }
7313         LDKCResult_PendingHTLCInfoInboundHTLCErrZ* operator &() { return &self; }
7314         LDKCResult_PendingHTLCInfoInboundHTLCErrZ* operator ->() { return &self; }
7315         const LDKCResult_PendingHTLCInfoInboundHTLCErrZ* operator &() const { return &self; }
7316         const LDKCResult_PendingHTLCInfoInboundHTLCErrZ* operator ->() const { return &self; }
7317 };
7318 class CResult_PendingHTLCInfoDecodeErrorZ {
7319 private:
7320         LDKCResult_PendingHTLCInfoDecodeErrorZ self;
7321 public:
7322         CResult_PendingHTLCInfoDecodeErrorZ(const CResult_PendingHTLCInfoDecodeErrorZ&) = delete;
7323         CResult_PendingHTLCInfoDecodeErrorZ(CResult_PendingHTLCInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PendingHTLCInfoDecodeErrorZ)); }
7324         CResult_PendingHTLCInfoDecodeErrorZ(LDKCResult_PendingHTLCInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PendingHTLCInfoDecodeErrorZ)); }
7325         operator LDKCResult_PendingHTLCInfoDecodeErrorZ() && { LDKCResult_PendingHTLCInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PendingHTLCInfoDecodeErrorZ)); return res; }
7326         ~CResult_PendingHTLCInfoDecodeErrorZ() { CResult_PendingHTLCInfoDecodeErrorZ_free(self); }
7327         CResult_PendingHTLCInfoDecodeErrorZ& operator=(CResult_PendingHTLCInfoDecodeErrorZ&& o) { CResult_PendingHTLCInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PendingHTLCInfoDecodeErrorZ)); return *this; }
7328         LDKCResult_PendingHTLCInfoDecodeErrorZ* operator &() { return &self; }
7329         LDKCResult_PendingHTLCInfoDecodeErrorZ* operator ->() { return &self; }
7330         const LDKCResult_PendingHTLCInfoDecodeErrorZ* operator &() const { return &self; }
7331         const LDKCResult_PendingHTLCInfoDecodeErrorZ* operator ->() const { return &self; }
7332 };
7333 class COption_HTLCDestinationZ {
7334 private:
7335         LDKCOption_HTLCDestinationZ self;
7336 public:
7337         COption_HTLCDestinationZ(const COption_HTLCDestinationZ&) = delete;
7338         COption_HTLCDestinationZ(COption_HTLCDestinationZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_HTLCDestinationZ)); }
7339         COption_HTLCDestinationZ(LDKCOption_HTLCDestinationZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_HTLCDestinationZ)); }
7340         operator LDKCOption_HTLCDestinationZ() && { LDKCOption_HTLCDestinationZ res = self; memset(&self, 0, sizeof(LDKCOption_HTLCDestinationZ)); return res; }
7341         ~COption_HTLCDestinationZ() { COption_HTLCDestinationZ_free(self); }
7342         COption_HTLCDestinationZ& operator=(COption_HTLCDestinationZ&& o) { COption_HTLCDestinationZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_HTLCDestinationZ)); return *this; }
7343         LDKCOption_HTLCDestinationZ* operator &() { return &self; }
7344         LDKCOption_HTLCDestinationZ* operator ->() { return &self; }
7345         const LDKCOption_HTLCDestinationZ* operator &() const { return &self; }
7346         const LDKCOption_HTLCDestinationZ* operator ->() const { return &self; }
7347 };
7348 class CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ {
7349 private:
7350         LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ self;
7351 public:
7352         CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ(const CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ&) = delete;
7353         CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ(CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ)); }
7354         CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ)); }
7355         operator LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ() && { LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ)); return res; }
7356         ~CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ() { CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_free(self); }
7357         CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ& operator=(CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ&& o) { CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ)); return *this; }
7358         LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ* operator &() { return &self; }
7359         LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ* operator ->() { return &self; }
7360         const LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ* operator &() const { return &self; }
7361         const LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ* operator ->() const { return &self; }
7362 };
7363 class CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ {
7364 private:
7365         LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ self;
7366 public:
7367         CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(const CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&) = delete;
7368         CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); }
7369         CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); }
7370         operator LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ() && { LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); return res; }
7371         ~CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ() { CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(self); }
7372         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; }
7373         LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator &() { return &self; }
7374         LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator ->() { return &self; }
7375         const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator &() const { return &self; }
7376         const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator ->() const { return &self; }
7377 };
7378 class CVec_RouteHopZ {
7379 private:
7380         LDKCVec_RouteHopZ self;
7381 public:
7382         CVec_RouteHopZ(const CVec_RouteHopZ&) = delete;
7383         CVec_RouteHopZ(CVec_RouteHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHopZ)); }
7384         CVec_RouteHopZ(LDKCVec_RouteHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHopZ)); }
7385         operator LDKCVec_RouteHopZ() && { LDKCVec_RouteHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHopZ)); return res; }
7386         ~CVec_RouteHopZ() { CVec_RouteHopZ_free(self); }
7387         CVec_RouteHopZ& operator=(CVec_RouteHopZ&& o) { CVec_RouteHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHopZ)); return *this; }
7388         LDKCVec_RouteHopZ* operator &() { return &self; }
7389         LDKCVec_RouteHopZ* operator ->() { return &self; }
7390         const LDKCVec_RouteHopZ* operator &() const { return &self; }
7391         const LDKCVec_RouteHopZ* operator ->() const { return &self; }
7392 };
7393 class C2Tuple_PublicKeyCVec_SocketAddressZZ {
7394 private:
7395         LDKC2Tuple_PublicKeyCVec_SocketAddressZZ self;
7396 public:
7397         C2Tuple_PublicKeyCVec_SocketAddressZZ(const C2Tuple_PublicKeyCVec_SocketAddressZZ&) = delete;
7398         C2Tuple_PublicKeyCVec_SocketAddressZZ(C2Tuple_PublicKeyCVec_SocketAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyCVec_SocketAddressZZ)); }
7399         C2Tuple_PublicKeyCVec_SocketAddressZZ(LDKC2Tuple_PublicKeyCVec_SocketAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyCVec_SocketAddressZZ)); }
7400         operator LDKC2Tuple_PublicKeyCVec_SocketAddressZZ() && { LDKC2Tuple_PublicKeyCVec_SocketAddressZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyCVec_SocketAddressZZ)); return res; }
7401         ~C2Tuple_PublicKeyCVec_SocketAddressZZ() { C2Tuple_PublicKeyCVec_SocketAddressZZ_free(self); }
7402         C2Tuple_PublicKeyCVec_SocketAddressZZ& operator=(C2Tuple_PublicKeyCVec_SocketAddressZZ&& o) { C2Tuple_PublicKeyCVec_SocketAddressZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyCVec_SocketAddressZZ)); return *this; }
7403         LDKC2Tuple_PublicKeyCVec_SocketAddressZZ* operator &() { return &self; }
7404         LDKC2Tuple_PublicKeyCVec_SocketAddressZZ* operator ->() { return &self; }
7405         const LDKC2Tuple_PublicKeyCVec_SocketAddressZZ* operator &() const { return &self; }
7406         const LDKC2Tuple_PublicKeyCVec_SocketAddressZZ* operator ->() const { return &self; }
7407 };
7408 class CResult_CVec_UtxoZNoneZ {
7409 private:
7410         LDKCResult_CVec_UtxoZNoneZ self;
7411 public:
7412         CResult_CVec_UtxoZNoneZ(const CResult_CVec_UtxoZNoneZ&) = delete;
7413         CResult_CVec_UtxoZNoneZ(CResult_CVec_UtxoZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_UtxoZNoneZ)); }
7414         CResult_CVec_UtxoZNoneZ(LDKCResult_CVec_UtxoZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_UtxoZNoneZ)); }
7415         operator LDKCResult_CVec_UtxoZNoneZ() && { LDKCResult_CVec_UtxoZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_UtxoZNoneZ)); return res; }
7416         ~CResult_CVec_UtxoZNoneZ() { CResult_CVec_UtxoZNoneZ_free(self); }
7417         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; }
7418         LDKCResult_CVec_UtxoZNoneZ* operator &() { return &self; }
7419         LDKCResult_CVec_UtxoZNoneZ* operator ->() { return &self; }
7420         const LDKCResult_CVec_UtxoZNoneZ* operator &() const { return &self; }
7421         const LDKCResult_CVec_UtxoZNoneZ* operator ->() const { return &self; }
7422 };
7423 class CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ {
7424 private:
7425         LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ self;
7426 public:
7427         CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ(const CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&) = delete;
7428         CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ(CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); }
7429         CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ(LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); }
7430         operator LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ() && { LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); return res; }
7431         ~CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ() { CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(self); }
7432         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; }
7433         LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator &() { return &self; }
7434         LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator ->() { return &self; }
7435         const LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator &() const { return &self; }
7436         const LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator ->() const { return &self; }
7437 };
7438 class CResult_CVec_u8ZIOErrorZ {
7439 private:
7440         LDKCResult_CVec_u8ZIOErrorZ self;
7441 public:
7442         CResult_CVec_u8ZIOErrorZ(const CResult_CVec_u8ZIOErrorZ&) = delete;
7443         CResult_CVec_u8ZIOErrorZ(CResult_CVec_u8ZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZIOErrorZ)); }
7444         CResult_CVec_u8ZIOErrorZ(LDKCResult_CVec_u8ZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZIOErrorZ)); }
7445         operator LDKCResult_CVec_u8ZIOErrorZ() && { LDKCResult_CVec_u8ZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZIOErrorZ)); return res; }
7446         ~CResult_CVec_u8ZIOErrorZ() { CResult_CVec_u8ZIOErrorZ_free(self); }
7447         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; }
7448         LDKCResult_CVec_u8ZIOErrorZ* operator &() { return &self; }
7449         LDKCResult_CVec_u8ZIOErrorZ* operator ->() { return &self; }
7450         const LDKCResult_CVec_u8ZIOErrorZ* operator &() const { return &self; }
7451         const LDKCResult_CVec_u8ZIOErrorZ* operator ->() const { return &self; }
7452 };
7453 class C3Tuple_OffersMessageDestinationBlindedPathZ {
7454 private:
7455         LDKC3Tuple_OffersMessageDestinationBlindedPathZ self;
7456 public:
7457         C3Tuple_OffersMessageDestinationBlindedPathZ(const C3Tuple_OffersMessageDestinationBlindedPathZ&) = delete;
7458         C3Tuple_OffersMessageDestinationBlindedPathZ(C3Tuple_OffersMessageDestinationBlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_OffersMessageDestinationBlindedPathZ)); }
7459         C3Tuple_OffersMessageDestinationBlindedPathZ(LDKC3Tuple_OffersMessageDestinationBlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_OffersMessageDestinationBlindedPathZ)); }
7460         operator LDKC3Tuple_OffersMessageDestinationBlindedPathZ() && { LDKC3Tuple_OffersMessageDestinationBlindedPathZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_OffersMessageDestinationBlindedPathZ)); return res; }
7461         ~C3Tuple_OffersMessageDestinationBlindedPathZ() { C3Tuple_OffersMessageDestinationBlindedPathZ_free(self); }
7462         C3Tuple_OffersMessageDestinationBlindedPathZ& operator=(C3Tuple_OffersMessageDestinationBlindedPathZ&& o) { C3Tuple_OffersMessageDestinationBlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_OffersMessageDestinationBlindedPathZ)); return *this; }
7463         LDKC3Tuple_OffersMessageDestinationBlindedPathZ* operator &() { return &self; }
7464         LDKC3Tuple_OffersMessageDestinationBlindedPathZ* operator ->() { return &self; }
7465         const LDKC3Tuple_OffersMessageDestinationBlindedPathZ* operator &() const { return &self; }
7466         const LDKC3Tuple_OffersMessageDestinationBlindedPathZ* operator ->() const { return &self; }
7467 };
7468 class CVec_ThirtyTwoBytesZ {
7469 private:
7470         LDKCVec_ThirtyTwoBytesZ self;
7471 public:
7472         CVec_ThirtyTwoBytesZ(const CVec_ThirtyTwoBytesZ&) = delete;
7473         CVec_ThirtyTwoBytesZ(CVec_ThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); }
7474         CVec_ThirtyTwoBytesZ(LDKCVec_ThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); }
7475         operator LDKCVec_ThirtyTwoBytesZ() && { LDKCVec_ThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); return res; }
7476         ~CVec_ThirtyTwoBytesZ() { CVec_ThirtyTwoBytesZ_free(self); }
7477         CVec_ThirtyTwoBytesZ& operator=(CVec_ThirtyTwoBytesZ&& o) { CVec_ThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); return *this; }
7478         LDKCVec_ThirtyTwoBytesZ* operator &() { return &self; }
7479         LDKCVec_ThirtyTwoBytesZ* operator ->() { return &self; }
7480         const LDKCVec_ThirtyTwoBytesZ* operator &() const { return &self; }
7481         const LDKCVec_ThirtyTwoBytesZ* operator ->() const { return &self; }
7482 };
7483 class CResult_ChannelMonitorUpdateStatusNoneZ {
7484 private:
7485         LDKCResult_ChannelMonitorUpdateStatusNoneZ self;
7486 public:
7487         CResult_ChannelMonitorUpdateStatusNoneZ(const CResult_ChannelMonitorUpdateStatusNoneZ&) = delete;
7488         CResult_ChannelMonitorUpdateStatusNoneZ(CResult_ChannelMonitorUpdateStatusNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateStatusNoneZ)); }
7489         CResult_ChannelMonitorUpdateStatusNoneZ(LDKCResult_ChannelMonitorUpdateStatusNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateStatusNoneZ)); }
7490         operator LDKCResult_ChannelMonitorUpdateStatusNoneZ() && { LDKCResult_ChannelMonitorUpdateStatusNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateStatusNoneZ)); return res; }
7491         ~CResult_ChannelMonitorUpdateStatusNoneZ() { CResult_ChannelMonitorUpdateStatusNoneZ_free(self); }
7492         CResult_ChannelMonitorUpdateStatusNoneZ& operator=(CResult_ChannelMonitorUpdateStatusNoneZ&& o) { CResult_ChannelMonitorUpdateStatusNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateStatusNoneZ)); return *this; }
7493         LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator &() { return &self; }
7494         LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator ->() { return &self; }
7495         const LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator &() const { return &self; }
7496         const LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator ->() const { return &self; }
7497 };
7498 class CResult_ClosingSignedDecodeErrorZ {
7499 private:
7500         LDKCResult_ClosingSignedDecodeErrorZ self;
7501 public:
7502         CResult_ClosingSignedDecodeErrorZ(const CResult_ClosingSignedDecodeErrorZ&) = delete;
7503         CResult_ClosingSignedDecodeErrorZ(CResult_ClosingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); }
7504         CResult_ClosingSignedDecodeErrorZ(LDKCResult_ClosingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); }
7505         operator LDKCResult_ClosingSignedDecodeErrorZ() && { LDKCResult_ClosingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); return res; }
7506         ~CResult_ClosingSignedDecodeErrorZ() { CResult_ClosingSignedDecodeErrorZ_free(self); }
7507         CResult_ClosingSignedDecodeErrorZ& operator=(CResult_ClosingSignedDecodeErrorZ&& o) { CResult_ClosingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); return *this; }
7508         LDKCResult_ClosingSignedDecodeErrorZ* operator &() { return &self; }
7509         LDKCResult_ClosingSignedDecodeErrorZ* operator ->() { return &self; }
7510         const LDKCResult_ClosingSignedDecodeErrorZ* operator &() const { return &self; }
7511         const LDKCResult_ClosingSignedDecodeErrorZ* operator ->() const { return &self; }
7512 };
7513 class CVec_CResult_NoneAPIErrorZZ {
7514 private:
7515         LDKCVec_CResult_NoneAPIErrorZZ self;
7516 public:
7517         CVec_CResult_NoneAPIErrorZZ(const CVec_CResult_NoneAPIErrorZZ&) = delete;
7518         CVec_CResult_NoneAPIErrorZZ(CVec_CResult_NoneAPIErrorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CResult_NoneAPIErrorZZ)); }
7519         CVec_CResult_NoneAPIErrorZZ(LDKCVec_CResult_NoneAPIErrorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); }
7520         operator LDKCVec_CResult_NoneAPIErrorZZ() && { LDKCVec_CResult_NoneAPIErrorZZ res = self; memset(&self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); return res; }
7521         ~CVec_CResult_NoneAPIErrorZZ() { CVec_CResult_NoneAPIErrorZZ_free(self); }
7522         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; }
7523         LDKCVec_CResult_NoneAPIErrorZZ* operator &() { return &self; }
7524         LDKCVec_CResult_NoneAPIErrorZZ* operator ->() { return &self; }
7525         const LDKCVec_CResult_NoneAPIErrorZZ* operator &() const { return &self; }
7526         const LDKCVec_CResult_NoneAPIErrorZZ* operator ->() const { return &self; }
7527 };
7528 class CResult_SchnorrSignatureNoneZ {
7529 private:
7530         LDKCResult_SchnorrSignatureNoneZ self;
7531 public:
7532         CResult_SchnorrSignatureNoneZ(const CResult_SchnorrSignatureNoneZ&) = delete;
7533         CResult_SchnorrSignatureNoneZ(CResult_SchnorrSignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SchnorrSignatureNoneZ)); }
7534         CResult_SchnorrSignatureNoneZ(LDKCResult_SchnorrSignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SchnorrSignatureNoneZ)); }
7535         operator LDKCResult_SchnorrSignatureNoneZ() && { LDKCResult_SchnorrSignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SchnorrSignatureNoneZ)); return res; }
7536         ~CResult_SchnorrSignatureNoneZ() { CResult_SchnorrSignatureNoneZ_free(self); }
7537         CResult_SchnorrSignatureNoneZ& operator=(CResult_SchnorrSignatureNoneZ&& o) { CResult_SchnorrSignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SchnorrSignatureNoneZ)); return *this; }
7538         LDKCResult_SchnorrSignatureNoneZ* operator &() { return &self; }
7539         LDKCResult_SchnorrSignatureNoneZ* operator ->() { return &self; }
7540         const LDKCResult_SchnorrSignatureNoneZ* operator &() const { return &self; }
7541         const LDKCResult_SchnorrSignatureNoneZ* operator ->() const { return &self; }
7542 };
7543 class CResult_CounterpartyCommitmentSecretsDecodeErrorZ {
7544 private:
7545         LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ self;
7546 public:
7547         CResult_CounterpartyCommitmentSecretsDecodeErrorZ(const CResult_CounterpartyCommitmentSecretsDecodeErrorZ&) = delete;
7548         CResult_CounterpartyCommitmentSecretsDecodeErrorZ(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
7549         CResult_CounterpartyCommitmentSecretsDecodeErrorZ(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
7550         operator LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ() && { LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return res; }
7551         ~CResult_CounterpartyCommitmentSecretsDecodeErrorZ() { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); }
7552         CResult_CounterpartyCommitmentSecretsDecodeErrorZ& operator=(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return *this; }
7553         LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() { return &self; }
7554         LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() { return &self; }
7555         const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() const { return &self; }
7556         const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() const { return &self; }
7557 };
7558 class CResult_HTLCDescriptorDecodeErrorZ {
7559 private:
7560         LDKCResult_HTLCDescriptorDecodeErrorZ self;
7561 public:
7562         CResult_HTLCDescriptorDecodeErrorZ(const CResult_HTLCDescriptorDecodeErrorZ&) = delete;
7563         CResult_HTLCDescriptorDecodeErrorZ(CResult_HTLCDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCDescriptorDecodeErrorZ)); }
7564         CResult_HTLCDescriptorDecodeErrorZ(LDKCResult_HTLCDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCDescriptorDecodeErrorZ)); }
7565         operator LDKCResult_HTLCDescriptorDecodeErrorZ() && { LDKCResult_HTLCDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCDescriptorDecodeErrorZ)); return res; }
7566         ~CResult_HTLCDescriptorDecodeErrorZ() { CResult_HTLCDescriptorDecodeErrorZ_free(self); }
7567         CResult_HTLCDescriptorDecodeErrorZ& operator=(CResult_HTLCDescriptorDecodeErrorZ&& o) { CResult_HTLCDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCDescriptorDecodeErrorZ)); return *this; }
7568         LDKCResult_HTLCDescriptorDecodeErrorZ* operator &() { return &self; }
7569         LDKCResult_HTLCDescriptorDecodeErrorZ* operator ->() { return &self; }
7570         const LDKCResult_HTLCDescriptorDecodeErrorZ* operator &() const { return &self; }
7571         const LDKCResult_HTLCDescriptorDecodeErrorZ* operator ->() const { return &self; }
7572 };
7573 class CVec_RecentPaymentDetailsZ {
7574 private:
7575         LDKCVec_RecentPaymentDetailsZ self;
7576 public:
7577         CVec_RecentPaymentDetailsZ(const CVec_RecentPaymentDetailsZ&) = delete;
7578         CVec_RecentPaymentDetailsZ(CVec_RecentPaymentDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RecentPaymentDetailsZ)); }
7579         CVec_RecentPaymentDetailsZ(LDKCVec_RecentPaymentDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RecentPaymentDetailsZ)); }
7580         operator LDKCVec_RecentPaymentDetailsZ() && { LDKCVec_RecentPaymentDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_RecentPaymentDetailsZ)); return res; }
7581         ~CVec_RecentPaymentDetailsZ() { CVec_RecentPaymentDetailsZ_free(self); }
7582         CVec_RecentPaymentDetailsZ& operator=(CVec_RecentPaymentDetailsZ&& o) { CVec_RecentPaymentDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RecentPaymentDetailsZ)); return *this; }
7583         LDKCVec_RecentPaymentDetailsZ* operator &() { return &self; }
7584         LDKCVec_RecentPaymentDetailsZ* operator ->() { return &self; }
7585         const LDKCVec_RecentPaymentDetailsZ* operator &() const { return &self; }
7586         const LDKCVec_RecentPaymentDetailsZ* operator ->() const { return &self; }
7587 };
7588 class CVec_RouteHintHopZ {
7589 private:
7590         LDKCVec_RouteHintHopZ self;
7591 public:
7592         CVec_RouteHintHopZ(const CVec_RouteHintHopZ&) = delete;
7593         CVec_RouteHintHopZ(CVec_RouteHintHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintHopZ)); }
7594         CVec_RouteHintHopZ(LDKCVec_RouteHintHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintHopZ)); }
7595         operator LDKCVec_RouteHintHopZ() && { LDKCVec_RouteHintHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintHopZ)); return res; }
7596         ~CVec_RouteHintHopZ() { CVec_RouteHintHopZ_free(self); }
7597         CVec_RouteHintHopZ& operator=(CVec_RouteHintHopZ&& o) { CVec_RouteHintHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintHopZ)); return *this; }
7598         LDKCVec_RouteHintHopZ* operator &() { return &self; }
7599         LDKCVec_RouteHintHopZ* operator ->() { return &self; }
7600         const LDKCVec_RouteHintHopZ* operator &() const { return &self; }
7601         const LDKCVec_RouteHintHopZ* operator ->() const { return &self; }
7602 };
7603 class CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ {
7604 private:
7605         LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ self;
7606 public:
7607         CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ(const CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ&) = delete;
7608         CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ(CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ)); }
7609         CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ(LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ)); }
7610         operator LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ() && { LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ)); return res; }
7611         ~CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ() { CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ_free(self); }
7612         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; }
7613         LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ* operator &() { return &self; }
7614         LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ* operator ->() { return &self; }
7615         const LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ* operator &() const { return &self; }
7616         const LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ* operator ->() const { return &self; }
7617 };
7618 class CResult_UntrustedStringDecodeErrorZ {
7619 private:
7620         LDKCResult_UntrustedStringDecodeErrorZ self;
7621 public:
7622         CResult_UntrustedStringDecodeErrorZ(const CResult_UntrustedStringDecodeErrorZ&) = delete;
7623         CResult_UntrustedStringDecodeErrorZ(CResult_UntrustedStringDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UntrustedStringDecodeErrorZ)); }
7624         CResult_UntrustedStringDecodeErrorZ(LDKCResult_UntrustedStringDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UntrustedStringDecodeErrorZ)); }
7625         operator LDKCResult_UntrustedStringDecodeErrorZ() && { LDKCResult_UntrustedStringDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UntrustedStringDecodeErrorZ)); return res; }
7626         ~CResult_UntrustedStringDecodeErrorZ() { CResult_UntrustedStringDecodeErrorZ_free(self); }
7627         CResult_UntrustedStringDecodeErrorZ& operator=(CResult_UntrustedStringDecodeErrorZ&& o) { CResult_UntrustedStringDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UntrustedStringDecodeErrorZ)); return *this; }
7628         LDKCResult_UntrustedStringDecodeErrorZ* operator &() { return &self; }
7629         LDKCResult_UntrustedStringDecodeErrorZ* operator ->() { return &self; }
7630         const LDKCResult_UntrustedStringDecodeErrorZ* operator &() const { return &self; }
7631         const LDKCResult_UntrustedStringDecodeErrorZ* operator ->() const { return &self; }
7632 };
7633 class CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ {
7634 private:
7635         LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ self;
7636 public:
7637         CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ(const CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ&) = delete;
7638         CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ(CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ)); }
7639         CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ(LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ)); }
7640         operator LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ() && { LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ)); return res; }
7641         ~CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ() { CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ_free(self); }
7642         CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ& operator=(CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ&& o) { CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ)); return *this; }
7643         LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ* operator &() { return &self; }
7644         LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ* operator ->() { return &self; }
7645         const LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ* operator &() const { return &self; }
7646         const LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ* operator ->() const { return &self; }
7647 };
7648 class CVec_U5Z {
7649 private:
7650         LDKCVec_U5Z self;
7651 public:
7652         CVec_U5Z(const CVec_U5Z&) = delete;
7653         CVec_U5Z(CVec_U5Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_U5Z)); }
7654         CVec_U5Z(LDKCVec_U5Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_U5Z)); }
7655         operator LDKCVec_U5Z() && { LDKCVec_U5Z res = self; memset(&self, 0, sizeof(LDKCVec_U5Z)); return res; }
7656         ~CVec_U5Z() { CVec_U5Z_free(self); }
7657         CVec_U5Z& operator=(CVec_U5Z&& o) { CVec_U5Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_U5Z)); return *this; }
7658         LDKCVec_U5Z* operator &() { return &self; }
7659         LDKCVec_U5Z* operator ->() { return &self; }
7660         const LDKCVec_U5Z* operator &() const { return &self; }
7661         const LDKCVec_U5Z* operator ->() const { return &self; }
7662 };
7663 class CResult_PaymentParametersDecodeErrorZ {
7664 private:
7665         LDKCResult_PaymentParametersDecodeErrorZ self;
7666 public:
7667         CResult_PaymentParametersDecodeErrorZ(const CResult_PaymentParametersDecodeErrorZ&) = delete;
7668         CResult_PaymentParametersDecodeErrorZ(CResult_PaymentParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); }
7669         CResult_PaymentParametersDecodeErrorZ(LDKCResult_PaymentParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); }
7670         operator LDKCResult_PaymentParametersDecodeErrorZ() && { LDKCResult_PaymentParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); return res; }
7671         ~CResult_PaymentParametersDecodeErrorZ() { CResult_PaymentParametersDecodeErrorZ_free(self); }
7672         CResult_PaymentParametersDecodeErrorZ& operator=(CResult_PaymentParametersDecodeErrorZ&& o) { CResult_PaymentParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); return *this; }
7673         LDKCResult_PaymentParametersDecodeErrorZ* operator &() { return &self; }
7674         LDKCResult_PaymentParametersDecodeErrorZ* operator ->() { return &self; }
7675         const LDKCResult_PaymentParametersDecodeErrorZ* operator &() const { return &self; }
7676         const LDKCResult_PaymentParametersDecodeErrorZ* operator ->() const { return &self; }
7677 };
7678 class C2Tuple_ThirtyTwoBytesChannelMonitorZ {
7679 private:
7680         LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ self;
7681 public:
7682         C2Tuple_ThirtyTwoBytesChannelMonitorZ(const C2Tuple_ThirtyTwoBytesChannelMonitorZ&) = delete;
7683         C2Tuple_ThirtyTwoBytesChannelMonitorZ(C2Tuple_ThirtyTwoBytesChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelMonitorZ)); }
7684         C2Tuple_ThirtyTwoBytesChannelMonitorZ(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ)); }
7685         operator LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ() && { LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ)); return res; }
7686         ~C2Tuple_ThirtyTwoBytesChannelMonitorZ() { C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(self); }
7687         C2Tuple_ThirtyTwoBytesChannelMonitorZ& operator=(C2Tuple_ThirtyTwoBytesChannelMonitorZ&& o) { C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelMonitorZ)); return *this; }
7688         LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator &() { return &self; }
7689         LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator ->() { return &self; }
7690         const LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator &() const { return &self; }
7691         const LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator ->() const { return &self; }
7692 };
7693 class COption_U128Z {
7694 private:
7695         LDKCOption_U128Z self;
7696 public:
7697         COption_U128Z(const COption_U128Z&) = delete;
7698         COption_U128Z(COption_U128Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_U128Z)); }
7699         COption_U128Z(LDKCOption_U128Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_U128Z)); }
7700         operator LDKCOption_U128Z() && { LDKCOption_U128Z res = self; memset(&self, 0, sizeof(LDKCOption_U128Z)); return res; }
7701         ~COption_U128Z() { COption_U128Z_free(self); }
7702         COption_U128Z& operator=(COption_U128Z&& o) { COption_U128Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_U128Z)); return *this; }
7703         LDKCOption_U128Z* operator &() { return &self; }
7704         LDKCOption_U128Z* operator ->() { return &self; }
7705         const LDKCOption_U128Z* operator &() const { return &self; }
7706         const LDKCOption_U128Z* operator ->() const { return &self; }
7707 };
7708 class CResult_DelayedPaymentBasepointDecodeErrorZ {
7709 private:
7710         LDKCResult_DelayedPaymentBasepointDecodeErrorZ self;
7711 public:
7712         CResult_DelayedPaymentBasepointDecodeErrorZ(const CResult_DelayedPaymentBasepointDecodeErrorZ&) = delete;
7713         CResult_DelayedPaymentBasepointDecodeErrorZ(CResult_DelayedPaymentBasepointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentBasepointDecodeErrorZ)); }
7714         CResult_DelayedPaymentBasepointDecodeErrorZ(LDKCResult_DelayedPaymentBasepointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentBasepointDecodeErrorZ)); }
7715         operator LDKCResult_DelayedPaymentBasepointDecodeErrorZ() && { LDKCResult_DelayedPaymentBasepointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentBasepointDecodeErrorZ)); return res; }
7716         ~CResult_DelayedPaymentBasepointDecodeErrorZ() { CResult_DelayedPaymentBasepointDecodeErrorZ_free(self); }
7717         CResult_DelayedPaymentBasepointDecodeErrorZ& operator=(CResult_DelayedPaymentBasepointDecodeErrorZ&& o) { CResult_DelayedPaymentBasepointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentBasepointDecodeErrorZ)); return *this; }
7718         LDKCResult_DelayedPaymentBasepointDecodeErrorZ* operator &() { return &self; }
7719         LDKCResult_DelayedPaymentBasepointDecodeErrorZ* operator ->() { return &self; }
7720         const LDKCResult_DelayedPaymentBasepointDecodeErrorZ* operator &() const { return &self; }
7721         const LDKCResult_DelayedPaymentBasepointDecodeErrorZ* operator ->() const { return &self; }
7722 };
7723 class C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ {
7724 private:
7725         LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ self;
7726 public:
7727         C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(const C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&) = delete;
7728         C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); }
7729         C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); }
7730         operator LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ() && { LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); return res; }
7731         ~C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ() { C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(self); }
7732         C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ& operator=(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& o) { C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); return *this; }
7733         LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator &() { return &self; }
7734         LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator ->() { return &self; }
7735         const LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator &() const { return &self; }
7736         const LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator ->() const { return &self; }
7737 };
7738 class CResult_TxAckRbfDecodeErrorZ {
7739 private:
7740         LDKCResult_TxAckRbfDecodeErrorZ self;
7741 public:
7742         CResult_TxAckRbfDecodeErrorZ(const CResult_TxAckRbfDecodeErrorZ&) = delete;
7743         CResult_TxAckRbfDecodeErrorZ(CResult_TxAckRbfDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAckRbfDecodeErrorZ)); }
7744         CResult_TxAckRbfDecodeErrorZ(LDKCResult_TxAckRbfDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAckRbfDecodeErrorZ)); }
7745         operator LDKCResult_TxAckRbfDecodeErrorZ() && { LDKCResult_TxAckRbfDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAckRbfDecodeErrorZ)); return res; }
7746         ~CResult_TxAckRbfDecodeErrorZ() { CResult_TxAckRbfDecodeErrorZ_free(self); }
7747         CResult_TxAckRbfDecodeErrorZ& operator=(CResult_TxAckRbfDecodeErrorZ&& o) { CResult_TxAckRbfDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAckRbfDecodeErrorZ)); return *this; }
7748         LDKCResult_TxAckRbfDecodeErrorZ* operator &() { return &self; }
7749         LDKCResult_TxAckRbfDecodeErrorZ* operator ->() { return &self; }
7750         const LDKCResult_TxAckRbfDecodeErrorZ* operator &() const { return &self; }
7751         const LDKCResult_TxAckRbfDecodeErrorZ* operator ->() const { return &self; }
7752 };
7753 class CResult_Bolt11InvoiceBolt11SemanticErrorZ {
7754 private:
7755         LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ self;
7756 public:
7757         CResult_Bolt11InvoiceBolt11SemanticErrorZ(const CResult_Bolt11InvoiceBolt11SemanticErrorZ&) = delete;
7758         CResult_Bolt11InvoiceBolt11SemanticErrorZ(CResult_Bolt11InvoiceBolt11SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceBolt11SemanticErrorZ)); }
7759         CResult_Bolt11InvoiceBolt11SemanticErrorZ(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ)); }
7760         operator LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ() && { LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ)); return res; }
7761         ~CResult_Bolt11InvoiceBolt11SemanticErrorZ() { CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(self); }
7762         CResult_Bolt11InvoiceBolt11SemanticErrorZ& operator=(CResult_Bolt11InvoiceBolt11SemanticErrorZ&& o) { CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceBolt11SemanticErrorZ)); return *this; }
7763         LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator &() { return &self; }
7764         LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator ->() { return &self; }
7765         const LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator &() const { return &self; }
7766         const LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator ->() const { return &self; }
7767 };
7768 class COption_UtxoLookupZ {
7769 private:
7770         LDKCOption_UtxoLookupZ self;
7771 public:
7772         COption_UtxoLookupZ(const COption_UtxoLookupZ&) = delete;
7773         COption_UtxoLookupZ(COption_UtxoLookupZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_UtxoLookupZ)); }
7774         COption_UtxoLookupZ(LDKCOption_UtxoLookupZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_UtxoLookupZ)); }
7775         operator LDKCOption_UtxoLookupZ() && { LDKCOption_UtxoLookupZ res = self; memset(&self, 0, sizeof(LDKCOption_UtxoLookupZ)); return res; }
7776         ~COption_UtxoLookupZ() { COption_UtxoLookupZ_free(self); }
7777         COption_UtxoLookupZ& operator=(COption_UtxoLookupZ&& o) { COption_UtxoLookupZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_UtxoLookupZ)); return *this; }
7778         LDKCOption_UtxoLookupZ* operator &() { return &self; }
7779         LDKCOption_UtxoLookupZ* operator ->() { return &self; }
7780         const LDKCOption_UtxoLookupZ* operator &() const { return &self; }
7781         const LDKCOption_UtxoLookupZ* operator ->() const { return &self; }
7782 };
7783 class CResult_PongDecodeErrorZ {
7784 private:
7785         LDKCResult_PongDecodeErrorZ self;
7786 public:
7787         CResult_PongDecodeErrorZ(const CResult_PongDecodeErrorZ&) = delete;
7788         CResult_PongDecodeErrorZ(CResult_PongDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); }
7789         CResult_PongDecodeErrorZ(LDKCResult_PongDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); }
7790         operator LDKCResult_PongDecodeErrorZ() && { LDKCResult_PongDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); return res; }
7791         ~CResult_PongDecodeErrorZ() { CResult_PongDecodeErrorZ_free(self); }
7792         CResult_PongDecodeErrorZ& operator=(CResult_PongDecodeErrorZ&& o) { CResult_PongDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); return *this; }
7793         LDKCResult_PongDecodeErrorZ* operator &() { return &self; }
7794         LDKCResult_PongDecodeErrorZ* operator ->() { return &self; }
7795         const LDKCResult_PongDecodeErrorZ* operator &() const { return &self; }
7796         const LDKCResult_PongDecodeErrorZ* operator ->() const { return &self; }
7797 };
7798 class CResult_UnsignedChannelAnnouncementDecodeErrorZ {
7799 private:
7800         LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ self;
7801 public:
7802         CResult_UnsignedChannelAnnouncementDecodeErrorZ(const CResult_UnsignedChannelAnnouncementDecodeErrorZ&) = delete;
7803         CResult_UnsignedChannelAnnouncementDecodeErrorZ(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
7804         CResult_UnsignedChannelAnnouncementDecodeErrorZ(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
7805         operator LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); return res; }
7806         ~CResult_UnsignedChannelAnnouncementDecodeErrorZ() { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); }
7807         CResult_UnsignedChannelAnnouncementDecodeErrorZ& operator=(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); return *this; }
7808         LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
7809         LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
7810         const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
7811         const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
7812 };
7813 class C2Tuple_OutPointCVec_MonitorUpdateIdZZ {
7814 private:
7815         LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ self;
7816 public:
7817         C2Tuple_OutPointCVec_MonitorUpdateIdZZ(const C2Tuple_OutPointCVec_MonitorUpdateIdZZ&) = delete;
7818         C2Tuple_OutPointCVec_MonitorUpdateIdZZ(C2Tuple_OutPointCVec_MonitorUpdateIdZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointCVec_MonitorUpdateIdZZ)); }
7819         C2Tuple_OutPointCVec_MonitorUpdateIdZZ(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ)); }
7820         operator LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ() && { LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ)); return res; }
7821         ~C2Tuple_OutPointCVec_MonitorUpdateIdZZ() { C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(self); }
7822         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; }
7823         LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator &() { return &self; }
7824         LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator ->() { return &self; }
7825         const LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator &() const { return &self; }
7826         const LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator ->() const { return &self; }
7827 };
7828 class CResult_CVec_u8ZNoneZ {
7829 private:
7830         LDKCResult_CVec_u8ZNoneZ self;
7831 public:
7832         CResult_CVec_u8ZNoneZ(const CResult_CVec_u8ZNoneZ&) = delete;
7833         CResult_CVec_u8ZNoneZ(CResult_CVec_u8ZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZNoneZ)); }
7834         CResult_CVec_u8ZNoneZ(LDKCResult_CVec_u8ZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZNoneZ)); }
7835         operator LDKCResult_CVec_u8ZNoneZ() && { LDKCResult_CVec_u8ZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZNoneZ)); return res; }
7836         ~CResult_CVec_u8ZNoneZ() { CResult_CVec_u8ZNoneZ_free(self); }
7837         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; }
7838         LDKCResult_CVec_u8ZNoneZ* operator &() { return &self; }
7839         LDKCResult_CVec_u8ZNoneZ* operator ->() { return &self; }
7840         const LDKCResult_CVec_u8ZNoneZ* operator &() const { return &self; }
7841         const LDKCResult_CVec_u8ZNoneZ* operator ->() const { return &self; }
7842 };
7843 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ {
7844 private:
7845         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ self;
7846 public:
7847         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(const C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&) = delete;
7848         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); }
7849         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); }
7850         operator LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ() && { LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); return res; }
7851         ~C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ() { C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(self); }
7852         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; }
7853         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator &() { return &self; }
7854         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator ->() { return &self; }
7855         const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator &() const { return &self; }
7856         const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator ->() const { return &self; }
7857 };
7858 class CResult_ChannelTransactionParametersDecodeErrorZ {
7859 private:
7860         LDKCResult_ChannelTransactionParametersDecodeErrorZ self;
7861 public:
7862         CResult_ChannelTransactionParametersDecodeErrorZ(const CResult_ChannelTransactionParametersDecodeErrorZ&) = delete;
7863         CResult_ChannelTransactionParametersDecodeErrorZ(CResult_ChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); }
7864         CResult_ChannelTransactionParametersDecodeErrorZ(LDKCResult_ChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); }
7865         operator LDKCResult_ChannelTransactionParametersDecodeErrorZ() && { LDKCResult_ChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); return res; }
7866         ~CResult_ChannelTransactionParametersDecodeErrorZ() { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); }
7867         CResult_ChannelTransactionParametersDecodeErrorZ& operator=(CResult_ChannelTransactionParametersDecodeErrorZ&& o) { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); return *this; }
7868         LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
7869         LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
7870         const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
7871         const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
7872 };
7873 class CResult_WriteableEcdsaChannelSignerDecodeErrorZ {
7874 private:
7875         LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ self;
7876 public:
7877         CResult_WriteableEcdsaChannelSignerDecodeErrorZ(const CResult_WriteableEcdsaChannelSignerDecodeErrorZ&) = delete;
7878         CResult_WriteableEcdsaChannelSignerDecodeErrorZ(CResult_WriteableEcdsaChannelSignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WriteableEcdsaChannelSignerDecodeErrorZ)); }
7879         CResult_WriteableEcdsaChannelSignerDecodeErrorZ(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ)); }
7880         operator LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ() && { LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ)); return res; }
7881         ~CResult_WriteableEcdsaChannelSignerDecodeErrorZ() { CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(self); }
7882         CResult_WriteableEcdsaChannelSignerDecodeErrorZ& operator=(CResult_WriteableEcdsaChannelSignerDecodeErrorZ&& o) { CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WriteableEcdsaChannelSignerDecodeErrorZ)); return *this; }
7883         LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator &() { return &self; }
7884         LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator ->() { return &self; }
7885         const LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator &() const { return &self; }
7886         const LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator ->() const { return &self; }
7887 };
7888 class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
7889 private:
7890         LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ self;
7891 public:
7892         CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(const CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&) = delete;
7893         CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
7894         CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
7895         operator LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return res; }
7896         ~CResult_DelayedPaymentOutputDescriptorDecodeErrorZ() { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); }
7897         CResult_DelayedPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return *this; }
7898         LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
7899         LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
7900         const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
7901         const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
7902 };
7903 class CResult_InFlightHtlcsDecodeErrorZ {
7904 private:
7905         LDKCResult_InFlightHtlcsDecodeErrorZ self;
7906 public:
7907         CResult_InFlightHtlcsDecodeErrorZ(const CResult_InFlightHtlcsDecodeErrorZ&) = delete;
7908         CResult_InFlightHtlcsDecodeErrorZ(CResult_InFlightHtlcsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InFlightHtlcsDecodeErrorZ)); }
7909         CResult_InFlightHtlcsDecodeErrorZ(LDKCResult_InFlightHtlcsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ)); }
7910         operator LDKCResult_InFlightHtlcsDecodeErrorZ() && { LDKCResult_InFlightHtlcsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ)); return res; }
7911         ~CResult_InFlightHtlcsDecodeErrorZ() { CResult_InFlightHtlcsDecodeErrorZ_free(self); }
7912         CResult_InFlightHtlcsDecodeErrorZ& operator=(CResult_InFlightHtlcsDecodeErrorZ&& o) { CResult_InFlightHtlcsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InFlightHtlcsDecodeErrorZ)); return *this; }
7913         LDKCResult_InFlightHtlcsDecodeErrorZ* operator &() { return &self; }
7914         LDKCResult_InFlightHtlcsDecodeErrorZ* operator ->() { return &self; }
7915         const LDKCResult_InFlightHtlcsDecodeErrorZ* operator &() const { return &self; }
7916         const LDKCResult_InFlightHtlcsDecodeErrorZ* operator ->() const { return &self; }
7917 };
7918 class CResult_COption_HTLCDestinationZDecodeErrorZ {
7919 private:
7920         LDKCResult_COption_HTLCDestinationZDecodeErrorZ self;
7921 public:
7922         CResult_COption_HTLCDestinationZDecodeErrorZ(const CResult_COption_HTLCDestinationZDecodeErrorZ&) = delete;
7923         CResult_COption_HTLCDestinationZDecodeErrorZ(CResult_COption_HTLCDestinationZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_HTLCDestinationZDecodeErrorZ)); }
7924         CResult_COption_HTLCDestinationZDecodeErrorZ(LDKCResult_COption_HTLCDestinationZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ)); }
7925         operator LDKCResult_COption_HTLCDestinationZDecodeErrorZ() && { LDKCResult_COption_HTLCDestinationZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ)); return res; }
7926         ~CResult_COption_HTLCDestinationZDecodeErrorZ() { CResult_COption_HTLCDestinationZDecodeErrorZ_free(self); }
7927         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; }
7928         LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator &() { return &self; }
7929         LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator ->() { return &self; }
7930         const LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator &() const { return &self; }
7931         const LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator ->() const { return &self; }
7932 };
7933 class CResult_ThirtyTwoBytesNoneZ {
7934 private:
7935         LDKCResult_ThirtyTwoBytesNoneZ self;
7936 public:
7937         CResult_ThirtyTwoBytesNoneZ(const CResult_ThirtyTwoBytesNoneZ&) = delete;
7938         CResult_ThirtyTwoBytesNoneZ(CResult_ThirtyTwoBytesNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesNoneZ)); }
7939         CResult_ThirtyTwoBytesNoneZ(LDKCResult_ThirtyTwoBytesNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesNoneZ)); }
7940         operator LDKCResult_ThirtyTwoBytesNoneZ() && { LDKCResult_ThirtyTwoBytesNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesNoneZ)); return res; }
7941         ~CResult_ThirtyTwoBytesNoneZ() { CResult_ThirtyTwoBytesNoneZ_free(self); }
7942         CResult_ThirtyTwoBytesNoneZ& operator=(CResult_ThirtyTwoBytesNoneZ&& o) { CResult_ThirtyTwoBytesNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesNoneZ)); return *this; }
7943         LDKCResult_ThirtyTwoBytesNoneZ* operator &() { return &self; }
7944         LDKCResult_ThirtyTwoBytesNoneZ* operator ->() { return &self; }
7945         const LDKCResult_ThirtyTwoBytesNoneZ* operator &() const { return &self; }
7946         const LDKCResult_ThirtyTwoBytesNoneZ* operator ->() const { return &self; }
7947 };
7948 class C3Tuple_OnionMessageContentsDestinationBlindedPathZ {
7949 private:
7950         LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ self;
7951 public:
7952         C3Tuple_OnionMessageContentsDestinationBlindedPathZ(const C3Tuple_OnionMessageContentsDestinationBlindedPathZ&) = delete;
7953         C3Tuple_OnionMessageContentsDestinationBlindedPathZ(C3Tuple_OnionMessageContentsDestinationBlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_OnionMessageContentsDestinationBlindedPathZ)); }
7954         C3Tuple_OnionMessageContentsDestinationBlindedPathZ(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ)); }
7955         operator LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ() && { LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ)); return res; }
7956         ~C3Tuple_OnionMessageContentsDestinationBlindedPathZ() { C3Tuple_OnionMessageContentsDestinationBlindedPathZ_free(self); }
7957         C3Tuple_OnionMessageContentsDestinationBlindedPathZ& operator=(C3Tuple_OnionMessageContentsDestinationBlindedPathZ&& o) { C3Tuple_OnionMessageContentsDestinationBlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_OnionMessageContentsDestinationBlindedPathZ)); return *this; }
7958         LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ* operator &() { return &self; }
7959         LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ* operator ->() { return &self; }
7960         const LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ* operator &() const { return &self; }
7961         const LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ* operator ->() const { return &self; }
7962 };
7963 class C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ {
7964 private:
7965         LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ self;
7966 public:
7967         C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(const C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&) = delete;
7968         C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); }
7969         C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); }
7970         operator LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ() && { LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); return res; }
7971         ~C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ() { C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(self); }
7972         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; }
7973         LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator &() { return &self; }
7974         LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator ->() { return &self; }
7975         const LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator &() const { return &self; }
7976         const LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator ->() const { return &self; }
7977 };
7978 class CResult_SendSuccessSendErrorZ {
7979 private:
7980         LDKCResult_SendSuccessSendErrorZ self;
7981 public:
7982         CResult_SendSuccessSendErrorZ(const CResult_SendSuccessSendErrorZ&) = delete;
7983         CResult_SendSuccessSendErrorZ(CResult_SendSuccessSendErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SendSuccessSendErrorZ)); }
7984         CResult_SendSuccessSendErrorZ(LDKCResult_SendSuccessSendErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SendSuccessSendErrorZ)); }
7985         operator LDKCResult_SendSuccessSendErrorZ() && { LDKCResult_SendSuccessSendErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SendSuccessSendErrorZ)); return res; }
7986         ~CResult_SendSuccessSendErrorZ() { CResult_SendSuccessSendErrorZ_free(self); }
7987         CResult_SendSuccessSendErrorZ& operator=(CResult_SendSuccessSendErrorZ&& o) { CResult_SendSuccessSendErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SendSuccessSendErrorZ)); return *this; }
7988         LDKCResult_SendSuccessSendErrorZ* operator &() { return &self; }
7989         LDKCResult_SendSuccessSendErrorZ* operator ->() { return &self; }
7990         const LDKCResult_SendSuccessSendErrorZ* operator &() const { return &self; }
7991         const LDKCResult_SendSuccessSendErrorZ* operator ->() const { return &self; }
7992 };
7993 class CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ {
7994 private:
7995         LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ self;
7996 public:
7997         CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ(const CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ&) = delete;
7998         CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ(CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ)); }
7999         CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ(LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ)); }
8000         operator LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ() && { LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ)); return res; }
8001         ~CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ() { CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ_free(self); }
8002         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; }
8003         LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator &() { return &self; }
8004         LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator ->() { return &self; }
8005         const LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator &() const { return &self; }
8006         const LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator ->() const { return &self; }
8007 };
8008 class C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ {
8009 private:
8010         LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ self;
8011 public:
8012         C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ(const C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ&) = delete;
8013         C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ(C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ)); }
8014         C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ)); }
8015         operator LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ() && { LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ)); return res; }
8016         ~C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ() { C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_free(self); }
8017         C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ& operator=(C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ&& o) { C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ)); return *this; }
8018         LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ* operator &() { return &self; }
8019         LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ* operator ->() { return &self; }
8020         const LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ* operator &() const { return &self; }
8021         const LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ* operator ->() const { return &self; }
8022 };
8023 class CResult_BlindedHopDecodeErrorZ {
8024 private:
8025         LDKCResult_BlindedHopDecodeErrorZ self;
8026 public:
8027         CResult_BlindedHopDecodeErrorZ(const CResult_BlindedHopDecodeErrorZ&) = delete;
8028         CResult_BlindedHopDecodeErrorZ(CResult_BlindedHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedHopDecodeErrorZ)); }
8029         CResult_BlindedHopDecodeErrorZ(LDKCResult_BlindedHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedHopDecodeErrorZ)); }
8030         operator LDKCResult_BlindedHopDecodeErrorZ() && { LDKCResult_BlindedHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedHopDecodeErrorZ)); return res; }
8031         ~CResult_BlindedHopDecodeErrorZ() { CResult_BlindedHopDecodeErrorZ_free(self); }
8032         CResult_BlindedHopDecodeErrorZ& operator=(CResult_BlindedHopDecodeErrorZ&& o) { CResult_BlindedHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedHopDecodeErrorZ)); return *this; }
8033         LDKCResult_BlindedHopDecodeErrorZ* operator &() { return &self; }
8034         LDKCResult_BlindedHopDecodeErrorZ* operator ->() { return &self; }
8035         const LDKCResult_BlindedHopDecodeErrorZ* operator &() const { return &self; }
8036         const LDKCResult_BlindedHopDecodeErrorZ* operator ->() const { return &self; }
8037 };
8038 class CResult_NoneLightningErrorZ {
8039 private:
8040         LDKCResult_NoneLightningErrorZ self;
8041 public:
8042         CResult_NoneLightningErrorZ(const CResult_NoneLightningErrorZ&) = delete;
8043         CResult_NoneLightningErrorZ(CResult_NoneLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); }
8044         CResult_NoneLightningErrorZ(LDKCResult_NoneLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); }
8045         operator LDKCResult_NoneLightningErrorZ() && { LDKCResult_NoneLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); return res; }
8046         ~CResult_NoneLightningErrorZ() { CResult_NoneLightningErrorZ_free(self); }
8047         CResult_NoneLightningErrorZ& operator=(CResult_NoneLightningErrorZ&& o) { CResult_NoneLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); return *this; }
8048         LDKCResult_NoneLightningErrorZ* operator &() { return &self; }
8049         LDKCResult_NoneLightningErrorZ* operator ->() { return &self; }
8050         const LDKCResult_NoneLightningErrorZ* operator &() const { return &self; }
8051         const LDKCResult_NoneLightningErrorZ* operator ->() const { return &self; }
8052 };
8053 class CResult_FixedPenaltyScorerDecodeErrorZ {
8054 private:
8055         LDKCResult_FixedPenaltyScorerDecodeErrorZ self;
8056 public:
8057         CResult_FixedPenaltyScorerDecodeErrorZ(const CResult_FixedPenaltyScorerDecodeErrorZ&) = delete;
8058         CResult_FixedPenaltyScorerDecodeErrorZ(CResult_FixedPenaltyScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); }
8059         CResult_FixedPenaltyScorerDecodeErrorZ(LDKCResult_FixedPenaltyScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); }
8060         operator LDKCResult_FixedPenaltyScorerDecodeErrorZ() && { LDKCResult_FixedPenaltyScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); return res; }
8061         ~CResult_FixedPenaltyScorerDecodeErrorZ() { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); }
8062         CResult_FixedPenaltyScorerDecodeErrorZ& operator=(CResult_FixedPenaltyScorerDecodeErrorZ&& o) { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); return *this; }
8063         LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() { return &self; }
8064         LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() { return &self; }
8065         const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() const { return &self; }
8066         const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() const { return &self; }
8067 };
8068 class CVec_BlindedPathZ {
8069 private:
8070         LDKCVec_BlindedPathZ self;
8071 public:
8072         CVec_BlindedPathZ(const CVec_BlindedPathZ&) = delete;
8073         CVec_BlindedPathZ(CVec_BlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BlindedPathZ)); }
8074         CVec_BlindedPathZ(LDKCVec_BlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BlindedPathZ)); }
8075         operator LDKCVec_BlindedPathZ() && { LDKCVec_BlindedPathZ res = self; memset(&self, 0, sizeof(LDKCVec_BlindedPathZ)); return res; }
8076         ~CVec_BlindedPathZ() { CVec_BlindedPathZ_free(self); }
8077         CVec_BlindedPathZ& operator=(CVec_BlindedPathZ&& o) { CVec_BlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BlindedPathZ)); return *this; }
8078         LDKCVec_BlindedPathZ* operator &() { return &self; }
8079         LDKCVec_BlindedPathZ* operator ->() { return &self; }
8080         const LDKCVec_BlindedPathZ* operator &() const { return &self; }
8081         const LDKCVec_BlindedPathZ* operator ->() const { return &self; }
8082 };
8083 class CResult_NonePeerHandleErrorZ {
8084 private:
8085         LDKCResult_NonePeerHandleErrorZ self;
8086 public:
8087         CResult_NonePeerHandleErrorZ(const CResult_NonePeerHandleErrorZ&) = delete;
8088         CResult_NonePeerHandleErrorZ(CResult_NonePeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); }
8089         CResult_NonePeerHandleErrorZ(LDKCResult_NonePeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); }
8090         operator LDKCResult_NonePeerHandleErrorZ() && { LDKCResult_NonePeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); return res; }
8091         ~CResult_NonePeerHandleErrorZ() { CResult_NonePeerHandleErrorZ_free(self); }
8092         CResult_NonePeerHandleErrorZ& operator=(CResult_NonePeerHandleErrorZ&& o) { CResult_NonePeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); return *this; }
8093         LDKCResult_NonePeerHandleErrorZ* operator &() { return &self; }
8094         LDKCResult_NonePeerHandleErrorZ* operator ->() { return &self; }
8095         const LDKCResult_NonePeerHandleErrorZ* operator &() const { return &self; }
8096         const LDKCResult_NonePeerHandleErrorZ* operator ->() const { return &self; }
8097 };
8098 class CResult_FinalOnionHopDataDecodeErrorZ {
8099 private:
8100         LDKCResult_FinalOnionHopDataDecodeErrorZ self;
8101 public:
8102         CResult_FinalOnionHopDataDecodeErrorZ(const CResult_FinalOnionHopDataDecodeErrorZ&) = delete;
8103         CResult_FinalOnionHopDataDecodeErrorZ(CResult_FinalOnionHopDataDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FinalOnionHopDataDecodeErrorZ)); }
8104         CResult_FinalOnionHopDataDecodeErrorZ(LDKCResult_FinalOnionHopDataDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FinalOnionHopDataDecodeErrorZ)); }
8105         operator LDKCResult_FinalOnionHopDataDecodeErrorZ() && { LDKCResult_FinalOnionHopDataDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FinalOnionHopDataDecodeErrorZ)); return res; }
8106         ~CResult_FinalOnionHopDataDecodeErrorZ() { CResult_FinalOnionHopDataDecodeErrorZ_free(self); }
8107         CResult_FinalOnionHopDataDecodeErrorZ& operator=(CResult_FinalOnionHopDataDecodeErrorZ&& o) { CResult_FinalOnionHopDataDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FinalOnionHopDataDecodeErrorZ)); return *this; }
8108         LDKCResult_FinalOnionHopDataDecodeErrorZ* operator &() { return &self; }
8109         LDKCResult_FinalOnionHopDataDecodeErrorZ* operator ->() { return &self; }
8110         const LDKCResult_FinalOnionHopDataDecodeErrorZ* operator &() const { return &self; }
8111         const LDKCResult_FinalOnionHopDataDecodeErrorZ* operator ->() const { return &self; }
8112 };
8113 class CResult_TrustedCommitmentTransactionNoneZ {
8114 private:
8115         LDKCResult_TrustedCommitmentTransactionNoneZ self;
8116 public:
8117         CResult_TrustedCommitmentTransactionNoneZ(const CResult_TrustedCommitmentTransactionNoneZ&) = delete;
8118         CResult_TrustedCommitmentTransactionNoneZ(CResult_TrustedCommitmentTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); }
8119         CResult_TrustedCommitmentTransactionNoneZ(LDKCResult_TrustedCommitmentTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); }
8120         operator LDKCResult_TrustedCommitmentTransactionNoneZ() && { LDKCResult_TrustedCommitmentTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); return res; }
8121         ~CResult_TrustedCommitmentTransactionNoneZ() { CResult_TrustedCommitmentTransactionNoneZ_free(self); }
8122         CResult_TrustedCommitmentTransactionNoneZ& operator=(CResult_TrustedCommitmentTransactionNoneZ&& o) { CResult_TrustedCommitmentTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); return *this; }
8123         LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() { return &self; }
8124         LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() { return &self; }
8125         const LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() const { return &self; }
8126         const LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() const { return &self; }
8127 };
8128 class CResult_COption_EventZDecodeErrorZ {
8129 private:
8130         LDKCResult_COption_EventZDecodeErrorZ self;
8131 public:
8132         CResult_COption_EventZDecodeErrorZ(const CResult_COption_EventZDecodeErrorZ&) = delete;
8133         CResult_COption_EventZDecodeErrorZ(CResult_COption_EventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_EventZDecodeErrorZ)); }
8134         CResult_COption_EventZDecodeErrorZ(LDKCResult_COption_EventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); }
8135         operator LDKCResult_COption_EventZDecodeErrorZ() && { LDKCResult_COption_EventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); return res; }
8136         ~CResult_COption_EventZDecodeErrorZ() { CResult_COption_EventZDecodeErrorZ_free(self); }
8137         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; }
8138         LDKCResult_COption_EventZDecodeErrorZ* operator &() { return &self; }
8139         LDKCResult_COption_EventZDecodeErrorZ* operator ->() { return &self; }
8140         const LDKCResult_COption_EventZDecodeErrorZ* operator &() const { return &self; }
8141         const LDKCResult_COption_EventZDecodeErrorZ* operator ->() const { return &self; }
8142 };
8143 class CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ {
8144 private:
8145         LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ self;
8146 public:
8147         CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(const CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&) = delete;
8148         CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); }
8149         CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); }
8150         operator LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ() && { LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); return res; }
8151         ~CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ() { CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(self); }
8152         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; }
8153         LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator &() { return &self; }
8154         LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator ->() { return &self; }
8155         const LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator &() const { return &self; }
8156         const LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator ->() const { return &self; }
8157 };
8158 class CResult_PaymentFailureReasonDecodeErrorZ {
8159 private:
8160         LDKCResult_PaymentFailureReasonDecodeErrorZ self;
8161 public:
8162         CResult_PaymentFailureReasonDecodeErrorZ(const CResult_PaymentFailureReasonDecodeErrorZ&) = delete;
8163         CResult_PaymentFailureReasonDecodeErrorZ(CResult_PaymentFailureReasonDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentFailureReasonDecodeErrorZ)); }
8164         CResult_PaymentFailureReasonDecodeErrorZ(LDKCResult_PaymentFailureReasonDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ)); }
8165         operator LDKCResult_PaymentFailureReasonDecodeErrorZ() && { LDKCResult_PaymentFailureReasonDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ)); return res; }
8166         ~CResult_PaymentFailureReasonDecodeErrorZ() { CResult_PaymentFailureReasonDecodeErrorZ_free(self); }
8167         CResult_PaymentFailureReasonDecodeErrorZ& operator=(CResult_PaymentFailureReasonDecodeErrorZ&& o) { CResult_PaymentFailureReasonDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentFailureReasonDecodeErrorZ)); return *this; }
8168         LDKCResult_PaymentFailureReasonDecodeErrorZ* operator &() { return &self; }
8169         LDKCResult_PaymentFailureReasonDecodeErrorZ* operator ->() { return &self; }
8170         const LDKCResult_PaymentFailureReasonDecodeErrorZ* operator &() const { return &self; }
8171         const LDKCResult_PaymentFailureReasonDecodeErrorZ* operator ->() const { return &self; }
8172 };
8173 class COption_SocketAddressZ {
8174 private:
8175         LDKCOption_SocketAddressZ self;
8176 public:
8177         COption_SocketAddressZ(const COption_SocketAddressZ&) = delete;
8178         COption_SocketAddressZ(COption_SocketAddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_SocketAddressZ)); }
8179         COption_SocketAddressZ(LDKCOption_SocketAddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_SocketAddressZ)); }
8180         operator LDKCOption_SocketAddressZ() && { LDKCOption_SocketAddressZ res = self; memset(&self, 0, sizeof(LDKCOption_SocketAddressZ)); return res; }
8181         ~COption_SocketAddressZ() { COption_SocketAddressZ_free(self); }
8182         COption_SocketAddressZ& operator=(COption_SocketAddressZ&& o) { COption_SocketAddressZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_SocketAddressZ)); return *this; }
8183         LDKCOption_SocketAddressZ* operator &() { return &self; }
8184         LDKCOption_SocketAddressZ* operator ->() { return &self; }
8185         const LDKCOption_SocketAddressZ* operator &() const { return &self; }
8186         const LDKCOption_SocketAddressZ* operator ->() const { return &self; }
8187 };
8188 class CResult_COption_MonitorEventZDecodeErrorZ {
8189 private:
8190         LDKCResult_COption_MonitorEventZDecodeErrorZ self;
8191 public:
8192         CResult_COption_MonitorEventZDecodeErrorZ(const CResult_COption_MonitorEventZDecodeErrorZ&) = delete;
8193         CResult_COption_MonitorEventZDecodeErrorZ(CResult_COption_MonitorEventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_MonitorEventZDecodeErrorZ)); }
8194         CResult_COption_MonitorEventZDecodeErrorZ(LDKCResult_COption_MonitorEventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); }
8195         operator LDKCResult_COption_MonitorEventZDecodeErrorZ() && { LDKCResult_COption_MonitorEventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); return res; }
8196         ~CResult_COption_MonitorEventZDecodeErrorZ() { CResult_COption_MonitorEventZDecodeErrorZ_free(self); }
8197         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; }
8198         LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() { return &self; }
8199         LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() { return &self; }
8200         const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() const { return &self; }
8201         const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() const { return &self; }
8202 };
8203 class COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ {
8204 private:
8205         LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ self;
8206 public:
8207         COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(const COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&) = delete;
8208         COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); }
8209         COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); }
8210         operator LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ() && { LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); return res; }
8211         ~COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ() { COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(self); }
8212         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; }
8213         LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator &() { return &self; }
8214         LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator ->() { return &self; }
8215         const LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator &() const { return &self; }
8216         const LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator ->() const { return &self; }
8217 };
8218 class CResult_DescriptionCreationErrorZ {
8219 private:
8220         LDKCResult_DescriptionCreationErrorZ self;
8221 public:
8222         CResult_DescriptionCreationErrorZ(const CResult_DescriptionCreationErrorZ&) = delete;
8223         CResult_DescriptionCreationErrorZ(CResult_DescriptionCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); }
8224         CResult_DescriptionCreationErrorZ(LDKCResult_DescriptionCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); }
8225         operator LDKCResult_DescriptionCreationErrorZ() && { LDKCResult_DescriptionCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); return res; }
8226         ~CResult_DescriptionCreationErrorZ() { CResult_DescriptionCreationErrorZ_free(self); }
8227         CResult_DescriptionCreationErrorZ& operator=(CResult_DescriptionCreationErrorZ&& o) { CResult_DescriptionCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); return *this; }
8228         LDKCResult_DescriptionCreationErrorZ* operator &() { return &self; }
8229         LDKCResult_DescriptionCreationErrorZ* operator ->() { return &self; }
8230         const LDKCResult_DescriptionCreationErrorZ* operator &() const { return &self; }
8231         const LDKCResult_DescriptionCreationErrorZ* operator ->() const { return &self; }
8232 };
8233 class CResult_RoutingFeesDecodeErrorZ {
8234 private:
8235         LDKCResult_RoutingFeesDecodeErrorZ self;
8236 public:
8237         CResult_RoutingFeesDecodeErrorZ(const CResult_RoutingFeesDecodeErrorZ&) = delete;
8238         CResult_RoutingFeesDecodeErrorZ(CResult_RoutingFeesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); }
8239         CResult_RoutingFeesDecodeErrorZ(LDKCResult_RoutingFeesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); }
8240         operator LDKCResult_RoutingFeesDecodeErrorZ() && { LDKCResult_RoutingFeesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); return res; }
8241         ~CResult_RoutingFeesDecodeErrorZ() { CResult_RoutingFeesDecodeErrorZ_free(self); }
8242         CResult_RoutingFeesDecodeErrorZ& operator=(CResult_RoutingFeesDecodeErrorZ&& o) { CResult_RoutingFeesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); return *this; }
8243         LDKCResult_RoutingFeesDecodeErrorZ* operator &() { return &self; }
8244         LDKCResult_RoutingFeesDecodeErrorZ* operator ->() { return &self; }
8245         const LDKCResult_RoutingFeesDecodeErrorZ* operator &() const { return &self; }
8246         const LDKCResult_RoutingFeesDecodeErrorZ* operator ->() const { return &self; }
8247 };
8248 class CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ {
8249 private:
8250         LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ self;
8251 public:
8252         CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ(const CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ&) = delete;
8253         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)); }
8254         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)); }
8255         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; }
8256         ~CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ() { CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(self); }
8257         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; }
8258         LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator &() { return &self; }
8259         LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator ->() { return &self; }
8260         const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator &() const { return &self; }
8261         const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator ->() const { return &self; }
8262 };
8263 class CResult_PaymentRelayDecodeErrorZ {
8264 private:
8265         LDKCResult_PaymentRelayDecodeErrorZ self;
8266 public:
8267         CResult_PaymentRelayDecodeErrorZ(const CResult_PaymentRelayDecodeErrorZ&) = delete;
8268         CResult_PaymentRelayDecodeErrorZ(CResult_PaymentRelayDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentRelayDecodeErrorZ)); }
8269         CResult_PaymentRelayDecodeErrorZ(LDKCResult_PaymentRelayDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentRelayDecodeErrorZ)); }
8270         operator LDKCResult_PaymentRelayDecodeErrorZ() && { LDKCResult_PaymentRelayDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentRelayDecodeErrorZ)); return res; }
8271         ~CResult_PaymentRelayDecodeErrorZ() { CResult_PaymentRelayDecodeErrorZ_free(self); }
8272         CResult_PaymentRelayDecodeErrorZ& operator=(CResult_PaymentRelayDecodeErrorZ&& o) { CResult_PaymentRelayDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentRelayDecodeErrorZ)); return *this; }
8273         LDKCResult_PaymentRelayDecodeErrorZ* operator &() { return &self; }
8274         LDKCResult_PaymentRelayDecodeErrorZ* operator ->() { return &self; }
8275         const LDKCResult_PaymentRelayDecodeErrorZ* operator &() const { return &self; }
8276         const LDKCResult_PaymentRelayDecodeErrorZ* operator ->() const { return &self; }
8277 };
8278 class CResult_QueryShortChannelIdsDecodeErrorZ {
8279 private:
8280         LDKCResult_QueryShortChannelIdsDecodeErrorZ self;
8281 public:
8282         CResult_QueryShortChannelIdsDecodeErrorZ(const CResult_QueryShortChannelIdsDecodeErrorZ&) = delete;
8283         CResult_QueryShortChannelIdsDecodeErrorZ(CResult_QueryShortChannelIdsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); }
8284         CResult_QueryShortChannelIdsDecodeErrorZ(LDKCResult_QueryShortChannelIdsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); }
8285         operator LDKCResult_QueryShortChannelIdsDecodeErrorZ() && { LDKCResult_QueryShortChannelIdsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); return res; }
8286         ~CResult_QueryShortChannelIdsDecodeErrorZ() { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); }
8287         CResult_QueryShortChannelIdsDecodeErrorZ& operator=(CResult_QueryShortChannelIdsDecodeErrorZ&& o) { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); return *this; }
8288         LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() { return &self; }
8289         LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() { return &self; }
8290         const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() const { return &self; }
8291         const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() const { return &self; }
8292 };
8293 class CResult_VerifiedInvoiceRequestNoneZ {
8294 private:
8295         LDKCResult_VerifiedInvoiceRequestNoneZ self;
8296 public:
8297         CResult_VerifiedInvoiceRequestNoneZ(const CResult_VerifiedInvoiceRequestNoneZ&) = delete;
8298         CResult_VerifiedInvoiceRequestNoneZ(CResult_VerifiedInvoiceRequestNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_VerifiedInvoiceRequestNoneZ)); }
8299         CResult_VerifiedInvoiceRequestNoneZ(LDKCResult_VerifiedInvoiceRequestNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_VerifiedInvoiceRequestNoneZ)); }
8300         operator LDKCResult_VerifiedInvoiceRequestNoneZ() && { LDKCResult_VerifiedInvoiceRequestNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_VerifiedInvoiceRequestNoneZ)); return res; }
8301         ~CResult_VerifiedInvoiceRequestNoneZ() { CResult_VerifiedInvoiceRequestNoneZ_free(self); }
8302         CResult_VerifiedInvoiceRequestNoneZ& operator=(CResult_VerifiedInvoiceRequestNoneZ&& o) { CResult_VerifiedInvoiceRequestNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_VerifiedInvoiceRequestNoneZ)); return *this; }
8303         LDKCResult_VerifiedInvoiceRequestNoneZ* operator &() { return &self; }
8304         LDKCResult_VerifiedInvoiceRequestNoneZ* operator ->() { return &self; }
8305         const LDKCResult_VerifiedInvoiceRequestNoneZ* operator &() const { return &self; }
8306         const LDKCResult_VerifiedInvoiceRequestNoneZ* operator ->() const { return &self; }
8307 };
8308 class CResult_UpdateAddHTLCDecodeErrorZ {
8309 private:
8310         LDKCResult_UpdateAddHTLCDecodeErrorZ self;
8311 public:
8312         CResult_UpdateAddHTLCDecodeErrorZ(const CResult_UpdateAddHTLCDecodeErrorZ&) = delete;
8313         CResult_UpdateAddHTLCDecodeErrorZ(CResult_UpdateAddHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); }
8314         CResult_UpdateAddHTLCDecodeErrorZ(LDKCResult_UpdateAddHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); }
8315         operator LDKCResult_UpdateAddHTLCDecodeErrorZ() && { LDKCResult_UpdateAddHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); return res; }
8316         ~CResult_UpdateAddHTLCDecodeErrorZ() { CResult_UpdateAddHTLCDecodeErrorZ_free(self); }
8317         CResult_UpdateAddHTLCDecodeErrorZ& operator=(CResult_UpdateAddHTLCDecodeErrorZ&& o) { CResult_UpdateAddHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); return *this; }
8318         LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() { return &self; }
8319         LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() { return &self; }
8320         const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() const { return &self; }
8321         const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() const { return &self; }
8322 };
8323 class COption_MonitorEventZ {
8324 private:
8325         LDKCOption_MonitorEventZ self;
8326 public:
8327         COption_MonitorEventZ(const COption_MonitorEventZ&) = delete;
8328         COption_MonitorEventZ(COption_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MonitorEventZ)); }
8329         COption_MonitorEventZ(LDKCOption_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MonitorEventZ)); }
8330         operator LDKCOption_MonitorEventZ() && { LDKCOption_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCOption_MonitorEventZ)); return res; }
8331         ~COption_MonitorEventZ() { COption_MonitorEventZ_free(self); }
8332         COption_MonitorEventZ& operator=(COption_MonitorEventZ&& o) { COption_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MonitorEventZ)); return *this; }
8333         LDKCOption_MonitorEventZ* operator &() { return &self; }
8334         LDKCOption_MonitorEventZ* operator ->() { return &self; }
8335         const LDKCOption_MonitorEventZ* operator &() const { return &self; }
8336         const LDKCOption_MonitorEventZ* operator ->() const { return &self; }
8337 };
8338 class COption_TypeZ {
8339 private:
8340         LDKCOption_TypeZ self;
8341 public:
8342         COption_TypeZ(const COption_TypeZ&) = delete;
8343         COption_TypeZ(COption_TypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_TypeZ)); }
8344         COption_TypeZ(LDKCOption_TypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_TypeZ)); }
8345         operator LDKCOption_TypeZ() && { LDKCOption_TypeZ res = self; memset(&self, 0, sizeof(LDKCOption_TypeZ)); return res; }
8346         ~COption_TypeZ() { COption_TypeZ_free(self); }
8347         COption_TypeZ& operator=(COption_TypeZ&& o) { COption_TypeZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_TypeZ)); return *this; }
8348         LDKCOption_TypeZ* operator &() { return &self; }
8349         LDKCOption_TypeZ* operator ->() { return &self; }
8350         const LDKCOption_TypeZ* operator &() const { return &self; }
8351         const LDKCOption_TypeZ* operator ->() const { return &self; }
8352 };
8353 class CResult_COption_TypeZDecodeErrorZ {
8354 private:
8355         LDKCResult_COption_TypeZDecodeErrorZ self;
8356 public:
8357         CResult_COption_TypeZDecodeErrorZ(const CResult_COption_TypeZDecodeErrorZ&) = delete;
8358         CResult_COption_TypeZDecodeErrorZ(CResult_COption_TypeZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_TypeZDecodeErrorZ)); }
8359         CResult_COption_TypeZDecodeErrorZ(LDKCResult_COption_TypeZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); }
8360         operator LDKCResult_COption_TypeZDecodeErrorZ() && { LDKCResult_COption_TypeZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); return res; }
8361         ~CResult_COption_TypeZDecodeErrorZ() { CResult_COption_TypeZDecodeErrorZ_free(self); }
8362         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; }
8363         LDKCResult_COption_TypeZDecodeErrorZ* operator &() { return &self; }
8364         LDKCResult_COption_TypeZDecodeErrorZ* operator ->() { return &self; }
8365         const LDKCResult_COption_TypeZDecodeErrorZ* operator &() const { return &self; }
8366         const LDKCResult_COption_TypeZDecodeErrorZ* operator ->() const { return &self; }
8367 };
8368 class CResult_COption_PathFailureZDecodeErrorZ {
8369 private:
8370         LDKCResult_COption_PathFailureZDecodeErrorZ self;
8371 public:
8372         CResult_COption_PathFailureZDecodeErrorZ(const CResult_COption_PathFailureZDecodeErrorZ&) = delete;
8373         CResult_COption_PathFailureZDecodeErrorZ(CResult_COption_PathFailureZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_PathFailureZDecodeErrorZ)); }
8374         CResult_COption_PathFailureZDecodeErrorZ(LDKCResult_COption_PathFailureZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ)); }
8375         operator LDKCResult_COption_PathFailureZDecodeErrorZ() && { LDKCResult_COption_PathFailureZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ)); return res; }
8376         ~CResult_COption_PathFailureZDecodeErrorZ() { CResult_COption_PathFailureZDecodeErrorZ_free(self); }
8377         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; }
8378         LDKCResult_COption_PathFailureZDecodeErrorZ* operator &() { return &self; }
8379         LDKCResult_COption_PathFailureZDecodeErrorZ* operator ->() { return &self; }
8380         const LDKCResult_COption_PathFailureZDecodeErrorZ* operator &() const { return &self; }
8381         const LDKCResult_COption_PathFailureZDecodeErrorZ* operator ->() const { return &self; }
8382 };
8383 class CResult_Bolt11InvoiceSignOrCreationErrorZ {
8384 private:
8385         LDKCResult_Bolt11InvoiceSignOrCreationErrorZ self;
8386 public:
8387         CResult_Bolt11InvoiceSignOrCreationErrorZ(const CResult_Bolt11InvoiceSignOrCreationErrorZ&) = delete;
8388         CResult_Bolt11InvoiceSignOrCreationErrorZ(CResult_Bolt11InvoiceSignOrCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceSignOrCreationErrorZ)); }
8389         CResult_Bolt11InvoiceSignOrCreationErrorZ(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ)); }
8390         operator LDKCResult_Bolt11InvoiceSignOrCreationErrorZ() && { LDKCResult_Bolt11InvoiceSignOrCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ)); return res; }
8391         ~CResult_Bolt11InvoiceSignOrCreationErrorZ() { CResult_Bolt11InvoiceSignOrCreationErrorZ_free(self); }
8392         CResult_Bolt11InvoiceSignOrCreationErrorZ& operator=(CResult_Bolt11InvoiceSignOrCreationErrorZ&& o) { CResult_Bolt11InvoiceSignOrCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceSignOrCreationErrorZ)); return *this; }
8393         LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator &() { return &self; }
8394         LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator ->() { return &self; }
8395         const LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator &() const { return &self; }
8396         const LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator ->() const { return &self; }
8397 };
8398 class CResult_UpdateFailHTLCDecodeErrorZ {
8399 private:
8400         LDKCResult_UpdateFailHTLCDecodeErrorZ self;
8401 public:
8402         CResult_UpdateFailHTLCDecodeErrorZ(const CResult_UpdateFailHTLCDecodeErrorZ&) = delete;
8403         CResult_UpdateFailHTLCDecodeErrorZ(CResult_UpdateFailHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); }
8404         CResult_UpdateFailHTLCDecodeErrorZ(LDKCResult_UpdateFailHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); }
8405         operator LDKCResult_UpdateFailHTLCDecodeErrorZ() && { LDKCResult_UpdateFailHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); return res; }
8406         ~CResult_UpdateFailHTLCDecodeErrorZ() { CResult_UpdateFailHTLCDecodeErrorZ_free(self); }
8407         CResult_UpdateFailHTLCDecodeErrorZ& operator=(CResult_UpdateFailHTLCDecodeErrorZ&& o) { CResult_UpdateFailHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); return *this; }
8408         LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() { return &self; }
8409         LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() { return &self; }
8410         const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() const { return &self; }
8411         const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() const { return &self; }
8412 };
8413 class CResult_CVec_BlindedPathZNoneZ {
8414 private:
8415         LDKCResult_CVec_BlindedPathZNoneZ self;
8416 public:
8417         CResult_CVec_BlindedPathZNoneZ(const CResult_CVec_BlindedPathZNoneZ&) = delete;
8418         CResult_CVec_BlindedPathZNoneZ(CResult_CVec_BlindedPathZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_BlindedPathZNoneZ)); }
8419         CResult_CVec_BlindedPathZNoneZ(LDKCResult_CVec_BlindedPathZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_BlindedPathZNoneZ)); }
8420         operator LDKCResult_CVec_BlindedPathZNoneZ() && { LDKCResult_CVec_BlindedPathZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_BlindedPathZNoneZ)); return res; }
8421         ~CResult_CVec_BlindedPathZNoneZ() { CResult_CVec_BlindedPathZNoneZ_free(self); }
8422         CResult_CVec_BlindedPathZNoneZ& operator=(CResult_CVec_BlindedPathZNoneZ&& o) { CResult_CVec_BlindedPathZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_BlindedPathZNoneZ)); return *this; }
8423         LDKCResult_CVec_BlindedPathZNoneZ* operator &() { return &self; }
8424         LDKCResult_CVec_BlindedPathZNoneZ* operator ->() { return &self; }
8425         const LDKCResult_CVec_BlindedPathZNoneZ* operator &() const { return &self; }
8426         const LDKCResult_CVec_BlindedPathZNoneZ* operator ->() const { return &self; }
8427 };
8428 class CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ {
8429 private:
8430         LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ self;
8431 public:
8432         CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(const CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&) = delete;
8433         CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); }
8434         CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); }
8435         operator LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); return res; }
8436         ~CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ() { CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(self); }
8437         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; }
8438         LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator &() { return &self; }
8439         LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator ->() { return &self; }
8440         const LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator &() const { return &self; }
8441         const LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator ->() const { return &self; }
8442 };
8443 class CResult_RevokeAndACKDecodeErrorZ {
8444 private:
8445         LDKCResult_RevokeAndACKDecodeErrorZ self;
8446 public:
8447         CResult_RevokeAndACKDecodeErrorZ(const CResult_RevokeAndACKDecodeErrorZ&) = delete;
8448         CResult_RevokeAndACKDecodeErrorZ(CResult_RevokeAndACKDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); }
8449         CResult_RevokeAndACKDecodeErrorZ(LDKCResult_RevokeAndACKDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); }
8450         operator LDKCResult_RevokeAndACKDecodeErrorZ() && { LDKCResult_RevokeAndACKDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); return res; }
8451         ~CResult_RevokeAndACKDecodeErrorZ() { CResult_RevokeAndACKDecodeErrorZ_free(self); }
8452         CResult_RevokeAndACKDecodeErrorZ& operator=(CResult_RevokeAndACKDecodeErrorZ&& o) { CResult_RevokeAndACKDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); return *this; }
8453         LDKCResult_RevokeAndACKDecodeErrorZ* operator &() { return &self; }
8454         LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() { return &self; }
8455         const LDKCResult_RevokeAndACKDecodeErrorZ* operator &() const { return &self; }
8456         const LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() const { return &self; }
8457 };
8458 class CResult_SpendableOutputDescriptorDecodeErrorZ {
8459 private:
8460         LDKCResult_SpendableOutputDescriptorDecodeErrorZ self;
8461 public:
8462         CResult_SpendableOutputDescriptorDecodeErrorZ(const CResult_SpendableOutputDescriptorDecodeErrorZ&) = delete;
8463         CResult_SpendableOutputDescriptorDecodeErrorZ(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); }
8464         CResult_SpendableOutputDescriptorDecodeErrorZ(LDKCResult_SpendableOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); }
8465         operator LDKCResult_SpendableOutputDescriptorDecodeErrorZ() && { LDKCResult_SpendableOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); return res; }
8466         ~CResult_SpendableOutputDescriptorDecodeErrorZ() { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); }
8467         CResult_SpendableOutputDescriptorDecodeErrorZ& operator=(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); return *this; }
8468         LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() { return &self; }
8469         LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
8470         const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
8471         const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
8472 };
8473 class C2Tuple_PublicKeyCOption_SocketAddressZZ {
8474 private:
8475         LDKC2Tuple_PublicKeyCOption_SocketAddressZZ self;
8476 public:
8477         C2Tuple_PublicKeyCOption_SocketAddressZZ(const C2Tuple_PublicKeyCOption_SocketAddressZZ&) = delete;
8478         C2Tuple_PublicKeyCOption_SocketAddressZZ(C2Tuple_PublicKeyCOption_SocketAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyCOption_SocketAddressZZ)); }
8479         C2Tuple_PublicKeyCOption_SocketAddressZZ(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ)); }
8480         operator LDKC2Tuple_PublicKeyCOption_SocketAddressZZ() && { LDKC2Tuple_PublicKeyCOption_SocketAddressZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ)); return res; }
8481         ~C2Tuple_PublicKeyCOption_SocketAddressZZ() { C2Tuple_PublicKeyCOption_SocketAddressZZ_free(self); }
8482         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; }
8483         LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator &() { return &self; }
8484         LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator ->() { return &self; }
8485         const LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator &() const { return &self; }
8486         const LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator ->() const { return &self; }
8487 };
8488 class CResult_UnsignedChannelUpdateDecodeErrorZ {
8489 private:
8490         LDKCResult_UnsignedChannelUpdateDecodeErrorZ self;
8491 public:
8492         CResult_UnsignedChannelUpdateDecodeErrorZ(const CResult_UnsignedChannelUpdateDecodeErrorZ&) = delete;
8493         CResult_UnsignedChannelUpdateDecodeErrorZ(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); }
8494         CResult_UnsignedChannelUpdateDecodeErrorZ(LDKCResult_UnsignedChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); }
8495         operator LDKCResult_UnsignedChannelUpdateDecodeErrorZ() && { LDKCResult_UnsignedChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); return res; }
8496         ~CResult_UnsignedChannelUpdateDecodeErrorZ() { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); }
8497         CResult_UnsignedChannelUpdateDecodeErrorZ& operator=(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); return *this; }
8498         LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() { return &self; }
8499         LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() { return &self; }
8500         const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() const { return &self; }
8501         const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
8502 };
8503 class CResult_PayeePubKeySecp256k1ErrorZ {
8504 private:
8505         LDKCResult_PayeePubKeySecp256k1ErrorZ self;
8506 public:
8507         CResult_PayeePubKeySecp256k1ErrorZ(const CResult_PayeePubKeySecp256k1ErrorZ&) = delete;
8508         CResult_PayeePubKeySecp256k1ErrorZ(CResult_PayeePubKeySecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PayeePubKeySecp256k1ErrorZ)); }
8509         CResult_PayeePubKeySecp256k1ErrorZ(LDKCResult_PayeePubKeySecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PayeePubKeySecp256k1ErrorZ)); }
8510         operator LDKCResult_PayeePubKeySecp256k1ErrorZ() && { LDKCResult_PayeePubKeySecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PayeePubKeySecp256k1ErrorZ)); return res; }
8511         ~CResult_PayeePubKeySecp256k1ErrorZ() { CResult_PayeePubKeySecp256k1ErrorZ_free(self); }
8512         CResult_PayeePubKeySecp256k1ErrorZ& operator=(CResult_PayeePubKeySecp256k1ErrorZ&& o) { CResult_PayeePubKeySecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PayeePubKeySecp256k1ErrorZ)); return *this; }
8513         LDKCResult_PayeePubKeySecp256k1ErrorZ* operator &() { return &self; }
8514         LDKCResult_PayeePubKeySecp256k1ErrorZ* operator ->() { return &self; }
8515         const LDKCResult_PayeePubKeySecp256k1ErrorZ* operator &() const { return &self; }
8516         const LDKCResult_PayeePubKeySecp256k1ErrorZ* operator ->() const { return &self; }
8517 };
8518 class C2Tuple__u832u16Z {
8519 private:
8520         LDKC2Tuple__u832u16Z self;
8521 public:
8522         C2Tuple__u832u16Z(const C2Tuple__u832u16Z&) = delete;
8523         C2Tuple__u832u16Z(C2Tuple__u832u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple__u832u16Z)); }
8524         C2Tuple__u832u16Z(LDKC2Tuple__u832u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple__u832u16Z)); }
8525         operator LDKC2Tuple__u832u16Z() && { LDKC2Tuple__u832u16Z res = self; memset(&self, 0, sizeof(LDKC2Tuple__u832u16Z)); return res; }
8526         ~C2Tuple__u832u16Z() { C2Tuple__u832u16Z_free(self); }
8527         C2Tuple__u832u16Z& operator=(C2Tuple__u832u16Z&& o) { C2Tuple__u832u16Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple__u832u16Z)); return *this; }
8528         LDKC2Tuple__u832u16Z* operator &() { return &self; }
8529         LDKC2Tuple__u832u16Z* operator ->() { return &self; }
8530         const LDKC2Tuple__u832u16Z* operator &() const { return &self; }
8531         const LDKC2Tuple__u832u16Z* operator ->() const { return &self; }
8532 };
8533 class COption_BigEndianScalarZ {
8534 private:
8535         LDKCOption_BigEndianScalarZ self;
8536 public:
8537         COption_BigEndianScalarZ(const COption_BigEndianScalarZ&) = delete;
8538         COption_BigEndianScalarZ(COption_BigEndianScalarZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_BigEndianScalarZ)); }
8539         COption_BigEndianScalarZ(LDKCOption_BigEndianScalarZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_BigEndianScalarZ)); }
8540         operator LDKCOption_BigEndianScalarZ() && { LDKCOption_BigEndianScalarZ res = self; memset(&self, 0, sizeof(LDKCOption_BigEndianScalarZ)); return res; }
8541         ~COption_BigEndianScalarZ() { COption_BigEndianScalarZ_free(self); }
8542         COption_BigEndianScalarZ& operator=(COption_BigEndianScalarZ&& o) { COption_BigEndianScalarZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_BigEndianScalarZ)); return *this; }
8543         LDKCOption_BigEndianScalarZ* operator &() { return &self; }
8544         LDKCOption_BigEndianScalarZ* operator ->() { return &self; }
8545         const LDKCOption_BigEndianScalarZ* operator &() const { return &self; }
8546         const LDKCOption_BigEndianScalarZ* operator ->() const { return &self; }
8547 };
8548 class CResult_PublicKeySecp256k1ErrorZ {
8549 private:
8550         LDKCResult_PublicKeySecp256k1ErrorZ self;
8551 public:
8552         CResult_PublicKeySecp256k1ErrorZ(const CResult_PublicKeySecp256k1ErrorZ&) = delete;
8553         CResult_PublicKeySecp256k1ErrorZ(CResult_PublicKeySecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PublicKeySecp256k1ErrorZ)); }
8554         CResult_PublicKeySecp256k1ErrorZ(LDKCResult_PublicKeySecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PublicKeySecp256k1ErrorZ)); }
8555         operator LDKCResult_PublicKeySecp256k1ErrorZ() && { LDKCResult_PublicKeySecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PublicKeySecp256k1ErrorZ)); return res; }
8556         ~CResult_PublicKeySecp256k1ErrorZ() { CResult_PublicKeySecp256k1ErrorZ_free(self); }
8557         CResult_PublicKeySecp256k1ErrorZ& operator=(CResult_PublicKeySecp256k1ErrorZ&& o) { CResult_PublicKeySecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PublicKeySecp256k1ErrorZ)); return *this; }
8558         LDKCResult_PublicKeySecp256k1ErrorZ* operator &() { return &self; }
8559         LDKCResult_PublicKeySecp256k1ErrorZ* operator ->() { return &self; }
8560         const LDKCResult_PublicKeySecp256k1ErrorZ* operator &() const { return &self; }
8561         const LDKCResult_PublicKeySecp256k1ErrorZ* operator ->() const { return &self; }
8562 };
8563 class CResult_CVec_ECDSASignatureZNoneZ {
8564 private:
8565         LDKCResult_CVec_ECDSASignatureZNoneZ self;
8566 public:
8567         CResult_CVec_ECDSASignatureZNoneZ(const CResult_CVec_ECDSASignatureZNoneZ&) = delete;
8568         CResult_CVec_ECDSASignatureZNoneZ(CResult_CVec_ECDSASignatureZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_ECDSASignatureZNoneZ)); }
8569         CResult_CVec_ECDSASignatureZNoneZ(LDKCResult_CVec_ECDSASignatureZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ)); }
8570         operator LDKCResult_CVec_ECDSASignatureZNoneZ() && { LDKCResult_CVec_ECDSASignatureZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ)); return res; }
8571         ~CResult_CVec_ECDSASignatureZNoneZ() { CResult_CVec_ECDSASignatureZNoneZ_free(self); }
8572         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; }
8573         LDKCResult_CVec_ECDSASignatureZNoneZ* operator &() { return &self; }
8574         LDKCResult_CVec_ECDSASignatureZNoneZ* operator ->() { return &self; }
8575         const LDKCResult_CVec_ECDSASignatureZNoneZ* operator &() const { return &self; }
8576         const LDKCResult_CVec_ECDSASignatureZNoneZ* operator ->() const { return &self; }
8577 };
8578 class CVec_BlindedHopZ {
8579 private:
8580         LDKCVec_BlindedHopZ self;
8581 public:
8582         CVec_BlindedHopZ(const CVec_BlindedHopZ&) = delete;
8583         CVec_BlindedHopZ(CVec_BlindedHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BlindedHopZ)); }
8584         CVec_BlindedHopZ(LDKCVec_BlindedHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BlindedHopZ)); }
8585         operator LDKCVec_BlindedHopZ() && { LDKCVec_BlindedHopZ res = self; memset(&self, 0, sizeof(LDKCVec_BlindedHopZ)); return res; }
8586         ~CVec_BlindedHopZ() { CVec_BlindedHopZ_free(self); }
8587         CVec_BlindedHopZ& operator=(CVec_BlindedHopZ&& o) { CVec_BlindedHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BlindedHopZ)); return *this; }
8588         LDKCVec_BlindedHopZ* operator &() { return &self; }
8589         LDKCVec_BlindedHopZ* operator ->() { return &self; }
8590         const LDKCVec_BlindedHopZ* operator &() const { return &self; }
8591         const LDKCVec_BlindedHopZ* operator ->() const { return &self; }
8592 };
8593 class CResult_COption_ClosureReasonZDecodeErrorZ {
8594 private:
8595         LDKCResult_COption_ClosureReasonZDecodeErrorZ self;
8596 public:
8597         CResult_COption_ClosureReasonZDecodeErrorZ(const CResult_COption_ClosureReasonZDecodeErrorZ&) = delete;
8598         CResult_COption_ClosureReasonZDecodeErrorZ(CResult_COption_ClosureReasonZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_ClosureReasonZDecodeErrorZ)); }
8599         CResult_COption_ClosureReasonZDecodeErrorZ(LDKCResult_COption_ClosureReasonZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); }
8600         operator LDKCResult_COption_ClosureReasonZDecodeErrorZ() && { LDKCResult_COption_ClosureReasonZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); return res; }
8601         ~CResult_COption_ClosureReasonZDecodeErrorZ() { CResult_COption_ClosureReasonZDecodeErrorZ_free(self); }
8602         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; }
8603         LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() { return &self; }
8604         LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() { return &self; }
8605         const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() const { return &self; }
8606         const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() const { return &self; }
8607 };
8608 class CResult_InvoiceErrorDecodeErrorZ {
8609 private:
8610         LDKCResult_InvoiceErrorDecodeErrorZ self;
8611 public:
8612         CResult_InvoiceErrorDecodeErrorZ(const CResult_InvoiceErrorDecodeErrorZ&) = delete;
8613         CResult_InvoiceErrorDecodeErrorZ(CResult_InvoiceErrorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceErrorDecodeErrorZ)); }
8614         CResult_InvoiceErrorDecodeErrorZ(LDKCResult_InvoiceErrorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceErrorDecodeErrorZ)); }
8615         operator LDKCResult_InvoiceErrorDecodeErrorZ() && { LDKCResult_InvoiceErrorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceErrorDecodeErrorZ)); return res; }
8616         ~CResult_InvoiceErrorDecodeErrorZ() { CResult_InvoiceErrorDecodeErrorZ_free(self); }
8617         CResult_InvoiceErrorDecodeErrorZ& operator=(CResult_InvoiceErrorDecodeErrorZ&& o) { CResult_InvoiceErrorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceErrorDecodeErrorZ)); return *this; }
8618         LDKCResult_InvoiceErrorDecodeErrorZ* operator &() { return &self; }
8619         LDKCResult_InvoiceErrorDecodeErrorZ* operator ->() { return &self; }
8620         const LDKCResult_InvoiceErrorDecodeErrorZ* operator &() const { return &self; }
8621         const LDKCResult_InvoiceErrorDecodeErrorZ* operator ->() const { return &self; }
8622 };
8623 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
8624 private:
8625         LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ self;
8626 public:
8627         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(const C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&) = delete;
8628         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
8629         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
8630         operator LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() && { LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return res; }
8631         ~C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); }
8632         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ& operator=(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return *this; }
8633         LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() { return &self; }
8634         LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() { return &self; }
8635         const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() const { return &self; }
8636         const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() const { return &self; }
8637 };
8638 class CResult_RouteParametersDecodeErrorZ {
8639 private:
8640         LDKCResult_RouteParametersDecodeErrorZ self;
8641 public:
8642         CResult_RouteParametersDecodeErrorZ(const CResult_RouteParametersDecodeErrorZ&) = delete;
8643         CResult_RouteParametersDecodeErrorZ(CResult_RouteParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); }
8644         CResult_RouteParametersDecodeErrorZ(LDKCResult_RouteParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); }
8645         operator LDKCResult_RouteParametersDecodeErrorZ() && { LDKCResult_RouteParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); return res; }
8646         ~CResult_RouteParametersDecodeErrorZ() { CResult_RouteParametersDecodeErrorZ_free(self); }
8647         CResult_RouteParametersDecodeErrorZ& operator=(CResult_RouteParametersDecodeErrorZ&& o) { CResult_RouteParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); return *this; }
8648         LDKCResult_RouteParametersDecodeErrorZ* operator &() { return &self; }
8649         LDKCResult_RouteParametersDecodeErrorZ* operator ->() { return &self; }
8650         const LDKCResult_RouteParametersDecodeErrorZ* operator &() const { return &self; }
8651         const LDKCResult_RouteParametersDecodeErrorZ* operator ->() const { return &self; }
8652 };
8653 class CResult_PrivateRouteCreationErrorZ {
8654 private:
8655         LDKCResult_PrivateRouteCreationErrorZ self;
8656 public:
8657         CResult_PrivateRouteCreationErrorZ(const CResult_PrivateRouteCreationErrorZ&) = delete;
8658         CResult_PrivateRouteCreationErrorZ(CResult_PrivateRouteCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); }
8659         CResult_PrivateRouteCreationErrorZ(LDKCResult_PrivateRouteCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); }
8660         operator LDKCResult_PrivateRouteCreationErrorZ() && { LDKCResult_PrivateRouteCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); return res; }
8661         ~CResult_PrivateRouteCreationErrorZ() { CResult_PrivateRouteCreationErrorZ_free(self); }
8662         CResult_PrivateRouteCreationErrorZ& operator=(CResult_PrivateRouteCreationErrorZ&& o) { CResult_PrivateRouteCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); return *this; }
8663         LDKCResult_PrivateRouteCreationErrorZ* operator &() { return &self; }
8664         LDKCResult_PrivateRouteCreationErrorZ* operator ->() { return &self; }
8665         const LDKCResult_PrivateRouteCreationErrorZ* operator &() const { return &self; }
8666         const LDKCResult_PrivateRouteCreationErrorZ* operator ->() const { return &self; }
8667 };
8668 class CResult_NodeAliasDecodeErrorZ {
8669 private:
8670         LDKCResult_NodeAliasDecodeErrorZ self;
8671 public:
8672         CResult_NodeAliasDecodeErrorZ(const CResult_NodeAliasDecodeErrorZ&) = delete;
8673         CResult_NodeAliasDecodeErrorZ(CResult_NodeAliasDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); }
8674         CResult_NodeAliasDecodeErrorZ(LDKCResult_NodeAliasDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); }
8675         operator LDKCResult_NodeAliasDecodeErrorZ() && { LDKCResult_NodeAliasDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); return res; }
8676         ~CResult_NodeAliasDecodeErrorZ() { CResult_NodeAliasDecodeErrorZ_free(self); }
8677         CResult_NodeAliasDecodeErrorZ& operator=(CResult_NodeAliasDecodeErrorZ&& o) { CResult_NodeAliasDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); return *this; }
8678         LDKCResult_NodeAliasDecodeErrorZ* operator &() { return &self; }
8679         LDKCResult_NodeAliasDecodeErrorZ* operator ->() { return &self; }
8680         const LDKCResult_NodeAliasDecodeErrorZ* operator &() const { return &self; }
8681         const LDKCResult_NodeAliasDecodeErrorZ* operator ->() const { return &self; }
8682 };
8683 class CVec_UpdateFulfillHTLCZ {
8684 private:
8685         LDKCVec_UpdateFulfillHTLCZ self;
8686 public:
8687         CVec_UpdateFulfillHTLCZ(const CVec_UpdateFulfillHTLCZ&) = delete;
8688         CVec_UpdateFulfillHTLCZ(CVec_UpdateFulfillHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); }
8689         CVec_UpdateFulfillHTLCZ(LDKCVec_UpdateFulfillHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); }
8690         operator LDKCVec_UpdateFulfillHTLCZ() && { LDKCVec_UpdateFulfillHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); return res; }
8691         ~CVec_UpdateFulfillHTLCZ() { CVec_UpdateFulfillHTLCZ_free(self); }
8692         CVec_UpdateFulfillHTLCZ& operator=(CVec_UpdateFulfillHTLCZ&& o) { CVec_UpdateFulfillHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); return *this; }
8693         LDKCVec_UpdateFulfillHTLCZ* operator &() { return &self; }
8694         LDKCVec_UpdateFulfillHTLCZ* operator ->() { return &self; }
8695         const LDKCVec_UpdateFulfillHTLCZ* operator &() const { return &self; }
8696         const LDKCVec_UpdateFulfillHTLCZ* operator ->() const { return &self; }
8697 };
8698 class CVec_C2Tuple_u32CVec_u8ZZZ {
8699 private:
8700         LDKCVec_C2Tuple_u32CVec_u8ZZZ self;
8701 public:
8702         CVec_C2Tuple_u32CVec_u8ZZZ(const CVec_C2Tuple_u32CVec_u8ZZZ&) = delete;
8703         CVec_C2Tuple_u32CVec_u8ZZZ(CVec_C2Tuple_u32CVec_u8ZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32CVec_u8ZZZ)); }
8704         CVec_C2Tuple_u32CVec_u8ZZZ(LDKCVec_C2Tuple_u32CVec_u8ZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32CVec_u8ZZZ)); }
8705         operator LDKCVec_C2Tuple_u32CVec_u8ZZZ() && { LDKCVec_C2Tuple_u32CVec_u8ZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32CVec_u8ZZZ)); return res; }
8706         ~CVec_C2Tuple_u32CVec_u8ZZZ() { CVec_C2Tuple_u32CVec_u8ZZZ_free(self); }
8707         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; }
8708         LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator &() { return &self; }
8709         LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator ->() { return &self; }
8710         const LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator &() const { return &self; }
8711         const LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator ->() const { return &self; }
8712 };
8713 class C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ {
8714 private:
8715         LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ self;
8716 public:
8717         C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ(const C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ&) = delete;
8718         C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ(C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ)); }
8719         C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ)); }
8720         operator LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ() && { LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ)); return res; }
8721         ~C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ() { C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_free(self); }
8722         C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ& operator=(C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ&& o) { C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ)); return *this; }
8723         LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ* operator &() { return &self; }
8724         LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ* operator ->() { return &self; }
8725         const LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ* operator &() const { return &self; }
8726         const LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ* operator ->() const { return &self; }
8727 };
8728 class CResult_AnnouncementSignaturesDecodeErrorZ {
8729 private:
8730         LDKCResult_AnnouncementSignaturesDecodeErrorZ self;
8731 public:
8732         CResult_AnnouncementSignaturesDecodeErrorZ(const CResult_AnnouncementSignaturesDecodeErrorZ&) = delete;
8733         CResult_AnnouncementSignaturesDecodeErrorZ(CResult_AnnouncementSignaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); }
8734         CResult_AnnouncementSignaturesDecodeErrorZ(LDKCResult_AnnouncementSignaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); }
8735         operator LDKCResult_AnnouncementSignaturesDecodeErrorZ() && { LDKCResult_AnnouncementSignaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); return res; }
8736         ~CResult_AnnouncementSignaturesDecodeErrorZ() { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); }
8737         CResult_AnnouncementSignaturesDecodeErrorZ& operator=(CResult_AnnouncementSignaturesDecodeErrorZ&& o) { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); return *this; }
8738         LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() { return &self; }
8739         LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() { return &self; }
8740         const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() const { return &self; }
8741         const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() const { return &self; }
8742 };
8743 class CResult_TxCompleteDecodeErrorZ {
8744 private:
8745         LDKCResult_TxCompleteDecodeErrorZ self;
8746 public:
8747         CResult_TxCompleteDecodeErrorZ(const CResult_TxCompleteDecodeErrorZ&) = delete;
8748         CResult_TxCompleteDecodeErrorZ(CResult_TxCompleteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCompleteDecodeErrorZ)); }
8749         CResult_TxCompleteDecodeErrorZ(LDKCResult_TxCompleteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCompleteDecodeErrorZ)); }
8750         operator LDKCResult_TxCompleteDecodeErrorZ() && { LDKCResult_TxCompleteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCompleteDecodeErrorZ)); return res; }
8751         ~CResult_TxCompleteDecodeErrorZ() { CResult_TxCompleteDecodeErrorZ_free(self); }
8752         CResult_TxCompleteDecodeErrorZ& operator=(CResult_TxCompleteDecodeErrorZ&& o) { CResult_TxCompleteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCompleteDecodeErrorZ)); return *this; }
8753         LDKCResult_TxCompleteDecodeErrorZ* operator &() { return &self; }
8754         LDKCResult_TxCompleteDecodeErrorZ* operator ->() { return &self; }
8755         const LDKCResult_TxCompleteDecodeErrorZ* operator &() const { return &self; }
8756         const LDKCResult_TxCompleteDecodeErrorZ* operator ->() const { return &self; }
8757 };
8758 class CResult_UpdateFulfillHTLCDecodeErrorZ {
8759 private:
8760         LDKCResult_UpdateFulfillHTLCDecodeErrorZ self;
8761 public:
8762         CResult_UpdateFulfillHTLCDecodeErrorZ(const CResult_UpdateFulfillHTLCDecodeErrorZ&) = delete;
8763         CResult_UpdateFulfillHTLCDecodeErrorZ(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); }
8764         CResult_UpdateFulfillHTLCDecodeErrorZ(LDKCResult_UpdateFulfillHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); }
8765         operator LDKCResult_UpdateFulfillHTLCDecodeErrorZ() && { LDKCResult_UpdateFulfillHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); return res; }
8766         ~CResult_UpdateFulfillHTLCDecodeErrorZ() { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); }
8767         CResult_UpdateFulfillHTLCDecodeErrorZ& operator=(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); return *this; }
8768         LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() { return &self; }
8769         LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() { return &self; }
8770         const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() const { return &self; }
8771         const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() const { return &self; }
8772 };
8773 class CResult_NodeFeaturesDecodeErrorZ {
8774 private:
8775         LDKCResult_NodeFeaturesDecodeErrorZ self;
8776 public:
8777         CResult_NodeFeaturesDecodeErrorZ(const CResult_NodeFeaturesDecodeErrorZ&) = delete;
8778         CResult_NodeFeaturesDecodeErrorZ(CResult_NodeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); }
8779         CResult_NodeFeaturesDecodeErrorZ(LDKCResult_NodeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); }
8780         operator LDKCResult_NodeFeaturesDecodeErrorZ() && { LDKCResult_NodeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); return res; }
8781         ~CResult_NodeFeaturesDecodeErrorZ() { CResult_NodeFeaturesDecodeErrorZ_free(self); }
8782         CResult_NodeFeaturesDecodeErrorZ& operator=(CResult_NodeFeaturesDecodeErrorZ&& o) { CResult_NodeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); return *this; }
8783         LDKCResult_NodeFeaturesDecodeErrorZ* operator &() { return &self; }
8784         LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() { return &self; }
8785         const LDKCResult_NodeFeaturesDecodeErrorZ* operator &() const { return &self; }
8786         const LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() const { return &self; }
8787 };
8788 class CResult_InMemorySignerDecodeErrorZ {
8789 private:
8790         LDKCResult_InMemorySignerDecodeErrorZ self;
8791 public:
8792         CResult_InMemorySignerDecodeErrorZ(const CResult_InMemorySignerDecodeErrorZ&) = delete;
8793         CResult_InMemorySignerDecodeErrorZ(CResult_InMemorySignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); }
8794         CResult_InMemorySignerDecodeErrorZ(LDKCResult_InMemorySignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); }
8795         operator LDKCResult_InMemorySignerDecodeErrorZ() && { LDKCResult_InMemorySignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); return res; }
8796         ~CResult_InMemorySignerDecodeErrorZ() { CResult_InMemorySignerDecodeErrorZ_free(self); }
8797         CResult_InMemorySignerDecodeErrorZ& operator=(CResult_InMemorySignerDecodeErrorZ&& o) { CResult_InMemorySignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); return *this; }
8798         LDKCResult_InMemorySignerDecodeErrorZ* operator &() { return &self; }
8799         LDKCResult_InMemorySignerDecodeErrorZ* operator ->() { return &self; }
8800         const LDKCResult_InMemorySignerDecodeErrorZ* operator &() const { return &self; }
8801         const LDKCResult_InMemorySignerDecodeErrorZ* operator ->() const { return &self; }
8802 };
8803 class CResult_TxSignaturesDecodeErrorZ {
8804 private:
8805         LDKCResult_TxSignaturesDecodeErrorZ self;
8806 public:
8807         CResult_TxSignaturesDecodeErrorZ(const CResult_TxSignaturesDecodeErrorZ&) = delete;
8808         CResult_TxSignaturesDecodeErrorZ(CResult_TxSignaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxSignaturesDecodeErrorZ)); }
8809         CResult_TxSignaturesDecodeErrorZ(LDKCResult_TxSignaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxSignaturesDecodeErrorZ)); }
8810         operator LDKCResult_TxSignaturesDecodeErrorZ() && { LDKCResult_TxSignaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxSignaturesDecodeErrorZ)); return res; }
8811         ~CResult_TxSignaturesDecodeErrorZ() { CResult_TxSignaturesDecodeErrorZ_free(self); }
8812         CResult_TxSignaturesDecodeErrorZ& operator=(CResult_TxSignaturesDecodeErrorZ&& o) { CResult_TxSignaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxSignaturesDecodeErrorZ)); return *this; }
8813         LDKCResult_TxSignaturesDecodeErrorZ* operator &() { return &self; }
8814         LDKCResult_TxSignaturesDecodeErrorZ* operator ->() { return &self; }
8815         const LDKCResult_TxSignaturesDecodeErrorZ* operator &() const { return &self; }
8816         const LDKCResult_TxSignaturesDecodeErrorZ* operator ->() const { return &self; }
8817 };
8818 class CVec_HTLCDescriptorZ {
8819 private:
8820         LDKCVec_HTLCDescriptorZ self;
8821 public:
8822         CVec_HTLCDescriptorZ(const CVec_HTLCDescriptorZ&) = delete;
8823         CVec_HTLCDescriptorZ(CVec_HTLCDescriptorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_HTLCDescriptorZ)); }
8824         CVec_HTLCDescriptorZ(LDKCVec_HTLCDescriptorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_HTLCDescriptorZ)); }
8825         operator LDKCVec_HTLCDescriptorZ() && { LDKCVec_HTLCDescriptorZ res = self; memset(&self, 0, sizeof(LDKCVec_HTLCDescriptorZ)); return res; }
8826         ~CVec_HTLCDescriptorZ() { CVec_HTLCDescriptorZ_free(self); }
8827         CVec_HTLCDescriptorZ& operator=(CVec_HTLCDescriptorZ&& o) { CVec_HTLCDescriptorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_HTLCDescriptorZ)); return *this; }
8828         LDKCVec_HTLCDescriptorZ* operator &() { return &self; }
8829         LDKCVec_HTLCDescriptorZ* operator ->() { return &self; }
8830         const LDKCVec_HTLCDescriptorZ* operator &() const { return &self; }
8831         const LDKCVec_HTLCDescriptorZ* operator ->() const { return &self; }
8832 };
8833 class CResult_ReplyShortChannelIdsEndDecodeErrorZ {
8834 private:
8835         LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ self;
8836 public:
8837         CResult_ReplyShortChannelIdsEndDecodeErrorZ(const CResult_ReplyShortChannelIdsEndDecodeErrorZ&) = delete;
8838         CResult_ReplyShortChannelIdsEndDecodeErrorZ(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
8839         CResult_ReplyShortChannelIdsEndDecodeErrorZ(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
8840         operator LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ() && { LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); return res; }
8841         ~CResult_ReplyShortChannelIdsEndDecodeErrorZ() { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); }
8842         CResult_ReplyShortChannelIdsEndDecodeErrorZ& operator=(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); return *this; }
8843         LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() { return &self; }
8844         LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() { return &self; }
8845         const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() const { return &self; }
8846         const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() const { return &self; }
8847 };
8848 class COption_PathFailureZ {
8849 private:
8850         LDKCOption_PathFailureZ self;
8851 public:
8852         COption_PathFailureZ(const COption_PathFailureZ&) = delete;
8853         COption_PathFailureZ(COption_PathFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_PathFailureZ)); }
8854         COption_PathFailureZ(LDKCOption_PathFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_PathFailureZ)); }
8855         operator LDKCOption_PathFailureZ() && { LDKCOption_PathFailureZ res = self; memset(&self, 0, sizeof(LDKCOption_PathFailureZ)); return res; }
8856         ~COption_PathFailureZ() { COption_PathFailureZ_free(self); }
8857         COption_PathFailureZ& operator=(COption_PathFailureZ&& o) { COption_PathFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_PathFailureZ)); return *this; }
8858         LDKCOption_PathFailureZ* operator &() { return &self; }
8859         LDKCOption_PathFailureZ* operator ->() { return &self; }
8860         const LDKCOption_PathFailureZ* operator &() const { return &self; }
8861         const LDKCOption_PathFailureZ* operator ->() const { return &self; }
8862 };
8863 class CResult_StrSecp256k1ErrorZ {
8864 private:
8865         LDKCResult_StrSecp256k1ErrorZ self;
8866 public:
8867         CResult_StrSecp256k1ErrorZ(const CResult_StrSecp256k1ErrorZ&) = delete;
8868         CResult_StrSecp256k1ErrorZ(CResult_StrSecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StrSecp256k1ErrorZ)); }
8869         CResult_StrSecp256k1ErrorZ(LDKCResult_StrSecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StrSecp256k1ErrorZ)); }
8870         operator LDKCResult_StrSecp256k1ErrorZ() && { LDKCResult_StrSecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StrSecp256k1ErrorZ)); return res; }
8871         ~CResult_StrSecp256k1ErrorZ() { CResult_StrSecp256k1ErrorZ_free(self); }
8872         CResult_StrSecp256k1ErrorZ& operator=(CResult_StrSecp256k1ErrorZ&& o) { CResult_StrSecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StrSecp256k1ErrorZ)); return *this; }
8873         LDKCResult_StrSecp256k1ErrorZ* operator &() { return &self; }
8874         LDKCResult_StrSecp256k1ErrorZ* operator ->() { return &self; }
8875         const LDKCResult_StrSecp256k1ErrorZ* operator &() const { return &self; }
8876         const LDKCResult_StrSecp256k1ErrorZ* operator ->() const { return &self; }
8877 };
8878 class CVec_ECDSASignatureZ {
8879 private:
8880         LDKCVec_ECDSASignatureZ self;
8881 public:
8882         CVec_ECDSASignatureZ(const CVec_ECDSASignatureZ&) = delete;
8883         CVec_ECDSASignatureZ(CVec_ECDSASignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ECDSASignatureZ)); }
8884         CVec_ECDSASignatureZ(LDKCVec_ECDSASignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ECDSASignatureZ)); }
8885         operator LDKCVec_ECDSASignatureZ() && { LDKCVec_ECDSASignatureZ res = self; memset(&self, 0, sizeof(LDKCVec_ECDSASignatureZ)); return res; }
8886         ~CVec_ECDSASignatureZ() { CVec_ECDSASignatureZ_free(self); }
8887         CVec_ECDSASignatureZ& operator=(CVec_ECDSASignatureZ&& o) { CVec_ECDSASignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ECDSASignatureZ)); return *this; }
8888         LDKCVec_ECDSASignatureZ* operator &() { return &self; }
8889         LDKCVec_ECDSASignatureZ* operator ->() { return &self; }
8890         const LDKCVec_ECDSASignatureZ* operator &() const { return &self; }
8891         const LDKCVec_ECDSASignatureZ* operator ->() const { return &self; }
8892 };
8893 class CResult_ChannelUpdateInfoDecodeErrorZ {
8894 private:
8895         LDKCResult_ChannelUpdateInfoDecodeErrorZ self;
8896 public:
8897         CResult_ChannelUpdateInfoDecodeErrorZ(const CResult_ChannelUpdateInfoDecodeErrorZ&) = delete;
8898         CResult_ChannelUpdateInfoDecodeErrorZ(CResult_ChannelUpdateInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); }
8899         CResult_ChannelUpdateInfoDecodeErrorZ(LDKCResult_ChannelUpdateInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); }
8900         operator LDKCResult_ChannelUpdateInfoDecodeErrorZ() && { LDKCResult_ChannelUpdateInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); return res; }
8901         ~CResult_ChannelUpdateInfoDecodeErrorZ() { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); }
8902         CResult_ChannelUpdateInfoDecodeErrorZ& operator=(CResult_ChannelUpdateInfoDecodeErrorZ&& o) { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); return *this; }
8903         LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() { return &self; }
8904         LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() { return &self; }
8905         const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() const { return &self; }
8906         const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() const { return &self; }
8907 };
8908 class CVec_UpdateFailHTLCZ {
8909 private:
8910         LDKCVec_UpdateFailHTLCZ self;
8911 public:
8912         CVec_UpdateFailHTLCZ(const CVec_UpdateFailHTLCZ&) = delete;
8913         CVec_UpdateFailHTLCZ(CVec_UpdateFailHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); }
8914         CVec_UpdateFailHTLCZ(LDKCVec_UpdateFailHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); }
8915         operator LDKCVec_UpdateFailHTLCZ() && { LDKCVec_UpdateFailHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); return res; }
8916         ~CVec_UpdateFailHTLCZ() { CVec_UpdateFailHTLCZ_free(self); }
8917         CVec_UpdateFailHTLCZ& operator=(CVec_UpdateFailHTLCZ&& o) { CVec_UpdateFailHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); return *this; }
8918         LDKCVec_UpdateFailHTLCZ* operator &() { return &self; }
8919         LDKCVec_UpdateFailHTLCZ* operator ->() { return &self; }
8920         const LDKCVec_UpdateFailHTLCZ* operator &() const { return &self; }
8921         const LDKCVec_UpdateFailHTLCZ* operator ->() const { return &self; }
8922 };
8923 class CVec_TxOutZ {
8924 private:
8925         LDKCVec_TxOutZ self;
8926 public:
8927         CVec_TxOutZ(const CVec_TxOutZ&) = delete;
8928         CVec_TxOutZ(CVec_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TxOutZ)); }
8929         CVec_TxOutZ(LDKCVec_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TxOutZ)); }
8930         operator LDKCVec_TxOutZ() && { LDKCVec_TxOutZ res = self; memset(&self, 0, sizeof(LDKCVec_TxOutZ)); return res; }
8931         ~CVec_TxOutZ() { CVec_TxOutZ_free(self); }
8932         CVec_TxOutZ& operator=(CVec_TxOutZ&& o) { CVec_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TxOutZ)); return *this; }
8933         LDKCVec_TxOutZ* operator &() { return &self; }
8934         LDKCVec_TxOutZ* operator ->() { return &self; }
8935         const LDKCVec_TxOutZ* operator &() const { return &self; }
8936         const LDKCVec_TxOutZ* operator ->() const { return &self; }
8937 };
8938 class CResult_BuiltCommitmentTransactionDecodeErrorZ {
8939 private:
8940         LDKCResult_BuiltCommitmentTransactionDecodeErrorZ self;
8941 public:
8942         CResult_BuiltCommitmentTransactionDecodeErrorZ(const CResult_BuiltCommitmentTransactionDecodeErrorZ&) = delete;
8943         CResult_BuiltCommitmentTransactionDecodeErrorZ(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); }
8944         CResult_BuiltCommitmentTransactionDecodeErrorZ(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); }
8945         operator LDKCResult_BuiltCommitmentTransactionDecodeErrorZ() && { LDKCResult_BuiltCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); return res; }
8946         ~CResult_BuiltCommitmentTransactionDecodeErrorZ() { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); }
8947         CResult_BuiltCommitmentTransactionDecodeErrorZ& operator=(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); return *this; }
8948         LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
8949         LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
8950         const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
8951         const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
8952 };
8953 class CVec_SpendableOutputDescriptorZ {
8954 private:
8955         LDKCVec_SpendableOutputDescriptorZ self;
8956 public:
8957         CVec_SpendableOutputDescriptorZ(const CVec_SpendableOutputDescriptorZ&) = delete;
8958         CVec_SpendableOutputDescriptorZ(CVec_SpendableOutputDescriptorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SpendableOutputDescriptorZ)); }
8959         CVec_SpendableOutputDescriptorZ(LDKCVec_SpendableOutputDescriptorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SpendableOutputDescriptorZ)); }
8960         operator LDKCVec_SpendableOutputDescriptorZ() && { LDKCVec_SpendableOutputDescriptorZ res = self; memset(&self, 0, sizeof(LDKCVec_SpendableOutputDescriptorZ)); return res; }
8961         ~CVec_SpendableOutputDescriptorZ() { CVec_SpendableOutputDescriptorZ_free(self); }
8962         CVec_SpendableOutputDescriptorZ& operator=(CVec_SpendableOutputDescriptorZ&& o) { CVec_SpendableOutputDescriptorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_SpendableOutputDescriptorZ)); return *this; }
8963         LDKCVec_SpendableOutputDescriptorZ* operator &() { return &self; }
8964         LDKCVec_SpendableOutputDescriptorZ* operator ->() { return &self; }
8965         const LDKCVec_SpendableOutputDescriptorZ* operator &() const { return &self; }
8966         const LDKCVec_SpendableOutputDescriptorZ* operator ->() const { return &self; }
8967 };
8968 class C2Tuple_OutPointCVec_u8ZZ {
8969 private:
8970         LDKC2Tuple_OutPointCVec_u8ZZ self;
8971 public:
8972         C2Tuple_OutPointCVec_u8ZZ(const C2Tuple_OutPointCVec_u8ZZ&) = delete;
8973         C2Tuple_OutPointCVec_u8ZZ(C2Tuple_OutPointCVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointCVec_u8ZZ)); }
8974         C2Tuple_OutPointCVec_u8ZZ(LDKC2Tuple_OutPointCVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointCVec_u8ZZ)); }
8975         operator LDKC2Tuple_OutPointCVec_u8ZZ() && { LDKC2Tuple_OutPointCVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointCVec_u8ZZ)); return res; }
8976         ~C2Tuple_OutPointCVec_u8ZZ() { C2Tuple_OutPointCVec_u8ZZ_free(self); }
8977         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; }
8978         LDKC2Tuple_OutPointCVec_u8ZZ* operator &() { return &self; }
8979         LDKC2Tuple_OutPointCVec_u8ZZ* operator ->() { return &self; }
8980         const LDKC2Tuple_OutPointCVec_u8ZZ* operator &() const { return &self; }
8981         const LDKC2Tuple_OutPointCVec_u8ZZ* operator ->() const { return &self; }
8982 };
8983 class CResult_WitnessNoneZ {
8984 private:
8985         LDKCResult_WitnessNoneZ self;
8986 public:
8987         CResult_WitnessNoneZ(const CResult_WitnessNoneZ&) = delete;
8988         CResult_WitnessNoneZ(CResult_WitnessNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WitnessNoneZ)); }
8989         CResult_WitnessNoneZ(LDKCResult_WitnessNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WitnessNoneZ)); }
8990         operator LDKCResult_WitnessNoneZ() && { LDKCResult_WitnessNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_WitnessNoneZ)); return res; }
8991         ~CResult_WitnessNoneZ() { CResult_WitnessNoneZ_free(self); }
8992         CResult_WitnessNoneZ& operator=(CResult_WitnessNoneZ&& o) { CResult_WitnessNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WitnessNoneZ)); return *this; }
8993         LDKCResult_WitnessNoneZ* operator &() { return &self; }
8994         LDKCResult_WitnessNoneZ* operator ->() { return &self; }
8995         const LDKCResult_WitnessNoneZ* operator &() const { return &self; }
8996         const LDKCResult_WitnessNoneZ* operator ->() const { return &self; }
8997 };
8998 class COption_C2Tuple_u64u64ZZ {
8999 private:
9000         LDKCOption_C2Tuple_u64u64ZZ self;
9001 public:
9002         COption_C2Tuple_u64u64ZZ(const COption_C2Tuple_u64u64ZZ&) = delete;
9003         COption_C2Tuple_u64u64ZZ(COption_C2Tuple_u64u64ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_u64u64ZZ)); }
9004         COption_C2Tuple_u64u64ZZ(LDKCOption_C2Tuple_u64u64ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_u64u64ZZ)); }
9005         operator LDKCOption_C2Tuple_u64u64ZZ() && { LDKCOption_C2Tuple_u64u64ZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_u64u64ZZ)); return res; }
9006         ~COption_C2Tuple_u64u64ZZ() { COption_C2Tuple_u64u64ZZ_free(self); }
9007         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; }
9008         LDKCOption_C2Tuple_u64u64ZZ* operator &() { return &self; }
9009         LDKCOption_C2Tuple_u64u64ZZ* operator ->() { return &self; }
9010         const LDKCOption_C2Tuple_u64u64ZZ* operator &() const { return &self; }
9011         const LDKCOption_C2Tuple_u64u64ZZ* operator ->() const { return &self; }
9012 };
9013 class CResult_ChannelAnnouncementDecodeErrorZ {
9014 private:
9015         LDKCResult_ChannelAnnouncementDecodeErrorZ self;
9016 public:
9017         CResult_ChannelAnnouncementDecodeErrorZ(const CResult_ChannelAnnouncementDecodeErrorZ&) = delete;
9018         CResult_ChannelAnnouncementDecodeErrorZ(CResult_ChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); }
9019         CResult_ChannelAnnouncementDecodeErrorZ(LDKCResult_ChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); }
9020         operator LDKCResult_ChannelAnnouncementDecodeErrorZ() && { LDKCResult_ChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); return res; }
9021         ~CResult_ChannelAnnouncementDecodeErrorZ() { CResult_ChannelAnnouncementDecodeErrorZ_free(self); }
9022         CResult_ChannelAnnouncementDecodeErrorZ& operator=(CResult_ChannelAnnouncementDecodeErrorZ&& o) { CResult_ChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); return *this; }
9023         LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
9024         LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
9025         const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
9026         const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
9027 };
9028 class CResult_HTLCUpdateDecodeErrorZ {
9029 private:
9030         LDKCResult_HTLCUpdateDecodeErrorZ self;
9031 public:
9032         CResult_HTLCUpdateDecodeErrorZ(const CResult_HTLCUpdateDecodeErrorZ&) = delete;
9033         CResult_HTLCUpdateDecodeErrorZ(CResult_HTLCUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCUpdateDecodeErrorZ)); }
9034         CResult_HTLCUpdateDecodeErrorZ(LDKCResult_HTLCUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCUpdateDecodeErrorZ)); }
9035         operator LDKCResult_HTLCUpdateDecodeErrorZ() && { LDKCResult_HTLCUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCUpdateDecodeErrorZ)); return res; }
9036         ~CResult_HTLCUpdateDecodeErrorZ() { CResult_HTLCUpdateDecodeErrorZ_free(self); }
9037         CResult_HTLCUpdateDecodeErrorZ& operator=(CResult_HTLCUpdateDecodeErrorZ&& o) { CResult_HTLCUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCUpdateDecodeErrorZ)); return *this; }
9038         LDKCResult_HTLCUpdateDecodeErrorZ* operator &() { return &self; }
9039         LDKCResult_HTLCUpdateDecodeErrorZ* operator ->() { return &self; }
9040         const LDKCResult_HTLCUpdateDecodeErrorZ* operator &() const { return &self; }
9041         const LDKCResult_HTLCUpdateDecodeErrorZ* operator ->() const { return &self; }
9042 };
9043 class CResult_TxAddInputDecodeErrorZ {
9044 private:
9045         LDKCResult_TxAddInputDecodeErrorZ self;
9046 public:
9047         CResult_TxAddInputDecodeErrorZ(const CResult_TxAddInputDecodeErrorZ&) = delete;
9048         CResult_TxAddInputDecodeErrorZ(CResult_TxAddInputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAddInputDecodeErrorZ)); }
9049         CResult_TxAddInputDecodeErrorZ(LDKCResult_TxAddInputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAddInputDecodeErrorZ)); }
9050         operator LDKCResult_TxAddInputDecodeErrorZ() && { LDKCResult_TxAddInputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAddInputDecodeErrorZ)); return res; }
9051         ~CResult_TxAddInputDecodeErrorZ() { CResult_TxAddInputDecodeErrorZ_free(self); }
9052         CResult_TxAddInputDecodeErrorZ& operator=(CResult_TxAddInputDecodeErrorZ&& o) { CResult_TxAddInputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAddInputDecodeErrorZ)); return *this; }
9053         LDKCResult_TxAddInputDecodeErrorZ* operator &() { return &self; }
9054         LDKCResult_TxAddInputDecodeErrorZ* operator ->() { return &self; }
9055         const LDKCResult_TxAddInputDecodeErrorZ* operator &() const { return &self; }
9056         const LDKCResult_TxAddInputDecodeErrorZ* operator ->() const { return &self; }
9057 };
9058 class CResult_PeeledOnionNoneZ {
9059 private:
9060         LDKCResult_PeeledOnionNoneZ self;
9061 public:
9062         CResult_PeeledOnionNoneZ(const CResult_PeeledOnionNoneZ&) = delete;
9063         CResult_PeeledOnionNoneZ(CResult_PeeledOnionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PeeledOnionNoneZ)); }
9064         CResult_PeeledOnionNoneZ(LDKCResult_PeeledOnionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PeeledOnionNoneZ)); }
9065         operator LDKCResult_PeeledOnionNoneZ() && { LDKCResult_PeeledOnionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_PeeledOnionNoneZ)); return res; }
9066         ~CResult_PeeledOnionNoneZ() { CResult_PeeledOnionNoneZ_free(self); }
9067         CResult_PeeledOnionNoneZ& operator=(CResult_PeeledOnionNoneZ&& o) { CResult_PeeledOnionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PeeledOnionNoneZ)); return *this; }
9068         LDKCResult_PeeledOnionNoneZ* operator &() { return &self; }
9069         LDKCResult_PeeledOnionNoneZ* operator ->() { return &self; }
9070         const LDKCResult_PeeledOnionNoneZ* operator &() const { return &self; }
9071         const LDKCResult_PeeledOnionNoneZ* operator ->() const { return &self; }
9072 };
9073 class CResult_TxInitRbfDecodeErrorZ {
9074 private:
9075         LDKCResult_TxInitRbfDecodeErrorZ self;
9076 public:
9077         CResult_TxInitRbfDecodeErrorZ(const CResult_TxInitRbfDecodeErrorZ&) = delete;
9078         CResult_TxInitRbfDecodeErrorZ(CResult_TxInitRbfDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxInitRbfDecodeErrorZ)); }
9079         CResult_TxInitRbfDecodeErrorZ(LDKCResult_TxInitRbfDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxInitRbfDecodeErrorZ)); }
9080         operator LDKCResult_TxInitRbfDecodeErrorZ() && { LDKCResult_TxInitRbfDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxInitRbfDecodeErrorZ)); return res; }
9081         ~CResult_TxInitRbfDecodeErrorZ() { CResult_TxInitRbfDecodeErrorZ_free(self); }
9082         CResult_TxInitRbfDecodeErrorZ& operator=(CResult_TxInitRbfDecodeErrorZ&& o) { CResult_TxInitRbfDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxInitRbfDecodeErrorZ)); return *this; }
9083         LDKCResult_TxInitRbfDecodeErrorZ* operator &() { return &self; }
9084         LDKCResult_TxInitRbfDecodeErrorZ* operator ->() { return &self; }
9085         const LDKCResult_TxInitRbfDecodeErrorZ* operator &() const { return &self; }
9086         const LDKCResult_TxInitRbfDecodeErrorZ* operator ->() const { return &self; }
9087 };
9088 class COption_WriteableScoreZ {
9089 private:
9090         LDKCOption_WriteableScoreZ self;
9091 public:
9092         COption_WriteableScoreZ(const COption_WriteableScoreZ&) = delete;
9093         COption_WriteableScoreZ(COption_WriteableScoreZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_WriteableScoreZ)); }
9094         COption_WriteableScoreZ(LDKCOption_WriteableScoreZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_WriteableScoreZ)); }
9095         operator LDKCOption_WriteableScoreZ() && { LDKCOption_WriteableScoreZ res = self; memset(&self, 0, sizeof(LDKCOption_WriteableScoreZ)); return res; }
9096         ~COption_WriteableScoreZ() { COption_WriteableScoreZ_free(self); }
9097         COption_WriteableScoreZ& operator=(COption_WriteableScoreZ&& o) { COption_WriteableScoreZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_WriteableScoreZ)); return *this; }
9098         LDKCOption_WriteableScoreZ* operator &() { return &self; }
9099         LDKCOption_WriteableScoreZ* operator ->() { return &self; }
9100         const LDKCOption_WriteableScoreZ* operator &() const { return &self; }
9101         const LDKCOption_WriteableScoreZ* operator ->() const { return &self; }
9102 };
9103 class CVec_StrZ {
9104 private:
9105         LDKCVec_StrZ self;
9106 public:
9107         CVec_StrZ(const CVec_StrZ&) = delete;
9108         CVec_StrZ(CVec_StrZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_StrZ)); }
9109         CVec_StrZ(LDKCVec_StrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_StrZ)); }
9110         operator LDKCVec_StrZ() && { LDKCVec_StrZ res = self; memset(&self, 0, sizeof(LDKCVec_StrZ)); return res; }
9111         ~CVec_StrZ() { CVec_StrZ_free(self); }
9112         CVec_StrZ& operator=(CVec_StrZ&& o) { CVec_StrZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_StrZ)); return *this; }
9113         LDKCVec_StrZ* operator &() { return &self; }
9114         LDKCVec_StrZ* operator ->() { return &self; }
9115         const LDKCVec_StrZ* operator &() const { return &self; }
9116         const LDKCVec_StrZ* operator ->() const { return &self; }
9117 };
9118 class CVec_OutPointZ {
9119 private:
9120         LDKCVec_OutPointZ self;
9121 public:
9122         CVec_OutPointZ(const CVec_OutPointZ&) = delete;
9123         CVec_OutPointZ(CVec_OutPointZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_OutPointZ)); }
9124         CVec_OutPointZ(LDKCVec_OutPointZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_OutPointZ)); }
9125         operator LDKCVec_OutPointZ() && { LDKCVec_OutPointZ res = self; memset(&self, 0, sizeof(LDKCVec_OutPointZ)); return res; }
9126         ~CVec_OutPointZ() { CVec_OutPointZ_free(self); }
9127         CVec_OutPointZ& operator=(CVec_OutPointZ&& o) { CVec_OutPointZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_OutPointZ)); return *this; }
9128         LDKCVec_OutPointZ* operator &() { return &self; }
9129         LDKCVec_OutPointZ* operator ->() { return &self; }
9130         const LDKCVec_OutPointZ* operator &() const { return &self; }
9131         const LDKCVec_OutPointZ* operator ->() const { return &self; }
9132 };
9133 class CResult_SpliceAckDecodeErrorZ {
9134 private:
9135         LDKCResult_SpliceAckDecodeErrorZ self;
9136 public:
9137         CResult_SpliceAckDecodeErrorZ(const CResult_SpliceAckDecodeErrorZ&) = delete;
9138         CResult_SpliceAckDecodeErrorZ(CResult_SpliceAckDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpliceAckDecodeErrorZ)); }
9139         CResult_SpliceAckDecodeErrorZ(LDKCResult_SpliceAckDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpliceAckDecodeErrorZ)); }
9140         operator LDKCResult_SpliceAckDecodeErrorZ() && { LDKCResult_SpliceAckDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpliceAckDecodeErrorZ)); return res; }
9141         ~CResult_SpliceAckDecodeErrorZ() { CResult_SpliceAckDecodeErrorZ_free(self); }
9142         CResult_SpliceAckDecodeErrorZ& operator=(CResult_SpliceAckDecodeErrorZ&& o) { CResult_SpliceAckDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpliceAckDecodeErrorZ)); return *this; }
9143         LDKCResult_SpliceAckDecodeErrorZ* operator &() { return &self; }
9144         LDKCResult_SpliceAckDecodeErrorZ* operator ->() { return &self; }
9145         const LDKCResult_SpliceAckDecodeErrorZ* operator &() const { return &self; }
9146         const LDKCResult_SpliceAckDecodeErrorZ* operator ->() const { return &self; }
9147 };
9148 class CResult_PositiveTimestampCreationErrorZ {
9149 private:
9150         LDKCResult_PositiveTimestampCreationErrorZ self;
9151 public:
9152         CResult_PositiveTimestampCreationErrorZ(const CResult_PositiveTimestampCreationErrorZ&) = delete;
9153         CResult_PositiveTimestampCreationErrorZ(CResult_PositiveTimestampCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PositiveTimestampCreationErrorZ)); }
9154         CResult_PositiveTimestampCreationErrorZ(LDKCResult_PositiveTimestampCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PositiveTimestampCreationErrorZ)); }
9155         operator LDKCResult_PositiveTimestampCreationErrorZ() && { LDKCResult_PositiveTimestampCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PositiveTimestampCreationErrorZ)); return res; }
9156         ~CResult_PositiveTimestampCreationErrorZ() { CResult_PositiveTimestampCreationErrorZ_free(self); }
9157         CResult_PositiveTimestampCreationErrorZ& operator=(CResult_PositiveTimestampCreationErrorZ&& o) { CResult_PositiveTimestampCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PositiveTimestampCreationErrorZ)); return *this; }
9158         LDKCResult_PositiveTimestampCreationErrorZ* operator &() { return &self; }
9159         LDKCResult_PositiveTimestampCreationErrorZ* operator ->() { return &self; }
9160         const LDKCResult_PositiveTimestampCreationErrorZ* operator &() const { return &self; }
9161         const LDKCResult_PositiveTimestampCreationErrorZ* operator ->() const { return &self; }
9162 };
9163 class CResult_ChannelMonitorUpdateDecodeErrorZ {
9164 private:
9165         LDKCResult_ChannelMonitorUpdateDecodeErrorZ self;
9166 public:
9167         CResult_ChannelMonitorUpdateDecodeErrorZ(const CResult_ChannelMonitorUpdateDecodeErrorZ&) = delete;
9168         CResult_ChannelMonitorUpdateDecodeErrorZ(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); }
9169         CResult_ChannelMonitorUpdateDecodeErrorZ(LDKCResult_ChannelMonitorUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); }
9170         operator LDKCResult_ChannelMonitorUpdateDecodeErrorZ() && { LDKCResult_ChannelMonitorUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); return res; }
9171         ~CResult_ChannelMonitorUpdateDecodeErrorZ() { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); }
9172         CResult_ChannelMonitorUpdateDecodeErrorZ& operator=(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); return *this; }
9173         LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() { return &self; }
9174         LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() { return &self; }
9175         const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() const { return &self; }
9176         const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() const { return &self; }
9177 };
9178 class C2Tuple_BlindedPayInfoBlindedPathZ {
9179 private:
9180         LDKC2Tuple_BlindedPayInfoBlindedPathZ self;
9181 public:
9182         C2Tuple_BlindedPayInfoBlindedPathZ(const C2Tuple_BlindedPayInfoBlindedPathZ&) = delete;
9183         C2Tuple_BlindedPayInfoBlindedPathZ(C2Tuple_BlindedPayInfoBlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BlindedPayInfoBlindedPathZ)); }
9184         C2Tuple_BlindedPayInfoBlindedPathZ(LDKC2Tuple_BlindedPayInfoBlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ)); }
9185         operator LDKC2Tuple_BlindedPayInfoBlindedPathZ() && { LDKC2Tuple_BlindedPayInfoBlindedPathZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ)); return res; }
9186         ~C2Tuple_BlindedPayInfoBlindedPathZ() { C2Tuple_BlindedPayInfoBlindedPathZ_free(self); }
9187         C2Tuple_BlindedPayInfoBlindedPathZ& operator=(C2Tuple_BlindedPayInfoBlindedPathZ&& o) { C2Tuple_BlindedPayInfoBlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BlindedPayInfoBlindedPathZ)); return *this; }
9188         LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator &() { return &self; }
9189         LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator ->() { return &self; }
9190         const LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator &() const { return &self; }
9191         const LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator ->() const { return &self; }
9192 };
9193 class CResult_ReplyChannelRangeDecodeErrorZ {
9194 private:
9195         LDKCResult_ReplyChannelRangeDecodeErrorZ self;
9196 public:
9197         CResult_ReplyChannelRangeDecodeErrorZ(const CResult_ReplyChannelRangeDecodeErrorZ&) = delete;
9198         CResult_ReplyChannelRangeDecodeErrorZ(CResult_ReplyChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); }
9199         CResult_ReplyChannelRangeDecodeErrorZ(LDKCResult_ReplyChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); }
9200         operator LDKCResult_ReplyChannelRangeDecodeErrorZ() && { LDKCResult_ReplyChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); return res; }
9201         ~CResult_ReplyChannelRangeDecodeErrorZ() { CResult_ReplyChannelRangeDecodeErrorZ_free(self); }
9202         CResult_ReplyChannelRangeDecodeErrorZ& operator=(CResult_ReplyChannelRangeDecodeErrorZ&& o) { CResult_ReplyChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); return *this; }
9203         LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() { return &self; }
9204         LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() { return &self; }
9205         const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() const { return &self; }
9206         const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() const { return &self; }
9207 };
9208 class CResult_UnsignedNodeAnnouncementDecodeErrorZ {
9209 private:
9210         LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ self;
9211 public:
9212         CResult_UnsignedNodeAnnouncementDecodeErrorZ(const CResult_UnsignedNodeAnnouncementDecodeErrorZ&) = delete;
9213         CResult_UnsignedNodeAnnouncementDecodeErrorZ(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
9214         CResult_UnsignedNodeAnnouncementDecodeErrorZ(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
9215         operator LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); return res; }
9216         ~CResult_UnsignedNodeAnnouncementDecodeErrorZ() { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); }
9217         CResult_UnsignedNodeAnnouncementDecodeErrorZ& operator=(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); return *this; }
9218         LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() { return &self; }
9219         LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
9220         const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
9221         const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
9222 };
9223 class CResult_TrustedClosingTransactionNoneZ {
9224 private:
9225         LDKCResult_TrustedClosingTransactionNoneZ self;
9226 public:
9227         CResult_TrustedClosingTransactionNoneZ(const CResult_TrustedClosingTransactionNoneZ&) = delete;
9228         CResult_TrustedClosingTransactionNoneZ(CResult_TrustedClosingTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedClosingTransactionNoneZ)); }
9229         CResult_TrustedClosingTransactionNoneZ(LDKCResult_TrustedClosingTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedClosingTransactionNoneZ)); }
9230         operator LDKCResult_TrustedClosingTransactionNoneZ() && { LDKCResult_TrustedClosingTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedClosingTransactionNoneZ)); return res; }
9231         ~CResult_TrustedClosingTransactionNoneZ() { CResult_TrustedClosingTransactionNoneZ_free(self); }
9232         CResult_TrustedClosingTransactionNoneZ& operator=(CResult_TrustedClosingTransactionNoneZ&& o) { CResult_TrustedClosingTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedClosingTransactionNoneZ)); return *this; }
9233         LDKCResult_TrustedClosingTransactionNoneZ* operator &() { return &self; }
9234         LDKCResult_TrustedClosingTransactionNoneZ* operator ->() { return &self; }
9235         const LDKCResult_TrustedClosingTransactionNoneZ* operator &() const { return &self; }
9236         const LDKCResult_TrustedClosingTransactionNoneZ* operator ->() const { return &self; }
9237 };
9238 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ {
9239 private:
9240         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ self;
9241 public:
9242         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(const CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&) = delete;
9243         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); }
9244         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); }
9245         operator LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); return res; }
9246         ~CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ() { CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(self); }
9247         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; }
9248         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator &() { return &self; }
9249         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator ->() { return &self; }
9250         const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator &() const { return &self; }
9251         const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator ->() const { return &self; }
9252 };
9253 class C2Tuple_PublicKeyTypeZ {
9254 private:
9255         LDKC2Tuple_PublicKeyTypeZ self;
9256 public:
9257         C2Tuple_PublicKeyTypeZ(const C2Tuple_PublicKeyTypeZ&) = delete;
9258         C2Tuple_PublicKeyTypeZ(C2Tuple_PublicKeyTypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyTypeZ)); }
9259         C2Tuple_PublicKeyTypeZ(LDKC2Tuple_PublicKeyTypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyTypeZ)); }
9260         operator LDKC2Tuple_PublicKeyTypeZ() && { LDKC2Tuple_PublicKeyTypeZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyTypeZ)); return res; }
9261         ~C2Tuple_PublicKeyTypeZ() { C2Tuple_PublicKeyTypeZ_free(self); }
9262         C2Tuple_PublicKeyTypeZ& operator=(C2Tuple_PublicKeyTypeZ&& o) { C2Tuple_PublicKeyTypeZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyTypeZ)); return *this; }
9263         LDKC2Tuple_PublicKeyTypeZ* operator &() { return &self; }
9264         LDKC2Tuple_PublicKeyTypeZ* operator ->() { return &self; }
9265         const LDKC2Tuple_PublicKeyTypeZ* operator &() const { return &self; }
9266         const LDKC2Tuple_PublicKeyTypeZ* operator ->() const { return &self; }
9267 };
9268 class CResult_TxRemoveOutputDecodeErrorZ {
9269 private:
9270         LDKCResult_TxRemoveOutputDecodeErrorZ self;
9271 public:
9272         CResult_TxRemoveOutputDecodeErrorZ(const CResult_TxRemoveOutputDecodeErrorZ&) = delete;
9273         CResult_TxRemoveOutputDecodeErrorZ(CResult_TxRemoveOutputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxRemoveOutputDecodeErrorZ)); }
9274         CResult_TxRemoveOutputDecodeErrorZ(LDKCResult_TxRemoveOutputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxRemoveOutputDecodeErrorZ)); }
9275         operator LDKCResult_TxRemoveOutputDecodeErrorZ() && { LDKCResult_TxRemoveOutputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxRemoveOutputDecodeErrorZ)); return res; }
9276         ~CResult_TxRemoveOutputDecodeErrorZ() { CResult_TxRemoveOutputDecodeErrorZ_free(self); }
9277         CResult_TxRemoveOutputDecodeErrorZ& operator=(CResult_TxRemoveOutputDecodeErrorZ&& o) { CResult_TxRemoveOutputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxRemoveOutputDecodeErrorZ)); return *this; }
9278         LDKCResult_TxRemoveOutputDecodeErrorZ* operator &() { return &self; }
9279         LDKCResult_TxRemoveOutputDecodeErrorZ* operator ->() { return &self; }
9280         const LDKCResult_TxRemoveOutputDecodeErrorZ* operator &() const { return &self; }
9281         const LDKCResult_TxRemoveOutputDecodeErrorZ* operator ->() const { return &self; }
9282 };
9283 class CResult_ChannelReestablishDecodeErrorZ {
9284 private:
9285         LDKCResult_ChannelReestablishDecodeErrorZ self;
9286 public:
9287         CResult_ChannelReestablishDecodeErrorZ(const CResult_ChannelReestablishDecodeErrorZ&) = delete;
9288         CResult_ChannelReestablishDecodeErrorZ(CResult_ChannelReestablishDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelReestablishDecodeErrorZ)); }
9289         CResult_ChannelReestablishDecodeErrorZ(LDKCResult_ChannelReestablishDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelReestablishDecodeErrorZ)); }
9290         operator LDKCResult_ChannelReestablishDecodeErrorZ() && { LDKCResult_ChannelReestablishDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelReestablishDecodeErrorZ)); return res; }
9291         ~CResult_ChannelReestablishDecodeErrorZ() { CResult_ChannelReestablishDecodeErrorZ_free(self); }
9292         CResult_ChannelReestablishDecodeErrorZ& operator=(CResult_ChannelReestablishDecodeErrorZ&& o) { CResult_ChannelReestablishDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelReestablishDecodeErrorZ)); return *this; }
9293         LDKCResult_ChannelReestablishDecodeErrorZ* operator &() { return &self; }
9294         LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() { return &self; }
9295         const LDKCResult_ChannelReestablishDecodeErrorZ* operator &() const { return &self; }
9296         const LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() const { return &self; }
9297 };
9298 class CResult_OnionMessageDecodeErrorZ {
9299 private:
9300         LDKCResult_OnionMessageDecodeErrorZ self;
9301 public:
9302         CResult_OnionMessageDecodeErrorZ(const CResult_OnionMessageDecodeErrorZ&) = delete;
9303         CResult_OnionMessageDecodeErrorZ(CResult_OnionMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionMessageDecodeErrorZ)); }
9304         CResult_OnionMessageDecodeErrorZ(LDKCResult_OnionMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionMessageDecodeErrorZ)); }
9305         operator LDKCResult_OnionMessageDecodeErrorZ() && { LDKCResult_OnionMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionMessageDecodeErrorZ)); return res; }
9306         ~CResult_OnionMessageDecodeErrorZ() { CResult_OnionMessageDecodeErrorZ_free(self); }
9307         CResult_OnionMessageDecodeErrorZ& operator=(CResult_OnionMessageDecodeErrorZ&& o) { CResult_OnionMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionMessageDecodeErrorZ)); return *this; }
9308         LDKCResult_OnionMessageDecodeErrorZ* operator &() { return &self; }
9309         LDKCResult_OnionMessageDecodeErrorZ* operator ->() { return &self; }
9310         const LDKCResult_OnionMessageDecodeErrorZ* operator &() const { return &self; }
9311         const LDKCResult_OnionMessageDecodeErrorZ* operator ->() const { return &self; }
9312 };
9313 class CResult_Bolt11InvoiceParseOrSemanticErrorZ {
9314 private:
9315         LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ self;
9316 public:
9317         CResult_Bolt11InvoiceParseOrSemanticErrorZ(const CResult_Bolt11InvoiceParseOrSemanticErrorZ&) = delete;
9318         CResult_Bolt11InvoiceParseOrSemanticErrorZ(CResult_Bolt11InvoiceParseOrSemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceParseOrSemanticErrorZ)); }
9319         CResult_Bolt11InvoiceParseOrSemanticErrorZ(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ)); }
9320         operator LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ() && { LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ)); return res; }
9321         ~CResult_Bolt11InvoiceParseOrSemanticErrorZ() { CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(self); }
9322         CResult_Bolt11InvoiceParseOrSemanticErrorZ& operator=(CResult_Bolt11InvoiceParseOrSemanticErrorZ&& o) { CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceParseOrSemanticErrorZ)); return *this; }
9323         LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator &() { return &self; }
9324         LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator ->() { return &self; }
9325         const LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator &() const { return &self; }
9326         const LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator ->() const { return &self; }
9327 };
9328 class CResult_InitFeaturesDecodeErrorZ {
9329 private:
9330         LDKCResult_InitFeaturesDecodeErrorZ self;
9331 public:
9332         CResult_InitFeaturesDecodeErrorZ(const CResult_InitFeaturesDecodeErrorZ&) = delete;
9333         CResult_InitFeaturesDecodeErrorZ(CResult_InitFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); }
9334         CResult_InitFeaturesDecodeErrorZ(LDKCResult_InitFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); }
9335         operator LDKCResult_InitFeaturesDecodeErrorZ() && { LDKCResult_InitFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); return res; }
9336         ~CResult_InitFeaturesDecodeErrorZ() { CResult_InitFeaturesDecodeErrorZ_free(self); }
9337         CResult_InitFeaturesDecodeErrorZ& operator=(CResult_InitFeaturesDecodeErrorZ&& o) { CResult_InitFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); return *this; }
9338         LDKCResult_InitFeaturesDecodeErrorZ* operator &() { return &self; }
9339         LDKCResult_InitFeaturesDecodeErrorZ* operator ->() { return &self; }
9340         const LDKCResult_InitFeaturesDecodeErrorZ* operator &() const { return &self; }
9341         const LDKCResult_InitFeaturesDecodeErrorZ* operator ->() const { return &self; }
9342 };
9343 class CResult_PublicKeyNoneZ {
9344 private:
9345         LDKCResult_PublicKeyNoneZ self;
9346 public:
9347         CResult_PublicKeyNoneZ(const CResult_PublicKeyNoneZ&) = delete;
9348         CResult_PublicKeyNoneZ(CResult_PublicKeyNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PublicKeyNoneZ)); }
9349         CResult_PublicKeyNoneZ(LDKCResult_PublicKeyNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PublicKeyNoneZ)); }
9350         operator LDKCResult_PublicKeyNoneZ() && { LDKCResult_PublicKeyNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_PublicKeyNoneZ)); return res; }
9351         ~CResult_PublicKeyNoneZ() { CResult_PublicKeyNoneZ_free(self); }
9352         CResult_PublicKeyNoneZ& operator=(CResult_PublicKeyNoneZ&& o) { CResult_PublicKeyNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PublicKeyNoneZ)); return *this; }
9353         LDKCResult_PublicKeyNoneZ* operator &() { return &self; }
9354         LDKCResult_PublicKeyNoneZ* operator ->() { return &self; }
9355         const LDKCResult_PublicKeyNoneZ* operator &() const { return &self; }
9356         const LDKCResult_PublicKeyNoneZ* operator ->() const { return &self; }
9357 };
9358 class CResult_PingDecodeErrorZ {
9359 private:
9360         LDKCResult_PingDecodeErrorZ self;
9361 public:
9362         CResult_PingDecodeErrorZ(const CResult_PingDecodeErrorZ&) = delete;
9363         CResult_PingDecodeErrorZ(CResult_PingDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PingDecodeErrorZ)); }
9364         CResult_PingDecodeErrorZ(LDKCResult_PingDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PingDecodeErrorZ)); }
9365         operator LDKCResult_PingDecodeErrorZ() && { LDKCResult_PingDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PingDecodeErrorZ)); return res; }
9366         ~CResult_PingDecodeErrorZ() { CResult_PingDecodeErrorZ_free(self); }
9367         CResult_PingDecodeErrorZ& operator=(CResult_PingDecodeErrorZ&& o) { CResult_PingDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PingDecodeErrorZ)); return *this; }
9368         LDKCResult_PingDecodeErrorZ* operator &() { return &self; }
9369         LDKCResult_PingDecodeErrorZ* operator ->() { return &self; }
9370         const LDKCResult_PingDecodeErrorZ* operator &() const { return &self; }
9371         const LDKCResult_PingDecodeErrorZ* operator ->() const { return &self; }
9372 };
9373 class CResult_RevocationKeyDecodeErrorZ {
9374 private:
9375         LDKCResult_RevocationKeyDecodeErrorZ self;
9376 public:
9377         CResult_RevocationKeyDecodeErrorZ(const CResult_RevocationKeyDecodeErrorZ&) = delete;
9378         CResult_RevocationKeyDecodeErrorZ(CResult_RevocationKeyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevocationKeyDecodeErrorZ)); }
9379         CResult_RevocationKeyDecodeErrorZ(LDKCResult_RevocationKeyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevocationKeyDecodeErrorZ)); }
9380         operator LDKCResult_RevocationKeyDecodeErrorZ() && { LDKCResult_RevocationKeyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevocationKeyDecodeErrorZ)); return res; }
9381         ~CResult_RevocationKeyDecodeErrorZ() { CResult_RevocationKeyDecodeErrorZ_free(self); }
9382         CResult_RevocationKeyDecodeErrorZ& operator=(CResult_RevocationKeyDecodeErrorZ&& o) { CResult_RevocationKeyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevocationKeyDecodeErrorZ)); return *this; }
9383         LDKCResult_RevocationKeyDecodeErrorZ* operator &() { return &self; }
9384         LDKCResult_RevocationKeyDecodeErrorZ* operator ->() { return &self; }
9385         const LDKCResult_RevocationKeyDecodeErrorZ* operator &() const { return &self; }
9386         const LDKCResult_RevocationKeyDecodeErrorZ* operator ->() const { return &self; }
9387 };
9388 class CResult_BlindedHopFeaturesDecodeErrorZ {
9389 private:
9390         LDKCResult_BlindedHopFeaturesDecodeErrorZ self;
9391 public:
9392         CResult_BlindedHopFeaturesDecodeErrorZ(const CResult_BlindedHopFeaturesDecodeErrorZ&) = delete;
9393         CResult_BlindedHopFeaturesDecodeErrorZ(CResult_BlindedHopFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedHopFeaturesDecodeErrorZ)); }
9394         CResult_BlindedHopFeaturesDecodeErrorZ(LDKCResult_BlindedHopFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ)); }
9395         operator LDKCResult_BlindedHopFeaturesDecodeErrorZ() && { LDKCResult_BlindedHopFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ)); return res; }
9396         ~CResult_BlindedHopFeaturesDecodeErrorZ() { CResult_BlindedHopFeaturesDecodeErrorZ_free(self); }
9397         CResult_BlindedHopFeaturesDecodeErrorZ& operator=(CResult_BlindedHopFeaturesDecodeErrorZ&& o) { CResult_BlindedHopFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedHopFeaturesDecodeErrorZ)); return *this; }
9398         LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator &() { return &self; }
9399         LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator ->() { return &self; }
9400         const LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator &() const { return &self; }
9401         const LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator ->() const { return &self; }
9402 };
9403 class CVec_TransactionOutputsZ {
9404 private:
9405         LDKCVec_TransactionOutputsZ self;
9406 public:
9407         CVec_TransactionOutputsZ(const CVec_TransactionOutputsZ&) = delete;
9408         CVec_TransactionOutputsZ(CVec_TransactionOutputsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionOutputsZ)); }
9409         CVec_TransactionOutputsZ(LDKCVec_TransactionOutputsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionOutputsZ)); }
9410         operator LDKCVec_TransactionOutputsZ() && { LDKCVec_TransactionOutputsZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionOutputsZ)); return res; }
9411         ~CVec_TransactionOutputsZ() { CVec_TransactionOutputsZ_free(self); }
9412         CVec_TransactionOutputsZ& operator=(CVec_TransactionOutputsZ&& o) { CVec_TransactionOutputsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionOutputsZ)); return *this; }
9413         LDKCVec_TransactionOutputsZ* operator &() { return &self; }
9414         LDKCVec_TransactionOutputsZ* operator ->() { return &self; }
9415         const LDKCVec_TransactionOutputsZ* operator &() const { return &self; }
9416         const LDKCVec_TransactionOutputsZ* operator ->() const { return &self; }
9417 };
9418 class COption_HTLCClaimZ {
9419 private:
9420         LDKCOption_HTLCClaimZ self;
9421 public:
9422         COption_HTLCClaimZ(const COption_HTLCClaimZ&) = delete;
9423         COption_HTLCClaimZ(COption_HTLCClaimZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_HTLCClaimZ)); }
9424         COption_HTLCClaimZ(LDKCOption_HTLCClaimZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_HTLCClaimZ)); }
9425         operator LDKCOption_HTLCClaimZ() && { LDKCOption_HTLCClaimZ res = self; memset(&self, 0, sizeof(LDKCOption_HTLCClaimZ)); return res; }
9426         ~COption_HTLCClaimZ() { COption_HTLCClaimZ_free(self); }
9427         COption_HTLCClaimZ& operator=(COption_HTLCClaimZ&& o) { COption_HTLCClaimZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_HTLCClaimZ)); return *this; }
9428         LDKCOption_HTLCClaimZ* operator &() { return &self; }
9429         LDKCOption_HTLCClaimZ* operator ->() { return &self; }
9430         const LDKCOption_HTLCClaimZ* operator &() const { return &self; }
9431         const LDKCOption_HTLCClaimZ* operator ->() const { return &self; }
9432 };
9433 class COption_boolZ {
9434 private:
9435         LDKCOption_boolZ self;
9436 public:
9437         COption_boolZ(const COption_boolZ&) = delete;
9438         COption_boolZ(COption_boolZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_boolZ)); }
9439         COption_boolZ(LDKCOption_boolZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_boolZ)); }
9440         operator LDKCOption_boolZ() && { LDKCOption_boolZ res = self; memset(&self, 0, sizeof(LDKCOption_boolZ)); return res; }
9441         ~COption_boolZ() { COption_boolZ_free(self); }
9442         COption_boolZ& operator=(COption_boolZ&& o) { COption_boolZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_boolZ)); return *this; }
9443         LDKCOption_boolZ* operator &() { return &self; }
9444         LDKCOption_boolZ* operator ->() { return &self; }
9445         const LDKCOption_boolZ* operator &() const { return &self; }
9446         const LDKCOption_boolZ* operator ->() const { return &self; }
9447 };
9448 class CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ {
9449 private:
9450         LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ self;
9451 public:
9452         CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ(const CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&) = delete;
9453         CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ(CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); }
9454         CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ(LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); }
9455         operator LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); return res; }
9456         ~CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ() { CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(self); }
9457         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; }
9458         LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator &() { return &self; }
9459         LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator ->() { return &self; }
9460         const LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator &() const { return &self; }
9461         const LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator ->() const { return &self; }
9462 };
9463 class CResult_ProbabilisticScorerDecodeErrorZ {
9464 private:
9465         LDKCResult_ProbabilisticScorerDecodeErrorZ self;
9466 public:
9467         CResult_ProbabilisticScorerDecodeErrorZ(const CResult_ProbabilisticScorerDecodeErrorZ&) = delete;
9468         CResult_ProbabilisticScorerDecodeErrorZ(CResult_ProbabilisticScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ProbabilisticScorerDecodeErrorZ)); }
9469         CResult_ProbabilisticScorerDecodeErrorZ(LDKCResult_ProbabilisticScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ)); }
9470         operator LDKCResult_ProbabilisticScorerDecodeErrorZ() && { LDKCResult_ProbabilisticScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ)); return res; }
9471         ~CResult_ProbabilisticScorerDecodeErrorZ() { CResult_ProbabilisticScorerDecodeErrorZ_free(self); }
9472         CResult_ProbabilisticScorerDecodeErrorZ& operator=(CResult_ProbabilisticScorerDecodeErrorZ&& o) { CResult_ProbabilisticScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ProbabilisticScorerDecodeErrorZ)); return *this; }
9473         LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() { return &self; }
9474         LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() { return &self; }
9475         const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() const { return &self; }
9476         const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() const { return &self; }
9477 };
9478 class COption_StrZ {
9479 private:
9480         LDKCOption_StrZ self;
9481 public:
9482         COption_StrZ(const COption_StrZ&) = delete;
9483         COption_StrZ(COption_StrZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_StrZ)); }
9484         COption_StrZ(LDKCOption_StrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_StrZ)); }
9485         operator LDKCOption_StrZ() && { LDKCOption_StrZ res = self; memset(&self, 0, sizeof(LDKCOption_StrZ)); return res; }
9486         ~COption_StrZ() { COption_StrZ_free(self); }
9487         COption_StrZ& operator=(COption_StrZ&& o) { COption_StrZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_StrZ)); return *this; }
9488         LDKCOption_StrZ* operator &() { return &self; }
9489         LDKCOption_StrZ* operator ->() { return &self; }
9490         const LDKCOption_StrZ* operator &() const { return &self; }
9491         const LDKCOption_StrZ* operator ->() const { return &self; }
9492 };
9493 class CResult_ShutdownScriptDecodeErrorZ {
9494 private:
9495         LDKCResult_ShutdownScriptDecodeErrorZ self;
9496 public:
9497         CResult_ShutdownScriptDecodeErrorZ(const CResult_ShutdownScriptDecodeErrorZ&) = delete;
9498         CResult_ShutdownScriptDecodeErrorZ(CResult_ShutdownScriptDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); }
9499         CResult_ShutdownScriptDecodeErrorZ(LDKCResult_ShutdownScriptDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); }
9500         operator LDKCResult_ShutdownScriptDecodeErrorZ() && { LDKCResult_ShutdownScriptDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); return res; }
9501         ~CResult_ShutdownScriptDecodeErrorZ() { CResult_ShutdownScriptDecodeErrorZ_free(self); }
9502         CResult_ShutdownScriptDecodeErrorZ& operator=(CResult_ShutdownScriptDecodeErrorZ&& o) { CResult_ShutdownScriptDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); return *this; }
9503         LDKCResult_ShutdownScriptDecodeErrorZ* operator &() { return &self; }
9504         LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() { return &self; }
9505         const LDKCResult_ShutdownScriptDecodeErrorZ* operator &() const { return &self; }
9506         const LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() const { return &self; }
9507 };
9508 class CResult_SiPrefixBolt11ParseErrorZ {
9509 private:
9510         LDKCResult_SiPrefixBolt11ParseErrorZ self;
9511 public:
9512         CResult_SiPrefixBolt11ParseErrorZ(const CResult_SiPrefixBolt11ParseErrorZ&) = delete;
9513         CResult_SiPrefixBolt11ParseErrorZ(CResult_SiPrefixBolt11ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SiPrefixBolt11ParseErrorZ)); }
9514         CResult_SiPrefixBolt11ParseErrorZ(LDKCResult_SiPrefixBolt11ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ)); }
9515         operator LDKCResult_SiPrefixBolt11ParseErrorZ() && { LDKCResult_SiPrefixBolt11ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ)); return res; }
9516         ~CResult_SiPrefixBolt11ParseErrorZ() { CResult_SiPrefixBolt11ParseErrorZ_free(self); }
9517         CResult_SiPrefixBolt11ParseErrorZ& operator=(CResult_SiPrefixBolt11ParseErrorZ&& o) { CResult_SiPrefixBolt11ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SiPrefixBolt11ParseErrorZ)); return *this; }
9518         LDKCResult_SiPrefixBolt11ParseErrorZ* operator &() { return &self; }
9519         LDKCResult_SiPrefixBolt11ParseErrorZ* operator ->() { return &self; }
9520         const LDKCResult_SiPrefixBolt11ParseErrorZ* operator &() const { return &self; }
9521         const LDKCResult_SiPrefixBolt11ParseErrorZ* operator ->() const { return &self; }
9522 };
9523 class C2Tuple_usizeTransactionZ {
9524 private:
9525         LDKC2Tuple_usizeTransactionZ self;
9526 public:
9527         C2Tuple_usizeTransactionZ(const C2Tuple_usizeTransactionZ&) = delete;
9528         C2Tuple_usizeTransactionZ(C2Tuple_usizeTransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_usizeTransactionZ)); }
9529         C2Tuple_usizeTransactionZ(LDKC2Tuple_usizeTransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_usizeTransactionZ)); }
9530         operator LDKC2Tuple_usizeTransactionZ() && { LDKC2Tuple_usizeTransactionZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_usizeTransactionZ)); return res; }
9531         ~C2Tuple_usizeTransactionZ() { C2Tuple_usizeTransactionZ_free(self); }
9532         C2Tuple_usizeTransactionZ& operator=(C2Tuple_usizeTransactionZ&& o) { C2Tuple_usizeTransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_usizeTransactionZ)); return *this; }
9533         LDKC2Tuple_usizeTransactionZ* operator &() { return &self; }
9534         LDKC2Tuple_usizeTransactionZ* operator ->() { return &self; }
9535         const LDKC2Tuple_usizeTransactionZ* operator &() const { return &self; }
9536         const LDKC2Tuple_usizeTransactionZ* operator ->() const { return &self; }
9537 };
9538 class CResult_NodeAnnouncementDecodeErrorZ {
9539 private:
9540         LDKCResult_NodeAnnouncementDecodeErrorZ self;
9541 public:
9542         CResult_NodeAnnouncementDecodeErrorZ(const CResult_NodeAnnouncementDecodeErrorZ&) = delete;
9543         CResult_NodeAnnouncementDecodeErrorZ(CResult_NodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); }
9544         CResult_NodeAnnouncementDecodeErrorZ(LDKCResult_NodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); }
9545         operator LDKCResult_NodeAnnouncementDecodeErrorZ() && { LDKCResult_NodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); return res; }
9546         ~CResult_NodeAnnouncementDecodeErrorZ() { CResult_NodeAnnouncementDecodeErrorZ_free(self); }
9547         CResult_NodeAnnouncementDecodeErrorZ& operator=(CResult_NodeAnnouncementDecodeErrorZ&& o) { CResult_NodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); return *this; }
9548         LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() { return &self; }
9549         LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
9550         const LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
9551         const LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
9552 };
9553 class CVec_FutureZ {
9554 private:
9555         LDKCVec_FutureZ self;
9556 public:
9557         CVec_FutureZ(const CVec_FutureZ&) = delete;
9558         CVec_FutureZ(CVec_FutureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_FutureZ)); }
9559         CVec_FutureZ(LDKCVec_FutureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_FutureZ)); }
9560         operator LDKCVec_FutureZ() && { LDKCVec_FutureZ res = self; memset(&self, 0, sizeof(LDKCVec_FutureZ)); return res; }
9561         ~CVec_FutureZ() { CVec_FutureZ_free(self); }
9562         CVec_FutureZ& operator=(CVec_FutureZ&& o) { CVec_FutureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_FutureZ)); return *this; }
9563         LDKCVec_FutureZ* operator &() { return &self; }
9564         LDKCVec_FutureZ* operator ->() { return &self; }
9565         const LDKCVec_FutureZ* operator &() const { return &self; }
9566         const LDKCVec_FutureZ* operator ->() const { return &self; }
9567 };
9568 class CVec_ChannelMonitorZ {
9569 private:
9570         LDKCVec_ChannelMonitorZ self;
9571 public:
9572         CVec_ChannelMonitorZ(const CVec_ChannelMonitorZ&) = delete;
9573         CVec_ChannelMonitorZ(CVec_ChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); }
9574         CVec_ChannelMonitorZ(LDKCVec_ChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelMonitorZ)); }
9575         operator LDKCVec_ChannelMonitorZ() && { LDKCVec_ChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelMonitorZ)); return res; }
9576         ~CVec_ChannelMonitorZ() { CVec_ChannelMonitorZ_free(self); }
9577         CVec_ChannelMonitorZ& operator=(CVec_ChannelMonitorZ&& o) { CVec_ChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); return *this; }
9578         LDKCVec_ChannelMonitorZ* operator &() { return &self; }
9579         LDKCVec_ChannelMonitorZ* operator ->() { return &self; }
9580         const LDKCVec_ChannelMonitorZ* operator &() const { return &self; }
9581         const LDKCVec_ChannelMonitorZ* operator ->() const { return &self; }
9582 };
9583 class CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ {
9584 private:
9585         LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ self;
9586 public:
9587         CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ(const CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ&) = delete;
9588         CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ(CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ)); }
9589         CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ(LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ)); }
9590         operator LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ() && { LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ)); return res; }
9591         ~CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ() { CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ_free(self); }
9592         CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ& operator=(CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ&& o) { CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ)); return *this; }
9593         LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ* operator &() { return &self; }
9594         LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ* operator ->() { return &self; }
9595         const LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ* operator &() const { return &self; }
9596         const LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ* operator ->() const { return &self; }
9597 };
9598 class CResult_AcceptChannelV2DecodeErrorZ {
9599 private:
9600         LDKCResult_AcceptChannelV2DecodeErrorZ self;
9601 public:
9602         CResult_AcceptChannelV2DecodeErrorZ(const CResult_AcceptChannelV2DecodeErrorZ&) = delete;
9603         CResult_AcceptChannelV2DecodeErrorZ(CResult_AcceptChannelV2DecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AcceptChannelV2DecodeErrorZ)); }
9604         CResult_AcceptChannelV2DecodeErrorZ(LDKCResult_AcceptChannelV2DecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AcceptChannelV2DecodeErrorZ)); }
9605         operator LDKCResult_AcceptChannelV2DecodeErrorZ() && { LDKCResult_AcceptChannelV2DecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AcceptChannelV2DecodeErrorZ)); return res; }
9606         ~CResult_AcceptChannelV2DecodeErrorZ() { CResult_AcceptChannelV2DecodeErrorZ_free(self); }
9607         CResult_AcceptChannelV2DecodeErrorZ& operator=(CResult_AcceptChannelV2DecodeErrorZ&& o) { CResult_AcceptChannelV2DecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AcceptChannelV2DecodeErrorZ)); return *this; }
9608         LDKCResult_AcceptChannelV2DecodeErrorZ* operator &() { return &self; }
9609         LDKCResult_AcceptChannelV2DecodeErrorZ* operator ->() { return &self; }
9610         const LDKCResult_AcceptChannelV2DecodeErrorZ* operator &() const { return &self; }
9611         const LDKCResult_AcceptChannelV2DecodeErrorZ* operator ->() const { return &self; }
9612 };
9613 class CResult_RouteHopDecodeErrorZ {
9614 private:
9615         LDKCResult_RouteHopDecodeErrorZ self;
9616 public:
9617         CResult_RouteHopDecodeErrorZ(const CResult_RouteHopDecodeErrorZ&) = delete;
9618         CResult_RouteHopDecodeErrorZ(CResult_RouteHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHopDecodeErrorZ)); }
9619         CResult_RouteHopDecodeErrorZ(LDKCResult_RouteHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHopDecodeErrorZ)); }
9620         operator LDKCResult_RouteHopDecodeErrorZ() && { LDKCResult_RouteHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHopDecodeErrorZ)); return res; }
9621         ~CResult_RouteHopDecodeErrorZ() { CResult_RouteHopDecodeErrorZ_free(self); }
9622         CResult_RouteHopDecodeErrorZ& operator=(CResult_RouteHopDecodeErrorZ&& o) { CResult_RouteHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHopDecodeErrorZ)); return *this; }
9623         LDKCResult_RouteHopDecodeErrorZ* operator &() { return &self; }
9624         LDKCResult_RouteHopDecodeErrorZ* operator ->() { return &self; }
9625         const LDKCResult_RouteHopDecodeErrorZ* operator &() const { return &self; }
9626         const LDKCResult_RouteHopDecodeErrorZ* operator ->() const { return &self; }
9627 };
9628 class CVec_HTLCOutputInCommitmentZ {
9629 private:
9630         LDKCVec_HTLCOutputInCommitmentZ self;
9631 public:
9632         CVec_HTLCOutputInCommitmentZ(const CVec_HTLCOutputInCommitmentZ&) = delete;
9633         CVec_HTLCOutputInCommitmentZ(CVec_HTLCOutputInCommitmentZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_HTLCOutputInCommitmentZ)); }
9634         CVec_HTLCOutputInCommitmentZ(LDKCVec_HTLCOutputInCommitmentZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_HTLCOutputInCommitmentZ)); }
9635         operator LDKCVec_HTLCOutputInCommitmentZ() && { LDKCVec_HTLCOutputInCommitmentZ res = self; memset(&self, 0, sizeof(LDKCVec_HTLCOutputInCommitmentZ)); return res; }
9636         ~CVec_HTLCOutputInCommitmentZ() { CVec_HTLCOutputInCommitmentZ_free(self); }
9637         CVec_HTLCOutputInCommitmentZ& operator=(CVec_HTLCOutputInCommitmentZ&& o) { CVec_HTLCOutputInCommitmentZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_HTLCOutputInCommitmentZ)); return *this; }
9638         LDKCVec_HTLCOutputInCommitmentZ* operator &() { return &self; }
9639         LDKCVec_HTLCOutputInCommitmentZ* operator ->() { return &self; }
9640         const LDKCVec_HTLCOutputInCommitmentZ* operator &() const { return &self; }
9641         const LDKCVec_HTLCOutputInCommitmentZ* operator ->() const { return &self; }
9642 };
9643 class CResult_CoinSelectionNoneZ {
9644 private:
9645         LDKCResult_CoinSelectionNoneZ self;
9646 public:
9647         CResult_CoinSelectionNoneZ(const CResult_CoinSelectionNoneZ&) = delete;
9648         CResult_CoinSelectionNoneZ(CResult_CoinSelectionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CoinSelectionNoneZ)); }
9649         CResult_CoinSelectionNoneZ(LDKCResult_CoinSelectionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CoinSelectionNoneZ)); }
9650         operator LDKCResult_CoinSelectionNoneZ() && { LDKCResult_CoinSelectionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CoinSelectionNoneZ)); return res; }
9651         ~CResult_CoinSelectionNoneZ() { CResult_CoinSelectionNoneZ_free(self); }
9652         CResult_CoinSelectionNoneZ& operator=(CResult_CoinSelectionNoneZ&& o) { CResult_CoinSelectionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CoinSelectionNoneZ)); return *this; }
9653         LDKCResult_CoinSelectionNoneZ* operator &() { return &self; }
9654         LDKCResult_CoinSelectionNoneZ* operator ->() { return &self; }
9655         const LDKCResult_CoinSelectionNoneZ* operator &() const { return &self; }
9656         const LDKCResult_CoinSelectionNoneZ* operator ->() const { return &self; }
9657 };
9658 class C2Tuple_ThirtyTwoBytesPublicKeyZ {
9659 private:
9660         LDKC2Tuple_ThirtyTwoBytesPublicKeyZ self;
9661 public:
9662         C2Tuple_ThirtyTwoBytesPublicKeyZ(const C2Tuple_ThirtyTwoBytesPublicKeyZ&) = delete;
9663         C2Tuple_ThirtyTwoBytesPublicKeyZ(C2Tuple_ThirtyTwoBytesPublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesPublicKeyZ)); }
9664         C2Tuple_ThirtyTwoBytesPublicKeyZ(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ)); }
9665         operator LDKC2Tuple_ThirtyTwoBytesPublicKeyZ() && { LDKC2Tuple_ThirtyTwoBytesPublicKeyZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ)); return res; }
9666         ~C2Tuple_ThirtyTwoBytesPublicKeyZ() { C2Tuple_ThirtyTwoBytesPublicKeyZ_free(self); }
9667         C2Tuple_ThirtyTwoBytesPublicKeyZ& operator=(C2Tuple_ThirtyTwoBytesPublicKeyZ&& o) { C2Tuple_ThirtyTwoBytesPublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesPublicKeyZ)); return *this; }
9668         LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator &() { return &self; }
9669         LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator ->() { return &self; }
9670         const LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator &() const { return &self; }
9671         const LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator ->() const { return &self; }
9672 };
9673 class CResult_TxCreationKeysDecodeErrorZ {
9674 private:
9675         LDKCResult_TxCreationKeysDecodeErrorZ self;
9676 public:
9677         CResult_TxCreationKeysDecodeErrorZ(const CResult_TxCreationKeysDecodeErrorZ&) = delete;
9678         CResult_TxCreationKeysDecodeErrorZ(CResult_TxCreationKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); }
9679         CResult_TxCreationKeysDecodeErrorZ(LDKCResult_TxCreationKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); }
9680         operator LDKCResult_TxCreationKeysDecodeErrorZ() && { LDKCResult_TxCreationKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); return res; }
9681         ~CResult_TxCreationKeysDecodeErrorZ() { CResult_TxCreationKeysDecodeErrorZ_free(self); }
9682         CResult_TxCreationKeysDecodeErrorZ& operator=(CResult_TxCreationKeysDecodeErrorZ&& o) { CResult_TxCreationKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); return *this; }
9683         LDKCResult_TxCreationKeysDecodeErrorZ* operator &() { return &self; }
9684         LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() { return &self; }
9685         const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
9686         const LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() const { return &self; }
9687 };
9688 class CResult_BlindedPathDecodeErrorZ {
9689 private:
9690         LDKCResult_BlindedPathDecodeErrorZ self;
9691 public:
9692         CResult_BlindedPathDecodeErrorZ(const CResult_BlindedPathDecodeErrorZ&) = delete;
9693         CResult_BlindedPathDecodeErrorZ(CResult_BlindedPathDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPathDecodeErrorZ)); }
9694         CResult_BlindedPathDecodeErrorZ(LDKCResult_BlindedPathDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPathDecodeErrorZ)); }
9695         operator LDKCResult_BlindedPathDecodeErrorZ() && { LDKCResult_BlindedPathDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPathDecodeErrorZ)); return res; }
9696         ~CResult_BlindedPathDecodeErrorZ() { CResult_BlindedPathDecodeErrorZ_free(self); }
9697         CResult_BlindedPathDecodeErrorZ& operator=(CResult_BlindedPathDecodeErrorZ&& o) { CResult_BlindedPathDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPathDecodeErrorZ)); return *this; }
9698         LDKCResult_BlindedPathDecodeErrorZ* operator &() { return &self; }
9699         LDKCResult_BlindedPathDecodeErrorZ* operator ->() { return &self; }
9700         const LDKCResult_BlindedPathDecodeErrorZ* operator &() const { return &self; }
9701         const LDKCResult_BlindedPathDecodeErrorZ* operator ->() const { return &self; }
9702 };
9703 class CVec_BalanceZ {
9704 private:
9705         LDKCVec_BalanceZ self;
9706 public:
9707         CVec_BalanceZ(const CVec_BalanceZ&) = delete;
9708         CVec_BalanceZ(CVec_BalanceZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BalanceZ)); }
9709         CVec_BalanceZ(LDKCVec_BalanceZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BalanceZ)); }
9710         operator LDKCVec_BalanceZ() && { LDKCVec_BalanceZ res = self; memset(&self, 0, sizeof(LDKCVec_BalanceZ)); return res; }
9711         ~CVec_BalanceZ() { CVec_BalanceZ_free(self); }
9712         CVec_BalanceZ& operator=(CVec_BalanceZ&& o) { CVec_BalanceZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BalanceZ)); return *this; }
9713         LDKCVec_BalanceZ* operator &() { return &self; }
9714         LDKCVec_BalanceZ* operator ->() { return &self; }
9715         const LDKCVec_BalanceZ* operator &() const { return &self; }
9716         const LDKCVec_BalanceZ* operator ->() const { return &self; }
9717 };
9718 class CResult_NoneIOErrorZ {
9719 private:
9720         LDKCResult_NoneIOErrorZ self;
9721 public:
9722         CResult_NoneIOErrorZ(const CResult_NoneIOErrorZ&) = delete;
9723         CResult_NoneIOErrorZ(CResult_NoneIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneIOErrorZ)); }
9724         CResult_NoneIOErrorZ(LDKCResult_NoneIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneIOErrorZ)); }
9725         operator LDKCResult_NoneIOErrorZ() && { LDKCResult_NoneIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneIOErrorZ)); return res; }
9726         ~CResult_NoneIOErrorZ() { CResult_NoneIOErrorZ_free(self); }
9727         CResult_NoneIOErrorZ& operator=(CResult_NoneIOErrorZ&& o) { CResult_NoneIOErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneIOErrorZ)); return *this; }
9728         LDKCResult_NoneIOErrorZ* operator &() { return &self; }
9729         LDKCResult_NoneIOErrorZ* operator ->() { return &self; }
9730         const LDKCResult_NoneIOErrorZ* operator &() const { return &self; }
9731         const LDKCResult_NoneIOErrorZ* operator ->() const { return &self; }
9732 };
9733 class CResult_MaxDustHTLCExposureDecodeErrorZ {
9734 private:
9735         LDKCResult_MaxDustHTLCExposureDecodeErrorZ self;
9736 public:
9737         CResult_MaxDustHTLCExposureDecodeErrorZ(const CResult_MaxDustHTLCExposureDecodeErrorZ&) = delete;
9738         CResult_MaxDustHTLCExposureDecodeErrorZ(CResult_MaxDustHTLCExposureDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_MaxDustHTLCExposureDecodeErrorZ)); }
9739         CResult_MaxDustHTLCExposureDecodeErrorZ(LDKCResult_MaxDustHTLCExposureDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_MaxDustHTLCExposureDecodeErrorZ)); }
9740         operator LDKCResult_MaxDustHTLCExposureDecodeErrorZ() && { LDKCResult_MaxDustHTLCExposureDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_MaxDustHTLCExposureDecodeErrorZ)); return res; }
9741         ~CResult_MaxDustHTLCExposureDecodeErrorZ() { CResult_MaxDustHTLCExposureDecodeErrorZ_free(self); }
9742         CResult_MaxDustHTLCExposureDecodeErrorZ& operator=(CResult_MaxDustHTLCExposureDecodeErrorZ&& o) { CResult_MaxDustHTLCExposureDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_MaxDustHTLCExposureDecodeErrorZ)); return *this; }
9743         LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator &() { return &self; }
9744         LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator ->() { return &self; }
9745         const LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator &() const { return &self; }
9746         const LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator ->() const { return &self; }
9747 };
9748 class CVec_CommitmentTransactionZ {
9749 private:
9750         LDKCVec_CommitmentTransactionZ self;
9751 public:
9752         CVec_CommitmentTransactionZ(const CVec_CommitmentTransactionZ&) = delete;
9753         CVec_CommitmentTransactionZ(CVec_CommitmentTransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CommitmentTransactionZ)); }
9754         CVec_CommitmentTransactionZ(LDKCVec_CommitmentTransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CommitmentTransactionZ)); }
9755         operator LDKCVec_CommitmentTransactionZ() && { LDKCVec_CommitmentTransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_CommitmentTransactionZ)); return res; }
9756         ~CVec_CommitmentTransactionZ() { CVec_CommitmentTransactionZ_free(self); }
9757         CVec_CommitmentTransactionZ& operator=(CVec_CommitmentTransactionZ&& o) { CVec_CommitmentTransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CommitmentTransactionZ)); return *this; }
9758         LDKCVec_CommitmentTransactionZ* operator &() { return &self; }
9759         LDKCVec_CommitmentTransactionZ* operator ->() { return &self; }
9760         const LDKCVec_CommitmentTransactionZ* operator &() const { return &self; }
9761         const LDKCVec_CommitmentTransactionZ* operator ->() const { return &self; }
9762 };
9763 class CResult_FundingSignedDecodeErrorZ {
9764 private:
9765         LDKCResult_FundingSignedDecodeErrorZ self;
9766 public:
9767         CResult_FundingSignedDecodeErrorZ(const CResult_FundingSignedDecodeErrorZ&) = delete;
9768         CResult_FundingSignedDecodeErrorZ(CResult_FundingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); }
9769         CResult_FundingSignedDecodeErrorZ(LDKCResult_FundingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); }
9770         operator LDKCResult_FundingSignedDecodeErrorZ() && { LDKCResult_FundingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); return res; }
9771         ~CResult_FundingSignedDecodeErrorZ() { CResult_FundingSignedDecodeErrorZ_free(self); }
9772         CResult_FundingSignedDecodeErrorZ& operator=(CResult_FundingSignedDecodeErrorZ&& o) { CResult_FundingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); return *this; }
9773         LDKCResult_FundingSignedDecodeErrorZ* operator &() { return &self; }
9774         LDKCResult_FundingSignedDecodeErrorZ* operator ->() { return &self; }
9775         const LDKCResult_FundingSignedDecodeErrorZ* operator &() const { return &self; }
9776         const LDKCResult_FundingSignedDecodeErrorZ* operator ->() const { return &self; }
9777 };
9778 class CResult_RecoverableSignatureNoneZ {
9779 private:
9780         LDKCResult_RecoverableSignatureNoneZ self;
9781 public:
9782         CResult_RecoverableSignatureNoneZ(const CResult_RecoverableSignatureNoneZ&) = delete;
9783         CResult_RecoverableSignatureNoneZ(CResult_RecoverableSignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecoverableSignatureNoneZ)); }
9784         CResult_RecoverableSignatureNoneZ(LDKCResult_RecoverableSignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecoverableSignatureNoneZ)); }
9785         operator LDKCResult_RecoverableSignatureNoneZ() && { LDKCResult_RecoverableSignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_RecoverableSignatureNoneZ)); return res; }
9786         ~CResult_RecoverableSignatureNoneZ() { CResult_RecoverableSignatureNoneZ_free(self); }
9787         CResult_RecoverableSignatureNoneZ& operator=(CResult_RecoverableSignatureNoneZ&& o) { CResult_RecoverableSignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecoverableSignatureNoneZ)); return *this; }
9788         LDKCResult_RecoverableSignatureNoneZ* operator &() { return &self; }
9789         LDKCResult_RecoverableSignatureNoneZ* operator ->() { return &self; }
9790         const LDKCResult_RecoverableSignatureNoneZ* operator &() const { return &self; }
9791         const LDKCResult_RecoverableSignatureNoneZ* operator ->() const { return &self; }
9792 };
9793 class CResult_SocketAddressDecodeErrorZ {
9794 private:
9795         LDKCResult_SocketAddressDecodeErrorZ self;
9796 public:
9797         CResult_SocketAddressDecodeErrorZ(const CResult_SocketAddressDecodeErrorZ&) = delete;
9798         CResult_SocketAddressDecodeErrorZ(CResult_SocketAddressDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SocketAddressDecodeErrorZ)); }
9799         CResult_SocketAddressDecodeErrorZ(LDKCResult_SocketAddressDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SocketAddressDecodeErrorZ)); }
9800         operator LDKCResult_SocketAddressDecodeErrorZ() && { LDKCResult_SocketAddressDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SocketAddressDecodeErrorZ)); return res; }
9801         ~CResult_SocketAddressDecodeErrorZ() { CResult_SocketAddressDecodeErrorZ_free(self); }
9802         CResult_SocketAddressDecodeErrorZ& operator=(CResult_SocketAddressDecodeErrorZ&& o) { CResult_SocketAddressDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SocketAddressDecodeErrorZ)); return *this; }
9803         LDKCResult_SocketAddressDecodeErrorZ* operator &() { return &self; }
9804         LDKCResult_SocketAddressDecodeErrorZ* operator ->() { return &self; }
9805         const LDKCResult_SocketAddressDecodeErrorZ* operator &() const { return &self; }
9806         const LDKCResult_SocketAddressDecodeErrorZ* operator ->() const { return &self; }
9807 };
9808 class C2Tuple_Z {
9809 private:
9810         LDKC2Tuple_Z self;
9811 public:
9812         C2Tuple_Z(const C2Tuple_Z&) = delete;
9813         C2Tuple_Z(C2Tuple_Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_Z)); }
9814         C2Tuple_Z(LDKC2Tuple_Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_Z)); }
9815         operator LDKC2Tuple_Z() && { LDKC2Tuple_Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_Z)); return res; }
9816         ~C2Tuple_Z() { C2Tuple_Z_free(self); }
9817         C2Tuple_Z& operator=(C2Tuple_Z&& o) { C2Tuple_Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_Z)); return *this; }
9818         LDKC2Tuple_Z* operator &() { return &self; }
9819         LDKC2Tuple_Z* operator ->() { return &self; }
9820         const LDKC2Tuple_Z* operator &() const { return &self; }
9821         const LDKC2Tuple_Z* operator ->() const { return &self; }
9822 };
9823 class C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ {
9824 private:
9825         LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ self;
9826 public:
9827         C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(const C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&) = delete;
9828         C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); }
9829         C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); }
9830         operator LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ() && { LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); return res; }
9831         ~C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ() { C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(self); }
9832         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; }
9833         LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator &() { return &self; }
9834         LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator ->() { return &self; }
9835         const LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator &() const { return &self; }
9836         const LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator ->() const { return &self; }
9837 };
9838 class CVec_PathZ {
9839 private:
9840         LDKCVec_PathZ self;
9841 public:
9842         CVec_PathZ(const CVec_PathZ&) = delete;
9843         CVec_PathZ(CVec_PathZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PathZ)); }
9844         CVec_PathZ(LDKCVec_PathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PathZ)); }
9845         operator LDKCVec_PathZ() && { LDKCVec_PathZ res = self; memset(&self, 0, sizeof(LDKCVec_PathZ)); return res; }
9846         ~CVec_PathZ() { CVec_PathZ_free(self); }
9847         CVec_PathZ& operator=(CVec_PathZ&& o) { CVec_PathZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PathZ)); return *this; }
9848         LDKCVec_PathZ* operator &() { return &self; }
9849         LDKCVec_PathZ* operator ->() { return &self; }
9850         const LDKCVec_PathZ* operator &() const { return &self; }
9851         const LDKCVec_PathZ* operator ->() const { return &self; }
9852 };
9853 class CResult_NetworkGraphDecodeErrorZ {
9854 private:
9855         LDKCResult_NetworkGraphDecodeErrorZ self;
9856 public:
9857         CResult_NetworkGraphDecodeErrorZ(const CResult_NetworkGraphDecodeErrorZ&) = delete;
9858         CResult_NetworkGraphDecodeErrorZ(CResult_NetworkGraphDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NetworkGraphDecodeErrorZ)); }
9859         CResult_NetworkGraphDecodeErrorZ(LDKCResult_NetworkGraphDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NetworkGraphDecodeErrorZ)); }
9860         operator LDKCResult_NetworkGraphDecodeErrorZ() && { LDKCResult_NetworkGraphDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NetworkGraphDecodeErrorZ)); return res; }
9861         ~CResult_NetworkGraphDecodeErrorZ() { CResult_NetworkGraphDecodeErrorZ_free(self); }
9862         CResult_NetworkGraphDecodeErrorZ& operator=(CResult_NetworkGraphDecodeErrorZ&& o) { CResult_NetworkGraphDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NetworkGraphDecodeErrorZ)); return *this; }
9863         LDKCResult_NetworkGraphDecodeErrorZ* operator &() { return &self; }
9864         LDKCResult_NetworkGraphDecodeErrorZ* operator ->() { return &self; }
9865         const LDKCResult_NetworkGraphDecodeErrorZ* operator &() const { return &self; }
9866         const LDKCResult_NetworkGraphDecodeErrorZ* operator ->() const { return &self; }
9867 };
9868 class CResult_NodeInfoDecodeErrorZ {
9869 private:
9870         LDKCResult_NodeInfoDecodeErrorZ self;
9871 public:
9872         CResult_NodeInfoDecodeErrorZ(const CResult_NodeInfoDecodeErrorZ&) = delete;
9873         CResult_NodeInfoDecodeErrorZ(CResult_NodeInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); }
9874         CResult_NodeInfoDecodeErrorZ(LDKCResult_NodeInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); }
9875         operator LDKCResult_NodeInfoDecodeErrorZ() && { LDKCResult_NodeInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); return res; }
9876         ~CResult_NodeInfoDecodeErrorZ() { CResult_NodeInfoDecodeErrorZ_free(self); }
9877         CResult_NodeInfoDecodeErrorZ& operator=(CResult_NodeInfoDecodeErrorZ&& o) { CResult_NodeInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); return *this; }
9878         LDKCResult_NodeInfoDecodeErrorZ* operator &() { return &self; }
9879         LDKCResult_NodeInfoDecodeErrorZ* operator ->() { return &self; }
9880         const LDKCResult_NodeInfoDecodeErrorZ* operator &() const { return &self; }
9881         const LDKCResult_NodeInfoDecodeErrorZ* operator ->() const { return &self; }
9882 };
9883 class CVec_NodeIdZ {
9884 private:
9885         LDKCVec_NodeIdZ self;
9886 public:
9887         CVec_NodeIdZ(const CVec_NodeIdZ&) = delete;
9888         CVec_NodeIdZ(CVec_NodeIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_NodeIdZ)); }
9889         CVec_NodeIdZ(LDKCVec_NodeIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_NodeIdZ)); }
9890         operator LDKCVec_NodeIdZ() && { LDKCVec_NodeIdZ res = self; memset(&self, 0, sizeof(LDKCVec_NodeIdZ)); return res; }
9891         ~CVec_NodeIdZ() { CVec_NodeIdZ_free(self); }
9892         CVec_NodeIdZ& operator=(CVec_NodeIdZ&& o) { CVec_NodeIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_NodeIdZ)); return *this; }
9893         LDKCVec_NodeIdZ* operator &() { return &self; }
9894         LDKCVec_NodeIdZ* operator ->() { return &self; }
9895         const LDKCVec_NodeIdZ* operator &() const { return &self; }
9896         const LDKCVec_NodeIdZ* operator ->() const { return &self; }
9897 };
9898 class CVec_u8Z {
9899 private:
9900         LDKCVec_u8Z self;
9901 public:
9902         CVec_u8Z(const CVec_u8Z&) = delete;
9903         CVec_u8Z(CVec_u8Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u8Z)); }
9904         CVec_u8Z(LDKCVec_u8Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u8Z)); }
9905         operator LDKCVec_u8Z() && { LDKCVec_u8Z res = self; memset(&self, 0, sizeof(LDKCVec_u8Z)); return res; }
9906         ~CVec_u8Z() { CVec_u8Z_free(self); }
9907         CVec_u8Z& operator=(CVec_u8Z&& o) { CVec_u8Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u8Z)); return *this; }
9908         LDKCVec_u8Z* operator &() { return &self; }
9909         LDKCVec_u8Z* operator ->() { return &self; }
9910         const LDKCVec_u8Z* operator &() const { return &self; }
9911         const LDKCVec_u8Z* operator ->() const { return &self; }
9912 };
9913 class CResult_RouteLightningErrorZ {
9914 private:
9915         LDKCResult_RouteLightningErrorZ self;
9916 public:
9917         CResult_RouteLightningErrorZ(const CResult_RouteLightningErrorZ&) = delete;
9918         CResult_RouteLightningErrorZ(CResult_RouteLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); }
9919         CResult_RouteLightningErrorZ(LDKCResult_RouteLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); }
9920         operator LDKCResult_RouteLightningErrorZ() && { LDKCResult_RouteLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); return res; }
9921         ~CResult_RouteLightningErrorZ() { CResult_RouteLightningErrorZ_free(self); }
9922         CResult_RouteLightningErrorZ& operator=(CResult_RouteLightningErrorZ&& o) { CResult_RouteLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); return *this; }
9923         LDKCResult_RouteLightningErrorZ* operator &() { return &self; }
9924         LDKCResult_RouteLightningErrorZ* operator ->() { return &self; }
9925         const LDKCResult_RouteLightningErrorZ* operator &() const { return &self; }
9926         const LDKCResult_RouteLightningErrorZ* operator ->() const { return &self; }
9927 };
9928 class CResult_NonePaymentSendFailureZ {
9929 private:
9930         LDKCResult_NonePaymentSendFailureZ self;
9931 public:
9932         CResult_NonePaymentSendFailureZ(const CResult_NonePaymentSendFailureZ&) = delete;
9933         CResult_NonePaymentSendFailureZ(CResult_NonePaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); }
9934         CResult_NonePaymentSendFailureZ(LDKCResult_NonePaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); }
9935         operator LDKCResult_NonePaymentSendFailureZ() && { LDKCResult_NonePaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); return res; }
9936         ~CResult_NonePaymentSendFailureZ() { CResult_NonePaymentSendFailureZ_free(self); }
9937         CResult_NonePaymentSendFailureZ& operator=(CResult_NonePaymentSendFailureZ&& o) { CResult_NonePaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); return *this; }
9938         LDKCResult_NonePaymentSendFailureZ* operator &() { return &self; }
9939         LDKCResult_NonePaymentSendFailureZ* operator ->() { return &self; }
9940         const LDKCResult_NonePaymentSendFailureZ* operator &() const { return &self; }
9941         const LDKCResult_NonePaymentSendFailureZ* operator ->() const { return &self; }
9942 };
9943 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ {
9944 private:
9945         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ self;
9946 public:
9947         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&) = delete;
9948         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); }
9949         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); }
9950         operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); return res; }
9951         ~CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(self); }
9952         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; }
9953         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator &() { return &self; }
9954         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator ->() { return &self; }
9955         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator &() const { return &self; }
9956         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator ->() const { return &self; }
9957 };
9958 class CResult_ChannelPublicKeysDecodeErrorZ {
9959 private:
9960         LDKCResult_ChannelPublicKeysDecodeErrorZ self;
9961 public:
9962         CResult_ChannelPublicKeysDecodeErrorZ(const CResult_ChannelPublicKeysDecodeErrorZ&) = delete;
9963         CResult_ChannelPublicKeysDecodeErrorZ(CResult_ChannelPublicKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelPublicKeysDecodeErrorZ)); }
9964         CResult_ChannelPublicKeysDecodeErrorZ(LDKCResult_ChannelPublicKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ)); }
9965         operator LDKCResult_ChannelPublicKeysDecodeErrorZ() && { LDKCResult_ChannelPublicKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ)); return res; }
9966         ~CResult_ChannelPublicKeysDecodeErrorZ() { CResult_ChannelPublicKeysDecodeErrorZ_free(self); }
9967         CResult_ChannelPublicKeysDecodeErrorZ& operator=(CResult_ChannelPublicKeysDecodeErrorZ&& o) { CResult_ChannelPublicKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelPublicKeysDecodeErrorZ)); return *this; }
9968         LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() { return &self; }
9969         LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() { return &self; }
9970         const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() const { return &self; }
9971         const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() const { return &self; }
9972 };
9973 class CVec_ClaimedHTLCZ {
9974 private:
9975         LDKCVec_ClaimedHTLCZ self;
9976 public:
9977         CVec_ClaimedHTLCZ(const CVec_ClaimedHTLCZ&) = delete;
9978         CVec_ClaimedHTLCZ(CVec_ClaimedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ClaimedHTLCZ)); }
9979         CVec_ClaimedHTLCZ(LDKCVec_ClaimedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ClaimedHTLCZ)); }
9980         operator LDKCVec_ClaimedHTLCZ() && { LDKCVec_ClaimedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_ClaimedHTLCZ)); return res; }
9981         ~CVec_ClaimedHTLCZ() { CVec_ClaimedHTLCZ_free(self); }
9982         CVec_ClaimedHTLCZ& operator=(CVec_ClaimedHTLCZ&& o) { CVec_ClaimedHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ClaimedHTLCZ)); return *this; }
9983         LDKCVec_ClaimedHTLCZ* operator &() { return &self; }
9984         LDKCVec_ClaimedHTLCZ* operator ->() { return &self; }
9985         const LDKCVec_ClaimedHTLCZ* operator &() const { return &self; }
9986         const LDKCVec_ClaimedHTLCZ* operator ->() const { return &self; }
9987 };
9988 class COption_CVec_ThirtyTwoBytesZZ {
9989 private:
9990         LDKCOption_CVec_ThirtyTwoBytesZZ self;
9991 public:
9992         COption_CVec_ThirtyTwoBytesZZ(const COption_CVec_ThirtyTwoBytesZZ&) = delete;
9993         COption_CVec_ThirtyTwoBytesZZ(COption_CVec_ThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_ThirtyTwoBytesZZ)); }
9994         COption_CVec_ThirtyTwoBytesZZ(LDKCOption_CVec_ThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ)); }
9995         operator LDKCOption_CVec_ThirtyTwoBytesZZ() && { LDKCOption_CVec_ThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ)); return res; }
9996         ~COption_CVec_ThirtyTwoBytesZZ() { COption_CVec_ThirtyTwoBytesZZ_free(self); }
9997         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; }
9998         LDKCOption_CVec_ThirtyTwoBytesZZ* operator &() { return &self; }
9999         LDKCOption_CVec_ThirtyTwoBytesZZ* operator ->() { return &self; }
10000         const LDKCOption_CVec_ThirtyTwoBytesZZ* operator &() const { return &self; }
10001         const LDKCOption_CVec_ThirtyTwoBytesZZ* operator ->() const { return &self; }
10002 };
10003 class CVec_SocketAddressZ {
10004 private:
10005         LDKCVec_SocketAddressZ self;
10006 public:
10007         CVec_SocketAddressZ(const CVec_SocketAddressZ&) = delete;
10008         CVec_SocketAddressZ(CVec_SocketAddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SocketAddressZ)); }
10009         CVec_SocketAddressZ(LDKCVec_SocketAddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SocketAddressZ)); }
10010         operator LDKCVec_SocketAddressZ() && { LDKCVec_SocketAddressZ res = self; memset(&self, 0, sizeof(LDKCVec_SocketAddressZ)); return res; }
10011         ~CVec_SocketAddressZ() { CVec_SocketAddressZ_free(self); }
10012         CVec_SocketAddressZ& operator=(CVec_SocketAddressZ&& o) { CVec_SocketAddressZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_SocketAddressZ)); return *this; }
10013         LDKCVec_SocketAddressZ* operator &() { return &self; }
10014         LDKCVec_SocketAddressZ* operator ->() { return &self; }
10015         const LDKCVec_SocketAddressZ* operator &() const { return &self; }
10016         const LDKCVec_SocketAddressZ* operator ->() const { return &self; }
10017 };
10018 class CResult_ThirtyTwoBytesPaymentSendFailureZ {
10019 private:
10020         LDKCResult_ThirtyTwoBytesPaymentSendFailureZ self;
10021 public:
10022         CResult_ThirtyTwoBytesPaymentSendFailureZ(const CResult_ThirtyTwoBytesPaymentSendFailureZ&) = delete;
10023         CResult_ThirtyTwoBytesPaymentSendFailureZ(CResult_ThirtyTwoBytesPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentSendFailureZ)); }
10024         CResult_ThirtyTwoBytesPaymentSendFailureZ(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ)); }
10025         operator LDKCResult_ThirtyTwoBytesPaymentSendFailureZ() && { LDKCResult_ThirtyTwoBytesPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ)); return res; }
10026         ~CResult_ThirtyTwoBytesPaymentSendFailureZ() { CResult_ThirtyTwoBytesPaymentSendFailureZ_free(self); }
10027         CResult_ThirtyTwoBytesPaymentSendFailureZ& operator=(CResult_ThirtyTwoBytesPaymentSendFailureZ&& o) { CResult_ThirtyTwoBytesPaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentSendFailureZ)); return *this; }
10028         LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator &() { return &self; }
10029         LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator ->() { return &self; }
10030         const LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator &() const { return &self; }
10031         const LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator ->() const { return &self; }
10032 };
10033 class CResult_HolderCommitmentTransactionDecodeErrorZ {
10034 private:
10035         LDKCResult_HolderCommitmentTransactionDecodeErrorZ self;
10036 public:
10037         CResult_HolderCommitmentTransactionDecodeErrorZ(const CResult_HolderCommitmentTransactionDecodeErrorZ&) = delete;
10038         CResult_HolderCommitmentTransactionDecodeErrorZ(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); }
10039         CResult_HolderCommitmentTransactionDecodeErrorZ(LDKCResult_HolderCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); }
10040         operator LDKCResult_HolderCommitmentTransactionDecodeErrorZ() && { LDKCResult_HolderCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); return res; }
10041         ~CResult_HolderCommitmentTransactionDecodeErrorZ() { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); }
10042         CResult_HolderCommitmentTransactionDecodeErrorZ& operator=(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); return *this; }
10043         LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
10044         LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
10045         const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
10046         const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
10047 };
10048 class CResult_WarningMessageDecodeErrorZ {
10049 private:
10050         LDKCResult_WarningMessageDecodeErrorZ self;
10051 public:
10052         CResult_WarningMessageDecodeErrorZ(const CResult_WarningMessageDecodeErrorZ&) = delete;
10053         CResult_WarningMessageDecodeErrorZ(CResult_WarningMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WarningMessageDecodeErrorZ)); }
10054         CResult_WarningMessageDecodeErrorZ(LDKCResult_WarningMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WarningMessageDecodeErrorZ)); }
10055         operator LDKCResult_WarningMessageDecodeErrorZ() && { LDKCResult_WarningMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_WarningMessageDecodeErrorZ)); return res; }
10056         ~CResult_WarningMessageDecodeErrorZ() { CResult_WarningMessageDecodeErrorZ_free(self); }
10057         CResult_WarningMessageDecodeErrorZ& operator=(CResult_WarningMessageDecodeErrorZ&& o) { CResult_WarningMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WarningMessageDecodeErrorZ)); return *this; }
10058         LDKCResult_WarningMessageDecodeErrorZ* operator &() { return &self; }
10059         LDKCResult_WarningMessageDecodeErrorZ* operator ->() { return &self; }
10060         const LDKCResult_WarningMessageDecodeErrorZ* operator &() const { return &self; }
10061         const LDKCResult_WarningMessageDecodeErrorZ* operator ->() const { return &self; }
10062 };
10063 class CResult_ChannelCounterpartyDecodeErrorZ {
10064 private:
10065         LDKCResult_ChannelCounterpartyDecodeErrorZ self;
10066 public:
10067         CResult_ChannelCounterpartyDecodeErrorZ(const CResult_ChannelCounterpartyDecodeErrorZ&) = delete;
10068         CResult_ChannelCounterpartyDecodeErrorZ(CResult_ChannelCounterpartyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); }
10069         CResult_ChannelCounterpartyDecodeErrorZ(LDKCResult_ChannelCounterpartyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); }
10070         operator LDKCResult_ChannelCounterpartyDecodeErrorZ() && { LDKCResult_ChannelCounterpartyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); return res; }
10071         ~CResult_ChannelCounterpartyDecodeErrorZ() { CResult_ChannelCounterpartyDecodeErrorZ_free(self); }
10072         CResult_ChannelCounterpartyDecodeErrorZ& operator=(CResult_ChannelCounterpartyDecodeErrorZ&& o) { CResult_ChannelCounterpartyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); return *this; }
10073         LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() { return &self; }
10074         LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() { return &self; }
10075         const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() const { return &self; }
10076         const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() const { return &self; }
10077 };
10078 class CVec_ForwardNodeZ {
10079 private:
10080         LDKCVec_ForwardNodeZ self;
10081 public:
10082         CVec_ForwardNodeZ(const CVec_ForwardNodeZ&) = delete;
10083         CVec_ForwardNodeZ(CVec_ForwardNodeZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ForwardNodeZ)); }
10084         CVec_ForwardNodeZ(LDKCVec_ForwardNodeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ForwardNodeZ)); }
10085         operator LDKCVec_ForwardNodeZ() && { LDKCVec_ForwardNodeZ res = self; memset(&self, 0, sizeof(LDKCVec_ForwardNodeZ)); return res; }
10086         ~CVec_ForwardNodeZ() { CVec_ForwardNodeZ_free(self); }
10087         CVec_ForwardNodeZ& operator=(CVec_ForwardNodeZ&& o) { CVec_ForwardNodeZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ForwardNodeZ)); return *this; }
10088         LDKCVec_ForwardNodeZ* operator &() { return &self; }
10089         LDKCVec_ForwardNodeZ* operator ->() { return &self; }
10090         const LDKCVec_ForwardNodeZ* operator &() const { return &self; }
10091         const LDKCVec_ForwardNodeZ* operator ->() const { return &self; }
10092 };
10093 class CResult_DelayedPaymentKeyDecodeErrorZ {
10094 private:
10095         LDKCResult_DelayedPaymentKeyDecodeErrorZ self;
10096 public:
10097         CResult_DelayedPaymentKeyDecodeErrorZ(const CResult_DelayedPaymentKeyDecodeErrorZ&) = delete;
10098         CResult_DelayedPaymentKeyDecodeErrorZ(CResult_DelayedPaymentKeyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentKeyDecodeErrorZ)); }
10099         CResult_DelayedPaymentKeyDecodeErrorZ(LDKCResult_DelayedPaymentKeyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentKeyDecodeErrorZ)); }
10100         operator LDKCResult_DelayedPaymentKeyDecodeErrorZ() && { LDKCResult_DelayedPaymentKeyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentKeyDecodeErrorZ)); return res; }
10101         ~CResult_DelayedPaymentKeyDecodeErrorZ() { CResult_DelayedPaymentKeyDecodeErrorZ_free(self); }
10102         CResult_DelayedPaymentKeyDecodeErrorZ& operator=(CResult_DelayedPaymentKeyDecodeErrorZ&& o) { CResult_DelayedPaymentKeyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentKeyDecodeErrorZ)); return *this; }
10103         LDKCResult_DelayedPaymentKeyDecodeErrorZ* operator &() { return &self; }
10104         LDKCResult_DelayedPaymentKeyDecodeErrorZ* operator ->() { return &self; }
10105         const LDKCResult_DelayedPaymentKeyDecodeErrorZ* operator &() const { return &self; }
10106         const LDKCResult_DelayedPaymentKeyDecodeErrorZ* operator ->() const { return &self; }
10107 };
10108 class CResult_InitDecodeErrorZ {
10109 private:
10110         LDKCResult_InitDecodeErrorZ self;
10111 public:
10112         CResult_InitDecodeErrorZ(const CResult_InitDecodeErrorZ&) = delete;
10113         CResult_InitDecodeErrorZ(CResult_InitDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); }
10114         CResult_InitDecodeErrorZ(LDKCResult_InitDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); }
10115         operator LDKCResult_InitDecodeErrorZ() && { LDKCResult_InitDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); return res; }
10116         ~CResult_InitDecodeErrorZ() { CResult_InitDecodeErrorZ_free(self); }
10117         CResult_InitDecodeErrorZ& operator=(CResult_InitDecodeErrorZ&& o) { CResult_InitDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); return *this; }
10118         LDKCResult_InitDecodeErrorZ* operator &() { return &self; }
10119         LDKCResult_InitDecodeErrorZ* operator ->() { return &self; }
10120         const LDKCResult_InitDecodeErrorZ* operator &() const { return &self; }
10121         const LDKCResult_InitDecodeErrorZ* operator ->() const { return &self; }
10122 };
10123 class CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ {
10124 private:
10125         LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ self;
10126 public:
10127         CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&) = delete;
10128         CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); }
10129         CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); }
10130         operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); return res; }
10131         ~CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(self); }
10132         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; }
10133         LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator &() { return &self; }
10134         LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator ->() { return &self; }
10135         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator &() const { return &self; }
10136         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator ->() const { return &self; }
10137 };
10138 class CResult_SpliceDecodeErrorZ {
10139 private:
10140         LDKCResult_SpliceDecodeErrorZ self;
10141 public:
10142         CResult_SpliceDecodeErrorZ(const CResult_SpliceDecodeErrorZ&) = delete;
10143         CResult_SpliceDecodeErrorZ(CResult_SpliceDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpliceDecodeErrorZ)); }
10144         CResult_SpliceDecodeErrorZ(LDKCResult_SpliceDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpliceDecodeErrorZ)); }
10145         operator LDKCResult_SpliceDecodeErrorZ() && { LDKCResult_SpliceDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpliceDecodeErrorZ)); return res; }
10146         ~CResult_SpliceDecodeErrorZ() { CResult_SpliceDecodeErrorZ_free(self); }
10147         CResult_SpliceDecodeErrorZ& operator=(CResult_SpliceDecodeErrorZ&& o) { CResult_SpliceDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpliceDecodeErrorZ)); return *this; }
10148         LDKCResult_SpliceDecodeErrorZ* operator &() { return &self; }
10149         LDKCResult_SpliceDecodeErrorZ* operator ->() { return &self; }
10150         const LDKCResult_SpliceDecodeErrorZ* operator &() const { return &self; }
10151         const LDKCResult_SpliceDecodeErrorZ* operator ->() const { return &self; }
10152 };
10153 class CResult_PaymentPurposeDecodeErrorZ {
10154 private:
10155         LDKCResult_PaymentPurposeDecodeErrorZ self;
10156 public:
10157         CResult_PaymentPurposeDecodeErrorZ(const CResult_PaymentPurposeDecodeErrorZ&) = delete;
10158         CResult_PaymentPurposeDecodeErrorZ(CResult_PaymentPurposeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentPurposeDecodeErrorZ)); }
10159         CResult_PaymentPurposeDecodeErrorZ(LDKCResult_PaymentPurposeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentPurposeDecodeErrorZ)); }
10160         operator LDKCResult_PaymentPurposeDecodeErrorZ() && { LDKCResult_PaymentPurposeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentPurposeDecodeErrorZ)); return res; }
10161         ~CResult_PaymentPurposeDecodeErrorZ() { CResult_PaymentPurposeDecodeErrorZ_free(self); }
10162         CResult_PaymentPurposeDecodeErrorZ& operator=(CResult_PaymentPurposeDecodeErrorZ&& o) { CResult_PaymentPurposeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentPurposeDecodeErrorZ)); return *this; }
10163         LDKCResult_PaymentPurposeDecodeErrorZ* operator &() { return &self; }
10164         LDKCResult_PaymentPurposeDecodeErrorZ* operator ->() { return &self; }
10165         const LDKCResult_PaymentPurposeDecodeErrorZ* operator &() const { return &self; }
10166         const LDKCResult_PaymentPurposeDecodeErrorZ* operator ->() const { return &self; }
10167 };
10168 class CResult_ClaimedHTLCDecodeErrorZ {
10169 private:
10170         LDKCResult_ClaimedHTLCDecodeErrorZ self;
10171 public:
10172         CResult_ClaimedHTLCDecodeErrorZ(const CResult_ClaimedHTLCDecodeErrorZ&) = delete;
10173         CResult_ClaimedHTLCDecodeErrorZ(CResult_ClaimedHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClaimedHTLCDecodeErrorZ)); }
10174         CResult_ClaimedHTLCDecodeErrorZ(LDKCResult_ClaimedHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ)); }
10175         operator LDKCResult_ClaimedHTLCDecodeErrorZ() && { LDKCResult_ClaimedHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ)); return res; }
10176         ~CResult_ClaimedHTLCDecodeErrorZ() { CResult_ClaimedHTLCDecodeErrorZ_free(self); }
10177         CResult_ClaimedHTLCDecodeErrorZ& operator=(CResult_ClaimedHTLCDecodeErrorZ&& o) { CResult_ClaimedHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClaimedHTLCDecodeErrorZ)); return *this; }
10178         LDKCResult_ClaimedHTLCDecodeErrorZ* operator &() { return &self; }
10179         LDKCResult_ClaimedHTLCDecodeErrorZ* operator ->() { return &self; }
10180         const LDKCResult_ClaimedHTLCDecodeErrorZ* operator &() const { return &self; }
10181         const LDKCResult_ClaimedHTLCDecodeErrorZ* operator ->() const { return &self; }
10182 };
10183 class C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ {
10184 private:
10185         LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ self;
10186 public:
10187         C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ(const C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ&) = delete;
10188         C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ(C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ)); }
10189         C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ)); }
10190         operator LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ() && { LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ)); return res; }
10191         ~C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ() { C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_free(self); }
10192         C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ& operator=(C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ&& o) { C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ)); return *this; }
10193         LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ* operator &() { return &self; }
10194         LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ* operator ->() { return &self; }
10195         const LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ* operator &() const { return &self; }
10196         const LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ* operator ->() const { return &self; }
10197 };
10198 class CResult_OutPointDecodeErrorZ {
10199 private:
10200         LDKCResult_OutPointDecodeErrorZ self;
10201 public:
10202         CResult_OutPointDecodeErrorZ(const CResult_OutPointDecodeErrorZ&) = delete;
10203         CResult_OutPointDecodeErrorZ(CResult_OutPointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OutPointDecodeErrorZ)); }
10204         CResult_OutPointDecodeErrorZ(LDKCResult_OutPointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OutPointDecodeErrorZ)); }
10205         operator LDKCResult_OutPointDecodeErrorZ() && { LDKCResult_OutPointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OutPointDecodeErrorZ)); return res; }
10206         ~CResult_OutPointDecodeErrorZ() { CResult_OutPointDecodeErrorZ_free(self); }
10207         CResult_OutPointDecodeErrorZ& operator=(CResult_OutPointDecodeErrorZ&& o) { CResult_OutPointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OutPointDecodeErrorZ)); return *this; }
10208         LDKCResult_OutPointDecodeErrorZ* operator &() { return &self; }
10209         LDKCResult_OutPointDecodeErrorZ* operator ->() { return &self; }
10210         const LDKCResult_OutPointDecodeErrorZ* operator &() const { return &self; }
10211         const LDKCResult_OutPointDecodeErrorZ* operator ->() const { return &self; }
10212 };
10213 class CVec_ChannelDetailsZ {
10214 private:
10215         LDKCVec_ChannelDetailsZ self;
10216 public:
10217         CVec_ChannelDetailsZ(const CVec_ChannelDetailsZ&) = delete;
10218         CVec_ChannelDetailsZ(CVec_ChannelDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelDetailsZ)); }
10219         CVec_ChannelDetailsZ(LDKCVec_ChannelDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelDetailsZ)); }
10220         operator LDKCVec_ChannelDetailsZ() && { LDKCVec_ChannelDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelDetailsZ)); return res; }
10221         ~CVec_ChannelDetailsZ() { CVec_ChannelDetailsZ_free(self); }
10222         CVec_ChannelDetailsZ& operator=(CVec_ChannelDetailsZ&& o) { CVec_ChannelDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelDetailsZ)); return *this; }
10223         LDKCVec_ChannelDetailsZ* operator &() { return &self; }
10224         LDKCVec_ChannelDetailsZ* operator ->() { return &self; }
10225         const LDKCVec_ChannelDetailsZ* operator &() const { return &self; }
10226         const LDKCVec_ChannelDetailsZ* operator ->() const { return &self; }
10227 };
10228 class CVec_MonitorUpdateIdZ {
10229 private:
10230         LDKCVec_MonitorUpdateIdZ self;
10231 public:
10232         CVec_MonitorUpdateIdZ(const CVec_MonitorUpdateIdZ&) = delete;
10233         CVec_MonitorUpdateIdZ(CVec_MonitorUpdateIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorUpdateIdZ)); }
10234         CVec_MonitorUpdateIdZ(LDKCVec_MonitorUpdateIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorUpdateIdZ)); }
10235         operator LDKCVec_MonitorUpdateIdZ() && { LDKCVec_MonitorUpdateIdZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorUpdateIdZ)); return res; }
10236         ~CVec_MonitorUpdateIdZ() { CVec_MonitorUpdateIdZ_free(self); }
10237         CVec_MonitorUpdateIdZ& operator=(CVec_MonitorUpdateIdZ&& o) { CVec_MonitorUpdateIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MonitorUpdateIdZ)); return *this; }
10238         LDKCVec_MonitorUpdateIdZ* operator &() { return &self; }
10239         LDKCVec_MonitorUpdateIdZ* operator ->() { return &self; }
10240         const LDKCVec_MonitorUpdateIdZ* operator &() const { return &self; }
10241         const LDKCVec_MonitorUpdateIdZ* operator ->() const { return &self; }
10242 };
10243 class CResult_Bolt11InvoiceFeaturesDecodeErrorZ {
10244 private:
10245         LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ self;
10246 public:
10247         CResult_Bolt11InvoiceFeaturesDecodeErrorZ(const CResult_Bolt11InvoiceFeaturesDecodeErrorZ&) = delete;
10248         CResult_Bolt11InvoiceFeaturesDecodeErrorZ(CResult_Bolt11InvoiceFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceFeaturesDecodeErrorZ)); }
10249         CResult_Bolt11InvoiceFeaturesDecodeErrorZ(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ)); }
10250         operator LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ() && { LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ)); return res; }
10251         ~CResult_Bolt11InvoiceFeaturesDecodeErrorZ() { CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(self); }
10252         CResult_Bolt11InvoiceFeaturesDecodeErrorZ& operator=(CResult_Bolt11InvoiceFeaturesDecodeErrorZ&& o) { CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceFeaturesDecodeErrorZ)); return *this; }
10253         LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator &() { return &self; }
10254         LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator ->() { return &self; }
10255         const LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
10256         const LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
10257 };
10258 class CVec_MessageSendEventZ {
10259 private:
10260         LDKCVec_MessageSendEventZ self;
10261 public:
10262         CVec_MessageSendEventZ(const CVec_MessageSendEventZ&) = delete;
10263         CVec_MessageSendEventZ(CVec_MessageSendEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MessageSendEventZ)); }
10264         CVec_MessageSendEventZ(LDKCVec_MessageSendEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MessageSendEventZ)); }
10265         operator LDKCVec_MessageSendEventZ() && { LDKCVec_MessageSendEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MessageSendEventZ)); return res; }
10266         ~CVec_MessageSendEventZ() { CVec_MessageSendEventZ_free(self); }
10267         CVec_MessageSendEventZ& operator=(CVec_MessageSendEventZ&& o) { CVec_MessageSendEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MessageSendEventZ)); return *this; }
10268         LDKCVec_MessageSendEventZ* operator &() { return &self; }
10269         LDKCVec_MessageSendEventZ* operator ->() { return &self; }
10270         const LDKCVec_MessageSendEventZ* operator &() const { return &self; }
10271         const LDKCVec_MessageSendEventZ* operator ->() const { return &self; }
10272 };
10273 class CResult_RouteHintHopDecodeErrorZ {
10274 private:
10275         LDKCResult_RouteHintHopDecodeErrorZ self;
10276 public:
10277         CResult_RouteHintHopDecodeErrorZ(const CResult_RouteHintHopDecodeErrorZ&) = delete;
10278         CResult_RouteHintHopDecodeErrorZ(CResult_RouteHintHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHintHopDecodeErrorZ)); }
10279         CResult_RouteHintHopDecodeErrorZ(LDKCResult_RouteHintHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHintHopDecodeErrorZ)); }
10280         operator LDKCResult_RouteHintHopDecodeErrorZ() && { LDKCResult_RouteHintHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHintHopDecodeErrorZ)); return res; }
10281         ~CResult_RouteHintHopDecodeErrorZ() { CResult_RouteHintHopDecodeErrorZ_free(self); }
10282         CResult_RouteHintHopDecodeErrorZ& operator=(CResult_RouteHintHopDecodeErrorZ&& o) { CResult_RouteHintHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHintHopDecodeErrorZ)); return *this; }
10283         LDKCResult_RouteHintHopDecodeErrorZ* operator &() { return &self; }
10284         LDKCResult_RouteHintHopDecodeErrorZ* operator ->() { return &self; }
10285         const LDKCResult_RouteHintHopDecodeErrorZ* operator &() const { return &self; }
10286         const LDKCResult_RouteHintHopDecodeErrorZ* operator ->() const { return &self; }
10287 };
10288 class CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ {
10289 private:
10290         LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ self;
10291 public:
10292         CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ(const CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ&) = delete;
10293         CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ(CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ)); }
10294         CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ(LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ)); }
10295         operator LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ() && { LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ)); return res; }
10296         ~CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ() { CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_free(self); }
10297         CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ& operator=(CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ&& o) { CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ)); return *this; }
10298         LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ* operator &() { return &self; }
10299         LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ* operator ->() { return &self; }
10300         const LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ* operator &() const { return &self; }
10301         const LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ* operator ->() const { return &self; }
10302 };
10303 class CResult_UpdateFailMalformedHTLCDecodeErrorZ {
10304 private:
10305         LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ self;
10306 public:
10307         CResult_UpdateFailMalformedHTLCDecodeErrorZ(const CResult_UpdateFailMalformedHTLCDecodeErrorZ&) = delete;
10308         CResult_UpdateFailMalformedHTLCDecodeErrorZ(CResult_UpdateFailMalformedHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFailMalformedHTLCDecodeErrorZ)); }
10309         CResult_UpdateFailMalformedHTLCDecodeErrorZ(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ)); }
10310         operator LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ() && { LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ)); return res; }
10311         ~CResult_UpdateFailMalformedHTLCDecodeErrorZ() { CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(self); }
10312         CResult_UpdateFailMalformedHTLCDecodeErrorZ& operator=(CResult_UpdateFailMalformedHTLCDecodeErrorZ&& o) { CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFailMalformedHTLCDecodeErrorZ)); return *this; }
10313         LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() { return &self; }
10314         LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() { return &self; }
10315         const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() const { return &self; }
10316         const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() const { return &self; }
10317 };
10318 class CResult_BlindedPayInfoDecodeErrorZ {
10319 private:
10320         LDKCResult_BlindedPayInfoDecodeErrorZ self;
10321 public:
10322         CResult_BlindedPayInfoDecodeErrorZ(const CResult_BlindedPayInfoDecodeErrorZ&) = delete;
10323         CResult_BlindedPayInfoDecodeErrorZ(CResult_BlindedPayInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPayInfoDecodeErrorZ)); }
10324         CResult_BlindedPayInfoDecodeErrorZ(LDKCResult_BlindedPayInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ)); }
10325         operator LDKCResult_BlindedPayInfoDecodeErrorZ() && { LDKCResult_BlindedPayInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ)); return res; }
10326         ~CResult_BlindedPayInfoDecodeErrorZ() { CResult_BlindedPayInfoDecodeErrorZ_free(self); }
10327         CResult_BlindedPayInfoDecodeErrorZ& operator=(CResult_BlindedPayInfoDecodeErrorZ&& o) { CResult_BlindedPayInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPayInfoDecodeErrorZ)); return *this; }
10328         LDKCResult_BlindedPayInfoDecodeErrorZ* operator &() { return &self; }
10329         LDKCResult_BlindedPayInfoDecodeErrorZ* operator ->() { return &self; }
10330         const LDKCResult_BlindedPayInfoDecodeErrorZ* operator &() const { return &self; }
10331         const LDKCResult_BlindedPayInfoDecodeErrorZ* operator ->() const { return &self; }
10332 };
10333 class CResult_ThirtyTwoBytesAPIErrorZ {
10334 private:
10335         LDKCResult_ThirtyTwoBytesAPIErrorZ self;
10336 public:
10337         CResult_ThirtyTwoBytesAPIErrorZ(const CResult_ThirtyTwoBytesAPIErrorZ&) = delete;
10338         CResult_ThirtyTwoBytesAPIErrorZ(CResult_ThirtyTwoBytesAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesAPIErrorZ)); }
10339         CResult_ThirtyTwoBytesAPIErrorZ(LDKCResult_ThirtyTwoBytesAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesAPIErrorZ)); }
10340         operator LDKCResult_ThirtyTwoBytesAPIErrorZ() && { LDKCResult_ThirtyTwoBytesAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesAPIErrorZ)); return res; }
10341         ~CResult_ThirtyTwoBytesAPIErrorZ() { CResult_ThirtyTwoBytesAPIErrorZ_free(self); }
10342         CResult_ThirtyTwoBytesAPIErrorZ& operator=(CResult_ThirtyTwoBytesAPIErrorZ&& o) { CResult_ThirtyTwoBytesAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesAPIErrorZ)); return *this; }
10343         LDKCResult_ThirtyTwoBytesAPIErrorZ* operator &() { return &self; }
10344         LDKCResult_ThirtyTwoBytesAPIErrorZ* operator ->() { return &self; }
10345         const LDKCResult_ThirtyTwoBytesAPIErrorZ* operator &() const { return &self; }
10346         const LDKCResult_ThirtyTwoBytesAPIErrorZ* operator ->() const { return &self; }
10347 };
10348 class COption_ChannelShutdownStateZ {
10349 private:
10350         LDKCOption_ChannelShutdownStateZ self;
10351 public:
10352         COption_ChannelShutdownStateZ(const COption_ChannelShutdownStateZ&) = delete;
10353         COption_ChannelShutdownStateZ(COption_ChannelShutdownStateZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ChannelShutdownStateZ)); }
10354         COption_ChannelShutdownStateZ(LDKCOption_ChannelShutdownStateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ChannelShutdownStateZ)); }
10355         operator LDKCOption_ChannelShutdownStateZ() && { LDKCOption_ChannelShutdownStateZ res = self; memset(&self, 0, sizeof(LDKCOption_ChannelShutdownStateZ)); return res; }
10356         ~COption_ChannelShutdownStateZ() { COption_ChannelShutdownStateZ_free(self); }
10357         COption_ChannelShutdownStateZ& operator=(COption_ChannelShutdownStateZ&& o) { COption_ChannelShutdownStateZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ChannelShutdownStateZ)); return *this; }
10358         LDKCOption_ChannelShutdownStateZ* operator &() { return &self; }
10359         LDKCOption_ChannelShutdownStateZ* operator ->() { return &self; }
10360         const LDKCOption_ChannelShutdownStateZ* operator &() const { return &self; }
10361         const LDKCOption_ChannelShutdownStateZ* operator ->() const { return &self; }
10362 };
10363 class CResult_AcceptChannelDecodeErrorZ {
10364 private:
10365         LDKCResult_AcceptChannelDecodeErrorZ self;
10366 public:
10367         CResult_AcceptChannelDecodeErrorZ(const CResult_AcceptChannelDecodeErrorZ&) = delete;
10368         CResult_AcceptChannelDecodeErrorZ(CResult_AcceptChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); }
10369         CResult_AcceptChannelDecodeErrorZ(LDKCResult_AcceptChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); }
10370         operator LDKCResult_AcceptChannelDecodeErrorZ() && { LDKCResult_AcceptChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); return res; }
10371         ~CResult_AcceptChannelDecodeErrorZ() { CResult_AcceptChannelDecodeErrorZ_free(self); }
10372         CResult_AcceptChannelDecodeErrorZ& operator=(CResult_AcceptChannelDecodeErrorZ&& o) { CResult_AcceptChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); return *this; }
10373         LDKCResult_AcceptChannelDecodeErrorZ* operator &() { return &self; }
10374         LDKCResult_AcceptChannelDecodeErrorZ* operator ->() { return &self; }
10375         const LDKCResult_AcceptChannelDecodeErrorZ* operator &() const { return &self; }
10376         const LDKCResult_AcceptChannelDecodeErrorZ* operator ->() const { return &self; }
10377 };
10378 class CResult_HostnameDecodeErrorZ {
10379 private:
10380         LDKCResult_HostnameDecodeErrorZ self;
10381 public:
10382         CResult_HostnameDecodeErrorZ(const CResult_HostnameDecodeErrorZ&) = delete;
10383         CResult_HostnameDecodeErrorZ(CResult_HostnameDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HostnameDecodeErrorZ)); }
10384         CResult_HostnameDecodeErrorZ(LDKCResult_HostnameDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HostnameDecodeErrorZ)); }
10385         operator LDKCResult_HostnameDecodeErrorZ() && { LDKCResult_HostnameDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HostnameDecodeErrorZ)); return res; }
10386         ~CResult_HostnameDecodeErrorZ() { CResult_HostnameDecodeErrorZ_free(self); }
10387         CResult_HostnameDecodeErrorZ& operator=(CResult_HostnameDecodeErrorZ&& o) { CResult_HostnameDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HostnameDecodeErrorZ)); return *this; }
10388         LDKCResult_HostnameDecodeErrorZ* operator &() { return &self; }
10389         LDKCResult_HostnameDecodeErrorZ* operator ->() { return &self; }
10390         const LDKCResult_HostnameDecodeErrorZ* operator &() const { return &self; }
10391         const LDKCResult_HostnameDecodeErrorZ* operator ->() const { return &self; }
10392 };
10393 class C2Tuple_u64u16Z {
10394 private:
10395         LDKC2Tuple_u64u16Z self;
10396 public:
10397         C2Tuple_u64u16Z(const C2Tuple_u64u16Z&) = delete;
10398         C2Tuple_u64u16Z(C2Tuple_u64u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64u16Z)); }
10399         C2Tuple_u64u16Z(LDKC2Tuple_u64u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64u16Z)); }
10400         operator LDKC2Tuple_u64u16Z() && { LDKC2Tuple_u64u16Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64u16Z)); return res; }
10401         ~C2Tuple_u64u16Z() { C2Tuple_u64u16Z_free(self); }
10402         C2Tuple_u64u16Z& operator=(C2Tuple_u64u16Z&& o) { C2Tuple_u64u16Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u64u16Z)); return *this; }
10403         LDKC2Tuple_u64u16Z* operator &() { return &self; }
10404         LDKC2Tuple_u64u16Z* operator ->() { return &self; }
10405         const LDKC2Tuple_u64u16Z* operator &() const { return &self; }
10406         const LDKC2Tuple_u64u16Z* operator ->() const { return &self; }
10407 };
10408 class COption_ThirtyTwoBytesZ {
10409 private:
10410         LDKCOption_ThirtyTwoBytesZ self;
10411 public:
10412         COption_ThirtyTwoBytesZ(const COption_ThirtyTwoBytesZ&) = delete;
10413         COption_ThirtyTwoBytesZ(COption_ThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ThirtyTwoBytesZ)); }
10414         COption_ThirtyTwoBytesZ(LDKCOption_ThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ThirtyTwoBytesZ)); }
10415         operator LDKCOption_ThirtyTwoBytesZ() && { LDKCOption_ThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKCOption_ThirtyTwoBytesZ)); return res; }
10416         ~COption_ThirtyTwoBytesZ() { COption_ThirtyTwoBytesZ_free(self); }
10417         COption_ThirtyTwoBytesZ& operator=(COption_ThirtyTwoBytesZ&& o) { COption_ThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ThirtyTwoBytesZ)); return *this; }
10418         LDKCOption_ThirtyTwoBytesZ* operator &() { return &self; }
10419         LDKCOption_ThirtyTwoBytesZ* operator ->() { return &self; }
10420         const LDKCOption_ThirtyTwoBytesZ* operator &() const { return &self; }
10421         const LDKCOption_ThirtyTwoBytesZ* operator ->() const { return &self; }
10422 };
10423 class CVec_u64Z {
10424 private:
10425         LDKCVec_u64Z self;
10426 public:
10427         CVec_u64Z(const CVec_u64Z&) = delete;
10428         CVec_u64Z(CVec_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u64Z)); }
10429         CVec_u64Z(LDKCVec_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u64Z)); }
10430         operator LDKCVec_u64Z() && { LDKCVec_u64Z res = self; memset(&self, 0, sizeof(LDKCVec_u64Z)); return res; }
10431         ~CVec_u64Z() { CVec_u64Z_free(self); }
10432         CVec_u64Z& operator=(CVec_u64Z&& o) { CVec_u64Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u64Z)); return *this; }
10433         LDKCVec_u64Z* operator &() { return &self; }
10434         LDKCVec_u64Z* operator ->() { return &self; }
10435         const LDKCVec_u64Z* operator &() const { return &self; }
10436         const LDKCVec_u64Z* operator ->() const { return &self; }
10437 };
10438 class CResult_NoneBolt12SemanticErrorZ {
10439 private:
10440         LDKCResult_NoneBolt12SemanticErrorZ self;
10441 public:
10442         CResult_NoneBolt12SemanticErrorZ(const CResult_NoneBolt12SemanticErrorZ&) = delete;
10443         CResult_NoneBolt12SemanticErrorZ(CResult_NoneBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneBolt12SemanticErrorZ)); }
10444         CResult_NoneBolt12SemanticErrorZ(LDKCResult_NoneBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneBolt12SemanticErrorZ)); }
10445         operator LDKCResult_NoneBolt12SemanticErrorZ() && { LDKCResult_NoneBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneBolt12SemanticErrorZ)); return res; }
10446         ~CResult_NoneBolt12SemanticErrorZ() { CResult_NoneBolt12SemanticErrorZ_free(self); }
10447         CResult_NoneBolt12SemanticErrorZ& operator=(CResult_NoneBolt12SemanticErrorZ&& o) { CResult_NoneBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneBolt12SemanticErrorZ)); return *this; }
10448         LDKCResult_NoneBolt12SemanticErrorZ* operator &() { return &self; }
10449         LDKCResult_NoneBolt12SemanticErrorZ* operator ->() { return &self; }
10450         const LDKCResult_NoneBolt12SemanticErrorZ* operator &() const { return &self; }
10451         const LDKCResult_NoneBolt12SemanticErrorZ* operator ->() const { return &self; }
10452 };
10453 class COption_SecretKeyZ {
10454 private:
10455         LDKCOption_SecretKeyZ self;
10456 public:
10457         COption_SecretKeyZ(const COption_SecretKeyZ&) = delete;
10458         COption_SecretKeyZ(COption_SecretKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_SecretKeyZ)); }
10459         COption_SecretKeyZ(LDKCOption_SecretKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_SecretKeyZ)); }
10460         operator LDKCOption_SecretKeyZ() && { LDKCOption_SecretKeyZ res = self; memset(&self, 0, sizeof(LDKCOption_SecretKeyZ)); return res; }
10461         ~COption_SecretKeyZ() { COption_SecretKeyZ_free(self); }
10462         COption_SecretKeyZ& operator=(COption_SecretKeyZ&& o) { COption_SecretKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_SecretKeyZ)); return *this; }
10463         LDKCOption_SecretKeyZ* operator &() { return &self; }
10464         LDKCOption_SecretKeyZ* operator ->() { return &self; }
10465         const LDKCOption_SecretKeyZ* operator &() const { return &self; }
10466         const LDKCOption_SecretKeyZ* operator ->() const { return &self; }
10467 };
10468 class CResult_C2Tuple_CVec_u8Zu64ZNoneZ {
10469 private:
10470         LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ self;
10471 public:
10472         CResult_C2Tuple_CVec_u8Zu64ZNoneZ(const CResult_C2Tuple_CVec_u8Zu64ZNoneZ&) = delete;
10473         CResult_C2Tuple_CVec_u8Zu64ZNoneZ(CResult_C2Tuple_CVec_u8Zu64ZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_CVec_u8Zu64ZNoneZ)); }
10474         CResult_C2Tuple_CVec_u8Zu64ZNoneZ(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ)); }
10475         operator LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ() && { LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ)); return res; }
10476         ~CResult_C2Tuple_CVec_u8Zu64ZNoneZ() { CResult_C2Tuple_CVec_u8Zu64ZNoneZ_free(self); }
10477         CResult_C2Tuple_CVec_u8Zu64ZNoneZ& operator=(CResult_C2Tuple_CVec_u8Zu64ZNoneZ&& o) { CResult_C2Tuple_CVec_u8Zu64ZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_CVec_u8Zu64ZNoneZ)); return *this; }
10478         LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ* operator &() { return &self; }
10479         LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ* operator ->() { return &self; }
10480         const LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ* operator &() const { return &self; }
10481         const LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ* operator ->() const { return &self; }
10482 };
10483 class COption_EventZ {
10484 private:
10485         LDKCOption_EventZ self;
10486 public:
10487         COption_EventZ(const COption_EventZ&) = delete;
10488         COption_EventZ(COption_EventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_EventZ)); }
10489         COption_EventZ(LDKCOption_EventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_EventZ)); }
10490         operator LDKCOption_EventZ() && { LDKCOption_EventZ res = self; memset(&self, 0, sizeof(LDKCOption_EventZ)); return res; }
10491         ~COption_EventZ() { COption_EventZ_free(self); }
10492         COption_EventZ& operator=(COption_EventZ&& o) { COption_EventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_EventZ)); return *this; }
10493         LDKCOption_EventZ* operator &() { return &self; }
10494         LDKCOption_EventZ* operator ->() { return &self; }
10495         const LDKCOption_EventZ* operator &() const { return &self; }
10496         const LDKCOption_EventZ* operator ->() const { return &self; }
10497 };
10498 class CResult_ChannelTypeFeaturesDecodeErrorZ {
10499 private:
10500         LDKCResult_ChannelTypeFeaturesDecodeErrorZ self;
10501 public:
10502         CResult_ChannelTypeFeaturesDecodeErrorZ(const CResult_ChannelTypeFeaturesDecodeErrorZ&) = delete;
10503         CResult_ChannelTypeFeaturesDecodeErrorZ(CResult_ChannelTypeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTypeFeaturesDecodeErrorZ)); }
10504         CResult_ChannelTypeFeaturesDecodeErrorZ(LDKCResult_ChannelTypeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ)); }
10505         operator LDKCResult_ChannelTypeFeaturesDecodeErrorZ() && { LDKCResult_ChannelTypeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ)); return res; }
10506         ~CResult_ChannelTypeFeaturesDecodeErrorZ() { CResult_ChannelTypeFeaturesDecodeErrorZ_free(self); }
10507         CResult_ChannelTypeFeaturesDecodeErrorZ& operator=(CResult_ChannelTypeFeaturesDecodeErrorZ&& o) { CResult_ChannelTypeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTypeFeaturesDecodeErrorZ)); return *this; }
10508         LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() { return &self; }
10509         LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() { return &self; }
10510         const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() const { return &self; }
10511         const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() const { return &self; }
10512 };
10513 class COption_CVec_SocketAddressZZ {
10514 private:
10515         LDKCOption_CVec_SocketAddressZZ self;
10516 public:
10517         COption_CVec_SocketAddressZZ(const COption_CVec_SocketAddressZZ&) = delete;
10518         COption_CVec_SocketAddressZZ(COption_CVec_SocketAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_SocketAddressZZ)); }
10519         COption_CVec_SocketAddressZZ(LDKCOption_CVec_SocketAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_SocketAddressZZ)); }
10520         operator LDKCOption_CVec_SocketAddressZZ() && { LDKCOption_CVec_SocketAddressZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_SocketAddressZZ)); return res; }
10521         ~COption_CVec_SocketAddressZZ() { COption_CVec_SocketAddressZZ_free(self); }
10522         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; }
10523         LDKCOption_CVec_SocketAddressZZ* operator &() { return &self; }
10524         LDKCOption_CVec_SocketAddressZZ* operator ->() { return &self; }
10525         const LDKCOption_CVec_SocketAddressZZ* operator &() const { return &self; }
10526         const LDKCOption_CVec_SocketAddressZZ* operator ->() const { return &self; }
10527 };
10528 class CVec_RouteHintZ {
10529 private:
10530         LDKCVec_RouteHintZ self;
10531 public:
10532         CVec_RouteHintZ(const CVec_RouteHintZ&) = delete;
10533         CVec_RouteHintZ(CVec_RouteHintZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintZ)); }
10534         CVec_RouteHintZ(LDKCVec_RouteHintZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintZ)); }
10535         operator LDKCVec_RouteHintZ() && { LDKCVec_RouteHintZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintZ)); return res; }
10536         ~CVec_RouteHintZ() { CVec_RouteHintZ_free(self); }
10537         CVec_RouteHintZ& operator=(CVec_RouteHintZ&& o) { CVec_RouteHintZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintZ)); return *this; }
10538         LDKCVec_RouteHintZ* operator &() { return &self; }
10539         LDKCVec_RouteHintZ* operator ->() { return &self; }
10540         const LDKCVec_RouteHintZ* operator &() const { return &self; }
10541         const LDKCVec_RouteHintZ* operator ->() const { return &self; }
10542 };
10543 class COption_u16Z {
10544 private:
10545         LDKCOption_u16Z self;
10546 public:
10547         COption_u16Z(const COption_u16Z&) = delete;
10548         COption_u16Z(COption_u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u16Z)); }
10549         COption_u16Z(LDKCOption_u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u16Z)); }
10550         operator LDKCOption_u16Z() && { LDKCOption_u16Z res = self; memset(&self, 0, sizeof(LDKCOption_u16Z)); return res; }
10551         ~COption_u16Z() { COption_u16Z_free(self); }
10552         COption_u16Z& operator=(COption_u16Z&& o) { COption_u16Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u16Z)); return *this; }
10553         LDKCOption_u16Z* operator &() { return &self; }
10554         LDKCOption_u16Z* operator ->() { return &self; }
10555         const LDKCOption_u16Z* operator &() const { return &self; }
10556         const LDKCOption_u16Z* operator ->() const { return &self; }
10557 };
10558 class COption_PaymentFailureReasonZ {
10559 private:
10560         LDKCOption_PaymentFailureReasonZ self;
10561 public:
10562         COption_PaymentFailureReasonZ(const COption_PaymentFailureReasonZ&) = delete;
10563         COption_PaymentFailureReasonZ(COption_PaymentFailureReasonZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_PaymentFailureReasonZ)); }
10564         COption_PaymentFailureReasonZ(LDKCOption_PaymentFailureReasonZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_PaymentFailureReasonZ)); }
10565         operator LDKCOption_PaymentFailureReasonZ() && { LDKCOption_PaymentFailureReasonZ res = self; memset(&self, 0, sizeof(LDKCOption_PaymentFailureReasonZ)); return res; }
10566         ~COption_PaymentFailureReasonZ() { COption_PaymentFailureReasonZ_free(self); }
10567         COption_PaymentFailureReasonZ& operator=(COption_PaymentFailureReasonZ&& o) { COption_PaymentFailureReasonZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_PaymentFailureReasonZ)); return *this; }
10568         LDKCOption_PaymentFailureReasonZ* operator &() { return &self; }
10569         LDKCOption_PaymentFailureReasonZ* operator ->() { return &self; }
10570         const LDKCOption_PaymentFailureReasonZ* operator &() const { return &self; }
10571         const LDKCOption_PaymentFailureReasonZ* operator ->() const { return &self; }
10572 };
10573 class CResult_ECDSASignatureNoneZ {
10574 private:
10575         LDKCResult_ECDSASignatureNoneZ self;
10576 public:
10577         CResult_ECDSASignatureNoneZ(const CResult_ECDSASignatureNoneZ&) = delete;
10578         CResult_ECDSASignatureNoneZ(CResult_ECDSASignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ECDSASignatureNoneZ)); }
10579         CResult_ECDSASignatureNoneZ(LDKCResult_ECDSASignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ECDSASignatureNoneZ)); }
10580         operator LDKCResult_ECDSASignatureNoneZ() && { LDKCResult_ECDSASignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ECDSASignatureNoneZ)); return res; }
10581         ~CResult_ECDSASignatureNoneZ() { CResult_ECDSASignatureNoneZ_free(self); }
10582         CResult_ECDSASignatureNoneZ& operator=(CResult_ECDSASignatureNoneZ&& o) { CResult_ECDSASignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ECDSASignatureNoneZ)); return *this; }
10583         LDKCResult_ECDSASignatureNoneZ* operator &() { return &self; }
10584         LDKCResult_ECDSASignatureNoneZ* operator ->() { return &self; }
10585         const LDKCResult_ECDSASignatureNoneZ* operator &() const { return &self; }
10586         const LDKCResult_ECDSASignatureNoneZ* operator ->() const { return &self; }
10587 };
10588 class CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ {
10589 private:
10590         LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ self;
10591 public:
10592         CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ(const CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ&) = delete;
10593         CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ(CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ)); }
10594         CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ(LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ)); }
10595         operator LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ() && { LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ)); return res; }
10596         ~CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ() { CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_free(self); }
10597         CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ& operator=(CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ&& o) { CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ)); return *this; }
10598         LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ* operator &() { return &self; }
10599         LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ* operator ->() { return &self; }
10600         const LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ* operator &() const { return &self; }
10601         const LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ* operator ->() const { return &self; }
10602 };
10603 class CVec_WitnessZ {
10604 private:
10605         LDKCVec_WitnessZ self;
10606 public:
10607         CVec_WitnessZ(const CVec_WitnessZ&) = delete;
10608         CVec_WitnessZ(CVec_WitnessZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_WitnessZ)); }
10609         CVec_WitnessZ(LDKCVec_WitnessZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_WitnessZ)); }
10610         operator LDKCVec_WitnessZ() && { LDKCVec_WitnessZ res = self; memset(&self, 0, sizeof(LDKCVec_WitnessZ)); return res; }
10611         ~CVec_WitnessZ() { CVec_WitnessZ_free(self); }
10612         CVec_WitnessZ& operator=(CVec_WitnessZ&& o) { CVec_WitnessZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_WitnessZ)); return *this; }
10613         LDKCVec_WitnessZ* operator &() { return &self; }
10614         LDKCVec_WitnessZ* operator ->() { return &self; }
10615         const LDKCVec_WitnessZ* operator &() const { return &self; }
10616         const LDKCVec_WitnessZ* operator ->() const { return &self; }
10617 };
10618 class CResult_BlindedTailDecodeErrorZ {
10619 private:
10620         LDKCResult_BlindedTailDecodeErrorZ self;
10621 public:
10622         CResult_BlindedTailDecodeErrorZ(const CResult_BlindedTailDecodeErrorZ&) = delete;
10623         CResult_BlindedTailDecodeErrorZ(CResult_BlindedTailDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedTailDecodeErrorZ)); }
10624         CResult_BlindedTailDecodeErrorZ(LDKCResult_BlindedTailDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedTailDecodeErrorZ)); }
10625         operator LDKCResult_BlindedTailDecodeErrorZ() && { LDKCResult_BlindedTailDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedTailDecodeErrorZ)); return res; }
10626         ~CResult_BlindedTailDecodeErrorZ() { CResult_BlindedTailDecodeErrorZ_free(self); }
10627         CResult_BlindedTailDecodeErrorZ& operator=(CResult_BlindedTailDecodeErrorZ&& o) { CResult_BlindedTailDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedTailDecodeErrorZ)); return *this; }
10628         LDKCResult_BlindedTailDecodeErrorZ* operator &() { return &self; }
10629         LDKCResult_BlindedTailDecodeErrorZ* operator ->() { return &self; }
10630         const LDKCResult_BlindedTailDecodeErrorZ* operator &() const { return &self; }
10631         const LDKCResult_BlindedTailDecodeErrorZ* operator ->() const { return &self; }
10632 };
10633 class CResult_SocketAddressSocketAddressParseErrorZ {
10634 private:
10635         LDKCResult_SocketAddressSocketAddressParseErrorZ self;
10636 public:
10637         CResult_SocketAddressSocketAddressParseErrorZ(const CResult_SocketAddressSocketAddressParseErrorZ&) = delete;
10638         CResult_SocketAddressSocketAddressParseErrorZ(CResult_SocketAddressSocketAddressParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SocketAddressSocketAddressParseErrorZ)); }
10639         CResult_SocketAddressSocketAddressParseErrorZ(LDKCResult_SocketAddressSocketAddressParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ)); }
10640         operator LDKCResult_SocketAddressSocketAddressParseErrorZ() && { LDKCResult_SocketAddressSocketAddressParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ)); return res; }
10641         ~CResult_SocketAddressSocketAddressParseErrorZ() { CResult_SocketAddressSocketAddressParseErrorZ_free(self); }
10642         CResult_SocketAddressSocketAddressParseErrorZ& operator=(CResult_SocketAddressSocketAddressParseErrorZ&& o) { CResult_SocketAddressSocketAddressParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SocketAddressSocketAddressParseErrorZ)); return *this; }
10643         LDKCResult_SocketAddressSocketAddressParseErrorZ* operator &() { return &self; }
10644         LDKCResult_SocketAddressSocketAddressParseErrorZ* operator ->() { return &self; }
10645         const LDKCResult_SocketAddressSocketAddressParseErrorZ* operator &() const { return &self; }
10646         const LDKCResult_SocketAddressSocketAddressParseErrorZ* operator ->() const { return &self; }
10647 };
10648 class COption_C2Tuple_u64u16ZZ {
10649 private:
10650         LDKCOption_C2Tuple_u64u16ZZ self;
10651 public:
10652         COption_C2Tuple_u64u16ZZ(const COption_C2Tuple_u64u16ZZ&) = delete;
10653         COption_C2Tuple_u64u16ZZ(COption_C2Tuple_u64u16ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_u64u16ZZ)); }
10654         COption_C2Tuple_u64u16ZZ(LDKCOption_C2Tuple_u64u16ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_u64u16ZZ)); }
10655         operator LDKCOption_C2Tuple_u64u16ZZ() && { LDKCOption_C2Tuple_u64u16ZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_u64u16ZZ)); return res; }
10656         ~COption_C2Tuple_u64u16ZZ() { COption_C2Tuple_u64u16ZZ_free(self); }
10657         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; }
10658         LDKCOption_C2Tuple_u64u16ZZ* operator &() { return &self; }
10659         LDKCOption_C2Tuple_u64u16ZZ* operator ->() { return &self; }
10660         const LDKCOption_C2Tuple_u64u16ZZ* operator &() const { return &self; }
10661         const LDKCOption_C2Tuple_u64u16ZZ* operator ->() const { return &self; }
10662 };
10663 class CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ {
10664 private:
10665         LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ self;
10666 public:
10667         CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(const CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&) = delete;
10668         CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); }
10669         CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); }
10670         operator LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ() && { LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); return res; }
10671         ~CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ() { CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(self); }
10672         CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ& operator=(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& o) { CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); return *this; }
10673         LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator &() { return &self; }
10674         LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator ->() { return &self; }
10675         const LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator &() const { return &self; }
10676         const LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator ->() const { return &self; }
10677 };
10678 class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ {
10679 private:
10680         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ self;
10681 public:
10682         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(const CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&) = delete;
10683         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); }
10684         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); }
10685         operator LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ() && { LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); return res; }
10686         ~CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ() { CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(self); }
10687         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; }
10688         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator &() { return &self; }
10689         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator ->() { return &self; }
10690         const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator &() const { return &self; }
10691         const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator ->() const { return &self; }
10692 };
10693 class CResult_ChannelDerivationParametersDecodeErrorZ {
10694 private:
10695         LDKCResult_ChannelDerivationParametersDecodeErrorZ self;
10696 public:
10697         CResult_ChannelDerivationParametersDecodeErrorZ(const CResult_ChannelDerivationParametersDecodeErrorZ&) = delete;
10698         CResult_ChannelDerivationParametersDecodeErrorZ(CResult_ChannelDerivationParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelDerivationParametersDecodeErrorZ)); }
10699         CResult_ChannelDerivationParametersDecodeErrorZ(LDKCResult_ChannelDerivationParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelDerivationParametersDecodeErrorZ)); }
10700         operator LDKCResult_ChannelDerivationParametersDecodeErrorZ() && { LDKCResult_ChannelDerivationParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelDerivationParametersDecodeErrorZ)); return res; }
10701         ~CResult_ChannelDerivationParametersDecodeErrorZ() { CResult_ChannelDerivationParametersDecodeErrorZ_free(self); }
10702         CResult_ChannelDerivationParametersDecodeErrorZ& operator=(CResult_ChannelDerivationParametersDecodeErrorZ&& o) { CResult_ChannelDerivationParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelDerivationParametersDecodeErrorZ)); return *this; }
10703         LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator &() { return &self; }
10704         LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator ->() { return &self; }
10705         const LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator &() const { return &self; }
10706         const LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator ->() const { return &self; }
10707 };
10708 class CResult_PaymentConstraintsDecodeErrorZ {
10709 private:
10710         LDKCResult_PaymentConstraintsDecodeErrorZ self;
10711 public:
10712         CResult_PaymentConstraintsDecodeErrorZ(const CResult_PaymentConstraintsDecodeErrorZ&) = delete;
10713         CResult_PaymentConstraintsDecodeErrorZ(CResult_PaymentConstraintsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentConstraintsDecodeErrorZ)); }
10714         CResult_PaymentConstraintsDecodeErrorZ(LDKCResult_PaymentConstraintsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ)); }
10715         operator LDKCResult_PaymentConstraintsDecodeErrorZ() && { LDKCResult_PaymentConstraintsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ)); return res; }
10716         ~CResult_PaymentConstraintsDecodeErrorZ() { CResult_PaymentConstraintsDecodeErrorZ_free(self); }
10717         CResult_PaymentConstraintsDecodeErrorZ& operator=(CResult_PaymentConstraintsDecodeErrorZ&& o) { CResult_PaymentConstraintsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentConstraintsDecodeErrorZ)); return *this; }
10718         LDKCResult_PaymentConstraintsDecodeErrorZ* operator &() { return &self; }
10719         LDKCResult_PaymentConstraintsDecodeErrorZ* operator ->() { return &self; }
10720         const LDKCResult_PaymentConstraintsDecodeErrorZ* operator &() const { return &self; }
10721         const LDKCResult_PaymentConstraintsDecodeErrorZ* operator ->() const { return &self; }
10722 };
10723 class CResult_OnionMessagePathNoneZ {
10724 private:
10725         LDKCResult_OnionMessagePathNoneZ self;
10726 public:
10727         CResult_OnionMessagePathNoneZ(const CResult_OnionMessagePathNoneZ&) = delete;
10728         CResult_OnionMessagePathNoneZ(CResult_OnionMessagePathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionMessagePathNoneZ)); }
10729         CResult_OnionMessagePathNoneZ(LDKCResult_OnionMessagePathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionMessagePathNoneZ)); }
10730         operator LDKCResult_OnionMessagePathNoneZ() && { LDKCResult_OnionMessagePathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionMessagePathNoneZ)); return res; }
10731         ~CResult_OnionMessagePathNoneZ() { CResult_OnionMessagePathNoneZ_free(self); }
10732         CResult_OnionMessagePathNoneZ& operator=(CResult_OnionMessagePathNoneZ&& o) { CResult_OnionMessagePathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionMessagePathNoneZ)); return *this; }
10733         LDKCResult_OnionMessagePathNoneZ* operator &() { return &self; }
10734         LDKCResult_OnionMessagePathNoneZ* operator ->() { return &self; }
10735         const LDKCResult_OnionMessagePathNoneZ* operator &() const { return &self; }
10736         const LDKCResult_OnionMessagePathNoneZ* operator ->() const { return &self; }
10737 };
10738 class C2Tuple_u32CVec_u8ZZ {
10739 private:
10740         LDKC2Tuple_u32CVec_u8ZZ self;
10741 public:
10742         C2Tuple_u32CVec_u8ZZ(const C2Tuple_u32CVec_u8ZZ&) = delete;
10743         C2Tuple_u32CVec_u8ZZ(C2Tuple_u32CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u32CVec_u8ZZ)); }
10744         C2Tuple_u32CVec_u8ZZ(LDKC2Tuple_u32CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u32CVec_u8ZZ)); }
10745         operator LDKC2Tuple_u32CVec_u8ZZ() && { LDKC2Tuple_u32CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u32CVec_u8ZZ)); return res; }
10746         ~C2Tuple_u32CVec_u8ZZ() { C2Tuple_u32CVec_u8ZZ_free(self); }
10747         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; }
10748         LDKC2Tuple_u32CVec_u8ZZ* operator &() { return &self; }
10749         LDKC2Tuple_u32CVec_u8ZZ* operator ->() { return &self; }
10750         const LDKC2Tuple_u32CVec_u8ZZ* operator &() const { return &self; }
10751         const LDKC2Tuple_u32CVec_u8ZZ* operator ->() const { return &self; }
10752 };
10753 class CVec_C2Tuple_PublicKeyTypeZZ {
10754 private:
10755         LDKCVec_C2Tuple_PublicKeyTypeZZ self;
10756 public:
10757         CVec_C2Tuple_PublicKeyTypeZZ(const CVec_C2Tuple_PublicKeyTypeZZ&) = delete;
10758         CVec_C2Tuple_PublicKeyTypeZZ(CVec_C2Tuple_PublicKeyTypeZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyTypeZZ)); }
10759         CVec_C2Tuple_PublicKeyTypeZZ(LDKCVec_C2Tuple_PublicKeyTypeZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ)); }
10760         operator LDKCVec_C2Tuple_PublicKeyTypeZZ() && { LDKCVec_C2Tuple_PublicKeyTypeZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ)); return res; }
10761         ~CVec_C2Tuple_PublicKeyTypeZZ() { CVec_C2Tuple_PublicKeyTypeZZ_free(self); }
10762         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; }
10763         LDKCVec_C2Tuple_PublicKeyTypeZZ* operator &() { return &self; }
10764         LDKCVec_C2Tuple_PublicKeyTypeZZ* operator ->() { return &self; }
10765         const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator &() const { return &self; }
10766         const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator ->() const { return &self; }
10767 };
10768 class CResult_RefundBolt12ParseErrorZ {
10769 private:
10770         LDKCResult_RefundBolt12ParseErrorZ self;
10771 public:
10772         CResult_RefundBolt12ParseErrorZ(const CResult_RefundBolt12ParseErrorZ&) = delete;
10773         CResult_RefundBolt12ParseErrorZ(CResult_RefundBolt12ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RefundBolt12ParseErrorZ)); }
10774         CResult_RefundBolt12ParseErrorZ(LDKCResult_RefundBolt12ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RefundBolt12ParseErrorZ)); }
10775         operator LDKCResult_RefundBolt12ParseErrorZ() && { LDKCResult_RefundBolt12ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RefundBolt12ParseErrorZ)); return res; }
10776         ~CResult_RefundBolt12ParseErrorZ() { CResult_RefundBolt12ParseErrorZ_free(self); }
10777         CResult_RefundBolt12ParseErrorZ& operator=(CResult_RefundBolt12ParseErrorZ&& o) { CResult_RefundBolt12ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RefundBolt12ParseErrorZ)); return *this; }
10778         LDKCResult_RefundBolt12ParseErrorZ* operator &() { return &self; }
10779         LDKCResult_RefundBolt12ParseErrorZ* operator ->() { return &self; }
10780         const LDKCResult_RefundBolt12ParseErrorZ* operator &() const { return &self; }
10781         const LDKCResult_RefundBolt12ParseErrorZ* operator ->() const { return &self; }
10782 };
10783 class C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ {
10784 private:
10785         LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ self;
10786 public:
10787         C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(const C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&) = delete;
10788         C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); }
10789         C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); }
10790         operator LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ() && { LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); return res; }
10791         ~C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ() { C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(self); }
10792         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; }
10793         LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator &() { return &self; }
10794         LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator ->() { return &self; }
10795         const LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator &() const { return &self; }
10796         const LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator ->() const { return &self; }
10797 };
10798 class CVec_C2Tuple_u64CVec_u8ZZZ {
10799 private:
10800         LDKCVec_C2Tuple_u64CVec_u8ZZZ self;
10801 public:
10802         CVec_C2Tuple_u64CVec_u8ZZZ(const CVec_C2Tuple_u64CVec_u8ZZZ&) = delete;
10803         CVec_C2Tuple_u64CVec_u8ZZZ(CVec_C2Tuple_u64CVec_u8ZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u64CVec_u8ZZZ)); }
10804         CVec_C2Tuple_u64CVec_u8ZZZ(LDKCVec_C2Tuple_u64CVec_u8ZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u64CVec_u8ZZZ)); }
10805         operator LDKCVec_C2Tuple_u64CVec_u8ZZZ() && { LDKCVec_C2Tuple_u64CVec_u8ZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u64CVec_u8ZZZ)); return res; }
10806         ~CVec_C2Tuple_u64CVec_u8ZZZ() { CVec_C2Tuple_u64CVec_u8ZZZ_free(self); }
10807         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; }
10808         LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator &() { return &self; }
10809         LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator ->() { return &self; }
10810         const LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator &() const { return &self; }
10811         const LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator ->() const { return &self; }
10812 };
10813 class CResult_u32GraphSyncErrorZ {
10814 private:
10815         LDKCResult_u32GraphSyncErrorZ self;
10816 public:
10817         CResult_u32GraphSyncErrorZ(const CResult_u32GraphSyncErrorZ&) = delete;
10818         CResult_u32GraphSyncErrorZ(CResult_u32GraphSyncErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); }
10819         CResult_u32GraphSyncErrorZ(LDKCResult_u32GraphSyncErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); }
10820         operator LDKCResult_u32GraphSyncErrorZ() && { LDKCResult_u32GraphSyncErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); return res; }
10821         ~CResult_u32GraphSyncErrorZ() { CResult_u32GraphSyncErrorZ_free(self); }
10822         CResult_u32GraphSyncErrorZ& operator=(CResult_u32GraphSyncErrorZ&& o) { CResult_u32GraphSyncErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); return *this; }
10823         LDKCResult_u32GraphSyncErrorZ* operator &() { return &self; }
10824         LDKCResult_u32GraphSyncErrorZ* operator ->() { return &self; }
10825         const LDKCResult_u32GraphSyncErrorZ* operator &() const { return &self; }
10826         const LDKCResult_u32GraphSyncErrorZ* operator ->() const { return &self; }
10827 };
10828 class CVec_PhantomRouteHintsZ {
10829 private:
10830         LDKCVec_PhantomRouteHintsZ self;
10831 public:
10832         CVec_PhantomRouteHintsZ(const CVec_PhantomRouteHintsZ&) = delete;
10833         CVec_PhantomRouteHintsZ(CVec_PhantomRouteHintsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); }
10834         CVec_PhantomRouteHintsZ(LDKCVec_PhantomRouteHintsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); }
10835         operator LDKCVec_PhantomRouteHintsZ() && { LDKCVec_PhantomRouteHintsZ res = self; memset(&self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); return res; }
10836         ~CVec_PhantomRouteHintsZ() { CVec_PhantomRouteHintsZ_free(self); }
10837         CVec_PhantomRouteHintsZ& operator=(CVec_PhantomRouteHintsZ&& o) { CVec_PhantomRouteHintsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); return *this; }
10838         LDKCVec_PhantomRouteHintsZ* operator &() { return &self; }
10839         LDKCVec_PhantomRouteHintsZ* operator ->() { return &self; }
10840         const LDKCVec_PhantomRouteHintsZ* operator &() const { return &self; }
10841         const LDKCVec_PhantomRouteHintsZ* operator ->() const { return &self; }
10842 };
10843 class CResult_NoneAPIErrorZ {
10844 private:
10845         LDKCResult_NoneAPIErrorZ self;
10846 public:
10847         CResult_NoneAPIErrorZ(const CResult_NoneAPIErrorZ&) = delete;
10848         CResult_NoneAPIErrorZ(CResult_NoneAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); }
10849         CResult_NoneAPIErrorZ(LDKCResult_NoneAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); }
10850         operator LDKCResult_NoneAPIErrorZ() && { LDKCResult_NoneAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); return res; }
10851         ~CResult_NoneAPIErrorZ() { CResult_NoneAPIErrorZ_free(self); }
10852         CResult_NoneAPIErrorZ& operator=(CResult_NoneAPIErrorZ&& o) { CResult_NoneAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); return *this; }
10853         LDKCResult_NoneAPIErrorZ* operator &() { return &self; }
10854         LDKCResult_NoneAPIErrorZ* operator ->() { return &self; }
10855         const LDKCResult_NoneAPIErrorZ* operator &() const { return &self; }
10856         const LDKCResult_NoneAPIErrorZ* operator ->() const { return &self; }
10857 };
10858 class CResult_Bolt12InvoiceFeaturesDecodeErrorZ {
10859 private:
10860         LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ self;
10861 public:
10862         CResult_Bolt12InvoiceFeaturesDecodeErrorZ(const CResult_Bolt12InvoiceFeaturesDecodeErrorZ&) = delete;
10863         CResult_Bolt12InvoiceFeaturesDecodeErrorZ(CResult_Bolt12InvoiceFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt12InvoiceFeaturesDecodeErrorZ)); }
10864         CResult_Bolt12InvoiceFeaturesDecodeErrorZ(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ)); }
10865         operator LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ() && { LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ)); return res; }
10866         ~CResult_Bolt12InvoiceFeaturesDecodeErrorZ() { CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(self); }
10867         CResult_Bolt12InvoiceFeaturesDecodeErrorZ& operator=(CResult_Bolt12InvoiceFeaturesDecodeErrorZ&& o) { CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt12InvoiceFeaturesDecodeErrorZ)); return *this; }
10868         LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator &() { return &self; }
10869         LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator ->() { return &self; }
10870         const LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
10871         const LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
10872 };
10873 class COption_f64Z {
10874 private:
10875         LDKCOption_f64Z self;
10876 public:
10877         COption_f64Z(const COption_f64Z&) = delete;
10878         COption_f64Z(COption_f64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_f64Z)); }
10879         COption_f64Z(LDKCOption_f64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_f64Z)); }
10880         operator LDKCOption_f64Z() && { LDKCOption_f64Z res = self; memset(&self, 0, sizeof(LDKCOption_f64Z)); return res; }
10881         ~COption_f64Z() { COption_f64Z_free(self); }
10882         COption_f64Z& operator=(COption_f64Z&& o) { COption_f64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_f64Z)); return *this; }
10883         LDKCOption_f64Z* operator &() { return &self; }
10884         LDKCOption_f64Z* operator ->() { return &self; }
10885         const LDKCOption_f64Z* operator &() const { return &self; }
10886         const LDKCOption_f64Z* operator ->() const { return &self; }
10887 };
10888 class CResult_ChannelDetailsDecodeErrorZ {
10889 private:
10890         LDKCResult_ChannelDetailsDecodeErrorZ self;
10891 public:
10892         CResult_ChannelDetailsDecodeErrorZ(const CResult_ChannelDetailsDecodeErrorZ&) = delete;
10893         CResult_ChannelDetailsDecodeErrorZ(CResult_ChannelDetailsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelDetailsDecodeErrorZ)); }
10894         CResult_ChannelDetailsDecodeErrorZ(LDKCResult_ChannelDetailsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelDetailsDecodeErrorZ)); }
10895         operator LDKCResult_ChannelDetailsDecodeErrorZ() && { LDKCResult_ChannelDetailsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelDetailsDecodeErrorZ)); return res; }
10896         ~CResult_ChannelDetailsDecodeErrorZ() { CResult_ChannelDetailsDecodeErrorZ_free(self); }
10897         CResult_ChannelDetailsDecodeErrorZ& operator=(CResult_ChannelDetailsDecodeErrorZ&& o) { CResult_ChannelDetailsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelDetailsDecodeErrorZ)); return *this; }
10898         LDKCResult_ChannelDetailsDecodeErrorZ* operator &() { return &self; }
10899         LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() { return &self; }
10900         const LDKCResult_ChannelDetailsDecodeErrorZ* operator &() const { return &self; }
10901         const LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() const { return &self; }
10902 };
10903 class CVec_PublicKeyZ {
10904 private:
10905         LDKCVec_PublicKeyZ self;
10906 public:
10907         CVec_PublicKeyZ(const CVec_PublicKeyZ&) = delete;
10908         CVec_PublicKeyZ(CVec_PublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PublicKeyZ)); }
10909         CVec_PublicKeyZ(LDKCVec_PublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PublicKeyZ)); }
10910         operator LDKCVec_PublicKeyZ() && { LDKCVec_PublicKeyZ res = self; memset(&self, 0, sizeof(LDKCVec_PublicKeyZ)); return res; }
10911         ~CVec_PublicKeyZ() { CVec_PublicKeyZ_free(self); }
10912         CVec_PublicKeyZ& operator=(CVec_PublicKeyZ&& o) { CVec_PublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PublicKeyZ)); return *this; }
10913         LDKCVec_PublicKeyZ* operator &() { return &self; }
10914         LDKCVec_PublicKeyZ* operator ->() { return &self; }
10915         const LDKCVec_PublicKeyZ* operator &() const { return &self; }
10916         const LDKCVec_PublicKeyZ* operator ->() const { return &self; }
10917 };
10918 class C2Tuple_CVec_u8Zu64Z {
10919 private:
10920         LDKC2Tuple_CVec_u8Zu64Z self;
10921 public:
10922         C2Tuple_CVec_u8Zu64Z(const C2Tuple_CVec_u8Zu64Z&) = delete;
10923         C2Tuple_CVec_u8Zu64Z(C2Tuple_CVec_u8Zu64Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_CVec_u8Zu64Z)); }
10924         C2Tuple_CVec_u8Zu64Z(LDKC2Tuple_CVec_u8Zu64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_CVec_u8Zu64Z)); }
10925         operator LDKC2Tuple_CVec_u8Zu64Z() && { LDKC2Tuple_CVec_u8Zu64Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_CVec_u8Zu64Z)); return res; }
10926         ~C2Tuple_CVec_u8Zu64Z() { C2Tuple_CVec_u8Zu64Z_free(self); }
10927         C2Tuple_CVec_u8Zu64Z& operator=(C2Tuple_CVec_u8Zu64Z&& o) { C2Tuple_CVec_u8Zu64Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_CVec_u8Zu64Z)); return *this; }
10928         LDKC2Tuple_CVec_u8Zu64Z* operator &() { return &self; }
10929         LDKC2Tuple_CVec_u8Zu64Z* operator ->() { return &self; }
10930         const LDKC2Tuple_CVec_u8Zu64Z* operator &() const { return &self; }
10931         const LDKC2Tuple_CVec_u8Zu64Z* operator ->() const { return &self; }
10932 };
10933 class CVec_C2Tuple_usizeTransactionZZ {
10934 private:
10935         LDKCVec_C2Tuple_usizeTransactionZZ self;
10936 public:
10937         CVec_C2Tuple_usizeTransactionZZ(const CVec_C2Tuple_usizeTransactionZZ&) = delete;
10938         CVec_C2Tuple_usizeTransactionZZ(CVec_C2Tuple_usizeTransactionZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_usizeTransactionZZ)); }
10939         CVec_C2Tuple_usizeTransactionZZ(LDKCVec_C2Tuple_usizeTransactionZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_usizeTransactionZZ)); }
10940         operator LDKCVec_C2Tuple_usizeTransactionZZ() && { LDKCVec_C2Tuple_usizeTransactionZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_usizeTransactionZZ)); return res; }
10941         ~CVec_C2Tuple_usizeTransactionZZ() { CVec_C2Tuple_usizeTransactionZZ_free(self); }
10942         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; }
10943         LDKCVec_C2Tuple_usizeTransactionZZ* operator &() { return &self; }
10944         LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() { return &self; }
10945         const LDKCVec_C2Tuple_usizeTransactionZZ* operator &() const { return &self; }
10946         const LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() const { return &self; }
10947 };
10948 class CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ {
10949 private:
10950         LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ self;
10951 public:
10952         CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(const CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&) = delete;
10953         CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); }
10954         CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); }
10955         operator LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); return res; }
10956         ~CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ() { CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(self); }
10957         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; }
10958         LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator &() { return &self; }
10959         LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator ->() { return &self; }
10960         const LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator &() const { return &self; }
10961         const LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator ->() const { return &self; }
10962 };
10963 class CResult_PendingHTLCRoutingDecodeErrorZ {
10964 private:
10965         LDKCResult_PendingHTLCRoutingDecodeErrorZ self;
10966 public:
10967         CResult_PendingHTLCRoutingDecodeErrorZ(const CResult_PendingHTLCRoutingDecodeErrorZ&) = delete;
10968         CResult_PendingHTLCRoutingDecodeErrorZ(CResult_PendingHTLCRoutingDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PendingHTLCRoutingDecodeErrorZ)); }
10969         CResult_PendingHTLCRoutingDecodeErrorZ(LDKCResult_PendingHTLCRoutingDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PendingHTLCRoutingDecodeErrorZ)); }
10970         operator LDKCResult_PendingHTLCRoutingDecodeErrorZ() && { LDKCResult_PendingHTLCRoutingDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PendingHTLCRoutingDecodeErrorZ)); return res; }
10971         ~CResult_PendingHTLCRoutingDecodeErrorZ() { CResult_PendingHTLCRoutingDecodeErrorZ_free(self); }
10972         CResult_PendingHTLCRoutingDecodeErrorZ& operator=(CResult_PendingHTLCRoutingDecodeErrorZ&& o) { CResult_PendingHTLCRoutingDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PendingHTLCRoutingDecodeErrorZ)); return *this; }
10973         LDKCResult_PendingHTLCRoutingDecodeErrorZ* operator &() { return &self; }
10974         LDKCResult_PendingHTLCRoutingDecodeErrorZ* operator ->() { return &self; }
10975         const LDKCResult_PendingHTLCRoutingDecodeErrorZ* operator &() const { return &self; }
10976         const LDKCResult_PendingHTLCRoutingDecodeErrorZ* operator ->() const { return &self; }
10977 };
10978 class C2Tuple_u64u64Z {
10979 private:
10980         LDKC2Tuple_u64u64Z self;
10981 public:
10982         C2Tuple_u64u64Z(const C2Tuple_u64u64Z&) = delete;
10983         C2Tuple_u64u64Z(C2Tuple_u64u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64u64Z)); }
10984         C2Tuple_u64u64Z(LDKC2Tuple_u64u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64u64Z)); }
10985         operator LDKC2Tuple_u64u64Z() && { LDKC2Tuple_u64u64Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64u64Z)); return res; }
10986         ~C2Tuple_u64u64Z() { C2Tuple_u64u64Z_free(self); }
10987         C2Tuple_u64u64Z& operator=(C2Tuple_u64u64Z&& o) { C2Tuple_u64u64Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u64u64Z)); return *this; }
10988         LDKC2Tuple_u64u64Z* operator &() { return &self; }
10989         LDKC2Tuple_u64u64Z* operator ->() { return &self; }
10990         const LDKC2Tuple_u64u64Z* operator &() const { return &self; }
10991         const LDKC2Tuple_u64u64Z* operator ->() const { return &self; }
10992 };
10993 class CResult_TxRemoveInputDecodeErrorZ {
10994 private:
10995         LDKCResult_TxRemoveInputDecodeErrorZ self;
10996 public:
10997         CResult_TxRemoveInputDecodeErrorZ(const CResult_TxRemoveInputDecodeErrorZ&) = delete;
10998         CResult_TxRemoveInputDecodeErrorZ(CResult_TxRemoveInputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxRemoveInputDecodeErrorZ)); }
10999         CResult_TxRemoveInputDecodeErrorZ(LDKCResult_TxRemoveInputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxRemoveInputDecodeErrorZ)); }
11000         operator LDKCResult_TxRemoveInputDecodeErrorZ() && { LDKCResult_TxRemoveInputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxRemoveInputDecodeErrorZ)); return res; }
11001         ~CResult_TxRemoveInputDecodeErrorZ() { CResult_TxRemoveInputDecodeErrorZ_free(self); }
11002         CResult_TxRemoveInputDecodeErrorZ& operator=(CResult_TxRemoveInputDecodeErrorZ&& o) { CResult_TxRemoveInputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxRemoveInputDecodeErrorZ)); return *this; }
11003         LDKCResult_TxRemoveInputDecodeErrorZ* operator &() { return &self; }
11004         LDKCResult_TxRemoveInputDecodeErrorZ* operator ->() { return &self; }
11005         const LDKCResult_TxRemoveInputDecodeErrorZ* operator &() const { return &self; }
11006         const LDKCResult_TxRemoveInputDecodeErrorZ* operator ->() const { return &self; }
11007 };
11008 class CResult_OffersMessageDecodeErrorZ {
11009 private:
11010         LDKCResult_OffersMessageDecodeErrorZ self;
11011 public:
11012         CResult_OffersMessageDecodeErrorZ(const CResult_OffersMessageDecodeErrorZ&) = delete;
11013         CResult_OffersMessageDecodeErrorZ(CResult_OffersMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OffersMessageDecodeErrorZ)); }
11014         CResult_OffersMessageDecodeErrorZ(LDKCResult_OffersMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OffersMessageDecodeErrorZ)); }
11015         operator LDKCResult_OffersMessageDecodeErrorZ() && { LDKCResult_OffersMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OffersMessageDecodeErrorZ)); return res; }
11016         ~CResult_OffersMessageDecodeErrorZ() { CResult_OffersMessageDecodeErrorZ_free(self); }
11017         CResult_OffersMessageDecodeErrorZ& operator=(CResult_OffersMessageDecodeErrorZ&& o) { CResult_OffersMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OffersMessageDecodeErrorZ)); return *this; }
11018         LDKCResult_OffersMessageDecodeErrorZ* operator &() { return &self; }
11019         LDKCResult_OffersMessageDecodeErrorZ* operator ->() { return &self; }
11020         const LDKCResult_OffersMessageDecodeErrorZ* operator &() const { return &self; }
11021         const LDKCResult_OffersMessageDecodeErrorZ* operator ->() const { return &self; }
11022 };
11023 class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
11024 private:
11025         LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ self;
11026 public:
11027         CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(const CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&) = delete;
11028         CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
11029         CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
11030         operator LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ() && { LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return res; }
11031         ~CResult_CounterpartyChannelTransactionParametersDecodeErrorZ() { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); }
11032         CResult_CounterpartyChannelTransactionParametersDecodeErrorZ& operator=(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return *this; }
11033         LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
11034         LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
11035         const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
11036         const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
11037 };
11038 class CResult_RecipientOnionFieldsDecodeErrorZ {
11039 private:
11040         LDKCResult_RecipientOnionFieldsDecodeErrorZ self;
11041 public:
11042         CResult_RecipientOnionFieldsDecodeErrorZ(const CResult_RecipientOnionFieldsDecodeErrorZ&) = delete;
11043         CResult_RecipientOnionFieldsDecodeErrorZ(CResult_RecipientOnionFieldsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecipientOnionFieldsDecodeErrorZ)); }
11044         CResult_RecipientOnionFieldsDecodeErrorZ(LDKCResult_RecipientOnionFieldsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ)); }
11045         operator LDKCResult_RecipientOnionFieldsDecodeErrorZ() && { LDKCResult_RecipientOnionFieldsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ)); return res; }
11046         ~CResult_RecipientOnionFieldsDecodeErrorZ() { CResult_RecipientOnionFieldsDecodeErrorZ_free(self); }
11047         CResult_RecipientOnionFieldsDecodeErrorZ& operator=(CResult_RecipientOnionFieldsDecodeErrorZ&& o) { CResult_RecipientOnionFieldsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecipientOnionFieldsDecodeErrorZ)); return *this; }
11048         LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator &() { return &self; }
11049         LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator ->() { return &self; }
11050         const LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator &() const { return &self; }
11051         const LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator ->() const { return &self; }
11052 };
11053 class C2Tuple_u32TxOutZ {
11054 private:
11055         LDKC2Tuple_u32TxOutZ self;
11056 public:
11057         C2Tuple_u32TxOutZ(const C2Tuple_u32TxOutZ&) = delete;
11058         C2Tuple_u32TxOutZ(C2Tuple_u32TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u32TxOutZ)); }
11059         C2Tuple_u32TxOutZ(LDKC2Tuple_u32TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u32TxOutZ)); }
11060         operator LDKC2Tuple_u32TxOutZ() && { LDKC2Tuple_u32TxOutZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u32TxOutZ)); return res; }
11061         ~C2Tuple_u32TxOutZ() { C2Tuple_u32TxOutZ_free(self); }
11062         C2Tuple_u32TxOutZ& operator=(C2Tuple_u32TxOutZ&& o) { C2Tuple_u32TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u32TxOutZ)); return *this; }
11063         LDKC2Tuple_u32TxOutZ* operator &() { return &self; }
11064         LDKC2Tuple_u32TxOutZ* operator ->() { return &self; }
11065         const LDKC2Tuple_u32TxOutZ* operator &() const { return &self; }
11066         const LDKC2Tuple_u32TxOutZ* operator ->() const { return &self; }
11067 };
11068 class CVec_UtxoZ {
11069 private:
11070         LDKCVec_UtxoZ self;
11071 public:
11072         CVec_UtxoZ(const CVec_UtxoZ&) = delete;
11073         CVec_UtxoZ(CVec_UtxoZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UtxoZ)); }
11074         CVec_UtxoZ(LDKCVec_UtxoZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UtxoZ)); }
11075         operator LDKCVec_UtxoZ() && { LDKCVec_UtxoZ res = self; memset(&self, 0, sizeof(LDKCVec_UtxoZ)); return res; }
11076         ~CVec_UtxoZ() { CVec_UtxoZ_free(self); }
11077         CVec_UtxoZ& operator=(CVec_UtxoZ&& o) { CVec_UtxoZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UtxoZ)); return *this; }
11078         LDKCVec_UtxoZ* operator &() { return &self; }
11079         LDKCVec_UtxoZ* operator ->() { return &self; }
11080         const LDKCVec_UtxoZ* operator &() const { return &self; }
11081         const LDKCVec_UtxoZ* operator ->() const { return &self; }
11082 };
11083 class CResult_ChannelConfigDecodeErrorZ {
11084 private:
11085         LDKCResult_ChannelConfigDecodeErrorZ self;
11086 public:
11087         CResult_ChannelConfigDecodeErrorZ(const CResult_ChannelConfigDecodeErrorZ&) = delete;
11088         CResult_ChannelConfigDecodeErrorZ(CResult_ChannelConfigDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelConfigDecodeErrorZ)); }
11089         CResult_ChannelConfigDecodeErrorZ(LDKCResult_ChannelConfigDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelConfigDecodeErrorZ)); }
11090         operator LDKCResult_ChannelConfigDecodeErrorZ() && { LDKCResult_ChannelConfigDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelConfigDecodeErrorZ)); return res; }
11091         ~CResult_ChannelConfigDecodeErrorZ() { CResult_ChannelConfigDecodeErrorZ_free(self); }
11092         CResult_ChannelConfigDecodeErrorZ& operator=(CResult_ChannelConfigDecodeErrorZ&& o) { CResult_ChannelConfigDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelConfigDecodeErrorZ)); return *this; }
11093         LDKCResult_ChannelConfigDecodeErrorZ* operator &() { return &self; }
11094         LDKCResult_ChannelConfigDecodeErrorZ* operator ->() { return &self; }
11095         const LDKCResult_ChannelConfigDecodeErrorZ* operator &() const { return &self; }
11096         const LDKCResult_ChannelConfigDecodeErrorZ* operator ->() const { return &self; }
11097 };
11098 class CVec_PrivateRouteZ {
11099 private:
11100         LDKCVec_PrivateRouteZ self;
11101 public:
11102         CVec_PrivateRouteZ(const CVec_PrivateRouteZ&) = delete;
11103         CVec_PrivateRouteZ(CVec_PrivateRouteZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PrivateRouteZ)); }
11104         CVec_PrivateRouteZ(LDKCVec_PrivateRouteZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PrivateRouteZ)); }
11105         operator LDKCVec_PrivateRouteZ() && { LDKCVec_PrivateRouteZ res = self; memset(&self, 0, sizeof(LDKCVec_PrivateRouteZ)); return res; }
11106         ~CVec_PrivateRouteZ() { CVec_PrivateRouteZ_free(self); }
11107         CVec_PrivateRouteZ& operator=(CVec_PrivateRouteZ&& o) { CVec_PrivateRouteZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PrivateRouteZ)); return *this; }
11108         LDKCVec_PrivateRouteZ* operator &() { return &self; }
11109         LDKCVec_PrivateRouteZ* operator ->() { return &self; }
11110         const LDKCVec_PrivateRouteZ* operator &() const { return &self; }
11111         const LDKCVec_PrivateRouteZ* operator ->() const { return &self; }
11112 };
11113 class COption_i64Z {
11114 private:
11115         LDKCOption_i64Z self;
11116 public:
11117         COption_i64Z(const COption_i64Z&) = delete;
11118         COption_i64Z(COption_i64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_i64Z)); }
11119         COption_i64Z(LDKCOption_i64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_i64Z)); }
11120         operator LDKCOption_i64Z() && { LDKCOption_i64Z res = self; memset(&self, 0, sizeof(LDKCOption_i64Z)); return res; }
11121         ~COption_i64Z() { COption_i64Z_free(self); }
11122         COption_i64Z& operator=(COption_i64Z&& o) { COption_i64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_i64Z)); return *this; }
11123         LDKCOption_i64Z* operator &() { return &self; }
11124         LDKCOption_i64Z* operator ->() { return &self; }
11125         const LDKCOption_i64Z* operator &() const { return &self; }
11126         const LDKCOption_i64Z* operator ->() const { return &self; }
11127 };
11128 class C2Tuple_ThirtyTwoBytesChannelManagerZ {
11129 private:
11130         LDKC2Tuple_ThirtyTwoBytesChannelManagerZ self;
11131 public:
11132         C2Tuple_ThirtyTwoBytesChannelManagerZ(const C2Tuple_ThirtyTwoBytesChannelManagerZ&) = delete;
11133         C2Tuple_ThirtyTwoBytesChannelManagerZ(C2Tuple_ThirtyTwoBytesChannelManagerZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelManagerZ)); }
11134         C2Tuple_ThirtyTwoBytesChannelManagerZ(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ)); }
11135         operator LDKC2Tuple_ThirtyTwoBytesChannelManagerZ() && { LDKC2Tuple_ThirtyTwoBytesChannelManagerZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ)); return res; }
11136         ~C2Tuple_ThirtyTwoBytesChannelManagerZ() { C2Tuple_ThirtyTwoBytesChannelManagerZ_free(self); }
11137         C2Tuple_ThirtyTwoBytesChannelManagerZ& operator=(C2Tuple_ThirtyTwoBytesChannelManagerZ&& o) { C2Tuple_ThirtyTwoBytesChannelManagerZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelManagerZ)); return *this; }
11138         LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator &() { return &self; }
11139         LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator ->() { return &self; }
11140         const LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator &() const { return &self; }
11141         const LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator ->() const { return &self; }
11142 };
11143 class CResult_COption_OnionMessageContentsZDecodeErrorZ {
11144 private:
11145         LDKCResult_COption_OnionMessageContentsZDecodeErrorZ self;
11146 public:
11147         CResult_COption_OnionMessageContentsZDecodeErrorZ(const CResult_COption_OnionMessageContentsZDecodeErrorZ&) = delete;
11148         CResult_COption_OnionMessageContentsZDecodeErrorZ(CResult_COption_OnionMessageContentsZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_OnionMessageContentsZDecodeErrorZ)); }
11149         CResult_COption_OnionMessageContentsZDecodeErrorZ(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ)); }
11150         operator LDKCResult_COption_OnionMessageContentsZDecodeErrorZ() && { LDKCResult_COption_OnionMessageContentsZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ)); return res; }
11151         ~CResult_COption_OnionMessageContentsZDecodeErrorZ() { CResult_COption_OnionMessageContentsZDecodeErrorZ_free(self); }
11152         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; }
11153         LDKCResult_COption_OnionMessageContentsZDecodeErrorZ* operator &() { return &self; }
11154         LDKCResult_COption_OnionMessageContentsZDecodeErrorZ* operator ->() { return &self; }
11155         const LDKCResult_COption_OnionMessageContentsZDecodeErrorZ* operator &() const { return &self; }
11156         const LDKCResult_COption_OnionMessageContentsZDecodeErrorZ* operator ->() const { return &self; }
11157 };
11158 class C2Tuple_u64CVec_u8ZZ {
11159 private:
11160         LDKC2Tuple_u64CVec_u8ZZ self;
11161 public:
11162         C2Tuple_u64CVec_u8ZZ(const C2Tuple_u64CVec_u8ZZ&) = delete;
11163         C2Tuple_u64CVec_u8ZZ(C2Tuple_u64CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64CVec_u8ZZ)); }
11164         C2Tuple_u64CVec_u8ZZ(LDKC2Tuple_u64CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64CVec_u8ZZ)); }
11165         operator LDKC2Tuple_u64CVec_u8ZZ() && { LDKC2Tuple_u64CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64CVec_u8ZZ)); return res; }
11166         ~C2Tuple_u64CVec_u8ZZ() { C2Tuple_u64CVec_u8ZZ_free(self); }
11167         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; }
11168         LDKC2Tuple_u64CVec_u8ZZ* operator &() { return &self; }
11169         LDKC2Tuple_u64CVec_u8ZZ* operator ->() { return &self; }
11170         const LDKC2Tuple_u64CVec_u8ZZ* operator &() const { return &self; }
11171         const LDKC2Tuple_u64CVec_u8ZZ* operator ->() const { return &self; }
11172 };
11173 class CResult_OfferBolt12ParseErrorZ {
11174 private:
11175         LDKCResult_OfferBolt12ParseErrorZ self;
11176 public:
11177         CResult_OfferBolt12ParseErrorZ(const CResult_OfferBolt12ParseErrorZ&) = delete;
11178         CResult_OfferBolt12ParseErrorZ(CResult_OfferBolt12ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OfferBolt12ParseErrorZ)); }
11179         CResult_OfferBolt12ParseErrorZ(LDKCResult_OfferBolt12ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OfferBolt12ParseErrorZ)); }
11180         operator LDKCResult_OfferBolt12ParseErrorZ() && { LDKCResult_OfferBolt12ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OfferBolt12ParseErrorZ)); return res; }
11181         ~CResult_OfferBolt12ParseErrorZ() { CResult_OfferBolt12ParseErrorZ_free(self); }
11182         CResult_OfferBolt12ParseErrorZ& operator=(CResult_OfferBolt12ParseErrorZ&& o) { CResult_OfferBolt12ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OfferBolt12ParseErrorZ)); return *this; }
11183         LDKCResult_OfferBolt12ParseErrorZ* operator &() { return &self; }
11184         LDKCResult_OfferBolt12ParseErrorZ* operator ->() { return &self; }
11185         const LDKCResult_OfferBolt12ParseErrorZ* operator &() const { return &self; }
11186         const LDKCResult_OfferBolt12ParseErrorZ* operator ->() const { return &self; }
11187 };
11188 class CResult_ThirtyTwoBytesRetryableSendFailureZ {
11189 private:
11190         LDKCResult_ThirtyTwoBytesRetryableSendFailureZ self;
11191 public:
11192         CResult_ThirtyTwoBytesRetryableSendFailureZ(const CResult_ThirtyTwoBytesRetryableSendFailureZ&) = delete;
11193         CResult_ThirtyTwoBytesRetryableSendFailureZ(CResult_ThirtyTwoBytesRetryableSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesRetryableSendFailureZ)); }
11194         CResult_ThirtyTwoBytesRetryableSendFailureZ(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ)); }
11195         operator LDKCResult_ThirtyTwoBytesRetryableSendFailureZ() && { LDKCResult_ThirtyTwoBytesRetryableSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ)); return res; }
11196         ~CResult_ThirtyTwoBytesRetryableSendFailureZ() { CResult_ThirtyTwoBytesRetryableSendFailureZ_free(self); }
11197         CResult_ThirtyTwoBytesRetryableSendFailureZ& operator=(CResult_ThirtyTwoBytesRetryableSendFailureZ&& o) { CResult_ThirtyTwoBytesRetryableSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesRetryableSendFailureZ)); return *this; }
11198         LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator &() { return &self; }
11199         LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator ->() { return &self; }
11200         const LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator &() const { return &self; }
11201         const LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator ->() const { return &self; }
11202 };
11203 class CVec_MonitorEventZ {
11204 private:
11205         LDKCVec_MonitorEventZ self;
11206 public:
11207         CVec_MonitorEventZ(const CVec_MonitorEventZ&) = delete;
11208         CVec_MonitorEventZ(CVec_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorEventZ)); }
11209         CVec_MonitorEventZ(LDKCVec_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorEventZ)); }
11210         operator LDKCVec_MonitorEventZ() && { LDKCVec_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorEventZ)); return res; }
11211         ~CVec_MonitorEventZ() { CVec_MonitorEventZ_free(self); }
11212         CVec_MonitorEventZ& operator=(CVec_MonitorEventZ&& o) { CVec_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MonitorEventZ)); return *this; }
11213         LDKCVec_MonitorEventZ* operator &() { return &self; }
11214         LDKCVec_MonitorEventZ* operator ->() { return &self; }
11215         const LDKCVec_MonitorEventZ* operator &() const { return &self; }
11216         const LDKCVec_MonitorEventZ* operator ->() const { return &self; }
11217 };
11218 class CResult_ShutdownDecodeErrorZ {
11219 private:
11220         LDKCResult_ShutdownDecodeErrorZ self;
11221 public:
11222         CResult_ShutdownDecodeErrorZ(const CResult_ShutdownDecodeErrorZ&) = delete;
11223         CResult_ShutdownDecodeErrorZ(CResult_ShutdownDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownDecodeErrorZ)); }
11224         CResult_ShutdownDecodeErrorZ(LDKCResult_ShutdownDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownDecodeErrorZ)); }
11225         operator LDKCResult_ShutdownDecodeErrorZ() && { LDKCResult_ShutdownDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownDecodeErrorZ)); return res; }
11226         ~CResult_ShutdownDecodeErrorZ() { CResult_ShutdownDecodeErrorZ_free(self); }
11227         CResult_ShutdownDecodeErrorZ& operator=(CResult_ShutdownDecodeErrorZ&& o) { CResult_ShutdownDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownDecodeErrorZ)); return *this; }
11228         LDKCResult_ShutdownDecodeErrorZ* operator &() { return &self; }
11229         LDKCResult_ShutdownDecodeErrorZ* operator ->() { return &self; }
11230         const LDKCResult_ShutdownDecodeErrorZ* operator &() const { return &self; }
11231         const LDKCResult_ShutdownDecodeErrorZ* operator ->() const { return &self; }
11232 };
11233 class CResult_BigSizeDecodeErrorZ {
11234 private:
11235         LDKCResult_BigSizeDecodeErrorZ self;
11236 public:
11237         CResult_BigSizeDecodeErrorZ(const CResult_BigSizeDecodeErrorZ&) = delete;
11238         CResult_BigSizeDecodeErrorZ(CResult_BigSizeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BigSizeDecodeErrorZ)); }
11239         CResult_BigSizeDecodeErrorZ(LDKCResult_BigSizeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BigSizeDecodeErrorZ)); }
11240         operator LDKCResult_BigSizeDecodeErrorZ() && { LDKCResult_BigSizeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BigSizeDecodeErrorZ)); return res; }
11241         ~CResult_BigSizeDecodeErrorZ() { CResult_BigSizeDecodeErrorZ_free(self); }
11242         CResult_BigSizeDecodeErrorZ& operator=(CResult_BigSizeDecodeErrorZ&& o) { CResult_BigSizeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BigSizeDecodeErrorZ)); return *this; }
11243         LDKCResult_BigSizeDecodeErrorZ* operator &() { return &self; }
11244         LDKCResult_BigSizeDecodeErrorZ* operator ->() { return &self; }
11245         const LDKCResult_BigSizeDecodeErrorZ* operator &() const { return &self; }
11246         const LDKCResult_BigSizeDecodeErrorZ* operator ->() const { return &self; }
11247 };
11248 class CResult_TxOutUtxoLookupErrorZ {
11249 private:
11250         LDKCResult_TxOutUtxoLookupErrorZ self;
11251 public:
11252         CResult_TxOutUtxoLookupErrorZ(const CResult_TxOutUtxoLookupErrorZ&) = delete;
11253         CResult_TxOutUtxoLookupErrorZ(CResult_TxOutUtxoLookupErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxOutUtxoLookupErrorZ)); }
11254         CResult_TxOutUtxoLookupErrorZ(LDKCResult_TxOutUtxoLookupErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxOutUtxoLookupErrorZ)); }
11255         operator LDKCResult_TxOutUtxoLookupErrorZ() && { LDKCResult_TxOutUtxoLookupErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxOutUtxoLookupErrorZ)); return res; }
11256         ~CResult_TxOutUtxoLookupErrorZ() { CResult_TxOutUtxoLookupErrorZ_free(self); }
11257         CResult_TxOutUtxoLookupErrorZ& operator=(CResult_TxOutUtxoLookupErrorZ&& o) { CResult_TxOutUtxoLookupErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxOutUtxoLookupErrorZ)); return *this; }
11258         LDKCResult_TxOutUtxoLookupErrorZ* operator &() { return &self; }
11259         LDKCResult_TxOutUtxoLookupErrorZ* operator ->() { return &self; }
11260         const LDKCResult_TxOutUtxoLookupErrorZ* operator &() const { return &self; }
11261         const LDKCResult_TxOutUtxoLookupErrorZ* operator ->() const { return &self; }
11262 };
11263 class CResult_BlindedPathNoneZ {
11264 private:
11265         LDKCResult_BlindedPathNoneZ self;
11266 public:
11267         CResult_BlindedPathNoneZ(const CResult_BlindedPathNoneZ&) = delete;
11268         CResult_BlindedPathNoneZ(CResult_BlindedPathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPathNoneZ)); }
11269         CResult_BlindedPathNoneZ(LDKCResult_BlindedPathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPathNoneZ)); }
11270         operator LDKCResult_BlindedPathNoneZ() && { LDKCResult_BlindedPathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPathNoneZ)); return res; }
11271         ~CResult_BlindedPathNoneZ() { CResult_BlindedPathNoneZ_free(self); }
11272         CResult_BlindedPathNoneZ& operator=(CResult_BlindedPathNoneZ&& o) { CResult_BlindedPathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPathNoneZ)); return *this; }
11273         LDKCResult_BlindedPathNoneZ* operator &() { return &self; }
11274         LDKCResult_BlindedPathNoneZ* operator ->() { return &self; }
11275         const LDKCResult_BlindedPathNoneZ* operator &() const { return &self; }
11276         const LDKCResult_BlindedPathNoneZ* operator ->() const { return &self; }
11277 };
11278 class COption_usizeZ {
11279 private:
11280         LDKCOption_usizeZ self;
11281 public:
11282         COption_usizeZ(const COption_usizeZ&) = delete;
11283         COption_usizeZ(COption_usizeZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_usizeZ)); }
11284         COption_usizeZ(LDKCOption_usizeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_usizeZ)); }
11285         operator LDKCOption_usizeZ() && { LDKCOption_usizeZ res = self; memset(&self, 0, sizeof(LDKCOption_usizeZ)); return res; }
11286         ~COption_usizeZ() { COption_usizeZ_free(self); }
11287         COption_usizeZ& operator=(COption_usizeZ&& o) { COption_usizeZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_usizeZ)); return *this; }
11288         LDKCOption_usizeZ* operator &() { return &self; }
11289         LDKCOption_usizeZ* operator ->() { return &self; }
11290         const LDKCOption_usizeZ* operator &() const { return &self; }
11291         const LDKCOption_usizeZ* operator ->() const { return &self; }
11292 };
11293 class CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ {
11294 private:
11295         LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ self;
11296 public:
11297         CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(const CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&) = delete;
11298         CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); }
11299         CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); }
11300         operator LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ() && { LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); return res; }
11301         ~CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ() { CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(self); }
11302         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; }
11303         LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator &() { return &self; }
11304         LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator ->() { return &self; }
11305         const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator &() const { return &self; }
11306         const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator ->() const { return &self; }
11307 };
11308 class CResult_NoneNoneZ {
11309 private:
11310         LDKCResult_NoneNoneZ self;
11311 public:
11312         CResult_NoneNoneZ(const CResult_NoneNoneZ&) = delete;
11313         CResult_NoneNoneZ(CResult_NoneNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneNoneZ)); }
11314         CResult_NoneNoneZ(LDKCResult_NoneNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneNoneZ)); }
11315         operator LDKCResult_NoneNoneZ() && { LDKCResult_NoneNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneNoneZ)); return res; }
11316         ~CResult_NoneNoneZ() { CResult_NoneNoneZ_free(self); }
11317         CResult_NoneNoneZ& operator=(CResult_NoneNoneZ&& o) { CResult_NoneNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneNoneZ)); return *this; }
11318         LDKCResult_NoneNoneZ* operator &() { return &self; }
11319         LDKCResult_NoneNoneZ* operator ->() { return &self; }
11320         const LDKCResult_NoneNoneZ* operator &() const { return &self; }
11321         const LDKCResult_NoneNoneZ* operator ->() const { return &self; }
11322 };
11323 class CResult_boolPeerHandleErrorZ {
11324 private:
11325         LDKCResult_boolPeerHandleErrorZ self;
11326 public:
11327         CResult_boolPeerHandleErrorZ(const CResult_boolPeerHandleErrorZ&) = delete;
11328         CResult_boolPeerHandleErrorZ(CResult_boolPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); }
11329         CResult_boolPeerHandleErrorZ(LDKCResult_boolPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); }
11330         operator LDKCResult_boolPeerHandleErrorZ() && { LDKCResult_boolPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); return res; }
11331         ~CResult_boolPeerHandleErrorZ() { CResult_boolPeerHandleErrorZ_free(self); }
11332         CResult_boolPeerHandleErrorZ& operator=(CResult_boolPeerHandleErrorZ&& o) { CResult_boolPeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); return *this; }
11333         LDKCResult_boolPeerHandleErrorZ* operator &() { return &self; }
11334         LDKCResult_boolPeerHandleErrorZ* operator ->() { return &self; }
11335         const LDKCResult_boolPeerHandleErrorZ* operator &() const { return &self; }
11336         const LDKCResult_boolPeerHandleErrorZ* operator ->() const { return &self; }
11337 };
11338 class CResult_ChannelUpdateDecodeErrorZ {
11339 private:
11340         LDKCResult_ChannelUpdateDecodeErrorZ self;
11341 public:
11342         CResult_ChannelUpdateDecodeErrorZ(const CResult_ChannelUpdateDecodeErrorZ&) = delete;
11343         CResult_ChannelUpdateDecodeErrorZ(CResult_ChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); }
11344         CResult_ChannelUpdateDecodeErrorZ(LDKCResult_ChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); }
11345         operator LDKCResult_ChannelUpdateDecodeErrorZ() && { LDKCResult_ChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); return res; }
11346         ~CResult_ChannelUpdateDecodeErrorZ() { CResult_ChannelUpdateDecodeErrorZ_free(self); }
11347         CResult_ChannelUpdateDecodeErrorZ& operator=(CResult_ChannelUpdateDecodeErrorZ&& o) { CResult_ChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); return *this; }
11348         LDKCResult_ChannelUpdateDecodeErrorZ* operator &() { return &self; }
11349         LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() { return &self; }
11350         const LDKCResult_ChannelUpdateDecodeErrorZ* operator &() const { return &self; }
11351         const LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
11352 };
11353 class CVec_APIErrorZ {
11354 private:
11355         LDKCVec_APIErrorZ self;
11356 public:
11357         CVec_APIErrorZ(const CVec_APIErrorZ&) = delete;
11358         CVec_APIErrorZ(CVec_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_APIErrorZ)); }
11359         CVec_APIErrorZ(LDKCVec_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_APIErrorZ)); }
11360         operator LDKCVec_APIErrorZ() && { LDKCVec_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCVec_APIErrorZ)); return res; }
11361         ~CVec_APIErrorZ() { CVec_APIErrorZ_free(self); }
11362         CVec_APIErrorZ& operator=(CVec_APIErrorZ&& o) { CVec_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_APIErrorZ)); return *this; }
11363         LDKCVec_APIErrorZ* operator &() { return &self; }
11364         LDKCVec_APIErrorZ* operator ->() { return &self; }
11365         const LDKCVec_APIErrorZ* operator &() const { return &self; }
11366         const LDKCVec_APIErrorZ* operator ->() const { return &self; }
11367 };
11368 class COption_TxOutZ {
11369 private:
11370         LDKCOption_TxOutZ self;
11371 public:
11372         COption_TxOutZ(const COption_TxOutZ&) = delete;
11373         COption_TxOutZ(COption_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_TxOutZ)); }
11374         COption_TxOutZ(LDKCOption_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_TxOutZ)); }
11375         operator LDKCOption_TxOutZ() && { LDKCOption_TxOutZ res = self; memset(&self, 0, sizeof(LDKCOption_TxOutZ)); return res; }
11376         ~COption_TxOutZ() { COption_TxOutZ_free(self); }
11377         COption_TxOutZ& operator=(COption_TxOutZ&& o) { COption_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_TxOutZ)); return *this; }
11378         LDKCOption_TxOutZ* operator &() { return &self; }
11379         LDKCOption_TxOutZ* operator ->() { return &self; }
11380         const LDKCOption_TxOutZ* operator &() const { return &self; }
11381         const LDKCOption_TxOutZ* operator ->() const { return &self; }
11382 };
11383 class COption_ClosureReasonZ {
11384 private:
11385         LDKCOption_ClosureReasonZ self;
11386 public:
11387         COption_ClosureReasonZ(const COption_ClosureReasonZ&) = delete;
11388         COption_ClosureReasonZ(COption_ClosureReasonZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ClosureReasonZ)); }
11389         COption_ClosureReasonZ(LDKCOption_ClosureReasonZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ClosureReasonZ)); }
11390         operator LDKCOption_ClosureReasonZ() && { LDKCOption_ClosureReasonZ res = self; memset(&self, 0, sizeof(LDKCOption_ClosureReasonZ)); return res; }
11391         ~COption_ClosureReasonZ() { COption_ClosureReasonZ_free(self); }
11392         COption_ClosureReasonZ& operator=(COption_ClosureReasonZ&& o) { COption_ClosureReasonZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ClosureReasonZ)); return *this; }
11393         LDKCOption_ClosureReasonZ* operator &() { return &self; }
11394         LDKCOption_ClosureReasonZ* operator ->() { return &self; }
11395         const LDKCOption_ClosureReasonZ* operator &() const { return &self; }
11396         const LDKCOption_ClosureReasonZ* operator ->() const { return &self; }
11397 };
11398 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ {
11399 private:
11400         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ self;
11401 public:
11402         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&) = delete;
11403         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); }
11404         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); }
11405         operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); return res; }
11406         ~CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(self); }
11407         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; }
11408         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator &() { return &self; }
11409         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator ->() { return &self; }
11410         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator &() const { return &self; }
11411         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator ->() const { return &self; }
11412 };
11413 class CResult_TransactionU16LenLimitedDecodeErrorZ {
11414 private:
11415         LDKCResult_TransactionU16LenLimitedDecodeErrorZ self;
11416 public:
11417         CResult_TransactionU16LenLimitedDecodeErrorZ(const CResult_TransactionU16LenLimitedDecodeErrorZ&) = delete;
11418         CResult_TransactionU16LenLimitedDecodeErrorZ(CResult_TransactionU16LenLimitedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedDecodeErrorZ)); }
11419         CResult_TransactionU16LenLimitedDecodeErrorZ(LDKCResult_TransactionU16LenLimitedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionU16LenLimitedDecodeErrorZ)); }
11420         operator LDKCResult_TransactionU16LenLimitedDecodeErrorZ() && { LDKCResult_TransactionU16LenLimitedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionU16LenLimitedDecodeErrorZ)); return res; }
11421         ~CResult_TransactionU16LenLimitedDecodeErrorZ() { CResult_TransactionU16LenLimitedDecodeErrorZ_free(self); }
11422         CResult_TransactionU16LenLimitedDecodeErrorZ& operator=(CResult_TransactionU16LenLimitedDecodeErrorZ&& o) { CResult_TransactionU16LenLimitedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedDecodeErrorZ)); return *this; }
11423         LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator &() { return &self; }
11424         LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator ->() { return &self; }
11425         const LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator &() const { return &self; }
11426         const LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator ->() const { return &self; }
11427 };
11428 class CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ {
11429 private:
11430         LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ self;
11431 public:
11432         CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(const CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&) = delete;
11433         CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); }
11434         CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); }
11435         operator LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ() && { LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); return res; }
11436         ~CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ() { CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(self); }
11437         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; }
11438         LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator &() { return &self; }
11439         LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator ->() { return &self; }
11440         const LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator &() const { return &self; }
11441         const LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator ->() const { return &self; }
11442 };
11443 class CResult_CounterpartyForwardingInfoDecodeErrorZ {
11444 private:
11445         LDKCResult_CounterpartyForwardingInfoDecodeErrorZ self;
11446 public:
11447         CResult_CounterpartyForwardingInfoDecodeErrorZ(const CResult_CounterpartyForwardingInfoDecodeErrorZ&) = delete;
11448         CResult_CounterpartyForwardingInfoDecodeErrorZ(CResult_CounterpartyForwardingInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyForwardingInfoDecodeErrorZ)); }
11449         CResult_CounterpartyForwardingInfoDecodeErrorZ(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ)); }
11450         operator LDKCResult_CounterpartyForwardingInfoDecodeErrorZ() && { LDKCResult_CounterpartyForwardingInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ)); return res; }
11451         ~CResult_CounterpartyForwardingInfoDecodeErrorZ() { CResult_CounterpartyForwardingInfoDecodeErrorZ_free(self); }
11452         CResult_CounterpartyForwardingInfoDecodeErrorZ& operator=(CResult_CounterpartyForwardingInfoDecodeErrorZ&& o) { CResult_CounterpartyForwardingInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyForwardingInfoDecodeErrorZ)); return *this; }
11453         LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator &() { return &self; }
11454         LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator ->() { return &self; }
11455         const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator &() const { return &self; }
11456         const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator ->() const { return &self; }
11457 };
11458 class CResult_OpenChannelV2DecodeErrorZ {
11459 private:
11460         LDKCResult_OpenChannelV2DecodeErrorZ self;
11461 public:
11462         CResult_OpenChannelV2DecodeErrorZ(const CResult_OpenChannelV2DecodeErrorZ&) = delete;
11463         CResult_OpenChannelV2DecodeErrorZ(CResult_OpenChannelV2DecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OpenChannelV2DecodeErrorZ)); }
11464         CResult_OpenChannelV2DecodeErrorZ(LDKCResult_OpenChannelV2DecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OpenChannelV2DecodeErrorZ)); }
11465         operator LDKCResult_OpenChannelV2DecodeErrorZ() && { LDKCResult_OpenChannelV2DecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OpenChannelV2DecodeErrorZ)); return res; }
11466         ~CResult_OpenChannelV2DecodeErrorZ() { CResult_OpenChannelV2DecodeErrorZ_free(self); }
11467         CResult_OpenChannelV2DecodeErrorZ& operator=(CResult_OpenChannelV2DecodeErrorZ&& o) { CResult_OpenChannelV2DecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OpenChannelV2DecodeErrorZ)); return *this; }
11468         LDKCResult_OpenChannelV2DecodeErrorZ* operator &() { return &self; }
11469         LDKCResult_OpenChannelV2DecodeErrorZ* operator ->() { return &self; }
11470         const LDKCResult_OpenChannelV2DecodeErrorZ* operator &() const { return &self; }
11471         const LDKCResult_OpenChannelV2DecodeErrorZ* operator ->() const { return &self; }
11472 };
11473 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ {
11474 private:
11475         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ self;
11476 public:
11477         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(const CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&) = delete;
11478         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); }
11479         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); }
11480         operator LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); return res; }
11481         ~CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ() { CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(self); }
11482         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; }
11483         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator &() { return &self; }
11484         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator ->() { return &self; }
11485         const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator &() const { return &self; }
11486         const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator ->() const { return &self; }
11487 };
11488 class CResult_HtlcBasepointDecodeErrorZ {
11489 private:
11490         LDKCResult_HtlcBasepointDecodeErrorZ self;
11491 public:
11492         CResult_HtlcBasepointDecodeErrorZ(const CResult_HtlcBasepointDecodeErrorZ&) = delete;
11493         CResult_HtlcBasepointDecodeErrorZ(CResult_HtlcBasepointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HtlcBasepointDecodeErrorZ)); }
11494         CResult_HtlcBasepointDecodeErrorZ(LDKCResult_HtlcBasepointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HtlcBasepointDecodeErrorZ)); }
11495         operator LDKCResult_HtlcBasepointDecodeErrorZ() && { LDKCResult_HtlcBasepointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HtlcBasepointDecodeErrorZ)); return res; }
11496         ~CResult_HtlcBasepointDecodeErrorZ() { CResult_HtlcBasepointDecodeErrorZ_free(self); }
11497         CResult_HtlcBasepointDecodeErrorZ& operator=(CResult_HtlcBasepointDecodeErrorZ&& o) { CResult_HtlcBasepointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HtlcBasepointDecodeErrorZ)); return *this; }
11498         LDKCResult_HtlcBasepointDecodeErrorZ* operator &() { return &self; }
11499         LDKCResult_HtlcBasepointDecodeErrorZ* operator ->() { return &self; }
11500         const LDKCResult_HtlcBasepointDecodeErrorZ* operator &() const { return &self; }
11501         const LDKCResult_HtlcBasepointDecodeErrorZ* operator ->() const { return &self; }
11502 };
11503 class CResult_SpliceLockedDecodeErrorZ {
11504 private:
11505         LDKCResult_SpliceLockedDecodeErrorZ self;
11506 public:
11507         CResult_SpliceLockedDecodeErrorZ(const CResult_SpliceLockedDecodeErrorZ&) = delete;
11508         CResult_SpliceLockedDecodeErrorZ(CResult_SpliceLockedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpliceLockedDecodeErrorZ)); }
11509         CResult_SpliceLockedDecodeErrorZ(LDKCResult_SpliceLockedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpliceLockedDecodeErrorZ)); }
11510         operator LDKCResult_SpliceLockedDecodeErrorZ() && { LDKCResult_SpliceLockedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpliceLockedDecodeErrorZ)); return res; }
11511         ~CResult_SpliceLockedDecodeErrorZ() { CResult_SpliceLockedDecodeErrorZ_free(self); }
11512         CResult_SpliceLockedDecodeErrorZ& operator=(CResult_SpliceLockedDecodeErrorZ&& o) { CResult_SpliceLockedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpliceLockedDecodeErrorZ)); return *this; }
11513         LDKCResult_SpliceLockedDecodeErrorZ* operator &() { return &self; }
11514         LDKCResult_SpliceLockedDecodeErrorZ* operator ->() { return &self; }
11515         const LDKCResult_SpliceLockedDecodeErrorZ* operator &() const { return &self; }
11516         const LDKCResult_SpliceLockedDecodeErrorZ* operator ->() const { return &self; }
11517 };
11518 class CResult_RouteDecodeErrorZ {
11519 private:
11520         LDKCResult_RouteDecodeErrorZ self;
11521 public:
11522         CResult_RouteDecodeErrorZ(const CResult_RouteDecodeErrorZ&) = delete;
11523         CResult_RouteDecodeErrorZ(CResult_RouteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); }
11524         CResult_RouteDecodeErrorZ(LDKCResult_RouteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); }
11525         operator LDKCResult_RouteDecodeErrorZ() && { LDKCResult_RouteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); return res; }
11526         ~CResult_RouteDecodeErrorZ() { CResult_RouteDecodeErrorZ_free(self); }
11527         CResult_RouteDecodeErrorZ& operator=(CResult_RouteDecodeErrorZ&& o) { CResult_RouteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); return *this; }
11528         LDKCResult_RouteDecodeErrorZ* operator &() { return &self; }
11529         LDKCResult_RouteDecodeErrorZ* operator ->() { return &self; }
11530         const LDKCResult_RouteDecodeErrorZ* operator &() const { return &self; }
11531         const LDKCResult_RouteDecodeErrorZ* operator ->() const { return &self; }
11532 };
11533 class CResult_BlindedFailureDecodeErrorZ {
11534 private:
11535         LDKCResult_BlindedFailureDecodeErrorZ self;
11536 public:
11537         CResult_BlindedFailureDecodeErrorZ(const CResult_BlindedFailureDecodeErrorZ&) = delete;
11538         CResult_BlindedFailureDecodeErrorZ(CResult_BlindedFailureDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedFailureDecodeErrorZ)); }
11539         CResult_BlindedFailureDecodeErrorZ(LDKCResult_BlindedFailureDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedFailureDecodeErrorZ)); }
11540         operator LDKCResult_BlindedFailureDecodeErrorZ() && { LDKCResult_BlindedFailureDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedFailureDecodeErrorZ)); return res; }
11541         ~CResult_BlindedFailureDecodeErrorZ() { CResult_BlindedFailureDecodeErrorZ_free(self); }
11542         CResult_BlindedFailureDecodeErrorZ& operator=(CResult_BlindedFailureDecodeErrorZ&& o) { CResult_BlindedFailureDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedFailureDecodeErrorZ)); return *this; }
11543         LDKCResult_BlindedFailureDecodeErrorZ* operator &() { return &self; }
11544         LDKCResult_BlindedFailureDecodeErrorZ* operator ->() { return &self; }
11545         const LDKCResult_BlindedFailureDecodeErrorZ* operator &() const { return &self; }
11546         const LDKCResult_BlindedFailureDecodeErrorZ* operator ->() const { return &self; }
11547 };
11548 class CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ {
11549 private:
11550         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ self;
11551 public:
11552         CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(const CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&) = delete;
11553         CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); }
11554         CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); }
11555         operator LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ() && { LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); return res; }
11556         ~CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ() { CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(self); }
11557         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; }
11558         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator &() { return &self; }
11559         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator ->() { return &self; }
11560         const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator &() const { return &self; }
11561         const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator ->() const { return &self; }
11562 };
11563 class COption_NoneZ {
11564 private:
11565         LDKCOption_NoneZ self;
11566 public:
11567         COption_NoneZ(const COption_NoneZ&) = delete;
11568         COption_NoneZ(COption_NoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NoneZ)); }
11569         COption_NoneZ(LDKCOption_NoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NoneZ)); }
11570         operator LDKCOption_NoneZ() && { LDKCOption_NoneZ res = self; memset(&self, 0, sizeof(LDKCOption_NoneZ)); return res; }
11571         ~COption_NoneZ() { COption_NoneZ_free(self); }
11572         COption_NoneZ& operator=(COption_NoneZ&& o) { COption_NoneZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NoneZ)); return *this; }
11573         LDKCOption_NoneZ* operator &() { return &self; }
11574         LDKCOption_NoneZ* operator ->() { return &self; }
11575         const LDKCOption_NoneZ* operator &() const { return &self; }
11576         const LDKCOption_NoneZ* operator ->() const { return &self; }
11577 };
11578 class CResult_TxAddOutputDecodeErrorZ {
11579 private:
11580         LDKCResult_TxAddOutputDecodeErrorZ self;
11581 public:
11582         CResult_TxAddOutputDecodeErrorZ(const CResult_TxAddOutputDecodeErrorZ&) = delete;
11583         CResult_TxAddOutputDecodeErrorZ(CResult_TxAddOutputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAddOutputDecodeErrorZ)); }
11584         CResult_TxAddOutputDecodeErrorZ(LDKCResult_TxAddOutputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAddOutputDecodeErrorZ)); }
11585         operator LDKCResult_TxAddOutputDecodeErrorZ() && { LDKCResult_TxAddOutputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAddOutputDecodeErrorZ)); return res; }
11586         ~CResult_TxAddOutputDecodeErrorZ() { CResult_TxAddOutputDecodeErrorZ_free(self); }
11587         CResult_TxAddOutputDecodeErrorZ& operator=(CResult_TxAddOutputDecodeErrorZ&& o) { CResult_TxAddOutputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAddOutputDecodeErrorZ)); return *this; }
11588         LDKCResult_TxAddOutputDecodeErrorZ* operator &() { return &self; }
11589         LDKCResult_TxAddOutputDecodeErrorZ* operator ->() { return &self; }
11590         const LDKCResult_TxAddOutputDecodeErrorZ* operator &() const { return &self; }
11591         const LDKCResult_TxAddOutputDecodeErrorZ* operator ->() const { return &self; }
11592 };
11593 class COption_CVec_u8ZZ {
11594 private:
11595         LDKCOption_CVec_u8ZZ self;
11596 public:
11597         COption_CVec_u8ZZ(const COption_CVec_u8ZZ&) = delete;
11598         COption_CVec_u8ZZ(COption_CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_u8ZZ)); }
11599         COption_CVec_u8ZZ(LDKCOption_CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_u8ZZ)); }
11600         operator LDKCOption_CVec_u8ZZ() && { LDKCOption_CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_u8ZZ)); return res; }
11601         ~COption_CVec_u8ZZ() { COption_CVec_u8ZZ_free(self); }
11602         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; }
11603         LDKCOption_CVec_u8ZZ* operator &() { return &self; }
11604         LDKCOption_CVec_u8ZZ* operator ->() { return &self; }
11605         const LDKCOption_CVec_u8ZZ* operator &() const { return &self; }
11606         const LDKCOption_CVec_u8ZZ* operator ->() const { return &self; }
11607 };
11608
11609 inline LDKPublicKey ChannelSigner::get_per_commitment_point(uint64_t idx) {
11610         LDKPublicKey ret = (self.get_per_commitment_point)(self.this_arg, idx);
11611         return ret;
11612 }
11613 inline LDKThirtyTwoBytes ChannelSigner::release_commitment_secret(uint64_t idx) {
11614         LDKThirtyTwoBytes ret = (self.release_commitment_secret)(self.this_arg, idx);
11615         return ret;
11616 }
11617 inline LDK::CResult_NoneNoneZ ChannelSigner::validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages) {
11618         LDK::CResult_NoneNoneZ ret = (self.validate_holder_commitment)(self.this_arg, holder_tx, outbound_htlc_preimages);
11619         return ret;
11620 }
11621 inline LDK::CResult_NoneNoneZ ChannelSigner::validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]) {
11622         LDK::CResult_NoneNoneZ ret = (self.validate_counterparty_revocation)(self.this_arg, idx, secret);
11623         return ret;
11624 }
11625 inline LDKThirtyTwoBytes ChannelSigner::channel_keys_id() {
11626         LDKThirtyTwoBytes ret = (self.channel_keys_id)(self.this_arg);
11627         return ret;
11628 }
11629 inline void ChannelSigner::provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters) {
11630         (self.provide_channel_parameters)(self.this_arg, channel_parameters);
11631 }
11632 inline LDKThirtyTwoBytes EntropySource::get_secure_random_bytes() {
11633         LDKThirtyTwoBytes ret = (self.get_secure_random_bytes)(self.this_arg);
11634         return ret;
11635 }
11636 inline LDKThirtyTwoBytes NodeSigner::get_inbound_payment_key_material() {
11637         LDKThirtyTwoBytes ret = (self.get_inbound_payment_key_material)(self.this_arg);
11638         return ret;
11639 }
11640 inline LDK::CResult_PublicKeyNoneZ NodeSigner::get_node_id(enum LDKRecipient recipient) {
11641         LDK::CResult_PublicKeyNoneZ ret = (self.get_node_id)(self.this_arg, recipient);
11642         return ret;
11643 }
11644 inline LDK::CResult_ThirtyTwoBytesNoneZ NodeSigner::ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak) {
11645         LDK::CResult_ThirtyTwoBytesNoneZ ret = (self.ecdh)(self.this_arg, recipient, other_key, tweak);
11646         return ret;
11647 }
11648 inline LDK::CResult_RecoverableSignatureNoneZ NodeSigner::sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient) {
11649         LDK::CResult_RecoverableSignatureNoneZ ret = (self.sign_invoice)(self.this_arg, hrp_bytes, invoice_data, recipient);
11650         return ret;
11651 }
11652 inline LDK::CResult_SchnorrSignatureNoneZ NodeSigner::sign_bolt12_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR invoice_request) {
11653         LDK::CResult_SchnorrSignatureNoneZ ret = (self.sign_bolt12_invoice_request)(self.this_arg, invoice_request);
11654         return ret;
11655 }
11656 inline LDK::CResult_SchnorrSignatureNoneZ NodeSigner::sign_bolt12_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR invoice) {
11657         LDK::CResult_SchnorrSignatureNoneZ ret = (self.sign_bolt12_invoice)(self.this_arg, invoice);
11658         return ret;
11659 }
11660 inline LDK::CResult_ECDSASignatureNoneZ NodeSigner::sign_gossip_message(struct LDKUnsignedGossipMessage msg) {
11661         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_gossip_message)(self.this_arg, msg);
11662         return ret;
11663 }
11664 inline LDKThirtyTwoBytes SignerProvider::generate_channel_keys_id(bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id) {
11665         LDKThirtyTwoBytes ret = (self.generate_channel_keys_id)(self.this_arg, inbound, channel_value_satoshis, user_channel_id);
11666         return ret;
11667 }
11668 inline LDK::WriteableEcdsaChannelSigner SignerProvider::derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id) {
11669         LDK::WriteableEcdsaChannelSigner ret = (self.derive_channel_signer)(self.this_arg, channel_value_satoshis, channel_keys_id);
11670         return ret;
11671 }
11672 inline LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ SignerProvider::read_chan_signer(struct LDKu8slice reader) {
11673         LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ ret = (self.read_chan_signer)(self.this_arg, reader);
11674         return ret;
11675 }
11676 inline LDK::CResult_CVec_u8ZNoneZ SignerProvider::get_destination_script(struct LDKThirtyTwoBytes channel_keys_id) {
11677         LDK::CResult_CVec_u8ZNoneZ ret = (self.get_destination_script)(self.this_arg, channel_keys_id);
11678         return ret;
11679 }
11680 inline LDK::CResult_ShutdownScriptNoneZ SignerProvider::get_shutdown_scriptpubkey() {
11681         LDK::CResult_ShutdownScriptNoneZ ret = (self.get_shutdown_scriptpubkey)(self.this_arg);
11682         return ret;
11683 }
11684 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) {
11685         LDK::CResult_RouteLightningErrorZ ret = (self.find_route)(self.this_arg, payer, route_params, first_hops, inflight_htlcs);
11686         return ret;
11687 }
11688 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) {
11689         LDK::CResult_RouteLightningErrorZ ret = (self.find_route_with_id)(self.this_arg, payer, route_params, first_hops, inflight_htlcs, _payment_hash, _payment_id);
11690         return ret;
11691 }
11692 inline LDK::CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ Router::create_blinded_payment_paths(struct LDKPublicKey recipient, struct LDKCVec_ChannelDetailsZ first_hops, struct LDKReceiveTlvs tlvs, uint64_t amount_msats) {
11693         LDK::CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ ret = (self.create_blinded_payment_paths)(self.this_arg, recipient, first_hops, tlvs, amount_msats);
11694         return ret;
11695 }
11696 inline uint64_t ScoreLookUp::channel_penalty_msat(const struct LDKCandidateRouteHop *NONNULL_PTR candidate, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params) {
11697         uint64_t ret = (self.channel_penalty_msat)(self.this_arg, candidate, usage, score_params);
11698         return ret;
11699 }
11700 inline void ScoreUpdate::payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch) {
11701         (self.payment_path_failed)(self.this_arg, path, short_channel_id, duration_since_epoch);
11702 }
11703 inline void ScoreUpdate::payment_path_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch) {
11704         (self.payment_path_successful)(self.this_arg, path, duration_since_epoch);
11705 }
11706 inline void ScoreUpdate::probe_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch) {
11707         (self.probe_failed)(self.this_arg, path, short_channel_id, duration_since_epoch);
11708 }
11709 inline void ScoreUpdate::probe_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch) {
11710         (self.probe_successful)(self.this_arg, path, duration_since_epoch);
11711 }
11712 inline void ScoreUpdate::time_passed(uint64_t duration_since_epoch) {
11713         (self.time_passed)(self.this_arg, duration_since_epoch);
11714 }
11715 inline LDK::ScoreLookUp LockableScore::read_lock() {
11716         LDK::ScoreLookUp ret = (self.read_lock)(self.this_arg);
11717         return ret;
11718 }
11719 inline LDK::ScoreUpdate LockableScore::write_lock() {
11720         LDK::ScoreUpdate ret = (self.write_lock)(self.this_arg);
11721         return ret;
11722 }
11723 inline void Listen::filtered_block_connected(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
11724         (self.filtered_block_connected)(self.this_arg, header, txdata, height);
11725 }
11726 inline void Listen::block_connected(struct LDKu8slice block, uint32_t height) {
11727         (self.block_connected)(self.this_arg, block, height);
11728 }
11729 inline void Listen::block_disconnected(const uint8_t (*header)[80], uint32_t height) {
11730         (self.block_disconnected)(self.this_arg, header, height);
11731 }
11732 inline void Confirm::transactions_confirmed(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
11733         (self.transactions_confirmed)(self.this_arg, header, txdata, height);
11734 }
11735 inline void Confirm::transaction_unconfirmed(const uint8_t (*txid)[32]) {
11736         (self.transaction_unconfirmed)(self.this_arg, txid);
11737 }
11738 inline void Confirm::best_block_updated(const uint8_t (*header)[80], uint32_t height) {
11739         (self.best_block_updated)(self.this_arg, header, height);
11740 }
11741 inline LDK::CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ Confirm::get_relevant_txids() {
11742         LDK::CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ ret = (self.get_relevant_txids)(self.this_arg);
11743         return ret;
11744 }
11745 inline LDK::CResult_ChannelMonitorUpdateStatusNoneZ Watch::watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor) {
11746         LDK::CResult_ChannelMonitorUpdateStatusNoneZ ret = (self.watch_channel)(self.this_arg, funding_txo, monitor);
11747         return ret;
11748 }
11749 inline LDK::ChannelMonitorUpdateStatus Watch::update_channel(struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update) {
11750         LDK::ChannelMonitorUpdateStatus ret = (self.update_channel)(self.this_arg, funding_txo, update);
11751         return ret;
11752 }
11753 inline LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Watch::release_pending_monitor_events() {
11754         LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret = (self.release_pending_monitor_events)(self.this_arg);
11755         return ret;
11756 }
11757 inline void Filter::register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey) {
11758         (self.register_tx)(self.this_arg, txid, script_pubkey);
11759 }
11760 inline void Filter::register_output(struct LDKWatchedOutput output) {
11761         (self.register_output)(self.this_arg, output);
11762 }
11763 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) {
11764         LDK::CResult_CoinSelectionNoneZ ret = (self.select_confirmed_utxos)(self.this_arg, claim_id, must_spend, must_pay_to, target_feerate_sat_per_1000_weight);
11765         return ret;
11766 }
11767 inline LDK::CResult_TransactionNoneZ CoinSelectionSource::sign_psbt(struct LDKCVec_u8Z psbt) {
11768         LDK::CResult_TransactionNoneZ ret = (self.sign_psbt)(self.this_arg, psbt);
11769         return ret;
11770 }
11771 inline LDK::CResult_CVec_UtxoZNoneZ WalletSource::list_confirmed_utxos() {
11772         LDK::CResult_CVec_UtxoZNoneZ ret = (self.list_confirmed_utxos)(self.this_arg);
11773         return ret;
11774 }
11775 inline LDK::CResult_CVec_u8ZNoneZ WalletSource::get_change_script() {
11776         LDK::CResult_CVec_u8ZNoneZ ret = (self.get_change_script)(self.this_arg);
11777         return ret;
11778 }
11779 inline LDK::CResult_TransactionNoneZ WalletSource::sign_psbt(struct LDKCVec_u8Z psbt) {
11780         LDK::CResult_TransactionNoneZ ret = (self.sign_psbt)(self.this_arg, psbt);
11781         return ret;
11782 }
11783 inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ EcdsaChannelSigner::sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ inbound_htlc_preimages, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages) {
11784         LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ ret = (self.sign_counterparty_commitment)(self.this_arg, commitment_tx, inbound_htlc_preimages, outbound_htlc_preimages);
11785         return ret;
11786 }
11787 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx) {
11788         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_commitment)(self.this_arg, commitment_tx);
11789         return ret;
11790 }
11791 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]) {
11792         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_justice_revoked_output)(self.this_arg, justice_tx, input, amount, per_commitment_key);
11793         return ret;
11794 }
11795 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) {
11796         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_justice_revoked_htlc)(self.this_arg, justice_tx, input, amount, per_commitment_key, htlc);
11797         return ret;
11798 }
11799 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor) {
11800         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_htlc_transaction)(self.this_arg, htlc_tx, input, htlc_descriptor);
11801         return ret;
11802 }
11803 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) {
11804         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_counterparty_htlc_transaction)(self.this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
11805         return ret;
11806 }
11807 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx) {
11808         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_closing_transaction)(self.this_arg, closing_tx);
11809         return ret;
11810 }
11811 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input) {
11812         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_anchor_input)(self.this_arg, anchor_tx, input);
11813         return ret;
11814 }
11815 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg) {
11816         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_channel_announcement_with_funding_key)(self.this_arg, msg);
11817         return ret;
11818 }
11819 inline LDK::CResult_NoneLightningErrorZ CustomMessageHandler::handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id) {
11820         LDK::CResult_NoneLightningErrorZ ret = (self.handle_custom_message)(self.this_arg, msg, sender_node_id);
11821         return ret;
11822 }
11823 inline LDK::CVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler::get_and_clear_pending_msg() {
11824         LDK::CVec_C2Tuple_PublicKeyTypeZZ ret = (self.get_and_clear_pending_msg)(self.this_arg);
11825         return ret;
11826 }
11827 inline LDK::NodeFeatures CustomMessageHandler::provided_node_features() {
11828         LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
11829         return ret;
11830 }
11831 inline LDK::InitFeatures CustomMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
11832         LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
11833         return ret;
11834 }
11835 inline uintptr_t SocketDescriptor::send_data(struct LDKu8slice data, bool resume_read) {
11836         uintptr_t ret = (self.send_data)(self.this_arg, data, resume_read);
11837         return ret;
11838 }
11839 inline void SocketDescriptor::disconnect_socket() {
11840         (self.disconnect_socket)(self.this_arg);
11841 }
11842 inline bool SocketDescriptor::eq(const struct LDKSocketDescriptor *NONNULL_PTR other_arg) {
11843         bool ret = (self.eq)(self.this_arg, other_arg);
11844         return ret;
11845 }
11846 inline uint64_t SocketDescriptor::hash() {
11847         uint64_t ret = (self.hash)(self.this_arg);
11848         return ret;
11849 }
11850 inline LDK::CResult_CVec_u8ZIOErrorZ KVStore::read(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key) {
11851         LDK::CResult_CVec_u8ZIOErrorZ ret = (self.read)(self.this_arg, primary_namespace, secondary_namespace, key);
11852         return ret;
11853 }
11854 inline LDK::CResult_NoneIOErrorZ KVStore::write(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, struct LDKu8slice buf) {
11855         LDK::CResult_NoneIOErrorZ ret = (self.write)(self.this_arg, primary_namespace, secondary_namespace, key, buf);
11856         return ret;
11857 }
11858 inline LDK::CResult_NoneIOErrorZ KVStore::remove(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, bool lazy) {
11859         LDK::CResult_NoneIOErrorZ ret = (self.remove)(self.this_arg, primary_namespace, secondary_namespace, key, lazy);
11860         return ret;
11861 }
11862 inline LDK::CResult_CVec_StrZIOErrorZ KVStore::list(struct LDKStr primary_namespace, struct LDKStr secondary_namespace) {
11863         LDK::CResult_CVec_StrZIOErrorZ ret = (self.list)(self.this_arg, primary_namespace, secondary_namespace);
11864         return ret;
11865 }
11866 inline LDK::CResult_NoneIOErrorZ Persister::persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager) {
11867         LDK::CResult_NoneIOErrorZ ret = (self.persist_manager)(self.this_arg, channel_manager);
11868         return ret;
11869 }
11870 inline LDK::CResult_NoneIOErrorZ Persister::persist_graph(const struct LDKNetworkGraph *NONNULL_PTR network_graph) {
11871         LDK::CResult_NoneIOErrorZ ret = (self.persist_graph)(self.this_arg, network_graph);
11872         return ret;
11873 }
11874 inline LDK::CResult_NoneIOErrorZ Persister::persist_scorer(const struct LDKWriteableScore *NONNULL_PTR scorer) {
11875         LDK::CResult_NoneIOErrorZ ret = (self.persist_scorer)(self.this_arg, scorer);
11876         return ret;
11877 }
11878 inline void ChannelMessageHandler::handle_open_channel(struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg) {
11879         (self.handle_open_channel)(self.this_arg, their_node_id, msg);
11880 }
11881 inline void ChannelMessageHandler::handle_open_channel_v2(struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg) {
11882         (self.handle_open_channel_v2)(self.this_arg, their_node_id, msg);
11883 }
11884 inline void ChannelMessageHandler::handle_accept_channel(struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg) {
11885         (self.handle_accept_channel)(self.this_arg, their_node_id, msg);
11886 }
11887 inline void ChannelMessageHandler::handle_accept_channel_v2(struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg) {
11888         (self.handle_accept_channel_v2)(self.this_arg, their_node_id, msg);
11889 }
11890 inline void ChannelMessageHandler::handle_funding_created(struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg) {
11891         (self.handle_funding_created)(self.this_arg, their_node_id, msg);
11892 }
11893 inline void ChannelMessageHandler::handle_funding_signed(struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg) {
11894         (self.handle_funding_signed)(self.this_arg, their_node_id, msg);
11895 }
11896 inline void ChannelMessageHandler::handle_channel_ready(struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg) {
11897         (self.handle_channel_ready)(self.this_arg, their_node_id, msg);
11898 }
11899 inline void ChannelMessageHandler::handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg) {
11900         (self.handle_shutdown)(self.this_arg, their_node_id, msg);
11901 }
11902 inline void ChannelMessageHandler::handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg) {
11903         (self.handle_closing_signed)(self.this_arg, their_node_id, msg);
11904 }
11905 inline void ChannelMessageHandler::handle_stfu(struct LDKPublicKey their_node_id, const struct LDKStfu *NONNULL_PTR msg) {
11906         (self.handle_stfu)(self.this_arg, their_node_id, msg);
11907 }
11908 inline void ChannelMessageHandler::handle_splice(struct LDKPublicKey their_node_id, const struct LDKSplice *NONNULL_PTR msg) {
11909         (self.handle_splice)(self.this_arg, their_node_id, msg);
11910 }
11911 inline void ChannelMessageHandler::handle_splice_ack(struct LDKPublicKey their_node_id, const struct LDKSpliceAck *NONNULL_PTR msg) {
11912         (self.handle_splice_ack)(self.this_arg, their_node_id, msg);
11913 }
11914 inline void ChannelMessageHandler::handle_splice_locked(struct LDKPublicKey their_node_id, const struct LDKSpliceLocked *NONNULL_PTR msg) {
11915         (self.handle_splice_locked)(self.this_arg, their_node_id, msg);
11916 }
11917 inline void ChannelMessageHandler::handle_tx_add_input(struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg) {
11918         (self.handle_tx_add_input)(self.this_arg, their_node_id, msg);
11919 }
11920 inline void ChannelMessageHandler::handle_tx_add_output(struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg) {
11921         (self.handle_tx_add_output)(self.this_arg, their_node_id, msg);
11922 }
11923 inline void ChannelMessageHandler::handle_tx_remove_input(struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg) {
11924         (self.handle_tx_remove_input)(self.this_arg, their_node_id, msg);
11925 }
11926 inline void ChannelMessageHandler::handle_tx_remove_output(struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg) {
11927         (self.handle_tx_remove_output)(self.this_arg, their_node_id, msg);
11928 }
11929 inline void ChannelMessageHandler::handle_tx_complete(struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg) {
11930         (self.handle_tx_complete)(self.this_arg, their_node_id, msg);
11931 }
11932 inline void ChannelMessageHandler::handle_tx_signatures(struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg) {
11933         (self.handle_tx_signatures)(self.this_arg, their_node_id, msg);
11934 }
11935 inline void ChannelMessageHandler::handle_tx_init_rbf(struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg) {
11936         (self.handle_tx_init_rbf)(self.this_arg, their_node_id, msg);
11937 }
11938 inline void ChannelMessageHandler::handle_tx_ack_rbf(struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg) {
11939         (self.handle_tx_ack_rbf)(self.this_arg, their_node_id, msg);
11940 }
11941 inline void ChannelMessageHandler::handle_tx_abort(struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg) {
11942         (self.handle_tx_abort)(self.this_arg, their_node_id, msg);
11943 }
11944 inline void ChannelMessageHandler::handle_update_add_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg) {
11945         (self.handle_update_add_htlc)(self.this_arg, their_node_id, msg);
11946 }
11947 inline void ChannelMessageHandler::handle_update_fulfill_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg) {
11948         (self.handle_update_fulfill_htlc)(self.this_arg, their_node_id, msg);
11949 }
11950 inline void ChannelMessageHandler::handle_update_fail_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg) {
11951         (self.handle_update_fail_htlc)(self.this_arg, their_node_id, msg);
11952 }
11953 inline void ChannelMessageHandler::handle_update_fail_malformed_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg) {
11954         (self.handle_update_fail_malformed_htlc)(self.this_arg, their_node_id, msg);
11955 }
11956 inline void ChannelMessageHandler::handle_commitment_signed(struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg) {
11957         (self.handle_commitment_signed)(self.this_arg, their_node_id, msg);
11958 }
11959 inline void ChannelMessageHandler::handle_revoke_and_ack(struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg) {
11960         (self.handle_revoke_and_ack)(self.this_arg, their_node_id, msg);
11961 }
11962 inline void ChannelMessageHandler::handle_update_fee(struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg) {
11963         (self.handle_update_fee)(self.this_arg, their_node_id, msg);
11964 }
11965 inline void ChannelMessageHandler::handle_announcement_signatures(struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg) {
11966         (self.handle_announcement_signatures)(self.this_arg, their_node_id, msg);
11967 }
11968 inline void ChannelMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id) {
11969         (self.peer_disconnected)(self.this_arg, their_node_id);
11970 }
11971 inline LDK::CResult_NoneNoneZ ChannelMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound) {
11972         LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, msg, inbound);
11973         return ret;
11974 }
11975 inline void ChannelMessageHandler::handle_channel_reestablish(struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg) {
11976         (self.handle_channel_reestablish)(self.this_arg, their_node_id, msg);
11977 }
11978 inline void ChannelMessageHandler::handle_channel_update(struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg) {
11979         (self.handle_channel_update)(self.this_arg, their_node_id, msg);
11980 }
11981 inline void ChannelMessageHandler::handle_error(struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg) {
11982         (self.handle_error)(self.this_arg, their_node_id, msg);
11983 }
11984 inline LDK::NodeFeatures ChannelMessageHandler::provided_node_features() {
11985         LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
11986         return ret;
11987 }
11988 inline LDK::InitFeatures ChannelMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
11989         LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
11990         return ret;
11991 }
11992 inline LDK::COption_CVec_ThirtyTwoBytesZZ ChannelMessageHandler::get_chain_hashes() {
11993         LDK::COption_CVec_ThirtyTwoBytesZZ ret = (self.get_chain_hashes)(self.this_arg);
11994         return ret;
11995 }
11996 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg) {
11997         LDK::CResult_boolLightningErrorZ ret = (self.handle_node_announcement)(self.this_arg, msg);
11998         return ret;
11999 }
12000 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg) {
12001         LDK::CResult_boolLightningErrorZ ret = (self.handle_channel_announcement)(self.this_arg, msg);
12002         return ret;
12003 }
12004 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_channel_update(const struct LDKChannelUpdate *NONNULL_PTR msg) {
12005         LDK::CResult_boolLightningErrorZ ret = (self.handle_channel_update)(self.this_arg, msg);
12006         return ret;
12007 }
12008 inline LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler::get_next_channel_announcement(uint64_t starting_point) {
12009         LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = (self.get_next_channel_announcement)(self.this_arg, starting_point);
12010         return ret;
12011 }
12012 inline LDK::NodeAnnouncement RoutingMessageHandler::get_next_node_announcement(struct LDKNodeId starting_point) {
12013         LDK::NodeAnnouncement ret = (self.get_next_node_announcement)(self.this_arg, starting_point);
12014         return ret;
12015 }
12016 inline LDK::CResult_NoneNoneZ RoutingMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound) {
12017         LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, init, inbound);
12018         return ret;
12019 }
12020 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_reply_channel_range(struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg) {
12021         LDK::CResult_NoneLightningErrorZ ret = (self.handle_reply_channel_range)(self.this_arg, their_node_id, msg);
12022         return ret;
12023 }
12024 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_reply_short_channel_ids_end(struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg) {
12025         LDK::CResult_NoneLightningErrorZ ret = (self.handle_reply_short_channel_ids_end)(self.this_arg, their_node_id, msg);
12026         return ret;
12027 }
12028 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_query_channel_range(struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg) {
12029         LDK::CResult_NoneLightningErrorZ ret = (self.handle_query_channel_range)(self.this_arg, their_node_id, msg);
12030         return ret;
12031 }
12032 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg) {
12033         LDK::CResult_NoneLightningErrorZ ret = (self.handle_query_short_channel_ids)(self.this_arg, their_node_id, msg);
12034         return ret;
12035 }
12036 inline bool RoutingMessageHandler::processing_queue_high() {
12037         bool ret = (self.processing_queue_high)(self.this_arg);
12038         return ret;
12039 }
12040 inline LDK::NodeFeatures RoutingMessageHandler::provided_node_features() {
12041         LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
12042         return ret;
12043 }
12044 inline LDK::InitFeatures RoutingMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
12045         LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
12046         return ret;
12047 }
12048 inline LDK::CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ OnionMessageHandler::get_and_clear_connections_needed() {
12049         LDK::CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ ret = (self.get_and_clear_connections_needed)(self.this_arg);
12050         return ret;
12051 }
12052 inline void OnionMessageHandler::handle_onion_message(struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg) {
12053         (self.handle_onion_message)(self.this_arg, peer_node_id, msg);
12054 }
12055 inline LDK::OnionMessage OnionMessageHandler::next_onion_message_for_peer(struct LDKPublicKey peer_node_id) {
12056         LDK::OnionMessage ret = (self.next_onion_message_for_peer)(self.this_arg, peer_node_id);
12057         return ret;
12058 }
12059 inline LDK::CResult_NoneNoneZ OnionMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound) {
12060         LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, init, inbound);
12061         return ret;
12062 }
12063 inline void OnionMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id) {
12064         (self.peer_disconnected)(self.this_arg, their_node_id);
12065 }
12066 inline void OnionMessageHandler::timer_tick_occurred() {
12067         (self.timer_tick_occurred)(self.this_arg);
12068 }
12069 inline LDK::NodeFeatures OnionMessageHandler::provided_node_features() {
12070         LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
12071         return ret;
12072 }
12073 inline LDK::InitFeatures OnionMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
12074         LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
12075         return ret;
12076 }
12077 inline void Logger::log(struct LDKRecord record) {
12078         (self.log)(self.this_arg, record);
12079 }
12080 inline void FutureCallback::call() {
12081         (self.call)(self.this_arg);
12082 }
12083 inline LDK::COption_OffersMessageZ OffersMessageHandler::handle_message(struct LDKOffersMessage message) {
12084         LDK::COption_OffersMessageZ ret = (self.handle_message)(self.this_arg, message);
12085         return ret;
12086 }
12087 inline LDK::CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ OffersMessageHandler::release_pending_messages() {
12088         LDK::CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ ret = (self.release_pending_messages)(self.this_arg);
12089         return ret;
12090 }
12091 inline void BroadcasterInterface::broadcast_transactions(struct LDKCVec_TransactionZ txs) {
12092         (self.broadcast_transactions)(self.this_arg, txs);
12093 }
12094 inline uint32_t FeeEstimator::get_est_sat_per_1000_weight(enum LDKConfirmationTarget confirmation_target) {
12095         uint32_t ret = (self.get_est_sat_per_1000_weight)(self.this_arg, confirmation_target);
12096         return ret;
12097 }
12098 inline uint64_t OnionMessageContents::tlv_type() {
12099         uint64_t ret = (self.tlv_type)(self.this_arg);
12100         return ret;
12101 }
12102 inline LDK::Str OnionMessageContents::debug_str() {
12103         LDK::Str ret = (self.debug_str)(self.this_arg);
12104         return ret;
12105 }
12106 inline LDK::CVec_MessageSendEventZ MessageSendEventsProvider::get_and_clear_pending_msg_events() {
12107         LDK::CVec_MessageSendEventZ ret = (self.get_and_clear_pending_msg_events)(self.this_arg);
12108         return ret;
12109 }
12110 inline void EventsProvider::process_pending_events(struct LDKEventHandler handler) {
12111         (self.process_pending_events)(self.this_arg, handler);
12112 }
12113 inline void EventHandler::handle_event(struct LDKEvent event) {
12114         (self.handle_event)(self.this_arg, event);
12115 }
12116 inline LDK::CResult_COption_TypeZDecodeErrorZ CustomMessageReader::read(uint16_t message_type, struct LDKu8slice buffer) {
12117         LDK::CResult_COption_TypeZDecodeErrorZ ret = (self.read)(self.this_arg, message_type, buffer);
12118         return ret;
12119 }
12120 inline uint16_t Type::type_id() {
12121         uint16_t ret = (self.type_id)(self.this_arg);
12122         return ret;
12123 }
12124 inline LDK::Str Type::debug_str() {
12125         LDK::Str ret = (self.debug_str)(self.this_arg);
12126         return ret;
12127 }
12128 inline LDK::UtxoResult UtxoLookup::get_utxo(const uint8_t (*chain_hash)[32], uint64_t short_channel_id) {
12129         LDK::UtxoResult ret = (self.get_utxo)(self.this_arg, chain_hash, short_channel_id);
12130         return ret;
12131 }
12132 inline LDK::CResult_OnionMessagePathNoneZ MessageRouter::find_path(struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination) {
12133         LDK::CResult_OnionMessagePathNoneZ ret = (self.find_path)(self.this_arg, sender, peers, destination);
12134         return ret;
12135 }
12136 inline LDK::CResult_CVec_BlindedPathZNoneZ MessageRouter::create_blinded_paths(struct LDKPublicKey recipient, struct LDKCVec_PublicKeyZ peers) {
12137         LDK::CResult_CVec_BlindedPathZNoneZ ret = (self.create_blinded_paths)(self.this_arg, recipient, peers);
12138         return ret;
12139 }
12140 inline LDK::COption_OnionMessageContentsZ CustomOnionMessageHandler::handle_custom_message(struct LDKOnionMessageContents msg) {
12141         LDK::COption_OnionMessageContentsZ ret = (self.handle_custom_message)(self.this_arg, msg);
12142         return ret;
12143 }
12144 inline LDK::CResult_COption_OnionMessageContentsZDecodeErrorZ CustomOnionMessageHandler::read_custom_message(uint64_t message_type, struct LDKu8slice buffer) {
12145         LDK::CResult_COption_OnionMessageContentsZDecodeErrorZ ret = (self.read_custom_message)(self.this_arg, message_type, buffer);
12146         return ret;
12147 }
12148 inline LDK::CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ CustomOnionMessageHandler::release_pending_custom_messages() {
12149         LDK::CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ ret = (self.release_pending_custom_messages)(self.this_arg);
12150         return ret;
12151 }
12152 inline LDK::ChannelMonitorUpdateStatus Persist::persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
12153         LDK::ChannelMonitorUpdateStatus ret = (self.persist_new_channel)(self.this_arg, channel_id, data, update_id);
12154         return ret;
12155 }
12156 inline LDK::ChannelMonitorUpdateStatus Persist::update_persisted_channel(struct LDKOutPoint channel_id, struct LDKChannelMonitorUpdate update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
12157         LDK::ChannelMonitorUpdateStatus ret = (self.update_persisted_channel)(self.this_arg, channel_id, update, data, update_id);
12158         return ret;
12159 }
12160 }