_ 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 RefundMaybeWithDerivedMetadataBuilder;
   6 class Refund;
   7 class Retry;
   8 class RetryableSendFailure;
   9 class PaymentSendFailure;
  10 class ProbeSendFailure;
  11 class RecipientOnionFields;
  12 class InvoiceWithExplicitSigningPubkeyBuilder;
  13 class InvoiceWithDerivedSigningPubkeyBuilder;
  14 class UnsignedBolt12Invoice;
  15 class SignBolt12InvoiceFn;
  16 class Bolt12Invoice;
  17 class BlindedPayInfo;
  18 class DelayedPaymentOutputDescriptor;
  19 class StaticPaymentOutputDescriptor;
  20 class SpendableOutputDescriptor;
  21 class ChannelDerivationParameters;
  22 class HTLCDescriptor;
  23 class ChannelSigner;
  24 class Recipient;
  25 class EntropySource;
  26 class NodeSigner;
  27 class OutputSpender;
  28 class SignerProvider;
  29 class ChangeDestinationSource;
  30 class InMemorySigner;
  31 class KeysManager;
  32 class PhantomKeysManager;
  33 class RandomBytes;
  34 class BackgroundProcessor;
  35 class GossipSync;
  36 class DefaultRouter;
  37 class Router;
  38 class ScorerAccountingForInFlightHtlcs;
  39 class InFlightHtlcs;
  40 class RouteHop;
  41 class BlindedTail;
  42 class Path;
  43 class Route;
  44 class RouteParameters;
  45 class PaymentParameters;
  46 class Payee;
  47 class RouteHint;
  48 class RouteHintHop;
  49 class FirstHopCandidate;
  50 class PublicHopCandidate;
  51 class PrivateHopCandidate;
  52 class BlindedPathCandidate;
  53 class OneHopBlindedPathCandidate;
  54 class CandidateRouteHop;
  55 class ScoreLookUp;
  56 class ScoreUpdate;
  57 class Score;
  58 class LockableScore;
  59 class WriteableScore;
  60 class MultiThreadedLockableScore;
  61 class MultiThreadedScoreLockRead;
  62 class MultiThreadedScoreLockWrite;
  63 class ChannelUsage;
  64 class FixedPenaltyScorer;
  65 class ProbabilisticScorer;
  66 class ProbabilisticScoringFeeParameters;
  67 class ProbabilisticScoringDecayParameters;
  68 class BestBlock;
  69 class Listen;
  70 class Confirm;
  71 class ChannelMonitorUpdateStatus;
  72 class Watch;
  73 class Filter;
  74 class WatchedOutput;
  75 class InitFeatures;
  76 class NodeFeatures;
  77 class ChannelFeatures;
  78 class Bolt11InvoiceFeatures;
  79 class OfferFeatures;
  80 class InvoiceRequestFeatures;
  81 class Bolt12InvoiceFeatures;
  82 class BlindedHopFeatures;
  83 class ChannelTypeFeatures;
  84 class OfferId;
  85 class OfferWithExplicitMetadataBuilder;
  86 class OfferWithDerivedMetadataBuilder;
  87 class Offer;
  88 class Amount;
  89 class Quantity;
  90 class NodeId;
  91 class NetworkGraph;
  92 class ReadOnlyNetworkGraph;
  93 class NetworkUpdate;
  94 class P2PGossipSync;
  95 class ChannelUpdateInfo;
  96 class ChannelInfo;
  97 class DirectedChannelInfo;
  98 class EffectiveCapacity;
  99 class RoutingFees;
 100 class NodeAnnouncementInfo;
 101 class NodeAlias;
 102 class NodeInfo;
 103 class ShortChannelIdError;
 104 class InboundHTLCErr;
 105 class AnchorDescriptor;
 106 class BumpTransactionEvent;
 107 class Input;
 108 class Utxo;
 109 class CoinSelection;
 110 class CoinSelectionSource;
 111 class WalletSource;
 112 class Wallet;
 113 class BumpTransactionEventHandler;
 114 class PendingHTLCRouting;
 115 class BlindedForward;
 116 class PendingHTLCInfo;
 117 class BlindedFailure;
 118 class FailureCode;
 119 class ChannelManager;
 120 class ChainParameters;
 121 class CounterpartyForwardingInfo;
 122 class ChannelCounterparty;
 123 class ChannelDetails;
 124 class ChannelShutdownState;
 125 class RecentPaymentDetails;
 126 class PhantomRouteHints;
 127 class ChannelManagerReadArgs;
 128 class ChannelHandshakeConfig;
 129 class ChannelHandshakeLimits;
 130 class MaxDustHTLCExposure;
 131 class ChannelConfig;
 132 class ChannelConfigUpdate;
 133 class UserConfig;
 134 class APIError;
 135 class TaggedHash;
 136 class SignError;
 137 class EcdsaChannelSigner;
 138 class WriteableEcdsaChannelSigner;
 139 class ChannelMonitorUpdate;
 140 class MonitorEvent;
 141 class HTLCUpdate;
 142 class Balance;
 143 class ChannelMonitor;
 144 class ExpandedKey;
 145 class CustomMessageHandler;
 146 class IgnoringMessageHandler;
 147 class ErroringMessageHandler;
 148 class MessageHandler;
 149 class SocketDescriptor;
 150 class PeerDetails;
 151 class PeerHandleError;
 152 class PeerManager;
 153 class GraphSyncError;
 154 class RapidGossipSync;
 155 class KVStore;
 156 class Persister;
 157 class MonitorUpdatingPersister;
 158 class InvoiceRequestWithExplicitPayerIdBuilder;
 159 class InvoiceRequestWithDerivedPayerIdBuilder;
 160 class UnsignedInvoiceRequest;
 161 class SignInvoiceRequestFn;
 162 class InvoiceRequest;
 163 class VerifiedInvoiceRequest;
 164 class InvoiceRequestFields;
 165 class DecodeError;
 166 class Init;
 167 class ErrorMessage;
 168 class WarningMessage;
 169 class Ping;
 170 class Pong;
 171 class CommonOpenChannelFields;
 172 class OpenChannel;
 173 class OpenChannelV2;
 174 class CommonAcceptChannelFields;
 175 class AcceptChannel;
 176 class AcceptChannelV2;
 177 class FundingCreated;
 178 class FundingSigned;
 179 class ChannelReady;
 180 class Stfu;
 181 class Splice;
 182 class SpliceAck;
 183 class SpliceLocked;
 184 class TxAddInput;
 185 class TxAddOutput;
 186 class TxRemoveInput;
 187 class TxRemoveOutput;
 188 class TxComplete;
 189 class TxSignatures;
 190 class TxInitRbf;
 191 class TxAckRbf;
 192 class TxAbort;
 193 class Shutdown;
 194 class ClosingSignedFeeRange;
 195 class ClosingSigned;
 196 class UpdateAddHTLC;
 197 class OnionMessage;
 198 class UpdateFulfillHTLC;
 199 class UpdateFailHTLC;
 200 class UpdateFailMalformedHTLC;
 201 class CommitmentSigned;
 202 class RevokeAndACK;
 203 class UpdateFee;
 204 class ChannelReestablish;
 205 class AnnouncementSignatures;
 206 class SocketAddress;
 207 class SocketAddressParseError;
 208 class UnsignedGossipMessage;
 209 class UnsignedNodeAnnouncement;
 210 class NodeAnnouncement;
 211 class UnsignedChannelAnnouncement;
 212 class ChannelAnnouncement;
 213 class UnsignedChannelUpdate;
 214 class ChannelUpdate;
 215 class QueryChannelRange;
 216 class ReplyChannelRange;
 217 class QueryShortChannelIds;
 218 class ReplyShortChannelIdsEnd;
 219 class GossipTimestampFilter;
 220 class ErrorAction;
 221 class LightningError;
 222 class CommitmentUpdate;
 223 class ChannelMessageHandler;
 224 class RoutingMessageHandler;
 225 class OnionMessageHandler;
 226 class FinalOnionHopData;
 227 class OnionPacket;
 228 class TrampolineOnionPacket;
 229 class Level;
 230 class Record;
 231 class Logger;
 232 class FutureCallback;
 233 class Future;
 234 class Sleeper;
 235 class OffersMessageHandler;
 236 class OffersMessage;
 237 class HTLCClaim;
 238 class CounterpartyCommitmentSecrets;
 239 class TxCreationKeys;
 240 class ChannelPublicKeys;
 241 class HTLCOutputInCommitment;
 242 class ChannelTransactionParameters;
 243 class CounterpartyChannelTransactionParameters;
 244 class DirectedChannelTransactionParameters;
 245 class HolderCommitmentTransaction;
 246 class BuiltCommitmentTransaction;
 247 class ClosingTransaction;
 248 class TrustedClosingTransaction;
 249 class CommitmentTransaction;
 250 class TrustedCommitmentTransaction;
 251 class ShutdownScript;
 252 class InvalidShutdownScript;
 253 class Bolt12ParseError;
 254 class Bolt12SemanticError;
 255 class BroadcasterInterface;
 256 class ConfirmationTarget;
 257 class FeeEstimator;
 258 class Packet;
 259 class ParsedOnionMessageContents;
 260 class OnionMessageContents;
 261 class PaymentPurpose;
 262 class ClaimedHTLC;
 263 class PathFailure;
 264 class ClosureReason;
 265 class HTLCDestination;
 266 class PaymentFailureReason;
 267 class Event;
 268 class MessageSendEvent;
 269 class MessageSendEventsProvider;
 270 class EventsProvider;
 271 class EventHandler;
 272 class Bolt11ParseError;
 273 class ParseOrSemanticError;
 274 class Bolt11Invoice;
 275 class SignedRawBolt11Invoice;
 276 class RawBolt11Invoice;
 277 class RawDataPart;
 278 class PositiveTimestamp;
 279 class SiPrefix;
 280 class Currency;
 281 class Sha256;
 282 class Description;
 283 class PayeePubKey;
 284 class ExpiryTime;
 285 class MinFinalCltvExpiryDelta;
 286 class Fallback;
 287 class Bolt11InvoiceSignature;
 288 class PrivateRoute;
 289 class CreationError;
 290 class Bolt11SemanticError;
 291 class SignOrCreationError;
 292 class OutPoint;
 293 class BigSize;
 294 class Hostname;
 295 class TransactionU16LenLimited;
 296 class UntrustedString;
 297 class PrintableString;
 298 class ChannelId;
 299 class CustomMessageReader;
 300 class Type;
 301 class ForwardNode;
 302 class ForwardTlvs;
 303 class ReceiveTlvs;
 304 class PaymentRelay;
 305 class PaymentConstraints;
 306 class PaymentContext;
 307 class UnknownPaymentContext;
 308 class Bolt12OfferContext;
 309 class Bolt12RefundContext;
 310 class UtxoLookupError;
 311 class UtxoResult;
 312 class UtxoLookup;
 313 class UtxoFuture;
 314 class OnionMessenger;
 315 class MessageRouter;
 316 class DefaultMessageRouter;
 317 class OnionMessagePath;
 318 class Destination;
 319 class SendSuccess;
 320 class SendError;
 321 class CustomOnionMessageHandler;
 322 class PeeledOnion;
 323 class FilesystemStore;
 324 class NextMessageHop;
 325 class BlindedPath;
 326 class IntroductionNode;
 327 class Direction;
 328 class NodeIdLookUp;
 329 class EmptyNodeIdLookUp;
 330 class BlindedHop;
 331 class InvoiceError;
 332 class ErroneousField;
 333 class TrackedSpendableOutput;
 334 class OutputSpendStatus;
 335 class OutputSweeper;
 336 class SpendingDelay;
 337 class DelayedPaymentBasepoint;
 338 class DelayedPaymentKey;
 339 class HtlcBasepoint;
 340 class HtlcKey;
 341 class RevocationBasepoint;
 342 class RevocationKey;
 343 class MonitorUpdateId;
 344 class Persist;
 345 class LockedChannelMonitor;
 346 class ChainMonitor;
 347 class CResult_HtlcKeyDecodeErrorZ;
 348 class CResult_TransactionU16LenLimitedNoneZ;
 349 class CVec_TrackedSpendableOutputZ;
 350 class CResult_LockedChannelMonitorNoneZ;
 351 class CVec_C2Tuple_BlindedPayInfoBlindedPathZZ;
 352 class CResult_PhantomRouteHintsDecodeErrorZ;
 353 class CResult_FundingCreatedDecodeErrorZ;
 354 class CVec_C2Tuple_u32TxOutZZ;
 355 class CResult_RetryDecodeErrorZ;
 356 class CResult_BlindedForwardDecodeErrorZ;
 357 class CResult_ChannelInfoDecodeErrorZ;
 358 class COption_PaymentContextZ;
 359 class COption_MaxDustHTLCExposureZ;
 360 class COption_OffersMessageZ;
 361 class CResult_CVec_u8ZPeerHandleErrorZ;
 362 class COption_NetworkUpdateZ;
 363 class COption_u64Z;
 364 class CResult_OnionPacketDecodeErrorZ;
 365 class CResult_GossipTimestampFilterDecodeErrorZ;
 366 class CResult_RouteHintDecodeErrorZ;
 367 class COption_FilterZ;
 368 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ;
 369 class COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ;
 370 class CResult_COption_APIErrorZDecodeErrorZ;
 371 class CVec_UpdateAddHTLCZ;
 372 class CResult_TxAbortDecodeErrorZ;
 373 class CResult_StaticPaymentOutputDescriptorDecodeErrorZ;
 374 class COption_u32Z;
 375 class CResult_RecipientOnionFieldsNoneZ;
 376 class C2Tuple__u1632_u1632Z;
 377 class CResult_CVec_StrZIOErrorZ;
 378 class COption_ECDSASignatureZ;
 379 class CResult_TransactionNoneZ;
 380 class CResult_ClosingSignedFeeRangeDecodeErrorZ;
 381 class CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ;
 382 class CResult_CommitmentSignedDecodeErrorZ;
 383 class CResult_CommitmentTransactionDecodeErrorZ;
 384 class CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ;
 385 class CResult_StfuDecodeErrorZ;
 386 class CResult_OpenChannelDecodeErrorZ;
 387 class CResult_ErrorMessageDecodeErrorZ;
 388 class COption_APIErrorZ;
 389 class CVec_PeerDetailsZ;
 390 class CResult_u64ShortChannelIdErrorZ;
 391 class CResult_QueryChannelRangeDecodeErrorZ;
 392 class CVec_InputZ;
 393 class CResult_ChannelFeaturesDecodeErrorZ;
 394 class CResult_ChannelReadyDecodeErrorZ;
 395 class CVec_TransactionZ;
 396 class CResult_UpdateFeeDecodeErrorZ;
 397 class CResult_NoneBolt11SemanticErrorZ;
 398 class CResult_RevocationBasepointDecodeErrorZ;
 399 class COption_OnionMessageContentsZ;
 400 class CResult_NoneRetryableSendFailureZ;
 401 class CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ;
 402 class CResult_NodeIdDecodeErrorZ;
 403 class CResult_boolLightningErrorZ;
 404 class CResult_ChannelShutdownStateDecodeErrorZ;
 405 class CResult_NodeAnnouncementInfoDecodeErrorZ;
 406 class CResult_InvoiceRequestBolt12SemanticErrorZ;
 407 class CResult_COption_NetworkUpdateZDecodeErrorZ;
 408 class CVec_UpdateFailMalformedHTLCZ;
 409 class CResult_ShutdownScriptNoneZ;
 410 class CResult_PendingHTLCInfoInboundHTLCErrZ;
 411 class CResult_PendingHTLCInfoDecodeErrorZ;
 412 class CResult_HTLCOutputInCommitmentDecodeErrorZ;
 413 class CResult_ShutdownScriptInvalidShutdownScriptZ;
 414 class COption_HTLCDestinationZ;
 415 class CVec_RouteHopZ;
 416 class C2Tuple_PublicKeyCVec_SocketAddressZZ;
 417 class CResult_CVec_UtxoZNoneZ;
 418 class CResult_CVec_u8ZIOErrorZ;
 419 class CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ;
 420 class CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ;
 421 class CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ;
 422 class C3Tuple_OffersMessageDestinationBlindedPathZ;
 423 class CVec_ThirtyTwoBytesZ;
 424 class CResult_ChannelMonitorUpdateStatusNoneZ;
 425 class CResult_ClosingSignedDecodeErrorZ;
 426 class CVec_CResult_NoneAPIErrorZZ;
 427 class CResult_SchnorrSignatureNoneZ;
 428 class CResult_CounterpartyCommitmentSecretsDecodeErrorZ;
 429 class CResult_HTLCDescriptorDecodeErrorZ;
 430 class CVec_RecentPaymentDetailsZ;
 431 class CVec_RouteHintHopZ;
 432 class CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ;
 433 class CResult_UntrustedStringDecodeErrorZ;
 434 class CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ;
 435 class CVec_U5Z;
 436 class CResult_PaymentParametersDecodeErrorZ;
 437 class C2Tuple_ThirtyTwoBytesChannelMonitorZ;
 438 class COption_U128Z;
 439 class CResult_DelayedPaymentBasepointDecodeErrorZ;
 440 class C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ;
 441 class CResult_TxAckRbfDecodeErrorZ;
 442 class CResult_Bolt11InvoiceBolt11SemanticErrorZ;
 443 class COption_UtxoLookupZ;
 444 class CResult_PongDecodeErrorZ;
 445 class CResult_UnsignedChannelAnnouncementDecodeErrorZ;
 446 class C2Tuple_OutPointCVec_MonitorUpdateIdZZ;
 447 class CResult_ChannelIdAPIErrorZ;
 448 class CResult_CVec_u8ZNoneZ;
 449 class CVec_C2Tuple_ChannelIdPublicKeyZZ;
 450 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ;
 451 class CResult_ChannelTransactionParametersDecodeErrorZ;
 452 class CResult_WriteableEcdsaChannelSignerDecodeErrorZ;
 453 class CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ;
 454 class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ;
 455 class CResult_InFlightHtlcsDecodeErrorZ;
 456 class CResult_COption_HTLCDestinationZDecodeErrorZ;
 457 class CResult_Bolt12OfferContextDecodeErrorZ;
 458 class CResult_ThirtyTwoBytesNoneZ;
 459 class C3Tuple_OnionMessageContentsDestinationBlindedPathZ;
 460 class C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ;
 461 class CResult_SendSuccessSendErrorZ;
 462 class CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ;
 463 class C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ;
 464 class CResult_BlindedHopDecodeErrorZ;
 465 class CResult_NoneLightningErrorZ;
 466 class CResult_FixedPenaltyScorerDecodeErrorZ;
 467 class CVec_BlindedPathZ;
 468 class CResult_NonePeerHandleErrorZ;
 469 class CResult_FinalOnionHopDataDecodeErrorZ;
 470 class CResult_TrustedCommitmentTransactionNoneZ;
 471 class CResult_COption_EventZDecodeErrorZ;
 472 class CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ;
 473 class CResult_PaymentFailureReasonDecodeErrorZ;
 474 class COption_SocketAddressZ;
 475 class CResult_COption_MonitorEventZDecodeErrorZ;
 476 class COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ;
 477 class CResult_DescriptionCreationErrorZ;
 478 class CResult_RoutingFeesDecodeErrorZ;
 479 class CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ;
 480 class CResult_PaymentRelayDecodeErrorZ;
 481 class CResult_QueryShortChannelIdsDecodeErrorZ;
 482 class CResult_VerifiedInvoiceRequestNoneZ;
 483 class CResult_UpdateAddHTLCDecodeErrorZ;
 484 class COption_MonitorEventZ;
 485 class COption_TypeZ;
 486 class CResult_COption_TypeZDecodeErrorZ;
 487 class CResult_COption_PathFailureZDecodeErrorZ;
 488 class CResult_Bolt11InvoiceSignOrCreationErrorZ;
 489 class CResult_UpdateFailHTLCDecodeErrorZ;
 490 class CResult_CVec_BlindedPathZNoneZ;
 491 class CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ;
 492 class CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ;
 493 class CResult_SpendableOutputDescriptorDecodeErrorZ;
 494 class CResult_RevokeAndACKDecodeErrorZ;
 495 class CResult_UnsignedChannelUpdateDecodeErrorZ;
 496 class CResult_PayeePubKeySecp256k1ErrorZ;
 497 class C2Tuple__u832u16Z;
 498 class COption_BigEndianScalarZ;
 499 class CVec_ChannelIdZ;
 500 class CResult_PublicKeySecp256k1ErrorZ;
 501 class CResult_CVec_ECDSASignatureZNoneZ;
 502 class CVec_BlindedHopZ;
 503 class CResult_COption_ClosureReasonZDecodeErrorZ;
 504 class CResult_InvoiceErrorDecodeErrorZ;
 505 class C2Tuple_BestBlockOutputSweeperZ;
 506 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
 507 class CResult_RouteParametersDecodeErrorZ;
 508 class CResult_PrivateRouteCreationErrorZ;
 509 class CResult_NodeAliasDecodeErrorZ;
 510 class CVec_UpdateFulfillHTLCZ;
 511 class CVec_C2Tuple_u32CVec_u8ZZZ;
 512 class C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ;
 513 class CResult_AnnouncementSignaturesDecodeErrorZ;
 514 class CResult_TxCompleteDecodeErrorZ;
 515 class CResult_UpdateFulfillHTLCDecodeErrorZ;
 516 class CResult_NodeFeaturesDecodeErrorZ;
 517 class CResult_InMemorySignerDecodeErrorZ;
 518 class CResult_TxSignaturesDecodeErrorZ;
 519 class CVec_HTLCDescriptorZ;
 520 class CResult_ReplyShortChannelIdsEndDecodeErrorZ;
 521 class COption_PathFailureZ;
 522 class CResult_StrSecp256k1ErrorZ;
 523 class CVec_ECDSASignatureZ;
 524 class CResult_ChannelUpdateInfoDecodeErrorZ;
 525 class CVec_UpdateFailHTLCZ;
 526 class CVec_TxOutZ;
 527 class CResult_BuiltCommitmentTransactionDecodeErrorZ;
 528 class CResult_TrackedSpendableOutputDecodeErrorZ;
 529 class CVec_SpendableOutputDescriptorZ;
 530 class C2Tuple_OutPointCVec_u8ZZ;
 531 class CResult_WitnessNoneZ;
 532 class COption_C2Tuple_u64u64ZZ;
 533 class CResult_ChannelAnnouncementDecodeErrorZ;
 534 class CResult_HTLCUpdateDecodeErrorZ;
 535 class CResult_TxAddInputDecodeErrorZ;
 536 class CResult_PeeledOnionNoneZ;
 537 class CResult_TxInitRbfDecodeErrorZ;
 538 class COption_WriteableScoreZ;
 539 class CVec_StrZ;
 540 class CResult_SpliceAckDecodeErrorZ;
 541 class CResult_PositiveTimestampCreationErrorZ;
 542 class CVec_C2Tuple_OutPointChannelIdZZ;
 543 class CResult_ChannelMonitorUpdateDecodeErrorZ;
 544 class C2Tuple_BlindedPayInfoBlindedPathZ;
 545 class CResult_ReplyChannelRangeDecodeErrorZ;
 546 class CResult_UnsignedNodeAnnouncementDecodeErrorZ;
 547 class CResult_TrustedClosingTransactionNoneZ;
 548 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ;
 549 class C2Tuple_PublicKeyTypeZ;
 550 class CResult_TxRemoveOutputDecodeErrorZ;
 551 class CResult_ChannelReestablishDecodeErrorZ;
 552 class CResult_OnionMessageDecodeErrorZ;
 553 class CResult_Bolt11InvoiceParseOrSemanticErrorZ;
 554 class CResult_InitFeaturesDecodeErrorZ;
 555 class CResult_PublicKeyNoneZ;
 556 class CResult_PingDecodeErrorZ;
 557 class CResult_RevocationKeyDecodeErrorZ;
 558 class CResult_ChannelIdDecodeErrorZ;
 559 class CResult_BlindedHopFeaturesDecodeErrorZ;
 560 class CVec_TransactionOutputsZ;
 561 class COption_HTLCClaimZ;
 562 class COption_boolZ;
 563 class COption_StrZ;
 564 class CResult_ProbabilisticScorerDecodeErrorZ;
 565 class CResult_ShutdownScriptDecodeErrorZ;
 566 class CResult_SiPrefixBolt11ParseErrorZ;
 567 class C2Tuple_usizeTransactionZ;
 568 class CResult_NodeAnnouncementDecodeErrorZ;
 569 class CVec_FutureZ;
 570 class CVec_ChannelMonitorZ;
 571 class CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ;
 572 class CResult_AcceptChannelV2DecodeErrorZ;
 573 class CResult_RouteHopDecodeErrorZ;
 574 class CResult_OfferIdDecodeErrorZ;
 575 class CVec_HTLCOutputInCommitmentZ;
 576 class CResult_CoinSelectionNoneZ;
 577 class CResult_TxCreationKeysDecodeErrorZ;
 578 class CResult_BlindedPathDecodeErrorZ;
 579 class CResult_RefundBolt12SemanticErrorZ;
 580 class CResult_NoneIOErrorZ;
 581 class CResult_MaxDustHTLCExposureDecodeErrorZ;
 582 class CVec_BalanceZ;
 583 class CVec_CommitmentTransactionZ;
 584 class CResult_FundingSignedDecodeErrorZ;
 585 class CResult_RecoverableSignatureNoneZ;
 586 class CResult_SocketAddressDecodeErrorZ;
 587 class C2Tuple_Z;
 588 class C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ;
 589 class CVec_PathZ;
 590 class CResult_NetworkGraphDecodeErrorZ;
 591 class CResult_NodeInfoDecodeErrorZ;
 592 class CVec_NodeIdZ;
 593 class CVec_u8Z;
 594 class CResult_RouteLightningErrorZ;
 595 class CResult_NonePaymentSendFailureZ;
 596 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ;
 597 class CResult_ChannelPublicKeysDecodeErrorZ;
 598 class CVec_ClaimedHTLCZ;
 599 class COption_CVec_ThirtyTwoBytesZZ;
 600 class CVec_SocketAddressZ;
 601 class CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ;
 602 class CResult_ThirtyTwoBytesPaymentSendFailureZ;
 603 class CResult_WarningMessageDecodeErrorZ;
 604 class CResult_ChannelCounterpartyDecodeErrorZ;
 605 class CResult_HolderCommitmentTransactionDecodeErrorZ;
 606 class CVec_ForwardNodeZ;
 607 class CResult_DelayedPaymentKeyDecodeErrorZ;
 608 class CResult_InitDecodeErrorZ;
 609 class CResult_OfferBolt12SemanticErrorZ;
 610 class CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ;
 611 class CResult_SpliceDecodeErrorZ;
 612 class CResult_PaymentPurposeDecodeErrorZ;
 613 class CResult_ClaimedHTLCDecodeErrorZ;
 614 class CResult_OutPointDecodeErrorZ;
 615 class CVec_ChannelDetailsZ;
 616 class C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ;
 617 class CResult_Bolt11InvoiceFeaturesDecodeErrorZ;
 618 class CVec_MessageSendEventZ;
 619 class CVec_MonitorUpdateIdZ;
 620 class CResult_RouteHintHopDecodeErrorZ;
 621 class CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ;
 622 class CResult_UpdateFailMalformedHTLCDecodeErrorZ;
 623 class CResult_BlindedPayInfoDecodeErrorZ;
 624 class CResult_ThirtyTwoBytesAPIErrorZ;
 625 class COption_ChannelShutdownStateZ;
 626 class CResult_Bolt12InvoiceBolt12SemanticErrorZ;
 627 class CResult_InvoiceRequestFieldsDecodeErrorZ;
 628 class CResult_AcceptChannelDecodeErrorZ;
 629 class CResult_HostnameDecodeErrorZ;
 630 class C2Tuple_u64u16Z;
 631 class COption_ThirtyTwoBytesZ;
 632 class CVec_u64Z;
 633 class CResult_NoneBolt12SemanticErrorZ;
 634 class COption_SecretKeyZ;
 635 class CResult_UnknownPaymentContextDecodeErrorZ;
 636 class CResult_OutputSweeperDecodeErrorZ;
 637 class CResult_C2Tuple_CVec_u8Zu64ZNoneZ;
 638 class COption_EventZ;
 639 class CResult_ChannelTypeFeaturesDecodeErrorZ;
 640 class COption_CVec_SocketAddressZZ;
 641 class CVec_RouteHintZ;
 642 class COption_u16Z;
 643 class COption_PaymentFailureReasonZ;
 644 class CResult_Bolt12RefundContextDecodeErrorZ;
 645 class CResult_ECDSASignatureNoneZ;
 646 class CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ;
 647 class C2Tuple_ChannelIdPublicKeyZ;
 648 class CVec_WitnessZ;
 649 class CResult_BlindedTailDecodeErrorZ;
 650 class CResult_SocketAddressSocketAddressParseErrorZ;
 651 class COption_C2Tuple_u64u16ZZ;
 652 class CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ;
 653 class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ;
 654 class CResult_ChannelDerivationParametersDecodeErrorZ;
 655 class CResult_PaymentConstraintsDecodeErrorZ;
 656 class CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ;
 657 class CResult_OnionMessagePathNoneZ;
 658 class C2Tuple_u32CVec_u8ZZ;
 659 class CVec_C2Tuple_PublicKeyTypeZZ;
 660 class CResult_RefundBolt12ParseErrorZ;
 661 class CResult_u32GraphSyncErrorZ;
 662 class CVec_C2Tuple_u64CVec_u8ZZZ;
 663 class CVec_PhantomRouteHintsZ;
 664 class CResult_OffersMessageDecodeErrorZ;
 665 class CResult_NoneAPIErrorZ;
 666 class CResult_Bolt12InvoiceFeaturesDecodeErrorZ;
 667 class COption_f64Z;
 668 class CResult_ChannelDetailsDecodeErrorZ;
 669 class CVec_PublicKeyZ;
 670 class C2Tuple_CVec_u8Zu64Z;
 671 class CVec_C2Tuple_usizeTransactionZZ;
 672 class CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ;
 673 class CResult_PendingHTLCRoutingDecodeErrorZ;
 674 class C2Tuple_u64u64Z;
 675 class CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ;
 676 class CResult_TxRemoveInputDecodeErrorZ;
 677 class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ;
 678 class CResult_RecipientOnionFieldsDecodeErrorZ;
 679 class C2Tuple_u32TxOutZ;
 680 class CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ;
 681 class CResult_PaymentContextDecodeErrorZ;
 682 class CVec_UtxoZ;
 683 class CResult_ChannelConfigDecodeErrorZ;
 684 class CVec_PrivateRouteZ;
 685 class COption_i64Z;
 686 class C2Tuple_ThirtyTwoBytesChannelManagerZ;
 687 class CResult_COption_OnionMessageContentsZDecodeErrorZ;
 688 class C2Tuple_u64CVec_u8ZZ;
 689 class CResult_OfferBolt12ParseErrorZ;
 690 class CResult_ThirtyTwoBytesRetryableSendFailureZ;
 691 class CVec_MonitorEventZ;
 692 class CResult_ShutdownDecodeErrorZ;
 693 class CResult_BigSizeDecodeErrorZ;
 694 class CResult_TxOutUtxoLookupErrorZ;
 695 class CResult_BlindedPathNoneZ;
 696 class COption_usizeZ;
 697 class CResult_NoneNoneZ;
 698 class CResult_boolPeerHandleErrorZ;
 699 class CResult_ChannelUpdateDecodeErrorZ;
 700 class CVec_APIErrorZ;
 701 class COption_TxOutZ;
 702 class COption_ClosureReasonZ;
 703 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ;
 704 class CResult_TransactionU16LenLimitedDecodeErrorZ;
 705 class COption_AmountZ;
 706 class CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ;
 707 class CResult_CounterpartyForwardingInfoDecodeErrorZ;
 708 class CResult_BestBlockDecodeErrorZ;
 709 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ;
 710 class CResult_OpenChannelV2DecodeErrorZ;
 711 class CResult_OutputSpendStatusDecodeErrorZ;
 712 class C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ;
 713 class CResult_RouteDecodeErrorZ;
 714 class CResult_BlindedFailureDecodeErrorZ;
 715 class CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ;
 716 class COption_NoneZ;
 717 class CResult_SpliceLockedDecodeErrorZ;
 718 class COption_CVec_u8ZZ;
 719 class COption_QuantityZ;
 720 class CResult_TxAddOutputDecodeErrorZ;
 721 class CResult_HtlcBasepointDecodeErrorZ;
 722 class C2Tuple_OutPointChannelIdZ;
 723
 724 class Str {
 725 private:
 726         LDKStr self;
 727 public:
 728         Str(const Str&) = delete;
 729         Str(Str&& o) : self(o.self) { memset(&o, 0, sizeof(Str)); }
 730         Str(LDKStr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStr)); }
 731         operator LDKStr() && { LDKStr res = self; memset(&self, 0, sizeof(LDKStr)); return res; }
 732         ~Str() { Str_free(self); }
 733         Str& operator=(Str&& o) { Str_free(self); self = o.self; memset(&o, 0, sizeof(Str)); return *this; }
 734         LDKStr* operator &() { return &self; }
 735         LDKStr* operator ->() { return &self; }
 736         const LDKStr* operator &() const { return &self; }
 737         const LDKStr* operator ->() const { return &self; }
 738 };
 739 class RefundMaybeWithDerivedMetadataBuilder {
 740 private:
 741         LDKRefundMaybeWithDerivedMetadataBuilder self;
 742 public:
 743         RefundMaybeWithDerivedMetadataBuilder(const RefundMaybeWithDerivedMetadataBuilder&) = delete;
 744         RefundMaybeWithDerivedMetadataBuilder(RefundMaybeWithDerivedMetadataBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(RefundMaybeWithDerivedMetadataBuilder)); }
 745         RefundMaybeWithDerivedMetadataBuilder(LDKRefundMaybeWithDerivedMetadataBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRefundMaybeWithDerivedMetadataBuilder)); }
 746         operator LDKRefundMaybeWithDerivedMetadataBuilder() && { LDKRefundMaybeWithDerivedMetadataBuilder res = self; memset(&self, 0, sizeof(LDKRefundMaybeWithDerivedMetadataBuilder)); return res; }
 747         ~RefundMaybeWithDerivedMetadataBuilder() { RefundMaybeWithDerivedMetadataBuilder_free(self); }
 748         RefundMaybeWithDerivedMetadataBuilder& operator=(RefundMaybeWithDerivedMetadataBuilder&& o) { RefundMaybeWithDerivedMetadataBuilder_free(self); self = o.self; memset(&o, 0, sizeof(RefundMaybeWithDerivedMetadataBuilder)); return *this; }
 749         LDKRefundMaybeWithDerivedMetadataBuilder* operator &() { return &self; }
 750         LDKRefundMaybeWithDerivedMetadataBuilder* operator ->() { return &self; }
 751         const LDKRefundMaybeWithDerivedMetadataBuilder* operator &() const { return &self; }
 752         const LDKRefundMaybeWithDerivedMetadataBuilder* operator ->() const { return &self; }
 753 };
 754 class Refund {
 755 private:
 756         LDKRefund self;
 757 public:
 758         Refund(const Refund&) = delete;
 759         Refund(Refund&& o) : self(o.self) { memset(&o, 0, sizeof(Refund)); }
 760         Refund(LDKRefund&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRefund)); }
 761         operator LDKRefund() && { LDKRefund res = self; memset(&self, 0, sizeof(LDKRefund)); return res; }
 762         ~Refund() { Refund_free(self); }
 763         Refund& operator=(Refund&& o) { Refund_free(self); self = o.self; memset(&o, 0, sizeof(Refund)); return *this; }
 764         LDKRefund* operator &() { return &self; }
 765         LDKRefund* operator ->() { return &self; }
 766         const LDKRefund* operator &() const { return &self; }
 767         const LDKRefund* operator ->() const { return &self; }
 768 };
 769 class Retry {
 770 private:
 771         LDKRetry self;
 772 public:
 773         Retry(const Retry&) = delete;
 774         Retry(Retry&& o) : self(o.self) { memset(&o, 0, sizeof(Retry)); }
 775         Retry(LDKRetry&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetry)); }
 776         operator LDKRetry() && { LDKRetry res = self; memset(&self, 0, sizeof(LDKRetry)); return res; }
 777         ~Retry() { Retry_free(self); }
 778         Retry& operator=(Retry&& o) { Retry_free(self); self = o.self; memset(&o, 0, sizeof(Retry)); return *this; }
 779         LDKRetry* operator &() { return &self; }
 780         LDKRetry* operator ->() { return &self; }
 781         const LDKRetry* operator &() const { return &self; }
 782         const LDKRetry* operator ->() const { return &self; }
 783 };
 784 class RetryableSendFailure {
 785 private:
 786         LDKRetryableSendFailure self;
 787 public:
 788         RetryableSendFailure(const RetryableSendFailure&) = delete;
 789         RetryableSendFailure(RetryableSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(RetryableSendFailure)); }
 790         RetryableSendFailure(LDKRetryableSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetryableSendFailure)); }
 791         operator LDKRetryableSendFailure() && { LDKRetryableSendFailure res = self; memset(&self, 0, sizeof(LDKRetryableSendFailure)); return res; }
 792         RetryableSendFailure& operator=(RetryableSendFailure&& o) { self = o.self; memset(&o, 0, sizeof(RetryableSendFailure)); return *this; }
 793         LDKRetryableSendFailure* operator &() { return &self; }
 794         LDKRetryableSendFailure* operator ->() { return &self; }
 795         const LDKRetryableSendFailure* operator &() const { return &self; }
 796         const LDKRetryableSendFailure* operator ->() const { return &self; }
 797 };
 798 class PaymentSendFailure {
 799 private:
 800         LDKPaymentSendFailure self;
 801 public:
 802         PaymentSendFailure(const PaymentSendFailure&) = delete;
 803         PaymentSendFailure(PaymentSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentSendFailure)); }
 804         PaymentSendFailure(LDKPaymentSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentSendFailure)); }
 805         operator LDKPaymentSendFailure() && { LDKPaymentSendFailure res = self; memset(&self, 0, sizeof(LDKPaymentSendFailure)); return res; }
 806         ~PaymentSendFailure() { PaymentSendFailure_free(self); }
 807         PaymentSendFailure& operator=(PaymentSendFailure&& o) { PaymentSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(PaymentSendFailure)); return *this; }
 808         LDKPaymentSendFailure* operator &() { return &self; }
 809         LDKPaymentSendFailure* operator ->() { return &self; }
 810         const LDKPaymentSendFailure* operator &() const { return &self; }
 811         const LDKPaymentSendFailure* operator ->() const { return &self; }
 812 };
 813 class ProbeSendFailure {
 814 private:
 815         LDKProbeSendFailure self;
 816 public:
 817         ProbeSendFailure(const ProbeSendFailure&) = delete;
 818         ProbeSendFailure(ProbeSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(ProbeSendFailure)); }
 819         ProbeSendFailure(LDKProbeSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbeSendFailure)); }
 820         operator LDKProbeSendFailure() && { LDKProbeSendFailure res = self; memset(&self, 0, sizeof(LDKProbeSendFailure)); return res; }
 821         ~ProbeSendFailure() { ProbeSendFailure_free(self); }
 822         ProbeSendFailure& operator=(ProbeSendFailure&& o) { ProbeSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(ProbeSendFailure)); return *this; }
 823         LDKProbeSendFailure* operator &() { return &self; }
 824         LDKProbeSendFailure* operator ->() { return &self; }
 825         const LDKProbeSendFailure* operator &() const { return &self; }
 826         const LDKProbeSendFailure* operator ->() const { return &self; }
 827 };
 828 class RecipientOnionFields {
 829 private:
 830         LDKRecipientOnionFields self;
 831 public:
 832         RecipientOnionFields(const RecipientOnionFields&) = delete;
 833         RecipientOnionFields(RecipientOnionFields&& o) : self(o.self) { memset(&o, 0, sizeof(RecipientOnionFields)); }
 834         RecipientOnionFields(LDKRecipientOnionFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecipientOnionFields)); }
 835         operator LDKRecipientOnionFields() && { LDKRecipientOnionFields res = self; memset(&self, 0, sizeof(LDKRecipientOnionFields)); return res; }
 836         ~RecipientOnionFields() { RecipientOnionFields_free(self); }
 837         RecipientOnionFields& operator=(RecipientOnionFields&& o) { RecipientOnionFields_free(self); self = o.self; memset(&o, 0, sizeof(RecipientOnionFields)); return *this; }
 838         LDKRecipientOnionFields* operator &() { return &self; }
 839         LDKRecipientOnionFields* operator ->() { return &self; }
 840         const LDKRecipientOnionFields* operator &() const { return &self; }
 841         const LDKRecipientOnionFields* operator ->() const { return &self; }
 842 };
 843 class InvoiceWithExplicitSigningPubkeyBuilder {
 844 private:
 845         LDKInvoiceWithExplicitSigningPubkeyBuilder self;
 846 public:
 847         InvoiceWithExplicitSigningPubkeyBuilder(const InvoiceWithExplicitSigningPubkeyBuilder&) = delete;
 848         InvoiceWithExplicitSigningPubkeyBuilder(InvoiceWithExplicitSigningPubkeyBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceWithExplicitSigningPubkeyBuilder)); }
 849         InvoiceWithExplicitSigningPubkeyBuilder(LDKInvoiceWithExplicitSigningPubkeyBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceWithExplicitSigningPubkeyBuilder)); }
 850         operator LDKInvoiceWithExplicitSigningPubkeyBuilder() && { LDKInvoiceWithExplicitSigningPubkeyBuilder res = self; memset(&self, 0, sizeof(LDKInvoiceWithExplicitSigningPubkeyBuilder)); return res; }
 851         ~InvoiceWithExplicitSigningPubkeyBuilder() { InvoiceWithExplicitSigningPubkeyBuilder_free(self); }
 852         InvoiceWithExplicitSigningPubkeyBuilder& operator=(InvoiceWithExplicitSigningPubkeyBuilder&& o) { InvoiceWithExplicitSigningPubkeyBuilder_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceWithExplicitSigningPubkeyBuilder)); return *this; }
 853         LDKInvoiceWithExplicitSigningPubkeyBuilder* operator &() { return &self; }
 854         LDKInvoiceWithExplicitSigningPubkeyBuilder* operator ->() { return &self; }
 855         const LDKInvoiceWithExplicitSigningPubkeyBuilder* operator &() const { return &self; }
 856         const LDKInvoiceWithExplicitSigningPubkeyBuilder* operator ->() const { return &self; }
 857 };
 858 class InvoiceWithDerivedSigningPubkeyBuilder {
 859 private:
 860         LDKInvoiceWithDerivedSigningPubkeyBuilder self;
 861 public:
 862         InvoiceWithDerivedSigningPubkeyBuilder(const InvoiceWithDerivedSigningPubkeyBuilder&) = delete;
 863         InvoiceWithDerivedSigningPubkeyBuilder(InvoiceWithDerivedSigningPubkeyBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceWithDerivedSigningPubkeyBuilder)); }
 864         InvoiceWithDerivedSigningPubkeyBuilder(LDKInvoiceWithDerivedSigningPubkeyBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceWithDerivedSigningPubkeyBuilder)); }
 865         operator LDKInvoiceWithDerivedSigningPubkeyBuilder() && { LDKInvoiceWithDerivedSigningPubkeyBuilder res = self; memset(&self, 0, sizeof(LDKInvoiceWithDerivedSigningPubkeyBuilder)); return res; }
 866         ~InvoiceWithDerivedSigningPubkeyBuilder() { InvoiceWithDerivedSigningPubkeyBuilder_free(self); }
 867         InvoiceWithDerivedSigningPubkeyBuilder& operator=(InvoiceWithDerivedSigningPubkeyBuilder&& o) { InvoiceWithDerivedSigningPubkeyBuilder_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceWithDerivedSigningPubkeyBuilder)); return *this; }
 868         LDKInvoiceWithDerivedSigningPubkeyBuilder* operator &() { return &self; }
 869         LDKInvoiceWithDerivedSigningPubkeyBuilder* operator ->() { return &self; }
 870         const LDKInvoiceWithDerivedSigningPubkeyBuilder* operator &() const { return &self; }
 871         const LDKInvoiceWithDerivedSigningPubkeyBuilder* operator ->() const { return &self; }
 872 };
 873 class UnsignedBolt12Invoice {
 874 private:
 875         LDKUnsignedBolt12Invoice self;
 876 public:
 877         UnsignedBolt12Invoice(const UnsignedBolt12Invoice&) = delete;
 878         UnsignedBolt12Invoice(UnsignedBolt12Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedBolt12Invoice)); }
 879         UnsignedBolt12Invoice(LDKUnsignedBolt12Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedBolt12Invoice)); }
 880         operator LDKUnsignedBolt12Invoice() && { LDKUnsignedBolt12Invoice res = self; memset(&self, 0, sizeof(LDKUnsignedBolt12Invoice)); return res; }
 881         ~UnsignedBolt12Invoice() { UnsignedBolt12Invoice_free(self); }
 882         UnsignedBolt12Invoice& operator=(UnsignedBolt12Invoice&& o) { UnsignedBolt12Invoice_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedBolt12Invoice)); return *this; }
 883         LDKUnsignedBolt12Invoice* operator &() { return &self; }
 884         LDKUnsignedBolt12Invoice* operator ->() { return &self; }
 885         const LDKUnsignedBolt12Invoice* operator &() const { return &self; }
 886         const LDKUnsignedBolt12Invoice* operator ->() const { return &self; }
 887 };
 888 class SignBolt12InvoiceFn {
 889 private:
 890         LDKSignBolt12InvoiceFn self;
 891 public:
 892         SignBolt12InvoiceFn(const SignBolt12InvoiceFn&) = delete;
 893         SignBolt12InvoiceFn(SignBolt12InvoiceFn&& o) : self(o.self) { memset(&o, 0, sizeof(SignBolt12InvoiceFn)); }
 894         SignBolt12InvoiceFn(LDKSignBolt12InvoiceFn&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignBolt12InvoiceFn)); }
 895         operator LDKSignBolt12InvoiceFn() && { LDKSignBolt12InvoiceFn res = self; memset(&self, 0, sizeof(LDKSignBolt12InvoiceFn)); return res; }
 896         ~SignBolt12InvoiceFn() { SignBolt12InvoiceFn_free(self); }
 897         SignBolt12InvoiceFn& operator=(SignBolt12InvoiceFn&& o) { SignBolt12InvoiceFn_free(self); self = o.self; memset(&o, 0, sizeof(SignBolt12InvoiceFn)); return *this; }
 898         LDKSignBolt12InvoiceFn* operator &() { return &self; }
 899         LDKSignBolt12InvoiceFn* operator ->() { return &self; }
 900         const LDKSignBolt12InvoiceFn* operator &() const { return &self; }
 901         const LDKSignBolt12InvoiceFn* operator ->() const { return &self; }
 902         /**
 903          *  Signs a [`TaggedHash`] computed over the merkle root of `message`'s TLV stream.
 904          */
 905         inline LDK::CResult_SchnorrSignatureNoneZ sign_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR message);
 906 };
 907 class Bolt12Invoice {
 908 private:
 909         LDKBolt12Invoice self;
 910 public:
 911         Bolt12Invoice(const Bolt12Invoice&) = delete;
 912         Bolt12Invoice(Bolt12Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12Invoice)); }
 913         Bolt12Invoice(LDKBolt12Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12Invoice)); }
 914         operator LDKBolt12Invoice() && { LDKBolt12Invoice res = self; memset(&self, 0, sizeof(LDKBolt12Invoice)); return res; }
 915         ~Bolt12Invoice() { Bolt12Invoice_free(self); }
 916         Bolt12Invoice& operator=(Bolt12Invoice&& o) { Bolt12Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12Invoice)); return *this; }
 917         LDKBolt12Invoice* operator &() { return &self; }
 918         LDKBolt12Invoice* operator ->() { return &self; }
 919         const LDKBolt12Invoice* operator &() const { return &self; }
 920         const LDKBolt12Invoice* operator ->() const { return &self; }
 921 };
 922 class BlindedPayInfo {
 923 private:
 924         LDKBlindedPayInfo self;
 925 public:
 926         BlindedPayInfo(const BlindedPayInfo&) = delete;
 927         BlindedPayInfo(BlindedPayInfo&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPayInfo)); }
 928         BlindedPayInfo(LDKBlindedPayInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPayInfo)); }
 929         operator LDKBlindedPayInfo() && { LDKBlindedPayInfo res = self; memset(&self, 0, sizeof(LDKBlindedPayInfo)); return res; }
 930         ~BlindedPayInfo() { BlindedPayInfo_free(self); }
 931         BlindedPayInfo& operator=(BlindedPayInfo&& o) { BlindedPayInfo_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPayInfo)); return *this; }
 932         LDKBlindedPayInfo* operator &() { return &self; }
 933         LDKBlindedPayInfo* operator ->() { return &self; }
 934         const LDKBlindedPayInfo* operator &() const { return &self; }
 935         const LDKBlindedPayInfo* operator ->() const { return &self; }
 936 };
 937 class DelayedPaymentOutputDescriptor {
 938 private:
 939         LDKDelayedPaymentOutputDescriptor self;
 940 public:
 941         DelayedPaymentOutputDescriptor(const DelayedPaymentOutputDescriptor&) = delete;
 942         DelayedPaymentOutputDescriptor(DelayedPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); }
 943         DelayedPaymentOutputDescriptor(LDKDelayedPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); }
 944         operator LDKDelayedPaymentOutputDescriptor() && { LDKDelayedPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); return res; }
 945         ~DelayedPaymentOutputDescriptor() { DelayedPaymentOutputDescriptor_free(self); }
 946         DelayedPaymentOutputDescriptor& operator=(DelayedPaymentOutputDescriptor&& o) { DelayedPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); return *this; }
 947         LDKDelayedPaymentOutputDescriptor* operator &() { return &self; }
 948         LDKDelayedPaymentOutputDescriptor* operator ->() { return &self; }
 949         const LDKDelayedPaymentOutputDescriptor* operator &() const { return &self; }
 950         const LDKDelayedPaymentOutputDescriptor* operator ->() const { return &self; }
 951 };
 952 class StaticPaymentOutputDescriptor {
 953 private:
 954         LDKStaticPaymentOutputDescriptor self;
 955 public:
 956         StaticPaymentOutputDescriptor(const StaticPaymentOutputDescriptor&) = delete;
 957         StaticPaymentOutputDescriptor(StaticPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); }
 958         StaticPaymentOutputDescriptor(LDKStaticPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); }
 959         operator LDKStaticPaymentOutputDescriptor() && { LDKStaticPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); return res; }
 960         ~StaticPaymentOutputDescriptor() { StaticPaymentOutputDescriptor_free(self); }
 961         StaticPaymentOutputDescriptor& operator=(StaticPaymentOutputDescriptor&& o) { StaticPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); return *this; }
 962         LDKStaticPaymentOutputDescriptor* operator &() { return &self; }
 963         LDKStaticPaymentOutputDescriptor* operator ->() { return &self; }
 964         const LDKStaticPaymentOutputDescriptor* operator &() const { return &self; }
 965         const LDKStaticPaymentOutputDescriptor* operator ->() const { return &self; }
 966 };
 967 class SpendableOutputDescriptor {
 968 private:
 969         LDKSpendableOutputDescriptor self;
 970 public:
 971         SpendableOutputDescriptor(const SpendableOutputDescriptor&) = delete;
 972         SpendableOutputDescriptor(SpendableOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SpendableOutputDescriptor)); }
 973         SpendableOutputDescriptor(LDKSpendableOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendableOutputDescriptor)); }
 974         operator LDKSpendableOutputDescriptor() && { LDKSpendableOutputDescriptor res = self; memset(&self, 0, sizeof(LDKSpendableOutputDescriptor)); return res; }
 975         ~SpendableOutputDescriptor() { SpendableOutputDescriptor_free(self); }
 976         SpendableOutputDescriptor& operator=(SpendableOutputDescriptor&& o) { SpendableOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SpendableOutputDescriptor)); return *this; }
 977         LDKSpendableOutputDescriptor* operator &() { return &self; }
 978         LDKSpendableOutputDescriptor* operator ->() { return &self; }
 979         const LDKSpendableOutputDescriptor* operator &() const { return &self; }
 980         const LDKSpendableOutputDescriptor* operator ->() const { return &self; }
 981 };
 982 class ChannelDerivationParameters {
 983 private:
 984         LDKChannelDerivationParameters self;
 985 public:
 986         ChannelDerivationParameters(const ChannelDerivationParameters&) = delete;
 987         ChannelDerivationParameters(ChannelDerivationParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDerivationParameters)); }
 988         ChannelDerivationParameters(LDKChannelDerivationParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDerivationParameters)); }
 989         operator LDKChannelDerivationParameters() && { LDKChannelDerivationParameters res = self; memset(&self, 0, sizeof(LDKChannelDerivationParameters)); return res; }
 990         ~ChannelDerivationParameters() { ChannelDerivationParameters_free(self); }
 991         ChannelDerivationParameters& operator=(ChannelDerivationParameters&& o) { ChannelDerivationParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDerivationParameters)); return *this; }
 992         LDKChannelDerivationParameters* operator &() { return &self; }
 993         LDKChannelDerivationParameters* operator ->() { return &self; }
 994         const LDKChannelDerivationParameters* operator &() const { return &self; }
 995         const LDKChannelDerivationParameters* operator ->() const { return &self; }
 996 };
 997 class HTLCDescriptor {
 998 private:
 999         LDKHTLCDescriptor self;
1000 public:
1001         HTLCDescriptor(const HTLCDescriptor&) = delete;
1002         HTLCDescriptor(HTLCDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCDescriptor)); }
1003         HTLCDescriptor(LDKHTLCDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCDescriptor)); }
1004         operator LDKHTLCDescriptor() && { LDKHTLCDescriptor res = self; memset(&self, 0, sizeof(LDKHTLCDescriptor)); return res; }
1005         ~HTLCDescriptor() { HTLCDescriptor_free(self); }
1006         HTLCDescriptor& operator=(HTLCDescriptor&& o) { HTLCDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(HTLCDescriptor)); return *this; }
1007         LDKHTLCDescriptor* operator &() { return &self; }
1008         LDKHTLCDescriptor* operator ->() { return &self; }
1009         const LDKHTLCDescriptor* operator &() const { return &self; }
1010         const LDKHTLCDescriptor* operator ->() const { return &self; }
1011 };
1012 class ChannelSigner {
1013 private:
1014         LDKChannelSigner self;
1015 public:
1016         ChannelSigner(const ChannelSigner&) = delete;
1017         ChannelSigner(ChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelSigner)); }
1018         ChannelSigner(LDKChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelSigner)); }
1019         operator LDKChannelSigner() && { LDKChannelSigner res = self; memset(&self, 0, sizeof(LDKChannelSigner)); return res; }
1020         ~ChannelSigner() { ChannelSigner_free(self); }
1021         ChannelSigner& operator=(ChannelSigner&& o) { ChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(ChannelSigner)); return *this; }
1022         LDKChannelSigner* operator &() { return &self; }
1023         LDKChannelSigner* operator ->() { return &self; }
1024         const LDKChannelSigner* operator &() const { return &self; }
1025         const LDKChannelSigner* operator ->() const { return &self; }
1026         /**
1027          *  Gets the per-commitment point for a specific commitment number
1028          *
1029          *  Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.
1030          */
1031         inline LDKPublicKey get_per_commitment_point(uint64_t idx);
1032         /**
1033          *  Gets the commitment secret for a specific commitment number as part of the revocation process
1034          *
1035          *  An external signer implementation should error here if the commitment was already signed
1036          *  and should refuse to sign it in the future.
1037          *
1038          *  May be called more than once for the same index.
1039          *
1040          *  Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.
1041          */
1042         inline LDKThirtyTwoBytes release_commitment_secret(uint64_t idx);
1043         /**
1044          *  Validate the counterparty's signatures on the holder commitment transaction and HTLCs.
1045          *
1046          *  This is required in order for the signer to make sure that releasing a commitment
1047          *  secret won't leave us without a broadcastable holder transaction.
1048          *  Policy checks should be implemented in this function, including checking the amount
1049          *  sent to us and checking the HTLCs.
1050          *
1051          *  The preimages of outbound HTLCs that were fulfilled since the last commitment are provided.
1052          *  A validating signer should ensure that an HTLC output is removed only when the matching
1053          *  preimage is provided, or when the value to holder is restored.
1054          *
1055          *  Note that all the relevant preimages will be provided, but there may also be additional
1056          *  irrelevant or duplicate preimages.
1057          */
1058         inline LDK::CResult_NoneNoneZ validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages);
1059         /**
1060          *  Validate the counterparty's revocation.
1061          *
1062          *  This is required in order for the signer to make sure that the state has moved
1063          *  forward and it is safe to sign the next counterparty commitment.
1064          */
1065         inline LDK::CResult_NoneNoneZ validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]);
1066         /**
1067          *  Returns an arbitrary identifier describing the set of keys which are provided back to you in
1068          *  some [`SpendableOutputDescriptor`] types. This should be sufficient to identify this
1069          *  [`EcdsaChannelSigner`] object uniquely and lookup or re-derive its keys.
1070          */
1071         inline LDKThirtyTwoBytes channel_keys_id();
1072         /**
1073          *  Set the counterparty static channel data, including basepoints,
1074          *  `counterparty_selected`/`holder_selected_contest_delay` and funding outpoint.
1075          *
1076          *  This data is static, and will never change for a channel once set. For a given [`ChannelSigner`]
1077          *  instance, LDK will call this method exactly once - either immediately after construction
1078          *  (not including if done via [`SignerProvider::read_chan_signer`]) or when the funding
1079          *  information has been generated.
1080          *
1081          *  channel_parameters.is_populated() MUST be true.
1082          */
1083         inline void provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters);
1084 };
1085 class Recipient {
1086 private:
1087         LDKRecipient self;
1088 public:
1089         Recipient(const Recipient&) = delete;
1090         Recipient(Recipient&& o) : self(o.self) { memset(&o, 0, sizeof(Recipient)); }
1091         Recipient(LDKRecipient&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecipient)); }
1092         operator LDKRecipient() && { LDKRecipient res = self; memset(&self, 0, sizeof(LDKRecipient)); return res; }
1093         Recipient& operator=(Recipient&& o) { self = o.self; memset(&o, 0, sizeof(Recipient)); return *this; }
1094         LDKRecipient* operator &() { return &self; }
1095         LDKRecipient* operator ->() { return &self; }
1096         const LDKRecipient* operator &() const { return &self; }
1097         const LDKRecipient* operator ->() const { return &self; }
1098 };
1099 class EntropySource {
1100 private:
1101         LDKEntropySource self;
1102 public:
1103         EntropySource(const EntropySource&) = delete;
1104         EntropySource(EntropySource&& o) : self(o.self) { memset(&o, 0, sizeof(EntropySource)); }
1105         EntropySource(LDKEntropySource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEntropySource)); }
1106         operator LDKEntropySource() && { LDKEntropySource res = self; memset(&self, 0, sizeof(LDKEntropySource)); return res; }
1107         ~EntropySource() { EntropySource_free(self); }
1108         EntropySource& operator=(EntropySource&& o) { EntropySource_free(self); self = o.self; memset(&o, 0, sizeof(EntropySource)); return *this; }
1109         LDKEntropySource* operator &() { return &self; }
1110         LDKEntropySource* operator ->() { return &self; }
1111         const LDKEntropySource* operator &() const { return &self; }
1112         const LDKEntropySource* operator ->() const { return &self; }
1113         /**
1114          *  Gets a unique, cryptographically-secure, random 32-byte value. This method must return a
1115          *  different value each time it is called.
1116          */
1117         inline LDKThirtyTwoBytes get_secure_random_bytes();
1118 };
1119 class NodeSigner {
1120 private:
1121         LDKNodeSigner self;
1122 public:
1123         NodeSigner(const NodeSigner&) = delete;
1124         NodeSigner(NodeSigner&& o) : self(o.self) { memset(&o, 0, sizeof(NodeSigner)); }
1125         NodeSigner(LDKNodeSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeSigner)); }
1126         operator LDKNodeSigner() && { LDKNodeSigner res = self; memset(&self, 0, sizeof(LDKNodeSigner)); return res; }
1127         ~NodeSigner() { NodeSigner_free(self); }
1128         NodeSigner& operator=(NodeSigner&& o) { NodeSigner_free(self); self = o.self; memset(&o, 0, sizeof(NodeSigner)); return *this; }
1129         LDKNodeSigner* operator &() { return &self; }
1130         LDKNodeSigner* operator ->() { return &self; }
1131         const LDKNodeSigner* operator &() const { return &self; }
1132         const LDKNodeSigner* operator ->() const { return &self; }
1133         /**
1134          *  Get secret key material as bytes for use in encrypting and decrypting inbound payment data.
1135          *
1136          *  If the implementor of this trait supports [phantom node payments], then every node that is
1137          *  intended to be included in the phantom invoice route hints must return the same value from
1138          *  this method.
1139          *
1140          *  This method must return the same value each time it is called.
1141          *
1142          *  [phantom node payments]: PhantomKeysManager
1143          */
1144         inline LDKThirtyTwoBytes get_inbound_payment_key_material();
1145         /**
1146          *  Get node id based on the provided [`Recipient`].
1147          *
1148          *  This method must return the same value each time it is called with a given [`Recipient`]
1149          *  parameter.
1150          *
1151          *  Errors if the [`Recipient`] variant is not supported by the implementation.
1152          */
1153         inline LDK::CResult_PublicKeyNoneZ get_node_id(enum LDKRecipient recipient);
1154         /**
1155          *  Gets the ECDH shared secret of our node secret and `other_key`, multiplying by `tweak` if
1156          *  one is provided. Note that this tweak can be applied to `other_key` instead of our node
1157          *  secret, though this is less efficient.
1158          *
1159          *  Note that if this fails while attempting to forward an HTLC, LDK will panic. The error
1160          *  should be resolved to allow LDK to resume forwarding HTLCs.
1161          *
1162          *  Errors if the [`Recipient`] variant is not supported by the implementation.
1163          */
1164         inline LDK::CResult_ThirtyTwoBytesNoneZ ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak);
1165         /**
1166          *  Sign an invoice.
1167          *
1168          *  By parameterizing by the raw invoice bytes instead of the hash, we allow implementors of
1169          *  this trait to parse the invoice and make sure they're signing what they expect, rather than
1170          *  blindly signing the hash.
1171          *
1172          *  The `hrp_bytes` are ASCII bytes, while the `invoice_data` is base32.
1173          *
1174          *  The secret key used to sign the invoice is dependent on the [`Recipient`].
1175          *
1176          *  Errors if the [`Recipient`] variant is not supported by the implementation.
1177          */
1178         inline LDK::CResult_RecoverableSignatureNoneZ sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient);
1179         /**
1180          *  Signs the [`TaggedHash`] of a BOLT 12 invoice request.
1181          *
1182          *  May be called by a function passed to [`UnsignedInvoiceRequest::sign`] where
1183          *  `invoice_request` is the callee.
1184          *
1185          *  Implementors may check that the `invoice_request` is expected rather than blindly signing
1186          *  the tagged hash. An `Ok` result should sign `invoice_request.tagged_hash().as_digest()` with
1187          *  the node's signing key or an ephemeral key to preserve privacy, whichever is associated with
1188          *  [`UnsignedInvoiceRequest::payer_id`].
1189          *
1190          *  [`TaggedHash`]: crate::offers::merkle::TaggedHash
1191          */
1192         inline LDK::CResult_SchnorrSignatureNoneZ sign_bolt12_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR invoice_request);
1193         /**
1194          *  Signs the [`TaggedHash`] of a BOLT 12 invoice.
1195          *
1196          *  May be called by a function passed to [`UnsignedBolt12Invoice::sign`] where `invoice` is the
1197          *  callee.
1198          *
1199          *  Implementors may check that the `invoice` is expected rather than blindly signing the tagged
1200          *  hash. An `Ok` result should sign `invoice.tagged_hash().as_digest()` with the node's signing
1201          *  key or an ephemeral key to preserve privacy, whichever is associated with
1202          *  [`UnsignedBolt12Invoice::signing_pubkey`].
1203          *
1204          *  [`TaggedHash`]: crate::offers::merkle::TaggedHash
1205          */
1206         inline LDK::CResult_SchnorrSignatureNoneZ sign_bolt12_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR invoice);
1207         /**
1208          *  Sign a gossip message.
1209          *
1210          *  Note that if this fails, LDK may panic and the message will not be broadcast to the network
1211          *  or a possible channel counterparty. If LDK panics, the error should be resolved to allow the
1212          *  message to be broadcast, as otherwise it may prevent one from receiving funds over the
1213          *  corresponding channel.
1214          */
1215         inline LDK::CResult_ECDSASignatureNoneZ sign_gossip_message(struct LDKUnsignedGossipMessage msg);
1216 };
1217 class OutputSpender {
1218 private:
1219         LDKOutputSpender self;
1220 public:
1221         OutputSpender(const OutputSpender&) = delete;
1222         OutputSpender(OutputSpender&& o) : self(o.self) { memset(&o, 0, sizeof(OutputSpender)); }
1223         OutputSpender(LDKOutputSpender&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutputSpender)); }
1224         operator LDKOutputSpender() && { LDKOutputSpender res = self; memset(&self, 0, sizeof(LDKOutputSpender)); return res; }
1225         ~OutputSpender() { OutputSpender_free(self); }
1226         OutputSpender& operator=(OutputSpender&& o) { OutputSpender_free(self); self = o.self; memset(&o, 0, sizeof(OutputSpender)); return *this; }
1227         LDKOutputSpender* operator &() { return &self; }
1228         LDKOutputSpender* operator ->() { return &self; }
1229         const LDKOutputSpender* operator &() const { return &self; }
1230         const LDKOutputSpender* operator ->() const { return &self; }
1231         /**
1232          *  Creates a [`Transaction`] which spends the given descriptors to the given outputs, plus an
1233          *  output to the given change destination (if sufficient change value remains). The
1234          *  transaction will have a feerate, at least, of the given value.
1235          *
1236          *  The `locktime` argument is used to set the transaction's locktime. If `None`, the
1237          *  transaction will have a locktime of 0. It it recommended to set this to the current block
1238          *  height to avoid fee sniping, unless you have some specific reason to use a different
1239          *  locktime.
1240          *
1241          *  Returns `Err(())` if the output value is greater than the input value minus required fee,
1242          *  if a descriptor was duplicated, or if an output descriptor `script_pubkey`
1243          *  does not match the one we can spend.
1244          */
1245         inline LDK::CResult_TransactionNoneZ spend_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ descriptors, struct LDKCVec_TxOutZ outputs, struct LDKCVec_u8Z change_destination_script, uint32_t feerate_sat_per_1000_weight, struct LDKCOption_u32Z locktime);
1246 };
1247 class SignerProvider {
1248 private:
1249         LDKSignerProvider self;
1250 public:
1251         SignerProvider(const SignerProvider&) = delete;
1252         SignerProvider(SignerProvider&& o) : self(o.self) { memset(&o, 0, sizeof(SignerProvider)); }
1253         SignerProvider(LDKSignerProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignerProvider)); }
1254         operator LDKSignerProvider() && { LDKSignerProvider res = self; memset(&self, 0, sizeof(LDKSignerProvider)); return res; }
1255         ~SignerProvider() { SignerProvider_free(self); }
1256         SignerProvider& operator=(SignerProvider&& o) { SignerProvider_free(self); self = o.self; memset(&o, 0, sizeof(SignerProvider)); return *this; }
1257         LDKSignerProvider* operator &() { return &self; }
1258         LDKSignerProvider* operator ->() { return &self; }
1259         const LDKSignerProvider* operator &() const { return &self; }
1260         const LDKSignerProvider* operator ->() const { return &self; }
1261         /**
1262          *  Generates a unique `channel_keys_id` that can be used to obtain a [`Self::EcdsaSigner`] through
1263          *  [`SignerProvider::derive_channel_signer`]. The `user_channel_id` is provided to allow
1264          *  implementations of [`SignerProvider`] to maintain a mapping between itself and the generated
1265          *  `channel_keys_id`.
1266          *
1267          *  This method must return a different value each time it is called.
1268          */
1269         inline LDKThirtyTwoBytes generate_channel_keys_id(bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id);
1270         /**
1271          *  Derives the private key material backing a `Signer`.
1272          *
1273          *  To derive a new `Signer`, a fresh `channel_keys_id` should be obtained through
1274          *  [`SignerProvider::generate_channel_keys_id`]. Otherwise, an existing `Signer` can be
1275          *  re-derived from its `channel_keys_id`, which can be obtained through its trait method
1276          *  [`ChannelSigner::channel_keys_id`].
1277          */
1278         inline LDK::WriteableEcdsaChannelSigner derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id);
1279         /**
1280          *  Reads a [`Signer`] for this [`SignerProvider`] from the given input stream.
1281          *  This is only called during deserialization of other objects which contain
1282          *  [`WriteableEcdsaChannelSigner`]-implementing objects (i.e., [`ChannelMonitor`]s and [`ChannelManager`]s).
1283          *  The bytes are exactly those which `<Self::Signer as Writeable>::write()` writes, and
1284          *  contain no versioning scheme. You may wish to include your own version prefix and ensure
1285          *  you've read all of the provided bytes to ensure no corruption occurred.
1286          *
1287          *  This method is slowly being phased out -- it will only be called when reading objects
1288          *  written by LDK versions prior to 0.0.113.
1289          *
1290          *  [`Signer`]: Self::EcdsaSigner
1291          *  [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
1292          *  [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
1293          */
1294         inline LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ read_chan_signer(struct LDKu8slice reader);
1295         /**
1296          *  Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
1297          *
1298          *  If this function returns an error, this will result in a channel failing to open.
1299          *
1300          *  This method should return a different value each time it is called, to avoid linking
1301          *  on-chain funds across channels as controlled to the same user. `channel_keys_id` may be
1302          *  used to derive a unique value for each channel.
1303          */
1304         inline LDK::CResult_CVec_u8ZNoneZ get_destination_script(struct LDKThirtyTwoBytes channel_keys_id);
1305         /**
1306          *  Get a script pubkey which we will send funds to when closing a channel.
1307          *
1308          *  If this function returns an error, this will result in a channel failing to open or close.
1309          *  In the event of a failure when the counterparty is initiating a close, this can result in a
1310          *  channel force close.
1311          *
1312          *  This method should return a different value each time it is called, to avoid linking
1313          *  on-chain funds across channels as controlled to the same user.
1314          */
1315         inline LDK::CResult_ShutdownScriptNoneZ get_shutdown_scriptpubkey();
1316 };
1317 class ChangeDestinationSource {
1318 private:
1319         LDKChangeDestinationSource self;
1320 public:
1321         ChangeDestinationSource(const ChangeDestinationSource&) = delete;
1322         ChangeDestinationSource(ChangeDestinationSource&& o) : self(o.self) { memset(&o, 0, sizeof(ChangeDestinationSource)); }
1323         ChangeDestinationSource(LDKChangeDestinationSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChangeDestinationSource)); }
1324         operator LDKChangeDestinationSource() && { LDKChangeDestinationSource res = self; memset(&self, 0, sizeof(LDKChangeDestinationSource)); return res; }
1325         ~ChangeDestinationSource() { ChangeDestinationSource_free(self); }
1326         ChangeDestinationSource& operator=(ChangeDestinationSource&& o) { ChangeDestinationSource_free(self); self = o.self; memset(&o, 0, sizeof(ChangeDestinationSource)); return *this; }
1327         LDKChangeDestinationSource* operator &() { return &self; }
1328         LDKChangeDestinationSource* operator ->() { return &self; }
1329         const LDKChangeDestinationSource* operator &() const { return &self; }
1330         const LDKChangeDestinationSource* operator ->() const { return &self; }
1331         /**
1332          *  Returns a script pubkey which can be used as a change destination for
1333          *  [`OutputSpender::spend_spendable_outputs`].
1334          *
1335          *  This method should return a different value each time it is called, to avoid linking
1336          *  on-chain funds controlled to the same user.
1337          */
1338         inline LDK::CResult_CVec_u8ZNoneZ get_change_destination_script();
1339 };
1340 class InMemorySigner {
1341 private:
1342         LDKInMemorySigner self;
1343 public:
1344         InMemorySigner(const InMemorySigner&) = delete;
1345         InMemorySigner(InMemorySigner&& o) : self(o.self) { memset(&o, 0, sizeof(InMemorySigner)); }
1346         InMemorySigner(LDKInMemorySigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInMemorySigner)); }
1347         operator LDKInMemorySigner() && { LDKInMemorySigner res = self; memset(&self, 0, sizeof(LDKInMemorySigner)); return res; }
1348         ~InMemorySigner() { InMemorySigner_free(self); }
1349         InMemorySigner& operator=(InMemorySigner&& o) { InMemorySigner_free(self); self = o.self; memset(&o, 0, sizeof(InMemorySigner)); return *this; }
1350         LDKInMemorySigner* operator &() { return &self; }
1351         LDKInMemorySigner* operator ->() { return &self; }
1352         const LDKInMemorySigner* operator &() const { return &self; }
1353         const LDKInMemorySigner* operator ->() const { return &self; }
1354 };
1355 class KeysManager {
1356 private:
1357         LDKKeysManager self;
1358 public:
1359         KeysManager(const KeysManager&) = delete;
1360         KeysManager(KeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(KeysManager)); }
1361         KeysManager(LDKKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysManager)); }
1362         operator LDKKeysManager() && { LDKKeysManager res = self; memset(&self, 0, sizeof(LDKKeysManager)); return res; }
1363         ~KeysManager() { KeysManager_free(self); }
1364         KeysManager& operator=(KeysManager&& o) { KeysManager_free(self); self = o.self; memset(&o, 0, sizeof(KeysManager)); return *this; }
1365         LDKKeysManager* operator &() { return &self; }
1366         LDKKeysManager* operator ->() { return &self; }
1367         const LDKKeysManager* operator &() const { return &self; }
1368         const LDKKeysManager* operator ->() const { return &self; }
1369 };
1370 class PhantomKeysManager {
1371 private:
1372         LDKPhantomKeysManager self;
1373 public:
1374         PhantomKeysManager(const PhantomKeysManager&) = delete;
1375         PhantomKeysManager(PhantomKeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomKeysManager)); }
1376         PhantomKeysManager(LDKPhantomKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomKeysManager)); }
1377         operator LDKPhantomKeysManager() && { LDKPhantomKeysManager res = self; memset(&self, 0, sizeof(LDKPhantomKeysManager)); return res; }
1378         ~PhantomKeysManager() { PhantomKeysManager_free(self); }
1379         PhantomKeysManager& operator=(PhantomKeysManager&& o) { PhantomKeysManager_free(self); self = o.self; memset(&o, 0, sizeof(PhantomKeysManager)); return *this; }
1380         LDKPhantomKeysManager* operator &() { return &self; }
1381         LDKPhantomKeysManager* operator ->() { return &self; }
1382         const LDKPhantomKeysManager* operator &() const { return &self; }
1383         const LDKPhantomKeysManager* operator ->() const { return &self; }
1384 };
1385 class RandomBytes {
1386 private:
1387         LDKRandomBytes self;
1388 public:
1389         RandomBytes(const RandomBytes&) = delete;
1390         RandomBytes(RandomBytes&& o) : self(o.self) { memset(&o, 0, sizeof(RandomBytes)); }
1391         RandomBytes(LDKRandomBytes&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRandomBytes)); }
1392         operator LDKRandomBytes() && { LDKRandomBytes res = self; memset(&self, 0, sizeof(LDKRandomBytes)); return res; }
1393         ~RandomBytes() { RandomBytes_free(self); }
1394         RandomBytes& operator=(RandomBytes&& o) { RandomBytes_free(self); self = o.self; memset(&o, 0, sizeof(RandomBytes)); return *this; }
1395         LDKRandomBytes* operator &() { return &self; }
1396         LDKRandomBytes* operator ->() { return &self; }
1397         const LDKRandomBytes* operator &() const { return &self; }
1398         const LDKRandomBytes* operator ->() const { return &self; }
1399 };
1400 class BackgroundProcessor {
1401 private:
1402         LDKBackgroundProcessor self;
1403 public:
1404         BackgroundProcessor(const BackgroundProcessor&) = delete;
1405         BackgroundProcessor(BackgroundProcessor&& o) : self(o.self) { memset(&o, 0, sizeof(BackgroundProcessor)); }
1406         BackgroundProcessor(LDKBackgroundProcessor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBackgroundProcessor)); }
1407         operator LDKBackgroundProcessor() && { LDKBackgroundProcessor res = self; memset(&self, 0, sizeof(LDKBackgroundProcessor)); return res; }
1408         ~BackgroundProcessor() { BackgroundProcessor_free(self); }
1409         BackgroundProcessor& operator=(BackgroundProcessor&& o) { BackgroundProcessor_free(self); self = o.self; memset(&o, 0, sizeof(BackgroundProcessor)); return *this; }
1410         LDKBackgroundProcessor* operator &() { return &self; }
1411         LDKBackgroundProcessor* operator ->() { return &self; }
1412         const LDKBackgroundProcessor* operator &() const { return &self; }
1413         const LDKBackgroundProcessor* operator ->() const { return &self; }
1414 };
1415 class GossipSync {
1416 private:
1417         LDKGossipSync self;
1418 public:
1419         GossipSync(const GossipSync&) = delete;
1420         GossipSync(GossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(GossipSync)); }
1421         GossipSync(LDKGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipSync)); }
1422         operator LDKGossipSync() && { LDKGossipSync res = self; memset(&self, 0, sizeof(LDKGossipSync)); return res; }
1423         ~GossipSync() { GossipSync_free(self); }
1424         GossipSync& operator=(GossipSync&& o) { GossipSync_free(self); self = o.self; memset(&o, 0, sizeof(GossipSync)); return *this; }
1425         LDKGossipSync* operator &() { return &self; }
1426         LDKGossipSync* operator ->() { return &self; }
1427         const LDKGossipSync* operator &() const { return &self; }
1428         const LDKGossipSync* operator ->() const { return &self; }
1429 };
1430 class DefaultRouter {
1431 private:
1432         LDKDefaultRouter self;
1433 public:
1434         DefaultRouter(const DefaultRouter&) = delete;
1435         DefaultRouter(DefaultRouter&& o) : self(o.self) { memset(&o, 0, sizeof(DefaultRouter)); }
1436         DefaultRouter(LDKDefaultRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDefaultRouter)); }
1437         operator LDKDefaultRouter() && { LDKDefaultRouter res = self; memset(&self, 0, sizeof(LDKDefaultRouter)); return res; }
1438         ~DefaultRouter() { DefaultRouter_free(self); }
1439         DefaultRouter& operator=(DefaultRouter&& o) { DefaultRouter_free(self); self = o.self; memset(&o, 0, sizeof(DefaultRouter)); return *this; }
1440         LDKDefaultRouter* operator &() { return &self; }
1441         LDKDefaultRouter* operator ->() { return &self; }
1442         const LDKDefaultRouter* operator &() const { return &self; }
1443         const LDKDefaultRouter* operator ->() const { return &self; }
1444 };
1445 class Router {
1446 private:
1447         LDKRouter self;
1448 public:
1449         Router(const Router&) = delete;
1450         Router(Router&& o) : self(o.self) { memset(&o, 0, sizeof(Router)); }
1451         Router(LDKRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouter)); }
1452         operator LDKRouter() && { LDKRouter res = self; memset(&self, 0, sizeof(LDKRouter)); return res; }
1453         ~Router() { Router_free(self); }
1454         Router& operator=(Router&& o) { Router_free(self); self = o.self; memset(&o, 0, sizeof(Router)); return *this; }
1455         LDKRouter* operator &() { return &self; }
1456         LDKRouter* operator ->() { return &self; }
1457         const LDKRouter* operator &() const { return &self; }
1458         const LDKRouter* operator ->() const { return &self; }
1459         /**
1460          *  Finds a [`Route`] for a payment between the given `payer` and a payee.
1461          *
1462          *  The `payee` and the payment's value are given in [`RouteParameters::payment_params`]
1463          *  and [`RouteParameters::final_value_msat`], respectively.
1464          *
1465          *  Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
1466          */
1467         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);
1468         /**
1469          *  Finds a [`Route`] for a payment between the given `payer` and a payee.
1470          *
1471          *  The `payee` and the payment's value are given in [`RouteParameters::payment_params`]
1472          *  and [`RouteParameters::final_value_msat`], respectively.
1473          *
1474          *  Includes a [`PaymentHash`] and a [`PaymentId`] to be able to correlate the request with a specific
1475          *  payment.
1476          *
1477          *  Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
1478          */
1479         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);
1480         /**
1481          *  Creates [`BlindedPath`]s for payment to the `recipient` node. The channels in `first_hops`
1482          *  are assumed to be with the `recipient`'s peers. The payment secret and any constraints are
1483          *  given in `tlvs`.
1484          */
1485         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);
1486 };
1487 class ScorerAccountingForInFlightHtlcs {
1488 private:
1489         LDKScorerAccountingForInFlightHtlcs self;
1490 public:
1491         ScorerAccountingForInFlightHtlcs(const ScorerAccountingForInFlightHtlcs&) = delete;
1492         ScorerAccountingForInFlightHtlcs(ScorerAccountingForInFlightHtlcs&& o) : self(o.self) { memset(&o, 0, sizeof(ScorerAccountingForInFlightHtlcs)); }
1493         ScorerAccountingForInFlightHtlcs(LDKScorerAccountingForInFlightHtlcs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScorerAccountingForInFlightHtlcs)); }
1494         operator LDKScorerAccountingForInFlightHtlcs() && { LDKScorerAccountingForInFlightHtlcs res = self; memset(&self, 0, sizeof(LDKScorerAccountingForInFlightHtlcs)); return res; }
1495         ~ScorerAccountingForInFlightHtlcs() { ScorerAccountingForInFlightHtlcs_free(self); }
1496         ScorerAccountingForInFlightHtlcs& operator=(ScorerAccountingForInFlightHtlcs&& o) { ScorerAccountingForInFlightHtlcs_free(self); self = o.self; memset(&o, 0, sizeof(ScorerAccountingForInFlightHtlcs)); return *this; }
1497         LDKScorerAccountingForInFlightHtlcs* operator &() { return &self; }
1498         LDKScorerAccountingForInFlightHtlcs* operator ->() { return &self; }
1499         const LDKScorerAccountingForInFlightHtlcs* operator &() const { return &self; }
1500         const LDKScorerAccountingForInFlightHtlcs* operator ->() const { return &self; }
1501 };
1502 class InFlightHtlcs {
1503 private:
1504         LDKInFlightHtlcs self;
1505 public:
1506         InFlightHtlcs(const InFlightHtlcs&) = delete;
1507         InFlightHtlcs(InFlightHtlcs&& o) : self(o.self) { memset(&o, 0, sizeof(InFlightHtlcs)); }
1508         InFlightHtlcs(LDKInFlightHtlcs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInFlightHtlcs)); }
1509         operator LDKInFlightHtlcs() && { LDKInFlightHtlcs res = self; memset(&self, 0, sizeof(LDKInFlightHtlcs)); return res; }
1510         ~InFlightHtlcs() { InFlightHtlcs_free(self); }
1511         InFlightHtlcs& operator=(InFlightHtlcs&& o) { InFlightHtlcs_free(self); self = o.self; memset(&o, 0, sizeof(InFlightHtlcs)); return *this; }
1512         LDKInFlightHtlcs* operator &() { return &self; }
1513         LDKInFlightHtlcs* operator ->() { return &self; }
1514         const LDKInFlightHtlcs* operator &() const { return &self; }
1515         const LDKInFlightHtlcs* operator ->() const { return &self; }
1516 };
1517 class RouteHop {
1518 private:
1519         LDKRouteHop self;
1520 public:
1521         RouteHop(const RouteHop&) = delete;
1522         RouteHop(RouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHop)); }
1523         RouteHop(LDKRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHop)); }
1524         operator LDKRouteHop() && { LDKRouteHop res = self; memset(&self, 0, sizeof(LDKRouteHop)); return res; }
1525         ~RouteHop() { RouteHop_free(self); }
1526         RouteHop& operator=(RouteHop&& o) { RouteHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHop)); return *this; }
1527         LDKRouteHop* operator &() { return &self; }
1528         LDKRouteHop* operator ->() { return &self; }
1529         const LDKRouteHop* operator &() const { return &self; }
1530         const LDKRouteHop* operator ->() const { return &self; }
1531 };
1532 class BlindedTail {
1533 private:
1534         LDKBlindedTail self;
1535 public:
1536         BlindedTail(const BlindedTail&) = delete;
1537         BlindedTail(BlindedTail&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedTail)); }
1538         BlindedTail(LDKBlindedTail&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedTail)); }
1539         operator LDKBlindedTail() && { LDKBlindedTail res = self; memset(&self, 0, sizeof(LDKBlindedTail)); return res; }
1540         ~BlindedTail() { BlindedTail_free(self); }
1541         BlindedTail& operator=(BlindedTail&& o) { BlindedTail_free(self); self = o.self; memset(&o, 0, sizeof(BlindedTail)); return *this; }
1542         LDKBlindedTail* operator &() { return &self; }
1543         LDKBlindedTail* operator ->() { return &self; }
1544         const LDKBlindedTail* operator &() const { return &self; }
1545         const LDKBlindedTail* operator ->() const { return &self; }
1546 };
1547 class Path {
1548 private:
1549         LDKPath self;
1550 public:
1551         Path(const Path&) = delete;
1552         Path(Path&& o) : self(o.self) { memset(&o, 0, sizeof(Path)); }
1553         Path(LDKPath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPath)); }
1554         operator LDKPath() && { LDKPath res = self; memset(&self, 0, sizeof(LDKPath)); return res; }
1555         ~Path() { Path_free(self); }
1556         Path& operator=(Path&& o) { Path_free(self); self = o.self; memset(&o, 0, sizeof(Path)); return *this; }
1557         LDKPath* operator &() { return &self; }
1558         LDKPath* operator ->() { return &self; }
1559         const LDKPath* operator &() const { return &self; }
1560         const LDKPath* operator ->() const { return &self; }
1561 };
1562 class Route {
1563 private:
1564         LDKRoute self;
1565 public:
1566         Route(const Route&) = delete;
1567         Route(Route&& o) : self(o.self) { memset(&o, 0, sizeof(Route)); }
1568         Route(LDKRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoute)); }
1569         operator LDKRoute() && { LDKRoute res = self; memset(&self, 0, sizeof(LDKRoute)); return res; }
1570         ~Route() { Route_free(self); }
1571         Route& operator=(Route&& o) { Route_free(self); self = o.self; memset(&o, 0, sizeof(Route)); return *this; }
1572         LDKRoute* operator &() { return &self; }
1573         LDKRoute* operator ->() { return &self; }
1574         const LDKRoute* operator &() const { return &self; }
1575         const LDKRoute* operator ->() const { return &self; }
1576 };
1577 class RouteParameters {
1578 private:
1579         LDKRouteParameters self;
1580 public:
1581         RouteParameters(const RouteParameters&) = delete;
1582         RouteParameters(RouteParameters&& o) : self(o.self) { memset(&o, 0, sizeof(RouteParameters)); }
1583         RouteParameters(LDKRouteParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteParameters)); }
1584         operator LDKRouteParameters() && { LDKRouteParameters res = self; memset(&self, 0, sizeof(LDKRouteParameters)); return res; }
1585         ~RouteParameters() { RouteParameters_free(self); }
1586         RouteParameters& operator=(RouteParameters&& o) { RouteParameters_free(self); self = o.self; memset(&o, 0, sizeof(RouteParameters)); return *this; }
1587         LDKRouteParameters* operator &() { return &self; }
1588         LDKRouteParameters* operator ->() { return &self; }
1589         const LDKRouteParameters* operator &() const { return &self; }
1590         const LDKRouteParameters* operator ->() const { return &self; }
1591 };
1592 class PaymentParameters {
1593 private:
1594         LDKPaymentParameters self;
1595 public:
1596         PaymentParameters(const PaymentParameters&) = delete;
1597         PaymentParameters(PaymentParameters&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentParameters)); }
1598         PaymentParameters(LDKPaymentParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentParameters)); }
1599         operator LDKPaymentParameters() && { LDKPaymentParameters res = self; memset(&self, 0, sizeof(LDKPaymentParameters)); return res; }
1600         ~PaymentParameters() { PaymentParameters_free(self); }
1601         PaymentParameters& operator=(PaymentParameters&& o) { PaymentParameters_free(self); self = o.self; memset(&o, 0, sizeof(PaymentParameters)); return *this; }
1602         LDKPaymentParameters* operator &() { return &self; }
1603         LDKPaymentParameters* operator ->() { return &self; }
1604         const LDKPaymentParameters* operator &() const { return &self; }
1605         const LDKPaymentParameters* operator ->() const { return &self; }
1606 };
1607 class Payee {
1608 private:
1609         LDKPayee self;
1610 public:
1611         Payee(const Payee&) = delete;
1612         Payee(Payee&& o) : self(o.self) { memset(&o, 0, sizeof(Payee)); }
1613         Payee(LDKPayee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayee)); }
1614         operator LDKPayee() && { LDKPayee res = self; memset(&self, 0, sizeof(LDKPayee)); return res; }
1615         ~Payee() { Payee_free(self); }
1616         Payee& operator=(Payee&& o) { Payee_free(self); self = o.self; memset(&o, 0, sizeof(Payee)); return *this; }
1617         LDKPayee* operator &() { return &self; }
1618         LDKPayee* operator ->() { return &self; }
1619         const LDKPayee* operator &() const { return &self; }
1620         const LDKPayee* operator ->() const { return &self; }
1621 };
1622 class RouteHint {
1623 private:
1624         LDKRouteHint self;
1625 public:
1626         RouteHint(const RouteHint&) = delete;
1627         RouteHint(RouteHint&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHint)); }
1628         RouteHint(LDKRouteHint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHint)); }
1629         operator LDKRouteHint() && { LDKRouteHint res = self; memset(&self, 0, sizeof(LDKRouteHint)); return res; }
1630         ~RouteHint() { RouteHint_free(self); }
1631         RouteHint& operator=(RouteHint&& o) { RouteHint_free(self); self = o.self; memset(&o, 0, sizeof(RouteHint)); return *this; }
1632         LDKRouteHint* operator &() { return &self; }
1633         LDKRouteHint* operator ->() { return &self; }
1634         const LDKRouteHint* operator &() const { return &self; }
1635         const LDKRouteHint* operator ->() const { return &self; }
1636 };
1637 class RouteHintHop {
1638 private:
1639         LDKRouteHintHop self;
1640 public:
1641         RouteHintHop(const RouteHintHop&) = delete;
1642         RouteHintHop(RouteHintHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHintHop)); }
1643         RouteHintHop(LDKRouteHintHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHintHop)); }
1644         operator LDKRouteHintHop() && { LDKRouteHintHop res = self; memset(&self, 0, sizeof(LDKRouteHintHop)); return res; }
1645         ~RouteHintHop() { RouteHintHop_free(self); }
1646         RouteHintHop& operator=(RouteHintHop&& o) { RouteHintHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHintHop)); return *this; }
1647         LDKRouteHintHop* operator &() { return &self; }
1648         LDKRouteHintHop* operator ->() { return &self; }
1649         const LDKRouteHintHop* operator &() const { return &self; }
1650         const LDKRouteHintHop* operator ->() const { return &self; }
1651 };
1652 class FirstHopCandidate {
1653 private:
1654         LDKFirstHopCandidate self;
1655 public:
1656         FirstHopCandidate(const FirstHopCandidate&) = delete;
1657         FirstHopCandidate(FirstHopCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(FirstHopCandidate)); }
1658         FirstHopCandidate(LDKFirstHopCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFirstHopCandidate)); }
1659         operator LDKFirstHopCandidate() && { LDKFirstHopCandidate res = self; memset(&self, 0, sizeof(LDKFirstHopCandidate)); return res; }
1660         ~FirstHopCandidate() { FirstHopCandidate_free(self); }
1661         FirstHopCandidate& operator=(FirstHopCandidate&& o) { FirstHopCandidate_free(self); self = o.self; memset(&o, 0, sizeof(FirstHopCandidate)); return *this; }
1662         LDKFirstHopCandidate* operator &() { return &self; }
1663         LDKFirstHopCandidate* operator ->() { return &self; }
1664         const LDKFirstHopCandidate* operator &() const { return &self; }
1665         const LDKFirstHopCandidate* operator ->() const { return &self; }
1666 };
1667 class PublicHopCandidate {
1668 private:
1669         LDKPublicHopCandidate self;
1670 public:
1671         PublicHopCandidate(const PublicHopCandidate&) = delete;
1672         PublicHopCandidate(PublicHopCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(PublicHopCandidate)); }
1673         PublicHopCandidate(LDKPublicHopCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPublicHopCandidate)); }
1674         operator LDKPublicHopCandidate() && { LDKPublicHopCandidate res = self; memset(&self, 0, sizeof(LDKPublicHopCandidate)); return res; }
1675         ~PublicHopCandidate() { PublicHopCandidate_free(self); }
1676         PublicHopCandidate& operator=(PublicHopCandidate&& o) { PublicHopCandidate_free(self); self = o.self; memset(&o, 0, sizeof(PublicHopCandidate)); return *this; }
1677         LDKPublicHopCandidate* operator &() { return &self; }
1678         LDKPublicHopCandidate* operator ->() { return &self; }
1679         const LDKPublicHopCandidate* operator &() const { return &self; }
1680         const LDKPublicHopCandidate* operator ->() const { return &self; }
1681 };
1682 class PrivateHopCandidate {
1683 private:
1684         LDKPrivateHopCandidate self;
1685 public:
1686         PrivateHopCandidate(const PrivateHopCandidate&) = delete;
1687         PrivateHopCandidate(PrivateHopCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(PrivateHopCandidate)); }
1688         PrivateHopCandidate(LDKPrivateHopCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrivateHopCandidate)); }
1689         operator LDKPrivateHopCandidate() && { LDKPrivateHopCandidate res = self; memset(&self, 0, sizeof(LDKPrivateHopCandidate)); return res; }
1690         ~PrivateHopCandidate() { PrivateHopCandidate_free(self); }
1691         PrivateHopCandidate& operator=(PrivateHopCandidate&& o) { PrivateHopCandidate_free(self); self = o.self; memset(&o, 0, sizeof(PrivateHopCandidate)); return *this; }
1692         LDKPrivateHopCandidate* operator &() { return &self; }
1693         LDKPrivateHopCandidate* operator ->() { return &self; }
1694         const LDKPrivateHopCandidate* operator &() const { return &self; }
1695         const LDKPrivateHopCandidate* operator ->() const { return &self; }
1696 };
1697 class BlindedPathCandidate {
1698 private:
1699         LDKBlindedPathCandidate self;
1700 public:
1701         BlindedPathCandidate(const BlindedPathCandidate&) = delete;
1702         BlindedPathCandidate(BlindedPathCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPathCandidate)); }
1703         BlindedPathCandidate(LDKBlindedPathCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPathCandidate)); }
1704         operator LDKBlindedPathCandidate() && { LDKBlindedPathCandidate res = self; memset(&self, 0, sizeof(LDKBlindedPathCandidate)); return res; }
1705         ~BlindedPathCandidate() { BlindedPathCandidate_free(self); }
1706         BlindedPathCandidate& operator=(BlindedPathCandidate&& o) { BlindedPathCandidate_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPathCandidate)); return *this; }
1707         LDKBlindedPathCandidate* operator &() { return &self; }
1708         LDKBlindedPathCandidate* operator ->() { return &self; }
1709         const LDKBlindedPathCandidate* operator &() const { return &self; }
1710         const LDKBlindedPathCandidate* operator ->() const { return &self; }
1711 };
1712 class OneHopBlindedPathCandidate {
1713 private:
1714         LDKOneHopBlindedPathCandidate self;
1715 public:
1716         OneHopBlindedPathCandidate(const OneHopBlindedPathCandidate&) = delete;
1717         OneHopBlindedPathCandidate(OneHopBlindedPathCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(OneHopBlindedPathCandidate)); }
1718         OneHopBlindedPathCandidate(LDKOneHopBlindedPathCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOneHopBlindedPathCandidate)); }
1719         operator LDKOneHopBlindedPathCandidate() && { LDKOneHopBlindedPathCandidate res = self; memset(&self, 0, sizeof(LDKOneHopBlindedPathCandidate)); return res; }
1720         ~OneHopBlindedPathCandidate() { OneHopBlindedPathCandidate_free(self); }
1721         OneHopBlindedPathCandidate& operator=(OneHopBlindedPathCandidate&& o) { OneHopBlindedPathCandidate_free(self); self = o.self; memset(&o, 0, sizeof(OneHopBlindedPathCandidate)); return *this; }
1722         LDKOneHopBlindedPathCandidate* operator &() { return &self; }
1723         LDKOneHopBlindedPathCandidate* operator ->() { return &self; }
1724         const LDKOneHopBlindedPathCandidate* operator &() const { return &self; }
1725         const LDKOneHopBlindedPathCandidate* operator ->() const { return &self; }
1726 };
1727 class CandidateRouteHop {
1728 private:
1729         LDKCandidateRouteHop self;
1730 public:
1731         CandidateRouteHop(const CandidateRouteHop&) = delete;
1732         CandidateRouteHop(CandidateRouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(CandidateRouteHop)); }
1733         CandidateRouteHop(LDKCandidateRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCandidateRouteHop)); }
1734         operator LDKCandidateRouteHop() && { LDKCandidateRouteHop res = self; memset(&self, 0, sizeof(LDKCandidateRouteHop)); return res; }
1735         ~CandidateRouteHop() { CandidateRouteHop_free(self); }
1736         CandidateRouteHop& operator=(CandidateRouteHop&& o) { CandidateRouteHop_free(self); self = o.self; memset(&o, 0, sizeof(CandidateRouteHop)); return *this; }
1737         LDKCandidateRouteHop* operator &() { return &self; }
1738         LDKCandidateRouteHop* operator ->() { return &self; }
1739         const LDKCandidateRouteHop* operator &() const { return &self; }
1740         const LDKCandidateRouteHop* operator ->() const { return &self; }
1741 };
1742 class ScoreLookUp {
1743 private:
1744         LDKScoreLookUp self;
1745 public:
1746         ScoreLookUp(const ScoreLookUp&) = delete;
1747         ScoreLookUp(ScoreLookUp&& o) : self(o.self) { memset(&o, 0, sizeof(ScoreLookUp)); }
1748         ScoreLookUp(LDKScoreLookUp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScoreLookUp)); }
1749         operator LDKScoreLookUp() && { LDKScoreLookUp res = self; memset(&self, 0, sizeof(LDKScoreLookUp)); return res; }
1750         ~ScoreLookUp() { ScoreLookUp_free(self); }
1751         ScoreLookUp& operator=(ScoreLookUp&& o) { ScoreLookUp_free(self); self = o.self; memset(&o, 0, sizeof(ScoreLookUp)); return *this; }
1752         LDKScoreLookUp* operator &() { return &self; }
1753         LDKScoreLookUp* operator ->() { return &self; }
1754         const LDKScoreLookUp* operator &() const { return &self; }
1755         const LDKScoreLookUp* operator ->() const { return &self; }
1756         /**
1757          *  Returns the fee in msats willing to be paid to avoid routing `send_amt_msat` through the
1758          *  given channel in the direction from `source` to `target`.
1759          *
1760          *  The channel's capacity (less any other MPP parts that are also being considered for use in
1761          *  the same payment) is given by `capacity_msat`. It may be determined from various sources
1762          *  such as a chain data, network gossip, or invoice hints. For invoice hints, a capacity near
1763          *  [`u64::max_value`] is given to indicate sufficient capacity for the invoice's full amount.
1764          *  Thus, implementations should be overflow-safe.
1765          */
1766         inline uint64_t channel_penalty_msat(const struct LDKCandidateRouteHop *NONNULL_PTR candidate, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params);
1767 };
1768 class ScoreUpdate {
1769 private:
1770         LDKScoreUpdate self;
1771 public:
1772         ScoreUpdate(const ScoreUpdate&) = delete;
1773         ScoreUpdate(ScoreUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ScoreUpdate)); }
1774         ScoreUpdate(LDKScoreUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScoreUpdate)); }
1775         operator LDKScoreUpdate() && { LDKScoreUpdate res = self; memset(&self, 0, sizeof(LDKScoreUpdate)); return res; }
1776         ~ScoreUpdate() { ScoreUpdate_free(self); }
1777         ScoreUpdate& operator=(ScoreUpdate&& o) { ScoreUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ScoreUpdate)); return *this; }
1778         LDKScoreUpdate* operator &() { return &self; }
1779         LDKScoreUpdate* operator ->() { return &self; }
1780         const LDKScoreUpdate* operator &() const { return &self; }
1781         const LDKScoreUpdate* operator ->() const { return &self; }
1782         /**
1783          *  Handles updating channel penalties after failing to route through a channel.
1784          */
1785         inline void payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch);
1786         /**
1787          *  Handles updating channel penalties after successfully routing along a path.
1788          */
1789         inline void payment_path_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch);
1790         /**
1791          *  Handles updating channel penalties after a probe over the given path failed.
1792          */
1793         inline void probe_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch);
1794         /**
1795          *  Handles updating channel penalties after a probe over the given path succeeded.
1796          */
1797         inline void probe_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch);
1798         /**
1799          *  Scorers may wish to reduce their certainty of channel liquidity information over time.
1800          *  Thus, this method is provided to allow scorers to observe the passage of time - the holder
1801          *  of this object should call this method regularly (generally via the
1802          *  `lightning-background-processor` crate).
1803          */
1804         inline void time_passed(uint64_t duration_since_epoch);
1805 };
1806 class Score {
1807 private:
1808         LDKScore self;
1809 public:
1810         Score(const Score&) = delete;
1811         Score(Score&& o) : self(o.self) { memset(&o, 0, sizeof(Score)); }
1812         Score(LDKScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScore)); }
1813         operator LDKScore() && { LDKScore res = self; memset(&self, 0, sizeof(LDKScore)); return res; }
1814         ~Score() { Score_free(self); }
1815         Score& operator=(Score&& o) { Score_free(self); self = o.self; memset(&o, 0, sizeof(Score)); return *this; }
1816         LDKScore* operator &() { return &self; }
1817         LDKScore* operator ->() { return &self; }
1818         const LDKScore* operator &() const { return &self; }
1819         const LDKScore* operator ->() const { return &self; }
1820 };
1821 class LockableScore {
1822 private:
1823         LDKLockableScore self;
1824 public:
1825         LockableScore(const LockableScore&) = delete;
1826         LockableScore(LockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(LockableScore)); }
1827         LockableScore(LDKLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockableScore)); }
1828         operator LDKLockableScore() && { LDKLockableScore res = self; memset(&self, 0, sizeof(LDKLockableScore)); return res; }
1829         ~LockableScore() { LockableScore_free(self); }
1830         LockableScore& operator=(LockableScore&& o) { LockableScore_free(self); self = o.self; memset(&o, 0, sizeof(LockableScore)); return *this; }
1831         LDKLockableScore* operator &() { return &self; }
1832         LDKLockableScore* operator ->() { return &self; }
1833         const LDKLockableScore* operator &() const { return &self; }
1834         const LDKLockableScore* operator ->() const { return &self; }
1835         /**
1836          *  Returns read locked scorer.
1837          */
1838         inline LDK::ScoreLookUp read_lock();
1839         /**
1840          *  Returns write locked scorer.
1841          */
1842         inline LDK::ScoreUpdate write_lock();
1843 };
1844 class WriteableScore {
1845 private:
1846         LDKWriteableScore self;
1847 public:
1848         WriteableScore(const WriteableScore&) = delete;
1849         WriteableScore(WriteableScore&& o) : self(o.self) { memset(&o, 0, sizeof(WriteableScore)); }
1850         WriteableScore(LDKWriteableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWriteableScore)); }
1851         operator LDKWriteableScore() && { LDKWriteableScore res = self; memset(&self, 0, sizeof(LDKWriteableScore)); return res; }
1852         ~WriteableScore() { WriteableScore_free(self); }
1853         WriteableScore& operator=(WriteableScore&& o) { WriteableScore_free(self); self = o.self; memset(&o, 0, sizeof(WriteableScore)); return *this; }
1854         LDKWriteableScore* operator &() { return &self; }
1855         LDKWriteableScore* operator ->() { return &self; }
1856         const LDKWriteableScore* operator &() const { return &self; }
1857         const LDKWriteableScore* operator ->() const { return &self; }
1858 };
1859 class MultiThreadedLockableScore {
1860 private:
1861         LDKMultiThreadedLockableScore self;
1862 public:
1863         MultiThreadedLockableScore(const MultiThreadedLockableScore&) = delete;
1864         MultiThreadedLockableScore(MultiThreadedLockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedLockableScore)); }
1865         MultiThreadedLockableScore(LDKMultiThreadedLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedLockableScore)); }
1866         operator LDKMultiThreadedLockableScore() && { LDKMultiThreadedLockableScore res = self; memset(&self, 0, sizeof(LDKMultiThreadedLockableScore)); return res; }
1867         ~MultiThreadedLockableScore() { MultiThreadedLockableScore_free(self); }
1868         MultiThreadedLockableScore& operator=(MultiThreadedLockableScore&& o) { MultiThreadedLockableScore_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedLockableScore)); return *this; }
1869         LDKMultiThreadedLockableScore* operator &() { return &self; }
1870         LDKMultiThreadedLockableScore* operator ->() { return &self; }
1871         const LDKMultiThreadedLockableScore* operator &() const { return &self; }
1872         const LDKMultiThreadedLockableScore* operator ->() const { return &self; }
1873 };
1874 class MultiThreadedScoreLockRead {
1875 private:
1876         LDKMultiThreadedScoreLockRead self;
1877 public:
1878         MultiThreadedScoreLockRead(const MultiThreadedScoreLockRead&) = delete;
1879         MultiThreadedScoreLockRead(MultiThreadedScoreLockRead&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedScoreLockRead)); }
1880         MultiThreadedScoreLockRead(LDKMultiThreadedScoreLockRead&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedScoreLockRead)); }
1881         operator LDKMultiThreadedScoreLockRead() && { LDKMultiThreadedScoreLockRead res = self; memset(&self, 0, sizeof(LDKMultiThreadedScoreLockRead)); return res; }
1882         ~MultiThreadedScoreLockRead() { MultiThreadedScoreLockRead_free(self); }
1883         MultiThreadedScoreLockRead& operator=(MultiThreadedScoreLockRead&& o) { MultiThreadedScoreLockRead_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedScoreLockRead)); return *this; }
1884         LDKMultiThreadedScoreLockRead* operator &() { return &self; }
1885         LDKMultiThreadedScoreLockRead* operator ->() { return &self; }
1886         const LDKMultiThreadedScoreLockRead* operator &() const { return &self; }
1887         const LDKMultiThreadedScoreLockRead* operator ->() const { return &self; }
1888 };
1889 class MultiThreadedScoreLockWrite {
1890 private:
1891         LDKMultiThreadedScoreLockWrite self;
1892 public:
1893         MultiThreadedScoreLockWrite(const MultiThreadedScoreLockWrite&) = delete;
1894         MultiThreadedScoreLockWrite(MultiThreadedScoreLockWrite&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedScoreLockWrite)); }
1895         MultiThreadedScoreLockWrite(LDKMultiThreadedScoreLockWrite&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedScoreLockWrite)); }
1896         operator LDKMultiThreadedScoreLockWrite() && { LDKMultiThreadedScoreLockWrite res = self; memset(&self, 0, sizeof(LDKMultiThreadedScoreLockWrite)); return res; }
1897         ~MultiThreadedScoreLockWrite() { MultiThreadedScoreLockWrite_free(self); }
1898         MultiThreadedScoreLockWrite& operator=(MultiThreadedScoreLockWrite&& o) { MultiThreadedScoreLockWrite_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedScoreLockWrite)); return *this; }
1899         LDKMultiThreadedScoreLockWrite* operator &() { return &self; }
1900         LDKMultiThreadedScoreLockWrite* operator ->() { return &self; }
1901         const LDKMultiThreadedScoreLockWrite* operator &() const { return &self; }
1902         const LDKMultiThreadedScoreLockWrite* operator ->() const { return &self; }
1903 };
1904 class ChannelUsage {
1905 private:
1906         LDKChannelUsage self;
1907 public:
1908         ChannelUsage(const ChannelUsage&) = delete;
1909         ChannelUsage(ChannelUsage&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUsage)); }
1910         ChannelUsage(LDKChannelUsage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUsage)); }
1911         operator LDKChannelUsage() && { LDKChannelUsage res = self; memset(&self, 0, sizeof(LDKChannelUsage)); return res; }
1912         ~ChannelUsage() { ChannelUsage_free(self); }
1913         ChannelUsage& operator=(ChannelUsage&& o) { ChannelUsage_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUsage)); return *this; }
1914         LDKChannelUsage* operator &() { return &self; }
1915         LDKChannelUsage* operator ->() { return &self; }
1916         const LDKChannelUsage* operator &() const { return &self; }
1917         const LDKChannelUsage* operator ->() const { return &self; }
1918 };
1919 class FixedPenaltyScorer {
1920 private:
1921         LDKFixedPenaltyScorer self;
1922 public:
1923         FixedPenaltyScorer(const FixedPenaltyScorer&) = delete;
1924         FixedPenaltyScorer(FixedPenaltyScorer&& o) : self(o.self) { memset(&o, 0, sizeof(FixedPenaltyScorer)); }
1925         FixedPenaltyScorer(LDKFixedPenaltyScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFixedPenaltyScorer)); }
1926         operator LDKFixedPenaltyScorer() && { LDKFixedPenaltyScorer res = self; memset(&self, 0, sizeof(LDKFixedPenaltyScorer)); return res; }
1927         ~FixedPenaltyScorer() { FixedPenaltyScorer_free(self); }
1928         FixedPenaltyScorer& operator=(FixedPenaltyScorer&& o) { FixedPenaltyScorer_free(self); self = o.self; memset(&o, 0, sizeof(FixedPenaltyScorer)); return *this; }
1929         LDKFixedPenaltyScorer* operator &() { return &self; }
1930         LDKFixedPenaltyScorer* operator ->() { return &self; }
1931         const LDKFixedPenaltyScorer* operator &() const { return &self; }
1932         const LDKFixedPenaltyScorer* operator ->() const { return &self; }
1933 };
1934 class ProbabilisticScorer {
1935 private:
1936         LDKProbabilisticScorer self;
1937 public:
1938         ProbabilisticScorer(const ProbabilisticScorer&) = delete;
1939         ProbabilisticScorer(ProbabilisticScorer&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScorer)); }
1940         ProbabilisticScorer(LDKProbabilisticScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScorer)); }
1941         operator LDKProbabilisticScorer() && { LDKProbabilisticScorer res = self; memset(&self, 0, sizeof(LDKProbabilisticScorer)); return res; }
1942         ~ProbabilisticScorer() { ProbabilisticScorer_free(self); }
1943         ProbabilisticScorer& operator=(ProbabilisticScorer&& o) { ProbabilisticScorer_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScorer)); return *this; }
1944         LDKProbabilisticScorer* operator &() { return &self; }
1945         LDKProbabilisticScorer* operator ->() { return &self; }
1946         const LDKProbabilisticScorer* operator &() const { return &self; }
1947         const LDKProbabilisticScorer* operator ->() const { return &self; }
1948 };
1949 class ProbabilisticScoringFeeParameters {
1950 private:
1951         LDKProbabilisticScoringFeeParameters self;
1952 public:
1953         ProbabilisticScoringFeeParameters(const ProbabilisticScoringFeeParameters&) = delete;
1954         ProbabilisticScoringFeeParameters(ProbabilisticScoringFeeParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScoringFeeParameters)); }
1955         ProbabilisticScoringFeeParameters(LDKProbabilisticScoringFeeParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScoringFeeParameters)); }
1956         operator LDKProbabilisticScoringFeeParameters() && { LDKProbabilisticScoringFeeParameters res = self; memset(&self, 0, sizeof(LDKProbabilisticScoringFeeParameters)); return res; }
1957         ~ProbabilisticScoringFeeParameters() { ProbabilisticScoringFeeParameters_free(self); }
1958         ProbabilisticScoringFeeParameters& operator=(ProbabilisticScoringFeeParameters&& o) { ProbabilisticScoringFeeParameters_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScoringFeeParameters)); return *this; }
1959         LDKProbabilisticScoringFeeParameters* operator &() { return &self; }
1960         LDKProbabilisticScoringFeeParameters* operator ->() { return &self; }
1961         const LDKProbabilisticScoringFeeParameters* operator &() const { return &self; }
1962         const LDKProbabilisticScoringFeeParameters* operator ->() const { return &self; }
1963 };
1964 class ProbabilisticScoringDecayParameters {
1965 private:
1966         LDKProbabilisticScoringDecayParameters self;
1967 public:
1968         ProbabilisticScoringDecayParameters(const ProbabilisticScoringDecayParameters&) = delete;
1969         ProbabilisticScoringDecayParameters(ProbabilisticScoringDecayParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScoringDecayParameters)); }
1970         ProbabilisticScoringDecayParameters(LDKProbabilisticScoringDecayParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScoringDecayParameters)); }
1971         operator LDKProbabilisticScoringDecayParameters() && { LDKProbabilisticScoringDecayParameters res = self; memset(&self, 0, sizeof(LDKProbabilisticScoringDecayParameters)); return res; }
1972         ~ProbabilisticScoringDecayParameters() { ProbabilisticScoringDecayParameters_free(self); }
1973         ProbabilisticScoringDecayParameters& operator=(ProbabilisticScoringDecayParameters&& o) { ProbabilisticScoringDecayParameters_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScoringDecayParameters)); return *this; }
1974         LDKProbabilisticScoringDecayParameters* operator &() { return &self; }
1975         LDKProbabilisticScoringDecayParameters* operator ->() { return &self; }
1976         const LDKProbabilisticScoringDecayParameters* operator &() const { return &self; }
1977         const LDKProbabilisticScoringDecayParameters* operator ->() const { return &self; }
1978 };
1979 class BestBlock {
1980 private:
1981         LDKBestBlock self;
1982 public:
1983         BestBlock(const BestBlock&) = delete;
1984         BestBlock(BestBlock&& o) : self(o.self) { memset(&o, 0, sizeof(BestBlock)); }
1985         BestBlock(LDKBestBlock&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBestBlock)); }
1986         operator LDKBestBlock() && { LDKBestBlock res = self; memset(&self, 0, sizeof(LDKBestBlock)); return res; }
1987         ~BestBlock() { BestBlock_free(self); }
1988         BestBlock& operator=(BestBlock&& o) { BestBlock_free(self); self = o.self; memset(&o, 0, sizeof(BestBlock)); return *this; }
1989         LDKBestBlock* operator &() { return &self; }
1990         LDKBestBlock* operator ->() { return &self; }
1991         const LDKBestBlock* operator &() const { return &self; }
1992         const LDKBestBlock* operator ->() const { return &self; }
1993 };
1994 class Listen {
1995 private:
1996         LDKListen self;
1997 public:
1998         Listen(const Listen&) = delete;
1999         Listen(Listen&& o) : self(o.self) { memset(&o, 0, sizeof(Listen)); }
2000         Listen(LDKListen&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKListen)); }
2001         operator LDKListen() && { LDKListen res = self; memset(&self, 0, sizeof(LDKListen)); return res; }
2002         ~Listen() { Listen_free(self); }
2003         Listen& operator=(Listen&& o) { Listen_free(self); self = o.self; memset(&o, 0, sizeof(Listen)); return *this; }
2004         LDKListen* operator &() { return &self; }
2005         LDKListen* operator ->() { return &self; }
2006         const LDKListen* operator &() const { return &self; }
2007         const LDKListen* operator ->() const { return &self; }
2008         /**
2009          *  Notifies the listener that a block was added at the given height, with the transaction data
2010          *  possibly filtered.
2011          */
2012         inline void filtered_block_connected(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
2013         /**
2014          *  Notifies the listener that a block was added at the given height.
2015          */
2016         inline void block_connected(struct LDKu8slice block, uint32_t height);
2017         /**
2018          *  Notifies the listener that a block was removed at the given height.
2019          */
2020         inline void block_disconnected(const uint8_t (*header)[80], uint32_t height);
2021 };
2022 class Confirm {
2023 private:
2024         LDKConfirm self;
2025 public:
2026         Confirm(const Confirm&) = delete;
2027         Confirm(Confirm&& o) : self(o.self) { memset(&o, 0, sizeof(Confirm)); }
2028         Confirm(LDKConfirm&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirm)); }
2029         operator LDKConfirm() && { LDKConfirm res = self; memset(&self, 0, sizeof(LDKConfirm)); return res; }
2030         ~Confirm() { Confirm_free(self); }
2031         Confirm& operator=(Confirm&& o) { Confirm_free(self); self = o.self; memset(&o, 0, sizeof(Confirm)); return *this; }
2032         LDKConfirm* operator &() { return &self; }
2033         LDKConfirm* operator ->() { return &self; }
2034         const LDKConfirm* operator &() const { return &self; }
2035         const LDKConfirm* operator ->() const { return &self; }
2036         /**
2037          *  Notifies LDK of transactions confirmed in a block with a given header and height.
2038          *
2039          *  Must be called for any transactions registered by [`Filter::register_tx`] or any
2040          *  transactions spending an output registered by [`Filter::register_output`]. Such transactions
2041          *  appearing in the same block do not need to be included in the same call; instead, multiple
2042          *  calls with additional transactions may be made so long as they are made in [chain order].
2043          *
2044          *  May be called before or after [`best_block_updated`] for the corresponding block. However,
2045          *  in the event of a chain reorganization, it must not be called with a `header` that is no
2046          *  longer in the chain as of the last call to [`best_block_updated`].
2047          *
2048          *  [chain order]: Confirm#order
2049          *  [`best_block_updated`]: Self::best_block_updated
2050          */
2051         inline void transactions_confirmed(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
2052         /**
2053          *  Notifies LDK of a transaction that is no longer confirmed as result of a chain reorganization.
2054          *
2055          *  Must be called for any transaction returned by [`get_relevant_txids`] if it has been
2056          *  reorganized out of the best chain or if it is no longer confirmed in the block with the
2057          *  given block hash. Once called, the given transaction will not be returned
2058          *  by [`get_relevant_txids`], unless it has been reconfirmed via [`transactions_confirmed`].
2059          *
2060          *  [`get_relevant_txids`]: Self::get_relevant_txids
2061          *  [`transactions_confirmed`]: Self::transactions_confirmed
2062          */
2063         inline void transaction_unconfirmed(const uint8_t (*txid)[32]);
2064         /**
2065          *  Notifies LDK of an update to the best header connected at the given height.
2066          *
2067          *  Must be called whenever a new chain tip becomes available. May be skipped for intermediary
2068          *  blocks.
2069          */
2070         inline void best_block_updated(const uint8_t (*header)[80], uint32_t height);
2071         /**
2072          *  Returns transactions that must be monitored for reorganization out of the chain along
2073          *  with the height and the hash of the block as part of which it had been previously confirmed.
2074          *
2075          *  Note that the returned `Option<BlockHash>` might be `None` for channels created with LDK
2076          *  0.0.112 and prior, in which case you need to manually track previous confirmations.
2077          *
2078          *  Will include any transactions passed to [`transactions_confirmed`] that have insufficient
2079          *  confirmations to be safe from a chain reorganization. Will not include any transactions
2080          *  passed to [`transaction_unconfirmed`], unless later reconfirmed.
2081          *
2082          *  Must be called to determine the subset of transactions that must be monitored for
2083          *  reorganization. Will be idempotent between calls but may change as a result of calls to the
2084          *  other interface methods. Thus, this is useful to determine which transactions must be
2085          *  given to [`transaction_unconfirmed`].
2086          *
2087          *  If any of the returned transactions are confirmed in a block other than the one with the
2088          *  given hash at the given height, they need to be unconfirmed and reconfirmed via
2089          *  [`transaction_unconfirmed`] and [`transactions_confirmed`], respectively.
2090          *
2091          *  [`transactions_confirmed`]: Self::transactions_confirmed
2092          *  [`transaction_unconfirmed`]: Self::transaction_unconfirmed
2093          */
2094         inline LDK::CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ get_relevant_txids();
2095 };
2096 class ChannelMonitorUpdateStatus {
2097 private:
2098         LDKChannelMonitorUpdateStatus self;
2099 public:
2100         ChannelMonitorUpdateStatus(const ChannelMonitorUpdateStatus&) = delete;
2101         ChannelMonitorUpdateStatus(ChannelMonitorUpdateStatus&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateStatus)); }
2102         ChannelMonitorUpdateStatus(LDKChannelMonitorUpdateStatus&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateStatus)); }
2103         operator LDKChannelMonitorUpdateStatus() && { LDKChannelMonitorUpdateStatus res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateStatus)); return res; }
2104         ChannelMonitorUpdateStatus& operator=(ChannelMonitorUpdateStatus&& o) { self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdateStatus)); return *this; }
2105         LDKChannelMonitorUpdateStatus* operator &() { return &self; }
2106         LDKChannelMonitorUpdateStatus* operator ->() { return &self; }
2107         const LDKChannelMonitorUpdateStatus* operator &() const { return &self; }
2108         const LDKChannelMonitorUpdateStatus* operator ->() const { return &self; }
2109 };
2110 class Watch {
2111 private:
2112         LDKWatch self;
2113 public:
2114         Watch(const Watch&) = delete;
2115         Watch(Watch&& o) : self(o.self) { memset(&o, 0, sizeof(Watch)); }
2116         Watch(LDKWatch&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatch)); }
2117         operator LDKWatch() && { LDKWatch res = self; memset(&self, 0, sizeof(LDKWatch)); return res; }
2118         ~Watch() { Watch_free(self); }
2119         Watch& operator=(Watch&& o) { Watch_free(self); self = o.self; memset(&o, 0, sizeof(Watch)); return *this; }
2120         LDKWatch* operator &() { return &self; }
2121         LDKWatch* operator ->() { return &self; }
2122         const LDKWatch* operator &() const { return &self; }
2123         const LDKWatch* operator ->() const { return &self; }
2124         /**
2125          *  Watches a channel identified by `funding_txo` using `monitor`.
2126          *
2127          *  Implementations are responsible for watching the chain for the funding transaction along
2128          *  with any spends of outputs returned by [`get_outputs_to_watch`]. In practice, this means
2129          *  calling [`block_connected`] and [`block_disconnected`] on the monitor.
2130          *
2131          *  A return of `Err(())` indicates that the channel should immediately be force-closed without
2132          *  broadcasting the funding transaction.
2133          *
2134          *  If the given `funding_txo` has previously been registered via `watch_channel`, `Err(())`
2135          *  must be returned.
2136          *
2137          *  [`get_outputs_to_watch`]: channelmonitor::ChannelMonitor::get_outputs_to_watch
2138          *  [`block_connected`]: channelmonitor::ChannelMonitor::block_connected
2139          *  [`block_disconnected`]: channelmonitor::ChannelMonitor::block_disconnected
2140          */
2141         inline LDK::CResult_ChannelMonitorUpdateStatusNoneZ watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor);
2142         /**
2143          *  Updates a channel identified by `funding_txo` by applying `update` to its monitor.
2144          *
2145          *  Implementations must call [`ChannelMonitor::update_monitor`] with the given update. This
2146          *  may fail (returning an `Err(())`), in which case this should return
2147          *  [`ChannelMonitorUpdateStatus::InProgress`] (and the update should never complete). This
2148          *  generally implies the channel has been closed (either by the funding outpoint being spent
2149          *  on-chain or the [`ChannelMonitor`] having decided to do so and broadcasted a transaction),
2150          *  and the [`ChannelManager`] state will be updated once it sees the funding spend on-chain.
2151          *
2152          *  In general, persistence failures should be retried after returning
2153          *  [`ChannelMonitorUpdateStatus::InProgress`] and eventually complete. If a failure truly
2154          *  cannot be retried, the node should shut down immediately after returning
2155          *  [`ChannelMonitorUpdateStatus::UnrecoverableError`], see its documentation for more info.
2156          *
2157          *  [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
2158          */
2159         inline LDK::ChannelMonitorUpdateStatus update_channel(struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update);
2160         /**
2161          *  Returns any monitor events since the last call. Subsequent calls must only return new
2162          *  events.
2163          *
2164          *  Note that after any block- or transaction-connection calls to a [`ChannelMonitor`], no
2165          *  further events may be returned here until the [`ChannelMonitor`] has been fully persisted
2166          *  to disk.
2167          *
2168          *  For details on asynchronous [`ChannelMonitor`] updating and returning
2169          *  [`MonitorEvent::Completed`] here, see [`ChannelMonitorUpdateStatus::InProgress`].
2170          */
2171         inline LDK::CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ release_pending_monitor_events();
2172 };
2173 class Filter {
2174 private:
2175         LDKFilter self;
2176 public:
2177         Filter(const Filter&) = delete;
2178         Filter(Filter&& o) : self(o.self) { memset(&o, 0, sizeof(Filter)); }
2179         Filter(LDKFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilter)); }
2180         operator LDKFilter() && { LDKFilter res = self; memset(&self, 0, sizeof(LDKFilter)); return res; }
2181         ~Filter() { Filter_free(self); }
2182         Filter& operator=(Filter&& o) { Filter_free(self); self = o.self; memset(&o, 0, sizeof(Filter)); return *this; }
2183         LDKFilter* operator &() { return &self; }
2184         LDKFilter* operator ->() { return &self; }
2185         const LDKFilter* operator &() const { return &self; }
2186         const LDKFilter* operator ->() const { return &self; }
2187         /**
2188          *  Registers interest in a transaction with `txid` and having an output with `script_pubkey` as
2189          *  a spending condition.
2190          */
2191         inline void register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey);
2192         /**
2193          *  Registers interest in spends of a transaction output.
2194          *
2195          *  Note that this method might be called during processing of a new block. You therefore need
2196          *  to ensure that also dependent output spents within an already connected block are correctly
2197          *  handled, e.g., by re-scanning the block in question whenever new outputs have been
2198          *  registered mid-processing.
2199          */
2200         inline void register_output(struct LDKWatchedOutput output);
2201 };
2202 class WatchedOutput {
2203 private:
2204         LDKWatchedOutput self;
2205 public:
2206         WatchedOutput(const WatchedOutput&) = delete;
2207         WatchedOutput(WatchedOutput&& o) : self(o.self) { memset(&o, 0, sizeof(WatchedOutput)); }
2208         WatchedOutput(LDKWatchedOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatchedOutput)); }
2209         operator LDKWatchedOutput() && { LDKWatchedOutput res = self; memset(&self, 0, sizeof(LDKWatchedOutput)); return res; }
2210         ~WatchedOutput() { WatchedOutput_free(self); }
2211         WatchedOutput& operator=(WatchedOutput&& o) { WatchedOutput_free(self); self = o.self; memset(&o, 0, sizeof(WatchedOutput)); return *this; }
2212         LDKWatchedOutput* operator &() { return &self; }
2213         LDKWatchedOutput* operator ->() { return &self; }
2214         const LDKWatchedOutput* operator &() const { return &self; }
2215         const LDKWatchedOutput* operator ->() const { return &self; }
2216 };
2217 class InitFeatures {
2218 private:
2219         LDKInitFeatures self;
2220 public:
2221         InitFeatures(const InitFeatures&) = delete;
2222         InitFeatures(InitFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InitFeatures)); }
2223         InitFeatures(LDKInitFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInitFeatures)); }
2224         operator LDKInitFeatures() && { LDKInitFeatures res = self; memset(&self, 0, sizeof(LDKInitFeatures)); return res; }
2225         ~InitFeatures() { InitFeatures_free(self); }
2226         InitFeatures& operator=(InitFeatures&& o) { InitFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InitFeatures)); return *this; }
2227         LDKInitFeatures* operator &() { return &self; }
2228         LDKInitFeatures* operator ->() { return &self; }
2229         const LDKInitFeatures* operator &() const { return &self; }
2230         const LDKInitFeatures* operator ->() const { return &self; }
2231 };
2232 class NodeFeatures {
2233 private:
2234         LDKNodeFeatures self;
2235 public:
2236         NodeFeatures(const NodeFeatures&) = delete;
2237         NodeFeatures(NodeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(NodeFeatures)); }
2238         NodeFeatures(LDKNodeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeFeatures)); }
2239         operator LDKNodeFeatures() && { LDKNodeFeatures res = self; memset(&self, 0, sizeof(LDKNodeFeatures)); return res; }
2240         ~NodeFeatures() { NodeFeatures_free(self); }
2241         NodeFeatures& operator=(NodeFeatures&& o) { NodeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(NodeFeatures)); return *this; }
2242         LDKNodeFeatures* operator &() { return &self; }
2243         LDKNodeFeatures* operator ->() { return &self; }
2244         const LDKNodeFeatures* operator &() const { return &self; }
2245         const LDKNodeFeatures* operator ->() const { return &self; }
2246 };
2247 class ChannelFeatures {
2248 private:
2249         LDKChannelFeatures self;
2250 public:
2251         ChannelFeatures(const ChannelFeatures&) = delete;
2252         ChannelFeatures(ChannelFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelFeatures)); }
2253         ChannelFeatures(LDKChannelFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelFeatures)); }
2254         operator LDKChannelFeatures() && { LDKChannelFeatures res = self; memset(&self, 0, sizeof(LDKChannelFeatures)); return res; }
2255         ~ChannelFeatures() { ChannelFeatures_free(self); }
2256         ChannelFeatures& operator=(ChannelFeatures&& o) { ChannelFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelFeatures)); return *this; }
2257         LDKChannelFeatures* operator &() { return &self; }
2258         LDKChannelFeatures* operator ->() { return &self; }
2259         const LDKChannelFeatures* operator &() const { return &self; }
2260         const LDKChannelFeatures* operator ->() const { return &self; }
2261 };
2262 class Bolt11InvoiceFeatures {
2263 private:
2264         LDKBolt11InvoiceFeatures self;
2265 public:
2266         Bolt11InvoiceFeatures(const Bolt11InvoiceFeatures&) = delete;
2267         Bolt11InvoiceFeatures(Bolt11InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11InvoiceFeatures)); }
2268         Bolt11InvoiceFeatures(LDKBolt11InvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11InvoiceFeatures)); }
2269         operator LDKBolt11InvoiceFeatures() && { LDKBolt11InvoiceFeatures res = self; memset(&self, 0, sizeof(LDKBolt11InvoiceFeatures)); return res; }
2270         ~Bolt11InvoiceFeatures() { Bolt11InvoiceFeatures_free(self); }
2271         Bolt11InvoiceFeatures& operator=(Bolt11InvoiceFeatures&& o) { Bolt11InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11InvoiceFeatures)); return *this; }
2272         LDKBolt11InvoiceFeatures* operator &() { return &self; }
2273         LDKBolt11InvoiceFeatures* operator ->() { return &self; }
2274         const LDKBolt11InvoiceFeatures* operator &() const { return &self; }
2275         const LDKBolt11InvoiceFeatures* operator ->() const { return &self; }
2276 };
2277 class OfferFeatures {
2278 private:
2279         LDKOfferFeatures self;
2280 public:
2281         OfferFeatures(const OfferFeatures&) = delete;
2282         OfferFeatures(OfferFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(OfferFeatures)); }
2283         OfferFeatures(LDKOfferFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferFeatures)); }
2284         operator LDKOfferFeatures() && { LDKOfferFeatures res = self; memset(&self, 0, sizeof(LDKOfferFeatures)); return res; }
2285         ~OfferFeatures() { OfferFeatures_free(self); }
2286         OfferFeatures& operator=(OfferFeatures&& o) { OfferFeatures_free(self); self = o.self; memset(&o, 0, sizeof(OfferFeatures)); return *this; }
2287         LDKOfferFeatures* operator &() { return &self; }
2288         LDKOfferFeatures* operator ->() { return &self; }
2289         const LDKOfferFeatures* operator &() const { return &self; }
2290         const LDKOfferFeatures* operator ->() const { return &self; }
2291 };
2292 class InvoiceRequestFeatures {
2293 private:
2294         LDKInvoiceRequestFeatures self;
2295 public:
2296         InvoiceRequestFeatures(const InvoiceRequestFeatures&) = delete;
2297         InvoiceRequestFeatures(InvoiceRequestFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestFeatures)); }
2298         InvoiceRequestFeatures(LDKInvoiceRequestFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestFeatures)); }
2299         operator LDKInvoiceRequestFeatures() && { LDKInvoiceRequestFeatures res = self; memset(&self, 0, sizeof(LDKInvoiceRequestFeatures)); return res; }
2300         ~InvoiceRequestFeatures() { InvoiceRequestFeatures_free(self); }
2301         InvoiceRequestFeatures& operator=(InvoiceRequestFeatures&& o) { InvoiceRequestFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestFeatures)); return *this; }
2302         LDKInvoiceRequestFeatures* operator &() { return &self; }
2303         LDKInvoiceRequestFeatures* operator ->() { return &self; }
2304         const LDKInvoiceRequestFeatures* operator &() const { return &self; }
2305         const LDKInvoiceRequestFeatures* operator ->() const { return &self; }
2306 };
2307 class Bolt12InvoiceFeatures {
2308 private:
2309         LDKBolt12InvoiceFeatures self;
2310 public:
2311         Bolt12InvoiceFeatures(const Bolt12InvoiceFeatures&) = delete;
2312         Bolt12InvoiceFeatures(Bolt12InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12InvoiceFeatures)); }
2313         Bolt12InvoiceFeatures(LDKBolt12InvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12InvoiceFeatures)); }
2314         operator LDKBolt12InvoiceFeatures() && { LDKBolt12InvoiceFeatures res = self; memset(&self, 0, sizeof(LDKBolt12InvoiceFeatures)); return res; }
2315         ~Bolt12InvoiceFeatures() { Bolt12InvoiceFeatures_free(self); }
2316         Bolt12InvoiceFeatures& operator=(Bolt12InvoiceFeatures&& o) { Bolt12InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12InvoiceFeatures)); return *this; }
2317         LDKBolt12InvoiceFeatures* operator &() { return &self; }
2318         LDKBolt12InvoiceFeatures* operator ->() { return &self; }
2319         const LDKBolt12InvoiceFeatures* operator &() const { return &self; }
2320         const LDKBolt12InvoiceFeatures* operator ->() const { return &self; }
2321 };
2322 class BlindedHopFeatures {
2323 private:
2324         LDKBlindedHopFeatures self;
2325 public:
2326         BlindedHopFeatures(const BlindedHopFeatures&) = delete;
2327         BlindedHopFeatures(BlindedHopFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedHopFeatures)); }
2328         BlindedHopFeatures(LDKBlindedHopFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedHopFeatures)); }
2329         operator LDKBlindedHopFeatures() && { LDKBlindedHopFeatures res = self; memset(&self, 0, sizeof(LDKBlindedHopFeatures)); return res; }
2330         ~BlindedHopFeatures() { BlindedHopFeatures_free(self); }
2331         BlindedHopFeatures& operator=(BlindedHopFeatures&& o) { BlindedHopFeatures_free(self); self = o.self; memset(&o, 0, sizeof(BlindedHopFeatures)); return *this; }
2332         LDKBlindedHopFeatures* operator &() { return &self; }
2333         LDKBlindedHopFeatures* operator ->() { return &self; }
2334         const LDKBlindedHopFeatures* operator &() const { return &self; }
2335         const LDKBlindedHopFeatures* operator ->() const { return &self; }
2336 };
2337 class ChannelTypeFeatures {
2338 private:
2339         LDKChannelTypeFeatures self;
2340 public:
2341         ChannelTypeFeatures(const ChannelTypeFeatures&) = delete;
2342         ChannelTypeFeatures(ChannelTypeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTypeFeatures)); }
2343         ChannelTypeFeatures(LDKChannelTypeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTypeFeatures)); }
2344         operator LDKChannelTypeFeatures() && { LDKChannelTypeFeatures res = self; memset(&self, 0, sizeof(LDKChannelTypeFeatures)); return res; }
2345         ~ChannelTypeFeatures() { ChannelTypeFeatures_free(self); }
2346         ChannelTypeFeatures& operator=(ChannelTypeFeatures&& o) { ChannelTypeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTypeFeatures)); return *this; }
2347         LDKChannelTypeFeatures* operator &() { return &self; }
2348         LDKChannelTypeFeatures* operator ->() { return &self; }
2349         const LDKChannelTypeFeatures* operator &() const { return &self; }
2350         const LDKChannelTypeFeatures* operator ->() const { return &self; }
2351 };
2352 class OfferId {
2353 private:
2354         LDKOfferId self;
2355 public:
2356         OfferId(const OfferId&) = delete;
2357         OfferId(OfferId&& o) : self(o.self) { memset(&o, 0, sizeof(OfferId)); }
2358         OfferId(LDKOfferId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferId)); }
2359         operator LDKOfferId() && { LDKOfferId res = self; memset(&self, 0, sizeof(LDKOfferId)); return res; }
2360         ~OfferId() { OfferId_free(self); }
2361         OfferId& operator=(OfferId&& o) { OfferId_free(self); self = o.self; memset(&o, 0, sizeof(OfferId)); return *this; }
2362         LDKOfferId* operator &() { return &self; }
2363         LDKOfferId* operator ->() { return &self; }
2364         const LDKOfferId* operator &() const { return &self; }
2365         const LDKOfferId* operator ->() const { return &self; }
2366 };
2367 class OfferWithExplicitMetadataBuilder {
2368 private:
2369         LDKOfferWithExplicitMetadataBuilder self;
2370 public:
2371         OfferWithExplicitMetadataBuilder(const OfferWithExplicitMetadataBuilder&) = delete;
2372         OfferWithExplicitMetadataBuilder(OfferWithExplicitMetadataBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(OfferWithExplicitMetadataBuilder)); }
2373         OfferWithExplicitMetadataBuilder(LDKOfferWithExplicitMetadataBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferWithExplicitMetadataBuilder)); }
2374         operator LDKOfferWithExplicitMetadataBuilder() && { LDKOfferWithExplicitMetadataBuilder res = self; memset(&self, 0, sizeof(LDKOfferWithExplicitMetadataBuilder)); return res; }
2375         ~OfferWithExplicitMetadataBuilder() { OfferWithExplicitMetadataBuilder_free(self); }
2376         OfferWithExplicitMetadataBuilder& operator=(OfferWithExplicitMetadataBuilder&& o) { OfferWithExplicitMetadataBuilder_free(self); self = o.self; memset(&o, 0, sizeof(OfferWithExplicitMetadataBuilder)); return *this; }
2377         LDKOfferWithExplicitMetadataBuilder* operator &() { return &self; }
2378         LDKOfferWithExplicitMetadataBuilder* operator ->() { return &self; }
2379         const LDKOfferWithExplicitMetadataBuilder* operator &() const { return &self; }
2380         const LDKOfferWithExplicitMetadataBuilder* operator ->() const { return &self; }
2381 };
2382 class OfferWithDerivedMetadataBuilder {
2383 private:
2384         LDKOfferWithDerivedMetadataBuilder self;
2385 public:
2386         OfferWithDerivedMetadataBuilder(const OfferWithDerivedMetadataBuilder&) = delete;
2387         OfferWithDerivedMetadataBuilder(OfferWithDerivedMetadataBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(OfferWithDerivedMetadataBuilder)); }
2388         OfferWithDerivedMetadataBuilder(LDKOfferWithDerivedMetadataBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferWithDerivedMetadataBuilder)); }
2389         operator LDKOfferWithDerivedMetadataBuilder() && { LDKOfferWithDerivedMetadataBuilder res = self; memset(&self, 0, sizeof(LDKOfferWithDerivedMetadataBuilder)); return res; }
2390         ~OfferWithDerivedMetadataBuilder() { OfferWithDerivedMetadataBuilder_free(self); }
2391         OfferWithDerivedMetadataBuilder& operator=(OfferWithDerivedMetadataBuilder&& o) { OfferWithDerivedMetadataBuilder_free(self); self = o.self; memset(&o, 0, sizeof(OfferWithDerivedMetadataBuilder)); return *this; }
2392         LDKOfferWithDerivedMetadataBuilder* operator &() { return &self; }
2393         LDKOfferWithDerivedMetadataBuilder* operator ->() { return &self; }
2394         const LDKOfferWithDerivedMetadataBuilder* operator &() const { return &self; }
2395         const LDKOfferWithDerivedMetadataBuilder* operator ->() const { return &self; }
2396 };
2397 class Offer {
2398 private:
2399         LDKOffer self;
2400 public:
2401         Offer(const Offer&) = delete;
2402         Offer(Offer&& o) : self(o.self) { memset(&o, 0, sizeof(Offer)); }
2403         Offer(LDKOffer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffer)); }
2404         operator LDKOffer() && { LDKOffer res = self; memset(&self, 0, sizeof(LDKOffer)); return res; }
2405         ~Offer() { Offer_free(self); }
2406         Offer& operator=(Offer&& o) { Offer_free(self); self = o.self; memset(&o, 0, sizeof(Offer)); return *this; }
2407         LDKOffer* operator &() { return &self; }
2408         LDKOffer* operator ->() { return &self; }
2409         const LDKOffer* operator &() const { return &self; }
2410         const LDKOffer* operator ->() const { return &self; }
2411 };
2412 class Amount {
2413 private:
2414         LDKAmount self;
2415 public:
2416         Amount(const Amount&) = delete;
2417         Amount(Amount&& o) : self(o.self) { memset(&o, 0, sizeof(Amount)); }
2418         Amount(LDKAmount&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAmount)); }
2419         operator LDKAmount() && { LDKAmount res = self; memset(&self, 0, sizeof(LDKAmount)); return res; }
2420         ~Amount() { Amount_free(self); }
2421         Amount& operator=(Amount&& o) { Amount_free(self); self = o.self; memset(&o, 0, sizeof(Amount)); return *this; }
2422         LDKAmount* operator &() { return &self; }
2423         LDKAmount* operator ->() { return &self; }
2424         const LDKAmount* operator &() const { return &self; }
2425         const LDKAmount* operator ->() const { return &self; }
2426 };
2427 class Quantity {
2428 private:
2429         LDKQuantity self;
2430 public:
2431         Quantity(const Quantity&) = delete;
2432         Quantity(Quantity&& o) : self(o.self) { memset(&o, 0, sizeof(Quantity)); }
2433         Quantity(LDKQuantity&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQuantity)); }
2434         operator LDKQuantity() && { LDKQuantity res = self; memset(&self, 0, sizeof(LDKQuantity)); return res; }
2435         ~Quantity() { Quantity_free(self); }
2436         Quantity& operator=(Quantity&& o) { Quantity_free(self); self = o.self; memset(&o, 0, sizeof(Quantity)); return *this; }
2437         LDKQuantity* operator &() { return &self; }
2438         LDKQuantity* operator ->() { return &self; }
2439         const LDKQuantity* operator &() const { return &self; }
2440         const LDKQuantity* operator ->() const { return &self; }
2441 };
2442 class NodeId {
2443 private:
2444         LDKNodeId self;
2445 public:
2446         NodeId(const NodeId&) = delete;
2447         NodeId(NodeId&& o) : self(o.self) { memset(&o, 0, sizeof(NodeId)); }
2448         NodeId(LDKNodeId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeId)); }
2449         operator LDKNodeId() && { LDKNodeId res = self; memset(&self, 0, sizeof(LDKNodeId)); return res; }
2450         ~NodeId() { NodeId_free(self); }
2451         NodeId& operator=(NodeId&& o) { NodeId_free(self); self = o.self; memset(&o, 0, sizeof(NodeId)); return *this; }
2452         LDKNodeId* operator &() { return &self; }
2453         LDKNodeId* operator ->() { return &self; }
2454         const LDKNodeId* operator &() const { return &self; }
2455         const LDKNodeId* operator ->() const { return &self; }
2456 };
2457 class NetworkGraph {
2458 private:
2459         LDKNetworkGraph self;
2460 public:
2461         NetworkGraph(const NetworkGraph&) = delete;
2462         NetworkGraph(NetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkGraph)); }
2463         NetworkGraph(LDKNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkGraph)); }
2464         operator LDKNetworkGraph() && { LDKNetworkGraph res = self; memset(&self, 0, sizeof(LDKNetworkGraph)); return res; }
2465         ~NetworkGraph() { NetworkGraph_free(self); }
2466         NetworkGraph& operator=(NetworkGraph&& o) { NetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(NetworkGraph)); return *this; }
2467         LDKNetworkGraph* operator &() { return &self; }
2468         LDKNetworkGraph* operator ->() { return &self; }
2469         const LDKNetworkGraph* operator &() const { return &self; }
2470         const LDKNetworkGraph* operator ->() const { return &self; }
2471 };
2472 class ReadOnlyNetworkGraph {
2473 private:
2474         LDKReadOnlyNetworkGraph self;
2475 public:
2476         ReadOnlyNetworkGraph(const ReadOnlyNetworkGraph&) = delete;
2477         ReadOnlyNetworkGraph(ReadOnlyNetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); }
2478         ReadOnlyNetworkGraph(LDKReadOnlyNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReadOnlyNetworkGraph)); }
2479         operator LDKReadOnlyNetworkGraph() && { LDKReadOnlyNetworkGraph res = self; memset(&self, 0, sizeof(LDKReadOnlyNetworkGraph)); return res; }
2480         ~ReadOnlyNetworkGraph() { ReadOnlyNetworkGraph_free(self); }
2481         ReadOnlyNetworkGraph& operator=(ReadOnlyNetworkGraph&& o) { ReadOnlyNetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); return *this; }
2482         LDKReadOnlyNetworkGraph* operator &() { return &self; }
2483         LDKReadOnlyNetworkGraph* operator ->() { return &self; }
2484         const LDKReadOnlyNetworkGraph* operator &() const { return &self; }
2485         const LDKReadOnlyNetworkGraph* operator ->() const { return &self; }
2486 };
2487 class NetworkUpdate {
2488 private:
2489         LDKNetworkUpdate self;
2490 public:
2491         NetworkUpdate(const NetworkUpdate&) = delete;
2492         NetworkUpdate(NetworkUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkUpdate)); }
2493         NetworkUpdate(LDKNetworkUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkUpdate)); }
2494         operator LDKNetworkUpdate() && { LDKNetworkUpdate res = self; memset(&self, 0, sizeof(LDKNetworkUpdate)); return res; }
2495         ~NetworkUpdate() { NetworkUpdate_free(self); }
2496         NetworkUpdate& operator=(NetworkUpdate&& o) { NetworkUpdate_free(self); self = o.self; memset(&o, 0, sizeof(NetworkUpdate)); return *this; }
2497         LDKNetworkUpdate* operator &() { return &self; }
2498         LDKNetworkUpdate* operator ->() { return &self; }
2499         const LDKNetworkUpdate* operator &() const { return &self; }
2500         const LDKNetworkUpdate* operator ->() const { return &self; }
2501 };
2502 class P2PGossipSync {
2503 private:
2504         LDKP2PGossipSync self;
2505 public:
2506         P2PGossipSync(const P2PGossipSync&) = delete;
2507         P2PGossipSync(P2PGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(P2PGossipSync)); }
2508         P2PGossipSync(LDKP2PGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKP2PGossipSync)); }
2509         operator LDKP2PGossipSync() && { LDKP2PGossipSync res = self; memset(&self, 0, sizeof(LDKP2PGossipSync)); return res; }
2510         ~P2PGossipSync() { P2PGossipSync_free(self); }
2511         P2PGossipSync& operator=(P2PGossipSync&& o) { P2PGossipSync_free(self); self = o.self; memset(&o, 0, sizeof(P2PGossipSync)); return *this; }
2512         LDKP2PGossipSync* operator &() { return &self; }
2513         LDKP2PGossipSync* operator ->() { return &self; }
2514         const LDKP2PGossipSync* operator &() const { return &self; }
2515         const LDKP2PGossipSync* operator ->() const { return &self; }
2516 };
2517 class ChannelUpdateInfo {
2518 private:
2519         LDKChannelUpdateInfo self;
2520 public:
2521         ChannelUpdateInfo(const ChannelUpdateInfo&) = delete;
2522         ChannelUpdateInfo(ChannelUpdateInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdateInfo)); }
2523         ChannelUpdateInfo(LDKChannelUpdateInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdateInfo)); }
2524         operator LDKChannelUpdateInfo() && { LDKChannelUpdateInfo res = self; memset(&self, 0, sizeof(LDKChannelUpdateInfo)); return res; }
2525         ~ChannelUpdateInfo() { ChannelUpdateInfo_free(self); }
2526         ChannelUpdateInfo& operator=(ChannelUpdateInfo&& o) { ChannelUpdateInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdateInfo)); return *this; }
2527         LDKChannelUpdateInfo* operator &() { return &self; }
2528         LDKChannelUpdateInfo* operator ->() { return &self; }
2529         const LDKChannelUpdateInfo* operator &() const { return &self; }
2530         const LDKChannelUpdateInfo* operator ->() const { return &self; }
2531 };
2532 class ChannelInfo {
2533 private:
2534         LDKChannelInfo self;
2535 public:
2536         ChannelInfo(const ChannelInfo&) = delete;
2537         ChannelInfo(ChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelInfo)); }
2538         ChannelInfo(LDKChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelInfo)); }
2539         operator LDKChannelInfo() && { LDKChannelInfo res = self; memset(&self, 0, sizeof(LDKChannelInfo)); return res; }
2540         ~ChannelInfo() { ChannelInfo_free(self); }
2541         ChannelInfo& operator=(ChannelInfo&& o) { ChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelInfo)); return *this; }
2542         LDKChannelInfo* operator &() { return &self; }
2543         LDKChannelInfo* operator ->() { return &self; }
2544         const LDKChannelInfo* operator &() const { return &self; }
2545         const LDKChannelInfo* operator ->() const { return &self; }
2546 };
2547 class DirectedChannelInfo {
2548 private:
2549         LDKDirectedChannelInfo self;
2550 public:
2551         DirectedChannelInfo(const DirectedChannelInfo&) = delete;
2552         DirectedChannelInfo(DirectedChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(DirectedChannelInfo)); }
2553         DirectedChannelInfo(LDKDirectedChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectedChannelInfo)); }
2554         operator LDKDirectedChannelInfo() && { LDKDirectedChannelInfo res = self; memset(&self, 0, sizeof(LDKDirectedChannelInfo)); return res; }
2555         ~DirectedChannelInfo() { DirectedChannelInfo_free(self); }
2556         DirectedChannelInfo& operator=(DirectedChannelInfo&& o) { DirectedChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(DirectedChannelInfo)); return *this; }
2557         LDKDirectedChannelInfo* operator &() { return &self; }
2558         LDKDirectedChannelInfo* operator ->() { return &self; }
2559         const LDKDirectedChannelInfo* operator &() const { return &self; }
2560         const LDKDirectedChannelInfo* operator ->() const { return &self; }
2561 };
2562 class EffectiveCapacity {
2563 private:
2564         LDKEffectiveCapacity self;
2565 public:
2566         EffectiveCapacity(const EffectiveCapacity&) = delete;
2567         EffectiveCapacity(EffectiveCapacity&& o) : self(o.self) { memset(&o, 0, sizeof(EffectiveCapacity)); }
2568         EffectiveCapacity(LDKEffectiveCapacity&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEffectiveCapacity)); }
2569         operator LDKEffectiveCapacity() && { LDKEffectiveCapacity res = self; memset(&self, 0, sizeof(LDKEffectiveCapacity)); return res; }
2570         ~EffectiveCapacity() { EffectiveCapacity_free(self); }
2571         EffectiveCapacity& operator=(EffectiveCapacity&& o) { EffectiveCapacity_free(self); self = o.self; memset(&o, 0, sizeof(EffectiveCapacity)); return *this; }
2572         LDKEffectiveCapacity* operator &() { return &self; }
2573         LDKEffectiveCapacity* operator ->() { return &self; }
2574         const LDKEffectiveCapacity* operator &() const { return &self; }
2575         const LDKEffectiveCapacity* operator ->() const { return &self; }
2576 };
2577 class RoutingFees {
2578 private:
2579         LDKRoutingFees self;
2580 public:
2581         RoutingFees(const RoutingFees&) = delete;
2582         RoutingFees(RoutingFees&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingFees)); }
2583         RoutingFees(LDKRoutingFees&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingFees)); }
2584         operator LDKRoutingFees() && { LDKRoutingFees res = self; memset(&self, 0, sizeof(LDKRoutingFees)); return res; }
2585         ~RoutingFees() { RoutingFees_free(self); }
2586         RoutingFees& operator=(RoutingFees&& o) { RoutingFees_free(self); self = o.self; memset(&o, 0, sizeof(RoutingFees)); return *this; }
2587         LDKRoutingFees* operator &() { return &self; }
2588         LDKRoutingFees* operator ->() { return &self; }
2589         const LDKRoutingFees* operator &() const { return &self; }
2590         const LDKRoutingFees* operator ->() const { return &self; }
2591 };
2592 class NodeAnnouncementInfo {
2593 private:
2594         LDKNodeAnnouncementInfo self;
2595 public:
2596         NodeAnnouncementInfo(const NodeAnnouncementInfo&) = delete;
2597         NodeAnnouncementInfo(NodeAnnouncementInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncementInfo)); }
2598         NodeAnnouncementInfo(LDKNodeAnnouncementInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncementInfo)); }
2599         operator LDKNodeAnnouncementInfo() && { LDKNodeAnnouncementInfo res = self; memset(&self, 0, sizeof(LDKNodeAnnouncementInfo)); return res; }
2600         ~NodeAnnouncementInfo() { NodeAnnouncementInfo_free(self); }
2601         NodeAnnouncementInfo& operator=(NodeAnnouncementInfo&& o) { NodeAnnouncementInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncementInfo)); return *this; }
2602         LDKNodeAnnouncementInfo* operator &() { return &self; }
2603         LDKNodeAnnouncementInfo* operator ->() { return &self; }
2604         const LDKNodeAnnouncementInfo* operator &() const { return &self; }
2605         const LDKNodeAnnouncementInfo* operator ->() const { return &self; }
2606 };
2607 class NodeAlias {
2608 private:
2609         LDKNodeAlias self;
2610 public:
2611         NodeAlias(const NodeAlias&) = delete;
2612         NodeAlias(NodeAlias&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAlias)); }
2613         NodeAlias(LDKNodeAlias&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAlias)); }
2614         operator LDKNodeAlias() && { LDKNodeAlias res = self; memset(&self, 0, sizeof(LDKNodeAlias)); return res; }
2615         ~NodeAlias() { NodeAlias_free(self); }
2616         NodeAlias& operator=(NodeAlias&& o) { NodeAlias_free(self); self = o.self; memset(&o, 0, sizeof(NodeAlias)); return *this; }
2617         LDKNodeAlias* operator &() { return &self; }
2618         LDKNodeAlias* operator ->() { return &self; }
2619         const LDKNodeAlias* operator &() const { return &self; }
2620         const LDKNodeAlias* operator ->() const { return &self; }
2621 };
2622 class NodeInfo {
2623 private:
2624         LDKNodeInfo self;
2625 public:
2626         NodeInfo(const NodeInfo&) = delete;
2627         NodeInfo(NodeInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeInfo)); }
2628         NodeInfo(LDKNodeInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeInfo)); }
2629         operator LDKNodeInfo() && { LDKNodeInfo res = self; memset(&self, 0, sizeof(LDKNodeInfo)); return res; }
2630         ~NodeInfo() { NodeInfo_free(self); }
2631         NodeInfo& operator=(NodeInfo&& o) { NodeInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeInfo)); return *this; }
2632         LDKNodeInfo* operator &() { return &self; }
2633         LDKNodeInfo* operator ->() { return &self; }
2634         const LDKNodeInfo* operator &() const { return &self; }
2635         const LDKNodeInfo* operator ->() const { return &self; }
2636 };
2637 class ShortChannelIdError {
2638 private:
2639         LDKShortChannelIdError self;
2640 public:
2641         ShortChannelIdError(const ShortChannelIdError&) = delete;
2642         ShortChannelIdError(ShortChannelIdError&& o) : self(o.self) { memset(&o, 0, sizeof(ShortChannelIdError)); }
2643         ShortChannelIdError(LDKShortChannelIdError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShortChannelIdError)); }
2644         operator LDKShortChannelIdError() && { LDKShortChannelIdError res = self; memset(&self, 0, sizeof(LDKShortChannelIdError)); return res; }
2645         ShortChannelIdError& operator=(ShortChannelIdError&& o) { self = o.self; memset(&o, 0, sizeof(ShortChannelIdError)); return *this; }
2646         LDKShortChannelIdError* operator &() { return &self; }
2647         LDKShortChannelIdError* operator ->() { return &self; }
2648         const LDKShortChannelIdError* operator &() const { return &self; }
2649         const LDKShortChannelIdError* operator ->() const { return &self; }
2650 };
2651 class InboundHTLCErr {
2652 private:
2653         LDKInboundHTLCErr self;
2654 public:
2655         InboundHTLCErr(const InboundHTLCErr&) = delete;
2656         InboundHTLCErr(InboundHTLCErr&& o) : self(o.self) { memset(&o, 0, sizeof(InboundHTLCErr)); }
2657         InboundHTLCErr(LDKInboundHTLCErr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInboundHTLCErr)); }
2658         operator LDKInboundHTLCErr() && { LDKInboundHTLCErr res = self; memset(&self, 0, sizeof(LDKInboundHTLCErr)); return res; }
2659         ~InboundHTLCErr() { InboundHTLCErr_free(self); }
2660         InboundHTLCErr& operator=(InboundHTLCErr&& o) { InboundHTLCErr_free(self); self = o.self; memset(&o, 0, sizeof(InboundHTLCErr)); return *this; }
2661         LDKInboundHTLCErr* operator &() { return &self; }
2662         LDKInboundHTLCErr* operator ->() { return &self; }
2663         const LDKInboundHTLCErr* operator &() const { return &self; }
2664         const LDKInboundHTLCErr* operator ->() const { return &self; }
2665 };
2666 class AnchorDescriptor {
2667 private:
2668         LDKAnchorDescriptor self;
2669 public:
2670         AnchorDescriptor(const AnchorDescriptor&) = delete;
2671         AnchorDescriptor(AnchorDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(AnchorDescriptor)); }
2672         AnchorDescriptor(LDKAnchorDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnchorDescriptor)); }
2673         operator LDKAnchorDescriptor() && { LDKAnchorDescriptor res = self; memset(&self, 0, sizeof(LDKAnchorDescriptor)); return res; }
2674         ~AnchorDescriptor() { AnchorDescriptor_free(self); }
2675         AnchorDescriptor& operator=(AnchorDescriptor&& o) { AnchorDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(AnchorDescriptor)); return *this; }
2676         LDKAnchorDescriptor* operator &() { return &self; }
2677         LDKAnchorDescriptor* operator ->() { return &self; }
2678         const LDKAnchorDescriptor* operator &() const { return &self; }
2679         const LDKAnchorDescriptor* operator ->() const { return &self; }
2680 };
2681 class BumpTransactionEvent {
2682 private:
2683         LDKBumpTransactionEvent self;
2684 public:
2685         BumpTransactionEvent(const BumpTransactionEvent&) = delete;
2686         BumpTransactionEvent(BumpTransactionEvent&& o) : self(o.self) { memset(&o, 0, sizeof(BumpTransactionEvent)); }
2687         BumpTransactionEvent(LDKBumpTransactionEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBumpTransactionEvent)); }
2688         operator LDKBumpTransactionEvent() && { LDKBumpTransactionEvent res = self; memset(&self, 0, sizeof(LDKBumpTransactionEvent)); return res; }
2689         ~BumpTransactionEvent() { BumpTransactionEvent_free(self); }
2690         BumpTransactionEvent& operator=(BumpTransactionEvent&& o) { BumpTransactionEvent_free(self); self = o.self; memset(&o, 0, sizeof(BumpTransactionEvent)); return *this; }
2691         LDKBumpTransactionEvent* operator &() { return &self; }
2692         LDKBumpTransactionEvent* operator ->() { return &self; }
2693         const LDKBumpTransactionEvent* operator &() const { return &self; }
2694         const LDKBumpTransactionEvent* operator ->() const { return &self; }
2695 };
2696 class Input {
2697 private:
2698         LDKInput self;
2699 public:
2700         Input(const Input&) = delete;
2701         Input(Input&& o) : self(o.self) { memset(&o, 0, sizeof(Input)); }
2702         Input(LDKInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInput)); }
2703         operator LDKInput() && { LDKInput res = self; memset(&self, 0, sizeof(LDKInput)); return res; }
2704         ~Input() { Input_free(self); }
2705         Input& operator=(Input&& o) { Input_free(self); self = o.self; memset(&o, 0, sizeof(Input)); return *this; }
2706         LDKInput* operator &() { return &self; }
2707         LDKInput* operator ->() { return &self; }
2708         const LDKInput* operator &() const { return &self; }
2709         const LDKInput* operator ->() const { return &self; }
2710 };
2711 class Utxo {
2712 private:
2713         LDKUtxo self;
2714 public:
2715         Utxo(const Utxo&) = delete;
2716         Utxo(Utxo&& o) : self(o.self) { memset(&o, 0, sizeof(Utxo)); }
2717         Utxo(LDKUtxo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxo)); }
2718         operator LDKUtxo() && { LDKUtxo res = self; memset(&self, 0, sizeof(LDKUtxo)); return res; }
2719         ~Utxo() { Utxo_free(self); }
2720         Utxo& operator=(Utxo&& o) { Utxo_free(self); self = o.self; memset(&o, 0, sizeof(Utxo)); return *this; }
2721         LDKUtxo* operator &() { return &self; }
2722         LDKUtxo* operator ->() { return &self; }
2723         const LDKUtxo* operator &() const { return &self; }
2724         const LDKUtxo* operator ->() const { return &self; }
2725 };
2726 class CoinSelection {
2727 private:
2728         LDKCoinSelection self;
2729 public:
2730         CoinSelection(const CoinSelection&) = delete;
2731         CoinSelection(CoinSelection&& o) : self(o.self) { memset(&o, 0, sizeof(CoinSelection)); }
2732         CoinSelection(LDKCoinSelection&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCoinSelection)); }
2733         operator LDKCoinSelection() && { LDKCoinSelection res = self; memset(&self, 0, sizeof(LDKCoinSelection)); return res; }
2734         ~CoinSelection() { CoinSelection_free(self); }
2735         CoinSelection& operator=(CoinSelection&& o) { CoinSelection_free(self); self = o.self; memset(&o, 0, sizeof(CoinSelection)); return *this; }
2736         LDKCoinSelection* operator &() { return &self; }
2737         LDKCoinSelection* operator ->() { return &self; }
2738         const LDKCoinSelection* operator &() const { return &self; }
2739         const LDKCoinSelection* operator ->() const { return &self; }
2740 };
2741 class CoinSelectionSource {
2742 private:
2743         LDKCoinSelectionSource self;
2744 public:
2745         CoinSelectionSource(const CoinSelectionSource&) = delete;
2746         CoinSelectionSource(CoinSelectionSource&& o) : self(o.self) { memset(&o, 0, sizeof(CoinSelectionSource)); }
2747         CoinSelectionSource(LDKCoinSelectionSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCoinSelectionSource)); }
2748         operator LDKCoinSelectionSource() && { LDKCoinSelectionSource res = self; memset(&self, 0, sizeof(LDKCoinSelectionSource)); return res; }
2749         ~CoinSelectionSource() { CoinSelectionSource_free(self); }
2750         CoinSelectionSource& operator=(CoinSelectionSource&& o) { CoinSelectionSource_free(self); self = o.self; memset(&o, 0, sizeof(CoinSelectionSource)); return *this; }
2751         LDKCoinSelectionSource* operator &() { return &self; }
2752         LDKCoinSelectionSource* operator ->() { return &self; }
2753         const LDKCoinSelectionSource* operator &() const { return &self; }
2754         const LDKCoinSelectionSource* operator ->() const { return &self; }
2755         /**
2756          *  Performs coin selection of a set of UTXOs, with at least 1 confirmation each, that are
2757          *  available to spend. Implementations are free to pick their coin selection algorithm of
2758          *  choice, as long as the following requirements are met:
2759          *
2760          *  1. `must_spend` contains a set of [`Input`]s that must be included in the transaction
2761          *     throughout coin selection, but must not be returned as part of the result.
2762          *  2. `must_pay_to` contains a set of [`TxOut`]s that must be included in the transaction
2763          *     throughout coin selection. In some cases, like when funding an anchor transaction, this
2764          *     set is empty. Implementations should ensure they handle this correctly on their end,
2765          *     e.g., Bitcoin Core's `fundrawtransaction` RPC requires at least one output to be
2766          *     provided, in which case a zero-value empty OP_RETURN output can be used instead.
2767          *  3. Enough inputs must be selected/contributed for the resulting transaction (including the
2768          *     inputs and outputs noted above) to meet `target_feerate_sat_per_1000_weight`.
2769          *
2770          *  Implementations must take note that [`Input::satisfaction_weight`] only tracks the weight of
2771          *  the input's `script_sig` and `witness`. Some wallets, like Bitcoin Core's, may require
2772          *  providing the full input weight. Failing to do so may lead to underestimating fee bumps and
2773          *  delaying block inclusion.
2774          *
2775          *  The `claim_id` must map to the set of external UTXOs assigned to the claim, such that they
2776          *  can be re-used within new fee-bumped iterations of the original claiming transaction,
2777          *  ensuring that claims don't double spend each other. If a specific `claim_id` has never had a
2778          *  transaction associated with it, and all of the available UTXOs have already been assigned to
2779          *  other claims, implementations must be willing to double spend their UTXOs. The choice of
2780          *  which UTXOs to double spend is left to the implementation, but it must strive to keep the
2781          *  set of other claims being double spent to a minimum.
2782          */
2783         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);
2784         /**
2785          *  Signs and provides the full witness for all inputs within the transaction known to the
2786          *  trait (i.e., any provided via [`CoinSelectionSource::select_confirmed_utxos`]).
2787          *
2788          *  If your wallet does not support signing PSBTs you can call `psbt.extract_tx()` to get the
2789          *  unsigned transaction and then sign it with your wallet.
2790          */
2791         inline LDK::CResult_TransactionNoneZ sign_psbt(struct LDKCVec_u8Z psbt);
2792 };
2793 class WalletSource {
2794 private:
2795         LDKWalletSource self;
2796 public:
2797         WalletSource(const WalletSource&) = delete;
2798         WalletSource(WalletSource&& o) : self(o.self) { memset(&o, 0, sizeof(WalletSource)); }
2799         WalletSource(LDKWalletSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWalletSource)); }
2800         operator LDKWalletSource() && { LDKWalletSource res = self; memset(&self, 0, sizeof(LDKWalletSource)); return res; }
2801         ~WalletSource() { WalletSource_free(self); }
2802         WalletSource& operator=(WalletSource&& o) { WalletSource_free(self); self = o.self; memset(&o, 0, sizeof(WalletSource)); return *this; }
2803         LDKWalletSource* operator &() { return &self; }
2804         LDKWalletSource* operator ->() { return &self; }
2805         const LDKWalletSource* operator &() const { return &self; }
2806         const LDKWalletSource* operator ->() const { return &self; }
2807         /**
2808          *  Returns all UTXOs, with at least 1 confirmation each, that are available to spend.
2809          */
2810         inline LDK::CResult_CVec_UtxoZNoneZ list_confirmed_utxos();
2811         /**
2812          *  Returns a script to use for change above dust resulting from a successful coin selection
2813          *  attempt.
2814          */
2815         inline LDK::CResult_CVec_u8ZNoneZ get_change_script();
2816         /**
2817          *  Signs and provides the full [`TxIn::script_sig`] and [`TxIn::witness`] for all inputs within
2818          *  the transaction known to the wallet (i.e., any provided via
2819          *  [`WalletSource::list_confirmed_utxos`]).
2820          *
2821          *  If your wallet does not support signing PSBTs you can call `psbt.extract_tx()` to get the
2822          *  unsigned transaction and then sign it with your wallet.
2823          */
2824         inline LDK::CResult_TransactionNoneZ sign_psbt(struct LDKCVec_u8Z psbt);
2825 };
2826 class Wallet {
2827 private:
2828         LDKWallet self;
2829 public:
2830         Wallet(const Wallet&) = delete;
2831         Wallet(Wallet&& o) : self(o.self) { memset(&o, 0, sizeof(Wallet)); }
2832         Wallet(LDKWallet&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWallet)); }
2833         operator LDKWallet() && { LDKWallet res = self; memset(&self, 0, sizeof(LDKWallet)); return res; }
2834         ~Wallet() { Wallet_free(self); }
2835         Wallet& operator=(Wallet&& o) { Wallet_free(self); self = o.self; memset(&o, 0, sizeof(Wallet)); return *this; }
2836         LDKWallet* operator &() { return &self; }
2837         LDKWallet* operator ->() { return &self; }
2838         const LDKWallet* operator &() const { return &self; }
2839         const LDKWallet* operator ->() const { return &self; }
2840 };
2841 class BumpTransactionEventHandler {
2842 private:
2843         LDKBumpTransactionEventHandler self;
2844 public:
2845         BumpTransactionEventHandler(const BumpTransactionEventHandler&) = delete;
2846         BumpTransactionEventHandler(BumpTransactionEventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(BumpTransactionEventHandler)); }
2847         BumpTransactionEventHandler(LDKBumpTransactionEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBumpTransactionEventHandler)); }
2848         operator LDKBumpTransactionEventHandler() && { LDKBumpTransactionEventHandler res = self; memset(&self, 0, sizeof(LDKBumpTransactionEventHandler)); return res; }
2849         ~BumpTransactionEventHandler() { BumpTransactionEventHandler_free(self); }
2850         BumpTransactionEventHandler& operator=(BumpTransactionEventHandler&& o) { BumpTransactionEventHandler_free(self); self = o.self; memset(&o, 0, sizeof(BumpTransactionEventHandler)); return *this; }
2851         LDKBumpTransactionEventHandler* operator &() { return &self; }
2852         LDKBumpTransactionEventHandler* operator ->() { return &self; }
2853         const LDKBumpTransactionEventHandler* operator &() const { return &self; }
2854         const LDKBumpTransactionEventHandler* operator ->() const { return &self; }
2855 };
2856 class PendingHTLCRouting {
2857 private:
2858         LDKPendingHTLCRouting self;
2859 public:
2860         PendingHTLCRouting(const PendingHTLCRouting&) = delete;
2861         PendingHTLCRouting(PendingHTLCRouting&& o) : self(o.self) { memset(&o, 0, sizeof(PendingHTLCRouting)); }
2862         PendingHTLCRouting(LDKPendingHTLCRouting&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPendingHTLCRouting)); }
2863         operator LDKPendingHTLCRouting() && { LDKPendingHTLCRouting res = self; memset(&self, 0, sizeof(LDKPendingHTLCRouting)); return res; }
2864         ~PendingHTLCRouting() { PendingHTLCRouting_free(self); }
2865         PendingHTLCRouting& operator=(PendingHTLCRouting&& o) { PendingHTLCRouting_free(self); self = o.self; memset(&o, 0, sizeof(PendingHTLCRouting)); return *this; }
2866         LDKPendingHTLCRouting* operator &() { return &self; }
2867         LDKPendingHTLCRouting* operator ->() { return &self; }
2868         const LDKPendingHTLCRouting* operator &() const { return &self; }
2869         const LDKPendingHTLCRouting* operator ->() const { return &self; }
2870 };
2871 class BlindedForward {
2872 private:
2873         LDKBlindedForward self;
2874 public:
2875         BlindedForward(const BlindedForward&) = delete;
2876         BlindedForward(BlindedForward&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedForward)); }
2877         BlindedForward(LDKBlindedForward&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedForward)); }
2878         operator LDKBlindedForward() && { LDKBlindedForward res = self; memset(&self, 0, sizeof(LDKBlindedForward)); return res; }
2879         ~BlindedForward() { BlindedForward_free(self); }
2880         BlindedForward& operator=(BlindedForward&& o) { BlindedForward_free(self); self = o.self; memset(&o, 0, sizeof(BlindedForward)); return *this; }
2881         LDKBlindedForward* operator &() { return &self; }
2882         LDKBlindedForward* operator ->() { return &self; }
2883         const LDKBlindedForward* operator &() const { return &self; }
2884         const LDKBlindedForward* operator ->() const { return &self; }
2885 };
2886 class PendingHTLCInfo {
2887 private:
2888         LDKPendingHTLCInfo self;
2889 public:
2890         PendingHTLCInfo(const PendingHTLCInfo&) = delete;
2891         PendingHTLCInfo(PendingHTLCInfo&& o) : self(o.self) { memset(&o, 0, sizeof(PendingHTLCInfo)); }
2892         PendingHTLCInfo(LDKPendingHTLCInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPendingHTLCInfo)); }
2893         operator LDKPendingHTLCInfo() && { LDKPendingHTLCInfo res = self; memset(&self, 0, sizeof(LDKPendingHTLCInfo)); return res; }
2894         ~PendingHTLCInfo() { PendingHTLCInfo_free(self); }
2895         PendingHTLCInfo& operator=(PendingHTLCInfo&& o) { PendingHTLCInfo_free(self); self = o.self; memset(&o, 0, sizeof(PendingHTLCInfo)); return *this; }
2896         LDKPendingHTLCInfo* operator &() { return &self; }
2897         LDKPendingHTLCInfo* operator ->() { return &self; }
2898         const LDKPendingHTLCInfo* operator &() const { return &self; }
2899         const LDKPendingHTLCInfo* operator ->() const { return &self; }
2900 };
2901 class BlindedFailure {
2902 private:
2903         LDKBlindedFailure self;
2904 public:
2905         BlindedFailure(const BlindedFailure&) = delete;
2906         BlindedFailure(BlindedFailure&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedFailure)); }
2907         BlindedFailure(LDKBlindedFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedFailure)); }
2908         operator LDKBlindedFailure() && { LDKBlindedFailure res = self; memset(&self, 0, sizeof(LDKBlindedFailure)); return res; }
2909         BlindedFailure& operator=(BlindedFailure&& o) { self = o.self; memset(&o, 0, sizeof(BlindedFailure)); return *this; }
2910         LDKBlindedFailure* operator &() { return &self; }
2911         LDKBlindedFailure* operator ->() { return &self; }
2912         const LDKBlindedFailure* operator &() const { return &self; }
2913         const LDKBlindedFailure* operator ->() const { return &self; }
2914 };
2915 class FailureCode {
2916 private:
2917         LDKFailureCode self;
2918 public:
2919         FailureCode(const FailureCode&) = delete;
2920         FailureCode(FailureCode&& o) : self(o.self) { memset(&o, 0, sizeof(FailureCode)); }
2921         FailureCode(LDKFailureCode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFailureCode)); }
2922         operator LDKFailureCode() && { LDKFailureCode res = self; memset(&self, 0, sizeof(LDKFailureCode)); return res; }
2923         ~FailureCode() { FailureCode_free(self); }
2924         FailureCode& operator=(FailureCode&& o) { FailureCode_free(self); self = o.self; memset(&o, 0, sizeof(FailureCode)); return *this; }
2925         LDKFailureCode* operator &() { return &self; }
2926         LDKFailureCode* operator ->() { return &self; }
2927         const LDKFailureCode* operator &() const { return &self; }
2928         const LDKFailureCode* operator ->() const { return &self; }
2929 };
2930 class ChannelManager {
2931 private:
2932         LDKChannelManager self;
2933 public:
2934         ChannelManager(const ChannelManager&) = delete;
2935         ChannelManager(ChannelManager&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManager)); }
2936         ChannelManager(LDKChannelManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManager)); }
2937         operator LDKChannelManager() && { LDKChannelManager res = self; memset(&self, 0, sizeof(LDKChannelManager)); return res; }
2938         ~ChannelManager() { ChannelManager_free(self); }
2939         ChannelManager& operator=(ChannelManager&& o) { ChannelManager_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManager)); return *this; }
2940         LDKChannelManager* operator &() { return &self; }
2941         LDKChannelManager* operator ->() { return &self; }
2942         const LDKChannelManager* operator &() const { return &self; }
2943         const LDKChannelManager* operator ->() const { return &self; }
2944 };
2945 class ChainParameters {
2946 private:
2947         LDKChainParameters self;
2948 public:
2949         ChainParameters(const ChainParameters&) = delete;
2950         ChainParameters(ChainParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChainParameters)); }
2951         ChainParameters(LDKChainParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainParameters)); }
2952         operator LDKChainParameters() && { LDKChainParameters res = self; memset(&self, 0, sizeof(LDKChainParameters)); return res; }
2953         ~ChainParameters() { ChainParameters_free(self); }
2954         ChainParameters& operator=(ChainParameters&& o) { ChainParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChainParameters)); return *this; }
2955         LDKChainParameters* operator &() { return &self; }
2956         LDKChainParameters* operator ->() { return &self; }
2957         const LDKChainParameters* operator &() const { return &self; }
2958         const LDKChainParameters* operator ->() const { return &self; }
2959 };
2960 class CounterpartyForwardingInfo {
2961 private:
2962         LDKCounterpartyForwardingInfo self;
2963 public:
2964         CounterpartyForwardingInfo(const CounterpartyForwardingInfo&) = delete;
2965         CounterpartyForwardingInfo(CounterpartyForwardingInfo&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyForwardingInfo)); }
2966         CounterpartyForwardingInfo(LDKCounterpartyForwardingInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyForwardingInfo)); }
2967         operator LDKCounterpartyForwardingInfo() && { LDKCounterpartyForwardingInfo res = self; memset(&self, 0, sizeof(LDKCounterpartyForwardingInfo)); return res; }
2968         ~CounterpartyForwardingInfo() { CounterpartyForwardingInfo_free(self); }
2969         CounterpartyForwardingInfo& operator=(CounterpartyForwardingInfo&& o) { CounterpartyForwardingInfo_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyForwardingInfo)); return *this; }
2970         LDKCounterpartyForwardingInfo* operator &() { return &self; }
2971         LDKCounterpartyForwardingInfo* operator ->() { return &self; }
2972         const LDKCounterpartyForwardingInfo* operator &() const { return &self; }
2973         const LDKCounterpartyForwardingInfo* operator ->() const { return &self; }
2974 };
2975 class ChannelCounterparty {
2976 private:
2977         LDKChannelCounterparty self;
2978 public:
2979         ChannelCounterparty(const ChannelCounterparty&) = delete;
2980         ChannelCounterparty(ChannelCounterparty&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelCounterparty)); }
2981         ChannelCounterparty(LDKChannelCounterparty&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelCounterparty)); }
2982         operator LDKChannelCounterparty() && { LDKChannelCounterparty res = self; memset(&self, 0, sizeof(LDKChannelCounterparty)); return res; }
2983         ~ChannelCounterparty() { ChannelCounterparty_free(self); }
2984         ChannelCounterparty& operator=(ChannelCounterparty&& o) { ChannelCounterparty_free(self); self = o.self; memset(&o, 0, sizeof(ChannelCounterparty)); return *this; }
2985         LDKChannelCounterparty* operator &() { return &self; }
2986         LDKChannelCounterparty* operator ->() { return &self; }
2987         const LDKChannelCounterparty* operator &() const { return &self; }
2988         const LDKChannelCounterparty* operator ->() const { return &self; }
2989 };
2990 class ChannelDetails {
2991 private:
2992         LDKChannelDetails self;
2993 public:
2994         ChannelDetails(const ChannelDetails&) = delete;
2995         ChannelDetails(ChannelDetails&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDetails)); }
2996         ChannelDetails(LDKChannelDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDetails)); }
2997         operator LDKChannelDetails() && { LDKChannelDetails res = self; memset(&self, 0, sizeof(LDKChannelDetails)); return res; }
2998         ~ChannelDetails() { ChannelDetails_free(self); }
2999         ChannelDetails& operator=(ChannelDetails&& o) { ChannelDetails_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDetails)); return *this; }
3000         LDKChannelDetails* operator &() { return &self; }
3001         LDKChannelDetails* operator ->() { return &self; }
3002         const LDKChannelDetails* operator &() const { return &self; }
3003         const LDKChannelDetails* operator ->() const { return &self; }
3004 };
3005 class ChannelShutdownState {
3006 private:
3007         LDKChannelShutdownState self;
3008 public:
3009         ChannelShutdownState(const ChannelShutdownState&) = delete;
3010         ChannelShutdownState(ChannelShutdownState&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelShutdownState)); }
3011         ChannelShutdownState(LDKChannelShutdownState&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelShutdownState)); }
3012         operator LDKChannelShutdownState() && { LDKChannelShutdownState res = self; memset(&self, 0, sizeof(LDKChannelShutdownState)); return res; }
3013         ChannelShutdownState& operator=(ChannelShutdownState&& o) { self = o.self; memset(&o, 0, sizeof(ChannelShutdownState)); return *this; }
3014         LDKChannelShutdownState* operator &() { return &self; }
3015         LDKChannelShutdownState* operator ->() { return &self; }
3016         const LDKChannelShutdownState* operator &() const { return &self; }
3017         const LDKChannelShutdownState* operator ->() const { return &self; }
3018 };
3019 class RecentPaymentDetails {
3020 private:
3021         LDKRecentPaymentDetails self;
3022 public:
3023         RecentPaymentDetails(const RecentPaymentDetails&) = delete;
3024         RecentPaymentDetails(RecentPaymentDetails&& o) : self(o.self) { memset(&o, 0, sizeof(RecentPaymentDetails)); }
3025         RecentPaymentDetails(LDKRecentPaymentDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecentPaymentDetails)); }
3026         operator LDKRecentPaymentDetails() && { LDKRecentPaymentDetails res = self; memset(&self, 0, sizeof(LDKRecentPaymentDetails)); return res; }
3027         ~RecentPaymentDetails() { RecentPaymentDetails_free(self); }
3028         RecentPaymentDetails& operator=(RecentPaymentDetails&& o) { RecentPaymentDetails_free(self); self = o.self; memset(&o, 0, sizeof(RecentPaymentDetails)); return *this; }
3029         LDKRecentPaymentDetails* operator &() { return &self; }
3030         LDKRecentPaymentDetails* operator ->() { return &self; }
3031         const LDKRecentPaymentDetails* operator &() const { return &self; }
3032         const LDKRecentPaymentDetails* operator ->() const { return &self; }
3033 };
3034 class PhantomRouteHints {
3035 private:
3036         LDKPhantomRouteHints self;
3037 public:
3038         PhantomRouteHints(const PhantomRouteHints&) = delete;
3039         PhantomRouteHints(PhantomRouteHints&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomRouteHints)); }
3040         PhantomRouteHints(LDKPhantomRouteHints&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomRouteHints)); }
3041         operator LDKPhantomRouteHints() && { LDKPhantomRouteHints res = self; memset(&self, 0, sizeof(LDKPhantomRouteHints)); return res; }
3042         ~PhantomRouteHints() { PhantomRouteHints_free(self); }
3043         PhantomRouteHints& operator=(PhantomRouteHints&& o) { PhantomRouteHints_free(self); self = o.self; memset(&o, 0, sizeof(PhantomRouteHints)); return *this; }
3044         LDKPhantomRouteHints* operator &() { return &self; }
3045         LDKPhantomRouteHints* operator ->() { return &self; }
3046         const LDKPhantomRouteHints* operator &() const { return &self; }
3047         const LDKPhantomRouteHints* operator ->() const { return &self; }
3048 };
3049 class ChannelManagerReadArgs {
3050 private:
3051         LDKChannelManagerReadArgs self;
3052 public:
3053         ChannelManagerReadArgs(const ChannelManagerReadArgs&) = delete;
3054         ChannelManagerReadArgs(ChannelManagerReadArgs&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerReadArgs)); }
3055         ChannelManagerReadArgs(LDKChannelManagerReadArgs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerReadArgs)); }
3056         operator LDKChannelManagerReadArgs() && { LDKChannelManagerReadArgs res = self; memset(&self, 0, sizeof(LDKChannelManagerReadArgs)); return res; }
3057         ~ChannelManagerReadArgs() { ChannelManagerReadArgs_free(self); }
3058         ChannelManagerReadArgs& operator=(ChannelManagerReadArgs&& o) { ChannelManagerReadArgs_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManagerReadArgs)); return *this; }
3059         LDKChannelManagerReadArgs* operator &() { return &self; }
3060         LDKChannelManagerReadArgs* operator ->() { return &self; }
3061         const LDKChannelManagerReadArgs* operator &() const { return &self; }
3062         const LDKChannelManagerReadArgs* operator ->() const { return &self; }
3063 };
3064 class ChannelHandshakeConfig {
3065 private:
3066         LDKChannelHandshakeConfig self;
3067 public:
3068         ChannelHandshakeConfig(const ChannelHandshakeConfig&) = delete;
3069         ChannelHandshakeConfig(ChannelHandshakeConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeConfig)); }
3070         ChannelHandshakeConfig(LDKChannelHandshakeConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeConfig)); }
3071         operator LDKChannelHandshakeConfig() && { LDKChannelHandshakeConfig res = self; memset(&self, 0, sizeof(LDKChannelHandshakeConfig)); return res; }
3072         ~ChannelHandshakeConfig() { ChannelHandshakeConfig_free(self); }
3073         ChannelHandshakeConfig& operator=(ChannelHandshakeConfig&& o) { ChannelHandshakeConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeConfig)); return *this; }
3074         LDKChannelHandshakeConfig* operator &() { return &self; }
3075         LDKChannelHandshakeConfig* operator ->() { return &self; }
3076         const LDKChannelHandshakeConfig* operator &() const { return &self; }
3077         const LDKChannelHandshakeConfig* operator ->() const { return &self; }
3078 };
3079 class ChannelHandshakeLimits {
3080 private:
3081         LDKChannelHandshakeLimits self;
3082 public:
3083         ChannelHandshakeLimits(const ChannelHandshakeLimits&) = delete;
3084         ChannelHandshakeLimits(ChannelHandshakeLimits&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeLimits)); }
3085         ChannelHandshakeLimits(LDKChannelHandshakeLimits&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeLimits)); }
3086         operator LDKChannelHandshakeLimits() && { LDKChannelHandshakeLimits res = self; memset(&self, 0, sizeof(LDKChannelHandshakeLimits)); return res; }
3087         ~ChannelHandshakeLimits() { ChannelHandshakeLimits_free(self); }
3088         ChannelHandshakeLimits& operator=(ChannelHandshakeLimits&& o) { ChannelHandshakeLimits_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeLimits)); return *this; }
3089         LDKChannelHandshakeLimits* operator &() { return &self; }
3090         LDKChannelHandshakeLimits* operator ->() { return &self; }
3091         const LDKChannelHandshakeLimits* operator &() const { return &self; }
3092         const LDKChannelHandshakeLimits* operator ->() const { return &self; }
3093 };
3094 class MaxDustHTLCExposure {
3095 private:
3096         LDKMaxDustHTLCExposure self;
3097 public:
3098         MaxDustHTLCExposure(const MaxDustHTLCExposure&) = delete;
3099         MaxDustHTLCExposure(MaxDustHTLCExposure&& o) : self(o.self) { memset(&o, 0, sizeof(MaxDustHTLCExposure)); }
3100         MaxDustHTLCExposure(LDKMaxDustHTLCExposure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMaxDustHTLCExposure)); }
3101         operator LDKMaxDustHTLCExposure() && { LDKMaxDustHTLCExposure res = self; memset(&self, 0, sizeof(LDKMaxDustHTLCExposure)); return res; }
3102         ~MaxDustHTLCExposure() { MaxDustHTLCExposure_free(self); }
3103         MaxDustHTLCExposure& operator=(MaxDustHTLCExposure&& o) { MaxDustHTLCExposure_free(self); self = o.self; memset(&o, 0, sizeof(MaxDustHTLCExposure)); return *this; }
3104         LDKMaxDustHTLCExposure* operator &() { return &self; }
3105         LDKMaxDustHTLCExposure* operator ->() { return &self; }
3106         const LDKMaxDustHTLCExposure* operator &() const { return &self; }
3107         const LDKMaxDustHTLCExposure* operator ->() const { return &self; }
3108 };
3109 class ChannelConfig {
3110 private:
3111         LDKChannelConfig self;
3112 public:
3113         ChannelConfig(const ChannelConfig&) = delete;
3114         ChannelConfig(ChannelConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfig)); }
3115         ChannelConfig(LDKChannelConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfig)); }
3116         operator LDKChannelConfig() && { LDKChannelConfig res = self; memset(&self, 0, sizeof(LDKChannelConfig)); return res; }
3117         ~ChannelConfig() { ChannelConfig_free(self); }
3118         ChannelConfig& operator=(ChannelConfig&& o) { ChannelConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfig)); return *this; }
3119         LDKChannelConfig* operator &() { return &self; }
3120         LDKChannelConfig* operator ->() { return &self; }
3121         const LDKChannelConfig* operator &() const { return &self; }
3122         const LDKChannelConfig* operator ->() const { return &self; }
3123 };
3124 class ChannelConfigUpdate {
3125 private:
3126         LDKChannelConfigUpdate self;
3127 public:
3128         ChannelConfigUpdate(const ChannelConfigUpdate&) = delete;
3129         ChannelConfigUpdate(ChannelConfigUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfigUpdate)); }
3130         ChannelConfigUpdate(LDKChannelConfigUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfigUpdate)); }
3131         operator LDKChannelConfigUpdate() && { LDKChannelConfigUpdate res = self; memset(&self, 0, sizeof(LDKChannelConfigUpdate)); return res; }
3132         ~ChannelConfigUpdate() { ChannelConfigUpdate_free(self); }
3133         ChannelConfigUpdate& operator=(ChannelConfigUpdate&& o) { ChannelConfigUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfigUpdate)); return *this; }
3134         LDKChannelConfigUpdate* operator &() { return &self; }
3135         LDKChannelConfigUpdate* operator ->() { return &self; }
3136         const LDKChannelConfigUpdate* operator &() const { return &self; }
3137         const LDKChannelConfigUpdate* operator ->() const { return &self; }
3138 };
3139 class UserConfig {
3140 private:
3141         LDKUserConfig self;
3142 public:
3143         UserConfig(const UserConfig&) = delete;
3144         UserConfig(UserConfig&& o) : self(o.self) { memset(&o, 0, sizeof(UserConfig)); }
3145         UserConfig(LDKUserConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUserConfig)); }
3146         operator LDKUserConfig() && { LDKUserConfig res = self; memset(&self, 0, sizeof(LDKUserConfig)); return res; }
3147         ~UserConfig() { UserConfig_free(self); }
3148         UserConfig& operator=(UserConfig&& o) { UserConfig_free(self); self = o.self; memset(&o, 0, sizeof(UserConfig)); return *this; }
3149         LDKUserConfig* operator &() { return &self; }
3150         LDKUserConfig* operator ->() { return &self; }
3151         const LDKUserConfig* operator &() const { return &self; }
3152         const LDKUserConfig* operator ->() const { return &self; }
3153 };
3154 class APIError {
3155 private:
3156         LDKAPIError self;
3157 public:
3158         APIError(const APIError&) = delete;
3159         APIError(APIError&& o) : self(o.self) { memset(&o, 0, sizeof(APIError)); }
3160         APIError(LDKAPIError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAPIError)); }
3161         operator LDKAPIError() && { LDKAPIError res = self; memset(&self, 0, sizeof(LDKAPIError)); return res; }
3162         ~APIError() { APIError_free(self); }
3163         APIError& operator=(APIError&& o) { APIError_free(self); self = o.self; memset(&o, 0, sizeof(APIError)); return *this; }
3164         LDKAPIError* operator &() { return &self; }
3165         LDKAPIError* operator ->() { return &self; }
3166         const LDKAPIError* operator &() const { return &self; }
3167         const LDKAPIError* operator ->() const { return &self; }
3168 };
3169 class TaggedHash {
3170 private:
3171         LDKTaggedHash self;
3172 public:
3173         TaggedHash(const TaggedHash&) = delete;
3174         TaggedHash(TaggedHash&& o) : self(o.self) { memset(&o, 0, sizeof(TaggedHash)); }
3175         TaggedHash(LDKTaggedHash&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTaggedHash)); }
3176         operator LDKTaggedHash() && { LDKTaggedHash res = self; memset(&self, 0, sizeof(LDKTaggedHash)); return res; }
3177         ~TaggedHash() { TaggedHash_free(self); }
3178         TaggedHash& operator=(TaggedHash&& o) { TaggedHash_free(self); self = o.self; memset(&o, 0, sizeof(TaggedHash)); return *this; }
3179         LDKTaggedHash* operator &() { return &self; }
3180         LDKTaggedHash* operator ->() { return &self; }
3181         const LDKTaggedHash* operator &() const { return &self; }
3182         const LDKTaggedHash* operator ->() const { return &self; }
3183 };
3184 class SignError {
3185 private:
3186         LDKSignError self;
3187 public:
3188         SignError(const SignError&) = delete;
3189         SignError(SignError&& o) : self(o.self) { memset(&o, 0, sizeof(SignError)); }
3190         SignError(LDKSignError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignError)); }
3191         operator LDKSignError() && { LDKSignError res = self; memset(&self, 0, sizeof(LDKSignError)); return res; }
3192         ~SignError() { SignError_free(self); }
3193         SignError& operator=(SignError&& o) { SignError_free(self); self = o.self; memset(&o, 0, sizeof(SignError)); return *this; }
3194         LDKSignError* operator &() { return &self; }
3195         LDKSignError* operator ->() { return &self; }
3196         const LDKSignError* operator &() const { return &self; }
3197         const LDKSignError* operator ->() const { return &self; }
3198 };
3199 class EcdsaChannelSigner {
3200 private:
3201         LDKEcdsaChannelSigner self;
3202 public:
3203         EcdsaChannelSigner(const EcdsaChannelSigner&) = delete;
3204         EcdsaChannelSigner(EcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(EcdsaChannelSigner)); }
3205         EcdsaChannelSigner(LDKEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEcdsaChannelSigner)); }
3206         operator LDKEcdsaChannelSigner() && { LDKEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKEcdsaChannelSigner)); return res; }
3207         ~EcdsaChannelSigner() { EcdsaChannelSigner_free(self); }
3208         EcdsaChannelSigner& operator=(EcdsaChannelSigner&& o) { EcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(EcdsaChannelSigner)); return *this; }
3209         LDKEcdsaChannelSigner* operator &() { return &self; }
3210         LDKEcdsaChannelSigner* operator ->() { return &self; }
3211         const LDKEcdsaChannelSigner* operator &() const { return &self; }
3212         const LDKEcdsaChannelSigner* operator ->() const { return &self; }
3213         /**
3214          *  Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
3215          *
3216          *  Note that if signing fails or is rejected, the channel will be force-closed.
3217          *
3218          *  Policy checks should be implemented in this function, including checking the amount
3219          *  sent to us and checking the HTLCs.
3220          *
3221          *  The preimages of outbound and inbound HTLCs that were fulfilled since the last commitment
3222          *  are provided. A validating signer should ensure that an outbound HTLC output is removed
3223          *  only when the matching preimage is provided and after the corresponding inbound HTLC has
3224          *  been removed for forwarded payments.
3225          *
3226          *  Note that all the relevant preimages will be provided, but there may also be additional
3227          *  irrelevant or duplicate preimages.
3228          */
3229         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);
3230         /**
3231          *  Creates a signature for a holder's commitment transaction.
3232          *
3233          *  This will be called
3234          *  - with a non-revoked `commitment_tx`.
3235          *  - with the latest `commitment_tx` when we initiate a force-close.
3236          *
3237          *  This may be called multiple times for the same transaction.
3238          *
3239          *  An external signer implementation should check that the commitment has not been revoked.
3240          *
3241          *  An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
3242          *  signature and should be retried later. Once the signer is ready to provide a signature after
3243          *  previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
3244          *  monitor.
3245          *
3246          *  [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
3247          */
3248         inline LDK::CResult_ECDSASignatureNoneZ sign_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx);
3249         /**
3250          *  Create a signature for the given input in a transaction spending an HTLC transaction output
3251          *  or a commitment transaction `to_local` output when our counterparty broadcasts an old state.
3252          *
3253          *  A justice transaction may claim multiple outputs at the same time if timelocks are
3254          *  similar, but only a signature for the input at index `input` should be signed for here.
3255          *  It may be called multiple times for same output(s) if a fee-bump is needed with regards
3256          *  to an upcoming timelock expiration.
3257          *
3258          *  Amount is value of the output spent by this input, committed to in the BIP 143 signature.
3259          *
3260          *  `per_commitment_key` is revocation secret which was provided by our counterparty when they
3261          *  revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
3262          *  not allow the spending of any funds by itself (you need our holder `revocation_secret` to do
3263          *  so).
3264          *
3265          *  An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
3266          *  signature and should be retried later. Once the signer is ready to provide a signature after
3267          *  previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
3268          *  monitor.
3269          *
3270          *  [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
3271          */
3272         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]);
3273         /**
3274          *  Create a signature for the given input in a transaction spending a commitment transaction
3275          *  HTLC output when our counterparty broadcasts an old state.
3276          *
3277          *  A justice transaction may claim multiple outputs at the same time if timelocks are
3278          *  similar, but only a signature for the input at index `input` should be signed for here.
3279          *  It may be called multiple times for same output(s) if a fee-bump is needed with regards
3280          *  to an upcoming timelock expiration.
3281          *
3282          *  `amount` is the value of the output spent by this input, committed to in the BIP 143
3283          *  signature.
3284          *
3285          *  `per_commitment_key` is revocation secret which was provided by our counterparty when they
3286          *  revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
3287          *  not allow the spending of any funds by itself (you need our holder revocation_secret to do
3288          *  so).
3289          *
3290          *  `htlc` holds HTLC elements (hash, timelock), thus changing the format of the witness script
3291          *  (which is committed to in the BIP 143 signatures).
3292          *
3293          *  An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
3294          *  signature and should be retried later. Once the signer is ready to provide a signature after
3295          *  previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
3296          *  monitor.
3297          *
3298          *  [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
3299          */
3300         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);
3301         /**
3302          *  Computes the signature for a commitment transaction's HTLC output used as an input within
3303          *  `htlc_tx`, which spends the commitment transaction at index `input`. The signature returned
3304          *  must be be computed using [`EcdsaSighashType::All`].
3305          *
3306          *  Note that this may be called for HTLCs in the penultimate commitment transaction if a
3307          *  [`ChannelMonitor`] [replica](https://github.com/lightningdevkit/rust-lightning/blob/main/GLOSSARY.md#monitor-replicas)
3308          *  broadcasts it before receiving the update for the latest commitment transaction.
3309          *
3310          *  An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
3311          *  signature and should be retried later. Once the signer is ready to provide a signature after
3312          *  previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
3313          *  monitor.
3314          *
3315          *  [`EcdsaSighashType::All`]: bitcoin::sighash::EcdsaSighashType::All
3316          *  [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
3317          *  [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
3318          */
3319         inline LDK::CResult_ECDSASignatureNoneZ sign_holder_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor);
3320         /**
3321          *  Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment
3322          *  transaction, either offered or received.
3323          *
3324          *  Such a transaction may claim multiples offered outputs at same time if we know the
3325          *  preimage for each when we create it, but only the input at index `input` should be
3326          *  signed for here. It may be called multiple times for same output(s) if a fee-bump is
3327          *  needed with regards to an upcoming timelock expiration.
3328          *
3329          *  `witness_script` is either an offered or received script as defined in BOLT3 for HTLC
3330          *  outputs.
3331          *
3332          *  `amount` is value of the output spent by this input, committed to in the BIP 143 signature.
3333          *
3334          *  `per_commitment_point` is the dynamic point corresponding to the channel state
3335          *  detected onchain. It has been generated by our counterparty and is used to derive
3336          *  channel state keys, which are then included in the witness script and committed to in the
3337          *  BIP 143 signature.
3338          *
3339          *  An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
3340          *  signature and should be retried later. Once the signer is ready to provide a signature after
3341          *  previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
3342          *  monitor.
3343          *
3344          *  [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
3345          */
3346         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);
3347         /**
3348          *  Create a signature for a (proposed) closing transaction.
3349          *
3350          *  Note that, due to rounding, there may be one "missing" satoshi, and either party may have
3351          *  chosen to forgo their output as dust.
3352          */
3353         inline LDK::CResult_ECDSASignatureNoneZ sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx);
3354         /**
3355          *  Computes the signature for a commitment transaction's anchor output used as an
3356          *  input within `anchor_tx`, which spends the commitment transaction, at index `input`.
3357          *
3358          *  An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
3359          *  signature and should be retried later. Once the signer is ready to provide a signature after
3360          *  previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
3361          *  monitor.
3362          *
3363          *  [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
3364          */
3365         inline LDK::CResult_ECDSASignatureNoneZ sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input);
3366         /**
3367          *  Signs a channel announcement message with our funding key proving it comes from one of the
3368          *  channel participants.
3369          *
3370          *  Channel announcements also require a signature from each node's network key. Our node
3371          *  signature is computed through [`NodeSigner::sign_gossip_message`].
3372          *
3373          *  Note that if this fails or is rejected, the channel will not be publicly announced and
3374          *  our counterparty may (though likely will not) close the channel on us for violating the
3375          *  protocol.
3376          *
3377          *  [`NodeSigner::sign_gossip_message`]: crate::sign::NodeSigner::sign_gossip_message
3378          */
3379         inline LDK::CResult_ECDSASignatureNoneZ sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
3380 };
3381 class WriteableEcdsaChannelSigner {
3382 private:
3383         LDKWriteableEcdsaChannelSigner self;
3384 public:
3385         WriteableEcdsaChannelSigner(const WriteableEcdsaChannelSigner&) = delete;
3386         WriteableEcdsaChannelSigner(WriteableEcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(WriteableEcdsaChannelSigner)); }
3387         WriteableEcdsaChannelSigner(LDKWriteableEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWriteableEcdsaChannelSigner)); }
3388         operator LDKWriteableEcdsaChannelSigner() && { LDKWriteableEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKWriteableEcdsaChannelSigner)); return res; }
3389         ~WriteableEcdsaChannelSigner() { WriteableEcdsaChannelSigner_free(self); }
3390         WriteableEcdsaChannelSigner& operator=(WriteableEcdsaChannelSigner&& o) { WriteableEcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(WriteableEcdsaChannelSigner)); return *this; }
3391         LDKWriteableEcdsaChannelSigner* operator &() { return &self; }
3392         LDKWriteableEcdsaChannelSigner* operator ->() { return &self; }
3393         const LDKWriteableEcdsaChannelSigner* operator &() const { return &self; }
3394         const LDKWriteableEcdsaChannelSigner* operator ->() const { return &self; }
3395 };
3396 class ChannelMonitorUpdate {
3397 private:
3398         LDKChannelMonitorUpdate self;
3399 public:
3400         ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete;
3401         ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); }
3402         ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); }
3403         operator LDKChannelMonitorUpdate() && { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; }
3404         ~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); }
3405         ChannelMonitorUpdate& operator=(ChannelMonitorUpdate&& o) { ChannelMonitorUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdate)); return *this; }
3406         LDKChannelMonitorUpdate* operator &() { return &self; }
3407         LDKChannelMonitorUpdate* operator ->() { return &self; }
3408         const LDKChannelMonitorUpdate* operator &() const { return &self; }
3409         const LDKChannelMonitorUpdate* operator ->() const { return &self; }
3410 };
3411 class MonitorEvent {
3412 private:
3413         LDKMonitorEvent self;
3414 public:
3415         MonitorEvent(const MonitorEvent&) = delete;
3416         MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); }
3417         MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); }
3418         operator LDKMonitorEvent() && { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; }
3419         ~MonitorEvent() { MonitorEvent_free(self); }
3420         MonitorEvent& operator=(MonitorEvent&& o) { MonitorEvent_free(self); self = o.self; memset(&o, 0, sizeof(MonitorEvent)); return *this; }
3421         LDKMonitorEvent* operator &() { return &self; }
3422         LDKMonitorEvent* operator ->() { return &self; }
3423         const LDKMonitorEvent* operator &() const { return &self; }
3424         const LDKMonitorEvent* operator ->() const { return &self; }
3425 };
3426 class HTLCUpdate {
3427 private:
3428         LDKHTLCUpdate self;
3429 public:
3430         HTLCUpdate(const HTLCUpdate&) = delete;
3431         HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); }
3432         HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); }
3433         operator LDKHTLCUpdate() && { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; }
3434         ~HTLCUpdate() { HTLCUpdate_free(self); }
3435         HTLCUpdate& operator=(HTLCUpdate&& o) { HTLCUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCUpdate)); return *this; }
3436         LDKHTLCUpdate* operator &() { return &self; }
3437         LDKHTLCUpdate* operator ->() { return &self; }
3438         const LDKHTLCUpdate* operator &() const { return &self; }
3439         const LDKHTLCUpdate* operator ->() const { return &self; }
3440 };
3441 class Balance {
3442 private:
3443         LDKBalance self;
3444 public:
3445         Balance(const Balance&) = delete;
3446         Balance(Balance&& o) : self(o.self) { memset(&o, 0, sizeof(Balance)); }
3447         Balance(LDKBalance&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBalance)); }
3448         operator LDKBalance() && { LDKBalance res = self; memset(&self, 0, sizeof(LDKBalance)); return res; }
3449         ~Balance() { Balance_free(self); }
3450         Balance& operator=(Balance&& o) { Balance_free(self); self = o.self; memset(&o, 0, sizeof(Balance)); return *this; }
3451         LDKBalance* operator &() { return &self; }
3452         LDKBalance* operator ->() { return &self; }
3453         const LDKBalance* operator &() const { return &self; }
3454         const LDKBalance* operator ->() const { return &self; }
3455 };
3456 class ChannelMonitor {
3457 private:
3458         LDKChannelMonitor self;
3459 public:
3460         ChannelMonitor(const ChannelMonitor&) = delete;
3461         ChannelMonitor(ChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitor)); }
3462         ChannelMonitor(LDKChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitor)); }
3463         operator LDKChannelMonitor() && { LDKChannelMonitor res = self; memset(&self, 0, sizeof(LDKChannelMonitor)); return res; }
3464         ~ChannelMonitor() { ChannelMonitor_free(self); }
3465         ChannelMonitor& operator=(ChannelMonitor&& o) { ChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitor)); return *this; }
3466         LDKChannelMonitor* operator &() { return &self; }
3467         LDKChannelMonitor* operator ->() { return &self; }
3468         const LDKChannelMonitor* operator &() const { return &self; }
3469         const LDKChannelMonitor* operator ->() const { return &self; }
3470 };
3471 class ExpandedKey {
3472 private:
3473         LDKExpandedKey self;
3474 public:
3475         ExpandedKey(const ExpandedKey&) = delete;
3476         ExpandedKey(ExpandedKey&& o) : self(o.self) { memset(&o, 0, sizeof(ExpandedKey)); }
3477         ExpandedKey(LDKExpandedKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpandedKey)); }
3478         operator LDKExpandedKey() && { LDKExpandedKey res = self; memset(&self, 0, sizeof(LDKExpandedKey)); return res; }
3479         ~ExpandedKey() { ExpandedKey_free(self); }
3480         ExpandedKey& operator=(ExpandedKey&& o) { ExpandedKey_free(self); self = o.self; memset(&o, 0, sizeof(ExpandedKey)); return *this; }
3481         LDKExpandedKey* operator &() { return &self; }
3482         LDKExpandedKey* operator ->() { return &self; }
3483         const LDKExpandedKey* operator &() const { return &self; }
3484         const LDKExpandedKey* operator ->() const { return &self; }
3485 };
3486 class CustomMessageHandler {
3487 private:
3488         LDKCustomMessageHandler self;
3489 public:
3490         CustomMessageHandler(const CustomMessageHandler&) = delete;
3491         CustomMessageHandler(CustomMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(CustomMessageHandler)); }
3492         CustomMessageHandler(LDKCustomMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomMessageHandler)); }
3493         operator LDKCustomMessageHandler() && { LDKCustomMessageHandler res = self; memset(&self, 0, sizeof(LDKCustomMessageHandler)); return res; }
3494         ~CustomMessageHandler() { CustomMessageHandler_free(self); }
3495         CustomMessageHandler& operator=(CustomMessageHandler&& o) { CustomMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(CustomMessageHandler)); return *this; }
3496         LDKCustomMessageHandler* operator &() { return &self; }
3497         LDKCustomMessageHandler* operator ->() { return &self; }
3498         const LDKCustomMessageHandler* operator &() const { return &self; }
3499         const LDKCustomMessageHandler* operator ->() const { return &self; }
3500         /**
3501          *  Handles the given message sent from `sender_node_id`, possibly producing messages for
3502          *  [`CustomMessageHandler::get_and_clear_pending_msg`] to return and thus for [`PeerManager`]
3503          *  to send.
3504          */
3505         inline LDK::CResult_NoneLightningErrorZ handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id);
3506         /**
3507          *  Returns the list of pending messages that were generated by the handler, clearing the list
3508          *  in the process. Each message is paired with the node id of the intended recipient. If no
3509          *  connection to the node exists, then the message is simply not sent.
3510          */
3511         inline LDK::CVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg();
3512         /**
3513          *  Gets the node feature flags which this handler itself supports. All available handlers are
3514          *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
3515          *  which are broadcasted in our [`NodeAnnouncement`] message.
3516          *
3517          *  [`NodeAnnouncement`]: crate::ln::msgs::NodeAnnouncement
3518          */
3519         inline LDK::NodeFeatures provided_node_features();
3520         /**
3521          *  Gets the init feature flags which should be sent to the given peer. All available handlers
3522          *  are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
3523          *  which are sent in our [`Init`] message.
3524          *
3525          *  [`Init`]: crate::ln::msgs::Init
3526          */
3527         inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
3528 };
3529 class IgnoringMessageHandler {
3530 private:
3531         LDKIgnoringMessageHandler self;
3532 public:
3533         IgnoringMessageHandler(const IgnoringMessageHandler&) = delete;
3534         IgnoringMessageHandler(IgnoringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(IgnoringMessageHandler)); }
3535         IgnoringMessageHandler(LDKIgnoringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKIgnoringMessageHandler)); }
3536         operator LDKIgnoringMessageHandler() && { LDKIgnoringMessageHandler res = self; memset(&self, 0, sizeof(LDKIgnoringMessageHandler)); return res; }
3537         ~IgnoringMessageHandler() { IgnoringMessageHandler_free(self); }
3538         IgnoringMessageHandler& operator=(IgnoringMessageHandler&& o) { IgnoringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(IgnoringMessageHandler)); return *this; }
3539         LDKIgnoringMessageHandler* operator &() { return &self; }
3540         LDKIgnoringMessageHandler* operator ->() { return &self; }
3541         const LDKIgnoringMessageHandler* operator &() const { return &self; }
3542         const LDKIgnoringMessageHandler* operator ->() const { return &self; }
3543 };
3544 class ErroringMessageHandler {
3545 private:
3546         LDKErroringMessageHandler self;
3547 public:
3548         ErroringMessageHandler(const ErroringMessageHandler&) = delete;
3549         ErroringMessageHandler(ErroringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ErroringMessageHandler)); }
3550         ErroringMessageHandler(LDKErroringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroringMessageHandler)); }
3551         operator LDKErroringMessageHandler() && { LDKErroringMessageHandler res = self; memset(&self, 0, sizeof(LDKErroringMessageHandler)); return res; }
3552         ~ErroringMessageHandler() { ErroringMessageHandler_free(self); }
3553         ErroringMessageHandler& operator=(ErroringMessageHandler&& o) { ErroringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ErroringMessageHandler)); return *this; }
3554         LDKErroringMessageHandler* operator &() { return &self; }
3555         LDKErroringMessageHandler* operator ->() { return &self; }
3556         const LDKErroringMessageHandler* operator &() const { return &self; }
3557         const LDKErroringMessageHandler* operator ->() const { return &self; }
3558 };
3559 class MessageHandler {
3560 private:
3561         LDKMessageHandler self;
3562 public:
3563         MessageHandler(const MessageHandler&) = delete;
3564         MessageHandler(MessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(MessageHandler)); }
3565         MessageHandler(LDKMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageHandler)); }
3566         operator LDKMessageHandler() && { LDKMessageHandler res = self; memset(&self, 0, sizeof(LDKMessageHandler)); return res; }
3567         ~MessageHandler() { MessageHandler_free(self); }
3568         MessageHandler& operator=(MessageHandler&& o) { MessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(MessageHandler)); return *this; }
3569         LDKMessageHandler* operator &() { return &self; }
3570         LDKMessageHandler* operator ->() { return &self; }
3571         const LDKMessageHandler* operator &() const { return &self; }
3572         const LDKMessageHandler* operator ->() const { return &self; }
3573 };
3574 class SocketDescriptor {
3575 private:
3576         LDKSocketDescriptor self;
3577 public:
3578         SocketDescriptor(const SocketDescriptor&) = delete;
3579         SocketDescriptor(SocketDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SocketDescriptor)); }
3580         SocketDescriptor(LDKSocketDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketDescriptor)); }
3581         operator LDKSocketDescriptor() && { LDKSocketDescriptor res = self; memset(&self, 0, sizeof(LDKSocketDescriptor)); return res; }
3582         ~SocketDescriptor() { SocketDescriptor_free(self); }
3583         SocketDescriptor& operator=(SocketDescriptor&& o) { SocketDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SocketDescriptor)); return *this; }
3584         LDKSocketDescriptor* operator &() { return &self; }
3585         LDKSocketDescriptor* operator ->() { return &self; }
3586         const LDKSocketDescriptor* operator &() const { return &self; }
3587         const LDKSocketDescriptor* operator ->() const { return &self; }
3588         /**
3589          *  Attempts to send some data from the given slice to the peer.
3590          *
3591          *  Returns the amount of data which was sent, possibly 0 if the socket has since disconnected.
3592          *  Note that in the disconnected case, [`PeerManager::socket_disconnected`] must still be
3593          *  called and further write attempts may occur until that time.
3594          *
3595          *  If the returned size is smaller than `data.len()`, a
3596          *  [`PeerManager::write_buffer_space_avail`] call must be made the next time more data can be
3597          *  written. Additionally, until a `send_data` event completes fully, no further
3598          *  [`PeerManager::read_event`] calls should be made for the same peer! Because this is to
3599          *  prevent denial-of-service issues, you should not read or buffer any data from the socket
3600          *  until then.
3601          *
3602          *  If a [`PeerManager::read_event`] call on this descriptor had previously returned true
3603          *  (indicating that read events should be paused to prevent DoS in the send buffer),
3604          *  `resume_read` may be set indicating that read events on this descriptor should resume. A
3605          *  `resume_read` of false carries no meaning, and should not cause any action.
3606          */
3607         inline uintptr_t send_data(struct LDKu8slice data, bool resume_read);
3608         /**
3609          *  Disconnect the socket pointed to by this SocketDescriptor.
3610          *
3611          *  You do *not* need to call [`PeerManager::socket_disconnected`] with this socket after this
3612          *  call (doing so is a noop).
3613          */
3614         inline void disconnect_socket();
3615         /** Checks if two objects are equal given this object's this_arg pointer and another object. */
3616         inline bool eq(const struct LDKSocketDescriptor *NONNULL_PTR other_arg);
3617         /**
3618          * Calculate a succinct non-cryptographic hash for an object given its this_arg pointer.
3619          * This is used, for example, for inclusion of this object in a hash map.
3620          */
3621         inline uint64_t hash();
3622 };
3623 class PeerDetails {
3624 private:
3625         LDKPeerDetails self;
3626 public:
3627         PeerDetails(const PeerDetails&) = delete;
3628         PeerDetails(PeerDetails&& o) : self(o.self) { memset(&o, 0, sizeof(PeerDetails)); }
3629         PeerDetails(LDKPeerDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerDetails)); }
3630         operator LDKPeerDetails() && { LDKPeerDetails res = self; memset(&self, 0, sizeof(LDKPeerDetails)); return res; }
3631         ~PeerDetails() { PeerDetails_free(self); }
3632         PeerDetails& operator=(PeerDetails&& o) { PeerDetails_free(self); self = o.self; memset(&o, 0, sizeof(PeerDetails)); return *this; }
3633         LDKPeerDetails* operator &() { return &self; }
3634         LDKPeerDetails* operator ->() { return &self; }
3635         const LDKPeerDetails* operator &() const { return &self; }
3636         const LDKPeerDetails* operator ->() const { return &self; }
3637 };
3638 class PeerHandleError {
3639 private:
3640         LDKPeerHandleError self;
3641 public:
3642         PeerHandleError(const PeerHandleError&) = delete;
3643         PeerHandleError(PeerHandleError&& o) : self(o.self) { memset(&o, 0, sizeof(PeerHandleError)); }
3644         PeerHandleError(LDKPeerHandleError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerHandleError)); }
3645         operator LDKPeerHandleError() && { LDKPeerHandleError res = self; memset(&self, 0, sizeof(LDKPeerHandleError)); return res; }
3646         ~PeerHandleError() { PeerHandleError_free(self); }
3647         PeerHandleError& operator=(PeerHandleError&& o) { PeerHandleError_free(self); self = o.self; memset(&o, 0, sizeof(PeerHandleError)); return *this; }
3648         LDKPeerHandleError* operator &() { return &self; }
3649         LDKPeerHandleError* operator ->() { return &self; }
3650         const LDKPeerHandleError* operator &() const { return &self; }
3651         const LDKPeerHandleError* operator ->() const { return &self; }
3652 };
3653 class PeerManager {
3654 private:
3655         LDKPeerManager self;
3656 public:
3657         PeerManager(const PeerManager&) = delete;
3658         PeerManager(PeerManager&& o) : self(o.self) { memset(&o, 0, sizeof(PeerManager)); }
3659         PeerManager(LDKPeerManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerManager)); }
3660         operator LDKPeerManager() && { LDKPeerManager res = self; memset(&self, 0, sizeof(LDKPeerManager)); return res; }
3661         ~PeerManager() { PeerManager_free(self); }
3662         PeerManager& operator=(PeerManager&& o) { PeerManager_free(self); self = o.self; memset(&o, 0, sizeof(PeerManager)); return *this; }
3663         LDKPeerManager* operator &() { return &self; }
3664         LDKPeerManager* operator ->() { return &self; }
3665         const LDKPeerManager* operator &() const { return &self; }
3666         const LDKPeerManager* operator ->() const { return &self; }
3667 };
3668 class GraphSyncError {
3669 private:
3670         LDKGraphSyncError self;
3671 public:
3672         GraphSyncError(const GraphSyncError&) = delete;
3673         GraphSyncError(GraphSyncError&& o) : self(o.self) { memset(&o, 0, sizeof(GraphSyncError)); }
3674         GraphSyncError(LDKGraphSyncError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGraphSyncError)); }
3675         operator LDKGraphSyncError() && { LDKGraphSyncError res = self; memset(&self, 0, sizeof(LDKGraphSyncError)); return res; }
3676         ~GraphSyncError() { GraphSyncError_free(self); }
3677         GraphSyncError& operator=(GraphSyncError&& o) { GraphSyncError_free(self); self = o.self; memset(&o, 0, sizeof(GraphSyncError)); return *this; }
3678         LDKGraphSyncError* operator &() { return &self; }
3679         LDKGraphSyncError* operator ->() { return &self; }
3680         const LDKGraphSyncError* operator &() const { return &self; }
3681         const LDKGraphSyncError* operator ->() const { return &self; }
3682 };
3683 class RapidGossipSync {
3684 private:
3685         LDKRapidGossipSync self;
3686 public:
3687         RapidGossipSync(const RapidGossipSync&) = delete;
3688         RapidGossipSync(RapidGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(RapidGossipSync)); }
3689         RapidGossipSync(LDKRapidGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRapidGossipSync)); }
3690         operator LDKRapidGossipSync() && { LDKRapidGossipSync res = self; memset(&self, 0, sizeof(LDKRapidGossipSync)); return res; }
3691         ~RapidGossipSync() { RapidGossipSync_free(self); }
3692         RapidGossipSync& operator=(RapidGossipSync&& o) { RapidGossipSync_free(self); self = o.self; memset(&o, 0, sizeof(RapidGossipSync)); return *this; }
3693         LDKRapidGossipSync* operator &() { return &self; }
3694         LDKRapidGossipSync* operator ->() { return &self; }
3695         const LDKRapidGossipSync* operator &() const { return &self; }
3696         const LDKRapidGossipSync* operator ->() const { return &self; }
3697 };
3698 class KVStore {
3699 private:
3700         LDKKVStore self;
3701 public:
3702         KVStore(const KVStore&) = delete;
3703         KVStore(KVStore&& o) : self(o.self) { memset(&o, 0, sizeof(KVStore)); }
3704         KVStore(LDKKVStore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKVStore)); }
3705         operator LDKKVStore() && { LDKKVStore res = self; memset(&self, 0, sizeof(LDKKVStore)); return res; }
3706         ~KVStore() { KVStore_free(self); }
3707         KVStore& operator=(KVStore&& o) { KVStore_free(self); self = o.self; memset(&o, 0, sizeof(KVStore)); return *this; }
3708         LDKKVStore* operator &() { return &self; }
3709         LDKKVStore* operator ->() { return &self; }
3710         const LDKKVStore* operator &() const { return &self; }
3711         const LDKKVStore* operator ->() const { return &self; }
3712         /**
3713          *  Returns the data stored for the given `primary_namespace`, `secondary_namespace`, and
3714          *  `key`.
3715          *
3716          *  Returns an [`ErrorKind::NotFound`] if the given `key` could not be found in the given
3717          *  `primary_namespace` and `secondary_namespace`.
3718          *
3719          *  [`ErrorKind::NotFound`]: io::ErrorKind::NotFound
3720          */
3721         inline LDK::CResult_CVec_u8ZIOErrorZ read(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key);
3722         /**
3723          *  Persists the given data under the given `key`.
3724          *
3725          *  Will create the given `primary_namespace` and `secondary_namespace` if not already present
3726          *  in the store.
3727          */
3728         inline LDK::CResult_NoneIOErrorZ write(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, struct LDKu8slice buf);
3729         /**
3730          *  Removes any data that had previously been persisted under the given `key`.
3731          *
3732          *  If the `lazy` flag is set to `true`, the backend implementation might choose to lazily
3733          *  remove the given `key` at some point in time after the method returns, e.g., as part of an
3734          *  eventual batch deletion of multiple keys. As a consequence, subsequent calls to
3735          *  [`KVStore::list`] might include the removed key until the changes are actually persisted.
3736          *
3737          *  Note that while setting the `lazy` flag reduces the I/O burden of multiple subsequent
3738          *  `remove` calls, it also influences the atomicity guarantees as lazy `remove`s could
3739          *  potentially get lost on crash after the method returns. Therefore, this flag should only be
3740          *  set for `remove` operations that can be safely replayed at a later time.
3741          *
3742          *  Returns successfully if no data will be stored for the given `primary_namespace`,
3743          *  `secondary_namespace`, and `key`, independently of whether it was present before its
3744          *  invokation or not.
3745          */
3746         inline LDK::CResult_NoneIOErrorZ remove(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, bool lazy);
3747         /**
3748          *  Returns a list of keys that are stored under the given `secondary_namespace` in
3749          *  `primary_namespace`.
3750          *
3751          *  Returns the keys in arbitrary order, so users requiring a particular order need to sort the
3752          *  returned keys. Returns an empty list if `primary_namespace` or `secondary_namespace` is unknown.
3753          */
3754         inline LDK::CResult_CVec_StrZIOErrorZ list(struct LDKStr primary_namespace, struct LDKStr secondary_namespace);
3755 };
3756 class Persister {
3757 private:
3758         LDKPersister self;
3759 public:
3760         Persister(const Persister&) = delete;
3761         Persister(Persister&& o) : self(o.self) { memset(&o, 0, sizeof(Persister)); }
3762         Persister(LDKPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersister)); }
3763         operator LDKPersister() && { LDKPersister res = self; memset(&self, 0, sizeof(LDKPersister)); return res; }
3764         ~Persister() { Persister_free(self); }
3765         Persister& operator=(Persister&& o) { Persister_free(self); self = o.self; memset(&o, 0, sizeof(Persister)); return *this; }
3766         LDKPersister* operator &() { return &self; }
3767         LDKPersister* operator ->() { return &self; }
3768         const LDKPersister* operator &() const { return &self; }
3769         const LDKPersister* operator ->() const { return &self; }
3770         /**
3771          *  Persist the given ['ChannelManager'] to disk, returning an error if persistence failed.
3772          *
3773          *  [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
3774          */
3775         inline LDK::CResult_NoneIOErrorZ persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager);
3776         /**
3777          *  Persist the given [`NetworkGraph`] to disk, returning an error if persistence failed.
3778          */
3779         inline LDK::CResult_NoneIOErrorZ persist_graph(const struct LDKNetworkGraph *NONNULL_PTR network_graph);
3780         /**
3781          *  Persist the given [`WriteableScore`] to disk, returning an error if persistence failed.
3782          */
3783         inline LDK::CResult_NoneIOErrorZ persist_scorer(const struct LDKWriteableScore *NONNULL_PTR scorer);
3784 };
3785 class MonitorUpdatingPersister {
3786 private:
3787         LDKMonitorUpdatingPersister self;
3788 public:
3789         MonitorUpdatingPersister(const MonitorUpdatingPersister&) = delete;
3790         MonitorUpdatingPersister(MonitorUpdatingPersister&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdatingPersister)); }
3791         MonitorUpdatingPersister(LDKMonitorUpdatingPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdatingPersister)); }
3792         operator LDKMonitorUpdatingPersister() && { LDKMonitorUpdatingPersister res = self; memset(&self, 0, sizeof(LDKMonitorUpdatingPersister)); return res; }
3793         ~MonitorUpdatingPersister() { MonitorUpdatingPersister_free(self); }
3794         MonitorUpdatingPersister& operator=(MonitorUpdatingPersister&& o) { MonitorUpdatingPersister_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdatingPersister)); return *this; }
3795         LDKMonitorUpdatingPersister* operator &() { return &self; }
3796         LDKMonitorUpdatingPersister* operator ->() { return &self; }
3797         const LDKMonitorUpdatingPersister* operator &() const { return &self; }
3798         const LDKMonitorUpdatingPersister* operator ->() const { return &self; }
3799 };
3800 class InvoiceRequestWithExplicitPayerIdBuilder {
3801 private:
3802         LDKInvoiceRequestWithExplicitPayerIdBuilder self;
3803 public:
3804         InvoiceRequestWithExplicitPayerIdBuilder(const InvoiceRequestWithExplicitPayerIdBuilder&) = delete;
3805         InvoiceRequestWithExplicitPayerIdBuilder(InvoiceRequestWithExplicitPayerIdBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestWithExplicitPayerIdBuilder)); }
3806         InvoiceRequestWithExplicitPayerIdBuilder(LDKInvoiceRequestWithExplicitPayerIdBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestWithExplicitPayerIdBuilder)); }
3807         operator LDKInvoiceRequestWithExplicitPayerIdBuilder() && { LDKInvoiceRequestWithExplicitPayerIdBuilder res = self; memset(&self, 0, sizeof(LDKInvoiceRequestWithExplicitPayerIdBuilder)); return res; }
3808         ~InvoiceRequestWithExplicitPayerIdBuilder() { InvoiceRequestWithExplicitPayerIdBuilder_free(self); }
3809         InvoiceRequestWithExplicitPayerIdBuilder& operator=(InvoiceRequestWithExplicitPayerIdBuilder&& o) { InvoiceRequestWithExplicitPayerIdBuilder_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestWithExplicitPayerIdBuilder)); return *this; }
3810         LDKInvoiceRequestWithExplicitPayerIdBuilder* operator &() { return &self; }
3811         LDKInvoiceRequestWithExplicitPayerIdBuilder* operator ->() { return &self; }
3812         const LDKInvoiceRequestWithExplicitPayerIdBuilder* operator &() const { return &self; }
3813         const LDKInvoiceRequestWithExplicitPayerIdBuilder* operator ->() const { return &self; }
3814 };
3815 class InvoiceRequestWithDerivedPayerIdBuilder {
3816 private:
3817         LDKInvoiceRequestWithDerivedPayerIdBuilder self;
3818 public:
3819         InvoiceRequestWithDerivedPayerIdBuilder(const InvoiceRequestWithDerivedPayerIdBuilder&) = delete;
3820         InvoiceRequestWithDerivedPayerIdBuilder(InvoiceRequestWithDerivedPayerIdBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestWithDerivedPayerIdBuilder)); }
3821         InvoiceRequestWithDerivedPayerIdBuilder(LDKInvoiceRequestWithDerivedPayerIdBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestWithDerivedPayerIdBuilder)); }
3822         operator LDKInvoiceRequestWithDerivedPayerIdBuilder() && { LDKInvoiceRequestWithDerivedPayerIdBuilder res = self; memset(&self, 0, sizeof(LDKInvoiceRequestWithDerivedPayerIdBuilder)); return res; }
3823         ~InvoiceRequestWithDerivedPayerIdBuilder() { InvoiceRequestWithDerivedPayerIdBuilder_free(self); }
3824         InvoiceRequestWithDerivedPayerIdBuilder& operator=(InvoiceRequestWithDerivedPayerIdBuilder&& o) { InvoiceRequestWithDerivedPayerIdBuilder_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestWithDerivedPayerIdBuilder)); return *this; }
3825         LDKInvoiceRequestWithDerivedPayerIdBuilder* operator &() { return &self; }
3826         LDKInvoiceRequestWithDerivedPayerIdBuilder* operator ->() { return &self; }
3827         const LDKInvoiceRequestWithDerivedPayerIdBuilder* operator &() const { return &self; }
3828         const LDKInvoiceRequestWithDerivedPayerIdBuilder* operator ->() const { return &self; }
3829 };
3830 class UnsignedInvoiceRequest {
3831 private:
3832         LDKUnsignedInvoiceRequest self;
3833 public:
3834         UnsignedInvoiceRequest(const UnsignedInvoiceRequest&) = delete;
3835         UnsignedInvoiceRequest(UnsignedInvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedInvoiceRequest)); }
3836         UnsignedInvoiceRequest(LDKUnsignedInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedInvoiceRequest)); }
3837         operator LDKUnsignedInvoiceRequest() && { LDKUnsignedInvoiceRequest res = self; memset(&self, 0, sizeof(LDKUnsignedInvoiceRequest)); return res; }
3838         ~UnsignedInvoiceRequest() { UnsignedInvoiceRequest_free(self); }
3839         UnsignedInvoiceRequest& operator=(UnsignedInvoiceRequest&& o) { UnsignedInvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedInvoiceRequest)); return *this; }
3840         LDKUnsignedInvoiceRequest* operator &() { return &self; }
3841         LDKUnsignedInvoiceRequest* operator ->() { return &self; }
3842         const LDKUnsignedInvoiceRequest* operator &() const { return &self; }
3843         const LDKUnsignedInvoiceRequest* operator ->() const { return &self; }
3844 };
3845 class SignInvoiceRequestFn {
3846 private:
3847         LDKSignInvoiceRequestFn self;
3848 public:
3849         SignInvoiceRequestFn(const SignInvoiceRequestFn&) = delete;
3850         SignInvoiceRequestFn(SignInvoiceRequestFn&& o) : self(o.self) { memset(&o, 0, sizeof(SignInvoiceRequestFn)); }
3851         SignInvoiceRequestFn(LDKSignInvoiceRequestFn&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignInvoiceRequestFn)); }
3852         operator LDKSignInvoiceRequestFn() && { LDKSignInvoiceRequestFn res = self; memset(&self, 0, sizeof(LDKSignInvoiceRequestFn)); return res; }
3853         ~SignInvoiceRequestFn() { SignInvoiceRequestFn_free(self); }
3854         SignInvoiceRequestFn& operator=(SignInvoiceRequestFn&& o) { SignInvoiceRequestFn_free(self); self = o.self; memset(&o, 0, sizeof(SignInvoiceRequestFn)); return *this; }
3855         LDKSignInvoiceRequestFn* operator &() { return &self; }
3856         LDKSignInvoiceRequestFn* operator ->() { return &self; }
3857         const LDKSignInvoiceRequestFn* operator &() const { return &self; }
3858         const LDKSignInvoiceRequestFn* operator ->() const { return &self; }
3859         /**
3860          *  Signs a [`TaggedHash`] computed over the merkle root of `message`'s TLV stream.
3861          */
3862         inline LDK::CResult_SchnorrSignatureNoneZ sign_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR message);
3863 };
3864 class InvoiceRequest {
3865 private:
3866         LDKInvoiceRequest self;
3867 public:
3868         InvoiceRequest(const InvoiceRequest&) = delete;
3869         InvoiceRequest(InvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequest)); }
3870         InvoiceRequest(LDKInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequest)); }
3871         operator LDKInvoiceRequest() && { LDKInvoiceRequest res = self; memset(&self, 0, sizeof(LDKInvoiceRequest)); return res; }
3872         ~InvoiceRequest() { InvoiceRequest_free(self); }
3873         InvoiceRequest& operator=(InvoiceRequest&& o) { InvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequest)); return *this; }
3874         LDKInvoiceRequest* operator &() { return &self; }
3875         LDKInvoiceRequest* operator ->() { return &self; }
3876         const LDKInvoiceRequest* operator &() const { return &self; }
3877         const LDKInvoiceRequest* operator ->() const { return &self; }
3878 };
3879 class VerifiedInvoiceRequest {
3880 private:
3881         LDKVerifiedInvoiceRequest self;
3882 public:
3883         VerifiedInvoiceRequest(const VerifiedInvoiceRequest&) = delete;
3884         VerifiedInvoiceRequest(VerifiedInvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(VerifiedInvoiceRequest)); }
3885         VerifiedInvoiceRequest(LDKVerifiedInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKVerifiedInvoiceRequest)); }
3886         operator LDKVerifiedInvoiceRequest() && { LDKVerifiedInvoiceRequest res = self; memset(&self, 0, sizeof(LDKVerifiedInvoiceRequest)); return res; }
3887         ~VerifiedInvoiceRequest() { VerifiedInvoiceRequest_free(self); }
3888         VerifiedInvoiceRequest& operator=(VerifiedInvoiceRequest&& o) { VerifiedInvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(VerifiedInvoiceRequest)); return *this; }
3889         LDKVerifiedInvoiceRequest* operator &() { return &self; }
3890         LDKVerifiedInvoiceRequest* operator ->() { return &self; }
3891         const LDKVerifiedInvoiceRequest* operator &() const { return &self; }
3892         const LDKVerifiedInvoiceRequest* operator ->() const { return &self; }
3893 };
3894 class InvoiceRequestFields {
3895 private:
3896         LDKInvoiceRequestFields self;
3897 public:
3898         InvoiceRequestFields(const InvoiceRequestFields&) = delete;
3899         InvoiceRequestFields(InvoiceRequestFields&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestFields)); }
3900         InvoiceRequestFields(LDKInvoiceRequestFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestFields)); }
3901         operator LDKInvoiceRequestFields() && { LDKInvoiceRequestFields res = self; memset(&self, 0, sizeof(LDKInvoiceRequestFields)); return res; }
3902         ~InvoiceRequestFields() { InvoiceRequestFields_free(self); }
3903         InvoiceRequestFields& operator=(InvoiceRequestFields&& o) { InvoiceRequestFields_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestFields)); return *this; }
3904         LDKInvoiceRequestFields* operator &() { return &self; }
3905         LDKInvoiceRequestFields* operator ->() { return &self; }
3906         const LDKInvoiceRequestFields* operator &() const { return &self; }
3907         const LDKInvoiceRequestFields* operator ->() const { return &self; }
3908 };
3909 class DecodeError {
3910 private:
3911         LDKDecodeError self;
3912 public:
3913         DecodeError(const DecodeError&) = delete;
3914         DecodeError(DecodeError&& o) : self(o.self) { memset(&o, 0, sizeof(DecodeError)); }
3915         DecodeError(LDKDecodeError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDecodeError)); }
3916         operator LDKDecodeError() && { LDKDecodeError res = self; memset(&self, 0, sizeof(LDKDecodeError)); return res; }
3917         ~DecodeError() { DecodeError_free(self); }
3918         DecodeError& operator=(DecodeError&& o) { DecodeError_free(self); self = o.self; memset(&o, 0, sizeof(DecodeError)); return *this; }
3919         LDKDecodeError* operator &() { return &self; }
3920         LDKDecodeError* operator ->() { return &self; }
3921         const LDKDecodeError* operator &() const { return &self; }
3922         const LDKDecodeError* operator ->() const { return &self; }
3923 };
3924 class Init {
3925 private:
3926         LDKInit self;
3927 public:
3928         Init(const Init&) = delete;
3929         Init(Init&& o) : self(o.self) { memset(&o, 0, sizeof(Init)); }
3930         Init(LDKInit&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInit)); }
3931         operator LDKInit() && { LDKInit res = self; memset(&self, 0, sizeof(LDKInit)); return res; }
3932         ~Init() { Init_free(self); }
3933         Init& operator=(Init&& o) { Init_free(self); self = o.self; memset(&o, 0, sizeof(Init)); return *this; }
3934         LDKInit* operator &() { return &self; }
3935         LDKInit* operator ->() { return &self; }
3936         const LDKInit* operator &() const { return &self; }
3937         const LDKInit* operator ->() const { return &self; }
3938 };
3939 class ErrorMessage {
3940 private:
3941         LDKErrorMessage self;
3942 public:
3943         ErrorMessage(const ErrorMessage&) = delete;
3944         ErrorMessage(ErrorMessage&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorMessage)); }
3945         ErrorMessage(LDKErrorMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorMessage)); }
3946         operator LDKErrorMessage() && { LDKErrorMessage res = self; memset(&self, 0, sizeof(LDKErrorMessage)); return res; }
3947         ~ErrorMessage() { ErrorMessage_free(self); }
3948         ErrorMessage& operator=(ErrorMessage&& o) { ErrorMessage_free(self); self = o.self; memset(&o, 0, sizeof(ErrorMessage)); return *this; }
3949         LDKErrorMessage* operator &() { return &self; }
3950         LDKErrorMessage* operator ->() { return &self; }
3951         const LDKErrorMessage* operator &() const { return &self; }
3952         const LDKErrorMessage* operator ->() const { return &self; }
3953 };
3954 class WarningMessage {
3955 private:
3956         LDKWarningMessage self;
3957 public:
3958         WarningMessage(const WarningMessage&) = delete;
3959         WarningMessage(WarningMessage&& o) : self(o.self) { memset(&o, 0, sizeof(WarningMessage)); }
3960         WarningMessage(LDKWarningMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWarningMessage)); }
3961         operator LDKWarningMessage() && { LDKWarningMessage res = self; memset(&self, 0, sizeof(LDKWarningMessage)); return res; }
3962         ~WarningMessage() { WarningMessage_free(self); }
3963         WarningMessage& operator=(WarningMessage&& o) { WarningMessage_free(self); self = o.self; memset(&o, 0, sizeof(WarningMessage)); return *this; }
3964         LDKWarningMessage* operator &() { return &self; }
3965         LDKWarningMessage* operator ->() { return &self; }
3966         const LDKWarningMessage* operator &() const { return &self; }
3967         const LDKWarningMessage* operator ->() const { return &self; }
3968 };
3969 class Ping {
3970 private:
3971         LDKPing self;
3972 public:
3973         Ping(const Ping&) = delete;
3974         Ping(Ping&& o) : self(o.self) { memset(&o, 0, sizeof(Ping)); }
3975         Ping(LDKPing&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPing)); }
3976         operator LDKPing() && { LDKPing res = self; memset(&self, 0, sizeof(LDKPing)); return res; }
3977         ~Ping() { Ping_free(self); }
3978         Ping& operator=(Ping&& o) { Ping_free(self); self = o.self; memset(&o, 0, sizeof(Ping)); return *this; }
3979         LDKPing* operator &() { return &self; }
3980         LDKPing* operator ->() { return &self; }
3981         const LDKPing* operator &() const { return &self; }
3982         const LDKPing* operator ->() const { return &self; }
3983 };
3984 class Pong {
3985 private:
3986         LDKPong self;
3987 public:
3988         Pong(const Pong&) = delete;
3989         Pong(Pong&& o) : self(o.self) { memset(&o, 0, sizeof(Pong)); }
3990         Pong(LDKPong&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPong)); }
3991         operator LDKPong() && { LDKPong res = self; memset(&self, 0, sizeof(LDKPong)); return res; }
3992         ~Pong() { Pong_free(self); }
3993         Pong& operator=(Pong&& o) { Pong_free(self); self = o.self; memset(&o, 0, sizeof(Pong)); return *this; }
3994         LDKPong* operator &() { return &self; }
3995         LDKPong* operator ->() { return &self; }
3996         const LDKPong* operator &() const { return &self; }
3997         const LDKPong* operator ->() const { return &self; }
3998 };
3999 class CommonOpenChannelFields {
4000 private:
4001         LDKCommonOpenChannelFields self;
4002 public:
4003         CommonOpenChannelFields(const CommonOpenChannelFields&) = delete;
4004         CommonOpenChannelFields(CommonOpenChannelFields&& o) : self(o.self) { memset(&o, 0, sizeof(CommonOpenChannelFields)); }
4005         CommonOpenChannelFields(LDKCommonOpenChannelFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommonOpenChannelFields)); }
4006         operator LDKCommonOpenChannelFields() && { LDKCommonOpenChannelFields res = self; memset(&self, 0, sizeof(LDKCommonOpenChannelFields)); return res; }
4007         ~CommonOpenChannelFields() { CommonOpenChannelFields_free(self); }
4008         CommonOpenChannelFields& operator=(CommonOpenChannelFields&& o) { CommonOpenChannelFields_free(self); self = o.self; memset(&o, 0, sizeof(CommonOpenChannelFields)); return *this; }
4009         LDKCommonOpenChannelFields* operator &() { return &self; }
4010         LDKCommonOpenChannelFields* operator ->() { return &self; }
4011         const LDKCommonOpenChannelFields* operator &() const { return &self; }
4012         const LDKCommonOpenChannelFields* operator ->() const { return &self; }
4013 };
4014 class OpenChannel {
4015 private:
4016         LDKOpenChannel self;
4017 public:
4018         OpenChannel(const OpenChannel&) = delete;
4019         OpenChannel(OpenChannel&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannel)); }
4020         OpenChannel(LDKOpenChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannel)); }
4021         operator LDKOpenChannel() && { LDKOpenChannel res = self; memset(&self, 0, sizeof(LDKOpenChannel)); return res; }
4022         ~OpenChannel() { OpenChannel_free(self); }
4023         OpenChannel& operator=(OpenChannel&& o) { OpenChannel_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannel)); return *this; }
4024         LDKOpenChannel* operator &() { return &self; }
4025         LDKOpenChannel* operator ->() { return &self; }
4026         const LDKOpenChannel* operator &() const { return &self; }
4027         const LDKOpenChannel* operator ->() const { return &self; }
4028 };
4029 class OpenChannelV2 {
4030 private:
4031         LDKOpenChannelV2 self;
4032 public:
4033         OpenChannelV2(const OpenChannelV2&) = delete;
4034         OpenChannelV2(OpenChannelV2&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannelV2)); }
4035         OpenChannelV2(LDKOpenChannelV2&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannelV2)); }
4036         operator LDKOpenChannelV2() && { LDKOpenChannelV2 res = self; memset(&self, 0, sizeof(LDKOpenChannelV2)); return res; }
4037         ~OpenChannelV2() { OpenChannelV2_free(self); }
4038         OpenChannelV2& operator=(OpenChannelV2&& o) { OpenChannelV2_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannelV2)); return *this; }
4039         LDKOpenChannelV2* operator &() { return &self; }
4040         LDKOpenChannelV2* operator ->() { return &self; }
4041         const LDKOpenChannelV2* operator &() const { return &self; }
4042         const LDKOpenChannelV2* operator ->() const { return &self; }
4043 };
4044 class CommonAcceptChannelFields {
4045 private:
4046         LDKCommonAcceptChannelFields self;
4047 public:
4048         CommonAcceptChannelFields(const CommonAcceptChannelFields&) = delete;
4049         CommonAcceptChannelFields(CommonAcceptChannelFields&& o) : self(o.self) { memset(&o, 0, sizeof(CommonAcceptChannelFields)); }
4050         CommonAcceptChannelFields(LDKCommonAcceptChannelFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommonAcceptChannelFields)); }
4051         operator LDKCommonAcceptChannelFields() && { LDKCommonAcceptChannelFields res = self; memset(&self, 0, sizeof(LDKCommonAcceptChannelFields)); return res; }
4052         ~CommonAcceptChannelFields() { CommonAcceptChannelFields_free(self); }
4053         CommonAcceptChannelFields& operator=(CommonAcceptChannelFields&& o) { CommonAcceptChannelFields_free(self); self = o.self; memset(&o, 0, sizeof(CommonAcceptChannelFields)); return *this; }
4054         LDKCommonAcceptChannelFields* operator &() { return &self; }
4055         LDKCommonAcceptChannelFields* operator ->() { return &self; }
4056         const LDKCommonAcceptChannelFields* operator &() const { return &self; }
4057         const LDKCommonAcceptChannelFields* operator ->() const { return &self; }
4058 };
4059 class AcceptChannel {
4060 private:
4061         LDKAcceptChannel self;
4062 public:
4063         AcceptChannel(const AcceptChannel&) = delete;
4064         AcceptChannel(AcceptChannel&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannel)); }
4065         AcceptChannel(LDKAcceptChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannel)); }
4066         operator LDKAcceptChannel() && { LDKAcceptChannel res = self; memset(&self, 0, sizeof(LDKAcceptChannel)); return res; }
4067         ~AcceptChannel() { AcceptChannel_free(self); }
4068         AcceptChannel& operator=(AcceptChannel&& o) { AcceptChannel_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannel)); return *this; }
4069         LDKAcceptChannel* operator &() { return &self; }
4070         LDKAcceptChannel* operator ->() { return &self; }
4071         const LDKAcceptChannel* operator &() const { return &self; }
4072         const LDKAcceptChannel* operator ->() const { return &self; }
4073 };
4074 class AcceptChannelV2 {
4075 private:
4076         LDKAcceptChannelV2 self;
4077 public:
4078         AcceptChannelV2(const AcceptChannelV2&) = delete;
4079         AcceptChannelV2(AcceptChannelV2&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannelV2)); }
4080         AcceptChannelV2(LDKAcceptChannelV2&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannelV2)); }
4081         operator LDKAcceptChannelV2() && { LDKAcceptChannelV2 res = self; memset(&self, 0, sizeof(LDKAcceptChannelV2)); return res; }
4082         ~AcceptChannelV2() { AcceptChannelV2_free(self); }
4083         AcceptChannelV2& operator=(AcceptChannelV2&& o) { AcceptChannelV2_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannelV2)); return *this; }
4084         LDKAcceptChannelV2* operator &() { return &self; }
4085         LDKAcceptChannelV2* operator ->() { return &self; }
4086         const LDKAcceptChannelV2* operator &() const { return &self; }
4087         const LDKAcceptChannelV2* operator ->() const { return &self; }
4088 };
4089 class FundingCreated {
4090 private:
4091         LDKFundingCreated self;
4092 public:
4093         FundingCreated(const FundingCreated&) = delete;
4094         FundingCreated(FundingCreated&& o) : self(o.self) { memset(&o, 0, sizeof(FundingCreated)); }
4095         FundingCreated(LDKFundingCreated&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingCreated)); }
4096         operator LDKFundingCreated() && { LDKFundingCreated res = self; memset(&self, 0, sizeof(LDKFundingCreated)); return res; }
4097         ~FundingCreated() { FundingCreated_free(self); }
4098         FundingCreated& operator=(FundingCreated&& o) { FundingCreated_free(self); self = o.self; memset(&o, 0, sizeof(FundingCreated)); return *this; }
4099         LDKFundingCreated* operator &() { return &self; }
4100         LDKFundingCreated* operator ->() { return &self; }
4101         const LDKFundingCreated* operator &() const { return &self; }
4102         const LDKFundingCreated* operator ->() const { return &self; }
4103 };
4104 class FundingSigned {
4105 private:
4106         LDKFundingSigned self;
4107 public:
4108         FundingSigned(const FundingSigned&) = delete;
4109         FundingSigned(FundingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(FundingSigned)); }
4110         FundingSigned(LDKFundingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingSigned)); }
4111         operator LDKFundingSigned() && { LDKFundingSigned res = self; memset(&self, 0, sizeof(LDKFundingSigned)); return res; }
4112         ~FundingSigned() { FundingSigned_free(self); }
4113         FundingSigned& operator=(FundingSigned&& o) { FundingSigned_free(self); self = o.self; memset(&o, 0, sizeof(FundingSigned)); return *this; }
4114         LDKFundingSigned* operator &() { return &self; }
4115         LDKFundingSigned* operator ->() { return &self; }
4116         const LDKFundingSigned* operator &() const { return &self; }
4117         const LDKFundingSigned* operator ->() const { return &self; }
4118 };
4119 class ChannelReady {
4120 private:
4121         LDKChannelReady self;
4122 public:
4123         ChannelReady(const ChannelReady&) = delete;
4124         ChannelReady(ChannelReady&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReady)); }
4125         ChannelReady(LDKChannelReady&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReady)); }
4126         operator LDKChannelReady() && { LDKChannelReady res = self; memset(&self, 0, sizeof(LDKChannelReady)); return res; }
4127         ~ChannelReady() { ChannelReady_free(self); }
4128         ChannelReady& operator=(ChannelReady&& o) { ChannelReady_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReady)); return *this; }
4129         LDKChannelReady* operator &() { return &self; }
4130         LDKChannelReady* operator ->() { return &self; }
4131         const LDKChannelReady* operator &() const { return &self; }
4132         const LDKChannelReady* operator ->() const { return &self; }
4133 };
4134 class Stfu {
4135 private:
4136         LDKStfu self;
4137 public:
4138         Stfu(const Stfu&) = delete;
4139         Stfu(Stfu&& o) : self(o.self) { memset(&o, 0, sizeof(Stfu)); }
4140         Stfu(LDKStfu&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStfu)); }
4141         operator LDKStfu() && { LDKStfu res = self; memset(&self, 0, sizeof(LDKStfu)); return res; }
4142         ~Stfu() { Stfu_free(self); }
4143         Stfu& operator=(Stfu&& o) { Stfu_free(self); self = o.self; memset(&o, 0, sizeof(Stfu)); return *this; }
4144         LDKStfu* operator &() { return &self; }
4145         LDKStfu* operator ->() { return &self; }
4146         const LDKStfu* operator &() const { return &self; }
4147         const LDKStfu* operator ->() const { return &self; }
4148 };
4149 class Splice {
4150 private:
4151         LDKSplice self;
4152 public:
4153         Splice(const Splice&) = delete;
4154         Splice(Splice&& o) : self(o.self) { memset(&o, 0, sizeof(Splice)); }
4155         Splice(LDKSplice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSplice)); }
4156         operator LDKSplice() && { LDKSplice res = self; memset(&self, 0, sizeof(LDKSplice)); return res; }
4157         ~Splice() { Splice_free(self); }
4158         Splice& operator=(Splice&& o) { Splice_free(self); self = o.self; memset(&o, 0, sizeof(Splice)); return *this; }
4159         LDKSplice* operator &() { return &self; }
4160         LDKSplice* operator ->() { return &self; }
4161         const LDKSplice* operator &() const { return &self; }
4162         const LDKSplice* operator ->() const { return &self; }
4163 };
4164 class SpliceAck {
4165 private:
4166         LDKSpliceAck self;
4167 public:
4168         SpliceAck(const SpliceAck&) = delete;
4169         SpliceAck(SpliceAck&& o) : self(o.self) { memset(&o, 0, sizeof(SpliceAck)); }
4170         SpliceAck(LDKSpliceAck&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpliceAck)); }
4171         operator LDKSpliceAck() && { LDKSpliceAck res = self; memset(&self, 0, sizeof(LDKSpliceAck)); return res; }
4172         ~SpliceAck() { SpliceAck_free(self); }
4173         SpliceAck& operator=(SpliceAck&& o) { SpliceAck_free(self); self = o.self; memset(&o, 0, sizeof(SpliceAck)); return *this; }
4174         LDKSpliceAck* operator &() { return &self; }
4175         LDKSpliceAck* operator ->() { return &self; }
4176         const LDKSpliceAck* operator &() const { return &self; }
4177         const LDKSpliceAck* operator ->() const { return &self; }
4178 };
4179 class SpliceLocked {
4180 private:
4181         LDKSpliceLocked self;
4182 public:
4183         SpliceLocked(const SpliceLocked&) = delete;
4184         SpliceLocked(SpliceLocked&& o) : self(o.self) { memset(&o, 0, sizeof(SpliceLocked)); }
4185         SpliceLocked(LDKSpliceLocked&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpliceLocked)); }
4186         operator LDKSpliceLocked() && { LDKSpliceLocked res = self; memset(&self, 0, sizeof(LDKSpliceLocked)); return res; }
4187         ~SpliceLocked() { SpliceLocked_free(self); }
4188         SpliceLocked& operator=(SpliceLocked&& o) { SpliceLocked_free(self); self = o.self; memset(&o, 0, sizeof(SpliceLocked)); return *this; }
4189         LDKSpliceLocked* operator &() { return &self; }
4190         LDKSpliceLocked* operator ->() { return &self; }
4191         const LDKSpliceLocked* operator &() const { return &self; }
4192         const LDKSpliceLocked* operator ->() const { return &self; }
4193 };
4194 class TxAddInput {
4195 private:
4196         LDKTxAddInput self;
4197 public:
4198         TxAddInput(const TxAddInput&) = delete;
4199         TxAddInput(TxAddInput&& o) : self(o.self) { memset(&o, 0, sizeof(TxAddInput)); }
4200         TxAddInput(LDKTxAddInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAddInput)); }
4201         operator LDKTxAddInput() && { LDKTxAddInput res = self; memset(&self, 0, sizeof(LDKTxAddInput)); return res; }
4202         ~TxAddInput() { TxAddInput_free(self); }
4203         TxAddInput& operator=(TxAddInput&& o) { TxAddInput_free(self); self = o.self; memset(&o, 0, sizeof(TxAddInput)); return *this; }
4204         LDKTxAddInput* operator &() { return &self; }
4205         LDKTxAddInput* operator ->() { return &self; }
4206         const LDKTxAddInput* operator &() const { return &self; }
4207         const LDKTxAddInput* operator ->() const { return &self; }
4208 };
4209 class TxAddOutput {
4210 private:
4211         LDKTxAddOutput self;
4212 public:
4213         TxAddOutput(const TxAddOutput&) = delete;
4214         TxAddOutput(TxAddOutput&& o) : self(o.self) { memset(&o, 0, sizeof(TxAddOutput)); }
4215         TxAddOutput(LDKTxAddOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAddOutput)); }
4216         operator LDKTxAddOutput() && { LDKTxAddOutput res = self; memset(&self, 0, sizeof(LDKTxAddOutput)); return res; }
4217         ~TxAddOutput() { TxAddOutput_free(self); }
4218         TxAddOutput& operator=(TxAddOutput&& o) { TxAddOutput_free(self); self = o.self; memset(&o, 0, sizeof(TxAddOutput)); return *this; }
4219         LDKTxAddOutput* operator &() { return &self; }
4220         LDKTxAddOutput* operator ->() { return &self; }
4221         const LDKTxAddOutput* operator &() const { return &self; }
4222         const LDKTxAddOutput* operator ->() const { return &self; }
4223 };
4224 class TxRemoveInput {
4225 private:
4226         LDKTxRemoveInput self;
4227 public:
4228         TxRemoveInput(const TxRemoveInput&) = delete;
4229         TxRemoveInput(TxRemoveInput&& o) : self(o.self) { memset(&o, 0, sizeof(TxRemoveInput)); }
4230         TxRemoveInput(LDKTxRemoveInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxRemoveInput)); }
4231         operator LDKTxRemoveInput() && { LDKTxRemoveInput res = self; memset(&self, 0, sizeof(LDKTxRemoveInput)); return res; }
4232         ~TxRemoveInput() { TxRemoveInput_free(self); }
4233         TxRemoveInput& operator=(TxRemoveInput&& o) { TxRemoveInput_free(self); self = o.self; memset(&o, 0, sizeof(TxRemoveInput)); return *this; }
4234         LDKTxRemoveInput* operator &() { return &self; }
4235         LDKTxRemoveInput* operator ->() { return &self; }
4236         const LDKTxRemoveInput* operator &() const { return &self; }
4237         const LDKTxRemoveInput* operator ->() const { return &self; }
4238 };
4239 class TxRemoveOutput {
4240 private:
4241         LDKTxRemoveOutput self;
4242 public:
4243         TxRemoveOutput(const TxRemoveOutput&) = delete;
4244         TxRemoveOutput(TxRemoveOutput&& o) : self(o.self) { memset(&o, 0, sizeof(TxRemoveOutput)); }
4245         TxRemoveOutput(LDKTxRemoveOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxRemoveOutput)); }
4246         operator LDKTxRemoveOutput() && { LDKTxRemoveOutput res = self; memset(&self, 0, sizeof(LDKTxRemoveOutput)); return res; }
4247         ~TxRemoveOutput() { TxRemoveOutput_free(self); }
4248         TxRemoveOutput& operator=(TxRemoveOutput&& o) { TxRemoveOutput_free(self); self = o.self; memset(&o, 0, sizeof(TxRemoveOutput)); return *this; }
4249         LDKTxRemoveOutput* operator &() { return &self; }
4250         LDKTxRemoveOutput* operator ->() { return &self; }
4251         const LDKTxRemoveOutput* operator &() const { return &self; }
4252         const LDKTxRemoveOutput* operator ->() const { return &self; }
4253 };
4254 class TxComplete {
4255 private:
4256         LDKTxComplete self;
4257 public:
4258         TxComplete(const TxComplete&) = delete;
4259         TxComplete(TxComplete&& o) : self(o.self) { memset(&o, 0, sizeof(TxComplete)); }
4260         TxComplete(LDKTxComplete&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxComplete)); }
4261         operator LDKTxComplete() && { LDKTxComplete res = self; memset(&self, 0, sizeof(LDKTxComplete)); return res; }
4262         ~TxComplete() { TxComplete_free(self); }
4263         TxComplete& operator=(TxComplete&& o) { TxComplete_free(self); self = o.self; memset(&o, 0, sizeof(TxComplete)); return *this; }
4264         LDKTxComplete* operator &() { return &self; }
4265         LDKTxComplete* operator ->() { return &self; }
4266         const LDKTxComplete* operator &() const { return &self; }
4267         const LDKTxComplete* operator ->() const { return &self; }
4268 };
4269 class TxSignatures {
4270 private:
4271         LDKTxSignatures self;
4272 public:
4273         TxSignatures(const TxSignatures&) = delete;
4274         TxSignatures(TxSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(TxSignatures)); }
4275         TxSignatures(LDKTxSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxSignatures)); }
4276         operator LDKTxSignatures() && { LDKTxSignatures res = self; memset(&self, 0, sizeof(LDKTxSignatures)); return res; }
4277         ~TxSignatures() { TxSignatures_free(self); }
4278         TxSignatures& operator=(TxSignatures&& o) { TxSignatures_free(self); self = o.self; memset(&o, 0, sizeof(TxSignatures)); return *this; }
4279         LDKTxSignatures* operator &() { return &self; }
4280         LDKTxSignatures* operator ->() { return &self; }
4281         const LDKTxSignatures* operator &() const { return &self; }
4282         const LDKTxSignatures* operator ->() const { return &self; }
4283 };
4284 class TxInitRbf {
4285 private:
4286         LDKTxInitRbf self;
4287 public:
4288         TxInitRbf(const TxInitRbf&) = delete;
4289         TxInitRbf(TxInitRbf&& o) : self(o.self) { memset(&o, 0, sizeof(TxInitRbf)); }
4290         TxInitRbf(LDKTxInitRbf&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxInitRbf)); }
4291         operator LDKTxInitRbf() && { LDKTxInitRbf res = self; memset(&self, 0, sizeof(LDKTxInitRbf)); return res; }
4292         ~TxInitRbf() { TxInitRbf_free(self); }
4293         TxInitRbf& operator=(TxInitRbf&& o) { TxInitRbf_free(self); self = o.self; memset(&o, 0, sizeof(TxInitRbf)); return *this; }
4294         LDKTxInitRbf* operator &() { return &self; }
4295         LDKTxInitRbf* operator ->() { return &self; }
4296         const LDKTxInitRbf* operator &() const { return &self; }
4297         const LDKTxInitRbf* operator ->() const { return &self; }
4298 };
4299 class TxAckRbf {
4300 private:
4301         LDKTxAckRbf self;
4302 public:
4303         TxAckRbf(const TxAckRbf&) = delete;
4304         TxAckRbf(TxAckRbf&& o) : self(o.self) { memset(&o, 0, sizeof(TxAckRbf)); }
4305         TxAckRbf(LDKTxAckRbf&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAckRbf)); }
4306         operator LDKTxAckRbf() && { LDKTxAckRbf res = self; memset(&self, 0, sizeof(LDKTxAckRbf)); return res; }
4307         ~TxAckRbf() { TxAckRbf_free(self); }
4308         TxAckRbf& operator=(TxAckRbf&& o) { TxAckRbf_free(self); self = o.self; memset(&o, 0, sizeof(TxAckRbf)); return *this; }
4309         LDKTxAckRbf* operator &() { return &self; }
4310         LDKTxAckRbf* operator ->() { return &self; }
4311         const LDKTxAckRbf* operator &() const { return &self; }
4312         const LDKTxAckRbf* operator ->() const { return &self; }
4313 };
4314 class TxAbort {
4315 private:
4316         LDKTxAbort self;
4317 public:
4318         TxAbort(const TxAbort&) = delete;
4319         TxAbort(TxAbort&& o) : self(o.self) { memset(&o, 0, sizeof(TxAbort)); }
4320         TxAbort(LDKTxAbort&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAbort)); }
4321         operator LDKTxAbort() && { LDKTxAbort res = self; memset(&self, 0, sizeof(LDKTxAbort)); return res; }
4322         ~TxAbort() { TxAbort_free(self); }
4323         TxAbort& operator=(TxAbort&& o) { TxAbort_free(self); self = o.self; memset(&o, 0, sizeof(TxAbort)); return *this; }
4324         LDKTxAbort* operator &() { return &self; }
4325         LDKTxAbort* operator ->() { return &self; }
4326         const LDKTxAbort* operator &() const { return &self; }
4327         const LDKTxAbort* operator ->() const { return &self; }
4328 };
4329 class Shutdown {
4330 private:
4331         LDKShutdown self;
4332 public:
4333         Shutdown(const Shutdown&) = delete;
4334         Shutdown(Shutdown&& o) : self(o.self) { memset(&o, 0, sizeof(Shutdown)); }
4335         Shutdown(LDKShutdown&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdown)); }
4336         operator LDKShutdown() && { LDKShutdown res = self; memset(&self, 0, sizeof(LDKShutdown)); return res; }
4337         ~Shutdown() { Shutdown_free(self); }
4338         Shutdown& operator=(Shutdown&& o) { Shutdown_free(self); self = o.self; memset(&o, 0, sizeof(Shutdown)); return *this; }
4339         LDKShutdown* operator &() { return &self; }
4340         LDKShutdown* operator ->() { return &self; }
4341         const LDKShutdown* operator &() const { return &self; }
4342         const LDKShutdown* operator ->() const { return &self; }
4343 };
4344 class ClosingSignedFeeRange {
4345 private:
4346         LDKClosingSignedFeeRange self;
4347 public:
4348         ClosingSignedFeeRange(const ClosingSignedFeeRange&) = delete;
4349         ClosingSignedFeeRange(ClosingSignedFeeRange&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSignedFeeRange)); }
4350         ClosingSignedFeeRange(LDKClosingSignedFeeRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSignedFeeRange)); }
4351         operator LDKClosingSignedFeeRange() && { LDKClosingSignedFeeRange res = self; memset(&self, 0, sizeof(LDKClosingSignedFeeRange)); return res; }
4352         ~ClosingSignedFeeRange() { ClosingSignedFeeRange_free(self); }
4353         ClosingSignedFeeRange& operator=(ClosingSignedFeeRange&& o) { ClosingSignedFeeRange_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSignedFeeRange)); return *this; }
4354         LDKClosingSignedFeeRange* operator &() { return &self; }
4355         LDKClosingSignedFeeRange* operator ->() { return &self; }
4356         const LDKClosingSignedFeeRange* operator &() const { return &self; }
4357         const LDKClosingSignedFeeRange* operator ->() const { return &self; }
4358 };
4359 class ClosingSigned {
4360 private:
4361         LDKClosingSigned self;
4362 public:
4363         ClosingSigned(const ClosingSigned&) = delete;
4364         ClosingSigned(ClosingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSigned)); }
4365         ClosingSigned(LDKClosingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSigned)); }
4366         operator LDKClosingSigned() && { LDKClosingSigned res = self; memset(&self, 0, sizeof(LDKClosingSigned)); return res; }
4367         ~ClosingSigned() { ClosingSigned_free(self); }
4368         ClosingSigned& operator=(ClosingSigned&& o) { ClosingSigned_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSigned)); return *this; }
4369         LDKClosingSigned* operator &() { return &self; }
4370         LDKClosingSigned* operator ->() { return &self; }
4371         const LDKClosingSigned* operator &() const { return &self; }
4372         const LDKClosingSigned* operator ->() const { return &self; }
4373 };
4374 class UpdateAddHTLC {
4375 private:
4376         LDKUpdateAddHTLC self;
4377 public:
4378         UpdateAddHTLC(const UpdateAddHTLC&) = delete;
4379         UpdateAddHTLC(UpdateAddHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateAddHTLC)); }
4380         UpdateAddHTLC(LDKUpdateAddHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateAddHTLC)); }
4381         operator LDKUpdateAddHTLC() && { LDKUpdateAddHTLC res = self; memset(&self, 0, sizeof(LDKUpdateAddHTLC)); return res; }
4382         ~UpdateAddHTLC() { UpdateAddHTLC_free(self); }
4383         UpdateAddHTLC& operator=(UpdateAddHTLC&& o) { UpdateAddHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateAddHTLC)); return *this; }
4384         LDKUpdateAddHTLC* operator &() { return &self; }
4385         LDKUpdateAddHTLC* operator ->() { return &self; }
4386         const LDKUpdateAddHTLC* operator &() const { return &self; }
4387         const LDKUpdateAddHTLC* operator ->() const { return &self; }
4388 };
4389 class OnionMessage {
4390 private:
4391         LDKOnionMessage self;
4392 public:
4393         OnionMessage(const OnionMessage&) = delete;
4394         OnionMessage(OnionMessage&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessage)); }
4395         OnionMessage(LDKOnionMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessage)); }
4396         operator LDKOnionMessage() && { LDKOnionMessage res = self; memset(&self, 0, sizeof(LDKOnionMessage)); return res; }
4397         ~OnionMessage() { OnionMessage_free(self); }
4398         OnionMessage& operator=(OnionMessage&& o) { OnionMessage_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessage)); return *this; }
4399         LDKOnionMessage* operator &() { return &self; }
4400         LDKOnionMessage* operator ->() { return &self; }
4401         const LDKOnionMessage* operator &() const { return &self; }
4402         const LDKOnionMessage* operator ->() const { return &self; }
4403 };
4404 class UpdateFulfillHTLC {
4405 private:
4406         LDKUpdateFulfillHTLC self;
4407 public:
4408         UpdateFulfillHTLC(const UpdateFulfillHTLC&) = delete;
4409         UpdateFulfillHTLC(UpdateFulfillHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFulfillHTLC)); }
4410         UpdateFulfillHTLC(LDKUpdateFulfillHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFulfillHTLC)); }
4411         operator LDKUpdateFulfillHTLC() && { LDKUpdateFulfillHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFulfillHTLC)); return res; }
4412         ~UpdateFulfillHTLC() { UpdateFulfillHTLC_free(self); }
4413         UpdateFulfillHTLC& operator=(UpdateFulfillHTLC&& o) { UpdateFulfillHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFulfillHTLC)); return *this; }
4414         LDKUpdateFulfillHTLC* operator &() { return &self; }
4415         LDKUpdateFulfillHTLC* operator ->() { return &self; }
4416         const LDKUpdateFulfillHTLC* operator &() const { return &self; }
4417         const LDKUpdateFulfillHTLC* operator ->() const { return &self; }
4418 };
4419 class UpdateFailHTLC {
4420 private:
4421         LDKUpdateFailHTLC self;
4422 public:
4423         UpdateFailHTLC(const UpdateFailHTLC&) = delete;
4424         UpdateFailHTLC(UpdateFailHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailHTLC)); }
4425         UpdateFailHTLC(LDKUpdateFailHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailHTLC)); }
4426         operator LDKUpdateFailHTLC() && { LDKUpdateFailHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailHTLC)); return res; }
4427         ~UpdateFailHTLC() { UpdateFailHTLC_free(self); }
4428         UpdateFailHTLC& operator=(UpdateFailHTLC&& o) { UpdateFailHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailHTLC)); return *this; }
4429         LDKUpdateFailHTLC* operator &() { return &self; }
4430         LDKUpdateFailHTLC* operator ->() { return &self; }
4431         const LDKUpdateFailHTLC* operator &() const { return &self; }
4432         const LDKUpdateFailHTLC* operator ->() const { return &self; }
4433 };
4434 class UpdateFailMalformedHTLC {
4435 private:
4436         LDKUpdateFailMalformedHTLC self;
4437 public:
4438         UpdateFailMalformedHTLC(const UpdateFailMalformedHTLC&) = delete;
4439         UpdateFailMalformedHTLC(UpdateFailMalformedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); }
4440         UpdateFailMalformedHTLC(LDKUpdateFailMalformedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailMalformedHTLC)); }
4441         operator LDKUpdateFailMalformedHTLC() && { LDKUpdateFailMalformedHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailMalformedHTLC)); return res; }
4442         ~UpdateFailMalformedHTLC() { UpdateFailMalformedHTLC_free(self); }
4443         UpdateFailMalformedHTLC& operator=(UpdateFailMalformedHTLC&& o) { UpdateFailMalformedHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); return *this; }
4444         LDKUpdateFailMalformedHTLC* operator &() { return &self; }
4445         LDKUpdateFailMalformedHTLC* operator ->() { return &self; }
4446         const LDKUpdateFailMalformedHTLC* operator &() const { return &self; }
4447         const LDKUpdateFailMalformedHTLC* operator ->() const { return &self; }
4448 };
4449 class CommitmentSigned {
4450 private:
4451         LDKCommitmentSigned self;
4452 public:
4453         CommitmentSigned(const CommitmentSigned&) = delete;
4454         CommitmentSigned(CommitmentSigned&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentSigned)); }
4455         CommitmentSigned(LDKCommitmentSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentSigned)); }
4456         operator LDKCommitmentSigned() && { LDKCommitmentSigned res = self; memset(&self, 0, sizeof(LDKCommitmentSigned)); return res; }
4457         ~CommitmentSigned() { CommitmentSigned_free(self); }
4458         CommitmentSigned& operator=(CommitmentSigned&& o) { CommitmentSigned_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentSigned)); return *this; }
4459         LDKCommitmentSigned* operator &() { return &self; }
4460         LDKCommitmentSigned* operator ->() { return &self; }
4461         const LDKCommitmentSigned* operator &() const { return &self; }
4462         const LDKCommitmentSigned* operator ->() const { return &self; }
4463 };
4464 class RevokeAndACK {
4465 private:
4466         LDKRevokeAndACK self;
4467 public:
4468         RevokeAndACK(const RevokeAndACK&) = delete;
4469         RevokeAndACK(RevokeAndACK&& o) : self(o.self) { memset(&o, 0, sizeof(RevokeAndACK)); }
4470         RevokeAndACK(LDKRevokeAndACK&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevokeAndACK)); }
4471         operator LDKRevokeAndACK() && { LDKRevokeAndACK res = self; memset(&self, 0, sizeof(LDKRevokeAndACK)); return res; }
4472         ~RevokeAndACK() { RevokeAndACK_free(self); }
4473         RevokeAndACK& operator=(RevokeAndACK&& o) { RevokeAndACK_free(self); self = o.self; memset(&o, 0, sizeof(RevokeAndACK)); return *this; }
4474         LDKRevokeAndACK* operator &() { return &self; }
4475         LDKRevokeAndACK* operator ->() { return &self; }
4476         const LDKRevokeAndACK* operator &() const { return &self; }
4477         const LDKRevokeAndACK* operator ->() const { return &self; }
4478 };
4479 class UpdateFee {
4480 private:
4481         LDKUpdateFee self;
4482 public:
4483         UpdateFee(const UpdateFee&) = delete;
4484         UpdateFee(UpdateFee&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFee)); }
4485         UpdateFee(LDKUpdateFee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFee)); }
4486         operator LDKUpdateFee() && { LDKUpdateFee res = self; memset(&self, 0, sizeof(LDKUpdateFee)); return res; }
4487         ~UpdateFee() { UpdateFee_free(self); }
4488         UpdateFee& operator=(UpdateFee&& o) { UpdateFee_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFee)); return *this; }
4489         LDKUpdateFee* operator &() { return &self; }
4490         LDKUpdateFee* operator ->() { return &self; }
4491         const LDKUpdateFee* operator &() const { return &self; }
4492         const LDKUpdateFee* operator ->() const { return &self; }
4493 };
4494 class ChannelReestablish {
4495 private:
4496         LDKChannelReestablish self;
4497 public:
4498         ChannelReestablish(const ChannelReestablish&) = delete;
4499         ChannelReestablish(ChannelReestablish&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReestablish)); }
4500         ChannelReestablish(LDKChannelReestablish&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReestablish)); }
4501         operator LDKChannelReestablish() && { LDKChannelReestablish res = self; memset(&self, 0, sizeof(LDKChannelReestablish)); return res; }
4502         ~ChannelReestablish() { ChannelReestablish_free(self); }
4503         ChannelReestablish& operator=(ChannelReestablish&& o) { ChannelReestablish_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReestablish)); return *this; }
4504         LDKChannelReestablish* operator &() { return &self; }
4505         LDKChannelReestablish* operator ->() { return &self; }
4506         const LDKChannelReestablish* operator &() const { return &self; }
4507         const LDKChannelReestablish* operator ->() const { return &self; }
4508 };
4509 class AnnouncementSignatures {
4510 private:
4511         LDKAnnouncementSignatures self;
4512 public:
4513         AnnouncementSignatures(const AnnouncementSignatures&) = delete;
4514         AnnouncementSignatures(AnnouncementSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(AnnouncementSignatures)); }
4515         AnnouncementSignatures(LDKAnnouncementSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnnouncementSignatures)); }
4516         operator LDKAnnouncementSignatures() && { LDKAnnouncementSignatures res = self; memset(&self, 0, sizeof(LDKAnnouncementSignatures)); return res; }
4517         ~AnnouncementSignatures() { AnnouncementSignatures_free(self); }
4518         AnnouncementSignatures& operator=(AnnouncementSignatures&& o) { AnnouncementSignatures_free(self); self = o.self; memset(&o, 0, sizeof(AnnouncementSignatures)); return *this; }
4519         LDKAnnouncementSignatures* operator &() { return &self; }
4520         LDKAnnouncementSignatures* operator ->() { return &self; }
4521         const LDKAnnouncementSignatures* operator &() const { return &self; }
4522         const LDKAnnouncementSignatures* operator ->() const { return &self; }
4523 };
4524 class SocketAddress {
4525 private:
4526         LDKSocketAddress self;
4527 public:
4528         SocketAddress(const SocketAddress&) = delete;
4529         SocketAddress(SocketAddress&& o) : self(o.self) { memset(&o, 0, sizeof(SocketAddress)); }
4530         SocketAddress(LDKSocketAddress&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketAddress)); }
4531         operator LDKSocketAddress() && { LDKSocketAddress res = self; memset(&self, 0, sizeof(LDKSocketAddress)); return res; }
4532         ~SocketAddress() { SocketAddress_free(self); }
4533         SocketAddress& operator=(SocketAddress&& o) { SocketAddress_free(self); self = o.self; memset(&o, 0, sizeof(SocketAddress)); return *this; }
4534         LDKSocketAddress* operator &() { return &self; }
4535         LDKSocketAddress* operator ->() { return &self; }
4536         const LDKSocketAddress* operator &() const { return &self; }
4537         const LDKSocketAddress* operator ->() const { return &self; }
4538 };
4539 class SocketAddressParseError {
4540 private:
4541         LDKSocketAddressParseError self;
4542 public:
4543         SocketAddressParseError(const SocketAddressParseError&) = delete;
4544         SocketAddressParseError(SocketAddressParseError&& o) : self(o.self) { memset(&o, 0, sizeof(SocketAddressParseError)); }
4545         SocketAddressParseError(LDKSocketAddressParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketAddressParseError)); }
4546         operator LDKSocketAddressParseError() && { LDKSocketAddressParseError res = self; memset(&self, 0, sizeof(LDKSocketAddressParseError)); return res; }
4547         SocketAddressParseError& operator=(SocketAddressParseError&& o) { self = o.self; memset(&o, 0, sizeof(SocketAddressParseError)); return *this; }
4548         LDKSocketAddressParseError* operator &() { return &self; }
4549         LDKSocketAddressParseError* operator ->() { return &self; }
4550         const LDKSocketAddressParseError* operator &() const { return &self; }
4551         const LDKSocketAddressParseError* operator ->() const { return &self; }
4552 };
4553 class UnsignedGossipMessage {
4554 private:
4555         LDKUnsignedGossipMessage self;
4556 public:
4557         UnsignedGossipMessage(const UnsignedGossipMessage&) = delete;
4558         UnsignedGossipMessage(UnsignedGossipMessage&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedGossipMessage)); }
4559         UnsignedGossipMessage(LDKUnsignedGossipMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedGossipMessage)); }
4560         operator LDKUnsignedGossipMessage() && { LDKUnsignedGossipMessage res = self; memset(&self, 0, sizeof(LDKUnsignedGossipMessage)); return res; }
4561         ~UnsignedGossipMessage() { UnsignedGossipMessage_free(self); }
4562         UnsignedGossipMessage& operator=(UnsignedGossipMessage&& o) { UnsignedGossipMessage_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedGossipMessage)); return *this; }
4563         LDKUnsignedGossipMessage* operator &() { return &self; }
4564         LDKUnsignedGossipMessage* operator ->() { return &self; }
4565         const LDKUnsignedGossipMessage* operator &() const { return &self; }
4566         const LDKUnsignedGossipMessage* operator ->() const { return &self; }
4567 };
4568 class UnsignedNodeAnnouncement {
4569 private:
4570         LDKUnsignedNodeAnnouncement self;
4571 public:
4572         UnsignedNodeAnnouncement(const UnsignedNodeAnnouncement&) = delete;
4573         UnsignedNodeAnnouncement(UnsignedNodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); }
4574         UnsignedNodeAnnouncement(LDKUnsignedNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedNodeAnnouncement)); }
4575         operator LDKUnsignedNodeAnnouncement() && { LDKUnsignedNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedNodeAnnouncement)); return res; }
4576         ~UnsignedNodeAnnouncement() { UnsignedNodeAnnouncement_free(self); }
4577         UnsignedNodeAnnouncement& operator=(UnsignedNodeAnnouncement&& o) { UnsignedNodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); return *this; }
4578         LDKUnsignedNodeAnnouncement* operator &() { return &self; }
4579         LDKUnsignedNodeAnnouncement* operator ->() { return &self; }
4580         const LDKUnsignedNodeAnnouncement* operator &() const { return &self; }
4581         const LDKUnsignedNodeAnnouncement* operator ->() const { return &self; }
4582 };
4583 class NodeAnnouncement {
4584 private:
4585         LDKNodeAnnouncement self;
4586 public:
4587         NodeAnnouncement(const NodeAnnouncement&) = delete;
4588         NodeAnnouncement(NodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncement)); }
4589         NodeAnnouncement(LDKNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncement)); }
4590         operator LDKNodeAnnouncement() && { LDKNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKNodeAnnouncement)); return res; }
4591         ~NodeAnnouncement() { NodeAnnouncement_free(self); }
4592         NodeAnnouncement& operator=(NodeAnnouncement&& o) { NodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncement)); return *this; }
4593         LDKNodeAnnouncement* operator &() { return &self; }
4594         LDKNodeAnnouncement* operator ->() { return &self; }
4595         const LDKNodeAnnouncement* operator &() const { return &self; }
4596         const LDKNodeAnnouncement* operator ->() const { return &self; }
4597 };
4598 class UnsignedChannelAnnouncement {
4599 private:
4600         LDKUnsignedChannelAnnouncement self;
4601 public:
4602         UnsignedChannelAnnouncement(const UnsignedChannelAnnouncement&) = delete;
4603         UnsignedChannelAnnouncement(UnsignedChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); }
4604         UnsignedChannelAnnouncement(LDKUnsignedChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelAnnouncement)); }
4605         operator LDKUnsignedChannelAnnouncement() && { LDKUnsignedChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedChannelAnnouncement)); return res; }
4606         ~UnsignedChannelAnnouncement() { UnsignedChannelAnnouncement_free(self); }
4607         UnsignedChannelAnnouncement& operator=(UnsignedChannelAnnouncement&& o) { UnsignedChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); return *this; }
4608         LDKUnsignedChannelAnnouncement* operator &() { return &self; }
4609         LDKUnsignedChannelAnnouncement* operator ->() { return &self; }
4610         const LDKUnsignedChannelAnnouncement* operator &() const { return &self; }
4611         const LDKUnsignedChannelAnnouncement* operator ->() const { return &self; }
4612 };
4613 class ChannelAnnouncement {
4614 private:
4615         LDKChannelAnnouncement self;
4616 public:
4617         ChannelAnnouncement(const ChannelAnnouncement&) = delete;
4618         ChannelAnnouncement(ChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelAnnouncement)); }
4619         ChannelAnnouncement(LDKChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelAnnouncement)); }
4620         operator LDKChannelAnnouncement() && { LDKChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKChannelAnnouncement)); return res; }
4621         ~ChannelAnnouncement() { ChannelAnnouncement_free(self); }
4622         ChannelAnnouncement& operator=(ChannelAnnouncement&& o) { ChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(ChannelAnnouncement)); return *this; }
4623         LDKChannelAnnouncement* operator &() { return &self; }
4624         LDKChannelAnnouncement* operator ->() { return &self; }
4625         const LDKChannelAnnouncement* operator &() const { return &self; }
4626         const LDKChannelAnnouncement* operator ->() const { return &self; }
4627 };
4628 class UnsignedChannelUpdate {
4629 private:
4630         LDKUnsignedChannelUpdate self;
4631 public:
4632         UnsignedChannelUpdate(const UnsignedChannelUpdate&) = delete;
4633         UnsignedChannelUpdate(UnsignedChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelUpdate)); }
4634         UnsignedChannelUpdate(LDKUnsignedChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelUpdate)); }
4635         operator LDKUnsignedChannelUpdate() && { LDKUnsignedChannelUpdate res = self; memset(&self, 0, sizeof(LDKUnsignedChannelUpdate)); return res; }
4636         ~UnsignedChannelUpdate() { UnsignedChannelUpdate_free(self); }
4637         UnsignedChannelUpdate& operator=(UnsignedChannelUpdate&& o) { UnsignedChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelUpdate)); return *this; }
4638         LDKUnsignedChannelUpdate* operator &() { return &self; }
4639         LDKUnsignedChannelUpdate* operator ->() { return &self; }
4640         const LDKUnsignedChannelUpdate* operator &() const { return &self; }
4641         const LDKUnsignedChannelUpdate* operator ->() const { return &self; }
4642 };
4643 class ChannelUpdate {
4644 private:
4645         LDKChannelUpdate self;
4646 public:
4647         ChannelUpdate(const ChannelUpdate&) = delete;
4648         ChannelUpdate(ChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdate)); }
4649         ChannelUpdate(LDKChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdate)); }
4650         operator LDKChannelUpdate() && { LDKChannelUpdate res = self; memset(&self, 0, sizeof(LDKChannelUpdate)); return res; }
4651         ~ChannelUpdate() { ChannelUpdate_free(self); }
4652         ChannelUpdate& operator=(ChannelUpdate&& o) { ChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdate)); return *this; }
4653         LDKChannelUpdate* operator &() { return &self; }
4654         LDKChannelUpdate* operator ->() { return &self; }
4655         const LDKChannelUpdate* operator &() const { return &self; }
4656         const LDKChannelUpdate* operator ->() const { return &self; }
4657 };
4658 class QueryChannelRange {
4659 private:
4660         LDKQueryChannelRange self;
4661 public:
4662         QueryChannelRange(const QueryChannelRange&) = delete;
4663         QueryChannelRange(QueryChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(QueryChannelRange)); }
4664         QueryChannelRange(LDKQueryChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryChannelRange)); }
4665         operator LDKQueryChannelRange() && { LDKQueryChannelRange res = self; memset(&self, 0, sizeof(LDKQueryChannelRange)); return res; }
4666         ~QueryChannelRange() { QueryChannelRange_free(self); }
4667         QueryChannelRange& operator=(QueryChannelRange&& o) { QueryChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(QueryChannelRange)); return *this; }
4668         LDKQueryChannelRange* operator &() { return &self; }
4669         LDKQueryChannelRange* operator ->() { return &self; }
4670         const LDKQueryChannelRange* operator &() const { return &self; }
4671         const LDKQueryChannelRange* operator ->() const { return &self; }
4672 };
4673 class ReplyChannelRange {
4674 private:
4675         LDKReplyChannelRange self;
4676 public:
4677         ReplyChannelRange(const ReplyChannelRange&) = delete;
4678         ReplyChannelRange(ReplyChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyChannelRange)); }
4679         ReplyChannelRange(LDKReplyChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyChannelRange)); }
4680         operator LDKReplyChannelRange() && { LDKReplyChannelRange res = self; memset(&self, 0, sizeof(LDKReplyChannelRange)); return res; }
4681         ~ReplyChannelRange() { ReplyChannelRange_free(self); }
4682         ReplyChannelRange& operator=(ReplyChannelRange&& o) { ReplyChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(ReplyChannelRange)); return *this; }
4683         LDKReplyChannelRange* operator &() { return &self; }
4684         LDKReplyChannelRange* operator ->() { return &self; }
4685         const LDKReplyChannelRange* operator &() const { return &self; }
4686         const LDKReplyChannelRange* operator ->() const { return &self; }
4687 };
4688 class QueryShortChannelIds {
4689 private:
4690         LDKQueryShortChannelIds self;
4691 public:
4692         QueryShortChannelIds(const QueryShortChannelIds&) = delete;
4693         QueryShortChannelIds(QueryShortChannelIds&& o) : self(o.self) { memset(&o, 0, sizeof(QueryShortChannelIds)); }
4694         QueryShortChannelIds(LDKQueryShortChannelIds&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryShortChannelIds)); }
4695         operator LDKQueryShortChannelIds() && { LDKQueryShortChannelIds res = self; memset(&self, 0, sizeof(LDKQueryShortChannelIds)); return res; }
4696         ~QueryShortChannelIds() { QueryShortChannelIds_free(self); }
4697         QueryShortChannelIds& operator=(QueryShortChannelIds&& o) { QueryShortChannelIds_free(self); self = o.self; memset(&o, 0, sizeof(QueryShortChannelIds)); return *this; }
4698         LDKQueryShortChannelIds* operator &() { return &self; }
4699         LDKQueryShortChannelIds* operator ->() { return &self; }
4700         const LDKQueryShortChannelIds* operator &() const { return &self; }
4701         const LDKQueryShortChannelIds* operator ->() const { return &self; }
4702 };
4703 class ReplyShortChannelIdsEnd {
4704 private:
4705         LDKReplyShortChannelIdsEnd self;
4706 public:
4707         ReplyShortChannelIdsEnd(const ReplyShortChannelIdsEnd&) = delete;
4708         ReplyShortChannelIdsEnd(ReplyShortChannelIdsEnd&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); }
4709         ReplyShortChannelIdsEnd(LDKReplyShortChannelIdsEnd&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyShortChannelIdsEnd)); }
4710         operator LDKReplyShortChannelIdsEnd() && { LDKReplyShortChannelIdsEnd res = self; memset(&self, 0, sizeof(LDKReplyShortChannelIdsEnd)); return res; }
4711         ~ReplyShortChannelIdsEnd() { ReplyShortChannelIdsEnd_free(self); }
4712         ReplyShortChannelIdsEnd& operator=(ReplyShortChannelIdsEnd&& o) { ReplyShortChannelIdsEnd_free(self); self = o.self; memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); return *this; }
4713         LDKReplyShortChannelIdsEnd* operator &() { return &self; }
4714         LDKReplyShortChannelIdsEnd* operator ->() { return &self; }
4715         const LDKReplyShortChannelIdsEnd* operator &() const { return &self; }
4716         const LDKReplyShortChannelIdsEnd* operator ->() const { return &self; }
4717 };
4718 class GossipTimestampFilter {
4719 private:
4720         LDKGossipTimestampFilter self;
4721 public:
4722         GossipTimestampFilter(const GossipTimestampFilter&) = delete;
4723         GossipTimestampFilter(GossipTimestampFilter&& o) : self(o.self) { memset(&o, 0, sizeof(GossipTimestampFilter)); }
4724         GossipTimestampFilter(LDKGossipTimestampFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipTimestampFilter)); }
4725         operator LDKGossipTimestampFilter() && { LDKGossipTimestampFilter res = self; memset(&self, 0, sizeof(LDKGossipTimestampFilter)); return res; }
4726         ~GossipTimestampFilter() { GossipTimestampFilter_free(self); }
4727         GossipTimestampFilter& operator=(GossipTimestampFilter&& o) { GossipTimestampFilter_free(self); self = o.self; memset(&o, 0, sizeof(GossipTimestampFilter)); return *this; }
4728         LDKGossipTimestampFilter* operator &() { return &self; }
4729         LDKGossipTimestampFilter* operator ->() { return &self; }
4730         const LDKGossipTimestampFilter* operator &() const { return &self; }
4731         const LDKGossipTimestampFilter* operator ->() const { return &self; }
4732 };
4733 class ErrorAction {
4734 private:
4735         LDKErrorAction self;
4736 public:
4737         ErrorAction(const ErrorAction&) = delete;
4738         ErrorAction(ErrorAction&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorAction)); }
4739         ErrorAction(LDKErrorAction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorAction)); }
4740         operator LDKErrorAction() && { LDKErrorAction res = self; memset(&self, 0, sizeof(LDKErrorAction)); return res; }
4741         ~ErrorAction() { ErrorAction_free(self); }
4742         ErrorAction& operator=(ErrorAction&& o) { ErrorAction_free(self); self = o.self; memset(&o, 0, sizeof(ErrorAction)); return *this; }
4743         LDKErrorAction* operator &() { return &self; }
4744         LDKErrorAction* operator ->() { return &self; }
4745         const LDKErrorAction* operator &() const { return &self; }
4746         const LDKErrorAction* operator ->() const { return &self; }
4747 };
4748 class LightningError {
4749 private:
4750         LDKLightningError self;
4751 public:
4752         LightningError(const LightningError&) = delete;
4753         LightningError(LightningError&& o) : self(o.self) { memset(&o, 0, sizeof(LightningError)); }
4754         LightningError(LDKLightningError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLightningError)); }
4755         operator LDKLightningError() && { LDKLightningError res = self; memset(&self, 0, sizeof(LDKLightningError)); return res; }
4756         ~LightningError() { LightningError_free(self); }
4757         LightningError& operator=(LightningError&& o) { LightningError_free(self); self = o.self; memset(&o, 0, sizeof(LightningError)); return *this; }
4758         LDKLightningError* operator &() { return &self; }
4759         LDKLightningError* operator ->() { return &self; }
4760         const LDKLightningError* operator &() const { return &self; }
4761         const LDKLightningError* operator ->() const { return &self; }
4762 };
4763 class CommitmentUpdate {
4764 private:
4765         LDKCommitmentUpdate self;
4766 public:
4767         CommitmentUpdate(const CommitmentUpdate&) = delete;
4768         CommitmentUpdate(CommitmentUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentUpdate)); }
4769         CommitmentUpdate(LDKCommitmentUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentUpdate)); }
4770         operator LDKCommitmentUpdate() && { LDKCommitmentUpdate res = self; memset(&self, 0, sizeof(LDKCommitmentUpdate)); return res; }
4771         ~CommitmentUpdate() { CommitmentUpdate_free(self); }
4772         CommitmentUpdate& operator=(CommitmentUpdate&& o) { CommitmentUpdate_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentUpdate)); return *this; }
4773         LDKCommitmentUpdate* operator &() { return &self; }
4774         LDKCommitmentUpdate* operator ->() { return &self; }
4775         const LDKCommitmentUpdate* operator &() const { return &self; }
4776         const LDKCommitmentUpdate* operator ->() const { return &self; }
4777 };
4778 class ChannelMessageHandler {
4779 private:
4780         LDKChannelMessageHandler self;
4781 public:
4782         ChannelMessageHandler(const ChannelMessageHandler&) = delete;
4783         ChannelMessageHandler(ChannelMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMessageHandler)); }
4784         ChannelMessageHandler(LDKChannelMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMessageHandler)); }
4785         operator LDKChannelMessageHandler() && { LDKChannelMessageHandler res = self; memset(&self, 0, sizeof(LDKChannelMessageHandler)); return res; }
4786         ~ChannelMessageHandler() { ChannelMessageHandler_free(self); }
4787         ChannelMessageHandler& operator=(ChannelMessageHandler&& o) { ChannelMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMessageHandler)); return *this; }
4788         LDKChannelMessageHandler* operator &() { return &self; }
4789         LDKChannelMessageHandler* operator ->() { return &self; }
4790         const LDKChannelMessageHandler* operator &() const { return &self; }
4791         const LDKChannelMessageHandler* operator ->() const { return &self; }
4792         /**
4793          *  Handle an incoming `open_channel` message from the given peer.
4794          */
4795         inline void handle_open_channel(struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg);
4796         /**
4797          *  Handle an incoming `open_channel2` message from the given peer.
4798          */
4799         inline void handle_open_channel_v2(struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg);
4800         /**
4801          *  Handle an incoming `accept_channel` message from the given peer.
4802          */
4803         inline void handle_accept_channel(struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg);
4804         /**
4805          *  Handle an incoming `accept_channel2` message from the given peer.
4806          */
4807         inline void handle_accept_channel_v2(struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg);
4808         /**
4809          *  Handle an incoming `funding_created` message from the given peer.
4810          */
4811         inline void handle_funding_created(struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg);
4812         /**
4813          *  Handle an incoming `funding_signed` message from the given peer.
4814          */
4815         inline void handle_funding_signed(struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg);
4816         /**
4817          *  Handle an incoming `channel_ready` message from the given peer.
4818          */
4819         inline void handle_channel_ready(struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg);
4820         /**
4821          *  Handle an incoming `shutdown` message from the given peer.
4822          */
4823         inline void handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg);
4824         /**
4825          *  Handle an incoming `closing_signed` message from the given peer.
4826          */
4827         inline void handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg);
4828         /**
4829          *  Handle an incoming `stfu` message from the given peer.
4830          */
4831         inline void handle_stfu(struct LDKPublicKey their_node_id, const struct LDKStfu *NONNULL_PTR msg);
4832         /**
4833          *  Handle an incoming `tx_add_input message` from the given peer.
4834          */
4835         inline void handle_tx_add_input(struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg);
4836         /**
4837          *  Handle an incoming `tx_add_output` message from the given peer.
4838          */
4839         inline void handle_tx_add_output(struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg);
4840         /**
4841          *  Handle an incoming `tx_remove_input` message from the given peer.
4842          */
4843         inline void handle_tx_remove_input(struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg);
4844         /**
4845          *  Handle an incoming `tx_remove_output` message from the given peer.
4846          */
4847         inline void handle_tx_remove_output(struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg);
4848         /**
4849          *  Handle an incoming `tx_complete message` from the given peer.
4850          */
4851         inline void handle_tx_complete(struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg);
4852         /**
4853          *  Handle an incoming `tx_signatures` message from the given peer.
4854          */
4855         inline void handle_tx_signatures(struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg);
4856         /**
4857          *  Handle an incoming `tx_init_rbf` message from the given peer.
4858          */
4859         inline void handle_tx_init_rbf(struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg);
4860         /**
4861          *  Handle an incoming `tx_ack_rbf` message from the given peer.
4862          */
4863         inline void handle_tx_ack_rbf(struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg);
4864         /**
4865          *  Handle an incoming `tx_abort message` from the given peer.
4866          */
4867         inline void handle_tx_abort(struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg);
4868         /**
4869          *  Handle an incoming `update_add_htlc` message from the given peer.
4870          */
4871         inline void handle_update_add_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg);
4872         /**
4873          *  Handle an incoming `update_fulfill_htlc` message from the given peer.
4874          */
4875         inline void handle_update_fulfill_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg);
4876         /**
4877          *  Handle an incoming `update_fail_htlc` message from the given peer.
4878          */
4879         inline void handle_update_fail_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg);
4880         /**
4881          *  Handle an incoming `update_fail_malformed_htlc` message from the given peer.
4882          */
4883         inline void handle_update_fail_malformed_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg);
4884         /**
4885          *  Handle an incoming `commitment_signed` message from the given peer.
4886          */
4887         inline void handle_commitment_signed(struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg);
4888         /**
4889          *  Handle an incoming `revoke_and_ack` message from the given peer.
4890          */
4891         inline void handle_revoke_and_ack(struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg);
4892         /**
4893          *  Handle an incoming `update_fee` message from the given peer.
4894          */
4895         inline void handle_update_fee(struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg);
4896         /**
4897          *  Handle an incoming `announcement_signatures` message from the given peer.
4898          */
4899         inline void handle_announcement_signatures(struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg);
4900         /**
4901          *  Indicates a connection to the peer failed/an existing connection was lost.
4902          */
4903         inline void peer_disconnected(struct LDKPublicKey their_node_id);
4904         /**
4905          *  Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
4906          *
4907          *  May return an `Err(())` if the features the peer supports are not sufficient to communicate
4908          *  with us. Implementors should be somewhat conservative about doing so, however, as other
4909          *  message handlers may still wish to communicate with this peer.
4910          */
4911         inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound);
4912         /**
4913          *  Handle an incoming `channel_reestablish` message from the given peer.
4914          */
4915         inline void handle_channel_reestablish(struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg);
4916         /**
4917          *  Handle an incoming `channel_update` message from the given peer.
4918          */
4919         inline void handle_channel_update(struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg);
4920         /**
4921          *  Handle an incoming `error` message from the given peer.
4922          */
4923         inline void handle_error(struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg);
4924         /**
4925          *  Gets the node feature flags which this handler itself supports. All available handlers are
4926          *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
4927          *  which are broadcasted in our [`NodeAnnouncement`] message.
4928          */
4929         inline LDK::NodeFeatures provided_node_features();
4930         /**
4931          *  Gets the init feature flags which should be sent to the given peer. All available handlers
4932          *  are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
4933          *  which are sent in our [`Init`] message.
4934          *
4935          *  Note that this method is called before [`Self::peer_connected`].
4936          */
4937         inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
4938         /**
4939          *  Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
4940          *
4941          *  If it's `None`, then no particular network chain hash compatibility will be enforced when
4942          *  connecting to peers.
4943          */
4944         inline LDK::COption_CVec_ThirtyTwoBytesZZ get_chain_hashes();
4945 };
4946 class RoutingMessageHandler {
4947 private:
4948         LDKRoutingMessageHandler self;
4949 public:
4950         RoutingMessageHandler(const RoutingMessageHandler&) = delete;
4951         RoutingMessageHandler(RoutingMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingMessageHandler)); }
4952         RoutingMessageHandler(LDKRoutingMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingMessageHandler)); }
4953         operator LDKRoutingMessageHandler() && { LDKRoutingMessageHandler res = self; memset(&self, 0, sizeof(LDKRoutingMessageHandler)); return res; }
4954         ~RoutingMessageHandler() { RoutingMessageHandler_free(self); }
4955         RoutingMessageHandler& operator=(RoutingMessageHandler&& o) { RoutingMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(RoutingMessageHandler)); return *this; }
4956         LDKRoutingMessageHandler* operator &() { return &self; }
4957         LDKRoutingMessageHandler* operator ->() { return &self; }
4958         const LDKRoutingMessageHandler* operator &() const { return &self; }
4959         const LDKRoutingMessageHandler* operator ->() const { return &self; }
4960         /**
4961          *  Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
4962          *  `false` or returning an `Err` otherwise.
4963          */
4964         inline LDK::CResult_boolLightningErrorZ handle_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg);
4965         /**
4966          *  Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
4967          *  or returning an `Err` otherwise.
4968          */
4969         inline LDK::CResult_boolLightningErrorZ handle_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg);
4970         /**
4971          *  Handle an incoming `channel_update` message, returning true if it should be forwarded on,
4972          *  `false` or returning an `Err` otherwise.
4973          */
4974         inline LDK::CResult_boolLightningErrorZ handle_channel_update(const struct LDKChannelUpdate *NONNULL_PTR msg);
4975         /**
4976          *  Gets channel announcements and updates required to dump our routing table to a remote node,
4977          *  starting at the `short_channel_id` indicated by `starting_point` and including announcements
4978          *  for a single channel.
4979          */
4980         inline LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcement(uint64_t starting_point);
4981         /**
4982          *  Gets a node announcement required to dump our routing table to a remote node, starting at
4983          *  the node *after* the provided pubkey and including up to one announcement immediately
4984          *  higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
4985          *  If `None` is provided for `starting_point`, we start at the first node.
4986          *
4987          *  Note that starting_point (or a relevant inner pointer) may be NULL or all-0s to represent None
4988          *  Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
4989          */
4990         inline LDK::NodeAnnouncement get_next_node_announcement(struct LDKNodeId starting_point);
4991         /**
4992          *  Called when a connection is established with a peer. This can be used to
4993          *  perform routing table synchronization using a strategy defined by the
4994          *  implementor.
4995          *
4996          *  May return an `Err(())` if the features the peer supports are not sufficient to communicate
4997          *  with us. Implementors should be somewhat conservative about doing so, however, as other
4998          *  message handlers may still wish to communicate with this peer.
4999          */
5000         inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound);
5001         /**
5002          *  Handles the reply of a query we initiated to learn about channels
5003          *  for a given range of blocks. We can expect to receive one or more
5004          *  replies to a single query.
5005          */
5006         inline LDK::CResult_NoneLightningErrorZ handle_reply_channel_range(struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg);
5007         /**
5008          *  Handles the reply of a query we initiated asking for routing gossip
5009          *  messages for a list of channels. We should receive this message when
5010          *  a node has completed its best effort to send us the pertaining routing
5011          *  gossip messages.
5012          */
5013         inline LDK::CResult_NoneLightningErrorZ handle_reply_short_channel_ids_end(struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg);
5014         /**
5015          *  Handles when a peer asks us to send a list of `short_channel_id`s
5016          *  for the requested range of blocks.
5017          */
5018         inline LDK::CResult_NoneLightningErrorZ handle_query_channel_range(struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg);
5019         /**
5020          *  Handles when a peer asks us to send routing gossip messages for a
5021          *  list of `short_channel_id`s.
5022          */
5023         inline LDK::CResult_NoneLightningErrorZ handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg);
5024         /**
5025          *  Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
5026          *  pending some async action. While there is no guarantee of the rate of future messages, the
5027          *  caller should seek to reduce the rate of new gossip messages handled, especially
5028          *  [`ChannelAnnouncement`]s.
5029          */
5030         inline bool processing_queue_high();
5031         /**
5032          *  Gets the node feature flags which this handler itself supports. All available handlers are
5033          *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
5034          *  which are broadcasted in our [`NodeAnnouncement`] message.
5035          */
5036         inline LDK::NodeFeatures provided_node_features();
5037         /**
5038          *  Gets the init feature flags which should be sent to the given peer. All available handlers
5039          *  are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
5040          *  which are sent in our [`Init`] message.
5041          *
5042          *  Note that this method is called before [`Self::peer_connected`].
5043          */
5044         inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
5045 };
5046 class OnionMessageHandler {
5047 private:
5048         LDKOnionMessageHandler self;
5049 public:
5050         OnionMessageHandler(const OnionMessageHandler&) = delete;
5051         OnionMessageHandler(OnionMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageHandler)); }
5052         OnionMessageHandler(LDKOnionMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageHandler)); }
5053         operator LDKOnionMessageHandler() && { LDKOnionMessageHandler res = self; memset(&self, 0, sizeof(LDKOnionMessageHandler)); return res; }
5054         ~OnionMessageHandler() { OnionMessageHandler_free(self); }
5055         OnionMessageHandler& operator=(OnionMessageHandler&& o) { OnionMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageHandler)); return *this; }
5056         LDKOnionMessageHandler* operator &() { return &self; }
5057         LDKOnionMessageHandler* operator ->() { return &self; }
5058         const LDKOnionMessageHandler* operator &() const { return &self; }
5059         const LDKOnionMessageHandler* operator ->() const { return &self; }
5060         /**
5061          *  Because much of the lightning network does not yet support forwarding onion messages, we
5062          *  may need to directly connect to a node which will forward a message for us. In such a case,
5063          *  this method will return the set of nodes which need connection by node_id and the
5064          *  corresponding socket addresses where they may accept incoming connections.
5065          *
5066          *  Thus, this method should be polled regularly to detect messages await such a direct
5067          *  connection.
5068          */
5069         inline LDK::CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ get_and_clear_connections_needed();
5070         /**
5071          *  Handle an incoming `onion_message` message from the given peer.
5072          */
5073         inline void handle_onion_message(struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg);
5074         /**
5075          *  Returns the next pending onion message for the peer with the given node id.
5076          *
5077          *  Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
5078          */
5079         inline LDK::OnionMessage next_onion_message_for_peer(struct LDKPublicKey peer_node_id);
5080         /**
5081          *  Called when a connection is established with a peer. Can be used to track which peers
5082          *  advertise onion message support and are online.
5083          *
5084          *  May return an `Err(())` if the features the peer supports are not sufficient to communicate
5085          *  with us. Implementors should be somewhat conservative about doing so, however, as other
5086          *  message handlers may still wish to communicate with this peer.
5087          */
5088         inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound);
5089         /**
5090          *  Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
5091          *  drop and refuse to forward onion messages to this peer.
5092          */
5093         inline void peer_disconnected(struct LDKPublicKey their_node_id);
5094         /**
5095          *  Performs actions that should happen roughly every ten seconds after startup. Allows handlers
5096          *  to drop any buffered onion messages intended for prospective peers.
5097          */
5098         inline void timer_tick_occurred();
5099         /**
5100          *  Gets the node feature flags which this handler itself supports. All available handlers are
5101          *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
5102          *  which are broadcasted in our [`NodeAnnouncement`] message.
5103          */
5104         inline LDK::NodeFeatures provided_node_features();
5105         /**
5106          *  Gets the init feature flags which should be sent to the given peer. All available handlers
5107          *  are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
5108          *  which are sent in our [`Init`] message.
5109          *
5110          *  Note that this method is called before [`Self::peer_connected`].
5111          */
5112         inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
5113 };
5114 class FinalOnionHopData {
5115 private:
5116         LDKFinalOnionHopData self;
5117 public:
5118         FinalOnionHopData(const FinalOnionHopData&) = delete;
5119         FinalOnionHopData(FinalOnionHopData&& o) : self(o.self) { memset(&o, 0, sizeof(FinalOnionHopData)); }
5120         FinalOnionHopData(LDKFinalOnionHopData&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFinalOnionHopData)); }
5121         operator LDKFinalOnionHopData() && { LDKFinalOnionHopData res = self; memset(&self, 0, sizeof(LDKFinalOnionHopData)); return res; }
5122         ~FinalOnionHopData() { FinalOnionHopData_free(self); }
5123         FinalOnionHopData& operator=(FinalOnionHopData&& o) { FinalOnionHopData_free(self); self = o.self; memset(&o, 0, sizeof(FinalOnionHopData)); return *this; }
5124         LDKFinalOnionHopData* operator &() { return &self; }
5125         LDKFinalOnionHopData* operator ->() { return &self; }
5126         const LDKFinalOnionHopData* operator &() const { return &self; }
5127         const LDKFinalOnionHopData* operator ->() const { return &self; }
5128 };
5129 class OnionPacket {
5130 private:
5131         LDKOnionPacket self;
5132 public:
5133         OnionPacket(const OnionPacket&) = delete;
5134         OnionPacket(OnionPacket&& o) : self(o.self) { memset(&o, 0, sizeof(OnionPacket)); }
5135         OnionPacket(LDKOnionPacket&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionPacket)); }
5136         operator LDKOnionPacket() && { LDKOnionPacket res = self; memset(&self, 0, sizeof(LDKOnionPacket)); return res; }
5137         ~OnionPacket() { OnionPacket_free(self); }
5138         OnionPacket& operator=(OnionPacket&& o) { OnionPacket_free(self); self = o.self; memset(&o, 0, sizeof(OnionPacket)); return *this; }
5139         LDKOnionPacket* operator &() { return &self; }
5140         LDKOnionPacket* operator ->() { return &self; }
5141         const LDKOnionPacket* operator &() const { return &self; }
5142         const LDKOnionPacket* operator ->() const { return &self; }
5143 };
5144 class TrampolineOnionPacket {
5145 private:
5146         LDKTrampolineOnionPacket self;
5147 public:
5148         TrampolineOnionPacket(const TrampolineOnionPacket&) = delete;
5149         TrampolineOnionPacket(TrampolineOnionPacket&& o) : self(o.self) { memset(&o, 0, sizeof(TrampolineOnionPacket)); }
5150         TrampolineOnionPacket(LDKTrampolineOnionPacket&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrampolineOnionPacket)); }
5151         operator LDKTrampolineOnionPacket() && { LDKTrampolineOnionPacket res = self; memset(&self, 0, sizeof(LDKTrampolineOnionPacket)); return res; }
5152         ~TrampolineOnionPacket() { TrampolineOnionPacket_free(self); }
5153         TrampolineOnionPacket& operator=(TrampolineOnionPacket&& o) { TrampolineOnionPacket_free(self); self = o.self; memset(&o, 0, sizeof(TrampolineOnionPacket)); return *this; }
5154         LDKTrampolineOnionPacket* operator &() { return &self; }
5155         LDKTrampolineOnionPacket* operator ->() { return &self; }
5156         const LDKTrampolineOnionPacket* operator &() const { return &self; }
5157         const LDKTrampolineOnionPacket* operator ->() const { return &self; }
5158 };
5159 class Level {
5160 private:
5161         LDKLevel self;
5162 public:
5163         Level(const Level&) = delete;
5164         Level(Level&& o) : self(o.self) { memset(&o, 0, sizeof(Level)); }
5165         Level(LDKLevel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLevel)); }
5166         operator LDKLevel() && { LDKLevel res = self; memset(&self, 0, sizeof(LDKLevel)); return res; }
5167         Level& operator=(Level&& o) { self = o.self; memset(&o, 0, sizeof(Level)); return *this; }
5168         LDKLevel* operator &() { return &self; }
5169         LDKLevel* operator ->() { return &self; }
5170         const LDKLevel* operator &() const { return &self; }
5171         const LDKLevel* operator ->() const { return &self; }
5172 };
5173 class Record {
5174 private:
5175         LDKRecord self;
5176 public:
5177         Record(const Record&) = delete;
5178         Record(Record&& o) : self(o.self) { memset(&o, 0, sizeof(Record)); }
5179         Record(LDKRecord&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecord)); }
5180         operator LDKRecord() && { LDKRecord res = self; memset(&self, 0, sizeof(LDKRecord)); return res; }
5181         ~Record() { Record_free(self); }
5182         Record& operator=(Record&& o) { Record_free(self); self = o.self; memset(&o, 0, sizeof(Record)); return *this; }
5183         LDKRecord* operator &() { return &self; }
5184         LDKRecord* operator ->() { return &self; }
5185         const LDKRecord* operator &() const { return &self; }
5186         const LDKRecord* operator ->() const { return &self; }
5187 };
5188 class Logger {
5189 private:
5190         LDKLogger self;
5191 public:
5192         Logger(const Logger&) = delete;
5193         Logger(Logger&& o) : self(o.self) { memset(&o, 0, sizeof(Logger)); }
5194         Logger(LDKLogger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLogger)); }
5195         operator LDKLogger() && { LDKLogger res = self; memset(&self, 0, sizeof(LDKLogger)); return res; }
5196         ~Logger() { Logger_free(self); }
5197         Logger& operator=(Logger&& o) { Logger_free(self); self = o.self; memset(&o, 0, sizeof(Logger)); return *this; }
5198         LDKLogger* operator &() { return &self; }
5199         LDKLogger* operator ->() { return &self; }
5200         const LDKLogger* operator &() const { return &self; }
5201         const LDKLogger* operator ->() const { return &self; }
5202         /**
5203          *  Logs the [`Record`].
5204          */
5205         inline void log(struct LDKRecord record);
5206 };
5207 class FutureCallback {
5208 private:
5209         LDKFutureCallback self;
5210 public:
5211         FutureCallback(const FutureCallback&) = delete;
5212         FutureCallback(FutureCallback&& o) : self(o.self) { memset(&o, 0, sizeof(FutureCallback)); }
5213         FutureCallback(LDKFutureCallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFutureCallback)); }
5214         operator LDKFutureCallback() && { LDKFutureCallback res = self; memset(&self, 0, sizeof(LDKFutureCallback)); return res; }
5215         ~FutureCallback() { FutureCallback_free(self); }
5216         FutureCallback& operator=(FutureCallback&& o) { FutureCallback_free(self); self = o.self; memset(&o, 0, sizeof(FutureCallback)); return *this; }
5217         LDKFutureCallback* operator &() { return &self; }
5218         LDKFutureCallback* operator ->() { return &self; }
5219         const LDKFutureCallback* operator &() const { return &self; }
5220         const LDKFutureCallback* operator ->() const { return &self; }
5221         /**
5222          *  The method which is called.
5223          */
5224         inline void call();
5225 };
5226 class Future {
5227 private:
5228         LDKFuture self;
5229 public:
5230         Future(const Future&) = delete;
5231         Future(Future&& o) : self(o.self) { memset(&o, 0, sizeof(Future)); }
5232         Future(LDKFuture&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFuture)); }
5233         operator LDKFuture() && { LDKFuture res = self; memset(&self, 0, sizeof(LDKFuture)); return res; }
5234         ~Future() { Future_free(self); }
5235         Future& operator=(Future&& o) { Future_free(self); self = o.self; memset(&o, 0, sizeof(Future)); return *this; }
5236         LDKFuture* operator &() { return &self; }
5237         LDKFuture* operator ->() { return &self; }
5238         const LDKFuture* operator &() const { return &self; }
5239         const LDKFuture* operator ->() const { return &self; }
5240 };
5241 class Sleeper {
5242 private:
5243         LDKSleeper self;
5244 public:
5245         Sleeper(const Sleeper&) = delete;
5246         Sleeper(Sleeper&& o) : self(o.self) { memset(&o, 0, sizeof(Sleeper)); }
5247         Sleeper(LDKSleeper&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSleeper)); }
5248         operator LDKSleeper() && { LDKSleeper res = self; memset(&self, 0, sizeof(LDKSleeper)); return res; }
5249         ~Sleeper() { Sleeper_free(self); }
5250         Sleeper& operator=(Sleeper&& o) { Sleeper_free(self); self = o.self; memset(&o, 0, sizeof(Sleeper)); return *this; }
5251         LDKSleeper* operator &() { return &self; }
5252         LDKSleeper* operator ->() { return &self; }
5253         const LDKSleeper* operator &() const { return &self; }
5254         const LDKSleeper* operator ->() const { return &self; }
5255 };
5256 class OffersMessageHandler {
5257 private:
5258         LDKOffersMessageHandler self;
5259 public:
5260         OffersMessageHandler(const OffersMessageHandler&) = delete;
5261         OffersMessageHandler(OffersMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(OffersMessageHandler)); }
5262         OffersMessageHandler(LDKOffersMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffersMessageHandler)); }
5263         operator LDKOffersMessageHandler() && { LDKOffersMessageHandler res = self; memset(&self, 0, sizeof(LDKOffersMessageHandler)); return res; }
5264         ~OffersMessageHandler() { OffersMessageHandler_free(self); }
5265         OffersMessageHandler& operator=(OffersMessageHandler&& o) { OffersMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(OffersMessageHandler)); return *this; }
5266         LDKOffersMessageHandler* operator &() { return &self; }
5267         LDKOffersMessageHandler* operator ->() { return &self; }
5268         const LDKOffersMessageHandler* operator &() const { return &self; }
5269         const LDKOffersMessageHandler* operator ->() const { return &self; }
5270         /**
5271          *  Handles the given message by either responding with an [`Bolt12Invoice`], sending a payment,
5272          *  or replying with an error.
5273          *
5274          *  The returned [`OffersMessage`], if any, is enqueued to be sent by [`OnionMessenger`].
5275          *
5276          *  [`OnionMessenger`]: crate::onion_message::messenger::OnionMessenger
5277          */
5278         inline LDK::COption_OffersMessageZ handle_message(struct LDKOffersMessage message);
5279         /**
5280          *  Releases any [`OffersMessage`]s that need to be sent.
5281          *
5282          *  Typically, this is used for messages initiating a payment flow rather than in response to
5283          *  another message. The latter should use the return value of [`Self::handle_message`].
5284          */
5285         inline LDK::CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ release_pending_messages();
5286 };
5287 class OffersMessage {
5288 private:
5289         LDKOffersMessage self;
5290 public:
5291         OffersMessage(const OffersMessage&) = delete;
5292         OffersMessage(OffersMessage&& o) : self(o.self) { memset(&o, 0, sizeof(OffersMessage)); }
5293         OffersMessage(LDKOffersMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffersMessage)); }
5294         operator LDKOffersMessage() && { LDKOffersMessage res = self; memset(&self, 0, sizeof(LDKOffersMessage)); return res; }
5295         ~OffersMessage() { OffersMessage_free(self); }
5296         OffersMessage& operator=(OffersMessage&& o) { OffersMessage_free(self); self = o.self; memset(&o, 0, sizeof(OffersMessage)); return *this; }
5297         LDKOffersMessage* operator &() { return &self; }
5298         LDKOffersMessage* operator ->() { return &self; }
5299         const LDKOffersMessage* operator &() const { return &self; }
5300         const LDKOffersMessage* operator ->() const { return &self; }
5301 };
5302 class HTLCClaim {
5303 private:
5304         LDKHTLCClaim self;
5305 public:
5306         HTLCClaim(const HTLCClaim&) = delete;
5307         HTLCClaim(HTLCClaim&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCClaim)); }
5308         HTLCClaim(LDKHTLCClaim&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCClaim)); }
5309         operator LDKHTLCClaim() && { LDKHTLCClaim res = self; memset(&self, 0, sizeof(LDKHTLCClaim)); return res; }
5310         HTLCClaim& operator=(HTLCClaim&& o) { self = o.self; memset(&o, 0, sizeof(HTLCClaim)); return *this; }
5311         LDKHTLCClaim* operator &() { return &self; }
5312         LDKHTLCClaim* operator ->() { return &self; }
5313         const LDKHTLCClaim* operator &() const { return &self; }
5314         const LDKHTLCClaim* operator ->() const { return &self; }
5315 };
5316 class CounterpartyCommitmentSecrets {
5317 private:
5318         LDKCounterpartyCommitmentSecrets self;
5319 public:
5320         CounterpartyCommitmentSecrets(const CounterpartyCommitmentSecrets&) = delete;
5321         CounterpartyCommitmentSecrets(CounterpartyCommitmentSecrets&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); }
5322         CounterpartyCommitmentSecrets(LDKCounterpartyCommitmentSecrets&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); }
5323         operator LDKCounterpartyCommitmentSecrets() && { LDKCounterpartyCommitmentSecrets res = self; memset(&self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); return res; }
5324         ~CounterpartyCommitmentSecrets() { CounterpartyCommitmentSecrets_free(self); }
5325         CounterpartyCommitmentSecrets& operator=(CounterpartyCommitmentSecrets&& o) { CounterpartyCommitmentSecrets_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); return *this; }
5326         LDKCounterpartyCommitmentSecrets* operator &() { return &self; }
5327         LDKCounterpartyCommitmentSecrets* operator ->() { return &self; }
5328         const LDKCounterpartyCommitmentSecrets* operator &() const { return &self; }
5329         const LDKCounterpartyCommitmentSecrets* operator ->() const { return &self; }
5330 };
5331 class TxCreationKeys {
5332 private:
5333         LDKTxCreationKeys self;
5334 public:
5335         TxCreationKeys(const TxCreationKeys&) = delete;
5336         TxCreationKeys(TxCreationKeys&& o) : self(o.self) { memset(&o, 0, sizeof(TxCreationKeys)); }
5337         TxCreationKeys(LDKTxCreationKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxCreationKeys)); }
5338         operator LDKTxCreationKeys() && { LDKTxCreationKeys res = self; memset(&self, 0, sizeof(LDKTxCreationKeys)); return res; }
5339         ~TxCreationKeys() { TxCreationKeys_free(self); }
5340         TxCreationKeys& operator=(TxCreationKeys&& o) { TxCreationKeys_free(self); self = o.self; memset(&o, 0, sizeof(TxCreationKeys)); return *this; }
5341         LDKTxCreationKeys* operator &() { return &self; }
5342         LDKTxCreationKeys* operator ->() { return &self; }
5343         const LDKTxCreationKeys* operator &() const { return &self; }
5344         const LDKTxCreationKeys* operator ->() const { return &self; }
5345 };
5346 class ChannelPublicKeys {
5347 private:
5348         LDKChannelPublicKeys self;
5349 public:
5350         ChannelPublicKeys(const ChannelPublicKeys&) = delete;
5351         ChannelPublicKeys(ChannelPublicKeys&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelPublicKeys)); }
5352         ChannelPublicKeys(LDKChannelPublicKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelPublicKeys)); }
5353         operator LDKChannelPublicKeys() && { LDKChannelPublicKeys res = self; memset(&self, 0, sizeof(LDKChannelPublicKeys)); return res; }
5354         ~ChannelPublicKeys() { ChannelPublicKeys_free(self); }
5355         ChannelPublicKeys& operator=(ChannelPublicKeys&& o) { ChannelPublicKeys_free(self); self = o.self; memset(&o, 0, sizeof(ChannelPublicKeys)); return *this; }
5356         LDKChannelPublicKeys* operator &() { return &self; }
5357         LDKChannelPublicKeys* operator ->() { return &self; }
5358         const LDKChannelPublicKeys* operator &() const { return &self; }
5359         const LDKChannelPublicKeys* operator ->() const { return &self; }
5360 };
5361 class HTLCOutputInCommitment {
5362 private:
5363         LDKHTLCOutputInCommitment self;
5364 public:
5365         HTLCOutputInCommitment(const HTLCOutputInCommitment&) = delete;
5366         HTLCOutputInCommitment(HTLCOutputInCommitment&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCOutputInCommitment)); }
5367         HTLCOutputInCommitment(LDKHTLCOutputInCommitment&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCOutputInCommitment)); }
5368         operator LDKHTLCOutputInCommitment() && { LDKHTLCOutputInCommitment res = self; memset(&self, 0, sizeof(LDKHTLCOutputInCommitment)); return res; }
5369         ~HTLCOutputInCommitment() { HTLCOutputInCommitment_free(self); }
5370         HTLCOutputInCommitment& operator=(HTLCOutputInCommitment&& o) { HTLCOutputInCommitment_free(self); self = o.self; memset(&o, 0, sizeof(HTLCOutputInCommitment)); return *this; }
5371         LDKHTLCOutputInCommitment* operator &() { return &self; }
5372         LDKHTLCOutputInCommitment* operator ->() { return &self; }
5373         const LDKHTLCOutputInCommitment* operator &() const { return &self; }
5374         const LDKHTLCOutputInCommitment* operator ->() const { return &self; }
5375 };
5376 class ChannelTransactionParameters {
5377 private:
5378         LDKChannelTransactionParameters self;
5379 public:
5380         ChannelTransactionParameters(const ChannelTransactionParameters&) = delete;
5381         ChannelTransactionParameters(ChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTransactionParameters)); }
5382         ChannelTransactionParameters(LDKChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTransactionParameters)); }
5383         operator LDKChannelTransactionParameters() && { LDKChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKChannelTransactionParameters)); return res; }
5384         ~ChannelTransactionParameters() { ChannelTransactionParameters_free(self); }
5385         ChannelTransactionParameters& operator=(ChannelTransactionParameters&& o) { ChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTransactionParameters)); return *this; }
5386         LDKChannelTransactionParameters* operator &() { return &self; }
5387         LDKChannelTransactionParameters* operator ->() { return &self; }
5388         const LDKChannelTransactionParameters* operator &() const { return &self; }
5389         const LDKChannelTransactionParameters* operator ->() const { return &self; }
5390 };
5391 class CounterpartyChannelTransactionParameters {
5392 private:
5393         LDKCounterpartyChannelTransactionParameters self;
5394 public:
5395         CounterpartyChannelTransactionParameters(const CounterpartyChannelTransactionParameters&) = delete;
5396         CounterpartyChannelTransactionParameters(CounterpartyChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyChannelTransactionParameters)); }
5397         CounterpartyChannelTransactionParameters(LDKCounterpartyChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyChannelTransactionParameters)); }
5398         operator LDKCounterpartyChannelTransactionParameters() && { LDKCounterpartyChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKCounterpartyChannelTransactionParameters)); return res; }
5399         ~CounterpartyChannelTransactionParameters() { CounterpartyChannelTransactionParameters_free(self); }
5400         CounterpartyChannelTransactionParameters& operator=(CounterpartyChannelTransactionParameters&& o) { CounterpartyChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyChannelTransactionParameters)); return *this; }
5401         LDKCounterpartyChannelTransactionParameters* operator &() { return &self; }
5402         LDKCounterpartyChannelTransactionParameters* operator ->() { return &self; }
5403         const LDKCounterpartyChannelTransactionParameters* operator &() const { return &self; }
5404         const LDKCounterpartyChannelTransactionParameters* operator ->() const { return &self; }
5405 };
5406 class DirectedChannelTransactionParameters {
5407 private:
5408         LDKDirectedChannelTransactionParameters self;
5409 public:
5410         DirectedChannelTransactionParameters(const DirectedChannelTransactionParameters&) = delete;
5411         DirectedChannelTransactionParameters(DirectedChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(DirectedChannelTransactionParameters)); }
5412         DirectedChannelTransactionParameters(LDKDirectedChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectedChannelTransactionParameters)); }
5413         operator LDKDirectedChannelTransactionParameters() && { LDKDirectedChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKDirectedChannelTransactionParameters)); return res; }
5414         ~DirectedChannelTransactionParameters() { DirectedChannelTransactionParameters_free(self); }
5415         DirectedChannelTransactionParameters& operator=(DirectedChannelTransactionParameters&& o) { DirectedChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(DirectedChannelTransactionParameters)); return *this; }
5416         LDKDirectedChannelTransactionParameters* operator &() { return &self; }
5417         LDKDirectedChannelTransactionParameters* operator ->() { return &self; }
5418         const LDKDirectedChannelTransactionParameters* operator &() const { return &self; }
5419         const LDKDirectedChannelTransactionParameters* operator ->() const { return &self; }
5420 };
5421 class HolderCommitmentTransaction {
5422 private:
5423         LDKHolderCommitmentTransaction self;
5424 public:
5425         HolderCommitmentTransaction(const HolderCommitmentTransaction&) = delete;
5426         HolderCommitmentTransaction(HolderCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(HolderCommitmentTransaction)); }
5427         HolderCommitmentTransaction(LDKHolderCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHolderCommitmentTransaction)); }
5428         operator LDKHolderCommitmentTransaction() && { LDKHolderCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKHolderCommitmentTransaction)); return res; }
5429         ~HolderCommitmentTransaction() { HolderCommitmentTransaction_free(self); }
5430         HolderCommitmentTransaction& operator=(HolderCommitmentTransaction&& o) { HolderCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(HolderCommitmentTransaction)); return *this; }
5431         LDKHolderCommitmentTransaction* operator &() { return &self; }
5432         LDKHolderCommitmentTransaction* operator ->() { return &self; }
5433         const LDKHolderCommitmentTransaction* operator &() const { return &self; }
5434         const LDKHolderCommitmentTransaction* operator ->() const { return &self; }
5435 };
5436 class BuiltCommitmentTransaction {
5437 private:
5438         LDKBuiltCommitmentTransaction self;
5439 public:
5440         BuiltCommitmentTransaction(const BuiltCommitmentTransaction&) = delete;
5441         BuiltCommitmentTransaction(BuiltCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(BuiltCommitmentTransaction)); }
5442         BuiltCommitmentTransaction(LDKBuiltCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBuiltCommitmentTransaction)); }
5443         operator LDKBuiltCommitmentTransaction() && { LDKBuiltCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKBuiltCommitmentTransaction)); return res; }
5444         ~BuiltCommitmentTransaction() { BuiltCommitmentTransaction_free(self); }
5445         BuiltCommitmentTransaction& operator=(BuiltCommitmentTransaction&& o) { BuiltCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(BuiltCommitmentTransaction)); return *this; }
5446         LDKBuiltCommitmentTransaction* operator &() { return &self; }
5447         LDKBuiltCommitmentTransaction* operator ->() { return &self; }
5448         const LDKBuiltCommitmentTransaction* operator &() const { return &self; }
5449         const LDKBuiltCommitmentTransaction* operator ->() const { return &self; }
5450 };
5451 class ClosingTransaction {
5452 private:
5453         LDKClosingTransaction self;
5454 public:
5455         ClosingTransaction(const ClosingTransaction&) = delete;
5456         ClosingTransaction(ClosingTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingTransaction)); }
5457         ClosingTransaction(LDKClosingTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingTransaction)); }
5458         operator LDKClosingTransaction() && { LDKClosingTransaction res = self; memset(&self, 0, sizeof(LDKClosingTransaction)); return res; }
5459         ~ClosingTransaction() { ClosingTransaction_free(self); }
5460         ClosingTransaction& operator=(ClosingTransaction&& o) { ClosingTransaction_free(self); self = o.self; memset(&o, 0, sizeof(ClosingTransaction)); return *this; }
5461         LDKClosingTransaction* operator &() { return &self; }
5462         LDKClosingTransaction* operator ->() { return &self; }
5463         const LDKClosingTransaction* operator &() const { return &self; }
5464         const LDKClosingTransaction* operator ->() const { return &self; }
5465 };
5466 class TrustedClosingTransaction {
5467 private:
5468         LDKTrustedClosingTransaction self;
5469 public:
5470         TrustedClosingTransaction(const TrustedClosingTransaction&) = delete;
5471         TrustedClosingTransaction(TrustedClosingTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(TrustedClosingTransaction)); }
5472         TrustedClosingTransaction(LDKTrustedClosingTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrustedClosingTransaction)); }
5473         operator LDKTrustedClosingTransaction() && { LDKTrustedClosingTransaction res = self; memset(&self, 0, sizeof(LDKTrustedClosingTransaction)); return res; }
5474         ~TrustedClosingTransaction() { TrustedClosingTransaction_free(self); }
5475         TrustedClosingTransaction& operator=(TrustedClosingTransaction&& o) { TrustedClosingTransaction_free(self); self = o.self; memset(&o, 0, sizeof(TrustedClosingTransaction)); return *this; }
5476         LDKTrustedClosingTransaction* operator &() { return &self; }
5477         LDKTrustedClosingTransaction* operator ->() { return &self; }
5478         const LDKTrustedClosingTransaction* operator &() const { return &self; }
5479         const LDKTrustedClosingTransaction* operator ->() const { return &self; }
5480 };
5481 class CommitmentTransaction {
5482 private:
5483         LDKCommitmentTransaction self;
5484 public:
5485         CommitmentTransaction(const CommitmentTransaction&) = delete;
5486         CommitmentTransaction(CommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentTransaction)); }
5487         CommitmentTransaction(LDKCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentTransaction)); }
5488         operator LDKCommitmentTransaction() && { LDKCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKCommitmentTransaction)); return res; }
5489         ~CommitmentTransaction() { CommitmentTransaction_free(self); }
5490         CommitmentTransaction& operator=(CommitmentTransaction&& o) { CommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentTransaction)); return *this; }
5491         LDKCommitmentTransaction* operator &() { return &self; }
5492         LDKCommitmentTransaction* operator ->() { return &self; }
5493         const LDKCommitmentTransaction* operator &() const { return &self; }
5494         const LDKCommitmentTransaction* operator ->() const { return &self; }
5495 };
5496 class TrustedCommitmentTransaction {
5497 private:
5498         LDKTrustedCommitmentTransaction self;
5499 public:
5500         TrustedCommitmentTransaction(const TrustedCommitmentTransaction&) = delete;
5501         TrustedCommitmentTransaction(TrustedCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(TrustedCommitmentTransaction)); }
5502         TrustedCommitmentTransaction(LDKTrustedCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrustedCommitmentTransaction)); }
5503         operator LDKTrustedCommitmentTransaction() && { LDKTrustedCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKTrustedCommitmentTransaction)); return res; }
5504         ~TrustedCommitmentTransaction() { TrustedCommitmentTransaction_free(self); }
5505         TrustedCommitmentTransaction& operator=(TrustedCommitmentTransaction&& o) { TrustedCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(TrustedCommitmentTransaction)); return *this; }
5506         LDKTrustedCommitmentTransaction* operator &() { return &self; }
5507         LDKTrustedCommitmentTransaction* operator ->() { return &self; }
5508         const LDKTrustedCommitmentTransaction* operator &() const { return &self; }
5509         const LDKTrustedCommitmentTransaction* operator ->() const { return &self; }
5510 };
5511 class ShutdownScript {
5512 private:
5513         LDKShutdownScript self;
5514 public:
5515         ShutdownScript(const ShutdownScript&) = delete;
5516         ShutdownScript(ShutdownScript&& o) : self(o.self) { memset(&o, 0, sizeof(ShutdownScript)); }
5517         ShutdownScript(LDKShutdownScript&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdownScript)); }
5518         operator LDKShutdownScript() && { LDKShutdownScript res = self; memset(&self, 0, sizeof(LDKShutdownScript)); return res; }
5519         ~ShutdownScript() { ShutdownScript_free(self); }
5520         ShutdownScript& operator=(ShutdownScript&& o) { ShutdownScript_free(self); self = o.self; memset(&o, 0, sizeof(ShutdownScript)); return *this; }
5521         LDKShutdownScript* operator &() { return &self; }
5522         LDKShutdownScript* operator ->() { return &self; }
5523         const LDKShutdownScript* operator &() const { return &self; }
5524         const LDKShutdownScript* operator ->() const { return &self; }
5525 };
5526 class InvalidShutdownScript {
5527 private:
5528         LDKInvalidShutdownScript self;
5529 public:
5530         InvalidShutdownScript(const InvalidShutdownScript&) = delete;
5531         InvalidShutdownScript(InvalidShutdownScript&& o) : self(o.self) { memset(&o, 0, sizeof(InvalidShutdownScript)); }
5532         InvalidShutdownScript(LDKInvalidShutdownScript&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvalidShutdownScript)); }
5533         operator LDKInvalidShutdownScript() && { LDKInvalidShutdownScript res = self; memset(&self, 0, sizeof(LDKInvalidShutdownScript)); return res; }
5534         ~InvalidShutdownScript() { InvalidShutdownScript_free(self); }
5535         InvalidShutdownScript& operator=(InvalidShutdownScript&& o) { InvalidShutdownScript_free(self); self = o.self; memset(&o, 0, sizeof(InvalidShutdownScript)); return *this; }
5536         LDKInvalidShutdownScript* operator &() { return &self; }
5537         LDKInvalidShutdownScript* operator ->() { return &self; }
5538         const LDKInvalidShutdownScript* operator &() const { return &self; }
5539         const LDKInvalidShutdownScript* operator ->() const { return &self; }
5540 };
5541 class Bolt12ParseError {
5542 private:
5543         LDKBolt12ParseError self;
5544 public:
5545         Bolt12ParseError(const Bolt12ParseError&) = delete;
5546         Bolt12ParseError(Bolt12ParseError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12ParseError)); }
5547         Bolt12ParseError(LDKBolt12ParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12ParseError)); }
5548         operator LDKBolt12ParseError() && { LDKBolt12ParseError res = self; memset(&self, 0, sizeof(LDKBolt12ParseError)); return res; }
5549         ~Bolt12ParseError() { Bolt12ParseError_free(self); }
5550         Bolt12ParseError& operator=(Bolt12ParseError&& o) { Bolt12ParseError_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12ParseError)); return *this; }
5551         LDKBolt12ParseError* operator &() { return &self; }
5552         LDKBolt12ParseError* operator ->() { return &self; }
5553         const LDKBolt12ParseError* operator &() const { return &self; }
5554         const LDKBolt12ParseError* operator ->() const { return &self; }
5555 };
5556 class Bolt12SemanticError {
5557 private:
5558         LDKBolt12SemanticError self;
5559 public:
5560         Bolt12SemanticError(const Bolt12SemanticError&) = delete;
5561         Bolt12SemanticError(Bolt12SemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12SemanticError)); }
5562         Bolt12SemanticError(LDKBolt12SemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12SemanticError)); }
5563         operator LDKBolt12SemanticError() && { LDKBolt12SemanticError res = self; memset(&self, 0, sizeof(LDKBolt12SemanticError)); return res; }
5564         Bolt12SemanticError& operator=(Bolt12SemanticError&& o) { self = o.self; memset(&o, 0, sizeof(Bolt12SemanticError)); return *this; }
5565         LDKBolt12SemanticError* operator &() { return &self; }
5566         LDKBolt12SemanticError* operator ->() { return &self; }
5567         const LDKBolt12SemanticError* operator &() const { return &self; }
5568         const LDKBolt12SemanticError* operator ->() const { return &self; }
5569 };
5570 class BroadcasterInterface {
5571 private:
5572         LDKBroadcasterInterface self;
5573 public:
5574         BroadcasterInterface(const BroadcasterInterface&) = delete;
5575         BroadcasterInterface(BroadcasterInterface&& o) : self(o.self) { memset(&o, 0, sizeof(BroadcasterInterface)); }
5576         BroadcasterInterface(LDKBroadcasterInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBroadcasterInterface)); }
5577         operator LDKBroadcasterInterface() && { LDKBroadcasterInterface res = self; memset(&self, 0, sizeof(LDKBroadcasterInterface)); return res; }
5578         ~BroadcasterInterface() { BroadcasterInterface_free(self); }
5579         BroadcasterInterface& operator=(BroadcasterInterface&& o) { BroadcasterInterface_free(self); self = o.self; memset(&o, 0, sizeof(BroadcasterInterface)); return *this; }
5580         LDKBroadcasterInterface* operator &() { return &self; }
5581         LDKBroadcasterInterface* operator ->() { return &self; }
5582         const LDKBroadcasterInterface* operator &() const { return &self; }
5583         const LDKBroadcasterInterface* operator ->() const { return &self; }
5584         /**
5585          *  Sends a list of transactions out to (hopefully) be mined.
5586          *  This only needs to handle the actual broadcasting of transactions, LDK will automatically
5587          *  rebroadcast transactions that haven't made it into a block.
5588          *
5589          *  In some cases LDK may attempt to broadcast a transaction which double-spends another
5590          *  and this isn't a bug and can be safely ignored.
5591          *
5592          *  If more than one transaction is given, these transactions should be considered to be a
5593          *  package and broadcast together. Some of the transactions may or may not depend on each other,
5594          *  be sure to manage both cases correctly.
5595          *
5596          *  Bitcoin transaction packages are defined in BIP 331 and here:
5597          *  <https://github.com/bitcoin/bitcoin/blob/master/doc/policy/packages.md>
5598          */
5599         inline void broadcast_transactions(struct LDKCVec_TransactionZ txs);
5600 };
5601 class ConfirmationTarget {
5602 private:
5603         LDKConfirmationTarget self;
5604 public:
5605         ConfirmationTarget(const ConfirmationTarget&) = delete;
5606         ConfirmationTarget(ConfirmationTarget&& o) : self(o.self) { memset(&o, 0, sizeof(ConfirmationTarget)); }
5607         ConfirmationTarget(LDKConfirmationTarget&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirmationTarget)); }
5608         operator LDKConfirmationTarget() && { LDKConfirmationTarget res = self; memset(&self, 0, sizeof(LDKConfirmationTarget)); return res; }
5609         ConfirmationTarget& operator=(ConfirmationTarget&& o) { self = o.self; memset(&o, 0, sizeof(ConfirmationTarget)); return *this; }
5610         LDKConfirmationTarget* operator &() { return &self; }
5611         LDKConfirmationTarget* operator ->() { return &self; }
5612         const LDKConfirmationTarget* operator &() const { return &self; }
5613         const LDKConfirmationTarget* operator ->() const { return &self; }
5614 };
5615 class FeeEstimator {
5616 private:
5617         LDKFeeEstimator self;
5618 public:
5619         FeeEstimator(const FeeEstimator&) = delete;
5620         FeeEstimator(FeeEstimator&& o) : self(o.self) { memset(&o, 0, sizeof(FeeEstimator)); }
5621         FeeEstimator(LDKFeeEstimator&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFeeEstimator)); }
5622         operator LDKFeeEstimator() && { LDKFeeEstimator res = self; memset(&self, 0, sizeof(LDKFeeEstimator)); return res; }
5623         ~FeeEstimator() { FeeEstimator_free(self); }
5624         FeeEstimator& operator=(FeeEstimator&& o) { FeeEstimator_free(self); self = o.self; memset(&o, 0, sizeof(FeeEstimator)); return *this; }
5625         LDKFeeEstimator* operator &() { return &self; }
5626         LDKFeeEstimator* operator ->() { return &self; }
5627         const LDKFeeEstimator* operator &() const { return &self; }
5628         const LDKFeeEstimator* operator ->() const { return &self; }
5629         /**
5630          *  Gets estimated satoshis of fee required per 1000 Weight-Units.
5631          *
5632          *  LDK will wrap this method and ensure that the value returned is no smaller than 253
5633          *  (ie 1 satoshi-per-byte rounded up to ensure later round-downs don't put us below 1 satoshi-per-byte).
5634          *
5635          *  The following unit conversions can be used to convert to sats/KW:
5636          *   * satoshis-per-byte * 250
5637          *   * satoshis-per-kbyte / 4
5638          */
5639         inline uint32_t get_est_sat_per_1000_weight(enum LDKConfirmationTarget confirmation_target);
5640 };
5641 class Packet {
5642 private:
5643         LDKPacket self;
5644 public:
5645         Packet(const Packet&) = delete;
5646         Packet(Packet&& o) : self(o.self) { memset(&o, 0, sizeof(Packet)); }
5647         Packet(LDKPacket&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPacket)); }
5648         operator LDKPacket() && { LDKPacket res = self; memset(&self, 0, sizeof(LDKPacket)); return res; }
5649         ~Packet() { Packet_free(self); }
5650         Packet& operator=(Packet&& o) { Packet_free(self); self = o.self; memset(&o, 0, sizeof(Packet)); return *this; }
5651         LDKPacket* operator &() { return &self; }
5652         LDKPacket* operator ->() { return &self; }
5653         const LDKPacket* operator &() const { return &self; }
5654         const LDKPacket* operator ->() const { return &self; }
5655 };
5656 class ParsedOnionMessageContents {
5657 private:
5658         LDKParsedOnionMessageContents self;
5659 public:
5660         ParsedOnionMessageContents(const ParsedOnionMessageContents&) = delete;
5661         ParsedOnionMessageContents(ParsedOnionMessageContents&& o) : self(o.self) { memset(&o, 0, sizeof(ParsedOnionMessageContents)); }
5662         ParsedOnionMessageContents(LDKParsedOnionMessageContents&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKParsedOnionMessageContents)); }
5663         operator LDKParsedOnionMessageContents() && { LDKParsedOnionMessageContents res = self; memset(&self, 0, sizeof(LDKParsedOnionMessageContents)); return res; }
5664         ~ParsedOnionMessageContents() { ParsedOnionMessageContents_free(self); }
5665         ParsedOnionMessageContents& operator=(ParsedOnionMessageContents&& o) { ParsedOnionMessageContents_free(self); self = o.self; memset(&o, 0, sizeof(ParsedOnionMessageContents)); return *this; }
5666         LDKParsedOnionMessageContents* operator &() { return &self; }
5667         LDKParsedOnionMessageContents* operator ->() { return &self; }
5668         const LDKParsedOnionMessageContents* operator &() const { return &self; }
5669         const LDKParsedOnionMessageContents* operator ->() const { return &self; }
5670 };
5671 class OnionMessageContents {
5672 private:
5673         LDKOnionMessageContents self;
5674 public:
5675         OnionMessageContents(const OnionMessageContents&) = delete;
5676         OnionMessageContents(OnionMessageContents&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageContents)); }
5677         OnionMessageContents(LDKOnionMessageContents&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageContents)); }
5678         operator LDKOnionMessageContents() && { LDKOnionMessageContents res = self; memset(&self, 0, sizeof(LDKOnionMessageContents)); return res; }
5679         ~OnionMessageContents() { OnionMessageContents_free(self); }
5680         OnionMessageContents& operator=(OnionMessageContents&& o) { OnionMessageContents_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageContents)); return *this; }
5681         LDKOnionMessageContents* operator &() { return &self; }
5682         LDKOnionMessageContents* operator ->() { return &self; }
5683         const LDKOnionMessageContents* operator &() const { return &self; }
5684         const LDKOnionMessageContents* operator ->() const { return &self; }
5685         /**
5686          *  Returns the TLV type identifying the message contents. MUST be >= 64.
5687          */
5688         inline uint64_t tlv_type();
5689         /**
5690          * Return a human-readable "debug" string describing this object
5691          */
5692         inline LDK::Str debug_str();
5693 };
5694 class PaymentPurpose {
5695 private:
5696         LDKPaymentPurpose self;
5697 public:
5698         PaymentPurpose(const PaymentPurpose&) = delete;
5699         PaymentPurpose(PaymentPurpose&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentPurpose)); }
5700         PaymentPurpose(LDKPaymentPurpose&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentPurpose)); }
5701         operator LDKPaymentPurpose() && { LDKPaymentPurpose res = self; memset(&self, 0, sizeof(LDKPaymentPurpose)); return res; }
5702         ~PaymentPurpose() { PaymentPurpose_free(self); }
5703         PaymentPurpose& operator=(PaymentPurpose&& o) { PaymentPurpose_free(self); self = o.self; memset(&o, 0, sizeof(PaymentPurpose)); return *this; }
5704         LDKPaymentPurpose* operator &() { return &self; }
5705         LDKPaymentPurpose* operator ->() { return &self; }
5706         const LDKPaymentPurpose* operator &() const { return &self; }
5707         const LDKPaymentPurpose* operator ->() const { return &self; }
5708 };
5709 class ClaimedHTLC {
5710 private:
5711         LDKClaimedHTLC self;
5712 public:
5713         ClaimedHTLC(const ClaimedHTLC&) = delete;
5714         ClaimedHTLC(ClaimedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(ClaimedHTLC)); }
5715         ClaimedHTLC(LDKClaimedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClaimedHTLC)); }
5716         operator LDKClaimedHTLC() && { LDKClaimedHTLC res = self; memset(&self, 0, sizeof(LDKClaimedHTLC)); return res; }
5717         ~ClaimedHTLC() { ClaimedHTLC_free(self); }
5718         ClaimedHTLC& operator=(ClaimedHTLC&& o) { ClaimedHTLC_free(self); self = o.self; memset(&o, 0, sizeof(ClaimedHTLC)); return *this; }
5719         LDKClaimedHTLC* operator &() { return &self; }
5720         LDKClaimedHTLC* operator ->() { return &self; }
5721         const LDKClaimedHTLC* operator &() const { return &self; }
5722         const LDKClaimedHTLC* operator ->() const { return &self; }
5723 };
5724 class PathFailure {
5725 private:
5726         LDKPathFailure self;
5727 public:
5728         PathFailure(const PathFailure&) = delete;
5729         PathFailure(PathFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PathFailure)); }
5730         PathFailure(LDKPathFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPathFailure)); }
5731         operator LDKPathFailure() && { LDKPathFailure res = self; memset(&self, 0, sizeof(LDKPathFailure)); return res; }
5732         ~PathFailure() { PathFailure_free(self); }
5733         PathFailure& operator=(PathFailure&& o) { PathFailure_free(self); self = o.self; memset(&o, 0, sizeof(PathFailure)); return *this; }
5734         LDKPathFailure* operator &() { return &self; }
5735         LDKPathFailure* operator ->() { return &self; }
5736         const LDKPathFailure* operator &() const { return &self; }
5737         const LDKPathFailure* operator ->() const { return &self; }
5738 };
5739 class ClosureReason {
5740 private:
5741         LDKClosureReason self;
5742 public:
5743         ClosureReason(const ClosureReason&) = delete;
5744         ClosureReason(ClosureReason&& o) : self(o.self) { memset(&o, 0, sizeof(ClosureReason)); }
5745         ClosureReason(LDKClosureReason&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosureReason)); }
5746         operator LDKClosureReason() && { LDKClosureReason res = self; memset(&self, 0, sizeof(LDKClosureReason)); return res; }
5747         ~ClosureReason() { ClosureReason_free(self); }
5748         ClosureReason& operator=(ClosureReason&& o) { ClosureReason_free(self); self = o.self; memset(&o, 0, sizeof(ClosureReason)); return *this; }
5749         LDKClosureReason* operator &() { return &self; }
5750         LDKClosureReason* operator ->() { return &self; }
5751         const LDKClosureReason* operator &() const { return &self; }
5752         const LDKClosureReason* operator ->() const { return &self; }
5753 };
5754 class HTLCDestination {
5755 private:
5756         LDKHTLCDestination self;
5757 public:
5758         HTLCDestination(const HTLCDestination&) = delete;
5759         HTLCDestination(HTLCDestination&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCDestination)); }
5760         HTLCDestination(LDKHTLCDestination&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCDestination)); }
5761         operator LDKHTLCDestination() && { LDKHTLCDestination res = self; memset(&self, 0, sizeof(LDKHTLCDestination)); return res; }
5762         ~HTLCDestination() { HTLCDestination_free(self); }
5763         HTLCDestination& operator=(HTLCDestination&& o) { HTLCDestination_free(self); self = o.self; memset(&o, 0, sizeof(HTLCDestination)); return *this; }
5764         LDKHTLCDestination* operator &() { return &self; }
5765         LDKHTLCDestination* operator ->() { return &self; }
5766         const LDKHTLCDestination* operator &() const { return &self; }
5767         const LDKHTLCDestination* operator ->() const { return &self; }
5768 };
5769 class PaymentFailureReason {
5770 private:
5771         LDKPaymentFailureReason self;
5772 public:
5773         PaymentFailureReason(const PaymentFailureReason&) = delete;
5774         PaymentFailureReason(PaymentFailureReason&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentFailureReason)); }
5775         PaymentFailureReason(LDKPaymentFailureReason&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentFailureReason)); }
5776         operator LDKPaymentFailureReason() && { LDKPaymentFailureReason res = self; memset(&self, 0, sizeof(LDKPaymentFailureReason)); return res; }
5777         PaymentFailureReason& operator=(PaymentFailureReason&& o) { self = o.self; memset(&o, 0, sizeof(PaymentFailureReason)); return *this; }
5778         LDKPaymentFailureReason* operator &() { return &self; }
5779         LDKPaymentFailureReason* operator ->() { return &self; }
5780         const LDKPaymentFailureReason* operator &() const { return &self; }
5781         const LDKPaymentFailureReason* operator ->() const { return &self; }
5782 };
5783 class Event {
5784 private:
5785         LDKEvent self;
5786 public:
5787         Event(const Event&) = delete;
5788         Event(Event&& o) : self(o.self) { memset(&o, 0, sizeof(Event)); }
5789         Event(LDKEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEvent)); }
5790         operator LDKEvent() && { LDKEvent res = self; memset(&self, 0, sizeof(LDKEvent)); return res; }
5791         ~Event() { Event_free(self); }
5792         Event& operator=(Event&& o) { Event_free(self); self = o.self; memset(&o, 0, sizeof(Event)); return *this; }
5793         LDKEvent* operator &() { return &self; }
5794         LDKEvent* operator ->() { return &self; }
5795         const LDKEvent* operator &() const { return &self; }
5796         const LDKEvent* operator ->() const { return &self; }
5797 };
5798 class MessageSendEvent {
5799 private:
5800         LDKMessageSendEvent self;
5801 public:
5802         MessageSendEvent(const MessageSendEvent&) = delete;
5803         MessageSendEvent(MessageSendEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEvent)); }
5804         MessageSendEvent(LDKMessageSendEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEvent)); }
5805         operator LDKMessageSendEvent() && { LDKMessageSendEvent res = self; memset(&self, 0, sizeof(LDKMessageSendEvent)); return res; }
5806         ~MessageSendEvent() { MessageSendEvent_free(self); }
5807         MessageSendEvent& operator=(MessageSendEvent&& o) { MessageSendEvent_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEvent)); return *this; }
5808         LDKMessageSendEvent* operator &() { return &self; }
5809         LDKMessageSendEvent* operator ->() { return &self; }
5810         const LDKMessageSendEvent* operator &() const { return &self; }
5811         const LDKMessageSendEvent* operator ->() const { return &self; }
5812 };
5813 class MessageSendEventsProvider {
5814 private:
5815         LDKMessageSendEventsProvider self;
5816 public:
5817         MessageSendEventsProvider(const MessageSendEventsProvider&) = delete;
5818         MessageSendEventsProvider(MessageSendEventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEventsProvider)); }
5819         MessageSendEventsProvider(LDKMessageSendEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEventsProvider)); }
5820         operator LDKMessageSendEventsProvider() && { LDKMessageSendEventsProvider res = self; memset(&self, 0, sizeof(LDKMessageSendEventsProvider)); return res; }
5821         ~MessageSendEventsProvider() { MessageSendEventsProvider_free(self); }
5822         MessageSendEventsProvider& operator=(MessageSendEventsProvider&& o) { MessageSendEventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEventsProvider)); return *this; }
5823         LDKMessageSendEventsProvider* operator &() { return &self; }
5824         LDKMessageSendEventsProvider* operator ->() { return &self; }
5825         const LDKMessageSendEventsProvider* operator &() const { return &self; }
5826         const LDKMessageSendEventsProvider* operator ->() const { return &self; }
5827         /**
5828          *  Gets the list of pending events which were generated by previous actions, clearing the list
5829          *  in the process.
5830          */
5831         inline LDK::CVec_MessageSendEventZ get_and_clear_pending_msg_events();
5832 };
5833 class EventsProvider {
5834 private:
5835         LDKEventsProvider self;
5836 public:
5837         EventsProvider(const EventsProvider&) = delete;
5838         EventsProvider(EventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(EventsProvider)); }
5839         EventsProvider(LDKEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventsProvider)); }
5840         operator LDKEventsProvider() && { LDKEventsProvider res = self; memset(&self, 0, sizeof(LDKEventsProvider)); return res; }
5841         ~EventsProvider() { EventsProvider_free(self); }
5842         EventsProvider& operator=(EventsProvider&& o) { EventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(EventsProvider)); return *this; }
5843         LDKEventsProvider* operator &() { return &self; }
5844         LDKEventsProvider* operator ->() { return &self; }
5845         const LDKEventsProvider* operator &() const { return &self; }
5846         const LDKEventsProvider* operator ->() const { return &self; }
5847         /**
5848          *  Processes any events generated since the last call using the given event handler.
5849          *
5850          *  See the trait-level documentation for requirements.
5851          */
5852         inline void process_pending_events(struct LDKEventHandler handler);
5853 };
5854 class EventHandler {
5855 private:
5856         LDKEventHandler self;
5857 public:
5858         EventHandler(const EventHandler&) = delete;
5859         EventHandler(EventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(EventHandler)); }
5860         EventHandler(LDKEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventHandler)); }
5861         operator LDKEventHandler() && { LDKEventHandler res = self; memset(&self, 0, sizeof(LDKEventHandler)); return res; }
5862         ~EventHandler() { EventHandler_free(self); }
5863         EventHandler& operator=(EventHandler&& o) { EventHandler_free(self); self = o.self; memset(&o, 0, sizeof(EventHandler)); return *this; }
5864         LDKEventHandler* operator &() { return &self; }
5865         LDKEventHandler* operator ->() { return &self; }
5866         const LDKEventHandler* operator &() const { return &self; }
5867         const LDKEventHandler* operator ->() const { return &self; }
5868         /**
5869          *  Handles the given [`Event`].
5870          *
5871          *  See [`EventsProvider`] for details that must be considered when implementing this method.
5872          */
5873         inline void handle_event(struct LDKEvent event);
5874 };
5875 class Bolt11ParseError {
5876 private:
5877         LDKBolt11ParseError self;
5878 public:
5879         Bolt11ParseError(const Bolt11ParseError&) = delete;
5880         Bolt11ParseError(Bolt11ParseError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11ParseError)); }
5881         Bolt11ParseError(LDKBolt11ParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11ParseError)); }
5882         operator LDKBolt11ParseError() && { LDKBolt11ParseError res = self; memset(&self, 0, sizeof(LDKBolt11ParseError)); return res; }
5883         ~Bolt11ParseError() { Bolt11ParseError_free(self); }
5884         Bolt11ParseError& operator=(Bolt11ParseError&& o) { Bolt11ParseError_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11ParseError)); return *this; }
5885         LDKBolt11ParseError* operator &() { return &self; }
5886         LDKBolt11ParseError* operator ->() { return &self; }
5887         const LDKBolt11ParseError* operator &() const { return &self; }
5888         const LDKBolt11ParseError* operator ->() const { return &self; }
5889 };
5890 class ParseOrSemanticError {
5891 private:
5892         LDKParseOrSemanticError self;
5893 public:
5894         ParseOrSemanticError(const ParseOrSemanticError&) = delete;
5895         ParseOrSemanticError(ParseOrSemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(ParseOrSemanticError)); }
5896         ParseOrSemanticError(LDKParseOrSemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKParseOrSemanticError)); }
5897         operator LDKParseOrSemanticError() && { LDKParseOrSemanticError res = self; memset(&self, 0, sizeof(LDKParseOrSemanticError)); return res; }
5898         ~ParseOrSemanticError() { ParseOrSemanticError_free(self); }
5899         ParseOrSemanticError& operator=(ParseOrSemanticError&& o) { ParseOrSemanticError_free(self); self = o.self; memset(&o, 0, sizeof(ParseOrSemanticError)); return *this; }
5900         LDKParseOrSemanticError* operator &() { return &self; }
5901         LDKParseOrSemanticError* operator ->() { return &self; }
5902         const LDKParseOrSemanticError* operator &() const { return &self; }
5903         const LDKParseOrSemanticError* operator ->() const { return &self; }
5904 };
5905 class Bolt11Invoice {
5906 private:
5907         LDKBolt11Invoice self;
5908 public:
5909         Bolt11Invoice(const Bolt11Invoice&) = delete;
5910         Bolt11Invoice(Bolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11Invoice)); }
5911         Bolt11Invoice(LDKBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11Invoice)); }
5912         operator LDKBolt11Invoice() && { LDKBolt11Invoice res = self; memset(&self, 0, sizeof(LDKBolt11Invoice)); return res; }
5913         ~Bolt11Invoice() { Bolt11Invoice_free(self); }
5914         Bolt11Invoice& operator=(Bolt11Invoice&& o) { Bolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11Invoice)); return *this; }
5915         LDKBolt11Invoice* operator &() { return &self; }
5916         LDKBolt11Invoice* operator ->() { return &self; }
5917         const LDKBolt11Invoice* operator &() const { return &self; }
5918         const LDKBolt11Invoice* operator ->() const { return &self; }
5919 };
5920 class SignedRawBolt11Invoice {
5921 private:
5922         LDKSignedRawBolt11Invoice self;
5923 public:
5924         SignedRawBolt11Invoice(const SignedRawBolt11Invoice&) = delete;
5925         SignedRawBolt11Invoice(SignedRawBolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(SignedRawBolt11Invoice)); }
5926         SignedRawBolt11Invoice(LDKSignedRawBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignedRawBolt11Invoice)); }
5927         operator LDKSignedRawBolt11Invoice() && { LDKSignedRawBolt11Invoice res = self; memset(&self, 0, sizeof(LDKSignedRawBolt11Invoice)); return res; }
5928         ~SignedRawBolt11Invoice() { SignedRawBolt11Invoice_free(self); }
5929         SignedRawBolt11Invoice& operator=(SignedRawBolt11Invoice&& o) { SignedRawBolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(SignedRawBolt11Invoice)); return *this; }
5930         LDKSignedRawBolt11Invoice* operator &() { return &self; }
5931         LDKSignedRawBolt11Invoice* operator ->() { return &self; }
5932         const LDKSignedRawBolt11Invoice* operator &() const { return &self; }
5933         const LDKSignedRawBolt11Invoice* operator ->() const { return &self; }
5934 };
5935 class RawBolt11Invoice {
5936 private:
5937         LDKRawBolt11Invoice self;
5938 public:
5939         RawBolt11Invoice(const RawBolt11Invoice&) = delete;
5940         RawBolt11Invoice(RawBolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(RawBolt11Invoice)); }
5941         RawBolt11Invoice(LDKRawBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawBolt11Invoice)); }
5942         operator LDKRawBolt11Invoice() && { LDKRawBolt11Invoice res = self; memset(&self, 0, sizeof(LDKRawBolt11Invoice)); return res; }
5943         ~RawBolt11Invoice() { RawBolt11Invoice_free(self); }
5944         RawBolt11Invoice& operator=(RawBolt11Invoice&& o) { RawBolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(RawBolt11Invoice)); return *this; }
5945         LDKRawBolt11Invoice* operator &() { return &self; }
5946         LDKRawBolt11Invoice* operator ->() { return &self; }
5947         const LDKRawBolt11Invoice* operator &() const { return &self; }
5948         const LDKRawBolt11Invoice* operator ->() const { return &self; }
5949 };
5950 class RawDataPart {
5951 private:
5952         LDKRawDataPart self;
5953 public:
5954         RawDataPart(const RawDataPart&) = delete;
5955         RawDataPart(RawDataPart&& o) : self(o.self) { memset(&o, 0, sizeof(RawDataPart)); }
5956         RawDataPart(LDKRawDataPart&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawDataPart)); }
5957         operator LDKRawDataPart() && { LDKRawDataPart res = self; memset(&self, 0, sizeof(LDKRawDataPart)); return res; }
5958         ~RawDataPart() { RawDataPart_free(self); }
5959         RawDataPart& operator=(RawDataPart&& o) { RawDataPart_free(self); self = o.self; memset(&o, 0, sizeof(RawDataPart)); return *this; }
5960         LDKRawDataPart* operator &() { return &self; }
5961         LDKRawDataPart* operator ->() { return &self; }
5962         const LDKRawDataPart* operator &() const { return &self; }
5963         const LDKRawDataPart* operator ->() const { return &self; }
5964 };
5965 class PositiveTimestamp {
5966 private:
5967         LDKPositiveTimestamp self;
5968 public:
5969         PositiveTimestamp(const PositiveTimestamp&) = delete;
5970         PositiveTimestamp(PositiveTimestamp&& o) : self(o.self) { memset(&o, 0, sizeof(PositiveTimestamp)); }
5971         PositiveTimestamp(LDKPositiveTimestamp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPositiveTimestamp)); }
5972         operator LDKPositiveTimestamp() && { LDKPositiveTimestamp res = self; memset(&self, 0, sizeof(LDKPositiveTimestamp)); return res; }
5973         ~PositiveTimestamp() { PositiveTimestamp_free(self); }
5974         PositiveTimestamp& operator=(PositiveTimestamp&& o) { PositiveTimestamp_free(self); self = o.self; memset(&o, 0, sizeof(PositiveTimestamp)); return *this; }
5975         LDKPositiveTimestamp* operator &() { return &self; }
5976         LDKPositiveTimestamp* operator ->() { return &self; }
5977         const LDKPositiveTimestamp* operator &() const { return &self; }
5978         const LDKPositiveTimestamp* operator ->() const { return &self; }
5979 };
5980 class SiPrefix {
5981 private:
5982         LDKSiPrefix self;
5983 public:
5984         SiPrefix(const SiPrefix&) = delete;
5985         SiPrefix(SiPrefix&& o) : self(o.self) { memset(&o, 0, sizeof(SiPrefix)); }
5986         SiPrefix(LDKSiPrefix&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSiPrefix)); }
5987         operator LDKSiPrefix() && { LDKSiPrefix res = self; memset(&self, 0, sizeof(LDKSiPrefix)); return res; }
5988         SiPrefix& operator=(SiPrefix&& o) { self = o.self; memset(&o, 0, sizeof(SiPrefix)); return *this; }
5989         LDKSiPrefix* operator &() { return &self; }
5990         LDKSiPrefix* operator ->() { return &self; }
5991         const LDKSiPrefix* operator &() const { return &self; }
5992         const LDKSiPrefix* operator ->() const { return &self; }
5993 };
5994 class Currency {
5995 private:
5996         LDKCurrency self;
5997 public:
5998         Currency(const Currency&) = delete;
5999         Currency(Currency&& o) : self(o.self) { memset(&o, 0, sizeof(Currency)); }
6000         Currency(LDKCurrency&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCurrency)); }
6001         operator LDKCurrency() && { LDKCurrency res = self; memset(&self, 0, sizeof(LDKCurrency)); return res; }
6002         Currency& operator=(Currency&& o) { self = o.self; memset(&o, 0, sizeof(Currency)); return *this; }
6003         LDKCurrency* operator &() { return &self; }
6004         LDKCurrency* operator ->() { return &self; }
6005         const LDKCurrency* operator &() const { return &self; }
6006         const LDKCurrency* operator ->() const { return &self; }
6007 };
6008 class Sha256 {
6009 private:
6010         LDKSha256 self;
6011 public:
6012         Sha256(const Sha256&) = delete;
6013         Sha256(Sha256&& o) : self(o.self) { memset(&o, 0, sizeof(Sha256)); }
6014         Sha256(LDKSha256&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSha256)); }
6015         operator LDKSha256() && { LDKSha256 res = self; memset(&self, 0, sizeof(LDKSha256)); return res; }
6016         ~Sha256() { Sha256_free(self); }
6017         Sha256& operator=(Sha256&& o) { Sha256_free(self); self = o.self; memset(&o, 0, sizeof(Sha256)); return *this; }
6018         LDKSha256* operator &() { return &self; }
6019         LDKSha256* operator ->() { return &self; }
6020         const LDKSha256* operator &() const { return &self; }
6021         const LDKSha256* operator ->() const { return &self; }
6022 };
6023 class Description {
6024 private:
6025         LDKDescription self;
6026 public:
6027         Description(const Description&) = delete;
6028         Description(Description&& o) : self(o.self) { memset(&o, 0, sizeof(Description)); }
6029         Description(LDKDescription&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDescription)); }
6030         operator LDKDescription() && { LDKDescription res = self; memset(&self, 0, sizeof(LDKDescription)); return res; }
6031         ~Description() { Description_free(self); }
6032         Description& operator=(Description&& o) { Description_free(self); self = o.self; memset(&o, 0, sizeof(Description)); return *this; }
6033         LDKDescription* operator &() { return &self; }
6034         LDKDescription* operator ->() { return &self; }
6035         const LDKDescription* operator &() const { return &self; }
6036         const LDKDescription* operator ->() const { return &self; }
6037 };
6038 class PayeePubKey {
6039 private:
6040         LDKPayeePubKey self;
6041 public:
6042         PayeePubKey(const PayeePubKey&) = delete;
6043         PayeePubKey(PayeePubKey&& o) : self(o.self) { memset(&o, 0, sizeof(PayeePubKey)); }
6044         PayeePubKey(LDKPayeePubKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayeePubKey)); }
6045         operator LDKPayeePubKey() && { LDKPayeePubKey res = self; memset(&self, 0, sizeof(LDKPayeePubKey)); return res; }
6046         ~PayeePubKey() { PayeePubKey_free(self); }
6047         PayeePubKey& operator=(PayeePubKey&& o) { PayeePubKey_free(self); self = o.self; memset(&o, 0, sizeof(PayeePubKey)); return *this; }
6048         LDKPayeePubKey* operator &() { return &self; }
6049         LDKPayeePubKey* operator ->() { return &self; }
6050         const LDKPayeePubKey* operator &() const { return &self; }
6051         const LDKPayeePubKey* operator ->() const { return &self; }
6052 };
6053 class ExpiryTime {
6054 private:
6055         LDKExpiryTime self;
6056 public:
6057         ExpiryTime(const ExpiryTime&) = delete;
6058         ExpiryTime(ExpiryTime&& o) : self(o.self) { memset(&o, 0, sizeof(ExpiryTime)); }
6059         ExpiryTime(LDKExpiryTime&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpiryTime)); }
6060         operator LDKExpiryTime() && { LDKExpiryTime res = self; memset(&self, 0, sizeof(LDKExpiryTime)); return res; }
6061         ~ExpiryTime() { ExpiryTime_free(self); }
6062         ExpiryTime& operator=(ExpiryTime&& o) { ExpiryTime_free(self); self = o.self; memset(&o, 0, sizeof(ExpiryTime)); return *this; }
6063         LDKExpiryTime* operator &() { return &self; }
6064         LDKExpiryTime* operator ->() { return &self; }
6065         const LDKExpiryTime* operator &() const { return &self; }
6066         const LDKExpiryTime* operator ->() const { return &self; }
6067 };
6068 class MinFinalCltvExpiryDelta {
6069 private:
6070         LDKMinFinalCltvExpiryDelta self;
6071 public:
6072         MinFinalCltvExpiryDelta(const MinFinalCltvExpiryDelta&) = delete;
6073         MinFinalCltvExpiryDelta(MinFinalCltvExpiryDelta&& o) : self(o.self) { memset(&o, 0, sizeof(MinFinalCltvExpiryDelta)); }
6074         MinFinalCltvExpiryDelta(LDKMinFinalCltvExpiryDelta&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMinFinalCltvExpiryDelta)); }
6075         operator LDKMinFinalCltvExpiryDelta() && { LDKMinFinalCltvExpiryDelta res = self; memset(&self, 0, sizeof(LDKMinFinalCltvExpiryDelta)); return res; }
6076         ~MinFinalCltvExpiryDelta() { MinFinalCltvExpiryDelta_free(self); }
6077         MinFinalCltvExpiryDelta& operator=(MinFinalCltvExpiryDelta&& o) { MinFinalCltvExpiryDelta_free(self); self = o.self; memset(&o, 0, sizeof(MinFinalCltvExpiryDelta)); return *this; }
6078         LDKMinFinalCltvExpiryDelta* operator &() { return &self; }
6079         LDKMinFinalCltvExpiryDelta* operator ->() { return &self; }
6080         const LDKMinFinalCltvExpiryDelta* operator &() const { return &self; }
6081         const LDKMinFinalCltvExpiryDelta* operator ->() const { return &self; }
6082 };
6083 class Fallback {
6084 private:
6085         LDKFallback self;
6086 public:
6087         Fallback(const Fallback&) = delete;
6088         Fallback(Fallback&& o) : self(o.self) { memset(&o, 0, sizeof(Fallback)); }
6089         Fallback(LDKFallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFallback)); }
6090         operator LDKFallback() && { LDKFallback res = self; memset(&self, 0, sizeof(LDKFallback)); return res; }
6091         ~Fallback() { Fallback_free(self); }
6092         Fallback& operator=(Fallback&& o) { Fallback_free(self); self = o.self; memset(&o, 0, sizeof(Fallback)); return *this; }
6093         LDKFallback* operator &() { return &self; }
6094         LDKFallback* operator ->() { return &self; }
6095         const LDKFallback* operator &() const { return &self; }
6096         const LDKFallback* operator ->() const { return &self; }
6097 };
6098 class Bolt11InvoiceSignature {
6099 private:
6100         LDKBolt11InvoiceSignature self;
6101 public:
6102         Bolt11InvoiceSignature(const Bolt11InvoiceSignature&) = delete;
6103         Bolt11InvoiceSignature(Bolt11InvoiceSignature&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11InvoiceSignature)); }
6104         Bolt11InvoiceSignature(LDKBolt11InvoiceSignature&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11InvoiceSignature)); }
6105         operator LDKBolt11InvoiceSignature() && { LDKBolt11InvoiceSignature res = self; memset(&self, 0, sizeof(LDKBolt11InvoiceSignature)); return res; }
6106         ~Bolt11InvoiceSignature() { Bolt11InvoiceSignature_free(self); }
6107         Bolt11InvoiceSignature& operator=(Bolt11InvoiceSignature&& o) { Bolt11InvoiceSignature_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11InvoiceSignature)); return *this; }
6108         LDKBolt11InvoiceSignature* operator &() { return &self; }
6109         LDKBolt11InvoiceSignature* operator ->() { return &self; }
6110         const LDKBolt11InvoiceSignature* operator &() const { return &self; }
6111         const LDKBolt11InvoiceSignature* operator ->() const { return &self; }
6112 };
6113 class PrivateRoute {
6114 private:
6115         LDKPrivateRoute self;
6116 public:
6117         PrivateRoute(const PrivateRoute&) = delete;
6118         PrivateRoute(PrivateRoute&& o) : self(o.self) { memset(&o, 0, sizeof(PrivateRoute)); }
6119         PrivateRoute(LDKPrivateRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrivateRoute)); }
6120         operator LDKPrivateRoute() && { LDKPrivateRoute res = self; memset(&self, 0, sizeof(LDKPrivateRoute)); return res; }
6121         ~PrivateRoute() { PrivateRoute_free(self); }
6122         PrivateRoute& operator=(PrivateRoute&& o) { PrivateRoute_free(self); self = o.self; memset(&o, 0, sizeof(PrivateRoute)); return *this; }
6123         LDKPrivateRoute* operator &() { return &self; }
6124         LDKPrivateRoute* operator ->() { return &self; }
6125         const LDKPrivateRoute* operator &() const { return &self; }
6126         const LDKPrivateRoute* operator ->() const { return &self; }
6127 };
6128 class CreationError {
6129 private:
6130         LDKCreationError self;
6131 public:
6132         CreationError(const CreationError&) = delete;
6133         CreationError(CreationError&& o) : self(o.self) { memset(&o, 0, sizeof(CreationError)); }
6134         CreationError(LDKCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCreationError)); }
6135         operator LDKCreationError() && { LDKCreationError res = self; memset(&self, 0, sizeof(LDKCreationError)); return res; }
6136         CreationError& operator=(CreationError&& o) { self = o.self; memset(&o, 0, sizeof(CreationError)); return *this; }
6137         LDKCreationError* operator &() { return &self; }
6138         LDKCreationError* operator ->() { return &self; }
6139         const LDKCreationError* operator &() const { return &self; }
6140         const LDKCreationError* operator ->() const { return &self; }
6141 };
6142 class Bolt11SemanticError {
6143 private:
6144         LDKBolt11SemanticError self;
6145 public:
6146         Bolt11SemanticError(const Bolt11SemanticError&) = delete;
6147         Bolt11SemanticError(Bolt11SemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11SemanticError)); }
6148         Bolt11SemanticError(LDKBolt11SemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11SemanticError)); }
6149         operator LDKBolt11SemanticError() && { LDKBolt11SemanticError res = self; memset(&self, 0, sizeof(LDKBolt11SemanticError)); return res; }
6150         Bolt11SemanticError& operator=(Bolt11SemanticError&& o) { self = o.self; memset(&o, 0, sizeof(Bolt11SemanticError)); return *this; }
6151         LDKBolt11SemanticError* operator &() { return &self; }
6152         LDKBolt11SemanticError* operator ->() { return &self; }
6153         const LDKBolt11SemanticError* operator &() const { return &self; }
6154         const LDKBolt11SemanticError* operator ->() const { return &self; }
6155 };
6156 class SignOrCreationError {
6157 private:
6158         LDKSignOrCreationError self;
6159 public:
6160         SignOrCreationError(const SignOrCreationError&) = delete;
6161         SignOrCreationError(SignOrCreationError&& o) : self(o.self) { memset(&o, 0, sizeof(SignOrCreationError)); }
6162         SignOrCreationError(LDKSignOrCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignOrCreationError)); }
6163         operator LDKSignOrCreationError() && { LDKSignOrCreationError res = self; memset(&self, 0, sizeof(LDKSignOrCreationError)); return res; }
6164         ~SignOrCreationError() { SignOrCreationError_free(self); }
6165         SignOrCreationError& operator=(SignOrCreationError&& o) { SignOrCreationError_free(self); self = o.self; memset(&o, 0, sizeof(SignOrCreationError)); return *this; }
6166         LDKSignOrCreationError* operator &() { return &self; }
6167         LDKSignOrCreationError* operator ->() { return &self; }
6168         const LDKSignOrCreationError* operator &() const { return &self; }
6169         const LDKSignOrCreationError* operator ->() const { return &self; }
6170 };
6171 class OutPoint {
6172 private:
6173         LDKOutPoint self;
6174 public:
6175         OutPoint(const OutPoint&) = delete;
6176         OutPoint(OutPoint&& o) : self(o.self) { memset(&o, 0, sizeof(OutPoint)); }
6177         OutPoint(LDKOutPoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutPoint)); }
6178         operator LDKOutPoint() && { LDKOutPoint res = self; memset(&self, 0, sizeof(LDKOutPoint)); return res; }
6179         ~OutPoint() { OutPoint_free(self); }
6180         OutPoint& operator=(OutPoint&& o) { OutPoint_free(self); self = o.self; memset(&o, 0, sizeof(OutPoint)); return *this; }
6181         LDKOutPoint* operator &() { return &self; }
6182         LDKOutPoint* operator ->() { return &self; }
6183         const LDKOutPoint* operator &() const { return &self; }
6184         const LDKOutPoint* operator ->() const { return &self; }
6185 };
6186 class BigSize {
6187 private:
6188         LDKBigSize self;
6189 public:
6190         BigSize(const BigSize&) = delete;
6191         BigSize(BigSize&& o) : self(o.self) { memset(&o, 0, sizeof(BigSize)); }
6192         BigSize(LDKBigSize&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBigSize)); }
6193         operator LDKBigSize() && { LDKBigSize res = self; memset(&self, 0, sizeof(LDKBigSize)); return res; }
6194         ~BigSize() { BigSize_free(self); }
6195         BigSize& operator=(BigSize&& o) { BigSize_free(self); self = o.self; memset(&o, 0, sizeof(BigSize)); return *this; }
6196         LDKBigSize* operator &() { return &self; }
6197         LDKBigSize* operator ->() { return &self; }
6198         const LDKBigSize* operator &() const { return &self; }
6199         const LDKBigSize* operator ->() const { return &self; }
6200 };
6201 class Hostname {
6202 private:
6203         LDKHostname self;
6204 public:
6205         Hostname(const Hostname&) = delete;
6206         Hostname(Hostname&& o) : self(o.self) { memset(&o, 0, sizeof(Hostname)); }
6207         Hostname(LDKHostname&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHostname)); }
6208         operator LDKHostname() && { LDKHostname res = self; memset(&self, 0, sizeof(LDKHostname)); return res; }
6209         ~Hostname() { Hostname_free(self); }
6210         Hostname& operator=(Hostname&& o) { Hostname_free(self); self = o.self; memset(&o, 0, sizeof(Hostname)); return *this; }
6211         LDKHostname* operator &() { return &self; }
6212         LDKHostname* operator ->() { return &self; }
6213         const LDKHostname* operator &() const { return &self; }
6214         const LDKHostname* operator ->() const { return &self; }
6215 };
6216 class TransactionU16LenLimited {
6217 private:
6218         LDKTransactionU16LenLimited self;
6219 public:
6220         TransactionU16LenLimited(const TransactionU16LenLimited&) = delete;
6221         TransactionU16LenLimited(TransactionU16LenLimited&& o) : self(o.self) { memset(&o, 0, sizeof(TransactionU16LenLimited)); }
6222         TransactionU16LenLimited(LDKTransactionU16LenLimited&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTransactionU16LenLimited)); }
6223         operator LDKTransactionU16LenLimited() && { LDKTransactionU16LenLimited res = self; memset(&self, 0, sizeof(LDKTransactionU16LenLimited)); return res; }
6224         ~TransactionU16LenLimited() { TransactionU16LenLimited_free(self); }
6225         TransactionU16LenLimited& operator=(TransactionU16LenLimited&& o) { TransactionU16LenLimited_free(self); self = o.self; memset(&o, 0, sizeof(TransactionU16LenLimited)); return *this; }
6226         LDKTransactionU16LenLimited* operator &() { return &self; }
6227         LDKTransactionU16LenLimited* operator ->() { return &self; }
6228         const LDKTransactionU16LenLimited* operator &() const { return &self; }
6229         const LDKTransactionU16LenLimited* operator ->() const { return &self; }
6230 };
6231 class UntrustedString {
6232 private:
6233         LDKUntrustedString self;
6234 public:
6235         UntrustedString(const UntrustedString&) = delete;
6236         UntrustedString(UntrustedString&& o) : self(o.self) { memset(&o, 0, sizeof(UntrustedString)); }
6237         UntrustedString(LDKUntrustedString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUntrustedString)); }
6238         operator LDKUntrustedString() && { LDKUntrustedString res = self; memset(&self, 0, sizeof(LDKUntrustedString)); return res; }
6239         ~UntrustedString() { UntrustedString_free(self); }
6240         UntrustedString& operator=(UntrustedString&& o) { UntrustedString_free(self); self = o.self; memset(&o, 0, sizeof(UntrustedString)); return *this; }
6241         LDKUntrustedString* operator &() { return &self; }
6242         LDKUntrustedString* operator ->() { return &self; }
6243         const LDKUntrustedString* operator &() const { return &self; }
6244         const LDKUntrustedString* operator ->() const { return &self; }
6245 };
6246 class PrintableString {
6247 private:
6248         LDKPrintableString self;
6249 public:
6250         PrintableString(const PrintableString&) = delete;
6251         PrintableString(PrintableString&& o) : self(o.self) { memset(&o, 0, sizeof(PrintableString)); }
6252         PrintableString(LDKPrintableString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrintableString)); }
6253         operator LDKPrintableString() && { LDKPrintableString res = self; memset(&self, 0, sizeof(LDKPrintableString)); return res; }
6254         ~PrintableString() { PrintableString_free(self); }
6255         PrintableString& operator=(PrintableString&& o) { PrintableString_free(self); self = o.self; memset(&o, 0, sizeof(PrintableString)); return *this; }
6256         LDKPrintableString* operator &() { return &self; }
6257         LDKPrintableString* operator ->() { return &self; }
6258         const LDKPrintableString* operator &() const { return &self; }
6259         const LDKPrintableString* operator ->() const { return &self; }
6260 };
6261 class ChannelId {
6262 private:
6263         LDKChannelId self;
6264 public:
6265         ChannelId(const ChannelId&) = delete;
6266         ChannelId(ChannelId&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelId)); }
6267         ChannelId(LDKChannelId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelId)); }
6268         operator LDKChannelId() && { LDKChannelId res = self; memset(&self, 0, sizeof(LDKChannelId)); return res; }
6269         ~ChannelId() { ChannelId_free(self); }
6270         ChannelId& operator=(ChannelId&& o) { ChannelId_free(self); self = o.self; memset(&o, 0, sizeof(ChannelId)); return *this; }
6271         LDKChannelId* operator &() { return &self; }
6272         LDKChannelId* operator ->() { return &self; }
6273         const LDKChannelId* operator &() const { return &self; }
6274         const LDKChannelId* operator ->() const { return &self; }
6275 };
6276 class CustomMessageReader {
6277 private:
6278         LDKCustomMessageReader self;
6279 public:
6280         CustomMessageReader(const CustomMessageReader&) = delete;
6281         CustomMessageReader(CustomMessageReader&& o) : self(o.self) { memset(&o, 0, sizeof(CustomMessageReader)); }
6282         CustomMessageReader(LDKCustomMessageReader&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomMessageReader)); }
6283         operator LDKCustomMessageReader() && { LDKCustomMessageReader res = self; memset(&self, 0, sizeof(LDKCustomMessageReader)); return res; }
6284         ~CustomMessageReader() { CustomMessageReader_free(self); }
6285         CustomMessageReader& operator=(CustomMessageReader&& o) { CustomMessageReader_free(self); self = o.self; memset(&o, 0, sizeof(CustomMessageReader)); return *this; }
6286         LDKCustomMessageReader* operator &() { return &self; }
6287         LDKCustomMessageReader* operator ->() { return &self; }
6288         const LDKCustomMessageReader* operator &() const { return &self; }
6289         const LDKCustomMessageReader* operator ->() const { return &self; }
6290         /**
6291          *  Decodes a custom message to `CustomMessageType`. If the given message type is known to the
6292          *  implementation and the message could be decoded, must return `Ok(Some(message))`. If the
6293          *  message type is unknown to the implementation, must return `Ok(None)`. If a decoding error
6294          *  occur, must return `Err(DecodeError::X)` where `X` details the encountered error.
6295          */
6296         inline LDK::CResult_COption_TypeZDecodeErrorZ read(uint16_t message_type, struct LDKu8slice buffer);
6297 };
6298 class Type {
6299 private:
6300         LDKType self;
6301 public:
6302         Type(const Type&) = delete;
6303         Type(Type&& o) : self(o.self) { memset(&o, 0, sizeof(Type)); }
6304         Type(LDKType&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKType)); }
6305         operator LDKType() && { LDKType res = self; memset(&self, 0, sizeof(LDKType)); return res; }
6306         ~Type() { Type_free(self); }
6307         Type& operator=(Type&& o) { Type_free(self); self = o.self; memset(&o, 0, sizeof(Type)); return *this; }
6308         LDKType* operator &() { return &self; }
6309         LDKType* operator ->() { return &self; }
6310         const LDKType* operator &() const { return &self; }
6311         const LDKType* operator ->() const { return &self; }
6312         /**
6313          *  Returns the type identifying the message payload.
6314          */
6315         inline uint16_t type_id();
6316         /**
6317          * Return a human-readable "debug" string describing this object
6318          */
6319         inline LDK::Str debug_str();
6320 };
6321 class ForwardNode {
6322 private:
6323         LDKForwardNode self;
6324 public:
6325         ForwardNode(const ForwardNode&) = delete;
6326         ForwardNode(ForwardNode&& o) : self(o.self) { memset(&o, 0, sizeof(ForwardNode)); }
6327         ForwardNode(LDKForwardNode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKForwardNode)); }
6328         operator LDKForwardNode() && { LDKForwardNode res = self; memset(&self, 0, sizeof(LDKForwardNode)); return res; }
6329         ~ForwardNode() { ForwardNode_free(self); }
6330         ForwardNode& operator=(ForwardNode&& o) { ForwardNode_free(self); self = o.self; memset(&o, 0, sizeof(ForwardNode)); return *this; }
6331         LDKForwardNode* operator &() { return &self; }
6332         LDKForwardNode* operator ->() { return &self; }
6333         const LDKForwardNode* operator &() const { return &self; }
6334         const LDKForwardNode* operator ->() const { return &self; }
6335 };
6336 class ForwardTlvs {
6337 private:
6338         LDKForwardTlvs self;
6339 public:
6340         ForwardTlvs(const ForwardTlvs&) = delete;
6341         ForwardTlvs(ForwardTlvs&& o) : self(o.self) { memset(&o, 0, sizeof(ForwardTlvs)); }
6342         ForwardTlvs(LDKForwardTlvs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKForwardTlvs)); }
6343         operator LDKForwardTlvs() && { LDKForwardTlvs res = self; memset(&self, 0, sizeof(LDKForwardTlvs)); return res; }
6344         ~ForwardTlvs() { ForwardTlvs_free(self); }
6345         ForwardTlvs& operator=(ForwardTlvs&& o) { ForwardTlvs_free(self); self = o.self; memset(&o, 0, sizeof(ForwardTlvs)); return *this; }
6346         LDKForwardTlvs* operator &() { return &self; }
6347         LDKForwardTlvs* operator ->() { return &self; }
6348         const LDKForwardTlvs* operator &() const { return &self; }
6349         const LDKForwardTlvs* operator ->() const { return &self; }
6350 };
6351 class ReceiveTlvs {
6352 private:
6353         LDKReceiveTlvs self;
6354 public:
6355         ReceiveTlvs(const ReceiveTlvs&) = delete;
6356         ReceiveTlvs(ReceiveTlvs&& o) : self(o.self) { memset(&o, 0, sizeof(ReceiveTlvs)); }
6357         ReceiveTlvs(LDKReceiveTlvs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReceiveTlvs)); }
6358         operator LDKReceiveTlvs() && { LDKReceiveTlvs res = self; memset(&self, 0, sizeof(LDKReceiveTlvs)); return res; }
6359         ~ReceiveTlvs() { ReceiveTlvs_free(self); }
6360         ReceiveTlvs& operator=(ReceiveTlvs&& o) { ReceiveTlvs_free(self); self = o.self; memset(&o, 0, sizeof(ReceiveTlvs)); return *this; }
6361         LDKReceiveTlvs* operator &() { return &self; }
6362         LDKReceiveTlvs* operator ->() { return &self; }
6363         const LDKReceiveTlvs* operator &() const { return &self; }
6364         const LDKReceiveTlvs* operator ->() const { return &self; }
6365 };
6366 class PaymentRelay {
6367 private:
6368         LDKPaymentRelay self;
6369 public:
6370         PaymentRelay(const PaymentRelay&) = delete;
6371         PaymentRelay(PaymentRelay&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentRelay)); }
6372         PaymentRelay(LDKPaymentRelay&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentRelay)); }
6373         operator LDKPaymentRelay() && { LDKPaymentRelay res = self; memset(&self, 0, sizeof(LDKPaymentRelay)); return res; }
6374         ~PaymentRelay() { PaymentRelay_free(self); }
6375         PaymentRelay& operator=(PaymentRelay&& o) { PaymentRelay_free(self); self = o.self; memset(&o, 0, sizeof(PaymentRelay)); return *this; }
6376         LDKPaymentRelay* operator &() { return &self; }
6377         LDKPaymentRelay* operator ->() { return &self; }
6378         const LDKPaymentRelay* operator &() const { return &self; }
6379         const LDKPaymentRelay* operator ->() const { return &self; }
6380 };
6381 class PaymentConstraints {
6382 private:
6383         LDKPaymentConstraints self;
6384 public:
6385         PaymentConstraints(const PaymentConstraints&) = delete;
6386         PaymentConstraints(PaymentConstraints&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentConstraints)); }
6387         PaymentConstraints(LDKPaymentConstraints&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentConstraints)); }
6388         operator LDKPaymentConstraints() && { LDKPaymentConstraints res = self; memset(&self, 0, sizeof(LDKPaymentConstraints)); return res; }
6389         ~PaymentConstraints() { PaymentConstraints_free(self); }
6390         PaymentConstraints& operator=(PaymentConstraints&& o) { PaymentConstraints_free(self); self = o.self; memset(&o, 0, sizeof(PaymentConstraints)); return *this; }
6391         LDKPaymentConstraints* operator &() { return &self; }
6392         LDKPaymentConstraints* operator ->() { return &self; }
6393         const LDKPaymentConstraints* operator &() const { return &self; }
6394         const LDKPaymentConstraints* operator ->() const { return &self; }
6395 };
6396 class PaymentContext {
6397 private:
6398         LDKPaymentContext self;
6399 public:
6400         PaymentContext(const PaymentContext&) = delete;
6401         PaymentContext(PaymentContext&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentContext)); }
6402         PaymentContext(LDKPaymentContext&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentContext)); }
6403         operator LDKPaymentContext() && { LDKPaymentContext res = self; memset(&self, 0, sizeof(LDKPaymentContext)); return res; }
6404         ~PaymentContext() { PaymentContext_free(self); }
6405         PaymentContext& operator=(PaymentContext&& o) { PaymentContext_free(self); self = o.self; memset(&o, 0, sizeof(PaymentContext)); return *this; }
6406         LDKPaymentContext* operator &() { return &self; }
6407         LDKPaymentContext* operator ->() { return &self; }
6408         const LDKPaymentContext* operator &() const { return &self; }
6409         const LDKPaymentContext* operator ->() const { return &self; }
6410 };
6411 class UnknownPaymentContext {
6412 private:
6413         LDKUnknownPaymentContext self;
6414 public:
6415         UnknownPaymentContext(const UnknownPaymentContext&) = delete;
6416         UnknownPaymentContext(UnknownPaymentContext&& o) : self(o.self) { memset(&o, 0, sizeof(UnknownPaymentContext)); }
6417         UnknownPaymentContext(LDKUnknownPaymentContext&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnknownPaymentContext)); }
6418         operator LDKUnknownPaymentContext() && { LDKUnknownPaymentContext res = self; memset(&self, 0, sizeof(LDKUnknownPaymentContext)); return res; }
6419         ~UnknownPaymentContext() { UnknownPaymentContext_free(self); }
6420         UnknownPaymentContext& operator=(UnknownPaymentContext&& o) { UnknownPaymentContext_free(self); self = o.self; memset(&o, 0, sizeof(UnknownPaymentContext)); return *this; }
6421         LDKUnknownPaymentContext* operator &() { return &self; }
6422         LDKUnknownPaymentContext* operator ->() { return &self; }
6423         const LDKUnknownPaymentContext* operator &() const { return &self; }
6424         const LDKUnknownPaymentContext* operator ->() const { return &self; }
6425 };
6426 class Bolt12OfferContext {
6427 private:
6428         LDKBolt12OfferContext self;
6429 public:
6430         Bolt12OfferContext(const Bolt12OfferContext&) = delete;
6431         Bolt12OfferContext(Bolt12OfferContext&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12OfferContext)); }
6432         Bolt12OfferContext(LDKBolt12OfferContext&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12OfferContext)); }
6433         operator LDKBolt12OfferContext() && { LDKBolt12OfferContext res = self; memset(&self, 0, sizeof(LDKBolt12OfferContext)); return res; }
6434         ~Bolt12OfferContext() { Bolt12OfferContext_free(self); }
6435         Bolt12OfferContext& operator=(Bolt12OfferContext&& o) { Bolt12OfferContext_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12OfferContext)); return *this; }
6436         LDKBolt12OfferContext* operator &() { return &self; }
6437         LDKBolt12OfferContext* operator ->() { return &self; }
6438         const LDKBolt12OfferContext* operator &() const { return &self; }
6439         const LDKBolt12OfferContext* operator ->() const { return &self; }
6440 };
6441 class Bolt12RefundContext {
6442 private:
6443         LDKBolt12RefundContext self;
6444 public:
6445         Bolt12RefundContext(const Bolt12RefundContext&) = delete;
6446         Bolt12RefundContext(Bolt12RefundContext&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12RefundContext)); }
6447         Bolt12RefundContext(LDKBolt12RefundContext&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12RefundContext)); }
6448         operator LDKBolt12RefundContext() && { LDKBolt12RefundContext res = self; memset(&self, 0, sizeof(LDKBolt12RefundContext)); return res; }
6449         ~Bolt12RefundContext() { Bolt12RefundContext_free(self); }
6450         Bolt12RefundContext& operator=(Bolt12RefundContext&& o) { Bolt12RefundContext_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12RefundContext)); return *this; }
6451         LDKBolt12RefundContext* operator &() { return &self; }
6452         LDKBolt12RefundContext* operator ->() { return &self; }
6453         const LDKBolt12RefundContext* operator &() const { return &self; }
6454         const LDKBolt12RefundContext* operator ->() const { return &self; }
6455 };
6456 class UtxoLookupError {
6457 private:
6458         LDKUtxoLookupError self;
6459 public:
6460         UtxoLookupError(const UtxoLookupError&) = delete;
6461         UtxoLookupError(UtxoLookupError&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoLookupError)); }
6462         UtxoLookupError(LDKUtxoLookupError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoLookupError)); }
6463         operator LDKUtxoLookupError() && { LDKUtxoLookupError res = self; memset(&self, 0, sizeof(LDKUtxoLookupError)); return res; }
6464         UtxoLookupError& operator=(UtxoLookupError&& o) { self = o.self; memset(&o, 0, sizeof(UtxoLookupError)); return *this; }
6465         LDKUtxoLookupError* operator &() { return &self; }
6466         LDKUtxoLookupError* operator ->() { return &self; }
6467         const LDKUtxoLookupError* operator &() const { return &self; }
6468         const LDKUtxoLookupError* operator ->() const { return &self; }
6469 };
6470 class UtxoResult {
6471 private:
6472         LDKUtxoResult self;
6473 public:
6474         UtxoResult(const UtxoResult&) = delete;
6475         UtxoResult(UtxoResult&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoResult)); }
6476         UtxoResult(LDKUtxoResult&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoResult)); }
6477         operator LDKUtxoResult() && { LDKUtxoResult res = self; memset(&self, 0, sizeof(LDKUtxoResult)); return res; }
6478         ~UtxoResult() { UtxoResult_free(self); }
6479         UtxoResult& operator=(UtxoResult&& o) { UtxoResult_free(self); self = o.self; memset(&o, 0, sizeof(UtxoResult)); return *this; }
6480         LDKUtxoResult* operator &() { return &self; }
6481         LDKUtxoResult* operator ->() { return &self; }
6482         const LDKUtxoResult* operator &() const { return &self; }
6483         const LDKUtxoResult* operator ->() const { return &self; }
6484 };
6485 class UtxoLookup {
6486 private:
6487         LDKUtxoLookup self;
6488 public:
6489         UtxoLookup(const UtxoLookup&) = delete;
6490         UtxoLookup(UtxoLookup&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoLookup)); }
6491         UtxoLookup(LDKUtxoLookup&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoLookup)); }
6492         operator LDKUtxoLookup() && { LDKUtxoLookup res = self; memset(&self, 0, sizeof(LDKUtxoLookup)); return res; }
6493         ~UtxoLookup() { UtxoLookup_free(self); }
6494         UtxoLookup& operator=(UtxoLookup&& o) { UtxoLookup_free(self); self = o.self; memset(&o, 0, sizeof(UtxoLookup)); return *this; }
6495         LDKUtxoLookup* operator &() { return &self; }
6496         LDKUtxoLookup* operator ->() { return &self; }
6497         const LDKUtxoLookup* operator &() const { return &self; }
6498         const LDKUtxoLookup* operator ->() const { return &self; }
6499         /**
6500          *  Returns the transaction output of a funding transaction encoded by [`short_channel_id`].
6501          *  Returns an error if `chain_hash` is for a different chain or if such a transaction output is
6502          *  unknown.
6503          *
6504          *  [`short_channel_id`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#definition-of-short_channel_id
6505          */
6506         inline LDK::UtxoResult get_utxo(const uint8_t (*chain_hash)[32], uint64_t short_channel_id);
6507 };
6508 class UtxoFuture {
6509 private:
6510         LDKUtxoFuture self;
6511 public:
6512         UtxoFuture(const UtxoFuture&) = delete;
6513         UtxoFuture(UtxoFuture&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoFuture)); }
6514         UtxoFuture(LDKUtxoFuture&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoFuture)); }
6515         operator LDKUtxoFuture() && { LDKUtxoFuture res = self; memset(&self, 0, sizeof(LDKUtxoFuture)); return res; }
6516         ~UtxoFuture() { UtxoFuture_free(self); }
6517         UtxoFuture& operator=(UtxoFuture&& o) { UtxoFuture_free(self); self = o.self; memset(&o, 0, sizeof(UtxoFuture)); return *this; }
6518         LDKUtxoFuture* operator &() { return &self; }
6519         LDKUtxoFuture* operator ->() { return &self; }
6520         const LDKUtxoFuture* operator &() const { return &self; }
6521         const LDKUtxoFuture* operator ->() const { return &self; }
6522 };
6523 class OnionMessenger {
6524 private:
6525         LDKOnionMessenger self;
6526 public:
6527         OnionMessenger(const OnionMessenger&) = delete;
6528         OnionMessenger(OnionMessenger&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessenger)); }
6529         OnionMessenger(LDKOnionMessenger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessenger)); }
6530         operator LDKOnionMessenger() && { LDKOnionMessenger res = self; memset(&self, 0, sizeof(LDKOnionMessenger)); return res; }
6531         ~OnionMessenger() { OnionMessenger_free(self); }
6532         OnionMessenger& operator=(OnionMessenger&& o) { OnionMessenger_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessenger)); return *this; }
6533         LDKOnionMessenger* operator &() { return &self; }
6534         LDKOnionMessenger* operator ->() { return &self; }
6535         const LDKOnionMessenger* operator &() const { return &self; }
6536         const LDKOnionMessenger* operator ->() const { return &self; }
6537 };
6538 class MessageRouter {
6539 private:
6540         LDKMessageRouter self;
6541 public:
6542         MessageRouter(const MessageRouter&) = delete;
6543         MessageRouter(MessageRouter&& o) : self(o.self) { memset(&o, 0, sizeof(MessageRouter)); }
6544         MessageRouter(LDKMessageRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageRouter)); }
6545         operator LDKMessageRouter() && { LDKMessageRouter res = self; memset(&self, 0, sizeof(LDKMessageRouter)); return res; }
6546         ~MessageRouter() { MessageRouter_free(self); }
6547         MessageRouter& operator=(MessageRouter&& o) { MessageRouter_free(self); self = o.self; memset(&o, 0, sizeof(MessageRouter)); return *this; }
6548         LDKMessageRouter* operator &() { return &self; }
6549         LDKMessageRouter* operator ->() { return &self; }
6550         const LDKMessageRouter* operator &() const { return &self; }
6551         const LDKMessageRouter* operator ->() const { return &self; }
6552         /**
6553          *  Returns a route for sending an [`OnionMessage`] to the given [`Destination`].
6554          */
6555         inline LDK::CResult_OnionMessagePathNoneZ find_path(struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination);
6556         /**
6557          *  Creates [`BlindedPath`]s to the `recipient` node. The nodes in `peers` are assumed to be
6558          *  direct peers with the `recipient`.
6559          */
6560         inline LDK::CResult_CVec_BlindedPathZNoneZ create_blinded_paths(struct LDKPublicKey recipient, struct LDKCVec_PublicKeyZ peers);
6561 };
6562 class DefaultMessageRouter {
6563 private:
6564         LDKDefaultMessageRouter self;
6565 public:
6566         DefaultMessageRouter(const DefaultMessageRouter&) = delete;
6567         DefaultMessageRouter(DefaultMessageRouter&& o) : self(o.self) { memset(&o, 0, sizeof(DefaultMessageRouter)); }
6568         DefaultMessageRouter(LDKDefaultMessageRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDefaultMessageRouter)); }
6569         operator LDKDefaultMessageRouter() && { LDKDefaultMessageRouter res = self; memset(&self, 0, sizeof(LDKDefaultMessageRouter)); return res; }
6570         ~DefaultMessageRouter() { DefaultMessageRouter_free(self); }
6571         DefaultMessageRouter& operator=(DefaultMessageRouter&& o) { DefaultMessageRouter_free(self); self = o.self; memset(&o, 0, sizeof(DefaultMessageRouter)); return *this; }
6572         LDKDefaultMessageRouter* operator &() { return &self; }
6573         LDKDefaultMessageRouter* operator ->() { return &self; }
6574         const LDKDefaultMessageRouter* operator &() const { return &self; }
6575         const LDKDefaultMessageRouter* operator ->() const { return &self; }
6576 };
6577 class OnionMessagePath {
6578 private:
6579         LDKOnionMessagePath self;
6580 public:
6581         OnionMessagePath(const OnionMessagePath&) = delete;
6582         OnionMessagePath(OnionMessagePath&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessagePath)); }
6583         OnionMessagePath(LDKOnionMessagePath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessagePath)); }
6584         operator LDKOnionMessagePath() && { LDKOnionMessagePath res = self; memset(&self, 0, sizeof(LDKOnionMessagePath)); return res; }
6585         ~OnionMessagePath() { OnionMessagePath_free(self); }
6586         OnionMessagePath& operator=(OnionMessagePath&& o) { OnionMessagePath_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessagePath)); return *this; }
6587         LDKOnionMessagePath* operator &() { return &self; }
6588         LDKOnionMessagePath* operator ->() { return &self; }
6589         const LDKOnionMessagePath* operator &() const { return &self; }
6590         const LDKOnionMessagePath* operator ->() const { return &self; }
6591 };
6592 class Destination {
6593 private:
6594         LDKDestination self;
6595 public:
6596         Destination(const Destination&) = delete;
6597         Destination(Destination&& o) : self(o.self) { memset(&o, 0, sizeof(Destination)); }
6598         Destination(LDKDestination&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDestination)); }
6599         operator LDKDestination() && { LDKDestination res = self; memset(&self, 0, sizeof(LDKDestination)); return res; }
6600         ~Destination() { Destination_free(self); }
6601         Destination& operator=(Destination&& o) { Destination_free(self); self = o.self; memset(&o, 0, sizeof(Destination)); return *this; }
6602         LDKDestination* operator &() { return &self; }
6603         LDKDestination* operator ->() { return &self; }
6604         const LDKDestination* operator &() const { return &self; }
6605         const LDKDestination* operator ->() const { return &self; }
6606 };
6607 class SendSuccess {
6608 private:
6609         LDKSendSuccess self;
6610 public:
6611         SendSuccess(const SendSuccess&) = delete;
6612         SendSuccess(SendSuccess&& o) : self(o.self) { memset(&o, 0, sizeof(SendSuccess)); }
6613         SendSuccess(LDKSendSuccess&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSendSuccess)); }
6614         operator LDKSendSuccess() && { LDKSendSuccess res = self; memset(&self, 0, sizeof(LDKSendSuccess)); return res; }
6615         ~SendSuccess() { SendSuccess_free(self); }
6616         SendSuccess& operator=(SendSuccess&& o) { SendSuccess_free(self); self = o.self; memset(&o, 0, sizeof(SendSuccess)); return *this; }
6617         LDKSendSuccess* operator &() { return &self; }
6618         LDKSendSuccess* operator ->() { return &self; }
6619         const LDKSendSuccess* operator &() const { return &self; }
6620         const LDKSendSuccess* operator ->() const { return &self; }
6621 };
6622 class SendError {
6623 private:
6624         LDKSendError self;
6625 public:
6626         SendError(const SendError&) = delete;
6627         SendError(SendError&& o) : self(o.self) { memset(&o, 0, sizeof(SendError)); }
6628         SendError(LDKSendError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSendError)); }
6629         operator LDKSendError() && { LDKSendError res = self; memset(&self, 0, sizeof(LDKSendError)); return res; }
6630         ~SendError() { SendError_free(self); }
6631         SendError& operator=(SendError&& o) { SendError_free(self); self = o.self; memset(&o, 0, sizeof(SendError)); return *this; }
6632         LDKSendError* operator &() { return &self; }
6633         LDKSendError* operator ->() { return &self; }
6634         const LDKSendError* operator &() const { return &self; }
6635         const LDKSendError* operator ->() const { return &self; }
6636 };
6637 class CustomOnionMessageHandler {
6638 private:
6639         LDKCustomOnionMessageHandler self;
6640 public:
6641         CustomOnionMessageHandler(const CustomOnionMessageHandler&) = delete;
6642         CustomOnionMessageHandler(CustomOnionMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(CustomOnionMessageHandler)); }
6643         CustomOnionMessageHandler(LDKCustomOnionMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomOnionMessageHandler)); }
6644         operator LDKCustomOnionMessageHandler() && { LDKCustomOnionMessageHandler res = self; memset(&self, 0, sizeof(LDKCustomOnionMessageHandler)); return res; }
6645         ~CustomOnionMessageHandler() { CustomOnionMessageHandler_free(self); }
6646         CustomOnionMessageHandler& operator=(CustomOnionMessageHandler&& o) { CustomOnionMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(CustomOnionMessageHandler)); return *this; }
6647         LDKCustomOnionMessageHandler* operator &() { return &self; }
6648         LDKCustomOnionMessageHandler* operator ->() { return &self; }
6649         const LDKCustomOnionMessageHandler* operator &() const { return &self; }
6650         const LDKCustomOnionMessageHandler* operator ->() const { return &self; }
6651         /**
6652          *  Called with the custom message that was received, returning a response to send, if any.
6653          *
6654          *  The returned [`Self::CustomMessage`], if any, is enqueued to be sent by [`OnionMessenger`].
6655          */
6656         inline LDK::COption_OnionMessageContentsZ handle_custom_message(struct LDKOnionMessageContents msg);
6657         /**
6658          *  Read a custom message of type `message_type` from `buffer`, returning `Ok(None)` if the
6659          *  message type is unknown.
6660          */
6661         inline LDK::CResult_COption_OnionMessageContentsZDecodeErrorZ read_custom_message(uint64_t message_type, struct LDKu8slice buffer);
6662         /**
6663          *  Releases any [`Self::CustomMessage`]s that need to be sent.
6664          *
6665          *  Typically, this is used for messages initiating a message flow rather than in response to
6666          *  another message. The latter should use the return value of [`Self::handle_custom_message`].
6667          */
6668         inline LDK::CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ release_pending_custom_messages();
6669 };
6670 class PeeledOnion {
6671 private:
6672         LDKPeeledOnion self;
6673 public:
6674         PeeledOnion(const PeeledOnion&) = delete;
6675         PeeledOnion(PeeledOnion&& o) : self(o.self) { memset(&o, 0, sizeof(PeeledOnion)); }
6676         PeeledOnion(LDKPeeledOnion&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeeledOnion)); }
6677         operator LDKPeeledOnion() && { LDKPeeledOnion res = self; memset(&self, 0, sizeof(LDKPeeledOnion)); return res; }
6678         ~PeeledOnion() { PeeledOnion_free(self); }
6679         PeeledOnion& operator=(PeeledOnion&& o) { PeeledOnion_free(self); self = o.self; memset(&o, 0, sizeof(PeeledOnion)); return *this; }
6680         LDKPeeledOnion* operator &() { return &self; }
6681         LDKPeeledOnion* operator ->() { return &self; }
6682         const LDKPeeledOnion* operator &() const { return &self; }
6683         const LDKPeeledOnion* operator ->() const { return &self; }
6684 };
6685 class FilesystemStore {
6686 private:
6687         LDKFilesystemStore self;
6688 public:
6689         FilesystemStore(const FilesystemStore&) = delete;
6690         FilesystemStore(FilesystemStore&& o) : self(o.self) { memset(&o, 0, sizeof(FilesystemStore)); }
6691         FilesystemStore(LDKFilesystemStore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilesystemStore)); }
6692         operator LDKFilesystemStore() && { LDKFilesystemStore res = self; memset(&self, 0, sizeof(LDKFilesystemStore)); return res; }
6693         ~FilesystemStore() { FilesystemStore_free(self); }
6694         FilesystemStore& operator=(FilesystemStore&& o) { FilesystemStore_free(self); self = o.self; memset(&o, 0, sizeof(FilesystemStore)); return *this; }
6695         LDKFilesystemStore* operator &() { return &self; }
6696         LDKFilesystemStore* operator ->() { return &self; }
6697         const LDKFilesystemStore* operator &() const { return &self; }
6698         const LDKFilesystemStore* operator ->() const { return &self; }
6699 };
6700 class NextMessageHop {
6701 private:
6702         LDKNextMessageHop self;
6703 public:
6704         NextMessageHop(const NextMessageHop&) = delete;
6705         NextMessageHop(NextMessageHop&& o) : self(o.self) { memset(&o, 0, sizeof(NextMessageHop)); }
6706         NextMessageHop(LDKNextMessageHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNextMessageHop)); }
6707         operator LDKNextMessageHop() && { LDKNextMessageHop res = self; memset(&self, 0, sizeof(LDKNextMessageHop)); return res; }
6708         ~NextMessageHop() { NextMessageHop_free(self); }
6709         NextMessageHop& operator=(NextMessageHop&& o) { NextMessageHop_free(self); self = o.self; memset(&o, 0, sizeof(NextMessageHop)); return *this; }
6710         LDKNextMessageHop* operator &() { return &self; }
6711         LDKNextMessageHop* operator ->() { return &self; }
6712         const LDKNextMessageHop* operator &() const { return &self; }
6713         const LDKNextMessageHop* operator ->() const { return &self; }
6714 };
6715 class BlindedPath {
6716 private:
6717         LDKBlindedPath self;
6718 public:
6719         BlindedPath(const BlindedPath&) = delete;
6720         BlindedPath(BlindedPath&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPath)); }
6721         BlindedPath(LDKBlindedPath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPath)); }
6722         operator LDKBlindedPath() && { LDKBlindedPath res = self; memset(&self, 0, sizeof(LDKBlindedPath)); return res; }
6723         ~BlindedPath() { BlindedPath_free(self); }
6724         BlindedPath& operator=(BlindedPath&& o) { BlindedPath_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPath)); return *this; }
6725         LDKBlindedPath* operator &() { return &self; }
6726         LDKBlindedPath* operator ->() { return &self; }
6727         const LDKBlindedPath* operator &() const { return &self; }
6728         const LDKBlindedPath* operator ->() const { return &self; }
6729 };
6730 class IntroductionNode {
6731 private:
6732         LDKIntroductionNode self;
6733 public:
6734         IntroductionNode(const IntroductionNode&) = delete;
6735         IntroductionNode(IntroductionNode&& o) : self(o.self) { memset(&o, 0, sizeof(IntroductionNode)); }
6736         IntroductionNode(LDKIntroductionNode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKIntroductionNode)); }
6737         operator LDKIntroductionNode() && { LDKIntroductionNode res = self; memset(&self, 0, sizeof(LDKIntroductionNode)); return res; }
6738         ~IntroductionNode() { IntroductionNode_free(self); }
6739         IntroductionNode& operator=(IntroductionNode&& o) { IntroductionNode_free(self); self = o.self; memset(&o, 0, sizeof(IntroductionNode)); return *this; }
6740         LDKIntroductionNode* operator &() { return &self; }
6741         LDKIntroductionNode* operator ->() { return &self; }
6742         const LDKIntroductionNode* operator &() const { return &self; }
6743         const LDKIntroductionNode* operator ->() const { return &self; }
6744 };
6745 class Direction {
6746 private:
6747         LDKDirection self;
6748 public:
6749         Direction(const Direction&) = delete;
6750         Direction(Direction&& o) : self(o.self) { memset(&o, 0, sizeof(Direction)); }
6751         Direction(LDKDirection&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirection)); }
6752         operator LDKDirection() && { LDKDirection res = self; memset(&self, 0, sizeof(LDKDirection)); return res; }
6753         Direction& operator=(Direction&& o) { self = o.self; memset(&o, 0, sizeof(Direction)); return *this; }
6754         LDKDirection* operator &() { return &self; }
6755         LDKDirection* operator ->() { return &self; }
6756         const LDKDirection* operator &() const { return &self; }
6757         const LDKDirection* operator ->() const { return &self; }
6758 };
6759 class NodeIdLookUp {
6760 private:
6761         LDKNodeIdLookUp self;
6762 public:
6763         NodeIdLookUp(const NodeIdLookUp&) = delete;
6764         NodeIdLookUp(NodeIdLookUp&& o) : self(o.self) { memset(&o, 0, sizeof(NodeIdLookUp)); }
6765         NodeIdLookUp(LDKNodeIdLookUp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeIdLookUp)); }
6766         operator LDKNodeIdLookUp() && { LDKNodeIdLookUp res = self; memset(&self, 0, sizeof(LDKNodeIdLookUp)); return res; }
6767         ~NodeIdLookUp() { NodeIdLookUp_free(self); }
6768         NodeIdLookUp& operator=(NodeIdLookUp&& o) { NodeIdLookUp_free(self); self = o.self; memset(&o, 0, sizeof(NodeIdLookUp)); return *this; }
6769         LDKNodeIdLookUp* operator &() { return &self; }
6770         LDKNodeIdLookUp* operator ->() { return &self; }
6771         const LDKNodeIdLookUp* operator &() const { return &self; }
6772         const LDKNodeIdLookUp* operator ->() const { return &self; }
6773         /**
6774          *  Returns the node id of the forwarding node's channel counterparty with `short_channel_id`.
6775          *
6776          *  Here, the forwarding node is referring to the node of the [`OnionMessenger`] parameterized
6777          *  by the [`NodeIdLookUp`] and the counterparty to one of that node's peers.
6778          *
6779          *  [`OnionMessenger`]: crate::onion_message::messenger::OnionMessenger
6780          *
6781          *  Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
6782          */
6783         inline LDKPublicKey next_node_id(uint64_t short_channel_id);
6784 };
6785 class EmptyNodeIdLookUp {
6786 private:
6787         LDKEmptyNodeIdLookUp self;
6788 public:
6789         EmptyNodeIdLookUp(const EmptyNodeIdLookUp&) = delete;
6790         EmptyNodeIdLookUp(EmptyNodeIdLookUp&& o) : self(o.self) { memset(&o, 0, sizeof(EmptyNodeIdLookUp)); }
6791         EmptyNodeIdLookUp(LDKEmptyNodeIdLookUp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEmptyNodeIdLookUp)); }
6792         operator LDKEmptyNodeIdLookUp() && { LDKEmptyNodeIdLookUp res = self; memset(&self, 0, sizeof(LDKEmptyNodeIdLookUp)); return res; }
6793         ~EmptyNodeIdLookUp() { EmptyNodeIdLookUp_free(self); }
6794         EmptyNodeIdLookUp& operator=(EmptyNodeIdLookUp&& o) { EmptyNodeIdLookUp_free(self); self = o.self; memset(&o, 0, sizeof(EmptyNodeIdLookUp)); return *this; }
6795         LDKEmptyNodeIdLookUp* operator &() { return &self; }
6796         LDKEmptyNodeIdLookUp* operator ->() { return &self; }
6797         const LDKEmptyNodeIdLookUp* operator &() const { return &self; }
6798         const LDKEmptyNodeIdLookUp* operator ->() const { return &self; }
6799 };
6800 class BlindedHop {
6801 private:
6802         LDKBlindedHop self;
6803 public:
6804         BlindedHop(const BlindedHop&) = delete;
6805         BlindedHop(BlindedHop&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedHop)); }
6806         BlindedHop(LDKBlindedHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedHop)); }
6807         operator LDKBlindedHop() && { LDKBlindedHop res = self; memset(&self, 0, sizeof(LDKBlindedHop)); return res; }
6808         ~BlindedHop() { BlindedHop_free(self); }
6809         BlindedHop& operator=(BlindedHop&& o) { BlindedHop_free(self); self = o.self; memset(&o, 0, sizeof(BlindedHop)); return *this; }
6810         LDKBlindedHop* operator &() { return &self; }
6811         LDKBlindedHop* operator ->() { return &self; }
6812         const LDKBlindedHop* operator &() const { return &self; }
6813         const LDKBlindedHop* operator ->() const { return &self; }
6814 };
6815 class InvoiceError {
6816 private:
6817         LDKInvoiceError self;
6818 public:
6819         InvoiceError(const InvoiceError&) = delete;
6820         InvoiceError(InvoiceError&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceError)); }
6821         InvoiceError(LDKInvoiceError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceError)); }
6822         operator LDKInvoiceError() && { LDKInvoiceError res = self; memset(&self, 0, sizeof(LDKInvoiceError)); return res; }
6823         ~InvoiceError() { InvoiceError_free(self); }
6824         InvoiceError& operator=(InvoiceError&& o) { InvoiceError_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceError)); return *this; }
6825         LDKInvoiceError* operator &() { return &self; }
6826         LDKInvoiceError* operator ->() { return &self; }
6827         const LDKInvoiceError* operator &() const { return &self; }
6828         const LDKInvoiceError* operator ->() const { return &self; }
6829 };
6830 class ErroneousField {
6831 private:
6832         LDKErroneousField self;
6833 public:
6834         ErroneousField(const ErroneousField&) = delete;
6835         ErroneousField(ErroneousField&& o) : self(o.self) { memset(&o, 0, sizeof(ErroneousField)); }
6836         ErroneousField(LDKErroneousField&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroneousField)); }
6837         operator LDKErroneousField() && { LDKErroneousField res = self; memset(&self, 0, sizeof(LDKErroneousField)); return res; }
6838         ~ErroneousField() { ErroneousField_free(self); }
6839         ErroneousField& operator=(ErroneousField&& o) { ErroneousField_free(self); self = o.self; memset(&o, 0, sizeof(ErroneousField)); return *this; }
6840         LDKErroneousField* operator &() { return &self; }
6841         LDKErroneousField* operator ->() { return &self; }
6842         const LDKErroneousField* operator &() const { return &self; }
6843         const LDKErroneousField* operator ->() const { return &self; }
6844 };
6845 class TrackedSpendableOutput {
6846 private:
6847         LDKTrackedSpendableOutput self;
6848 public:
6849         TrackedSpendableOutput(const TrackedSpendableOutput&) = delete;
6850         TrackedSpendableOutput(TrackedSpendableOutput&& o) : self(o.self) { memset(&o, 0, sizeof(TrackedSpendableOutput)); }
6851         TrackedSpendableOutput(LDKTrackedSpendableOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrackedSpendableOutput)); }
6852         operator LDKTrackedSpendableOutput() && { LDKTrackedSpendableOutput res = self; memset(&self, 0, sizeof(LDKTrackedSpendableOutput)); return res; }
6853         ~TrackedSpendableOutput() { TrackedSpendableOutput_free(self); }
6854         TrackedSpendableOutput& operator=(TrackedSpendableOutput&& o) { TrackedSpendableOutput_free(self); self = o.self; memset(&o, 0, sizeof(TrackedSpendableOutput)); return *this; }
6855         LDKTrackedSpendableOutput* operator &() { return &self; }
6856         LDKTrackedSpendableOutput* operator ->() { return &self; }
6857         const LDKTrackedSpendableOutput* operator &() const { return &self; }
6858         const LDKTrackedSpendableOutput* operator ->() const { return &self; }
6859 };
6860 class OutputSpendStatus {
6861 private:
6862         LDKOutputSpendStatus self;
6863 public:
6864         OutputSpendStatus(const OutputSpendStatus&) = delete;
6865         OutputSpendStatus(OutputSpendStatus&& o) : self(o.self) { memset(&o, 0, sizeof(OutputSpendStatus)); }
6866         OutputSpendStatus(LDKOutputSpendStatus&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutputSpendStatus)); }
6867         operator LDKOutputSpendStatus() && { LDKOutputSpendStatus res = self; memset(&self, 0, sizeof(LDKOutputSpendStatus)); return res; }
6868         ~OutputSpendStatus() { OutputSpendStatus_free(self); }
6869         OutputSpendStatus& operator=(OutputSpendStatus&& o) { OutputSpendStatus_free(self); self = o.self; memset(&o, 0, sizeof(OutputSpendStatus)); return *this; }
6870         LDKOutputSpendStatus* operator &() { return &self; }
6871         LDKOutputSpendStatus* operator ->() { return &self; }
6872         const LDKOutputSpendStatus* operator &() const { return &self; }
6873         const LDKOutputSpendStatus* operator ->() const { return &self; }
6874 };
6875 class OutputSweeper {
6876 private:
6877         LDKOutputSweeper self;
6878 public:
6879         OutputSweeper(const OutputSweeper&) = delete;
6880         OutputSweeper(OutputSweeper&& o) : self(o.self) { memset(&o, 0, sizeof(OutputSweeper)); }
6881         OutputSweeper(LDKOutputSweeper&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutputSweeper)); }
6882         operator LDKOutputSweeper() && { LDKOutputSweeper res = self; memset(&self, 0, sizeof(LDKOutputSweeper)); return res; }
6883         ~OutputSweeper() { OutputSweeper_free(self); }
6884         OutputSweeper& operator=(OutputSweeper&& o) { OutputSweeper_free(self); self = o.self; memset(&o, 0, sizeof(OutputSweeper)); return *this; }
6885         LDKOutputSweeper* operator &() { return &self; }
6886         LDKOutputSweeper* operator ->() { return &self; }
6887         const LDKOutputSweeper* operator &() const { return &self; }
6888         const LDKOutputSweeper* operator ->() const { return &self; }
6889 };
6890 class SpendingDelay {
6891 private:
6892         LDKSpendingDelay self;
6893 public:
6894         SpendingDelay(const SpendingDelay&) = delete;
6895         SpendingDelay(SpendingDelay&& o) : self(o.self) { memset(&o, 0, sizeof(SpendingDelay)); }
6896         SpendingDelay(LDKSpendingDelay&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendingDelay)); }
6897         operator LDKSpendingDelay() && { LDKSpendingDelay res = self; memset(&self, 0, sizeof(LDKSpendingDelay)); return res; }
6898         ~SpendingDelay() { SpendingDelay_free(self); }
6899         SpendingDelay& operator=(SpendingDelay&& o) { SpendingDelay_free(self); self = o.self; memset(&o, 0, sizeof(SpendingDelay)); return *this; }
6900         LDKSpendingDelay* operator &() { return &self; }
6901         LDKSpendingDelay* operator ->() { return &self; }
6902         const LDKSpendingDelay* operator &() const { return &self; }
6903         const LDKSpendingDelay* operator ->() const { return &self; }
6904 };
6905 class DelayedPaymentBasepoint {
6906 private:
6907         LDKDelayedPaymentBasepoint self;
6908 public:
6909         DelayedPaymentBasepoint(const DelayedPaymentBasepoint&) = delete;
6910         DelayedPaymentBasepoint(DelayedPaymentBasepoint&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentBasepoint)); }
6911         DelayedPaymentBasepoint(LDKDelayedPaymentBasepoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentBasepoint)); }
6912         operator LDKDelayedPaymentBasepoint() && { LDKDelayedPaymentBasepoint res = self; memset(&self, 0, sizeof(LDKDelayedPaymentBasepoint)); return res; }
6913         ~DelayedPaymentBasepoint() { DelayedPaymentBasepoint_free(self); }
6914         DelayedPaymentBasepoint& operator=(DelayedPaymentBasepoint&& o) { DelayedPaymentBasepoint_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentBasepoint)); return *this; }
6915         LDKDelayedPaymentBasepoint* operator &() { return &self; }
6916         LDKDelayedPaymentBasepoint* operator ->() { return &self; }
6917         const LDKDelayedPaymentBasepoint* operator &() const { return &self; }
6918         const LDKDelayedPaymentBasepoint* operator ->() const { return &self; }
6919 };
6920 class DelayedPaymentKey {
6921 private:
6922         LDKDelayedPaymentKey self;
6923 public:
6924         DelayedPaymentKey(const DelayedPaymentKey&) = delete;
6925         DelayedPaymentKey(DelayedPaymentKey&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentKey)); }
6926         DelayedPaymentKey(LDKDelayedPaymentKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentKey)); }
6927         operator LDKDelayedPaymentKey() && { LDKDelayedPaymentKey res = self; memset(&self, 0, sizeof(LDKDelayedPaymentKey)); return res; }
6928         ~DelayedPaymentKey() { DelayedPaymentKey_free(self); }
6929         DelayedPaymentKey& operator=(DelayedPaymentKey&& o) { DelayedPaymentKey_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentKey)); return *this; }
6930         LDKDelayedPaymentKey* operator &() { return &self; }
6931         LDKDelayedPaymentKey* operator ->() { return &self; }
6932         const LDKDelayedPaymentKey* operator &() const { return &self; }
6933         const LDKDelayedPaymentKey* operator ->() const { return &self; }
6934 };
6935 class HtlcBasepoint {
6936 private:
6937         LDKHtlcBasepoint self;
6938 public:
6939         HtlcBasepoint(const HtlcBasepoint&) = delete;
6940         HtlcBasepoint(HtlcBasepoint&& o) : self(o.self) { memset(&o, 0, sizeof(HtlcBasepoint)); }
6941         HtlcBasepoint(LDKHtlcBasepoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHtlcBasepoint)); }
6942         operator LDKHtlcBasepoint() && { LDKHtlcBasepoint res = self; memset(&self, 0, sizeof(LDKHtlcBasepoint)); return res; }
6943         ~HtlcBasepoint() { HtlcBasepoint_free(self); }
6944         HtlcBasepoint& operator=(HtlcBasepoint&& o) { HtlcBasepoint_free(self); self = o.self; memset(&o, 0, sizeof(HtlcBasepoint)); return *this; }
6945         LDKHtlcBasepoint* operator &() { return &self; }
6946         LDKHtlcBasepoint* operator ->() { return &self; }
6947         const LDKHtlcBasepoint* operator &() const { return &self; }
6948         const LDKHtlcBasepoint* operator ->() const { return &self; }
6949 };
6950 class HtlcKey {
6951 private:
6952         LDKHtlcKey self;
6953 public:
6954         HtlcKey(const HtlcKey&) = delete;
6955         HtlcKey(HtlcKey&& o) : self(o.self) { memset(&o, 0, sizeof(HtlcKey)); }
6956         HtlcKey(LDKHtlcKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHtlcKey)); }
6957         operator LDKHtlcKey() && { LDKHtlcKey res = self; memset(&self, 0, sizeof(LDKHtlcKey)); return res; }
6958         ~HtlcKey() { HtlcKey_free(self); }
6959         HtlcKey& operator=(HtlcKey&& o) { HtlcKey_free(self); self = o.self; memset(&o, 0, sizeof(HtlcKey)); return *this; }
6960         LDKHtlcKey* operator &() { return &self; }
6961         LDKHtlcKey* operator ->() { return &self; }
6962         const LDKHtlcKey* operator &() const { return &self; }
6963         const LDKHtlcKey* operator ->() const { return &self; }
6964 };
6965 class RevocationBasepoint {
6966 private:
6967         LDKRevocationBasepoint self;
6968 public:
6969         RevocationBasepoint(const RevocationBasepoint&) = delete;
6970         RevocationBasepoint(RevocationBasepoint&& o) : self(o.self) { memset(&o, 0, sizeof(RevocationBasepoint)); }
6971         RevocationBasepoint(LDKRevocationBasepoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevocationBasepoint)); }
6972         operator LDKRevocationBasepoint() && { LDKRevocationBasepoint res = self; memset(&self, 0, sizeof(LDKRevocationBasepoint)); return res; }
6973         ~RevocationBasepoint() { RevocationBasepoint_free(self); }
6974         RevocationBasepoint& operator=(RevocationBasepoint&& o) { RevocationBasepoint_free(self); self = o.self; memset(&o, 0, sizeof(RevocationBasepoint)); return *this; }
6975         LDKRevocationBasepoint* operator &() { return &self; }
6976         LDKRevocationBasepoint* operator ->() { return &self; }
6977         const LDKRevocationBasepoint* operator &() const { return &self; }
6978         const LDKRevocationBasepoint* operator ->() const { return &self; }
6979 };
6980 class RevocationKey {
6981 private:
6982         LDKRevocationKey self;
6983 public:
6984         RevocationKey(const RevocationKey&) = delete;
6985         RevocationKey(RevocationKey&& o) : self(o.self) { memset(&o, 0, sizeof(RevocationKey)); }
6986         RevocationKey(LDKRevocationKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevocationKey)); }
6987         operator LDKRevocationKey() && { LDKRevocationKey res = self; memset(&self, 0, sizeof(LDKRevocationKey)); return res; }
6988         ~RevocationKey() { RevocationKey_free(self); }
6989         RevocationKey& operator=(RevocationKey&& o) { RevocationKey_free(self); self = o.self; memset(&o, 0, sizeof(RevocationKey)); return *this; }
6990         LDKRevocationKey* operator &() { return &self; }
6991         LDKRevocationKey* operator ->() { return &self; }
6992         const LDKRevocationKey* operator &() const { return &self; }
6993         const LDKRevocationKey* operator ->() const { return &self; }
6994 };
6995 class MonitorUpdateId {
6996 private:
6997         LDKMonitorUpdateId self;
6998 public:
6999         MonitorUpdateId(const MonitorUpdateId&) = delete;
7000         MonitorUpdateId(MonitorUpdateId&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdateId)); }
7001         MonitorUpdateId(LDKMonitorUpdateId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdateId)); }
7002         operator LDKMonitorUpdateId() && { LDKMonitorUpdateId res = self; memset(&self, 0, sizeof(LDKMonitorUpdateId)); return res; }
7003         ~MonitorUpdateId() { MonitorUpdateId_free(self); }
7004         MonitorUpdateId& operator=(MonitorUpdateId&& o) { MonitorUpdateId_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdateId)); return *this; }
7005         LDKMonitorUpdateId* operator &() { return &self; }
7006         LDKMonitorUpdateId* operator ->() { return &self; }
7007         const LDKMonitorUpdateId* operator &() const { return &self; }
7008         const LDKMonitorUpdateId* operator ->() const { return &self; }
7009 };
7010 class Persist {
7011 private:
7012         LDKPersist self;
7013 public:
7014         Persist(const Persist&) = delete;
7015         Persist(Persist&& o) : self(o.self) { memset(&o, 0, sizeof(Persist)); }
7016         Persist(LDKPersist&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersist)); }
7017         operator LDKPersist() && { LDKPersist res = self; memset(&self, 0, sizeof(LDKPersist)); return res; }
7018         ~Persist() { Persist_free(self); }
7019         Persist& operator=(Persist&& o) { Persist_free(self); self = o.self; memset(&o, 0, sizeof(Persist)); return *this; }
7020         LDKPersist* operator &() { return &self; }
7021         LDKPersist* operator ->() { return &self; }
7022         const LDKPersist* operator &() const { return &self; }
7023         const LDKPersist* operator ->() const { return &self; }
7024         /**
7025          *  Persist a new channel's data in response to a [`chain::Watch::watch_channel`] call. This is
7026          *  called by [`ChannelManager`] for new channels, or may be called directly, e.g. on startup.
7027          *
7028          *  The data can be stored any way you want, but the identifier provided by LDK is the
7029          *  channel's outpoint (and it is up to you to maintain a correct mapping between the outpoint
7030          *  and the stored channel data). Note that you **must** persist every new monitor to disk.
7031          *
7032          *  The `update_id` is used to identify this call to [`ChainMonitor::channel_monitor_updated`],
7033          *  if you return [`ChannelMonitorUpdateStatus::InProgress`].
7034          *
7035          *  See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`
7036          *  and [`ChannelMonitorUpdateStatus`] for requirements when returning errors.
7037          *
7038          *  [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
7039          *  [`Writeable::write`]: crate::util::ser::Writeable::write
7040          */
7041         inline LDK::ChannelMonitorUpdateStatus persist_new_channel(struct LDKOutPoint channel_funding_outpoint, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
7042         /**
7043          *  Update one channel's data. The provided [`ChannelMonitor`] has already applied the given
7044          *  update.
7045          *
7046          *  Note that on every update, you **must** persist either the [`ChannelMonitorUpdate`] or the
7047          *  updated monitor itself to disk/backups. See the [`Persist`] trait documentation for more
7048          *  details.
7049          *
7050          *  During blockchain synchronization operations, and in some rare cases, this may be called with
7051          *  no [`ChannelMonitorUpdate`], in which case the full [`ChannelMonitor`] needs to be persisted.
7052          *  Note that after the full [`ChannelMonitor`] is persisted any previous
7053          *  [`ChannelMonitorUpdate`]s which were persisted should be discarded - they can no longer be
7054          *  applied to the persisted [`ChannelMonitor`] as they were already applied.
7055          *
7056          *  If an implementer chooses to persist the updates only, they need to make
7057          *  sure that all the updates are applied to the `ChannelMonitors` *before*
7058          *  the set of channel monitors is given to the `ChannelManager`
7059          *  deserialization routine. See [`ChannelMonitor::update_monitor`] for
7060          *  applying a monitor update to a monitor. If full `ChannelMonitors` are
7061          *  persisted, then there is no need to persist individual updates.
7062          *
7063          *  Note that there could be a performance tradeoff between persisting complete
7064          *  channel monitors on every update vs. persisting only updates and applying
7065          *  them in batches. The size of each monitor grows `O(number of state updates)`
7066          *  whereas updates are small and `O(1)`.
7067          *
7068          *  The `update_id` is used to identify this call to [`ChainMonitor::channel_monitor_updated`],
7069          *  if you return [`ChannelMonitorUpdateStatus::InProgress`].
7070          *
7071          *  See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`,
7072          *  [`Writeable::write`] on [`ChannelMonitorUpdate`] for writing out an update, and
7073          *  [`ChannelMonitorUpdateStatus`] for requirements when returning errors.
7074          *
7075          *  [`Writeable::write`]: crate::util::ser::Writeable::write
7076          *
7077          *  Note that update (or a relevant inner pointer) may be NULL or all-0s to represent None
7078          */
7079         inline LDK::ChannelMonitorUpdateStatus update_persisted_channel(struct LDKOutPoint channel_funding_outpoint, struct LDKChannelMonitorUpdate update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
7080         /**
7081          *  Prevents the channel monitor from being loaded on startup.
7082          *
7083          *  Archiving the data in a backup location (rather than deleting it fully) is useful for
7084          *  hedging against data loss in case of unexpected failure.
7085          */
7086         inline void archive_persisted_channel(struct LDKOutPoint channel_funding_outpoint);
7087 };
7088 class LockedChannelMonitor {
7089 private:
7090         LDKLockedChannelMonitor self;
7091 public:
7092         LockedChannelMonitor(const LockedChannelMonitor&) = delete;
7093         LockedChannelMonitor(LockedChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(LockedChannelMonitor)); }
7094         LockedChannelMonitor(LDKLockedChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockedChannelMonitor)); }
7095         operator LDKLockedChannelMonitor() && { LDKLockedChannelMonitor res = self; memset(&self, 0, sizeof(LDKLockedChannelMonitor)); return res; }
7096         ~LockedChannelMonitor() { LockedChannelMonitor_free(self); }
7097         LockedChannelMonitor& operator=(LockedChannelMonitor&& o) { LockedChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(LockedChannelMonitor)); return *this; }
7098         LDKLockedChannelMonitor* operator &() { return &self; }
7099         LDKLockedChannelMonitor* operator ->() { return &self; }
7100         const LDKLockedChannelMonitor* operator &() const { return &self; }
7101         const LDKLockedChannelMonitor* operator ->() const { return &self; }
7102 };
7103 class ChainMonitor {
7104 private:
7105         LDKChainMonitor self;
7106 public:
7107         ChainMonitor(const ChainMonitor&) = delete;
7108         ChainMonitor(ChainMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChainMonitor)); }
7109         ChainMonitor(LDKChainMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainMonitor)); }
7110         operator LDKChainMonitor() && { LDKChainMonitor res = self; memset(&self, 0, sizeof(LDKChainMonitor)); return res; }
7111         ~ChainMonitor() { ChainMonitor_free(self); }
7112         ChainMonitor& operator=(ChainMonitor&& o) { ChainMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChainMonitor)); return *this; }
7113         LDKChainMonitor* operator &() { return &self; }
7114         LDKChainMonitor* operator ->() { return &self; }
7115         const LDKChainMonitor* operator &() const { return &self; }
7116         const LDKChainMonitor* operator ->() const { return &self; }
7117 };
7118 class CResult_HtlcKeyDecodeErrorZ {
7119 private:
7120         LDKCResult_HtlcKeyDecodeErrorZ self;
7121 public:
7122         CResult_HtlcKeyDecodeErrorZ(const CResult_HtlcKeyDecodeErrorZ&) = delete;
7123         CResult_HtlcKeyDecodeErrorZ(CResult_HtlcKeyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HtlcKeyDecodeErrorZ)); }
7124         CResult_HtlcKeyDecodeErrorZ(LDKCResult_HtlcKeyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HtlcKeyDecodeErrorZ)); }
7125         operator LDKCResult_HtlcKeyDecodeErrorZ() && { LDKCResult_HtlcKeyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HtlcKeyDecodeErrorZ)); return res; }
7126         ~CResult_HtlcKeyDecodeErrorZ() { CResult_HtlcKeyDecodeErrorZ_free(self); }
7127         CResult_HtlcKeyDecodeErrorZ& operator=(CResult_HtlcKeyDecodeErrorZ&& o) { CResult_HtlcKeyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HtlcKeyDecodeErrorZ)); return *this; }
7128         LDKCResult_HtlcKeyDecodeErrorZ* operator &() { return &self; }
7129         LDKCResult_HtlcKeyDecodeErrorZ* operator ->() { return &self; }
7130         const LDKCResult_HtlcKeyDecodeErrorZ* operator &() const { return &self; }
7131         const LDKCResult_HtlcKeyDecodeErrorZ* operator ->() const { return &self; }
7132 };
7133 class CResult_TransactionU16LenLimitedNoneZ {
7134 private:
7135         LDKCResult_TransactionU16LenLimitedNoneZ self;
7136 public:
7137         CResult_TransactionU16LenLimitedNoneZ(const CResult_TransactionU16LenLimitedNoneZ&) = delete;
7138         CResult_TransactionU16LenLimitedNoneZ(CResult_TransactionU16LenLimitedNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedNoneZ)); }
7139         CResult_TransactionU16LenLimitedNoneZ(LDKCResult_TransactionU16LenLimitedNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionU16LenLimitedNoneZ)); }
7140         operator LDKCResult_TransactionU16LenLimitedNoneZ() && { LDKCResult_TransactionU16LenLimitedNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionU16LenLimitedNoneZ)); return res; }
7141         ~CResult_TransactionU16LenLimitedNoneZ() { CResult_TransactionU16LenLimitedNoneZ_free(self); }
7142         CResult_TransactionU16LenLimitedNoneZ& operator=(CResult_TransactionU16LenLimitedNoneZ&& o) { CResult_TransactionU16LenLimitedNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedNoneZ)); return *this; }
7143         LDKCResult_TransactionU16LenLimitedNoneZ* operator &() { return &self; }
7144         LDKCResult_TransactionU16LenLimitedNoneZ* operator ->() { return &self; }
7145         const LDKCResult_TransactionU16LenLimitedNoneZ* operator &() const { return &self; }
7146         const LDKCResult_TransactionU16LenLimitedNoneZ* operator ->() const { return &self; }
7147 };
7148 class CVec_TrackedSpendableOutputZ {
7149 private:
7150         LDKCVec_TrackedSpendableOutputZ self;
7151 public:
7152         CVec_TrackedSpendableOutputZ(const CVec_TrackedSpendableOutputZ&) = delete;
7153         CVec_TrackedSpendableOutputZ(CVec_TrackedSpendableOutputZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TrackedSpendableOutputZ)); }
7154         CVec_TrackedSpendableOutputZ(LDKCVec_TrackedSpendableOutputZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TrackedSpendableOutputZ)); }
7155         operator LDKCVec_TrackedSpendableOutputZ() && { LDKCVec_TrackedSpendableOutputZ res = self; memset(&self, 0, sizeof(LDKCVec_TrackedSpendableOutputZ)); return res; }
7156         ~CVec_TrackedSpendableOutputZ() { CVec_TrackedSpendableOutputZ_free(self); }
7157         CVec_TrackedSpendableOutputZ& operator=(CVec_TrackedSpendableOutputZ&& o) { CVec_TrackedSpendableOutputZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TrackedSpendableOutputZ)); return *this; }
7158         LDKCVec_TrackedSpendableOutputZ* operator &() { return &self; }
7159         LDKCVec_TrackedSpendableOutputZ* operator ->() { return &self; }
7160         const LDKCVec_TrackedSpendableOutputZ* operator &() const { return &self; }
7161         const LDKCVec_TrackedSpendableOutputZ* operator ->() const { return &self; }
7162 };
7163 class CResult_LockedChannelMonitorNoneZ {
7164 private:
7165         LDKCResult_LockedChannelMonitorNoneZ self;
7166 public:
7167         CResult_LockedChannelMonitorNoneZ(const CResult_LockedChannelMonitorNoneZ&) = delete;
7168         CResult_LockedChannelMonitorNoneZ(CResult_LockedChannelMonitorNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); }
7169         CResult_LockedChannelMonitorNoneZ(LDKCResult_LockedChannelMonitorNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); }
7170         operator LDKCResult_LockedChannelMonitorNoneZ() && { LDKCResult_LockedChannelMonitorNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); return res; }
7171         ~CResult_LockedChannelMonitorNoneZ() { CResult_LockedChannelMonitorNoneZ_free(self); }
7172         CResult_LockedChannelMonitorNoneZ& operator=(CResult_LockedChannelMonitorNoneZ&& o) { CResult_LockedChannelMonitorNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); return *this; }
7173         LDKCResult_LockedChannelMonitorNoneZ* operator &() { return &self; }
7174         LDKCResult_LockedChannelMonitorNoneZ* operator ->() { return &self; }
7175         const LDKCResult_LockedChannelMonitorNoneZ* operator &() const { return &self; }
7176         const LDKCResult_LockedChannelMonitorNoneZ* operator ->() const { return &self; }
7177 };
7178 class CVec_C2Tuple_BlindedPayInfoBlindedPathZZ {
7179 private:
7180         LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ self;
7181 public:
7182         CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(const CVec_C2Tuple_BlindedPayInfoBlindedPathZZ&) = delete;
7183         CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); }
7184         CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); }
7185         operator LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ() && { LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); return res; }
7186         ~CVec_C2Tuple_BlindedPayInfoBlindedPathZZ() { CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(self); }
7187         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; }
7188         LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator &() { return &self; }
7189         LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator ->() { return &self; }
7190         const LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator &() const { return &self; }
7191         const LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator ->() const { return &self; }
7192 };
7193 class CResult_PhantomRouteHintsDecodeErrorZ {
7194 private:
7195         LDKCResult_PhantomRouteHintsDecodeErrorZ self;
7196 public:
7197         CResult_PhantomRouteHintsDecodeErrorZ(const CResult_PhantomRouteHintsDecodeErrorZ&) = delete;
7198         CResult_PhantomRouteHintsDecodeErrorZ(CResult_PhantomRouteHintsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); }
7199         CResult_PhantomRouteHintsDecodeErrorZ(LDKCResult_PhantomRouteHintsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); }
7200         operator LDKCResult_PhantomRouteHintsDecodeErrorZ() && { LDKCResult_PhantomRouteHintsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); return res; }
7201         ~CResult_PhantomRouteHintsDecodeErrorZ() { CResult_PhantomRouteHintsDecodeErrorZ_free(self); }
7202         CResult_PhantomRouteHintsDecodeErrorZ& operator=(CResult_PhantomRouteHintsDecodeErrorZ&& o) { CResult_PhantomRouteHintsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); return *this; }
7203         LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() { return &self; }
7204         LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() { return &self; }
7205         const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() const { return &self; }
7206         const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() const { return &self; }
7207 };
7208 class CResult_FundingCreatedDecodeErrorZ {
7209 private:
7210         LDKCResult_FundingCreatedDecodeErrorZ self;
7211 public:
7212         CResult_FundingCreatedDecodeErrorZ(const CResult_FundingCreatedDecodeErrorZ&) = delete;
7213         CResult_FundingCreatedDecodeErrorZ(CResult_FundingCreatedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); }
7214         CResult_FundingCreatedDecodeErrorZ(LDKCResult_FundingCreatedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); }
7215         operator LDKCResult_FundingCreatedDecodeErrorZ() && { LDKCResult_FundingCreatedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); return res; }
7216         ~CResult_FundingCreatedDecodeErrorZ() { CResult_FundingCreatedDecodeErrorZ_free(self); }
7217         CResult_FundingCreatedDecodeErrorZ& operator=(CResult_FundingCreatedDecodeErrorZ&& o) { CResult_FundingCreatedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); return *this; }
7218         LDKCResult_FundingCreatedDecodeErrorZ* operator &() { return &self; }
7219         LDKCResult_FundingCreatedDecodeErrorZ* operator ->() { return &self; }
7220         const LDKCResult_FundingCreatedDecodeErrorZ* operator &() const { return &self; }
7221         const LDKCResult_FundingCreatedDecodeErrorZ* operator ->() const { return &self; }
7222 };
7223 class CVec_C2Tuple_u32TxOutZZ {
7224 private:
7225         LDKCVec_C2Tuple_u32TxOutZZ self;
7226 public:
7227         CVec_C2Tuple_u32TxOutZZ(const CVec_C2Tuple_u32TxOutZZ&) = delete;
7228         CVec_C2Tuple_u32TxOutZZ(CVec_C2Tuple_u32TxOutZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32TxOutZZ)); }
7229         CVec_C2Tuple_u32TxOutZZ(LDKCVec_C2Tuple_u32TxOutZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); }
7230         operator LDKCVec_C2Tuple_u32TxOutZZ() && { LDKCVec_C2Tuple_u32TxOutZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); return res; }
7231         ~CVec_C2Tuple_u32TxOutZZ() { CVec_C2Tuple_u32TxOutZZ_free(self); }
7232         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; }
7233         LDKCVec_C2Tuple_u32TxOutZZ* operator &() { return &self; }
7234         LDKCVec_C2Tuple_u32TxOutZZ* operator ->() { return &self; }
7235         const LDKCVec_C2Tuple_u32TxOutZZ* operator &() const { return &self; }
7236         const LDKCVec_C2Tuple_u32TxOutZZ* operator ->() const { return &self; }
7237 };
7238 class CResult_RetryDecodeErrorZ {
7239 private:
7240         LDKCResult_RetryDecodeErrorZ self;
7241 public:
7242         CResult_RetryDecodeErrorZ(const CResult_RetryDecodeErrorZ&) = delete;
7243         CResult_RetryDecodeErrorZ(CResult_RetryDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RetryDecodeErrorZ)); }
7244         CResult_RetryDecodeErrorZ(LDKCResult_RetryDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RetryDecodeErrorZ)); }
7245         operator LDKCResult_RetryDecodeErrorZ() && { LDKCResult_RetryDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RetryDecodeErrorZ)); return res; }
7246         ~CResult_RetryDecodeErrorZ() { CResult_RetryDecodeErrorZ_free(self); }
7247         CResult_RetryDecodeErrorZ& operator=(CResult_RetryDecodeErrorZ&& o) { CResult_RetryDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RetryDecodeErrorZ)); return *this; }
7248         LDKCResult_RetryDecodeErrorZ* operator &() { return &self; }
7249         LDKCResult_RetryDecodeErrorZ* operator ->() { return &self; }
7250         const LDKCResult_RetryDecodeErrorZ* operator &() const { return &self; }
7251         const LDKCResult_RetryDecodeErrorZ* operator ->() const { return &self; }
7252 };
7253 class CResult_BlindedForwardDecodeErrorZ {
7254 private:
7255         LDKCResult_BlindedForwardDecodeErrorZ self;
7256 public:
7257         CResult_BlindedForwardDecodeErrorZ(const CResult_BlindedForwardDecodeErrorZ&) = delete;
7258         CResult_BlindedForwardDecodeErrorZ(CResult_BlindedForwardDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedForwardDecodeErrorZ)); }
7259         CResult_BlindedForwardDecodeErrorZ(LDKCResult_BlindedForwardDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedForwardDecodeErrorZ)); }
7260         operator LDKCResult_BlindedForwardDecodeErrorZ() && { LDKCResult_BlindedForwardDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedForwardDecodeErrorZ)); return res; }
7261         ~CResult_BlindedForwardDecodeErrorZ() { CResult_BlindedForwardDecodeErrorZ_free(self); }
7262         CResult_BlindedForwardDecodeErrorZ& operator=(CResult_BlindedForwardDecodeErrorZ&& o) { CResult_BlindedForwardDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedForwardDecodeErrorZ)); return *this; }
7263         LDKCResult_BlindedForwardDecodeErrorZ* operator &() { return &self; }
7264         LDKCResult_BlindedForwardDecodeErrorZ* operator ->() { return &self; }
7265         const LDKCResult_BlindedForwardDecodeErrorZ* operator &() const { return &self; }
7266         const LDKCResult_BlindedForwardDecodeErrorZ* operator ->() const { return &self; }
7267 };
7268 class CResult_ChannelInfoDecodeErrorZ {
7269 private:
7270         LDKCResult_ChannelInfoDecodeErrorZ self;
7271 public:
7272         CResult_ChannelInfoDecodeErrorZ(const CResult_ChannelInfoDecodeErrorZ&) = delete;
7273         CResult_ChannelInfoDecodeErrorZ(CResult_ChannelInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); }
7274         CResult_ChannelInfoDecodeErrorZ(LDKCResult_ChannelInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); }
7275         operator LDKCResult_ChannelInfoDecodeErrorZ() && { LDKCResult_ChannelInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); return res; }
7276         ~CResult_ChannelInfoDecodeErrorZ() { CResult_ChannelInfoDecodeErrorZ_free(self); }
7277         CResult_ChannelInfoDecodeErrorZ& operator=(CResult_ChannelInfoDecodeErrorZ&& o) { CResult_ChannelInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); return *this; }
7278         LDKCResult_ChannelInfoDecodeErrorZ* operator &() { return &self; }
7279         LDKCResult_ChannelInfoDecodeErrorZ* operator ->() { return &self; }
7280         const LDKCResult_ChannelInfoDecodeErrorZ* operator &() const { return &self; }
7281         const LDKCResult_ChannelInfoDecodeErrorZ* operator ->() const { return &self; }
7282 };
7283 class COption_PaymentContextZ {
7284 private:
7285         LDKCOption_PaymentContextZ self;
7286 public:
7287         COption_PaymentContextZ(const COption_PaymentContextZ&) = delete;
7288         COption_PaymentContextZ(COption_PaymentContextZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_PaymentContextZ)); }
7289         COption_PaymentContextZ(LDKCOption_PaymentContextZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_PaymentContextZ)); }
7290         operator LDKCOption_PaymentContextZ() && { LDKCOption_PaymentContextZ res = self; memset(&self, 0, sizeof(LDKCOption_PaymentContextZ)); return res; }
7291         ~COption_PaymentContextZ() { COption_PaymentContextZ_free(self); }
7292         COption_PaymentContextZ& operator=(COption_PaymentContextZ&& o) { COption_PaymentContextZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_PaymentContextZ)); return *this; }
7293         LDKCOption_PaymentContextZ* operator &() { return &self; }
7294         LDKCOption_PaymentContextZ* operator ->() { return &self; }
7295         const LDKCOption_PaymentContextZ* operator &() const { return &self; }
7296         const LDKCOption_PaymentContextZ* operator ->() const { return &self; }
7297 };
7298 class COption_MaxDustHTLCExposureZ {
7299 private:
7300         LDKCOption_MaxDustHTLCExposureZ self;
7301 public:
7302         COption_MaxDustHTLCExposureZ(const COption_MaxDustHTLCExposureZ&) = delete;
7303         COption_MaxDustHTLCExposureZ(COption_MaxDustHTLCExposureZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MaxDustHTLCExposureZ)); }
7304         COption_MaxDustHTLCExposureZ(LDKCOption_MaxDustHTLCExposureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MaxDustHTLCExposureZ)); }
7305         operator LDKCOption_MaxDustHTLCExposureZ() && { LDKCOption_MaxDustHTLCExposureZ res = self; memset(&self, 0, sizeof(LDKCOption_MaxDustHTLCExposureZ)); return res; }
7306         ~COption_MaxDustHTLCExposureZ() { COption_MaxDustHTLCExposureZ_free(self); }
7307         COption_MaxDustHTLCExposureZ& operator=(COption_MaxDustHTLCExposureZ&& o) { COption_MaxDustHTLCExposureZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MaxDustHTLCExposureZ)); return *this; }
7308         LDKCOption_MaxDustHTLCExposureZ* operator &() { return &self; }
7309         LDKCOption_MaxDustHTLCExposureZ* operator ->() { return &self; }
7310         const LDKCOption_MaxDustHTLCExposureZ* operator &() const { return &self; }
7311         const LDKCOption_MaxDustHTLCExposureZ* operator ->() const { return &self; }
7312 };
7313 class COption_OffersMessageZ {
7314 private:
7315         LDKCOption_OffersMessageZ self;
7316 public:
7317         COption_OffersMessageZ(const COption_OffersMessageZ&) = delete;
7318         COption_OffersMessageZ(COption_OffersMessageZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_OffersMessageZ)); }
7319         COption_OffersMessageZ(LDKCOption_OffersMessageZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_OffersMessageZ)); }
7320         operator LDKCOption_OffersMessageZ() && { LDKCOption_OffersMessageZ res = self; memset(&self, 0, sizeof(LDKCOption_OffersMessageZ)); return res; }
7321         ~COption_OffersMessageZ() { COption_OffersMessageZ_free(self); }
7322         COption_OffersMessageZ& operator=(COption_OffersMessageZ&& o) { COption_OffersMessageZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_OffersMessageZ)); return *this; }
7323         LDKCOption_OffersMessageZ* operator &() { return &self; }
7324         LDKCOption_OffersMessageZ* operator ->() { return &self; }
7325         const LDKCOption_OffersMessageZ* operator &() const { return &self; }
7326         const LDKCOption_OffersMessageZ* operator ->() const { return &self; }
7327 };
7328 class CResult_CVec_u8ZPeerHandleErrorZ {
7329 private:
7330         LDKCResult_CVec_u8ZPeerHandleErrorZ self;
7331 public:
7332         CResult_CVec_u8ZPeerHandleErrorZ(const CResult_CVec_u8ZPeerHandleErrorZ&) = delete;
7333         CResult_CVec_u8ZPeerHandleErrorZ(CResult_CVec_u8ZPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); }
7334         CResult_CVec_u8ZPeerHandleErrorZ(LDKCResult_CVec_u8ZPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); }
7335         operator LDKCResult_CVec_u8ZPeerHandleErrorZ() && { LDKCResult_CVec_u8ZPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); return res; }
7336         ~CResult_CVec_u8ZPeerHandleErrorZ() { CResult_CVec_u8ZPeerHandleErrorZ_free(self); }
7337         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; }
7338         LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() { return &self; }
7339         LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() { return &self; }
7340         const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() const { return &self; }
7341         const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() const { return &self; }
7342 };
7343 class COption_NetworkUpdateZ {
7344 private:
7345         LDKCOption_NetworkUpdateZ self;
7346 public:
7347         COption_NetworkUpdateZ(const COption_NetworkUpdateZ&) = delete;
7348         COption_NetworkUpdateZ(COption_NetworkUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NetworkUpdateZ)); }
7349         COption_NetworkUpdateZ(LDKCOption_NetworkUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NetworkUpdateZ)); }
7350         operator LDKCOption_NetworkUpdateZ() && { LDKCOption_NetworkUpdateZ res = self; memset(&self, 0, sizeof(LDKCOption_NetworkUpdateZ)); return res; }
7351         ~COption_NetworkUpdateZ() { COption_NetworkUpdateZ_free(self); }
7352         COption_NetworkUpdateZ& operator=(COption_NetworkUpdateZ&& o) { COption_NetworkUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NetworkUpdateZ)); return *this; }
7353         LDKCOption_NetworkUpdateZ* operator &() { return &self; }
7354         LDKCOption_NetworkUpdateZ* operator ->() { return &self; }
7355         const LDKCOption_NetworkUpdateZ* operator &() const { return &self; }
7356         const LDKCOption_NetworkUpdateZ* operator ->() const { return &self; }
7357 };
7358 class COption_u64Z {
7359 private:
7360         LDKCOption_u64Z self;
7361 public:
7362         COption_u64Z(const COption_u64Z&) = delete;
7363         COption_u64Z(COption_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u64Z)); }
7364         COption_u64Z(LDKCOption_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u64Z)); }
7365         operator LDKCOption_u64Z() && { LDKCOption_u64Z res = self; memset(&self, 0, sizeof(LDKCOption_u64Z)); return res; }
7366         ~COption_u64Z() { COption_u64Z_free(self); }
7367         COption_u64Z& operator=(COption_u64Z&& o) { COption_u64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u64Z)); return *this; }
7368         LDKCOption_u64Z* operator &() { return &self; }
7369         LDKCOption_u64Z* operator ->() { return &self; }
7370         const LDKCOption_u64Z* operator &() const { return &self; }
7371         const LDKCOption_u64Z* operator ->() const { return &self; }
7372 };
7373 class CResult_OnionPacketDecodeErrorZ {
7374 private:
7375         LDKCResult_OnionPacketDecodeErrorZ self;
7376 public:
7377         CResult_OnionPacketDecodeErrorZ(const CResult_OnionPacketDecodeErrorZ&) = delete;
7378         CResult_OnionPacketDecodeErrorZ(CResult_OnionPacketDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionPacketDecodeErrorZ)); }
7379         CResult_OnionPacketDecodeErrorZ(LDKCResult_OnionPacketDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionPacketDecodeErrorZ)); }
7380         operator LDKCResult_OnionPacketDecodeErrorZ() && { LDKCResult_OnionPacketDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionPacketDecodeErrorZ)); return res; }
7381         ~CResult_OnionPacketDecodeErrorZ() { CResult_OnionPacketDecodeErrorZ_free(self); }
7382         CResult_OnionPacketDecodeErrorZ& operator=(CResult_OnionPacketDecodeErrorZ&& o) { CResult_OnionPacketDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionPacketDecodeErrorZ)); return *this; }
7383         LDKCResult_OnionPacketDecodeErrorZ* operator &() { return &self; }
7384         LDKCResult_OnionPacketDecodeErrorZ* operator ->() { return &self; }
7385         const LDKCResult_OnionPacketDecodeErrorZ* operator &() const { return &self; }
7386         const LDKCResult_OnionPacketDecodeErrorZ* operator ->() const { return &self; }
7387 };
7388 class CResult_GossipTimestampFilterDecodeErrorZ {
7389 private:
7390         LDKCResult_GossipTimestampFilterDecodeErrorZ self;
7391 public:
7392         CResult_GossipTimestampFilterDecodeErrorZ(const CResult_GossipTimestampFilterDecodeErrorZ&) = delete;
7393         CResult_GossipTimestampFilterDecodeErrorZ(CResult_GossipTimestampFilterDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); }
7394         CResult_GossipTimestampFilterDecodeErrorZ(LDKCResult_GossipTimestampFilterDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); }
7395         operator LDKCResult_GossipTimestampFilterDecodeErrorZ() && { LDKCResult_GossipTimestampFilterDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); return res; }
7396         ~CResult_GossipTimestampFilterDecodeErrorZ() { CResult_GossipTimestampFilterDecodeErrorZ_free(self); }
7397         CResult_GossipTimestampFilterDecodeErrorZ& operator=(CResult_GossipTimestampFilterDecodeErrorZ&& o) { CResult_GossipTimestampFilterDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); return *this; }
7398         LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() { return &self; }
7399         LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() { return &self; }
7400         const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() const { return &self; }
7401         const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() const { return &self; }
7402 };
7403 class CResult_RouteHintDecodeErrorZ {
7404 private:
7405         LDKCResult_RouteHintDecodeErrorZ self;
7406 public:
7407         CResult_RouteHintDecodeErrorZ(const CResult_RouteHintDecodeErrorZ&) = delete;
7408         CResult_RouteHintDecodeErrorZ(CResult_RouteHintDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); }
7409         CResult_RouteHintDecodeErrorZ(LDKCResult_RouteHintDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); }
7410         operator LDKCResult_RouteHintDecodeErrorZ() && { LDKCResult_RouteHintDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); return res; }
7411         ~CResult_RouteHintDecodeErrorZ() { CResult_RouteHintDecodeErrorZ_free(self); }
7412         CResult_RouteHintDecodeErrorZ& operator=(CResult_RouteHintDecodeErrorZ&& o) { CResult_RouteHintDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); return *this; }
7413         LDKCResult_RouteHintDecodeErrorZ* operator &() { return &self; }
7414         LDKCResult_RouteHintDecodeErrorZ* operator ->() { return &self; }
7415         const LDKCResult_RouteHintDecodeErrorZ* operator &() const { return &self; }
7416         const LDKCResult_RouteHintDecodeErrorZ* operator ->() const { return &self; }
7417 };
7418 class COption_FilterZ {
7419 private:
7420         LDKCOption_FilterZ self;
7421 public:
7422         COption_FilterZ(const COption_FilterZ&) = delete;
7423         COption_FilterZ(COption_FilterZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_FilterZ)); }
7424         COption_FilterZ(LDKCOption_FilterZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_FilterZ)); }
7425         operator LDKCOption_FilterZ() && { LDKCOption_FilterZ res = self; memset(&self, 0, sizeof(LDKCOption_FilterZ)); return res; }
7426         ~COption_FilterZ() { COption_FilterZ_free(self); }
7427         COption_FilterZ& operator=(COption_FilterZ&& o) { COption_FilterZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_FilterZ)); return *this; }
7428         LDKCOption_FilterZ* operator &() { return &self; }
7429         LDKCOption_FilterZ* operator ->() { return &self; }
7430         const LDKCOption_FilterZ* operator &() const { return &self; }
7431         const LDKCOption_FilterZ* operator ->() const { return &self; }
7432 };
7433 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ {
7434 private:
7435         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ self;
7436 public:
7437         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ(const C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ&) = delete;
7438         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ)); }
7439         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)); }
7440         operator LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ() && { LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ)); return res; }
7441         ~C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ() { C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(self); }
7442         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; }
7443         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator &() { return &self; }
7444         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator ->() { return &self; }
7445         const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator &() const { return &self; }
7446         const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator ->() const { return &self; }
7447 };
7448 class COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
7449 private:
7450         LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ self;
7451 public:
7452         COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(const COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&) = delete;
7453         COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
7454         COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
7455         operator LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() && { LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ res = self; memset(&self, 0, sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return res; }
7456         ~COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() { COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); }
7457         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; }
7458         LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() { return &self; }
7459         LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() { return &self; }
7460         const LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() const { return &self; }
7461         const LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() const { return &self; }
7462 };
7463 class CResult_COption_APIErrorZDecodeErrorZ {
7464 private:
7465         LDKCResult_COption_APIErrorZDecodeErrorZ self;
7466 public:
7467         CResult_COption_APIErrorZDecodeErrorZ(const CResult_COption_APIErrorZDecodeErrorZ&) = delete;
7468         CResult_COption_APIErrorZDecodeErrorZ(CResult_COption_APIErrorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_APIErrorZDecodeErrorZ)); }
7469         CResult_COption_APIErrorZDecodeErrorZ(LDKCResult_COption_APIErrorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ)); }
7470         operator LDKCResult_COption_APIErrorZDecodeErrorZ() && { LDKCResult_COption_APIErrorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ)); return res; }
7471         ~CResult_COption_APIErrorZDecodeErrorZ() { CResult_COption_APIErrorZDecodeErrorZ_free(self); }
7472         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; }
7473         LDKCResult_COption_APIErrorZDecodeErrorZ* operator &() { return &self; }
7474         LDKCResult_COption_APIErrorZDecodeErrorZ* operator ->() { return &self; }
7475         const LDKCResult_COption_APIErrorZDecodeErrorZ* operator &() const { return &self; }
7476         const LDKCResult_COption_APIErrorZDecodeErrorZ* operator ->() const { return &self; }
7477 };
7478 class CVec_UpdateAddHTLCZ {
7479 private:
7480         LDKCVec_UpdateAddHTLCZ self;
7481 public:
7482         CVec_UpdateAddHTLCZ(const CVec_UpdateAddHTLCZ&) = delete;
7483         CVec_UpdateAddHTLCZ(CVec_UpdateAddHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); }
7484         CVec_UpdateAddHTLCZ(LDKCVec_UpdateAddHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); }
7485         operator LDKCVec_UpdateAddHTLCZ() && { LDKCVec_UpdateAddHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); return res; }
7486         ~CVec_UpdateAddHTLCZ() { CVec_UpdateAddHTLCZ_free(self); }
7487         CVec_UpdateAddHTLCZ& operator=(CVec_UpdateAddHTLCZ&& o) { CVec_UpdateAddHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); return *this; }
7488         LDKCVec_UpdateAddHTLCZ* operator &() { return &self; }
7489         LDKCVec_UpdateAddHTLCZ* operator ->() { return &self; }
7490         const LDKCVec_UpdateAddHTLCZ* operator &() const { return &self; }
7491         const LDKCVec_UpdateAddHTLCZ* operator ->() const { return &self; }
7492 };
7493 class CResult_TxAbortDecodeErrorZ {
7494 private:
7495         LDKCResult_TxAbortDecodeErrorZ self;
7496 public:
7497         CResult_TxAbortDecodeErrorZ(const CResult_TxAbortDecodeErrorZ&) = delete;
7498         CResult_TxAbortDecodeErrorZ(CResult_TxAbortDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAbortDecodeErrorZ)); }
7499         CResult_TxAbortDecodeErrorZ(LDKCResult_TxAbortDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAbortDecodeErrorZ)); }
7500         operator LDKCResult_TxAbortDecodeErrorZ() && { LDKCResult_TxAbortDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAbortDecodeErrorZ)); return res; }
7501         ~CResult_TxAbortDecodeErrorZ() { CResult_TxAbortDecodeErrorZ_free(self); }
7502         CResult_TxAbortDecodeErrorZ& operator=(CResult_TxAbortDecodeErrorZ&& o) { CResult_TxAbortDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAbortDecodeErrorZ)); return *this; }
7503         LDKCResult_TxAbortDecodeErrorZ* operator &() { return &self; }
7504         LDKCResult_TxAbortDecodeErrorZ* operator ->() { return &self; }
7505         const LDKCResult_TxAbortDecodeErrorZ* operator &() const { return &self; }
7506         const LDKCResult_TxAbortDecodeErrorZ* operator ->() const { return &self; }
7507 };
7508 class CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
7509 private:
7510         LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ self;
7511 public:
7512         CResult_StaticPaymentOutputDescriptorDecodeErrorZ(const CResult_StaticPaymentOutputDescriptorDecodeErrorZ&) = delete;
7513         CResult_StaticPaymentOutputDescriptorDecodeErrorZ(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
7514         CResult_StaticPaymentOutputDescriptorDecodeErrorZ(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
7515         operator LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return res; }
7516         ~CResult_StaticPaymentOutputDescriptorDecodeErrorZ() { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); }
7517         CResult_StaticPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return *this; }
7518         LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
7519         LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
7520         const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
7521         const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
7522 };
7523 class COption_u32Z {
7524 private:
7525         LDKCOption_u32Z self;
7526 public:
7527         COption_u32Z(const COption_u32Z&) = delete;
7528         COption_u32Z(COption_u32Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u32Z)); }
7529         COption_u32Z(LDKCOption_u32Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u32Z)); }
7530         operator LDKCOption_u32Z() && { LDKCOption_u32Z res = self; memset(&self, 0, sizeof(LDKCOption_u32Z)); return res; }
7531         ~COption_u32Z() { COption_u32Z_free(self); }
7532         COption_u32Z& operator=(COption_u32Z&& o) { COption_u32Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u32Z)); return *this; }
7533         LDKCOption_u32Z* operator &() { return &self; }
7534         LDKCOption_u32Z* operator ->() { return &self; }
7535         const LDKCOption_u32Z* operator &() const { return &self; }
7536         const LDKCOption_u32Z* operator ->() const { return &self; }
7537 };
7538 class CResult_RecipientOnionFieldsNoneZ {
7539 private:
7540         LDKCResult_RecipientOnionFieldsNoneZ self;
7541 public:
7542         CResult_RecipientOnionFieldsNoneZ(const CResult_RecipientOnionFieldsNoneZ&) = delete;
7543         CResult_RecipientOnionFieldsNoneZ(CResult_RecipientOnionFieldsNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecipientOnionFieldsNoneZ)); }
7544         CResult_RecipientOnionFieldsNoneZ(LDKCResult_RecipientOnionFieldsNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecipientOnionFieldsNoneZ)); }
7545         operator LDKCResult_RecipientOnionFieldsNoneZ() && { LDKCResult_RecipientOnionFieldsNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_RecipientOnionFieldsNoneZ)); return res; }
7546         ~CResult_RecipientOnionFieldsNoneZ() { CResult_RecipientOnionFieldsNoneZ_free(self); }
7547         CResult_RecipientOnionFieldsNoneZ& operator=(CResult_RecipientOnionFieldsNoneZ&& o) { CResult_RecipientOnionFieldsNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecipientOnionFieldsNoneZ)); return *this; }
7548         LDKCResult_RecipientOnionFieldsNoneZ* operator &() { return &self; }
7549         LDKCResult_RecipientOnionFieldsNoneZ* operator ->() { return &self; }
7550         const LDKCResult_RecipientOnionFieldsNoneZ* operator &() const { return &self; }
7551         const LDKCResult_RecipientOnionFieldsNoneZ* operator ->() const { return &self; }
7552 };
7553 class C2Tuple__u1632_u1632Z {
7554 private:
7555         LDKC2Tuple__u1632_u1632Z self;
7556 public:
7557         C2Tuple__u1632_u1632Z(const C2Tuple__u1632_u1632Z&) = delete;
7558         C2Tuple__u1632_u1632Z(C2Tuple__u1632_u1632Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple__u1632_u1632Z)); }
7559         C2Tuple__u1632_u1632Z(LDKC2Tuple__u1632_u1632Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple__u1632_u1632Z)); }
7560         operator LDKC2Tuple__u1632_u1632Z() && { LDKC2Tuple__u1632_u1632Z res = self; memset(&self, 0, sizeof(LDKC2Tuple__u1632_u1632Z)); return res; }
7561         ~C2Tuple__u1632_u1632Z() { C2Tuple__u1632_u1632Z_free(self); }
7562         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; }
7563         LDKC2Tuple__u1632_u1632Z* operator &() { return &self; }
7564         LDKC2Tuple__u1632_u1632Z* operator ->() { return &self; }
7565         const LDKC2Tuple__u1632_u1632Z* operator &() const { return &self; }
7566         const LDKC2Tuple__u1632_u1632Z* operator ->() const { return &self; }
7567 };
7568 class CResult_CVec_StrZIOErrorZ {
7569 private:
7570         LDKCResult_CVec_StrZIOErrorZ self;
7571 public:
7572         CResult_CVec_StrZIOErrorZ(const CResult_CVec_StrZIOErrorZ&) = delete;
7573         CResult_CVec_StrZIOErrorZ(CResult_CVec_StrZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_StrZIOErrorZ)); }
7574         CResult_CVec_StrZIOErrorZ(LDKCResult_CVec_StrZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_StrZIOErrorZ)); }
7575         operator LDKCResult_CVec_StrZIOErrorZ() && { LDKCResult_CVec_StrZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_StrZIOErrorZ)); return res; }
7576         ~CResult_CVec_StrZIOErrorZ() { CResult_CVec_StrZIOErrorZ_free(self); }
7577         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; }
7578         LDKCResult_CVec_StrZIOErrorZ* operator &() { return &self; }
7579         LDKCResult_CVec_StrZIOErrorZ* operator ->() { return &self; }
7580         const LDKCResult_CVec_StrZIOErrorZ* operator &() const { return &self; }
7581         const LDKCResult_CVec_StrZIOErrorZ* operator ->() const { return &self; }
7582 };
7583 class COption_ECDSASignatureZ {
7584 private:
7585         LDKCOption_ECDSASignatureZ self;
7586 public:
7587         COption_ECDSASignatureZ(const COption_ECDSASignatureZ&) = delete;
7588         COption_ECDSASignatureZ(COption_ECDSASignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ECDSASignatureZ)); }
7589         COption_ECDSASignatureZ(LDKCOption_ECDSASignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ECDSASignatureZ)); }
7590         operator LDKCOption_ECDSASignatureZ() && { LDKCOption_ECDSASignatureZ res = self; memset(&self, 0, sizeof(LDKCOption_ECDSASignatureZ)); return res; }
7591         ~COption_ECDSASignatureZ() { COption_ECDSASignatureZ_free(self); }
7592         COption_ECDSASignatureZ& operator=(COption_ECDSASignatureZ&& o) { COption_ECDSASignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ECDSASignatureZ)); return *this; }
7593         LDKCOption_ECDSASignatureZ* operator &() { return &self; }
7594         LDKCOption_ECDSASignatureZ* operator ->() { return &self; }
7595         const LDKCOption_ECDSASignatureZ* operator &() const { return &self; }
7596         const LDKCOption_ECDSASignatureZ* operator ->() const { return &self; }
7597 };
7598 class CResult_TransactionNoneZ {
7599 private:
7600         LDKCResult_TransactionNoneZ self;
7601 public:
7602         CResult_TransactionNoneZ(const CResult_TransactionNoneZ&) = delete;
7603         CResult_TransactionNoneZ(CResult_TransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionNoneZ)); }
7604         CResult_TransactionNoneZ(LDKCResult_TransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionNoneZ)); }
7605         operator LDKCResult_TransactionNoneZ() && { LDKCResult_TransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionNoneZ)); return res; }
7606         ~CResult_TransactionNoneZ() { CResult_TransactionNoneZ_free(self); }
7607         CResult_TransactionNoneZ& operator=(CResult_TransactionNoneZ&& o) { CResult_TransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionNoneZ)); return *this; }
7608         LDKCResult_TransactionNoneZ* operator &() { return &self; }
7609         LDKCResult_TransactionNoneZ* operator ->() { return &self; }
7610         const LDKCResult_TransactionNoneZ* operator &() const { return &self; }
7611         const LDKCResult_TransactionNoneZ* operator ->() const { return &self; }
7612 };
7613 class CResult_ClosingSignedFeeRangeDecodeErrorZ {
7614 private:
7615         LDKCResult_ClosingSignedFeeRangeDecodeErrorZ self;
7616 public:
7617         CResult_ClosingSignedFeeRangeDecodeErrorZ(const CResult_ClosingSignedFeeRangeDecodeErrorZ&) = delete;
7618         CResult_ClosingSignedFeeRangeDecodeErrorZ(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); }
7619         CResult_ClosingSignedFeeRangeDecodeErrorZ(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); }
7620         operator LDKCResult_ClosingSignedFeeRangeDecodeErrorZ() && { LDKCResult_ClosingSignedFeeRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); return res; }
7621         ~CResult_ClosingSignedFeeRangeDecodeErrorZ() { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); }
7622         CResult_ClosingSignedFeeRangeDecodeErrorZ& operator=(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); return *this; }
7623         LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() { return &self; }
7624         LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() { return &self; }
7625         const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() const { return &self; }
7626         const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() const { return &self; }
7627 };
7628 class CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ {
7629 private:
7630         LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ self;
7631 public:
7632         CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ(const CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ&) = delete;
7633         CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ(CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ)); }
7634         CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ(LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ)); }
7635         operator LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ() && { LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ)); return res; }
7636         ~CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ() { CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_free(self); }
7637         CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ& operator=(CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ&& o) { CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ)); return *this; }
7638         LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ* operator &() { return &self; }
7639         LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ* operator ->() { return &self; }
7640         const LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ* operator &() const { return &self; }
7641         const LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ* operator ->() const { return &self; }
7642 };
7643 class CResult_CommitmentSignedDecodeErrorZ {
7644 private:
7645         LDKCResult_CommitmentSignedDecodeErrorZ self;
7646 public:
7647         CResult_CommitmentSignedDecodeErrorZ(const CResult_CommitmentSignedDecodeErrorZ&) = delete;
7648         CResult_CommitmentSignedDecodeErrorZ(CResult_CommitmentSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); }
7649         CResult_CommitmentSignedDecodeErrorZ(LDKCResult_CommitmentSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); }
7650         operator LDKCResult_CommitmentSignedDecodeErrorZ() && { LDKCResult_CommitmentSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); return res; }
7651         ~CResult_CommitmentSignedDecodeErrorZ() { CResult_CommitmentSignedDecodeErrorZ_free(self); }
7652         CResult_CommitmentSignedDecodeErrorZ& operator=(CResult_CommitmentSignedDecodeErrorZ&& o) { CResult_CommitmentSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); return *this; }
7653         LDKCResult_CommitmentSignedDecodeErrorZ* operator &() { return &self; }
7654         LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() { return &self; }
7655         const LDKCResult_CommitmentSignedDecodeErrorZ* operator &() const { return &self; }
7656         const LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() const { return &self; }
7657 };
7658 class CResult_CommitmentTransactionDecodeErrorZ {
7659 private:
7660         LDKCResult_CommitmentTransactionDecodeErrorZ self;
7661 public:
7662         CResult_CommitmentTransactionDecodeErrorZ(const CResult_CommitmentTransactionDecodeErrorZ&) = delete;
7663         CResult_CommitmentTransactionDecodeErrorZ(CResult_CommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); }
7664         CResult_CommitmentTransactionDecodeErrorZ(LDKCResult_CommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); }
7665         operator LDKCResult_CommitmentTransactionDecodeErrorZ() && { LDKCResult_CommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); return res; }
7666         ~CResult_CommitmentTransactionDecodeErrorZ() { CResult_CommitmentTransactionDecodeErrorZ_free(self); }
7667         CResult_CommitmentTransactionDecodeErrorZ& operator=(CResult_CommitmentTransactionDecodeErrorZ&& o) { CResult_CommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); return *this; }
7668         LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() { return &self; }
7669         LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
7670         const LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
7671         const LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
7672 };
7673 class CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ {
7674 private:
7675         LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ self;
7676 public:
7677         CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ(const CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ&) = delete;
7678         CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ(CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ)); }
7679         CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ(LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ)); }
7680         operator LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ() && { LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ)); return res; }
7681         ~CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ() { CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_free(self); }
7682         CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ& operator=(CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ&& o) { CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ)); return *this; }
7683         LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ* operator &() { return &self; }
7684         LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ* operator ->() { return &self; }
7685         const LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ* operator &() const { return &self; }
7686         const LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ* operator ->() const { return &self; }
7687 };
7688 class CResult_StfuDecodeErrorZ {
7689 private:
7690         LDKCResult_StfuDecodeErrorZ self;
7691 public:
7692         CResult_StfuDecodeErrorZ(const CResult_StfuDecodeErrorZ&) = delete;
7693         CResult_StfuDecodeErrorZ(CResult_StfuDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StfuDecodeErrorZ)); }
7694         CResult_StfuDecodeErrorZ(LDKCResult_StfuDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StfuDecodeErrorZ)); }
7695         operator LDKCResult_StfuDecodeErrorZ() && { LDKCResult_StfuDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StfuDecodeErrorZ)); return res; }
7696         ~CResult_StfuDecodeErrorZ() { CResult_StfuDecodeErrorZ_free(self); }
7697         CResult_StfuDecodeErrorZ& operator=(CResult_StfuDecodeErrorZ&& o) { CResult_StfuDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StfuDecodeErrorZ)); return *this; }
7698         LDKCResult_StfuDecodeErrorZ* operator &() { return &self; }
7699         LDKCResult_StfuDecodeErrorZ* operator ->() { return &self; }
7700         const LDKCResult_StfuDecodeErrorZ* operator &() const { return &self; }
7701         const LDKCResult_StfuDecodeErrorZ* operator ->() const { return &self; }
7702 };
7703 class CResult_OpenChannelDecodeErrorZ {
7704 private:
7705         LDKCResult_OpenChannelDecodeErrorZ self;
7706 public:
7707         CResult_OpenChannelDecodeErrorZ(const CResult_OpenChannelDecodeErrorZ&) = delete;
7708         CResult_OpenChannelDecodeErrorZ(CResult_OpenChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); }
7709         CResult_OpenChannelDecodeErrorZ(LDKCResult_OpenChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); }
7710         operator LDKCResult_OpenChannelDecodeErrorZ() && { LDKCResult_OpenChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); return res; }
7711         ~CResult_OpenChannelDecodeErrorZ() { CResult_OpenChannelDecodeErrorZ_free(self); }
7712         CResult_OpenChannelDecodeErrorZ& operator=(CResult_OpenChannelDecodeErrorZ&& o) { CResult_OpenChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); return *this; }
7713         LDKCResult_OpenChannelDecodeErrorZ* operator &() { return &self; }
7714         LDKCResult_OpenChannelDecodeErrorZ* operator ->() { return &self; }
7715         const LDKCResult_OpenChannelDecodeErrorZ* operator &() const { return &self; }
7716         const LDKCResult_OpenChannelDecodeErrorZ* operator ->() const { return &self; }
7717 };
7718 class CResult_ErrorMessageDecodeErrorZ {
7719 private:
7720         LDKCResult_ErrorMessageDecodeErrorZ self;
7721 public:
7722         CResult_ErrorMessageDecodeErrorZ(const CResult_ErrorMessageDecodeErrorZ&) = delete;
7723         CResult_ErrorMessageDecodeErrorZ(CResult_ErrorMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); }
7724         CResult_ErrorMessageDecodeErrorZ(LDKCResult_ErrorMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); }
7725         operator LDKCResult_ErrorMessageDecodeErrorZ() && { LDKCResult_ErrorMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); return res; }
7726         ~CResult_ErrorMessageDecodeErrorZ() { CResult_ErrorMessageDecodeErrorZ_free(self); }
7727         CResult_ErrorMessageDecodeErrorZ& operator=(CResult_ErrorMessageDecodeErrorZ&& o) { CResult_ErrorMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); return *this; }
7728         LDKCResult_ErrorMessageDecodeErrorZ* operator &() { return &self; }
7729         LDKCResult_ErrorMessageDecodeErrorZ* operator ->() { return &self; }
7730         const LDKCResult_ErrorMessageDecodeErrorZ* operator &() const { return &self; }
7731         const LDKCResult_ErrorMessageDecodeErrorZ* operator ->() const { return &self; }
7732 };
7733 class COption_APIErrorZ {
7734 private:
7735         LDKCOption_APIErrorZ self;
7736 public:
7737         COption_APIErrorZ(const COption_APIErrorZ&) = delete;
7738         COption_APIErrorZ(COption_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_APIErrorZ)); }
7739         COption_APIErrorZ(LDKCOption_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_APIErrorZ)); }
7740         operator LDKCOption_APIErrorZ() && { LDKCOption_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCOption_APIErrorZ)); return res; }
7741         ~COption_APIErrorZ() { COption_APIErrorZ_free(self); }
7742         COption_APIErrorZ& operator=(COption_APIErrorZ&& o) { COption_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_APIErrorZ)); return *this; }
7743         LDKCOption_APIErrorZ* operator &() { return &self; }
7744         LDKCOption_APIErrorZ* operator ->() { return &self; }
7745         const LDKCOption_APIErrorZ* operator &() const { return &self; }
7746         const LDKCOption_APIErrorZ* operator ->() const { return &self; }
7747 };
7748 class CVec_PeerDetailsZ {
7749 private:
7750         LDKCVec_PeerDetailsZ self;
7751 public:
7752         CVec_PeerDetailsZ(const CVec_PeerDetailsZ&) = delete;
7753         CVec_PeerDetailsZ(CVec_PeerDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PeerDetailsZ)); }
7754         CVec_PeerDetailsZ(LDKCVec_PeerDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PeerDetailsZ)); }
7755         operator LDKCVec_PeerDetailsZ() && { LDKCVec_PeerDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_PeerDetailsZ)); return res; }
7756         ~CVec_PeerDetailsZ() { CVec_PeerDetailsZ_free(self); }
7757         CVec_PeerDetailsZ& operator=(CVec_PeerDetailsZ&& o) { CVec_PeerDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PeerDetailsZ)); return *this; }
7758         LDKCVec_PeerDetailsZ* operator &() { return &self; }
7759         LDKCVec_PeerDetailsZ* operator ->() { return &self; }
7760         const LDKCVec_PeerDetailsZ* operator &() const { return &self; }
7761         const LDKCVec_PeerDetailsZ* operator ->() const { return &self; }
7762 };
7763 class CResult_u64ShortChannelIdErrorZ {
7764 private:
7765         LDKCResult_u64ShortChannelIdErrorZ self;
7766 public:
7767         CResult_u64ShortChannelIdErrorZ(const CResult_u64ShortChannelIdErrorZ&) = delete;
7768         CResult_u64ShortChannelIdErrorZ(CResult_u64ShortChannelIdErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_u64ShortChannelIdErrorZ)); }
7769         CResult_u64ShortChannelIdErrorZ(LDKCResult_u64ShortChannelIdErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_u64ShortChannelIdErrorZ)); }
7770         operator LDKCResult_u64ShortChannelIdErrorZ() && { LDKCResult_u64ShortChannelIdErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_u64ShortChannelIdErrorZ)); return res; }
7771         ~CResult_u64ShortChannelIdErrorZ() { CResult_u64ShortChannelIdErrorZ_free(self); }
7772         CResult_u64ShortChannelIdErrorZ& operator=(CResult_u64ShortChannelIdErrorZ&& o) { CResult_u64ShortChannelIdErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_u64ShortChannelIdErrorZ)); return *this; }
7773         LDKCResult_u64ShortChannelIdErrorZ* operator &() { return &self; }
7774         LDKCResult_u64ShortChannelIdErrorZ* operator ->() { return &self; }
7775         const LDKCResult_u64ShortChannelIdErrorZ* operator &() const { return &self; }
7776         const LDKCResult_u64ShortChannelIdErrorZ* operator ->() const { return &self; }
7777 };
7778 class CResult_QueryChannelRangeDecodeErrorZ {
7779 private:
7780         LDKCResult_QueryChannelRangeDecodeErrorZ self;
7781 public:
7782         CResult_QueryChannelRangeDecodeErrorZ(const CResult_QueryChannelRangeDecodeErrorZ&) = delete;
7783         CResult_QueryChannelRangeDecodeErrorZ(CResult_QueryChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); }
7784         CResult_QueryChannelRangeDecodeErrorZ(LDKCResult_QueryChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); }
7785         operator LDKCResult_QueryChannelRangeDecodeErrorZ() && { LDKCResult_QueryChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); return res; }
7786         ~CResult_QueryChannelRangeDecodeErrorZ() { CResult_QueryChannelRangeDecodeErrorZ_free(self); }
7787         CResult_QueryChannelRangeDecodeErrorZ& operator=(CResult_QueryChannelRangeDecodeErrorZ&& o) { CResult_QueryChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); return *this; }
7788         LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() { return &self; }
7789         LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() { return &self; }
7790         const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
7791         const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
7792 };
7793 class CVec_InputZ {
7794 private:
7795         LDKCVec_InputZ self;
7796 public:
7797         CVec_InputZ(const CVec_InputZ&) = delete;
7798         CVec_InputZ(CVec_InputZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_InputZ)); }
7799         CVec_InputZ(LDKCVec_InputZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_InputZ)); }
7800         operator LDKCVec_InputZ() && { LDKCVec_InputZ res = self; memset(&self, 0, sizeof(LDKCVec_InputZ)); return res; }
7801         ~CVec_InputZ() { CVec_InputZ_free(self); }
7802         CVec_InputZ& operator=(CVec_InputZ&& o) { CVec_InputZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_InputZ)); return *this; }
7803         LDKCVec_InputZ* operator &() { return &self; }
7804         LDKCVec_InputZ* operator ->() { return &self; }
7805         const LDKCVec_InputZ* operator &() const { return &self; }
7806         const LDKCVec_InputZ* operator ->() const { return &self; }
7807 };
7808 class CResult_ChannelFeaturesDecodeErrorZ {
7809 private:
7810         LDKCResult_ChannelFeaturesDecodeErrorZ self;
7811 public:
7812         CResult_ChannelFeaturesDecodeErrorZ(const CResult_ChannelFeaturesDecodeErrorZ&) = delete;
7813         CResult_ChannelFeaturesDecodeErrorZ(CResult_ChannelFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); }
7814         CResult_ChannelFeaturesDecodeErrorZ(LDKCResult_ChannelFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); }
7815         operator LDKCResult_ChannelFeaturesDecodeErrorZ() && { LDKCResult_ChannelFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); return res; }
7816         ~CResult_ChannelFeaturesDecodeErrorZ() { CResult_ChannelFeaturesDecodeErrorZ_free(self); }
7817         CResult_ChannelFeaturesDecodeErrorZ& operator=(CResult_ChannelFeaturesDecodeErrorZ&& o) { CResult_ChannelFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); return *this; }
7818         LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() { return &self; }
7819         LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() { return &self; }
7820         const LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() const { return &self; }
7821         const LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() const { return &self; }
7822 };
7823 class CResult_ChannelReadyDecodeErrorZ {
7824 private:
7825         LDKCResult_ChannelReadyDecodeErrorZ self;
7826 public:
7827         CResult_ChannelReadyDecodeErrorZ(const CResult_ChannelReadyDecodeErrorZ&) = delete;
7828         CResult_ChannelReadyDecodeErrorZ(CResult_ChannelReadyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelReadyDecodeErrorZ)); }
7829         CResult_ChannelReadyDecodeErrorZ(LDKCResult_ChannelReadyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelReadyDecodeErrorZ)); }
7830         operator LDKCResult_ChannelReadyDecodeErrorZ() && { LDKCResult_ChannelReadyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelReadyDecodeErrorZ)); return res; }
7831         ~CResult_ChannelReadyDecodeErrorZ() { CResult_ChannelReadyDecodeErrorZ_free(self); }
7832         CResult_ChannelReadyDecodeErrorZ& operator=(CResult_ChannelReadyDecodeErrorZ&& o) { CResult_ChannelReadyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelReadyDecodeErrorZ)); return *this; }
7833         LDKCResult_ChannelReadyDecodeErrorZ* operator &() { return &self; }
7834         LDKCResult_ChannelReadyDecodeErrorZ* operator ->() { return &self; }
7835         const LDKCResult_ChannelReadyDecodeErrorZ* operator &() const { return &self; }
7836         const LDKCResult_ChannelReadyDecodeErrorZ* operator ->() const { return &self; }
7837 };
7838 class CVec_TransactionZ {
7839 private:
7840         LDKCVec_TransactionZ self;
7841 public:
7842         CVec_TransactionZ(const CVec_TransactionZ&) = delete;
7843         CVec_TransactionZ(CVec_TransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionZ)); }
7844         CVec_TransactionZ(LDKCVec_TransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionZ)); }
7845         operator LDKCVec_TransactionZ() && { LDKCVec_TransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionZ)); return res; }
7846         ~CVec_TransactionZ() { CVec_TransactionZ_free(self); }
7847         CVec_TransactionZ& operator=(CVec_TransactionZ&& o) { CVec_TransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionZ)); return *this; }
7848         LDKCVec_TransactionZ* operator &() { return &self; }
7849         LDKCVec_TransactionZ* operator ->() { return &self; }
7850         const LDKCVec_TransactionZ* operator &() const { return &self; }
7851         const LDKCVec_TransactionZ* operator ->() const { return &self; }
7852 };
7853 class CResult_UpdateFeeDecodeErrorZ {
7854 private:
7855         LDKCResult_UpdateFeeDecodeErrorZ self;
7856 public:
7857         CResult_UpdateFeeDecodeErrorZ(const CResult_UpdateFeeDecodeErrorZ&) = delete;
7858         CResult_UpdateFeeDecodeErrorZ(CResult_UpdateFeeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); }
7859         CResult_UpdateFeeDecodeErrorZ(LDKCResult_UpdateFeeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); }
7860         operator LDKCResult_UpdateFeeDecodeErrorZ() && { LDKCResult_UpdateFeeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); return res; }
7861         ~CResult_UpdateFeeDecodeErrorZ() { CResult_UpdateFeeDecodeErrorZ_free(self); }
7862         CResult_UpdateFeeDecodeErrorZ& operator=(CResult_UpdateFeeDecodeErrorZ&& o) { CResult_UpdateFeeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); return *this; }
7863         LDKCResult_UpdateFeeDecodeErrorZ* operator &() { return &self; }
7864         LDKCResult_UpdateFeeDecodeErrorZ* operator ->() { return &self; }
7865         const LDKCResult_UpdateFeeDecodeErrorZ* operator &() const { return &self; }
7866         const LDKCResult_UpdateFeeDecodeErrorZ* operator ->() const { return &self; }
7867 };
7868 class CResult_NoneBolt11SemanticErrorZ {
7869 private:
7870         LDKCResult_NoneBolt11SemanticErrorZ self;
7871 public:
7872         CResult_NoneBolt11SemanticErrorZ(const CResult_NoneBolt11SemanticErrorZ&) = delete;
7873         CResult_NoneBolt11SemanticErrorZ(CResult_NoneBolt11SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneBolt11SemanticErrorZ)); }
7874         CResult_NoneBolt11SemanticErrorZ(LDKCResult_NoneBolt11SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneBolt11SemanticErrorZ)); }
7875         operator LDKCResult_NoneBolt11SemanticErrorZ() && { LDKCResult_NoneBolt11SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneBolt11SemanticErrorZ)); return res; }
7876         ~CResult_NoneBolt11SemanticErrorZ() { CResult_NoneBolt11SemanticErrorZ_free(self); }
7877         CResult_NoneBolt11SemanticErrorZ& operator=(CResult_NoneBolt11SemanticErrorZ&& o) { CResult_NoneBolt11SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneBolt11SemanticErrorZ)); return *this; }
7878         LDKCResult_NoneBolt11SemanticErrorZ* operator &() { return &self; }
7879         LDKCResult_NoneBolt11SemanticErrorZ* operator ->() { return &self; }
7880         const LDKCResult_NoneBolt11SemanticErrorZ* operator &() const { return &self; }
7881         const LDKCResult_NoneBolt11SemanticErrorZ* operator ->() const { return &self; }
7882 };
7883 class CResult_RevocationBasepointDecodeErrorZ {
7884 private:
7885         LDKCResult_RevocationBasepointDecodeErrorZ self;
7886 public:
7887         CResult_RevocationBasepointDecodeErrorZ(const CResult_RevocationBasepointDecodeErrorZ&) = delete;
7888         CResult_RevocationBasepointDecodeErrorZ(CResult_RevocationBasepointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevocationBasepointDecodeErrorZ)); }
7889         CResult_RevocationBasepointDecodeErrorZ(LDKCResult_RevocationBasepointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevocationBasepointDecodeErrorZ)); }
7890         operator LDKCResult_RevocationBasepointDecodeErrorZ() && { LDKCResult_RevocationBasepointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevocationBasepointDecodeErrorZ)); return res; }
7891         ~CResult_RevocationBasepointDecodeErrorZ() { CResult_RevocationBasepointDecodeErrorZ_free(self); }
7892         CResult_RevocationBasepointDecodeErrorZ& operator=(CResult_RevocationBasepointDecodeErrorZ&& o) { CResult_RevocationBasepointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevocationBasepointDecodeErrorZ)); return *this; }
7893         LDKCResult_RevocationBasepointDecodeErrorZ* operator &() { return &self; }
7894         LDKCResult_RevocationBasepointDecodeErrorZ* operator ->() { return &self; }
7895         const LDKCResult_RevocationBasepointDecodeErrorZ* operator &() const { return &self; }
7896         const LDKCResult_RevocationBasepointDecodeErrorZ* operator ->() const { return &self; }
7897 };
7898 class COption_OnionMessageContentsZ {
7899 private:
7900         LDKCOption_OnionMessageContentsZ self;
7901 public:
7902         COption_OnionMessageContentsZ(const COption_OnionMessageContentsZ&) = delete;
7903         COption_OnionMessageContentsZ(COption_OnionMessageContentsZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_OnionMessageContentsZ)); }
7904         COption_OnionMessageContentsZ(LDKCOption_OnionMessageContentsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_OnionMessageContentsZ)); }
7905         operator LDKCOption_OnionMessageContentsZ() && { LDKCOption_OnionMessageContentsZ res = self; memset(&self, 0, sizeof(LDKCOption_OnionMessageContentsZ)); return res; }
7906         ~COption_OnionMessageContentsZ() { COption_OnionMessageContentsZ_free(self); }
7907         COption_OnionMessageContentsZ& operator=(COption_OnionMessageContentsZ&& o) { COption_OnionMessageContentsZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_OnionMessageContentsZ)); return *this; }
7908         LDKCOption_OnionMessageContentsZ* operator &() { return &self; }
7909         LDKCOption_OnionMessageContentsZ* operator ->() { return &self; }
7910         const LDKCOption_OnionMessageContentsZ* operator &() const { return &self; }
7911         const LDKCOption_OnionMessageContentsZ* operator ->() const { return &self; }
7912 };
7913 class CResult_NoneRetryableSendFailureZ {
7914 private:
7915         LDKCResult_NoneRetryableSendFailureZ self;
7916 public:
7917         CResult_NoneRetryableSendFailureZ(const CResult_NoneRetryableSendFailureZ&) = delete;
7918         CResult_NoneRetryableSendFailureZ(CResult_NoneRetryableSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneRetryableSendFailureZ)); }
7919         CResult_NoneRetryableSendFailureZ(LDKCResult_NoneRetryableSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneRetryableSendFailureZ)); }
7920         operator LDKCResult_NoneRetryableSendFailureZ() && { LDKCResult_NoneRetryableSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneRetryableSendFailureZ)); return res; }
7921         ~CResult_NoneRetryableSendFailureZ() { CResult_NoneRetryableSendFailureZ_free(self); }
7922         CResult_NoneRetryableSendFailureZ& operator=(CResult_NoneRetryableSendFailureZ&& o) { CResult_NoneRetryableSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneRetryableSendFailureZ)); return *this; }
7923         LDKCResult_NoneRetryableSendFailureZ* operator &() { return &self; }
7924         LDKCResult_NoneRetryableSendFailureZ* operator ->() { return &self; }
7925         const LDKCResult_NoneRetryableSendFailureZ* operator &() const { return &self; }
7926         const LDKCResult_NoneRetryableSendFailureZ* operator ->() const { return &self; }
7927 };
7928 class CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ {
7929 private:
7930         LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ self;
7931 public:
7932         CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ(const CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ&) = delete;
7933         CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ(CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ)); }
7934         CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ(LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ)); }
7935         operator LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ() && { LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ)); return res; }
7936         ~CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ() { CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_free(self); }
7937         CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ& operator=(CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ&& o) { CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ)); return *this; }
7938         LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator &() { return &self; }
7939         LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator ->() { return &self; }
7940         const LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator &() const { return &self; }
7941         const LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator ->() const { return &self; }
7942 };
7943 class CResult_NodeIdDecodeErrorZ {
7944 private:
7945         LDKCResult_NodeIdDecodeErrorZ self;
7946 public:
7947         CResult_NodeIdDecodeErrorZ(const CResult_NodeIdDecodeErrorZ&) = delete;
7948         CResult_NodeIdDecodeErrorZ(CResult_NodeIdDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); }
7949         CResult_NodeIdDecodeErrorZ(LDKCResult_NodeIdDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); }
7950         operator LDKCResult_NodeIdDecodeErrorZ() && { LDKCResult_NodeIdDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); return res; }
7951         ~CResult_NodeIdDecodeErrorZ() { CResult_NodeIdDecodeErrorZ_free(self); }
7952         CResult_NodeIdDecodeErrorZ& operator=(CResult_NodeIdDecodeErrorZ&& o) { CResult_NodeIdDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); return *this; }
7953         LDKCResult_NodeIdDecodeErrorZ* operator &() { return &self; }
7954         LDKCResult_NodeIdDecodeErrorZ* operator ->() { return &self; }
7955         const LDKCResult_NodeIdDecodeErrorZ* operator &() const { return &self; }
7956         const LDKCResult_NodeIdDecodeErrorZ* operator ->() const { return &self; }
7957 };
7958 class CResult_boolLightningErrorZ {
7959 private:
7960         LDKCResult_boolLightningErrorZ self;
7961 public:
7962         CResult_boolLightningErrorZ(const CResult_boolLightningErrorZ&) = delete;
7963         CResult_boolLightningErrorZ(CResult_boolLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); }
7964         CResult_boolLightningErrorZ(LDKCResult_boolLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolLightningErrorZ)); }
7965         operator LDKCResult_boolLightningErrorZ() && { LDKCResult_boolLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolLightningErrorZ)); return res; }
7966         ~CResult_boolLightningErrorZ() { CResult_boolLightningErrorZ_free(self); }
7967         CResult_boolLightningErrorZ& operator=(CResult_boolLightningErrorZ&& o) { CResult_boolLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); return *this; }
7968         LDKCResult_boolLightningErrorZ* operator &() { return &self; }
7969         LDKCResult_boolLightningErrorZ* operator ->() { return &self; }
7970         const LDKCResult_boolLightningErrorZ* operator &() const { return &self; }
7971         const LDKCResult_boolLightningErrorZ* operator ->() const { return &self; }
7972 };
7973 class CResult_ChannelShutdownStateDecodeErrorZ {
7974 private:
7975         LDKCResult_ChannelShutdownStateDecodeErrorZ self;
7976 public:
7977         CResult_ChannelShutdownStateDecodeErrorZ(const CResult_ChannelShutdownStateDecodeErrorZ&) = delete;
7978         CResult_ChannelShutdownStateDecodeErrorZ(CResult_ChannelShutdownStateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelShutdownStateDecodeErrorZ)); }
7979         CResult_ChannelShutdownStateDecodeErrorZ(LDKCResult_ChannelShutdownStateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelShutdownStateDecodeErrorZ)); }
7980         operator LDKCResult_ChannelShutdownStateDecodeErrorZ() && { LDKCResult_ChannelShutdownStateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelShutdownStateDecodeErrorZ)); return res; }
7981         ~CResult_ChannelShutdownStateDecodeErrorZ() { CResult_ChannelShutdownStateDecodeErrorZ_free(self); }
7982         CResult_ChannelShutdownStateDecodeErrorZ& operator=(CResult_ChannelShutdownStateDecodeErrorZ&& o) { CResult_ChannelShutdownStateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelShutdownStateDecodeErrorZ)); return *this; }
7983         LDKCResult_ChannelShutdownStateDecodeErrorZ* operator &() { return &self; }
7984         LDKCResult_ChannelShutdownStateDecodeErrorZ* operator ->() { return &self; }
7985         const LDKCResult_ChannelShutdownStateDecodeErrorZ* operator &() const { return &self; }
7986         const LDKCResult_ChannelShutdownStateDecodeErrorZ* operator ->() const { return &self; }
7987 };
7988 class CResult_NodeAnnouncementInfoDecodeErrorZ {
7989 private:
7990         LDKCResult_NodeAnnouncementInfoDecodeErrorZ self;
7991 public:
7992         CResult_NodeAnnouncementInfoDecodeErrorZ(const CResult_NodeAnnouncementInfoDecodeErrorZ&) = delete;
7993         CResult_NodeAnnouncementInfoDecodeErrorZ(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); }
7994         CResult_NodeAnnouncementInfoDecodeErrorZ(LDKCResult_NodeAnnouncementInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); }
7995         operator LDKCResult_NodeAnnouncementInfoDecodeErrorZ() && { LDKCResult_NodeAnnouncementInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); return res; }
7996         ~CResult_NodeAnnouncementInfoDecodeErrorZ() { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); }
7997         CResult_NodeAnnouncementInfoDecodeErrorZ& operator=(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); return *this; }
7998         LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() { return &self; }
7999         LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() { return &self; }
8000         const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() const { return &self; }
8001         const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() const { return &self; }
8002 };
8003 class CResult_InvoiceRequestBolt12SemanticErrorZ {
8004 private:
8005         LDKCResult_InvoiceRequestBolt12SemanticErrorZ self;
8006 public:
8007         CResult_InvoiceRequestBolt12SemanticErrorZ(const CResult_InvoiceRequestBolt12SemanticErrorZ&) = delete;
8008         CResult_InvoiceRequestBolt12SemanticErrorZ(CResult_InvoiceRequestBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceRequestBolt12SemanticErrorZ)); }
8009         CResult_InvoiceRequestBolt12SemanticErrorZ(LDKCResult_InvoiceRequestBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceRequestBolt12SemanticErrorZ)); }
8010         operator LDKCResult_InvoiceRequestBolt12SemanticErrorZ() && { LDKCResult_InvoiceRequestBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceRequestBolt12SemanticErrorZ)); return res; }
8011         ~CResult_InvoiceRequestBolt12SemanticErrorZ() { CResult_InvoiceRequestBolt12SemanticErrorZ_free(self); }
8012         CResult_InvoiceRequestBolt12SemanticErrorZ& operator=(CResult_InvoiceRequestBolt12SemanticErrorZ&& o) { CResult_InvoiceRequestBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceRequestBolt12SemanticErrorZ)); return *this; }
8013         LDKCResult_InvoiceRequestBolt12SemanticErrorZ* operator &() { return &self; }
8014         LDKCResult_InvoiceRequestBolt12SemanticErrorZ* operator ->() { return &self; }
8015         const LDKCResult_InvoiceRequestBolt12SemanticErrorZ* operator &() const { return &self; }
8016         const LDKCResult_InvoiceRequestBolt12SemanticErrorZ* operator ->() const { return &self; }
8017 };
8018 class CResult_COption_NetworkUpdateZDecodeErrorZ {
8019 private:
8020         LDKCResult_COption_NetworkUpdateZDecodeErrorZ self;
8021 public:
8022         CResult_COption_NetworkUpdateZDecodeErrorZ(const CResult_COption_NetworkUpdateZDecodeErrorZ&) = delete;
8023         CResult_COption_NetworkUpdateZDecodeErrorZ(CResult_COption_NetworkUpdateZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_NetworkUpdateZDecodeErrorZ)); }
8024         CResult_COption_NetworkUpdateZDecodeErrorZ(LDKCResult_COption_NetworkUpdateZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); }
8025         operator LDKCResult_COption_NetworkUpdateZDecodeErrorZ() && { LDKCResult_COption_NetworkUpdateZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); return res; }
8026         ~CResult_COption_NetworkUpdateZDecodeErrorZ() { CResult_COption_NetworkUpdateZDecodeErrorZ_free(self); }
8027         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; }
8028         LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() { return &self; }
8029         LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() { return &self; }
8030         const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() const { return &self; }
8031         const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() const { return &self; }
8032 };
8033 class CVec_UpdateFailMalformedHTLCZ {
8034 private:
8035         LDKCVec_UpdateFailMalformedHTLCZ self;
8036 public:
8037         CVec_UpdateFailMalformedHTLCZ(const CVec_UpdateFailMalformedHTLCZ&) = delete;
8038         CVec_UpdateFailMalformedHTLCZ(CVec_UpdateFailMalformedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); }
8039         CVec_UpdateFailMalformedHTLCZ(LDKCVec_UpdateFailMalformedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); }
8040         operator LDKCVec_UpdateFailMalformedHTLCZ() && { LDKCVec_UpdateFailMalformedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); return res; }
8041         ~CVec_UpdateFailMalformedHTLCZ() { CVec_UpdateFailMalformedHTLCZ_free(self); }
8042         CVec_UpdateFailMalformedHTLCZ& operator=(CVec_UpdateFailMalformedHTLCZ&& o) { CVec_UpdateFailMalformedHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); return *this; }
8043         LDKCVec_UpdateFailMalformedHTLCZ* operator &() { return &self; }
8044         LDKCVec_UpdateFailMalformedHTLCZ* operator ->() { return &self; }
8045         const LDKCVec_UpdateFailMalformedHTLCZ* operator &() const { return &self; }
8046         const LDKCVec_UpdateFailMalformedHTLCZ* operator ->() const { return &self; }
8047 };
8048 class CResult_ShutdownScriptNoneZ {
8049 private:
8050         LDKCResult_ShutdownScriptNoneZ self;
8051 public:
8052         CResult_ShutdownScriptNoneZ(const CResult_ShutdownScriptNoneZ&) = delete;
8053         CResult_ShutdownScriptNoneZ(CResult_ShutdownScriptNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptNoneZ)); }
8054         CResult_ShutdownScriptNoneZ(LDKCResult_ShutdownScriptNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptNoneZ)); }
8055         operator LDKCResult_ShutdownScriptNoneZ() && { LDKCResult_ShutdownScriptNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptNoneZ)); return res; }
8056         ~CResult_ShutdownScriptNoneZ() { CResult_ShutdownScriptNoneZ_free(self); }
8057         CResult_ShutdownScriptNoneZ& operator=(CResult_ShutdownScriptNoneZ&& o) { CResult_ShutdownScriptNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptNoneZ)); return *this; }
8058         LDKCResult_ShutdownScriptNoneZ* operator &() { return &self; }
8059         LDKCResult_ShutdownScriptNoneZ* operator ->() { return &self; }
8060         const LDKCResult_ShutdownScriptNoneZ* operator &() const { return &self; }
8061         const LDKCResult_ShutdownScriptNoneZ* operator ->() const { return &self; }
8062 };
8063 class CResult_PendingHTLCInfoInboundHTLCErrZ {
8064 private:
8065         LDKCResult_PendingHTLCInfoInboundHTLCErrZ self;
8066 public:
8067         CResult_PendingHTLCInfoInboundHTLCErrZ(const CResult_PendingHTLCInfoInboundHTLCErrZ&) = delete;
8068         CResult_PendingHTLCInfoInboundHTLCErrZ(CResult_PendingHTLCInfoInboundHTLCErrZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PendingHTLCInfoInboundHTLCErrZ)); }
8069         CResult_PendingHTLCInfoInboundHTLCErrZ(LDKCResult_PendingHTLCInfoInboundHTLCErrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PendingHTLCInfoInboundHTLCErrZ)); }
8070         operator LDKCResult_PendingHTLCInfoInboundHTLCErrZ() && { LDKCResult_PendingHTLCInfoInboundHTLCErrZ res = self; memset(&self, 0, sizeof(LDKCResult_PendingHTLCInfoInboundHTLCErrZ)); return res; }
8071         ~CResult_PendingHTLCInfoInboundHTLCErrZ() { CResult_PendingHTLCInfoInboundHTLCErrZ_free(self); }
8072         CResult_PendingHTLCInfoInboundHTLCErrZ& operator=(CResult_PendingHTLCInfoInboundHTLCErrZ&& o) { CResult_PendingHTLCInfoInboundHTLCErrZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PendingHTLCInfoInboundHTLCErrZ)); return *this; }
8073         LDKCResult_PendingHTLCInfoInboundHTLCErrZ* operator &() { return &self; }
8074         LDKCResult_PendingHTLCInfoInboundHTLCErrZ* operator ->() { return &self; }
8075         const LDKCResult_PendingHTLCInfoInboundHTLCErrZ* operator &() const { return &self; }
8076         const LDKCResult_PendingHTLCInfoInboundHTLCErrZ* operator ->() const { return &self; }
8077 };
8078 class CResult_PendingHTLCInfoDecodeErrorZ {
8079 private:
8080         LDKCResult_PendingHTLCInfoDecodeErrorZ self;
8081 public:
8082         CResult_PendingHTLCInfoDecodeErrorZ(const CResult_PendingHTLCInfoDecodeErrorZ&) = delete;
8083         CResult_PendingHTLCInfoDecodeErrorZ(CResult_PendingHTLCInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PendingHTLCInfoDecodeErrorZ)); }
8084         CResult_PendingHTLCInfoDecodeErrorZ(LDKCResult_PendingHTLCInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PendingHTLCInfoDecodeErrorZ)); }
8085         operator LDKCResult_PendingHTLCInfoDecodeErrorZ() && { LDKCResult_PendingHTLCInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PendingHTLCInfoDecodeErrorZ)); return res; }
8086         ~CResult_PendingHTLCInfoDecodeErrorZ() { CResult_PendingHTLCInfoDecodeErrorZ_free(self); }
8087         CResult_PendingHTLCInfoDecodeErrorZ& operator=(CResult_PendingHTLCInfoDecodeErrorZ&& o) { CResult_PendingHTLCInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PendingHTLCInfoDecodeErrorZ)); return *this; }
8088         LDKCResult_PendingHTLCInfoDecodeErrorZ* operator &() { return &self; }
8089         LDKCResult_PendingHTLCInfoDecodeErrorZ* operator ->() { return &self; }
8090         const LDKCResult_PendingHTLCInfoDecodeErrorZ* operator &() const { return &self; }
8091         const LDKCResult_PendingHTLCInfoDecodeErrorZ* operator ->() const { return &self; }
8092 };
8093 class CResult_HTLCOutputInCommitmentDecodeErrorZ {
8094 private:
8095         LDKCResult_HTLCOutputInCommitmentDecodeErrorZ self;
8096 public:
8097         CResult_HTLCOutputInCommitmentDecodeErrorZ(const CResult_HTLCOutputInCommitmentDecodeErrorZ&) = delete;
8098         CResult_HTLCOutputInCommitmentDecodeErrorZ(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); }
8099         CResult_HTLCOutputInCommitmentDecodeErrorZ(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); }
8100         operator LDKCResult_HTLCOutputInCommitmentDecodeErrorZ() && { LDKCResult_HTLCOutputInCommitmentDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); return res; }
8101         ~CResult_HTLCOutputInCommitmentDecodeErrorZ() { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); }
8102         CResult_HTLCOutputInCommitmentDecodeErrorZ& operator=(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); return *this; }
8103         LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() { return &self; }
8104         LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() { return &self; }
8105         const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() const { return &self; }
8106         const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() const { return &self; }
8107 };
8108 class CResult_ShutdownScriptInvalidShutdownScriptZ {
8109 private:
8110         LDKCResult_ShutdownScriptInvalidShutdownScriptZ self;
8111 public:
8112         CResult_ShutdownScriptInvalidShutdownScriptZ(const CResult_ShutdownScriptInvalidShutdownScriptZ&) = delete;
8113         CResult_ShutdownScriptInvalidShutdownScriptZ(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); }
8114         CResult_ShutdownScriptInvalidShutdownScriptZ(LDKCResult_ShutdownScriptInvalidShutdownScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); }
8115         operator LDKCResult_ShutdownScriptInvalidShutdownScriptZ() && { LDKCResult_ShutdownScriptInvalidShutdownScriptZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); return res; }
8116         ~CResult_ShutdownScriptInvalidShutdownScriptZ() { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); }
8117         CResult_ShutdownScriptInvalidShutdownScriptZ& operator=(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); return *this; }
8118         LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() { return &self; }
8119         LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() { return &self; }
8120         const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() const { return &self; }
8121         const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() const { return &self; }
8122 };
8123 class COption_HTLCDestinationZ {
8124 private:
8125         LDKCOption_HTLCDestinationZ self;
8126 public:
8127         COption_HTLCDestinationZ(const COption_HTLCDestinationZ&) = delete;
8128         COption_HTLCDestinationZ(COption_HTLCDestinationZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_HTLCDestinationZ)); }
8129         COption_HTLCDestinationZ(LDKCOption_HTLCDestinationZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_HTLCDestinationZ)); }
8130         operator LDKCOption_HTLCDestinationZ() && { LDKCOption_HTLCDestinationZ res = self; memset(&self, 0, sizeof(LDKCOption_HTLCDestinationZ)); return res; }
8131         ~COption_HTLCDestinationZ() { COption_HTLCDestinationZ_free(self); }
8132         COption_HTLCDestinationZ& operator=(COption_HTLCDestinationZ&& o) { COption_HTLCDestinationZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_HTLCDestinationZ)); return *this; }
8133         LDKCOption_HTLCDestinationZ* operator &() { return &self; }
8134         LDKCOption_HTLCDestinationZ* operator ->() { return &self; }
8135         const LDKCOption_HTLCDestinationZ* operator &() const { return &self; }
8136         const LDKCOption_HTLCDestinationZ* operator ->() const { return &self; }
8137 };
8138 class CVec_RouteHopZ {
8139 private:
8140         LDKCVec_RouteHopZ self;
8141 public:
8142         CVec_RouteHopZ(const CVec_RouteHopZ&) = delete;
8143         CVec_RouteHopZ(CVec_RouteHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHopZ)); }
8144         CVec_RouteHopZ(LDKCVec_RouteHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHopZ)); }
8145         operator LDKCVec_RouteHopZ() && { LDKCVec_RouteHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHopZ)); return res; }
8146         ~CVec_RouteHopZ() { CVec_RouteHopZ_free(self); }
8147         CVec_RouteHopZ& operator=(CVec_RouteHopZ&& o) { CVec_RouteHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHopZ)); return *this; }
8148         LDKCVec_RouteHopZ* operator &() { return &self; }
8149         LDKCVec_RouteHopZ* operator ->() { return &self; }
8150         const LDKCVec_RouteHopZ* operator &() const { return &self; }
8151         const LDKCVec_RouteHopZ* operator ->() const { return &self; }
8152 };
8153 class C2Tuple_PublicKeyCVec_SocketAddressZZ {
8154 private:
8155         LDKC2Tuple_PublicKeyCVec_SocketAddressZZ self;
8156 public:
8157         C2Tuple_PublicKeyCVec_SocketAddressZZ(const C2Tuple_PublicKeyCVec_SocketAddressZZ&) = delete;
8158         C2Tuple_PublicKeyCVec_SocketAddressZZ(C2Tuple_PublicKeyCVec_SocketAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyCVec_SocketAddressZZ)); }
8159         C2Tuple_PublicKeyCVec_SocketAddressZZ(LDKC2Tuple_PublicKeyCVec_SocketAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyCVec_SocketAddressZZ)); }
8160         operator LDKC2Tuple_PublicKeyCVec_SocketAddressZZ() && { LDKC2Tuple_PublicKeyCVec_SocketAddressZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyCVec_SocketAddressZZ)); return res; }
8161         ~C2Tuple_PublicKeyCVec_SocketAddressZZ() { C2Tuple_PublicKeyCVec_SocketAddressZZ_free(self); }
8162         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; }
8163         LDKC2Tuple_PublicKeyCVec_SocketAddressZZ* operator &() { return &self; }
8164         LDKC2Tuple_PublicKeyCVec_SocketAddressZZ* operator ->() { return &self; }
8165         const LDKC2Tuple_PublicKeyCVec_SocketAddressZZ* operator &() const { return &self; }
8166         const LDKC2Tuple_PublicKeyCVec_SocketAddressZZ* operator ->() const { return &self; }
8167 };
8168 class CResult_CVec_UtxoZNoneZ {
8169 private:
8170         LDKCResult_CVec_UtxoZNoneZ self;
8171 public:
8172         CResult_CVec_UtxoZNoneZ(const CResult_CVec_UtxoZNoneZ&) = delete;
8173         CResult_CVec_UtxoZNoneZ(CResult_CVec_UtxoZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_UtxoZNoneZ)); }
8174         CResult_CVec_UtxoZNoneZ(LDKCResult_CVec_UtxoZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_UtxoZNoneZ)); }
8175         operator LDKCResult_CVec_UtxoZNoneZ() && { LDKCResult_CVec_UtxoZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_UtxoZNoneZ)); return res; }
8176         ~CResult_CVec_UtxoZNoneZ() { CResult_CVec_UtxoZNoneZ_free(self); }
8177         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; }
8178         LDKCResult_CVec_UtxoZNoneZ* operator &() { return &self; }
8179         LDKCResult_CVec_UtxoZNoneZ* operator ->() { return &self; }
8180         const LDKCResult_CVec_UtxoZNoneZ* operator &() const { return &self; }
8181         const LDKCResult_CVec_UtxoZNoneZ* operator ->() const { return &self; }
8182 };
8183 class CResult_CVec_u8ZIOErrorZ {
8184 private:
8185         LDKCResult_CVec_u8ZIOErrorZ self;
8186 public:
8187         CResult_CVec_u8ZIOErrorZ(const CResult_CVec_u8ZIOErrorZ&) = delete;
8188         CResult_CVec_u8ZIOErrorZ(CResult_CVec_u8ZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZIOErrorZ)); }
8189         CResult_CVec_u8ZIOErrorZ(LDKCResult_CVec_u8ZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZIOErrorZ)); }
8190         operator LDKCResult_CVec_u8ZIOErrorZ() && { LDKCResult_CVec_u8ZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZIOErrorZ)); return res; }
8191         ~CResult_CVec_u8ZIOErrorZ() { CResult_CVec_u8ZIOErrorZ_free(self); }
8192         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; }
8193         LDKCResult_CVec_u8ZIOErrorZ* operator &() { return &self; }
8194         LDKCResult_CVec_u8ZIOErrorZ* operator ->() { return &self; }
8195         const LDKCResult_CVec_u8ZIOErrorZ* operator &() const { return &self; }
8196         const LDKCResult_CVec_u8ZIOErrorZ* operator ->() const { return &self; }
8197 };
8198 class CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ {
8199 private:
8200         LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ self;
8201 public:
8202         CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ(const CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ&) = delete;
8203         CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ(CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ)); }
8204         CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ)); }
8205         operator LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ() && { LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ)); return res; }
8206         ~CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ() { CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_free(self); }
8207         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; }
8208         LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ* operator &() { return &self; }
8209         LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ* operator ->() { return &self; }
8210         const LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ* operator &() const { return &self; }
8211         const LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ* operator ->() const { return &self; }
8212 };
8213 class CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ {
8214 private:
8215         LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ self;
8216 public:
8217         CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ(const CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ&) = delete;
8218         CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ(CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ)); }
8219         CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ(LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ)); }
8220         operator LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ() && { LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ)); return res; }
8221         ~CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ() { CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_free(self); }
8222         CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ& operator=(CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ&& o) { CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ)); return *this; }
8223         LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ* operator &() { return &self; }
8224         LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ* operator ->() { return &self; }
8225         const LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ* operator &() const { return &self; }
8226         const LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ* operator ->() const { return &self; }
8227 };
8228 class CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ {
8229 private:
8230         LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ self;
8231 public:
8232         CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(const CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&) = delete;
8233         CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); }
8234         CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); }
8235         operator LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ() && { LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); return res; }
8236         ~CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ() { CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(self); }
8237         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; }
8238         LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator &() { return &self; }
8239         LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator ->() { return &self; }
8240         const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator &() const { return &self; }
8241         const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator ->() const { return &self; }
8242 };
8243 class C3Tuple_OffersMessageDestinationBlindedPathZ {
8244 private:
8245         LDKC3Tuple_OffersMessageDestinationBlindedPathZ self;
8246 public:
8247         C3Tuple_OffersMessageDestinationBlindedPathZ(const C3Tuple_OffersMessageDestinationBlindedPathZ&) = delete;
8248         C3Tuple_OffersMessageDestinationBlindedPathZ(C3Tuple_OffersMessageDestinationBlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_OffersMessageDestinationBlindedPathZ)); }
8249         C3Tuple_OffersMessageDestinationBlindedPathZ(LDKC3Tuple_OffersMessageDestinationBlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_OffersMessageDestinationBlindedPathZ)); }
8250         operator LDKC3Tuple_OffersMessageDestinationBlindedPathZ() && { LDKC3Tuple_OffersMessageDestinationBlindedPathZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_OffersMessageDestinationBlindedPathZ)); return res; }
8251         ~C3Tuple_OffersMessageDestinationBlindedPathZ() { C3Tuple_OffersMessageDestinationBlindedPathZ_free(self); }
8252         C3Tuple_OffersMessageDestinationBlindedPathZ& operator=(C3Tuple_OffersMessageDestinationBlindedPathZ&& o) { C3Tuple_OffersMessageDestinationBlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_OffersMessageDestinationBlindedPathZ)); return *this; }
8253         LDKC3Tuple_OffersMessageDestinationBlindedPathZ* operator &() { return &self; }
8254         LDKC3Tuple_OffersMessageDestinationBlindedPathZ* operator ->() { return &self; }
8255         const LDKC3Tuple_OffersMessageDestinationBlindedPathZ* operator &() const { return &self; }
8256         const LDKC3Tuple_OffersMessageDestinationBlindedPathZ* operator ->() const { return &self; }
8257 };
8258 class CVec_ThirtyTwoBytesZ {
8259 private:
8260         LDKCVec_ThirtyTwoBytesZ self;
8261 public:
8262         CVec_ThirtyTwoBytesZ(const CVec_ThirtyTwoBytesZ&) = delete;
8263         CVec_ThirtyTwoBytesZ(CVec_ThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); }
8264         CVec_ThirtyTwoBytesZ(LDKCVec_ThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); }
8265         operator LDKCVec_ThirtyTwoBytesZ() && { LDKCVec_ThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); return res; }
8266         ~CVec_ThirtyTwoBytesZ() { CVec_ThirtyTwoBytesZ_free(self); }
8267         CVec_ThirtyTwoBytesZ& operator=(CVec_ThirtyTwoBytesZ&& o) { CVec_ThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); return *this; }
8268         LDKCVec_ThirtyTwoBytesZ* operator &() { return &self; }
8269         LDKCVec_ThirtyTwoBytesZ* operator ->() { return &self; }
8270         const LDKCVec_ThirtyTwoBytesZ* operator &() const { return &self; }
8271         const LDKCVec_ThirtyTwoBytesZ* operator ->() const { return &self; }
8272 };
8273 class CResult_ChannelMonitorUpdateStatusNoneZ {
8274 private:
8275         LDKCResult_ChannelMonitorUpdateStatusNoneZ self;
8276 public:
8277         CResult_ChannelMonitorUpdateStatusNoneZ(const CResult_ChannelMonitorUpdateStatusNoneZ&) = delete;
8278         CResult_ChannelMonitorUpdateStatusNoneZ(CResult_ChannelMonitorUpdateStatusNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateStatusNoneZ)); }
8279         CResult_ChannelMonitorUpdateStatusNoneZ(LDKCResult_ChannelMonitorUpdateStatusNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateStatusNoneZ)); }
8280         operator LDKCResult_ChannelMonitorUpdateStatusNoneZ() && { LDKCResult_ChannelMonitorUpdateStatusNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateStatusNoneZ)); return res; }
8281         ~CResult_ChannelMonitorUpdateStatusNoneZ() { CResult_ChannelMonitorUpdateStatusNoneZ_free(self); }
8282         CResult_ChannelMonitorUpdateStatusNoneZ& operator=(CResult_ChannelMonitorUpdateStatusNoneZ&& o) { CResult_ChannelMonitorUpdateStatusNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateStatusNoneZ)); return *this; }
8283         LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator &() { return &self; }
8284         LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator ->() { return &self; }
8285         const LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator &() const { return &self; }
8286         const LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator ->() const { return &self; }
8287 };
8288 class CResult_ClosingSignedDecodeErrorZ {
8289 private:
8290         LDKCResult_ClosingSignedDecodeErrorZ self;
8291 public:
8292         CResult_ClosingSignedDecodeErrorZ(const CResult_ClosingSignedDecodeErrorZ&) = delete;
8293         CResult_ClosingSignedDecodeErrorZ(CResult_ClosingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); }
8294         CResult_ClosingSignedDecodeErrorZ(LDKCResult_ClosingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); }
8295         operator LDKCResult_ClosingSignedDecodeErrorZ() && { LDKCResult_ClosingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); return res; }
8296         ~CResult_ClosingSignedDecodeErrorZ() { CResult_ClosingSignedDecodeErrorZ_free(self); }
8297         CResult_ClosingSignedDecodeErrorZ& operator=(CResult_ClosingSignedDecodeErrorZ&& o) { CResult_ClosingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); return *this; }
8298         LDKCResult_ClosingSignedDecodeErrorZ* operator &() { return &self; }
8299         LDKCResult_ClosingSignedDecodeErrorZ* operator ->() { return &self; }
8300         const LDKCResult_ClosingSignedDecodeErrorZ* operator &() const { return &self; }
8301         const LDKCResult_ClosingSignedDecodeErrorZ* operator ->() const { return &self; }
8302 };
8303 class CVec_CResult_NoneAPIErrorZZ {
8304 private:
8305         LDKCVec_CResult_NoneAPIErrorZZ self;
8306 public:
8307         CVec_CResult_NoneAPIErrorZZ(const CVec_CResult_NoneAPIErrorZZ&) = delete;
8308         CVec_CResult_NoneAPIErrorZZ(CVec_CResult_NoneAPIErrorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CResult_NoneAPIErrorZZ)); }
8309         CVec_CResult_NoneAPIErrorZZ(LDKCVec_CResult_NoneAPIErrorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); }
8310         operator LDKCVec_CResult_NoneAPIErrorZZ() && { LDKCVec_CResult_NoneAPIErrorZZ res = self; memset(&self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); return res; }
8311         ~CVec_CResult_NoneAPIErrorZZ() { CVec_CResult_NoneAPIErrorZZ_free(self); }
8312         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; }
8313         LDKCVec_CResult_NoneAPIErrorZZ* operator &() { return &self; }
8314         LDKCVec_CResult_NoneAPIErrorZZ* operator ->() { return &self; }
8315         const LDKCVec_CResult_NoneAPIErrorZZ* operator &() const { return &self; }
8316         const LDKCVec_CResult_NoneAPIErrorZZ* operator ->() const { return &self; }
8317 };
8318 class CResult_SchnorrSignatureNoneZ {
8319 private:
8320         LDKCResult_SchnorrSignatureNoneZ self;
8321 public:
8322         CResult_SchnorrSignatureNoneZ(const CResult_SchnorrSignatureNoneZ&) = delete;
8323         CResult_SchnorrSignatureNoneZ(CResult_SchnorrSignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SchnorrSignatureNoneZ)); }
8324         CResult_SchnorrSignatureNoneZ(LDKCResult_SchnorrSignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SchnorrSignatureNoneZ)); }
8325         operator LDKCResult_SchnorrSignatureNoneZ() && { LDKCResult_SchnorrSignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SchnorrSignatureNoneZ)); return res; }
8326         ~CResult_SchnorrSignatureNoneZ() { CResult_SchnorrSignatureNoneZ_free(self); }
8327         CResult_SchnorrSignatureNoneZ& operator=(CResult_SchnorrSignatureNoneZ&& o) { CResult_SchnorrSignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SchnorrSignatureNoneZ)); return *this; }
8328         LDKCResult_SchnorrSignatureNoneZ* operator &() { return &self; }
8329         LDKCResult_SchnorrSignatureNoneZ* operator ->() { return &self; }
8330         const LDKCResult_SchnorrSignatureNoneZ* operator &() const { return &self; }
8331         const LDKCResult_SchnorrSignatureNoneZ* operator ->() const { return &self; }
8332 };
8333 class CResult_CounterpartyCommitmentSecretsDecodeErrorZ {
8334 private:
8335         LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ self;
8336 public:
8337         CResult_CounterpartyCommitmentSecretsDecodeErrorZ(const CResult_CounterpartyCommitmentSecretsDecodeErrorZ&) = delete;
8338         CResult_CounterpartyCommitmentSecretsDecodeErrorZ(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
8339         CResult_CounterpartyCommitmentSecretsDecodeErrorZ(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
8340         operator LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ() && { LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return res; }
8341         ~CResult_CounterpartyCommitmentSecretsDecodeErrorZ() { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); }
8342         CResult_CounterpartyCommitmentSecretsDecodeErrorZ& operator=(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return *this; }
8343         LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() { return &self; }
8344         LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() { return &self; }
8345         const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() const { return &self; }
8346         const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() const { return &self; }
8347 };
8348 class CResult_HTLCDescriptorDecodeErrorZ {
8349 private:
8350         LDKCResult_HTLCDescriptorDecodeErrorZ self;
8351 public:
8352         CResult_HTLCDescriptorDecodeErrorZ(const CResult_HTLCDescriptorDecodeErrorZ&) = delete;
8353         CResult_HTLCDescriptorDecodeErrorZ(CResult_HTLCDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCDescriptorDecodeErrorZ)); }
8354         CResult_HTLCDescriptorDecodeErrorZ(LDKCResult_HTLCDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCDescriptorDecodeErrorZ)); }
8355         operator LDKCResult_HTLCDescriptorDecodeErrorZ() && { LDKCResult_HTLCDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCDescriptorDecodeErrorZ)); return res; }
8356         ~CResult_HTLCDescriptorDecodeErrorZ() { CResult_HTLCDescriptorDecodeErrorZ_free(self); }
8357         CResult_HTLCDescriptorDecodeErrorZ& operator=(CResult_HTLCDescriptorDecodeErrorZ&& o) { CResult_HTLCDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCDescriptorDecodeErrorZ)); return *this; }
8358         LDKCResult_HTLCDescriptorDecodeErrorZ* operator &() { return &self; }
8359         LDKCResult_HTLCDescriptorDecodeErrorZ* operator ->() { return &self; }
8360         const LDKCResult_HTLCDescriptorDecodeErrorZ* operator &() const { return &self; }
8361         const LDKCResult_HTLCDescriptorDecodeErrorZ* operator ->() const { return &self; }
8362 };
8363 class CVec_RecentPaymentDetailsZ {
8364 private:
8365         LDKCVec_RecentPaymentDetailsZ self;
8366 public:
8367         CVec_RecentPaymentDetailsZ(const CVec_RecentPaymentDetailsZ&) = delete;
8368         CVec_RecentPaymentDetailsZ(CVec_RecentPaymentDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RecentPaymentDetailsZ)); }
8369         CVec_RecentPaymentDetailsZ(LDKCVec_RecentPaymentDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RecentPaymentDetailsZ)); }
8370         operator LDKCVec_RecentPaymentDetailsZ() && { LDKCVec_RecentPaymentDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_RecentPaymentDetailsZ)); return res; }
8371         ~CVec_RecentPaymentDetailsZ() { CVec_RecentPaymentDetailsZ_free(self); }
8372         CVec_RecentPaymentDetailsZ& operator=(CVec_RecentPaymentDetailsZ&& o) { CVec_RecentPaymentDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RecentPaymentDetailsZ)); return *this; }
8373         LDKCVec_RecentPaymentDetailsZ* operator &() { return &self; }
8374         LDKCVec_RecentPaymentDetailsZ* operator ->() { return &self; }
8375         const LDKCVec_RecentPaymentDetailsZ* operator &() const { return &self; }
8376         const LDKCVec_RecentPaymentDetailsZ* operator ->() const { return &self; }
8377 };
8378 class CVec_RouteHintHopZ {
8379 private:
8380         LDKCVec_RouteHintHopZ self;
8381 public:
8382         CVec_RouteHintHopZ(const CVec_RouteHintHopZ&) = delete;
8383         CVec_RouteHintHopZ(CVec_RouteHintHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintHopZ)); }
8384         CVec_RouteHintHopZ(LDKCVec_RouteHintHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintHopZ)); }
8385         operator LDKCVec_RouteHintHopZ() && { LDKCVec_RouteHintHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintHopZ)); return res; }
8386         ~CVec_RouteHintHopZ() { CVec_RouteHintHopZ_free(self); }
8387         CVec_RouteHintHopZ& operator=(CVec_RouteHintHopZ&& o) { CVec_RouteHintHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintHopZ)); return *this; }
8388         LDKCVec_RouteHintHopZ* operator &() { return &self; }
8389         LDKCVec_RouteHintHopZ* operator ->() { return &self; }
8390         const LDKCVec_RouteHintHopZ* operator &() const { return &self; }
8391         const LDKCVec_RouteHintHopZ* operator ->() const { return &self; }
8392 };
8393 class CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ {
8394 private:
8395         LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ self;
8396 public:
8397         CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ(const CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ&) = delete;
8398         CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ(CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ)); }
8399         CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ(LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ)); }
8400         operator LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ() && { LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ)); return res; }
8401         ~CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ() { CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ_free(self); }
8402         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; }
8403         LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ* operator &() { return &self; }
8404         LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ* operator ->() { return &self; }
8405         const LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ* operator &() const { return &self; }
8406         const LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ* operator ->() const { return &self; }
8407 };
8408 class CResult_UntrustedStringDecodeErrorZ {
8409 private:
8410         LDKCResult_UntrustedStringDecodeErrorZ self;
8411 public:
8412         CResult_UntrustedStringDecodeErrorZ(const CResult_UntrustedStringDecodeErrorZ&) = delete;
8413         CResult_UntrustedStringDecodeErrorZ(CResult_UntrustedStringDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UntrustedStringDecodeErrorZ)); }
8414         CResult_UntrustedStringDecodeErrorZ(LDKCResult_UntrustedStringDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UntrustedStringDecodeErrorZ)); }
8415         operator LDKCResult_UntrustedStringDecodeErrorZ() && { LDKCResult_UntrustedStringDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UntrustedStringDecodeErrorZ)); return res; }
8416         ~CResult_UntrustedStringDecodeErrorZ() { CResult_UntrustedStringDecodeErrorZ_free(self); }
8417         CResult_UntrustedStringDecodeErrorZ& operator=(CResult_UntrustedStringDecodeErrorZ&& o) { CResult_UntrustedStringDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UntrustedStringDecodeErrorZ)); return *this; }
8418         LDKCResult_UntrustedStringDecodeErrorZ* operator &() { return &self; }
8419         LDKCResult_UntrustedStringDecodeErrorZ* operator ->() { return &self; }
8420         const LDKCResult_UntrustedStringDecodeErrorZ* operator &() const { return &self; }
8421         const LDKCResult_UntrustedStringDecodeErrorZ* operator ->() const { return &self; }
8422 };
8423 class CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ {
8424 private:
8425         LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ self;
8426 public:
8427         CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ(const CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ&) = delete;
8428         CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ(CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ)); }
8429         CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ(LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ)); }
8430         operator LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ() && { LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ)); return res; }
8431         ~CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ() { CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ_free(self); }
8432         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; }
8433         LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ* operator &() { return &self; }
8434         LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ* operator ->() { return &self; }
8435         const LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ* operator &() const { return &self; }
8436         const LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ* operator ->() const { return &self; }
8437 };
8438 class CVec_U5Z {
8439 private:
8440         LDKCVec_U5Z self;
8441 public:
8442         CVec_U5Z(const CVec_U5Z&) = delete;
8443         CVec_U5Z(CVec_U5Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_U5Z)); }
8444         CVec_U5Z(LDKCVec_U5Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_U5Z)); }
8445         operator LDKCVec_U5Z() && { LDKCVec_U5Z res = self; memset(&self, 0, sizeof(LDKCVec_U5Z)); return res; }
8446         ~CVec_U5Z() { CVec_U5Z_free(self); }
8447         CVec_U5Z& operator=(CVec_U5Z&& o) { CVec_U5Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_U5Z)); return *this; }
8448         LDKCVec_U5Z* operator &() { return &self; }
8449         LDKCVec_U5Z* operator ->() { return &self; }
8450         const LDKCVec_U5Z* operator &() const { return &self; }
8451         const LDKCVec_U5Z* operator ->() const { return &self; }
8452 };
8453 class CResult_PaymentParametersDecodeErrorZ {
8454 private:
8455         LDKCResult_PaymentParametersDecodeErrorZ self;
8456 public:
8457         CResult_PaymentParametersDecodeErrorZ(const CResult_PaymentParametersDecodeErrorZ&) = delete;
8458         CResult_PaymentParametersDecodeErrorZ(CResult_PaymentParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); }
8459         CResult_PaymentParametersDecodeErrorZ(LDKCResult_PaymentParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); }
8460         operator LDKCResult_PaymentParametersDecodeErrorZ() && { LDKCResult_PaymentParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); return res; }
8461         ~CResult_PaymentParametersDecodeErrorZ() { CResult_PaymentParametersDecodeErrorZ_free(self); }
8462         CResult_PaymentParametersDecodeErrorZ& operator=(CResult_PaymentParametersDecodeErrorZ&& o) { CResult_PaymentParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); return *this; }
8463         LDKCResult_PaymentParametersDecodeErrorZ* operator &() { return &self; }
8464         LDKCResult_PaymentParametersDecodeErrorZ* operator ->() { return &self; }
8465         const LDKCResult_PaymentParametersDecodeErrorZ* operator &() const { return &self; }
8466         const LDKCResult_PaymentParametersDecodeErrorZ* operator ->() const { return &self; }
8467 };
8468 class C2Tuple_ThirtyTwoBytesChannelMonitorZ {
8469 private:
8470         LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ self;
8471 public:
8472         C2Tuple_ThirtyTwoBytesChannelMonitorZ(const C2Tuple_ThirtyTwoBytesChannelMonitorZ&) = delete;
8473         C2Tuple_ThirtyTwoBytesChannelMonitorZ(C2Tuple_ThirtyTwoBytesChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelMonitorZ)); }
8474         C2Tuple_ThirtyTwoBytesChannelMonitorZ(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ)); }
8475         operator LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ() && { LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ)); return res; }
8476         ~C2Tuple_ThirtyTwoBytesChannelMonitorZ() { C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(self); }
8477         C2Tuple_ThirtyTwoBytesChannelMonitorZ& operator=(C2Tuple_ThirtyTwoBytesChannelMonitorZ&& o) { C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelMonitorZ)); return *this; }
8478         LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator &() { return &self; }
8479         LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator ->() { return &self; }
8480         const LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator &() const { return &self; }
8481         const LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator ->() const { return &self; }
8482 };
8483 class COption_U128Z {
8484 private:
8485         LDKCOption_U128Z self;
8486 public:
8487         COption_U128Z(const COption_U128Z&) = delete;
8488         COption_U128Z(COption_U128Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_U128Z)); }
8489         COption_U128Z(LDKCOption_U128Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_U128Z)); }
8490         operator LDKCOption_U128Z() && { LDKCOption_U128Z res = self; memset(&self, 0, sizeof(LDKCOption_U128Z)); return res; }
8491         ~COption_U128Z() { COption_U128Z_free(self); }
8492         COption_U128Z& operator=(COption_U128Z&& o) { COption_U128Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_U128Z)); return *this; }
8493         LDKCOption_U128Z* operator &() { return &self; }
8494         LDKCOption_U128Z* operator ->() { return &self; }
8495         const LDKCOption_U128Z* operator &() const { return &self; }
8496         const LDKCOption_U128Z* operator ->() const { return &self; }
8497 };
8498 class CResult_DelayedPaymentBasepointDecodeErrorZ {
8499 private:
8500         LDKCResult_DelayedPaymentBasepointDecodeErrorZ self;
8501 public:
8502         CResult_DelayedPaymentBasepointDecodeErrorZ(const CResult_DelayedPaymentBasepointDecodeErrorZ&) = delete;
8503         CResult_DelayedPaymentBasepointDecodeErrorZ(CResult_DelayedPaymentBasepointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentBasepointDecodeErrorZ)); }
8504         CResult_DelayedPaymentBasepointDecodeErrorZ(LDKCResult_DelayedPaymentBasepointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentBasepointDecodeErrorZ)); }
8505         operator LDKCResult_DelayedPaymentBasepointDecodeErrorZ() && { LDKCResult_DelayedPaymentBasepointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentBasepointDecodeErrorZ)); return res; }
8506         ~CResult_DelayedPaymentBasepointDecodeErrorZ() { CResult_DelayedPaymentBasepointDecodeErrorZ_free(self); }
8507         CResult_DelayedPaymentBasepointDecodeErrorZ& operator=(CResult_DelayedPaymentBasepointDecodeErrorZ&& o) { CResult_DelayedPaymentBasepointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentBasepointDecodeErrorZ)); return *this; }
8508         LDKCResult_DelayedPaymentBasepointDecodeErrorZ* operator &() { return &self; }
8509         LDKCResult_DelayedPaymentBasepointDecodeErrorZ* operator ->() { return &self; }
8510         const LDKCResult_DelayedPaymentBasepointDecodeErrorZ* operator &() const { return &self; }
8511         const LDKCResult_DelayedPaymentBasepointDecodeErrorZ* operator ->() const { return &self; }
8512 };
8513 class C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ {
8514 private:
8515         LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ self;
8516 public:
8517         C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(const C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&) = delete;
8518         C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); }
8519         C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); }
8520         operator LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ() && { LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); return res; }
8521         ~C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ() { C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(self); }
8522         C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ& operator=(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& o) { C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); return *this; }
8523         LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator &() { return &self; }
8524         LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator ->() { return &self; }
8525         const LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator &() const { return &self; }
8526         const LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator ->() const { return &self; }
8527 };
8528 class CResult_TxAckRbfDecodeErrorZ {
8529 private:
8530         LDKCResult_TxAckRbfDecodeErrorZ self;
8531 public:
8532         CResult_TxAckRbfDecodeErrorZ(const CResult_TxAckRbfDecodeErrorZ&) = delete;
8533         CResult_TxAckRbfDecodeErrorZ(CResult_TxAckRbfDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAckRbfDecodeErrorZ)); }
8534         CResult_TxAckRbfDecodeErrorZ(LDKCResult_TxAckRbfDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAckRbfDecodeErrorZ)); }
8535         operator LDKCResult_TxAckRbfDecodeErrorZ() && { LDKCResult_TxAckRbfDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAckRbfDecodeErrorZ)); return res; }
8536         ~CResult_TxAckRbfDecodeErrorZ() { CResult_TxAckRbfDecodeErrorZ_free(self); }
8537         CResult_TxAckRbfDecodeErrorZ& operator=(CResult_TxAckRbfDecodeErrorZ&& o) { CResult_TxAckRbfDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAckRbfDecodeErrorZ)); return *this; }
8538         LDKCResult_TxAckRbfDecodeErrorZ* operator &() { return &self; }
8539         LDKCResult_TxAckRbfDecodeErrorZ* operator ->() { return &self; }
8540         const LDKCResult_TxAckRbfDecodeErrorZ* operator &() const { return &self; }
8541         const LDKCResult_TxAckRbfDecodeErrorZ* operator ->() const { return &self; }
8542 };
8543 class CResult_Bolt11InvoiceBolt11SemanticErrorZ {
8544 private:
8545         LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ self;
8546 public:
8547         CResult_Bolt11InvoiceBolt11SemanticErrorZ(const CResult_Bolt11InvoiceBolt11SemanticErrorZ&) = delete;
8548         CResult_Bolt11InvoiceBolt11SemanticErrorZ(CResult_Bolt11InvoiceBolt11SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceBolt11SemanticErrorZ)); }
8549         CResult_Bolt11InvoiceBolt11SemanticErrorZ(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ)); }
8550         operator LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ() && { LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ)); return res; }
8551         ~CResult_Bolt11InvoiceBolt11SemanticErrorZ() { CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(self); }
8552         CResult_Bolt11InvoiceBolt11SemanticErrorZ& operator=(CResult_Bolt11InvoiceBolt11SemanticErrorZ&& o) { CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceBolt11SemanticErrorZ)); return *this; }
8553         LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator &() { return &self; }
8554         LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator ->() { return &self; }
8555         const LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator &() const { return &self; }
8556         const LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator ->() const { return &self; }
8557 };
8558 class COption_UtxoLookupZ {
8559 private:
8560         LDKCOption_UtxoLookupZ self;
8561 public:
8562         COption_UtxoLookupZ(const COption_UtxoLookupZ&) = delete;
8563         COption_UtxoLookupZ(COption_UtxoLookupZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_UtxoLookupZ)); }
8564         COption_UtxoLookupZ(LDKCOption_UtxoLookupZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_UtxoLookupZ)); }
8565         operator LDKCOption_UtxoLookupZ() && { LDKCOption_UtxoLookupZ res = self; memset(&self, 0, sizeof(LDKCOption_UtxoLookupZ)); return res; }
8566         ~COption_UtxoLookupZ() { COption_UtxoLookupZ_free(self); }
8567         COption_UtxoLookupZ& operator=(COption_UtxoLookupZ&& o) { COption_UtxoLookupZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_UtxoLookupZ)); return *this; }
8568         LDKCOption_UtxoLookupZ* operator &() { return &self; }
8569         LDKCOption_UtxoLookupZ* operator ->() { return &self; }
8570         const LDKCOption_UtxoLookupZ* operator &() const { return &self; }
8571         const LDKCOption_UtxoLookupZ* operator ->() const { return &self; }
8572 };
8573 class CResult_PongDecodeErrorZ {
8574 private:
8575         LDKCResult_PongDecodeErrorZ self;
8576 public:
8577         CResult_PongDecodeErrorZ(const CResult_PongDecodeErrorZ&) = delete;
8578         CResult_PongDecodeErrorZ(CResult_PongDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); }
8579         CResult_PongDecodeErrorZ(LDKCResult_PongDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); }
8580         operator LDKCResult_PongDecodeErrorZ() && { LDKCResult_PongDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); return res; }
8581         ~CResult_PongDecodeErrorZ() { CResult_PongDecodeErrorZ_free(self); }
8582         CResult_PongDecodeErrorZ& operator=(CResult_PongDecodeErrorZ&& o) { CResult_PongDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); return *this; }
8583         LDKCResult_PongDecodeErrorZ* operator &() { return &self; }
8584         LDKCResult_PongDecodeErrorZ* operator ->() { return &self; }
8585         const LDKCResult_PongDecodeErrorZ* operator &() const { return &self; }
8586         const LDKCResult_PongDecodeErrorZ* operator ->() const { return &self; }
8587 };
8588 class CResult_UnsignedChannelAnnouncementDecodeErrorZ {
8589 private:
8590         LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ self;
8591 public:
8592         CResult_UnsignedChannelAnnouncementDecodeErrorZ(const CResult_UnsignedChannelAnnouncementDecodeErrorZ&) = delete;
8593         CResult_UnsignedChannelAnnouncementDecodeErrorZ(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
8594         CResult_UnsignedChannelAnnouncementDecodeErrorZ(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
8595         operator LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); return res; }
8596         ~CResult_UnsignedChannelAnnouncementDecodeErrorZ() { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); }
8597         CResult_UnsignedChannelAnnouncementDecodeErrorZ& operator=(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); return *this; }
8598         LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
8599         LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
8600         const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
8601         const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
8602 };
8603 class C2Tuple_OutPointCVec_MonitorUpdateIdZZ {
8604 private:
8605         LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ self;
8606 public:
8607         C2Tuple_OutPointCVec_MonitorUpdateIdZZ(const C2Tuple_OutPointCVec_MonitorUpdateIdZZ&) = delete;
8608         C2Tuple_OutPointCVec_MonitorUpdateIdZZ(C2Tuple_OutPointCVec_MonitorUpdateIdZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointCVec_MonitorUpdateIdZZ)); }
8609         C2Tuple_OutPointCVec_MonitorUpdateIdZZ(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ)); }
8610         operator LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ() && { LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ)); return res; }
8611         ~C2Tuple_OutPointCVec_MonitorUpdateIdZZ() { C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(self); }
8612         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; }
8613         LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator &() { return &self; }
8614         LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator ->() { return &self; }
8615         const LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator &() const { return &self; }
8616         const LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator ->() const { return &self; }
8617 };
8618 class CResult_ChannelIdAPIErrorZ {
8619 private:
8620         LDKCResult_ChannelIdAPIErrorZ self;
8621 public:
8622         CResult_ChannelIdAPIErrorZ(const CResult_ChannelIdAPIErrorZ&) = delete;
8623         CResult_ChannelIdAPIErrorZ(CResult_ChannelIdAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelIdAPIErrorZ)); }
8624         CResult_ChannelIdAPIErrorZ(LDKCResult_ChannelIdAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelIdAPIErrorZ)); }
8625         operator LDKCResult_ChannelIdAPIErrorZ() && { LDKCResult_ChannelIdAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelIdAPIErrorZ)); return res; }
8626         ~CResult_ChannelIdAPIErrorZ() { CResult_ChannelIdAPIErrorZ_free(self); }
8627         CResult_ChannelIdAPIErrorZ& operator=(CResult_ChannelIdAPIErrorZ&& o) { CResult_ChannelIdAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelIdAPIErrorZ)); return *this; }
8628         LDKCResult_ChannelIdAPIErrorZ* operator &() { return &self; }
8629         LDKCResult_ChannelIdAPIErrorZ* operator ->() { return &self; }
8630         const LDKCResult_ChannelIdAPIErrorZ* operator &() const { return &self; }
8631         const LDKCResult_ChannelIdAPIErrorZ* operator ->() const { return &self; }
8632 };
8633 class CResult_CVec_u8ZNoneZ {
8634 private:
8635         LDKCResult_CVec_u8ZNoneZ self;
8636 public:
8637         CResult_CVec_u8ZNoneZ(const CResult_CVec_u8ZNoneZ&) = delete;
8638         CResult_CVec_u8ZNoneZ(CResult_CVec_u8ZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZNoneZ)); }
8639         CResult_CVec_u8ZNoneZ(LDKCResult_CVec_u8ZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZNoneZ)); }
8640         operator LDKCResult_CVec_u8ZNoneZ() && { LDKCResult_CVec_u8ZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZNoneZ)); return res; }
8641         ~CResult_CVec_u8ZNoneZ() { CResult_CVec_u8ZNoneZ_free(self); }
8642         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; }
8643         LDKCResult_CVec_u8ZNoneZ* operator &() { return &self; }
8644         LDKCResult_CVec_u8ZNoneZ* operator ->() { return &self; }
8645         const LDKCResult_CVec_u8ZNoneZ* operator &() const { return &self; }
8646         const LDKCResult_CVec_u8ZNoneZ* operator ->() const { return &self; }
8647 };
8648 class CVec_C2Tuple_ChannelIdPublicKeyZZ {
8649 private:
8650         LDKCVec_C2Tuple_ChannelIdPublicKeyZZ self;
8651 public:
8652         CVec_C2Tuple_ChannelIdPublicKeyZZ(const CVec_C2Tuple_ChannelIdPublicKeyZZ&) = delete;
8653         CVec_C2Tuple_ChannelIdPublicKeyZZ(CVec_C2Tuple_ChannelIdPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ChannelIdPublicKeyZZ)); }
8654         CVec_C2Tuple_ChannelIdPublicKeyZZ(LDKCVec_C2Tuple_ChannelIdPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ChannelIdPublicKeyZZ)); }
8655         operator LDKCVec_C2Tuple_ChannelIdPublicKeyZZ() && { LDKCVec_C2Tuple_ChannelIdPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ChannelIdPublicKeyZZ)); return res; }
8656         ~CVec_C2Tuple_ChannelIdPublicKeyZZ() { CVec_C2Tuple_ChannelIdPublicKeyZZ_free(self); }
8657         CVec_C2Tuple_ChannelIdPublicKeyZZ& operator=(CVec_C2Tuple_ChannelIdPublicKeyZZ&& o) { CVec_C2Tuple_ChannelIdPublicKeyZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_ChannelIdPublicKeyZZ)); return *this; }
8658         LDKCVec_C2Tuple_ChannelIdPublicKeyZZ* operator &() { return &self; }
8659         LDKCVec_C2Tuple_ChannelIdPublicKeyZZ* operator ->() { return &self; }
8660         const LDKCVec_C2Tuple_ChannelIdPublicKeyZZ* operator &() const { return &self; }
8661         const LDKCVec_C2Tuple_ChannelIdPublicKeyZZ* operator ->() const { return &self; }
8662 };
8663 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ {
8664 private:
8665         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ self;
8666 public:
8667         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(const C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&) = delete;
8668         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); }
8669         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); }
8670         operator LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ() && { LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); return res; }
8671         ~C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ() { C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(self); }
8672         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; }
8673         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator &() { return &self; }
8674         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator ->() { return &self; }
8675         const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator &() const { return &self; }
8676         const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator ->() const { return &self; }
8677 };
8678 class CResult_ChannelTransactionParametersDecodeErrorZ {
8679 private:
8680         LDKCResult_ChannelTransactionParametersDecodeErrorZ self;
8681 public:
8682         CResult_ChannelTransactionParametersDecodeErrorZ(const CResult_ChannelTransactionParametersDecodeErrorZ&) = delete;
8683         CResult_ChannelTransactionParametersDecodeErrorZ(CResult_ChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); }
8684         CResult_ChannelTransactionParametersDecodeErrorZ(LDKCResult_ChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); }
8685         operator LDKCResult_ChannelTransactionParametersDecodeErrorZ() && { LDKCResult_ChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); return res; }
8686         ~CResult_ChannelTransactionParametersDecodeErrorZ() { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); }
8687         CResult_ChannelTransactionParametersDecodeErrorZ& operator=(CResult_ChannelTransactionParametersDecodeErrorZ&& o) { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); return *this; }
8688         LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
8689         LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
8690         const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
8691         const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
8692 };
8693 class CResult_WriteableEcdsaChannelSignerDecodeErrorZ {
8694 private:
8695         LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ self;
8696 public:
8697         CResult_WriteableEcdsaChannelSignerDecodeErrorZ(const CResult_WriteableEcdsaChannelSignerDecodeErrorZ&) = delete;
8698         CResult_WriteableEcdsaChannelSignerDecodeErrorZ(CResult_WriteableEcdsaChannelSignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WriteableEcdsaChannelSignerDecodeErrorZ)); }
8699         CResult_WriteableEcdsaChannelSignerDecodeErrorZ(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ)); }
8700         operator LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ() && { LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ)); return res; }
8701         ~CResult_WriteableEcdsaChannelSignerDecodeErrorZ() { CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(self); }
8702         CResult_WriteableEcdsaChannelSignerDecodeErrorZ& operator=(CResult_WriteableEcdsaChannelSignerDecodeErrorZ&& o) { CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WriteableEcdsaChannelSignerDecodeErrorZ)); return *this; }
8703         LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator &() { return &self; }
8704         LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator ->() { return &self; }
8705         const LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator &() const { return &self; }
8706         const LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator ->() const { return &self; }
8707 };
8708 class CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ {
8709 private:
8710         LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ self;
8711 public:
8712         CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ(const CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ&) = delete;
8713         CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ(CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ)); }
8714         CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ(LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ)); }
8715         operator LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ() && { LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ)); return res; }
8716         ~CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ() { CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_free(self); }
8717         CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ& operator=(CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ&& o) { CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ)); return *this; }
8718         LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ* operator &() { return &self; }
8719         LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ* operator ->() { return &self; }
8720         const LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ* operator &() const { return &self; }
8721         const LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ* operator ->() const { return &self; }
8722 };
8723 class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
8724 private:
8725         LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ self;
8726 public:
8727         CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(const CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&) = delete;
8728         CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
8729         CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
8730         operator LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return res; }
8731         ~CResult_DelayedPaymentOutputDescriptorDecodeErrorZ() { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); }
8732         CResult_DelayedPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return *this; }
8733         LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
8734         LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
8735         const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
8736         const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
8737 };
8738 class CResult_InFlightHtlcsDecodeErrorZ {
8739 private:
8740         LDKCResult_InFlightHtlcsDecodeErrorZ self;
8741 public:
8742         CResult_InFlightHtlcsDecodeErrorZ(const CResult_InFlightHtlcsDecodeErrorZ&) = delete;
8743         CResult_InFlightHtlcsDecodeErrorZ(CResult_InFlightHtlcsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InFlightHtlcsDecodeErrorZ)); }
8744         CResult_InFlightHtlcsDecodeErrorZ(LDKCResult_InFlightHtlcsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ)); }
8745         operator LDKCResult_InFlightHtlcsDecodeErrorZ() && { LDKCResult_InFlightHtlcsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ)); return res; }
8746         ~CResult_InFlightHtlcsDecodeErrorZ() { CResult_InFlightHtlcsDecodeErrorZ_free(self); }
8747         CResult_InFlightHtlcsDecodeErrorZ& operator=(CResult_InFlightHtlcsDecodeErrorZ&& o) { CResult_InFlightHtlcsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InFlightHtlcsDecodeErrorZ)); return *this; }
8748         LDKCResult_InFlightHtlcsDecodeErrorZ* operator &() { return &self; }
8749         LDKCResult_InFlightHtlcsDecodeErrorZ* operator ->() { return &self; }
8750         const LDKCResult_InFlightHtlcsDecodeErrorZ* operator &() const { return &self; }
8751         const LDKCResult_InFlightHtlcsDecodeErrorZ* operator ->() const { return &self; }
8752 };
8753 class CResult_COption_HTLCDestinationZDecodeErrorZ {
8754 private:
8755         LDKCResult_COption_HTLCDestinationZDecodeErrorZ self;
8756 public:
8757         CResult_COption_HTLCDestinationZDecodeErrorZ(const CResult_COption_HTLCDestinationZDecodeErrorZ&) = delete;
8758         CResult_COption_HTLCDestinationZDecodeErrorZ(CResult_COption_HTLCDestinationZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_HTLCDestinationZDecodeErrorZ)); }
8759         CResult_COption_HTLCDestinationZDecodeErrorZ(LDKCResult_COption_HTLCDestinationZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ)); }
8760         operator LDKCResult_COption_HTLCDestinationZDecodeErrorZ() && { LDKCResult_COption_HTLCDestinationZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ)); return res; }
8761         ~CResult_COption_HTLCDestinationZDecodeErrorZ() { CResult_COption_HTLCDestinationZDecodeErrorZ_free(self); }
8762         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; }
8763         LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator &() { return &self; }
8764         LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator ->() { return &self; }
8765         const LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator &() const { return &self; }
8766         const LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator ->() const { return &self; }
8767 };
8768 class CResult_Bolt12OfferContextDecodeErrorZ {
8769 private:
8770         LDKCResult_Bolt12OfferContextDecodeErrorZ self;
8771 public:
8772         CResult_Bolt12OfferContextDecodeErrorZ(const CResult_Bolt12OfferContextDecodeErrorZ&) = delete;
8773         CResult_Bolt12OfferContextDecodeErrorZ(CResult_Bolt12OfferContextDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt12OfferContextDecodeErrorZ)); }
8774         CResult_Bolt12OfferContextDecodeErrorZ(LDKCResult_Bolt12OfferContextDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt12OfferContextDecodeErrorZ)); }
8775         operator LDKCResult_Bolt12OfferContextDecodeErrorZ() && { LDKCResult_Bolt12OfferContextDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt12OfferContextDecodeErrorZ)); return res; }
8776         ~CResult_Bolt12OfferContextDecodeErrorZ() { CResult_Bolt12OfferContextDecodeErrorZ_free(self); }
8777         CResult_Bolt12OfferContextDecodeErrorZ& operator=(CResult_Bolt12OfferContextDecodeErrorZ&& o) { CResult_Bolt12OfferContextDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt12OfferContextDecodeErrorZ)); return *this; }
8778         LDKCResult_Bolt12OfferContextDecodeErrorZ* operator &() { return &self; }
8779         LDKCResult_Bolt12OfferContextDecodeErrorZ* operator ->() { return &self; }
8780         const LDKCResult_Bolt12OfferContextDecodeErrorZ* operator &() const { return &self; }
8781         const LDKCResult_Bolt12OfferContextDecodeErrorZ* operator ->() const { return &self; }
8782 };
8783 class CResult_ThirtyTwoBytesNoneZ {
8784 private:
8785         LDKCResult_ThirtyTwoBytesNoneZ self;
8786 public:
8787         CResult_ThirtyTwoBytesNoneZ(const CResult_ThirtyTwoBytesNoneZ&) = delete;
8788         CResult_ThirtyTwoBytesNoneZ(CResult_ThirtyTwoBytesNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesNoneZ)); }
8789         CResult_ThirtyTwoBytesNoneZ(LDKCResult_ThirtyTwoBytesNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesNoneZ)); }
8790         operator LDKCResult_ThirtyTwoBytesNoneZ() && { LDKCResult_ThirtyTwoBytesNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesNoneZ)); return res; }
8791         ~CResult_ThirtyTwoBytesNoneZ() { CResult_ThirtyTwoBytesNoneZ_free(self); }
8792         CResult_ThirtyTwoBytesNoneZ& operator=(CResult_ThirtyTwoBytesNoneZ&& o) { CResult_ThirtyTwoBytesNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesNoneZ)); return *this; }
8793         LDKCResult_ThirtyTwoBytesNoneZ* operator &() { return &self; }
8794         LDKCResult_ThirtyTwoBytesNoneZ* operator ->() { return &self; }
8795         const LDKCResult_ThirtyTwoBytesNoneZ* operator &() const { return &self; }
8796         const LDKCResult_ThirtyTwoBytesNoneZ* operator ->() const { return &self; }
8797 };
8798 class C3Tuple_OnionMessageContentsDestinationBlindedPathZ {
8799 private:
8800         LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ self;
8801 public:
8802         C3Tuple_OnionMessageContentsDestinationBlindedPathZ(const C3Tuple_OnionMessageContentsDestinationBlindedPathZ&) = delete;
8803         C3Tuple_OnionMessageContentsDestinationBlindedPathZ(C3Tuple_OnionMessageContentsDestinationBlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_OnionMessageContentsDestinationBlindedPathZ)); }
8804         C3Tuple_OnionMessageContentsDestinationBlindedPathZ(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ)); }
8805         operator LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ() && { LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ)); return res; }
8806         ~C3Tuple_OnionMessageContentsDestinationBlindedPathZ() { C3Tuple_OnionMessageContentsDestinationBlindedPathZ_free(self); }
8807         C3Tuple_OnionMessageContentsDestinationBlindedPathZ& operator=(C3Tuple_OnionMessageContentsDestinationBlindedPathZ&& o) { C3Tuple_OnionMessageContentsDestinationBlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_OnionMessageContentsDestinationBlindedPathZ)); return *this; }
8808         LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ* operator &() { return &self; }
8809         LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ* operator ->() { return &self; }
8810         const LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ* operator &() const { return &self; }
8811         const LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ* operator ->() const { return &self; }
8812 };
8813 class C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ {
8814 private:
8815         LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ self;
8816 public:
8817         C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(const C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&) = delete;
8818         C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); }
8819         C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); }
8820         operator LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ() && { LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); return res; }
8821         ~C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ() { C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(self); }
8822         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; }
8823         LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator &() { return &self; }
8824         LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator ->() { return &self; }
8825         const LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator &() const { return &self; }
8826         const LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator ->() const { return &self; }
8827 };
8828 class CResult_SendSuccessSendErrorZ {
8829 private:
8830         LDKCResult_SendSuccessSendErrorZ self;
8831 public:
8832         CResult_SendSuccessSendErrorZ(const CResult_SendSuccessSendErrorZ&) = delete;
8833         CResult_SendSuccessSendErrorZ(CResult_SendSuccessSendErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SendSuccessSendErrorZ)); }
8834         CResult_SendSuccessSendErrorZ(LDKCResult_SendSuccessSendErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SendSuccessSendErrorZ)); }
8835         operator LDKCResult_SendSuccessSendErrorZ() && { LDKCResult_SendSuccessSendErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SendSuccessSendErrorZ)); return res; }
8836         ~CResult_SendSuccessSendErrorZ() { CResult_SendSuccessSendErrorZ_free(self); }
8837         CResult_SendSuccessSendErrorZ& operator=(CResult_SendSuccessSendErrorZ&& o) { CResult_SendSuccessSendErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SendSuccessSendErrorZ)); return *this; }
8838         LDKCResult_SendSuccessSendErrorZ* operator &() { return &self; }
8839         LDKCResult_SendSuccessSendErrorZ* operator ->() { return &self; }
8840         const LDKCResult_SendSuccessSendErrorZ* operator &() const { return &self; }
8841         const LDKCResult_SendSuccessSendErrorZ* operator ->() const { return &self; }
8842 };
8843 class CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ {
8844 private:
8845         LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ self;
8846 public:
8847         CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ(const CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ&) = delete;
8848         CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ(CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ)); }
8849         CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ(LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ)); }
8850         operator LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ() && { LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ)); return res; }
8851         ~CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ() { CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ_free(self); }
8852         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; }
8853         LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator &() { return &self; }
8854         LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator ->() { return &self; }
8855         const LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator &() const { return &self; }
8856         const LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator ->() const { return &self; }
8857 };
8858 class C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ {
8859 private:
8860         LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ self;
8861 public:
8862         C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ(const C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ&) = delete;
8863         C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ(C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ)); }
8864         C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ)); }
8865         operator LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ() && { LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ)); return res; }
8866         ~C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ() { C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_free(self); }
8867         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; }
8868         LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ* operator &() { return &self; }
8869         LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ* operator ->() { return &self; }
8870         const LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ* operator &() const { return &self; }
8871         const LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ* operator ->() const { return &self; }
8872 };
8873 class CResult_BlindedHopDecodeErrorZ {
8874 private:
8875         LDKCResult_BlindedHopDecodeErrorZ self;
8876 public:
8877         CResult_BlindedHopDecodeErrorZ(const CResult_BlindedHopDecodeErrorZ&) = delete;
8878         CResult_BlindedHopDecodeErrorZ(CResult_BlindedHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedHopDecodeErrorZ)); }
8879         CResult_BlindedHopDecodeErrorZ(LDKCResult_BlindedHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedHopDecodeErrorZ)); }
8880         operator LDKCResult_BlindedHopDecodeErrorZ() && { LDKCResult_BlindedHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedHopDecodeErrorZ)); return res; }
8881         ~CResult_BlindedHopDecodeErrorZ() { CResult_BlindedHopDecodeErrorZ_free(self); }
8882         CResult_BlindedHopDecodeErrorZ& operator=(CResult_BlindedHopDecodeErrorZ&& o) { CResult_BlindedHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedHopDecodeErrorZ)); return *this; }
8883         LDKCResult_BlindedHopDecodeErrorZ* operator &() { return &self; }
8884         LDKCResult_BlindedHopDecodeErrorZ* operator ->() { return &self; }
8885         const LDKCResult_BlindedHopDecodeErrorZ* operator &() const { return &self; }
8886         const LDKCResult_BlindedHopDecodeErrorZ* operator ->() const { return &self; }
8887 };
8888 class CResult_NoneLightningErrorZ {
8889 private:
8890         LDKCResult_NoneLightningErrorZ self;
8891 public:
8892         CResult_NoneLightningErrorZ(const CResult_NoneLightningErrorZ&) = delete;
8893         CResult_NoneLightningErrorZ(CResult_NoneLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); }
8894         CResult_NoneLightningErrorZ(LDKCResult_NoneLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); }
8895         operator LDKCResult_NoneLightningErrorZ() && { LDKCResult_NoneLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); return res; }
8896         ~CResult_NoneLightningErrorZ() { CResult_NoneLightningErrorZ_free(self); }
8897         CResult_NoneLightningErrorZ& operator=(CResult_NoneLightningErrorZ&& o) { CResult_NoneLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); return *this; }
8898         LDKCResult_NoneLightningErrorZ* operator &() { return &self; }
8899         LDKCResult_NoneLightningErrorZ* operator ->() { return &self; }
8900         const LDKCResult_NoneLightningErrorZ* operator &() const { return &self; }
8901         const LDKCResult_NoneLightningErrorZ* operator ->() const { return &self; }
8902 };
8903 class CResult_FixedPenaltyScorerDecodeErrorZ {
8904 private:
8905         LDKCResult_FixedPenaltyScorerDecodeErrorZ self;
8906 public:
8907         CResult_FixedPenaltyScorerDecodeErrorZ(const CResult_FixedPenaltyScorerDecodeErrorZ&) = delete;
8908         CResult_FixedPenaltyScorerDecodeErrorZ(CResult_FixedPenaltyScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); }
8909         CResult_FixedPenaltyScorerDecodeErrorZ(LDKCResult_FixedPenaltyScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); }
8910         operator LDKCResult_FixedPenaltyScorerDecodeErrorZ() && { LDKCResult_FixedPenaltyScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); return res; }
8911         ~CResult_FixedPenaltyScorerDecodeErrorZ() { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); }
8912         CResult_FixedPenaltyScorerDecodeErrorZ& operator=(CResult_FixedPenaltyScorerDecodeErrorZ&& o) { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); return *this; }
8913         LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() { return &self; }
8914         LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() { return &self; }
8915         const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() const { return &self; }
8916         const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() const { return &self; }
8917 };
8918 class CVec_BlindedPathZ {
8919 private:
8920         LDKCVec_BlindedPathZ self;
8921 public:
8922         CVec_BlindedPathZ(const CVec_BlindedPathZ&) = delete;
8923         CVec_BlindedPathZ(CVec_BlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BlindedPathZ)); }
8924         CVec_BlindedPathZ(LDKCVec_BlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BlindedPathZ)); }
8925         operator LDKCVec_BlindedPathZ() && { LDKCVec_BlindedPathZ res = self; memset(&self, 0, sizeof(LDKCVec_BlindedPathZ)); return res; }
8926         ~CVec_BlindedPathZ() { CVec_BlindedPathZ_free(self); }
8927         CVec_BlindedPathZ& operator=(CVec_BlindedPathZ&& o) { CVec_BlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BlindedPathZ)); return *this; }
8928         LDKCVec_BlindedPathZ* operator &() { return &self; }
8929         LDKCVec_BlindedPathZ* operator ->() { return &self; }
8930         const LDKCVec_BlindedPathZ* operator &() const { return &self; }
8931         const LDKCVec_BlindedPathZ* operator ->() const { return &self; }
8932 };
8933 class CResult_NonePeerHandleErrorZ {
8934 private:
8935         LDKCResult_NonePeerHandleErrorZ self;
8936 public:
8937         CResult_NonePeerHandleErrorZ(const CResult_NonePeerHandleErrorZ&) = delete;
8938         CResult_NonePeerHandleErrorZ(CResult_NonePeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); }
8939         CResult_NonePeerHandleErrorZ(LDKCResult_NonePeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); }
8940         operator LDKCResult_NonePeerHandleErrorZ() && { LDKCResult_NonePeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); return res; }
8941         ~CResult_NonePeerHandleErrorZ() { CResult_NonePeerHandleErrorZ_free(self); }
8942         CResult_NonePeerHandleErrorZ& operator=(CResult_NonePeerHandleErrorZ&& o) { CResult_NonePeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); return *this; }
8943         LDKCResult_NonePeerHandleErrorZ* operator &() { return &self; }
8944         LDKCResult_NonePeerHandleErrorZ* operator ->() { return &self; }
8945         const LDKCResult_NonePeerHandleErrorZ* operator &() const { return &self; }
8946         const LDKCResult_NonePeerHandleErrorZ* operator ->() const { return &self; }
8947 };
8948 class CResult_FinalOnionHopDataDecodeErrorZ {
8949 private:
8950         LDKCResult_FinalOnionHopDataDecodeErrorZ self;
8951 public:
8952         CResult_FinalOnionHopDataDecodeErrorZ(const CResult_FinalOnionHopDataDecodeErrorZ&) = delete;
8953         CResult_FinalOnionHopDataDecodeErrorZ(CResult_FinalOnionHopDataDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FinalOnionHopDataDecodeErrorZ)); }
8954         CResult_FinalOnionHopDataDecodeErrorZ(LDKCResult_FinalOnionHopDataDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FinalOnionHopDataDecodeErrorZ)); }
8955         operator LDKCResult_FinalOnionHopDataDecodeErrorZ() && { LDKCResult_FinalOnionHopDataDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FinalOnionHopDataDecodeErrorZ)); return res; }
8956         ~CResult_FinalOnionHopDataDecodeErrorZ() { CResult_FinalOnionHopDataDecodeErrorZ_free(self); }
8957         CResult_FinalOnionHopDataDecodeErrorZ& operator=(CResult_FinalOnionHopDataDecodeErrorZ&& o) { CResult_FinalOnionHopDataDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FinalOnionHopDataDecodeErrorZ)); return *this; }
8958         LDKCResult_FinalOnionHopDataDecodeErrorZ* operator &() { return &self; }
8959         LDKCResult_FinalOnionHopDataDecodeErrorZ* operator ->() { return &self; }
8960         const LDKCResult_FinalOnionHopDataDecodeErrorZ* operator &() const { return &self; }
8961         const LDKCResult_FinalOnionHopDataDecodeErrorZ* operator ->() const { return &self; }
8962 };
8963 class CResult_TrustedCommitmentTransactionNoneZ {
8964 private:
8965         LDKCResult_TrustedCommitmentTransactionNoneZ self;
8966 public:
8967         CResult_TrustedCommitmentTransactionNoneZ(const CResult_TrustedCommitmentTransactionNoneZ&) = delete;
8968         CResult_TrustedCommitmentTransactionNoneZ(CResult_TrustedCommitmentTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); }
8969         CResult_TrustedCommitmentTransactionNoneZ(LDKCResult_TrustedCommitmentTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); }
8970         operator LDKCResult_TrustedCommitmentTransactionNoneZ() && { LDKCResult_TrustedCommitmentTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); return res; }
8971         ~CResult_TrustedCommitmentTransactionNoneZ() { CResult_TrustedCommitmentTransactionNoneZ_free(self); }
8972         CResult_TrustedCommitmentTransactionNoneZ& operator=(CResult_TrustedCommitmentTransactionNoneZ&& o) { CResult_TrustedCommitmentTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); return *this; }
8973         LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() { return &self; }
8974         LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() { return &self; }
8975         const LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() const { return &self; }
8976         const LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() const { return &self; }
8977 };
8978 class CResult_COption_EventZDecodeErrorZ {
8979 private:
8980         LDKCResult_COption_EventZDecodeErrorZ self;
8981 public:
8982         CResult_COption_EventZDecodeErrorZ(const CResult_COption_EventZDecodeErrorZ&) = delete;
8983         CResult_COption_EventZDecodeErrorZ(CResult_COption_EventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_EventZDecodeErrorZ)); }
8984         CResult_COption_EventZDecodeErrorZ(LDKCResult_COption_EventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); }
8985         operator LDKCResult_COption_EventZDecodeErrorZ() && { LDKCResult_COption_EventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); return res; }
8986         ~CResult_COption_EventZDecodeErrorZ() { CResult_COption_EventZDecodeErrorZ_free(self); }
8987         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; }
8988         LDKCResult_COption_EventZDecodeErrorZ* operator &() { return &self; }
8989         LDKCResult_COption_EventZDecodeErrorZ* operator ->() { return &self; }
8990         const LDKCResult_COption_EventZDecodeErrorZ* operator &() const { return &self; }
8991         const LDKCResult_COption_EventZDecodeErrorZ* operator ->() const { return &self; }
8992 };
8993 class CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ {
8994 private:
8995         LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ self;
8996 public:
8997         CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(const CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&) = delete;
8998         CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); }
8999         CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); }
9000         operator LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ() && { LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); return res; }
9001         ~CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ() { CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(self); }
9002         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; }
9003         LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator &() { return &self; }
9004         LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator ->() { return &self; }
9005         const LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator &() const { return &self; }
9006         const LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator ->() const { return &self; }
9007 };
9008 class CResult_PaymentFailureReasonDecodeErrorZ {
9009 private:
9010         LDKCResult_PaymentFailureReasonDecodeErrorZ self;
9011 public:
9012         CResult_PaymentFailureReasonDecodeErrorZ(const CResult_PaymentFailureReasonDecodeErrorZ&) = delete;
9013         CResult_PaymentFailureReasonDecodeErrorZ(CResult_PaymentFailureReasonDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentFailureReasonDecodeErrorZ)); }
9014         CResult_PaymentFailureReasonDecodeErrorZ(LDKCResult_PaymentFailureReasonDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ)); }
9015         operator LDKCResult_PaymentFailureReasonDecodeErrorZ() && { LDKCResult_PaymentFailureReasonDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ)); return res; }
9016         ~CResult_PaymentFailureReasonDecodeErrorZ() { CResult_PaymentFailureReasonDecodeErrorZ_free(self); }
9017         CResult_PaymentFailureReasonDecodeErrorZ& operator=(CResult_PaymentFailureReasonDecodeErrorZ&& o) { CResult_PaymentFailureReasonDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentFailureReasonDecodeErrorZ)); return *this; }
9018         LDKCResult_PaymentFailureReasonDecodeErrorZ* operator &() { return &self; }
9019         LDKCResult_PaymentFailureReasonDecodeErrorZ* operator ->() { return &self; }
9020         const LDKCResult_PaymentFailureReasonDecodeErrorZ* operator &() const { return &self; }
9021         const LDKCResult_PaymentFailureReasonDecodeErrorZ* operator ->() const { return &self; }
9022 };
9023 class COption_SocketAddressZ {
9024 private:
9025         LDKCOption_SocketAddressZ self;
9026 public:
9027         COption_SocketAddressZ(const COption_SocketAddressZ&) = delete;
9028         COption_SocketAddressZ(COption_SocketAddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_SocketAddressZ)); }
9029         COption_SocketAddressZ(LDKCOption_SocketAddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_SocketAddressZ)); }
9030         operator LDKCOption_SocketAddressZ() && { LDKCOption_SocketAddressZ res = self; memset(&self, 0, sizeof(LDKCOption_SocketAddressZ)); return res; }
9031         ~COption_SocketAddressZ() { COption_SocketAddressZ_free(self); }
9032         COption_SocketAddressZ& operator=(COption_SocketAddressZ&& o) { COption_SocketAddressZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_SocketAddressZ)); return *this; }
9033         LDKCOption_SocketAddressZ* operator &() { return &self; }
9034         LDKCOption_SocketAddressZ* operator ->() { return &self; }
9035         const LDKCOption_SocketAddressZ* operator &() const { return &self; }
9036         const LDKCOption_SocketAddressZ* operator ->() const { return &self; }
9037 };
9038 class CResult_COption_MonitorEventZDecodeErrorZ {
9039 private:
9040         LDKCResult_COption_MonitorEventZDecodeErrorZ self;
9041 public:
9042         CResult_COption_MonitorEventZDecodeErrorZ(const CResult_COption_MonitorEventZDecodeErrorZ&) = delete;
9043         CResult_COption_MonitorEventZDecodeErrorZ(CResult_COption_MonitorEventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_MonitorEventZDecodeErrorZ)); }
9044         CResult_COption_MonitorEventZDecodeErrorZ(LDKCResult_COption_MonitorEventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); }
9045         operator LDKCResult_COption_MonitorEventZDecodeErrorZ() && { LDKCResult_COption_MonitorEventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); return res; }
9046         ~CResult_COption_MonitorEventZDecodeErrorZ() { CResult_COption_MonitorEventZDecodeErrorZ_free(self); }
9047         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; }
9048         LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() { return &self; }
9049         LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() { return &self; }
9050         const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() const { return &self; }
9051         const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() const { return &self; }
9052 };
9053 class COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ {
9054 private:
9055         LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ self;
9056 public:
9057         COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(const COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&) = delete;
9058         COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); }
9059         COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); }
9060         operator LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ() && { LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); return res; }
9061         ~COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ() { COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(self); }
9062         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; }
9063         LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator &() { return &self; }
9064         LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator ->() { return &self; }
9065         const LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator &() const { return &self; }
9066         const LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator ->() const { return &self; }
9067 };
9068 class CResult_DescriptionCreationErrorZ {
9069 private:
9070         LDKCResult_DescriptionCreationErrorZ self;
9071 public:
9072         CResult_DescriptionCreationErrorZ(const CResult_DescriptionCreationErrorZ&) = delete;
9073         CResult_DescriptionCreationErrorZ(CResult_DescriptionCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); }
9074         CResult_DescriptionCreationErrorZ(LDKCResult_DescriptionCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); }
9075         operator LDKCResult_DescriptionCreationErrorZ() && { LDKCResult_DescriptionCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); return res; }
9076         ~CResult_DescriptionCreationErrorZ() { CResult_DescriptionCreationErrorZ_free(self); }
9077         CResult_DescriptionCreationErrorZ& operator=(CResult_DescriptionCreationErrorZ&& o) { CResult_DescriptionCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); return *this; }
9078         LDKCResult_DescriptionCreationErrorZ* operator &() { return &self; }
9079         LDKCResult_DescriptionCreationErrorZ* operator ->() { return &self; }
9080         const LDKCResult_DescriptionCreationErrorZ* operator &() const { return &self; }
9081         const LDKCResult_DescriptionCreationErrorZ* operator ->() const { return &self; }
9082 };
9083 class CResult_RoutingFeesDecodeErrorZ {
9084 private:
9085         LDKCResult_RoutingFeesDecodeErrorZ self;
9086 public:
9087         CResult_RoutingFeesDecodeErrorZ(const CResult_RoutingFeesDecodeErrorZ&) = delete;
9088         CResult_RoutingFeesDecodeErrorZ(CResult_RoutingFeesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); }
9089         CResult_RoutingFeesDecodeErrorZ(LDKCResult_RoutingFeesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); }
9090         operator LDKCResult_RoutingFeesDecodeErrorZ() && { LDKCResult_RoutingFeesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); return res; }
9091         ~CResult_RoutingFeesDecodeErrorZ() { CResult_RoutingFeesDecodeErrorZ_free(self); }
9092         CResult_RoutingFeesDecodeErrorZ& operator=(CResult_RoutingFeesDecodeErrorZ&& o) { CResult_RoutingFeesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); return *this; }
9093         LDKCResult_RoutingFeesDecodeErrorZ* operator &() { return &self; }
9094         LDKCResult_RoutingFeesDecodeErrorZ* operator ->() { return &self; }
9095         const LDKCResult_RoutingFeesDecodeErrorZ* operator &() const { return &self; }
9096         const LDKCResult_RoutingFeesDecodeErrorZ* operator ->() const { return &self; }
9097 };
9098 class CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ {
9099 private:
9100         LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ self;
9101 public:
9102         CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ(const CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ&) = delete;
9103         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)); }
9104         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)); }
9105         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; }
9106         ~CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ() { CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(self); }
9107         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; }
9108         LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator &() { return &self; }
9109         LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator ->() { return &self; }
9110         const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator &() const { return &self; }
9111         const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator ->() const { return &self; }
9112 };
9113 class CResult_PaymentRelayDecodeErrorZ {
9114 private:
9115         LDKCResult_PaymentRelayDecodeErrorZ self;
9116 public:
9117         CResult_PaymentRelayDecodeErrorZ(const CResult_PaymentRelayDecodeErrorZ&) = delete;
9118         CResult_PaymentRelayDecodeErrorZ(CResult_PaymentRelayDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentRelayDecodeErrorZ)); }
9119         CResult_PaymentRelayDecodeErrorZ(LDKCResult_PaymentRelayDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentRelayDecodeErrorZ)); }
9120         operator LDKCResult_PaymentRelayDecodeErrorZ() && { LDKCResult_PaymentRelayDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentRelayDecodeErrorZ)); return res; }
9121         ~CResult_PaymentRelayDecodeErrorZ() { CResult_PaymentRelayDecodeErrorZ_free(self); }
9122         CResult_PaymentRelayDecodeErrorZ& operator=(CResult_PaymentRelayDecodeErrorZ&& o) { CResult_PaymentRelayDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentRelayDecodeErrorZ)); return *this; }
9123         LDKCResult_PaymentRelayDecodeErrorZ* operator &() { return &self; }
9124         LDKCResult_PaymentRelayDecodeErrorZ* operator ->() { return &self; }
9125         const LDKCResult_PaymentRelayDecodeErrorZ* operator &() const { return &self; }
9126         const LDKCResult_PaymentRelayDecodeErrorZ* operator ->() const { return &self; }
9127 };
9128 class CResult_QueryShortChannelIdsDecodeErrorZ {
9129 private:
9130         LDKCResult_QueryShortChannelIdsDecodeErrorZ self;
9131 public:
9132         CResult_QueryShortChannelIdsDecodeErrorZ(const CResult_QueryShortChannelIdsDecodeErrorZ&) = delete;
9133         CResult_QueryShortChannelIdsDecodeErrorZ(CResult_QueryShortChannelIdsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); }
9134         CResult_QueryShortChannelIdsDecodeErrorZ(LDKCResult_QueryShortChannelIdsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); }
9135         operator LDKCResult_QueryShortChannelIdsDecodeErrorZ() && { LDKCResult_QueryShortChannelIdsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); return res; }
9136         ~CResult_QueryShortChannelIdsDecodeErrorZ() { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); }
9137         CResult_QueryShortChannelIdsDecodeErrorZ& operator=(CResult_QueryShortChannelIdsDecodeErrorZ&& o) { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); return *this; }
9138         LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() { return &self; }
9139         LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() { return &self; }
9140         const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() const { return &self; }
9141         const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() const { return &self; }
9142 };
9143 class CResult_VerifiedInvoiceRequestNoneZ {
9144 private:
9145         LDKCResult_VerifiedInvoiceRequestNoneZ self;
9146 public:
9147         CResult_VerifiedInvoiceRequestNoneZ(const CResult_VerifiedInvoiceRequestNoneZ&) = delete;
9148         CResult_VerifiedInvoiceRequestNoneZ(CResult_VerifiedInvoiceRequestNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_VerifiedInvoiceRequestNoneZ)); }
9149         CResult_VerifiedInvoiceRequestNoneZ(LDKCResult_VerifiedInvoiceRequestNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_VerifiedInvoiceRequestNoneZ)); }
9150         operator LDKCResult_VerifiedInvoiceRequestNoneZ() && { LDKCResult_VerifiedInvoiceRequestNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_VerifiedInvoiceRequestNoneZ)); return res; }
9151         ~CResult_VerifiedInvoiceRequestNoneZ() { CResult_VerifiedInvoiceRequestNoneZ_free(self); }
9152         CResult_VerifiedInvoiceRequestNoneZ& operator=(CResult_VerifiedInvoiceRequestNoneZ&& o) { CResult_VerifiedInvoiceRequestNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_VerifiedInvoiceRequestNoneZ)); return *this; }
9153         LDKCResult_VerifiedInvoiceRequestNoneZ* operator &() { return &self; }
9154         LDKCResult_VerifiedInvoiceRequestNoneZ* operator ->() { return &self; }
9155         const LDKCResult_VerifiedInvoiceRequestNoneZ* operator &() const { return &self; }
9156         const LDKCResult_VerifiedInvoiceRequestNoneZ* operator ->() const { return &self; }
9157 };
9158 class CResult_UpdateAddHTLCDecodeErrorZ {
9159 private:
9160         LDKCResult_UpdateAddHTLCDecodeErrorZ self;
9161 public:
9162         CResult_UpdateAddHTLCDecodeErrorZ(const CResult_UpdateAddHTLCDecodeErrorZ&) = delete;
9163         CResult_UpdateAddHTLCDecodeErrorZ(CResult_UpdateAddHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); }
9164         CResult_UpdateAddHTLCDecodeErrorZ(LDKCResult_UpdateAddHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); }
9165         operator LDKCResult_UpdateAddHTLCDecodeErrorZ() && { LDKCResult_UpdateAddHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); return res; }
9166         ~CResult_UpdateAddHTLCDecodeErrorZ() { CResult_UpdateAddHTLCDecodeErrorZ_free(self); }
9167         CResult_UpdateAddHTLCDecodeErrorZ& operator=(CResult_UpdateAddHTLCDecodeErrorZ&& o) { CResult_UpdateAddHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); return *this; }
9168         LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() { return &self; }
9169         LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() { return &self; }
9170         const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() const { return &self; }
9171         const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() const { return &self; }
9172 };
9173 class COption_MonitorEventZ {
9174 private:
9175         LDKCOption_MonitorEventZ self;
9176 public:
9177         COption_MonitorEventZ(const COption_MonitorEventZ&) = delete;
9178         COption_MonitorEventZ(COption_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MonitorEventZ)); }
9179         COption_MonitorEventZ(LDKCOption_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MonitorEventZ)); }
9180         operator LDKCOption_MonitorEventZ() && { LDKCOption_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCOption_MonitorEventZ)); return res; }
9181         ~COption_MonitorEventZ() { COption_MonitorEventZ_free(self); }
9182         COption_MonitorEventZ& operator=(COption_MonitorEventZ&& o) { COption_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MonitorEventZ)); return *this; }
9183         LDKCOption_MonitorEventZ* operator &() { return &self; }
9184         LDKCOption_MonitorEventZ* operator ->() { return &self; }
9185         const LDKCOption_MonitorEventZ* operator &() const { return &self; }
9186         const LDKCOption_MonitorEventZ* operator ->() const { return &self; }
9187 };
9188 class COption_TypeZ {
9189 private:
9190         LDKCOption_TypeZ self;
9191 public:
9192         COption_TypeZ(const COption_TypeZ&) = delete;
9193         COption_TypeZ(COption_TypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_TypeZ)); }
9194         COption_TypeZ(LDKCOption_TypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_TypeZ)); }
9195         operator LDKCOption_TypeZ() && { LDKCOption_TypeZ res = self; memset(&self, 0, sizeof(LDKCOption_TypeZ)); return res; }
9196         ~COption_TypeZ() { COption_TypeZ_free(self); }
9197         COption_TypeZ& operator=(COption_TypeZ&& o) { COption_TypeZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_TypeZ)); return *this; }
9198         LDKCOption_TypeZ* operator &() { return &self; }
9199         LDKCOption_TypeZ* operator ->() { return &self; }
9200         const LDKCOption_TypeZ* operator &() const { return &self; }
9201         const LDKCOption_TypeZ* operator ->() const { return &self; }
9202 };
9203 class CResult_COption_TypeZDecodeErrorZ {
9204 private:
9205         LDKCResult_COption_TypeZDecodeErrorZ self;
9206 public:
9207         CResult_COption_TypeZDecodeErrorZ(const CResult_COption_TypeZDecodeErrorZ&) = delete;
9208         CResult_COption_TypeZDecodeErrorZ(CResult_COption_TypeZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_TypeZDecodeErrorZ)); }
9209         CResult_COption_TypeZDecodeErrorZ(LDKCResult_COption_TypeZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); }
9210         operator LDKCResult_COption_TypeZDecodeErrorZ() && { LDKCResult_COption_TypeZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); return res; }
9211         ~CResult_COption_TypeZDecodeErrorZ() { CResult_COption_TypeZDecodeErrorZ_free(self); }
9212         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; }
9213         LDKCResult_COption_TypeZDecodeErrorZ* operator &() { return &self; }
9214         LDKCResult_COption_TypeZDecodeErrorZ* operator ->() { return &self; }
9215         const LDKCResult_COption_TypeZDecodeErrorZ* operator &() const { return &self; }
9216         const LDKCResult_COption_TypeZDecodeErrorZ* operator ->() const { return &self; }
9217 };
9218 class CResult_COption_PathFailureZDecodeErrorZ {
9219 private:
9220         LDKCResult_COption_PathFailureZDecodeErrorZ self;
9221 public:
9222         CResult_COption_PathFailureZDecodeErrorZ(const CResult_COption_PathFailureZDecodeErrorZ&) = delete;
9223         CResult_COption_PathFailureZDecodeErrorZ(CResult_COption_PathFailureZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_PathFailureZDecodeErrorZ)); }
9224         CResult_COption_PathFailureZDecodeErrorZ(LDKCResult_COption_PathFailureZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ)); }
9225         operator LDKCResult_COption_PathFailureZDecodeErrorZ() && { LDKCResult_COption_PathFailureZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ)); return res; }
9226         ~CResult_COption_PathFailureZDecodeErrorZ() { CResult_COption_PathFailureZDecodeErrorZ_free(self); }
9227         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; }
9228         LDKCResult_COption_PathFailureZDecodeErrorZ* operator &() { return &self; }
9229         LDKCResult_COption_PathFailureZDecodeErrorZ* operator ->() { return &self; }
9230         const LDKCResult_COption_PathFailureZDecodeErrorZ* operator &() const { return &self; }
9231         const LDKCResult_COption_PathFailureZDecodeErrorZ* operator ->() const { return &self; }
9232 };
9233 class CResult_Bolt11InvoiceSignOrCreationErrorZ {
9234 private:
9235         LDKCResult_Bolt11InvoiceSignOrCreationErrorZ self;
9236 public:
9237         CResult_Bolt11InvoiceSignOrCreationErrorZ(const CResult_Bolt11InvoiceSignOrCreationErrorZ&) = delete;
9238         CResult_Bolt11InvoiceSignOrCreationErrorZ(CResult_Bolt11InvoiceSignOrCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceSignOrCreationErrorZ)); }
9239         CResult_Bolt11InvoiceSignOrCreationErrorZ(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ)); }
9240         operator LDKCResult_Bolt11InvoiceSignOrCreationErrorZ() && { LDKCResult_Bolt11InvoiceSignOrCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ)); return res; }
9241         ~CResult_Bolt11InvoiceSignOrCreationErrorZ() { CResult_Bolt11InvoiceSignOrCreationErrorZ_free(self); }
9242         CResult_Bolt11InvoiceSignOrCreationErrorZ& operator=(CResult_Bolt11InvoiceSignOrCreationErrorZ&& o) { CResult_Bolt11InvoiceSignOrCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceSignOrCreationErrorZ)); return *this; }
9243         LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator &() { return &self; }
9244         LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator ->() { return &self; }
9245         const LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator &() const { return &self; }
9246         const LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator ->() const { return &self; }
9247 };
9248 class CResult_UpdateFailHTLCDecodeErrorZ {
9249 private:
9250         LDKCResult_UpdateFailHTLCDecodeErrorZ self;
9251 public:
9252         CResult_UpdateFailHTLCDecodeErrorZ(const CResult_UpdateFailHTLCDecodeErrorZ&) = delete;
9253         CResult_UpdateFailHTLCDecodeErrorZ(CResult_UpdateFailHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); }
9254         CResult_UpdateFailHTLCDecodeErrorZ(LDKCResult_UpdateFailHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); }
9255         operator LDKCResult_UpdateFailHTLCDecodeErrorZ() && { LDKCResult_UpdateFailHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); return res; }
9256         ~CResult_UpdateFailHTLCDecodeErrorZ() { CResult_UpdateFailHTLCDecodeErrorZ_free(self); }
9257         CResult_UpdateFailHTLCDecodeErrorZ& operator=(CResult_UpdateFailHTLCDecodeErrorZ&& o) { CResult_UpdateFailHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); return *this; }
9258         LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() { return &self; }
9259         LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() { return &self; }
9260         const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() const { return &self; }
9261         const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() const { return &self; }
9262 };
9263 class CResult_CVec_BlindedPathZNoneZ {
9264 private:
9265         LDKCResult_CVec_BlindedPathZNoneZ self;
9266 public:
9267         CResult_CVec_BlindedPathZNoneZ(const CResult_CVec_BlindedPathZNoneZ&) = delete;
9268         CResult_CVec_BlindedPathZNoneZ(CResult_CVec_BlindedPathZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_BlindedPathZNoneZ)); }
9269         CResult_CVec_BlindedPathZNoneZ(LDKCResult_CVec_BlindedPathZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_BlindedPathZNoneZ)); }
9270         operator LDKCResult_CVec_BlindedPathZNoneZ() && { LDKCResult_CVec_BlindedPathZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_BlindedPathZNoneZ)); return res; }
9271         ~CResult_CVec_BlindedPathZNoneZ() { CResult_CVec_BlindedPathZNoneZ_free(self); }
9272         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; }
9273         LDKCResult_CVec_BlindedPathZNoneZ* operator &() { return &self; }
9274         LDKCResult_CVec_BlindedPathZNoneZ* operator ->() { return &self; }
9275         const LDKCResult_CVec_BlindedPathZNoneZ* operator &() const { return &self; }
9276         const LDKCResult_CVec_BlindedPathZNoneZ* operator ->() const { return &self; }
9277 };
9278 class CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ {
9279 private:
9280         LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ self;
9281 public:
9282         CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ(const CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ&) = delete;
9283         CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ(CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ)); }
9284         CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ(LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ)); }
9285         operator LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ() && { LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ)); return res; }
9286         ~CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ() { CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_free(self); }
9287         CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ& operator=(CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ&& o) { CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ)); return *this; }
9288         LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator &() { return &self; }
9289         LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator ->() { return &self; }
9290         const LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator &() const { return &self; }
9291         const LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator ->() const { return &self; }
9292 };
9293 class CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ {
9294 private:
9295         LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ self;
9296 public:
9297         CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(const CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&) = delete;
9298         CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); }
9299         CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); }
9300         operator LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); return res; }
9301         ~CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ() { CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(self); }
9302         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; }
9303         LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator &() { return &self; }
9304         LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator ->() { return &self; }
9305         const LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator &() const { return &self; }
9306         const LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator ->() const { return &self; }
9307 };
9308 class CResult_SpendableOutputDescriptorDecodeErrorZ {
9309 private:
9310         LDKCResult_SpendableOutputDescriptorDecodeErrorZ self;
9311 public:
9312         CResult_SpendableOutputDescriptorDecodeErrorZ(const CResult_SpendableOutputDescriptorDecodeErrorZ&) = delete;
9313         CResult_SpendableOutputDescriptorDecodeErrorZ(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); }
9314         CResult_SpendableOutputDescriptorDecodeErrorZ(LDKCResult_SpendableOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); }
9315         operator LDKCResult_SpendableOutputDescriptorDecodeErrorZ() && { LDKCResult_SpendableOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); return res; }
9316         ~CResult_SpendableOutputDescriptorDecodeErrorZ() { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); }
9317         CResult_SpendableOutputDescriptorDecodeErrorZ& operator=(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); return *this; }
9318         LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() { return &self; }
9319         LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
9320         const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
9321         const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
9322 };
9323 class CResult_RevokeAndACKDecodeErrorZ {
9324 private:
9325         LDKCResult_RevokeAndACKDecodeErrorZ self;
9326 public:
9327         CResult_RevokeAndACKDecodeErrorZ(const CResult_RevokeAndACKDecodeErrorZ&) = delete;
9328         CResult_RevokeAndACKDecodeErrorZ(CResult_RevokeAndACKDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); }
9329         CResult_RevokeAndACKDecodeErrorZ(LDKCResult_RevokeAndACKDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); }
9330         operator LDKCResult_RevokeAndACKDecodeErrorZ() && { LDKCResult_RevokeAndACKDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); return res; }
9331         ~CResult_RevokeAndACKDecodeErrorZ() { CResult_RevokeAndACKDecodeErrorZ_free(self); }
9332         CResult_RevokeAndACKDecodeErrorZ& operator=(CResult_RevokeAndACKDecodeErrorZ&& o) { CResult_RevokeAndACKDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); return *this; }
9333         LDKCResult_RevokeAndACKDecodeErrorZ* operator &() { return &self; }
9334         LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() { return &self; }
9335         const LDKCResult_RevokeAndACKDecodeErrorZ* operator &() const { return &self; }
9336         const LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() const { return &self; }
9337 };
9338 class CResult_UnsignedChannelUpdateDecodeErrorZ {
9339 private:
9340         LDKCResult_UnsignedChannelUpdateDecodeErrorZ self;
9341 public:
9342         CResult_UnsignedChannelUpdateDecodeErrorZ(const CResult_UnsignedChannelUpdateDecodeErrorZ&) = delete;
9343         CResult_UnsignedChannelUpdateDecodeErrorZ(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); }
9344         CResult_UnsignedChannelUpdateDecodeErrorZ(LDKCResult_UnsignedChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); }
9345         operator LDKCResult_UnsignedChannelUpdateDecodeErrorZ() && { LDKCResult_UnsignedChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); return res; }
9346         ~CResult_UnsignedChannelUpdateDecodeErrorZ() { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); }
9347         CResult_UnsignedChannelUpdateDecodeErrorZ& operator=(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); return *this; }
9348         LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() { return &self; }
9349         LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() { return &self; }
9350         const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() const { return &self; }
9351         const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
9352 };
9353 class CResult_PayeePubKeySecp256k1ErrorZ {
9354 private:
9355         LDKCResult_PayeePubKeySecp256k1ErrorZ self;
9356 public:
9357         CResult_PayeePubKeySecp256k1ErrorZ(const CResult_PayeePubKeySecp256k1ErrorZ&) = delete;
9358         CResult_PayeePubKeySecp256k1ErrorZ(CResult_PayeePubKeySecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PayeePubKeySecp256k1ErrorZ)); }
9359         CResult_PayeePubKeySecp256k1ErrorZ(LDKCResult_PayeePubKeySecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PayeePubKeySecp256k1ErrorZ)); }
9360         operator LDKCResult_PayeePubKeySecp256k1ErrorZ() && { LDKCResult_PayeePubKeySecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PayeePubKeySecp256k1ErrorZ)); return res; }
9361         ~CResult_PayeePubKeySecp256k1ErrorZ() { CResult_PayeePubKeySecp256k1ErrorZ_free(self); }
9362         CResult_PayeePubKeySecp256k1ErrorZ& operator=(CResult_PayeePubKeySecp256k1ErrorZ&& o) { CResult_PayeePubKeySecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PayeePubKeySecp256k1ErrorZ)); return *this; }
9363         LDKCResult_PayeePubKeySecp256k1ErrorZ* operator &() { return &self; }
9364         LDKCResult_PayeePubKeySecp256k1ErrorZ* operator ->() { return &self; }
9365         const LDKCResult_PayeePubKeySecp256k1ErrorZ* operator &() const { return &self; }
9366         const LDKCResult_PayeePubKeySecp256k1ErrorZ* operator ->() const { return &self; }
9367 };
9368 class C2Tuple__u832u16Z {
9369 private:
9370         LDKC2Tuple__u832u16Z self;
9371 public:
9372         C2Tuple__u832u16Z(const C2Tuple__u832u16Z&) = delete;
9373         C2Tuple__u832u16Z(C2Tuple__u832u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple__u832u16Z)); }
9374         C2Tuple__u832u16Z(LDKC2Tuple__u832u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple__u832u16Z)); }
9375         operator LDKC2Tuple__u832u16Z() && { LDKC2Tuple__u832u16Z res = self; memset(&self, 0, sizeof(LDKC2Tuple__u832u16Z)); return res; }
9376         ~C2Tuple__u832u16Z() { C2Tuple__u832u16Z_free(self); }
9377         C2Tuple__u832u16Z& operator=(C2Tuple__u832u16Z&& o) { C2Tuple__u832u16Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple__u832u16Z)); return *this; }
9378         LDKC2Tuple__u832u16Z* operator &() { return &self; }
9379         LDKC2Tuple__u832u16Z* operator ->() { return &self; }
9380         const LDKC2Tuple__u832u16Z* operator &() const { return &self; }
9381         const LDKC2Tuple__u832u16Z* operator ->() const { return &self; }
9382 };
9383 class COption_BigEndianScalarZ {
9384 private:
9385         LDKCOption_BigEndianScalarZ self;
9386 public:
9387         COption_BigEndianScalarZ(const COption_BigEndianScalarZ&) = delete;
9388         COption_BigEndianScalarZ(COption_BigEndianScalarZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_BigEndianScalarZ)); }
9389         COption_BigEndianScalarZ(LDKCOption_BigEndianScalarZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_BigEndianScalarZ)); }
9390         operator LDKCOption_BigEndianScalarZ() && { LDKCOption_BigEndianScalarZ res = self; memset(&self, 0, sizeof(LDKCOption_BigEndianScalarZ)); return res; }
9391         ~COption_BigEndianScalarZ() { COption_BigEndianScalarZ_free(self); }
9392         COption_BigEndianScalarZ& operator=(COption_BigEndianScalarZ&& o) { COption_BigEndianScalarZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_BigEndianScalarZ)); return *this; }
9393         LDKCOption_BigEndianScalarZ* operator &() { return &self; }
9394         LDKCOption_BigEndianScalarZ* operator ->() { return &self; }
9395         const LDKCOption_BigEndianScalarZ* operator &() const { return &self; }
9396         const LDKCOption_BigEndianScalarZ* operator ->() const { return &self; }
9397 };
9398 class CVec_ChannelIdZ {
9399 private:
9400         LDKCVec_ChannelIdZ self;
9401 public:
9402         CVec_ChannelIdZ(const CVec_ChannelIdZ&) = delete;
9403         CVec_ChannelIdZ(CVec_ChannelIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelIdZ)); }
9404         CVec_ChannelIdZ(LDKCVec_ChannelIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelIdZ)); }
9405         operator LDKCVec_ChannelIdZ() && { LDKCVec_ChannelIdZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelIdZ)); return res; }
9406         ~CVec_ChannelIdZ() { CVec_ChannelIdZ_free(self); }
9407         CVec_ChannelIdZ& operator=(CVec_ChannelIdZ&& o) { CVec_ChannelIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelIdZ)); return *this; }
9408         LDKCVec_ChannelIdZ* operator &() { return &self; }
9409         LDKCVec_ChannelIdZ* operator ->() { return &self; }
9410         const LDKCVec_ChannelIdZ* operator &() const { return &self; }
9411         const LDKCVec_ChannelIdZ* operator ->() const { return &self; }
9412 };
9413 class CResult_PublicKeySecp256k1ErrorZ {
9414 private:
9415         LDKCResult_PublicKeySecp256k1ErrorZ self;
9416 public:
9417         CResult_PublicKeySecp256k1ErrorZ(const CResult_PublicKeySecp256k1ErrorZ&) = delete;
9418         CResult_PublicKeySecp256k1ErrorZ(CResult_PublicKeySecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PublicKeySecp256k1ErrorZ)); }
9419         CResult_PublicKeySecp256k1ErrorZ(LDKCResult_PublicKeySecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PublicKeySecp256k1ErrorZ)); }
9420         operator LDKCResult_PublicKeySecp256k1ErrorZ() && { LDKCResult_PublicKeySecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PublicKeySecp256k1ErrorZ)); return res; }
9421         ~CResult_PublicKeySecp256k1ErrorZ() { CResult_PublicKeySecp256k1ErrorZ_free(self); }
9422         CResult_PublicKeySecp256k1ErrorZ& operator=(CResult_PublicKeySecp256k1ErrorZ&& o) { CResult_PublicKeySecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PublicKeySecp256k1ErrorZ)); return *this; }
9423         LDKCResult_PublicKeySecp256k1ErrorZ* operator &() { return &self; }
9424         LDKCResult_PublicKeySecp256k1ErrorZ* operator ->() { return &self; }
9425         const LDKCResult_PublicKeySecp256k1ErrorZ* operator &() const { return &self; }
9426         const LDKCResult_PublicKeySecp256k1ErrorZ* operator ->() const { return &self; }
9427 };
9428 class CResult_CVec_ECDSASignatureZNoneZ {
9429 private:
9430         LDKCResult_CVec_ECDSASignatureZNoneZ self;
9431 public:
9432         CResult_CVec_ECDSASignatureZNoneZ(const CResult_CVec_ECDSASignatureZNoneZ&) = delete;
9433         CResult_CVec_ECDSASignatureZNoneZ(CResult_CVec_ECDSASignatureZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_ECDSASignatureZNoneZ)); }
9434         CResult_CVec_ECDSASignatureZNoneZ(LDKCResult_CVec_ECDSASignatureZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ)); }
9435         operator LDKCResult_CVec_ECDSASignatureZNoneZ() && { LDKCResult_CVec_ECDSASignatureZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ)); return res; }
9436         ~CResult_CVec_ECDSASignatureZNoneZ() { CResult_CVec_ECDSASignatureZNoneZ_free(self); }
9437         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; }
9438         LDKCResult_CVec_ECDSASignatureZNoneZ* operator &() { return &self; }
9439         LDKCResult_CVec_ECDSASignatureZNoneZ* operator ->() { return &self; }
9440         const LDKCResult_CVec_ECDSASignatureZNoneZ* operator &() const { return &self; }
9441         const LDKCResult_CVec_ECDSASignatureZNoneZ* operator ->() const { return &self; }
9442 };
9443 class CVec_BlindedHopZ {
9444 private:
9445         LDKCVec_BlindedHopZ self;
9446 public:
9447         CVec_BlindedHopZ(const CVec_BlindedHopZ&) = delete;
9448         CVec_BlindedHopZ(CVec_BlindedHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BlindedHopZ)); }
9449         CVec_BlindedHopZ(LDKCVec_BlindedHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BlindedHopZ)); }
9450         operator LDKCVec_BlindedHopZ() && { LDKCVec_BlindedHopZ res = self; memset(&self, 0, sizeof(LDKCVec_BlindedHopZ)); return res; }
9451         ~CVec_BlindedHopZ() { CVec_BlindedHopZ_free(self); }
9452         CVec_BlindedHopZ& operator=(CVec_BlindedHopZ&& o) { CVec_BlindedHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BlindedHopZ)); return *this; }
9453         LDKCVec_BlindedHopZ* operator &() { return &self; }
9454         LDKCVec_BlindedHopZ* operator ->() { return &self; }
9455         const LDKCVec_BlindedHopZ* operator &() const { return &self; }
9456         const LDKCVec_BlindedHopZ* operator ->() const { return &self; }
9457 };
9458 class CResult_COption_ClosureReasonZDecodeErrorZ {
9459 private:
9460         LDKCResult_COption_ClosureReasonZDecodeErrorZ self;
9461 public:
9462         CResult_COption_ClosureReasonZDecodeErrorZ(const CResult_COption_ClosureReasonZDecodeErrorZ&) = delete;
9463         CResult_COption_ClosureReasonZDecodeErrorZ(CResult_COption_ClosureReasonZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_ClosureReasonZDecodeErrorZ)); }
9464         CResult_COption_ClosureReasonZDecodeErrorZ(LDKCResult_COption_ClosureReasonZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); }
9465         operator LDKCResult_COption_ClosureReasonZDecodeErrorZ() && { LDKCResult_COption_ClosureReasonZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); return res; }
9466         ~CResult_COption_ClosureReasonZDecodeErrorZ() { CResult_COption_ClosureReasonZDecodeErrorZ_free(self); }
9467         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; }
9468         LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() { return &self; }
9469         LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() { return &self; }
9470         const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() const { return &self; }
9471         const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() const { return &self; }
9472 };
9473 class CResult_InvoiceErrorDecodeErrorZ {
9474 private:
9475         LDKCResult_InvoiceErrorDecodeErrorZ self;
9476 public:
9477         CResult_InvoiceErrorDecodeErrorZ(const CResult_InvoiceErrorDecodeErrorZ&) = delete;
9478         CResult_InvoiceErrorDecodeErrorZ(CResult_InvoiceErrorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceErrorDecodeErrorZ)); }
9479         CResult_InvoiceErrorDecodeErrorZ(LDKCResult_InvoiceErrorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceErrorDecodeErrorZ)); }
9480         operator LDKCResult_InvoiceErrorDecodeErrorZ() && { LDKCResult_InvoiceErrorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceErrorDecodeErrorZ)); return res; }
9481         ~CResult_InvoiceErrorDecodeErrorZ() { CResult_InvoiceErrorDecodeErrorZ_free(self); }
9482         CResult_InvoiceErrorDecodeErrorZ& operator=(CResult_InvoiceErrorDecodeErrorZ&& o) { CResult_InvoiceErrorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceErrorDecodeErrorZ)); return *this; }
9483         LDKCResult_InvoiceErrorDecodeErrorZ* operator &() { return &self; }
9484         LDKCResult_InvoiceErrorDecodeErrorZ* operator ->() { return &self; }
9485         const LDKCResult_InvoiceErrorDecodeErrorZ* operator &() const { return &self; }
9486         const LDKCResult_InvoiceErrorDecodeErrorZ* operator ->() const { return &self; }
9487 };
9488 class C2Tuple_BestBlockOutputSweeperZ {
9489 private:
9490         LDKC2Tuple_BestBlockOutputSweeperZ self;
9491 public:
9492         C2Tuple_BestBlockOutputSweeperZ(const C2Tuple_BestBlockOutputSweeperZ&) = delete;
9493         C2Tuple_BestBlockOutputSweeperZ(C2Tuple_BestBlockOutputSweeperZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BestBlockOutputSweeperZ)); }
9494         C2Tuple_BestBlockOutputSweeperZ(LDKC2Tuple_BestBlockOutputSweeperZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BestBlockOutputSweeperZ)); }
9495         operator LDKC2Tuple_BestBlockOutputSweeperZ() && { LDKC2Tuple_BestBlockOutputSweeperZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BestBlockOutputSweeperZ)); return res; }
9496         ~C2Tuple_BestBlockOutputSweeperZ() { C2Tuple_BestBlockOutputSweeperZ_free(self); }
9497         C2Tuple_BestBlockOutputSweeperZ& operator=(C2Tuple_BestBlockOutputSweeperZ&& o) { C2Tuple_BestBlockOutputSweeperZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BestBlockOutputSweeperZ)); return *this; }
9498         LDKC2Tuple_BestBlockOutputSweeperZ* operator &() { return &self; }
9499         LDKC2Tuple_BestBlockOutputSweeperZ* operator ->() { return &self; }
9500         const LDKC2Tuple_BestBlockOutputSweeperZ* operator &() const { return &self; }
9501         const LDKC2Tuple_BestBlockOutputSweeperZ* operator ->() const { return &self; }
9502 };
9503 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
9504 private:
9505         LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ self;
9506 public:
9507         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(const C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&) = delete;
9508         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
9509         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
9510         operator LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() && { LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return res; }
9511         ~C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); }
9512         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ& operator=(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return *this; }
9513         LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() { return &self; }
9514         LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() { return &self; }
9515         const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() const { return &self; }
9516         const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() const { return &self; }
9517 };
9518 class CResult_RouteParametersDecodeErrorZ {
9519 private:
9520         LDKCResult_RouteParametersDecodeErrorZ self;
9521 public:
9522         CResult_RouteParametersDecodeErrorZ(const CResult_RouteParametersDecodeErrorZ&) = delete;
9523         CResult_RouteParametersDecodeErrorZ(CResult_RouteParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); }
9524         CResult_RouteParametersDecodeErrorZ(LDKCResult_RouteParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); }
9525         operator LDKCResult_RouteParametersDecodeErrorZ() && { LDKCResult_RouteParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); return res; }
9526         ~CResult_RouteParametersDecodeErrorZ() { CResult_RouteParametersDecodeErrorZ_free(self); }
9527         CResult_RouteParametersDecodeErrorZ& operator=(CResult_RouteParametersDecodeErrorZ&& o) { CResult_RouteParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); return *this; }
9528         LDKCResult_RouteParametersDecodeErrorZ* operator &() { return &self; }
9529         LDKCResult_RouteParametersDecodeErrorZ* operator ->() { return &self; }
9530         const LDKCResult_RouteParametersDecodeErrorZ* operator &() const { return &self; }
9531         const LDKCResult_RouteParametersDecodeErrorZ* operator ->() const { return &self; }
9532 };
9533 class CResult_PrivateRouteCreationErrorZ {
9534 private:
9535         LDKCResult_PrivateRouteCreationErrorZ self;
9536 public:
9537         CResult_PrivateRouteCreationErrorZ(const CResult_PrivateRouteCreationErrorZ&) = delete;
9538         CResult_PrivateRouteCreationErrorZ(CResult_PrivateRouteCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); }
9539         CResult_PrivateRouteCreationErrorZ(LDKCResult_PrivateRouteCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); }
9540         operator LDKCResult_PrivateRouteCreationErrorZ() && { LDKCResult_PrivateRouteCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); return res; }
9541         ~CResult_PrivateRouteCreationErrorZ() { CResult_PrivateRouteCreationErrorZ_free(self); }
9542         CResult_PrivateRouteCreationErrorZ& operator=(CResult_PrivateRouteCreationErrorZ&& o) { CResult_PrivateRouteCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); return *this; }
9543         LDKCResult_PrivateRouteCreationErrorZ* operator &() { return &self; }
9544         LDKCResult_PrivateRouteCreationErrorZ* operator ->() { return &self; }
9545         const LDKCResult_PrivateRouteCreationErrorZ* operator &() const { return &self; }
9546         const LDKCResult_PrivateRouteCreationErrorZ* operator ->() const { return &self; }
9547 };
9548 class CResult_NodeAliasDecodeErrorZ {
9549 private:
9550         LDKCResult_NodeAliasDecodeErrorZ self;
9551 public:
9552         CResult_NodeAliasDecodeErrorZ(const CResult_NodeAliasDecodeErrorZ&) = delete;
9553         CResult_NodeAliasDecodeErrorZ(CResult_NodeAliasDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); }
9554         CResult_NodeAliasDecodeErrorZ(LDKCResult_NodeAliasDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); }
9555         operator LDKCResult_NodeAliasDecodeErrorZ() && { LDKCResult_NodeAliasDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); return res; }
9556         ~CResult_NodeAliasDecodeErrorZ() { CResult_NodeAliasDecodeErrorZ_free(self); }
9557         CResult_NodeAliasDecodeErrorZ& operator=(CResult_NodeAliasDecodeErrorZ&& o) { CResult_NodeAliasDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); return *this; }
9558         LDKCResult_NodeAliasDecodeErrorZ* operator &() { return &self; }
9559         LDKCResult_NodeAliasDecodeErrorZ* operator ->() { return &self; }
9560         const LDKCResult_NodeAliasDecodeErrorZ* operator &() const { return &self; }
9561         const LDKCResult_NodeAliasDecodeErrorZ* operator ->() const { return &self; }
9562 };
9563 class CVec_UpdateFulfillHTLCZ {
9564 private:
9565         LDKCVec_UpdateFulfillHTLCZ self;
9566 public:
9567         CVec_UpdateFulfillHTLCZ(const CVec_UpdateFulfillHTLCZ&) = delete;
9568         CVec_UpdateFulfillHTLCZ(CVec_UpdateFulfillHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); }
9569         CVec_UpdateFulfillHTLCZ(LDKCVec_UpdateFulfillHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); }
9570         operator LDKCVec_UpdateFulfillHTLCZ() && { LDKCVec_UpdateFulfillHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); return res; }
9571         ~CVec_UpdateFulfillHTLCZ() { CVec_UpdateFulfillHTLCZ_free(self); }
9572         CVec_UpdateFulfillHTLCZ& operator=(CVec_UpdateFulfillHTLCZ&& o) { CVec_UpdateFulfillHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); return *this; }
9573         LDKCVec_UpdateFulfillHTLCZ* operator &() { return &self; }
9574         LDKCVec_UpdateFulfillHTLCZ* operator ->() { return &self; }
9575         const LDKCVec_UpdateFulfillHTLCZ* operator &() const { return &self; }
9576         const LDKCVec_UpdateFulfillHTLCZ* operator ->() const { return &self; }
9577 };
9578 class CVec_C2Tuple_u32CVec_u8ZZZ {
9579 private:
9580         LDKCVec_C2Tuple_u32CVec_u8ZZZ self;
9581 public:
9582         CVec_C2Tuple_u32CVec_u8ZZZ(const CVec_C2Tuple_u32CVec_u8ZZZ&) = delete;
9583         CVec_C2Tuple_u32CVec_u8ZZZ(CVec_C2Tuple_u32CVec_u8ZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32CVec_u8ZZZ)); }
9584         CVec_C2Tuple_u32CVec_u8ZZZ(LDKCVec_C2Tuple_u32CVec_u8ZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32CVec_u8ZZZ)); }
9585         operator LDKCVec_C2Tuple_u32CVec_u8ZZZ() && { LDKCVec_C2Tuple_u32CVec_u8ZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32CVec_u8ZZZ)); return res; }
9586         ~CVec_C2Tuple_u32CVec_u8ZZZ() { CVec_C2Tuple_u32CVec_u8ZZZ_free(self); }
9587         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; }
9588         LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator &() { return &self; }
9589         LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator ->() { return &self; }
9590         const LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator &() const { return &self; }
9591         const LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator ->() const { return &self; }
9592 };
9593 class C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ {
9594 private:
9595         LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ self;
9596 public:
9597         C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ(const C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ&) = delete;
9598         C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ(C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ)); }
9599         C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ)); }
9600         operator LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ() && { LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ)); return res; }
9601         ~C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ() { C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_free(self); }
9602         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; }
9603         LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ* operator &() { return &self; }
9604         LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ* operator ->() { return &self; }
9605         const LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ* operator &() const { return &self; }
9606         const LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ* operator ->() const { return &self; }
9607 };
9608 class CResult_AnnouncementSignaturesDecodeErrorZ {
9609 private:
9610         LDKCResult_AnnouncementSignaturesDecodeErrorZ self;
9611 public:
9612         CResult_AnnouncementSignaturesDecodeErrorZ(const CResult_AnnouncementSignaturesDecodeErrorZ&) = delete;
9613         CResult_AnnouncementSignaturesDecodeErrorZ(CResult_AnnouncementSignaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); }
9614         CResult_AnnouncementSignaturesDecodeErrorZ(LDKCResult_AnnouncementSignaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); }
9615         operator LDKCResult_AnnouncementSignaturesDecodeErrorZ() && { LDKCResult_AnnouncementSignaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); return res; }
9616         ~CResult_AnnouncementSignaturesDecodeErrorZ() { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); }
9617         CResult_AnnouncementSignaturesDecodeErrorZ& operator=(CResult_AnnouncementSignaturesDecodeErrorZ&& o) { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); return *this; }
9618         LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() { return &self; }
9619         LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() { return &self; }
9620         const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() const { return &self; }
9621         const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() const { return &self; }
9622 };
9623 class CResult_TxCompleteDecodeErrorZ {
9624 private:
9625         LDKCResult_TxCompleteDecodeErrorZ self;
9626 public:
9627         CResult_TxCompleteDecodeErrorZ(const CResult_TxCompleteDecodeErrorZ&) = delete;
9628         CResult_TxCompleteDecodeErrorZ(CResult_TxCompleteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCompleteDecodeErrorZ)); }
9629         CResult_TxCompleteDecodeErrorZ(LDKCResult_TxCompleteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCompleteDecodeErrorZ)); }
9630         operator LDKCResult_TxCompleteDecodeErrorZ() && { LDKCResult_TxCompleteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCompleteDecodeErrorZ)); return res; }
9631         ~CResult_TxCompleteDecodeErrorZ() { CResult_TxCompleteDecodeErrorZ_free(self); }
9632         CResult_TxCompleteDecodeErrorZ& operator=(CResult_TxCompleteDecodeErrorZ&& o) { CResult_TxCompleteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCompleteDecodeErrorZ)); return *this; }
9633         LDKCResult_TxCompleteDecodeErrorZ* operator &() { return &self; }
9634         LDKCResult_TxCompleteDecodeErrorZ* operator ->() { return &self; }
9635         const LDKCResult_TxCompleteDecodeErrorZ* operator &() const { return &self; }
9636         const LDKCResult_TxCompleteDecodeErrorZ* operator ->() const { return &self; }
9637 };
9638 class CResult_UpdateFulfillHTLCDecodeErrorZ {
9639 private:
9640         LDKCResult_UpdateFulfillHTLCDecodeErrorZ self;
9641 public:
9642         CResult_UpdateFulfillHTLCDecodeErrorZ(const CResult_UpdateFulfillHTLCDecodeErrorZ&) = delete;
9643         CResult_UpdateFulfillHTLCDecodeErrorZ(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); }
9644         CResult_UpdateFulfillHTLCDecodeErrorZ(LDKCResult_UpdateFulfillHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); }
9645         operator LDKCResult_UpdateFulfillHTLCDecodeErrorZ() && { LDKCResult_UpdateFulfillHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); return res; }
9646         ~CResult_UpdateFulfillHTLCDecodeErrorZ() { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); }
9647         CResult_UpdateFulfillHTLCDecodeErrorZ& operator=(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); return *this; }
9648         LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() { return &self; }
9649         LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() { return &self; }
9650         const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() const { return &self; }
9651         const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() const { return &self; }
9652 };
9653 class CResult_NodeFeaturesDecodeErrorZ {
9654 private:
9655         LDKCResult_NodeFeaturesDecodeErrorZ self;
9656 public:
9657         CResult_NodeFeaturesDecodeErrorZ(const CResult_NodeFeaturesDecodeErrorZ&) = delete;
9658         CResult_NodeFeaturesDecodeErrorZ(CResult_NodeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); }
9659         CResult_NodeFeaturesDecodeErrorZ(LDKCResult_NodeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); }
9660         operator LDKCResult_NodeFeaturesDecodeErrorZ() && { LDKCResult_NodeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); return res; }
9661         ~CResult_NodeFeaturesDecodeErrorZ() { CResult_NodeFeaturesDecodeErrorZ_free(self); }
9662         CResult_NodeFeaturesDecodeErrorZ& operator=(CResult_NodeFeaturesDecodeErrorZ&& o) { CResult_NodeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); return *this; }
9663         LDKCResult_NodeFeaturesDecodeErrorZ* operator &() { return &self; }
9664         LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() { return &self; }
9665         const LDKCResult_NodeFeaturesDecodeErrorZ* operator &() const { return &self; }
9666         const LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() const { return &self; }
9667 };
9668 class CResult_InMemorySignerDecodeErrorZ {
9669 private:
9670         LDKCResult_InMemorySignerDecodeErrorZ self;
9671 public:
9672         CResult_InMemorySignerDecodeErrorZ(const CResult_InMemorySignerDecodeErrorZ&) = delete;
9673         CResult_InMemorySignerDecodeErrorZ(CResult_InMemorySignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); }
9674         CResult_InMemorySignerDecodeErrorZ(LDKCResult_InMemorySignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); }
9675         operator LDKCResult_InMemorySignerDecodeErrorZ() && { LDKCResult_InMemorySignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); return res; }
9676         ~CResult_InMemorySignerDecodeErrorZ() { CResult_InMemorySignerDecodeErrorZ_free(self); }
9677         CResult_InMemorySignerDecodeErrorZ& operator=(CResult_InMemorySignerDecodeErrorZ&& o) { CResult_InMemorySignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); return *this; }
9678         LDKCResult_InMemorySignerDecodeErrorZ* operator &() { return &self; }
9679         LDKCResult_InMemorySignerDecodeErrorZ* operator ->() { return &self; }
9680         const LDKCResult_InMemorySignerDecodeErrorZ* operator &() const { return &self; }
9681         const LDKCResult_InMemorySignerDecodeErrorZ* operator ->() const { return &self; }
9682 };
9683 class CResult_TxSignaturesDecodeErrorZ {
9684 private:
9685         LDKCResult_TxSignaturesDecodeErrorZ self;
9686 public:
9687         CResult_TxSignaturesDecodeErrorZ(const CResult_TxSignaturesDecodeErrorZ&) = delete;
9688         CResult_TxSignaturesDecodeErrorZ(CResult_TxSignaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxSignaturesDecodeErrorZ)); }
9689         CResult_TxSignaturesDecodeErrorZ(LDKCResult_TxSignaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxSignaturesDecodeErrorZ)); }
9690         operator LDKCResult_TxSignaturesDecodeErrorZ() && { LDKCResult_TxSignaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxSignaturesDecodeErrorZ)); return res; }
9691         ~CResult_TxSignaturesDecodeErrorZ() { CResult_TxSignaturesDecodeErrorZ_free(self); }
9692         CResult_TxSignaturesDecodeErrorZ& operator=(CResult_TxSignaturesDecodeErrorZ&& o) { CResult_TxSignaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxSignaturesDecodeErrorZ)); return *this; }
9693         LDKCResult_TxSignaturesDecodeErrorZ* operator &() { return &self; }
9694         LDKCResult_TxSignaturesDecodeErrorZ* operator ->() { return &self; }
9695         const LDKCResult_TxSignaturesDecodeErrorZ* operator &() const { return &self; }
9696         const LDKCResult_TxSignaturesDecodeErrorZ* operator ->() const { return &self; }
9697 };
9698 class CVec_HTLCDescriptorZ {
9699 private:
9700         LDKCVec_HTLCDescriptorZ self;
9701 public:
9702         CVec_HTLCDescriptorZ(const CVec_HTLCDescriptorZ&) = delete;
9703         CVec_HTLCDescriptorZ(CVec_HTLCDescriptorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_HTLCDescriptorZ)); }
9704         CVec_HTLCDescriptorZ(LDKCVec_HTLCDescriptorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_HTLCDescriptorZ)); }
9705         operator LDKCVec_HTLCDescriptorZ() && { LDKCVec_HTLCDescriptorZ res = self; memset(&self, 0, sizeof(LDKCVec_HTLCDescriptorZ)); return res; }
9706         ~CVec_HTLCDescriptorZ() { CVec_HTLCDescriptorZ_free(self); }
9707         CVec_HTLCDescriptorZ& operator=(CVec_HTLCDescriptorZ&& o) { CVec_HTLCDescriptorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_HTLCDescriptorZ)); return *this; }
9708         LDKCVec_HTLCDescriptorZ* operator &() { return &self; }
9709         LDKCVec_HTLCDescriptorZ* operator ->() { return &self; }
9710         const LDKCVec_HTLCDescriptorZ* operator &() const { return &self; }
9711         const LDKCVec_HTLCDescriptorZ* operator ->() const { return &self; }
9712 };
9713 class CResult_ReplyShortChannelIdsEndDecodeErrorZ {
9714 private:
9715         LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ self;
9716 public:
9717         CResult_ReplyShortChannelIdsEndDecodeErrorZ(const CResult_ReplyShortChannelIdsEndDecodeErrorZ&) = delete;
9718         CResult_ReplyShortChannelIdsEndDecodeErrorZ(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
9719         CResult_ReplyShortChannelIdsEndDecodeErrorZ(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
9720         operator LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ() && { LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); return res; }
9721         ~CResult_ReplyShortChannelIdsEndDecodeErrorZ() { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); }
9722         CResult_ReplyShortChannelIdsEndDecodeErrorZ& operator=(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); return *this; }
9723         LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() { return &self; }
9724         LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() { return &self; }
9725         const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() const { return &self; }
9726         const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() const { return &self; }
9727 };
9728 class COption_PathFailureZ {
9729 private:
9730         LDKCOption_PathFailureZ self;
9731 public:
9732         COption_PathFailureZ(const COption_PathFailureZ&) = delete;
9733         COption_PathFailureZ(COption_PathFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_PathFailureZ)); }
9734         COption_PathFailureZ(LDKCOption_PathFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_PathFailureZ)); }
9735         operator LDKCOption_PathFailureZ() && { LDKCOption_PathFailureZ res = self; memset(&self, 0, sizeof(LDKCOption_PathFailureZ)); return res; }
9736         ~COption_PathFailureZ() { COption_PathFailureZ_free(self); }
9737         COption_PathFailureZ& operator=(COption_PathFailureZ&& o) { COption_PathFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_PathFailureZ)); return *this; }
9738         LDKCOption_PathFailureZ* operator &() { return &self; }
9739         LDKCOption_PathFailureZ* operator ->() { return &self; }
9740         const LDKCOption_PathFailureZ* operator &() const { return &self; }
9741         const LDKCOption_PathFailureZ* operator ->() const { return &self; }
9742 };
9743 class CResult_StrSecp256k1ErrorZ {
9744 private:
9745         LDKCResult_StrSecp256k1ErrorZ self;
9746 public:
9747         CResult_StrSecp256k1ErrorZ(const CResult_StrSecp256k1ErrorZ&) = delete;
9748         CResult_StrSecp256k1ErrorZ(CResult_StrSecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StrSecp256k1ErrorZ)); }
9749         CResult_StrSecp256k1ErrorZ(LDKCResult_StrSecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StrSecp256k1ErrorZ)); }
9750         operator LDKCResult_StrSecp256k1ErrorZ() && { LDKCResult_StrSecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StrSecp256k1ErrorZ)); return res; }
9751         ~CResult_StrSecp256k1ErrorZ() { CResult_StrSecp256k1ErrorZ_free(self); }
9752         CResult_StrSecp256k1ErrorZ& operator=(CResult_StrSecp256k1ErrorZ&& o) { CResult_StrSecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StrSecp256k1ErrorZ)); return *this; }
9753         LDKCResult_StrSecp256k1ErrorZ* operator &() { return &self; }
9754         LDKCResult_StrSecp256k1ErrorZ* operator ->() { return &self; }
9755         const LDKCResult_StrSecp256k1ErrorZ* operator &() const { return &self; }
9756         const LDKCResult_StrSecp256k1ErrorZ* operator ->() const { return &self; }
9757 };
9758 class CVec_ECDSASignatureZ {
9759 private:
9760         LDKCVec_ECDSASignatureZ self;
9761 public:
9762         CVec_ECDSASignatureZ(const CVec_ECDSASignatureZ&) = delete;
9763         CVec_ECDSASignatureZ(CVec_ECDSASignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ECDSASignatureZ)); }
9764         CVec_ECDSASignatureZ(LDKCVec_ECDSASignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ECDSASignatureZ)); }
9765         operator LDKCVec_ECDSASignatureZ() && { LDKCVec_ECDSASignatureZ res = self; memset(&self, 0, sizeof(LDKCVec_ECDSASignatureZ)); return res; }
9766         ~CVec_ECDSASignatureZ() { CVec_ECDSASignatureZ_free(self); }
9767         CVec_ECDSASignatureZ& operator=(CVec_ECDSASignatureZ&& o) { CVec_ECDSASignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ECDSASignatureZ)); return *this; }
9768         LDKCVec_ECDSASignatureZ* operator &() { return &self; }
9769         LDKCVec_ECDSASignatureZ* operator ->() { return &self; }
9770         const LDKCVec_ECDSASignatureZ* operator &() const { return &self; }
9771         const LDKCVec_ECDSASignatureZ* operator ->() const { return &self; }
9772 };
9773 class CResult_ChannelUpdateInfoDecodeErrorZ {
9774 private:
9775         LDKCResult_ChannelUpdateInfoDecodeErrorZ self;
9776 public:
9777         CResult_ChannelUpdateInfoDecodeErrorZ(const CResult_ChannelUpdateInfoDecodeErrorZ&) = delete;
9778         CResult_ChannelUpdateInfoDecodeErrorZ(CResult_ChannelUpdateInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); }
9779         CResult_ChannelUpdateInfoDecodeErrorZ(LDKCResult_ChannelUpdateInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); }
9780         operator LDKCResult_ChannelUpdateInfoDecodeErrorZ() && { LDKCResult_ChannelUpdateInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); return res; }
9781         ~CResult_ChannelUpdateInfoDecodeErrorZ() { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); }
9782         CResult_ChannelUpdateInfoDecodeErrorZ& operator=(CResult_ChannelUpdateInfoDecodeErrorZ&& o) { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); return *this; }
9783         LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() { return &self; }
9784         LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() { return &self; }
9785         const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() const { return &self; }
9786         const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() const { return &self; }
9787 };
9788 class CVec_UpdateFailHTLCZ {
9789 private:
9790         LDKCVec_UpdateFailHTLCZ self;
9791 public:
9792         CVec_UpdateFailHTLCZ(const CVec_UpdateFailHTLCZ&) = delete;
9793         CVec_UpdateFailHTLCZ(CVec_UpdateFailHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); }
9794         CVec_UpdateFailHTLCZ(LDKCVec_UpdateFailHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); }
9795         operator LDKCVec_UpdateFailHTLCZ() && { LDKCVec_UpdateFailHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); return res; }
9796         ~CVec_UpdateFailHTLCZ() { CVec_UpdateFailHTLCZ_free(self); }
9797         CVec_UpdateFailHTLCZ& operator=(CVec_UpdateFailHTLCZ&& o) { CVec_UpdateFailHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); return *this; }
9798         LDKCVec_UpdateFailHTLCZ* operator &() { return &self; }
9799         LDKCVec_UpdateFailHTLCZ* operator ->() { return &self; }
9800         const LDKCVec_UpdateFailHTLCZ* operator &() const { return &self; }
9801         const LDKCVec_UpdateFailHTLCZ* operator ->() const { return &self; }
9802 };
9803 class CVec_TxOutZ {
9804 private:
9805         LDKCVec_TxOutZ self;
9806 public:
9807         CVec_TxOutZ(const CVec_TxOutZ&) = delete;
9808         CVec_TxOutZ(CVec_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TxOutZ)); }
9809         CVec_TxOutZ(LDKCVec_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TxOutZ)); }
9810         operator LDKCVec_TxOutZ() && { LDKCVec_TxOutZ res = self; memset(&self, 0, sizeof(LDKCVec_TxOutZ)); return res; }
9811         ~CVec_TxOutZ() { CVec_TxOutZ_free(self); }
9812         CVec_TxOutZ& operator=(CVec_TxOutZ&& o) { CVec_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TxOutZ)); return *this; }
9813         LDKCVec_TxOutZ* operator &() { return &self; }
9814         LDKCVec_TxOutZ* operator ->() { return &self; }
9815         const LDKCVec_TxOutZ* operator &() const { return &self; }
9816         const LDKCVec_TxOutZ* operator ->() const { return &self; }
9817 };
9818 class CResult_BuiltCommitmentTransactionDecodeErrorZ {
9819 private:
9820         LDKCResult_BuiltCommitmentTransactionDecodeErrorZ self;
9821 public:
9822         CResult_BuiltCommitmentTransactionDecodeErrorZ(const CResult_BuiltCommitmentTransactionDecodeErrorZ&) = delete;
9823         CResult_BuiltCommitmentTransactionDecodeErrorZ(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); }
9824         CResult_BuiltCommitmentTransactionDecodeErrorZ(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); }
9825         operator LDKCResult_BuiltCommitmentTransactionDecodeErrorZ() && { LDKCResult_BuiltCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); return res; }
9826         ~CResult_BuiltCommitmentTransactionDecodeErrorZ() { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); }
9827         CResult_BuiltCommitmentTransactionDecodeErrorZ& operator=(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); return *this; }
9828         LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
9829         LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
9830         const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
9831         const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
9832 };
9833 class CResult_TrackedSpendableOutputDecodeErrorZ {
9834 private:
9835         LDKCResult_TrackedSpendableOutputDecodeErrorZ self;
9836 public:
9837         CResult_TrackedSpendableOutputDecodeErrorZ(const CResult_TrackedSpendableOutputDecodeErrorZ&) = delete;
9838         CResult_TrackedSpendableOutputDecodeErrorZ(CResult_TrackedSpendableOutputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrackedSpendableOutputDecodeErrorZ)); }
9839         CResult_TrackedSpendableOutputDecodeErrorZ(LDKCResult_TrackedSpendableOutputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrackedSpendableOutputDecodeErrorZ)); }
9840         operator LDKCResult_TrackedSpendableOutputDecodeErrorZ() && { LDKCResult_TrackedSpendableOutputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TrackedSpendableOutputDecodeErrorZ)); return res; }
9841         ~CResult_TrackedSpendableOutputDecodeErrorZ() { CResult_TrackedSpendableOutputDecodeErrorZ_free(self); }
9842         CResult_TrackedSpendableOutputDecodeErrorZ& operator=(CResult_TrackedSpendableOutputDecodeErrorZ&& o) { CResult_TrackedSpendableOutputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrackedSpendableOutputDecodeErrorZ)); return *this; }
9843         LDKCResult_TrackedSpendableOutputDecodeErrorZ* operator &() { return &self; }
9844         LDKCResult_TrackedSpendableOutputDecodeErrorZ* operator ->() { return &self; }
9845         const LDKCResult_TrackedSpendableOutputDecodeErrorZ* operator &() const { return &self; }
9846         const LDKCResult_TrackedSpendableOutputDecodeErrorZ* operator ->() const { return &self; }
9847 };
9848 class CVec_SpendableOutputDescriptorZ {
9849 private:
9850         LDKCVec_SpendableOutputDescriptorZ self;
9851 public:
9852         CVec_SpendableOutputDescriptorZ(const CVec_SpendableOutputDescriptorZ&) = delete;
9853         CVec_SpendableOutputDescriptorZ(CVec_SpendableOutputDescriptorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SpendableOutputDescriptorZ)); }
9854         CVec_SpendableOutputDescriptorZ(LDKCVec_SpendableOutputDescriptorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SpendableOutputDescriptorZ)); }
9855         operator LDKCVec_SpendableOutputDescriptorZ() && { LDKCVec_SpendableOutputDescriptorZ res = self; memset(&self, 0, sizeof(LDKCVec_SpendableOutputDescriptorZ)); return res; }
9856         ~CVec_SpendableOutputDescriptorZ() { CVec_SpendableOutputDescriptorZ_free(self); }
9857         CVec_SpendableOutputDescriptorZ& operator=(CVec_SpendableOutputDescriptorZ&& o) { CVec_SpendableOutputDescriptorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_SpendableOutputDescriptorZ)); return *this; }
9858         LDKCVec_SpendableOutputDescriptorZ* operator &() { return &self; }
9859         LDKCVec_SpendableOutputDescriptorZ* operator ->() { return &self; }
9860         const LDKCVec_SpendableOutputDescriptorZ* operator &() const { return &self; }
9861         const LDKCVec_SpendableOutputDescriptorZ* operator ->() const { return &self; }
9862 };
9863 class C2Tuple_OutPointCVec_u8ZZ {
9864 private:
9865         LDKC2Tuple_OutPointCVec_u8ZZ self;
9866 public:
9867         C2Tuple_OutPointCVec_u8ZZ(const C2Tuple_OutPointCVec_u8ZZ&) = delete;
9868         C2Tuple_OutPointCVec_u8ZZ(C2Tuple_OutPointCVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointCVec_u8ZZ)); }
9869         C2Tuple_OutPointCVec_u8ZZ(LDKC2Tuple_OutPointCVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointCVec_u8ZZ)); }
9870         operator LDKC2Tuple_OutPointCVec_u8ZZ() && { LDKC2Tuple_OutPointCVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointCVec_u8ZZ)); return res; }
9871         ~C2Tuple_OutPointCVec_u8ZZ() { C2Tuple_OutPointCVec_u8ZZ_free(self); }
9872         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; }
9873         LDKC2Tuple_OutPointCVec_u8ZZ* operator &() { return &self; }
9874         LDKC2Tuple_OutPointCVec_u8ZZ* operator ->() { return &self; }
9875         const LDKC2Tuple_OutPointCVec_u8ZZ* operator &() const { return &self; }
9876         const LDKC2Tuple_OutPointCVec_u8ZZ* operator ->() const { return &self; }
9877 };
9878 class CResult_WitnessNoneZ {
9879 private:
9880         LDKCResult_WitnessNoneZ self;
9881 public:
9882         CResult_WitnessNoneZ(const CResult_WitnessNoneZ&) = delete;
9883         CResult_WitnessNoneZ(CResult_WitnessNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WitnessNoneZ)); }
9884         CResult_WitnessNoneZ(LDKCResult_WitnessNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WitnessNoneZ)); }
9885         operator LDKCResult_WitnessNoneZ() && { LDKCResult_WitnessNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_WitnessNoneZ)); return res; }
9886         ~CResult_WitnessNoneZ() { CResult_WitnessNoneZ_free(self); }
9887         CResult_WitnessNoneZ& operator=(CResult_WitnessNoneZ&& o) { CResult_WitnessNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WitnessNoneZ)); return *this; }
9888         LDKCResult_WitnessNoneZ* operator &() { return &self; }
9889         LDKCResult_WitnessNoneZ* operator ->() { return &self; }
9890         const LDKCResult_WitnessNoneZ* operator &() const { return &self; }
9891         const LDKCResult_WitnessNoneZ* operator ->() const { return &self; }
9892 };
9893 class COption_C2Tuple_u64u64ZZ {
9894 private:
9895         LDKCOption_C2Tuple_u64u64ZZ self;
9896 public:
9897         COption_C2Tuple_u64u64ZZ(const COption_C2Tuple_u64u64ZZ&) = delete;
9898         COption_C2Tuple_u64u64ZZ(COption_C2Tuple_u64u64ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_u64u64ZZ)); }
9899         COption_C2Tuple_u64u64ZZ(LDKCOption_C2Tuple_u64u64ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_u64u64ZZ)); }
9900         operator LDKCOption_C2Tuple_u64u64ZZ() && { LDKCOption_C2Tuple_u64u64ZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_u64u64ZZ)); return res; }
9901         ~COption_C2Tuple_u64u64ZZ() { COption_C2Tuple_u64u64ZZ_free(self); }
9902         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; }
9903         LDKCOption_C2Tuple_u64u64ZZ* operator &() { return &self; }
9904         LDKCOption_C2Tuple_u64u64ZZ* operator ->() { return &self; }
9905         const LDKCOption_C2Tuple_u64u64ZZ* operator &() const { return &self; }
9906         const LDKCOption_C2Tuple_u64u64ZZ* operator ->() const { return &self; }
9907 };
9908 class CResult_ChannelAnnouncementDecodeErrorZ {
9909 private:
9910         LDKCResult_ChannelAnnouncementDecodeErrorZ self;
9911 public:
9912         CResult_ChannelAnnouncementDecodeErrorZ(const CResult_ChannelAnnouncementDecodeErrorZ&) = delete;
9913         CResult_ChannelAnnouncementDecodeErrorZ(CResult_ChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); }
9914         CResult_ChannelAnnouncementDecodeErrorZ(LDKCResult_ChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); }
9915         operator LDKCResult_ChannelAnnouncementDecodeErrorZ() && { LDKCResult_ChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); return res; }
9916         ~CResult_ChannelAnnouncementDecodeErrorZ() { CResult_ChannelAnnouncementDecodeErrorZ_free(self); }
9917         CResult_ChannelAnnouncementDecodeErrorZ& operator=(CResult_ChannelAnnouncementDecodeErrorZ&& o) { CResult_ChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); return *this; }
9918         LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
9919         LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
9920         const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
9921         const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
9922 };
9923 class CResult_HTLCUpdateDecodeErrorZ {
9924 private:
9925         LDKCResult_HTLCUpdateDecodeErrorZ self;
9926 public:
9927         CResult_HTLCUpdateDecodeErrorZ(const CResult_HTLCUpdateDecodeErrorZ&) = delete;
9928         CResult_HTLCUpdateDecodeErrorZ(CResult_HTLCUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCUpdateDecodeErrorZ)); }
9929         CResult_HTLCUpdateDecodeErrorZ(LDKCResult_HTLCUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCUpdateDecodeErrorZ)); }
9930         operator LDKCResult_HTLCUpdateDecodeErrorZ() && { LDKCResult_HTLCUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCUpdateDecodeErrorZ)); return res; }
9931         ~CResult_HTLCUpdateDecodeErrorZ() { CResult_HTLCUpdateDecodeErrorZ_free(self); }
9932         CResult_HTLCUpdateDecodeErrorZ& operator=(CResult_HTLCUpdateDecodeErrorZ&& o) { CResult_HTLCUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCUpdateDecodeErrorZ)); return *this; }
9933         LDKCResult_HTLCUpdateDecodeErrorZ* operator &() { return &self; }
9934         LDKCResult_HTLCUpdateDecodeErrorZ* operator ->() { return &self; }
9935         const LDKCResult_HTLCUpdateDecodeErrorZ* operator &() const { return &self; }
9936         const LDKCResult_HTLCUpdateDecodeErrorZ* operator ->() const { return &self; }
9937 };
9938 class CResult_TxAddInputDecodeErrorZ {
9939 private:
9940         LDKCResult_TxAddInputDecodeErrorZ self;
9941 public:
9942         CResult_TxAddInputDecodeErrorZ(const CResult_TxAddInputDecodeErrorZ&) = delete;
9943         CResult_TxAddInputDecodeErrorZ(CResult_TxAddInputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAddInputDecodeErrorZ)); }
9944         CResult_TxAddInputDecodeErrorZ(LDKCResult_TxAddInputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAddInputDecodeErrorZ)); }
9945         operator LDKCResult_TxAddInputDecodeErrorZ() && { LDKCResult_TxAddInputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAddInputDecodeErrorZ)); return res; }
9946         ~CResult_TxAddInputDecodeErrorZ() { CResult_TxAddInputDecodeErrorZ_free(self); }
9947         CResult_TxAddInputDecodeErrorZ& operator=(CResult_TxAddInputDecodeErrorZ&& o) { CResult_TxAddInputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAddInputDecodeErrorZ)); return *this; }
9948         LDKCResult_TxAddInputDecodeErrorZ* operator &() { return &self; }
9949         LDKCResult_TxAddInputDecodeErrorZ* operator ->() { return &self; }
9950         const LDKCResult_TxAddInputDecodeErrorZ* operator &() const { return &self; }
9951         const LDKCResult_TxAddInputDecodeErrorZ* operator ->() const { return &self; }
9952 };
9953 class CResult_PeeledOnionNoneZ {
9954 private:
9955         LDKCResult_PeeledOnionNoneZ self;
9956 public:
9957         CResult_PeeledOnionNoneZ(const CResult_PeeledOnionNoneZ&) = delete;
9958         CResult_PeeledOnionNoneZ(CResult_PeeledOnionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PeeledOnionNoneZ)); }
9959         CResult_PeeledOnionNoneZ(LDKCResult_PeeledOnionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PeeledOnionNoneZ)); }
9960         operator LDKCResult_PeeledOnionNoneZ() && { LDKCResult_PeeledOnionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_PeeledOnionNoneZ)); return res; }
9961         ~CResult_PeeledOnionNoneZ() { CResult_PeeledOnionNoneZ_free(self); }
9962         CResult_PeeledOnionNoneZ& operator=(CResult_PeeledOnionNoneZ&& o) { CResult_PeeledOnionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PeeledOnionNoneZ)); return *this; }
9963         LDKCResult_PeeledOnionNoneZ* operator &() { return &self; }
9964         LDKCResult_PeeledOnionNoneZ* operator ->() { return &self; }
9965         const LDKCResult_PeeledOnionNoneZ* operator &() const { return &self; }
9966         const LDKCResult_PeeledOnionNoneZ* operator ->() const { return &self; }
9967 };
9968 class CResult_TxInitRbfDecodeErrorZ {
9969 private:
9970         LDKCResult_TxInitRbfDecodeErrorZ self;
9971 public:
9972         CResult_TxInitRbfDecodeErrorZ(const CResult_TxInitRbfDecodeErrorZ&) = delete;
9973         CResult_TxInitRbfDecodeErrorZ(CResult_TxInitRbfDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxInitRbfDecodeErrorZ)); }
9974         CResult_TxInitRbfDecodeErrorZ(LDKCResult_TxInitRbfDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxInitRbfDecodeErrorZ)); }
9975         operator LDKCResult_TxInitRbfDecodeErrorZ() && { LDKCResult_TxInitRbfDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxInitRbfDecodeErrorZ)); return res; }
9976         ~CResult_TxInitRbfDecodeErrorZ() { CResult_TxInitRbfDecodeErrorZ_free(self); }
9977         CResult_TxInitRbfDecodeErrorZ& operator=(CResult_TxInitRbfDecodeErrorZ&& o) { CResult_TxInitRbfDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxInitRbfDecodeErrorZ)); return *this; }
9978         LDKCResult_TxInitRbfDecodeErrorZ* operator &() { return &self; }
9979         LDKCResult_TxInitRbfDecodeErrorZ* operator ->() { return &self; }
9980         const LDKCResult_TxInitRbfDecodeErrorZ* operator &() const { return &self; }
9981         const LDKCResult_TxInitRbfDecodeErrorZ* operator ->() const { return &self; }
9982 };
9983 class COption_WriteableScoreZ {
9984 private:
9985         LDKCOption_WriteableScoreZ self;
9986 public:
9987         COption_WriteableScoreZ(const COption_WriteableScoreZ&) = delete;
9988         COption_WriteableScoreZ(COption_WriteableScoreZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_WriteableScoreZ)); }
9989         COption_WriteableScoreZ(LDKCOption_WriteableScoreZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_WriteableScoreZ)); }
9990         operator LDKCOption_WriteableScoreZ() && { LDKCOption_WriteableScoreZ res = self; memset(&self, 0, sizeof(LDKCOption_WriteableScoreZ)); return res; }
9991         ~COption_WriteableScoreZ() { COption_WriteableScoreZ_free(self); }
9992         COption_WriteableScoreZ& operator=(COption_WriteableScoreZ&& o) { COption_WriteableScoreZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_WriteableScoreZ)); return *this; }
9993         LDKCOption_WriteableScoreZ* operator &() { return &self; }
9994         LDKCOption_WriteableScoreZ* operator ->() { return &self; }
9995         const LDKCOption_WriteableScoreZ* operator &() const { return &self; }
9996         const LDKCOption_WriteableScoreZ* operator ->() const { return &self; }
9997 };
9998 class CVec_StrZ {
9999 private:
10000         LDKCVec_StrZ self;
10001 public:
10002         CVec_StrZ(const CVec_StrZ&) = delete;
10003         CVec_StrZ(CVec_StrZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_StrZ)); }
10004         CVec_StrZ(LDKCVec_StrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_StrZ)); }
10005         operator LDKCVec_StrZ() && { LDKCVec_StrZ res = self; memset(&self, 0, sizeof(LDKCVec_StrZ)); return res; }
10006         ~CVec_StrZ() { CVec_StrZ_free(self); }
10007         CVec_StrZ& operator=(CVec_StrZ&& o) { CVec_StrZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_StrZ)); return *this; }
10008         LDKCVec_StrZ* operator &() { return &self; }
10009         LDKCVec_StrZ* operator ->() { return &self; }
10010         const LDKCVec_StrZ* operator &() const { return &self; }
10011         const LDKCVec_StrZ* operator ->() const { return &self; }
10012 };
10013 class CResult_SpliceAckDecodeErrorZ {
10014 private:
10015         LDKCResult_SpliceAckDecodeErrorZ self;
10016 public:
10017         CResult_SpliceAckDecodeErrorZ(const CResult_SpliceAckDecodeErrorZ&) = delete;
10018         CResult_SpliceAckDecodeErrorZ(CResult_SpliceAckDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpliceAckDecodeErrorZ)); }
10019         CResult_SpliceAckDecodeErrorZ(LDKCResult_SpliceAckDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpliceAckDecodeErrorZ)); }
10020         operator LDKCResult_SpliceAckDecodeErrorZ() && { LDKCResult_SpliceAckDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpliceAckDecodeErrorZ)); return res; }
10021         ~CResult_SpliceAckDecodeErrorZ() { CResult_SpliceAckDecodeErrorZ_free(self); }
10022         CResult_SpliceAckDecodeErrorZ& operator=(CResult_SpliceAckDecodeErrorZ&& o) { CResult_SpliceAckDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpliceAckDecodeErrorZ)); return *this; }
10023         LDKCResult_SpliceAckDecodeErrorZ* operator &() { return &self; }
10024         LDKCResult_SpliceAckDecodeErrorZ* operator ->() { return &self; }
10025         const LDKCResult_SpliceAckDecodeErrorZ* operator &() const { return &self; }
10026         const LDKCResult_SpliceAckDecodeErrorZ* operator ->() const { return &self; }
10027 };
10028 class CResult_PositiveTimestampCreationErrorZ {
10029 private:
10030         LDKCResult_PositiveTimestampCreationErrorZ self;
10031 public:
10032         CResult_PositiveTimestampCreationErrorZ(const CResult_PositiveTimestampCreationErrorZ&) = delete;
10033         CResult_PositiveTimestampCreationErrorZ(CResult_PositiveTimestampCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PositiveTimestampCreationErrorZ)); }
10034         CResult_PositiveTimestampCreationErrorZ(LDKCResult_PositiveTimestampCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PositiveTimestampCreationErrorZ)); }
10035         operator LDKCResult_PositiveTimestampCreationErrorZ() && { LDKCResult_PositiveTimestampCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PositiveTimestampCreationErrorZ)); return res; }
10036         ~CResult_PositiveTimestampCreationErrorZ() { CResult_PositiveTimestampCreationErrorZ_free(self); }
10037         CResult_PositiveTimestampCreationErrorZ& operator=(CResult_PositiveTimestampCreationErrorZ&& o) { CResult_PositiveTimestampCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PositiveTimestampCreationErrorZ)); return *this; }
10038         LDKCResult_PositiveTimestampCreationErrorZ* operator &() { return &self; }
10039         LDKCResult_PositiveTimestampCreationErrorZ* operator ->() { return &self; }
10040         const LDKCResult_PositiveTimestampCreationErrorZ* operator &() const { return &self; }
10041         const LDKCResult_PositiveTimestampCreationErrorZ* operator ->() const { return &self; }
10042 };
10043 class CVec_C2Tuple_OutPointChannelIdZZ {
10044 private:
10045         LDKCVec_C2Tuple_OutPointChannelIdZZ self;
10046 public:
10047         CVec_C2Tuple_OutPointChannelIdZZ(const CVec_C2Tuple_OutPointChannelIdZZ&) = delete;
10048         CVec_C2Tuple_OutPointChannelIdZZ(CVec_C2Tuple_OutPointChannelIdZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_OutPointChannelIdZZ)); }
10049         CVec_C2Tuple_OutPointChannelIdZZ(LDKCVec_C2Tuple_OutPointChannelIdZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_OutPointChannelIdZZ)); }
10050         operator LDKCVec_C2Tuple_OutPointChannelIdZZ() && { LDKCVec_C2Tuple_OutPointChannelIdZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_OutPointChannelIdZZ)); return res; }
10051         ~CVec_C2Tuple_OutPointChannelIdZZ() { CVec_C2Tuple_OutPointChannelIdZZ_free(self); }
10052         CVec_C2Tuple_OutPointChannelIdZZ& operator=(CVec_C2Tuple_OutPointChannelIdZZ&& o) { CVec_C2Tuple_OutPointChannelIdZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_OutPointChannelIdZZ)); return *this; }
10053         LDKCVec_C2Tuple_OutPointChannelIdZZ* operator &() { return &self; }
10054         LDKCVec_C2Tuple_OutPointChannelIdZZ* operator ->() { return &self; }
10055         const LDKCVec_C2Tuple_OutPointChannelIdZZ* operator &() const { return &self; }
10056         const LDKCVec_C2Tuple_OutPointChannelIdZZ* operator ->() const { return &self; }
10057 };
10058 class CResult_ChannelMonitorUpdateDecodeErrorZ {
10059 private:
10060         LDKCResult_ChannelMonitorUpdateDecodeErrorZ self;
10061 public:
10062         CResult_ChannelMonitorUpdateDecodeErrorZ(const CResult_ChannelMonitorUpdateDecodeErrorZ&) = delete;
10063         CResult_ChannelMonitorUpdateDecodeErrorZ(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); }
10064         CResult_ChannelMonitorUpdateDecodeErrorZ(LDKCResult_ChannelMonitorUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); }
10065         operator LDKCResult_ChannelMonitorUpdateDecodeErrorZ() && { LDKCResult_ChannelMonitorUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); return res; }
10066         ~CResult_ChannelMonitorUpdateDecodeErrorZ() { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); }
10067         CResult_ChannelMonitorUpdateDecodeErrorZ& operator=(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); return *this; }
10068         LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() { return &self; }
10069         LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() { return &self; }
10070         const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() const { return &self; }
10071         const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() const { return &self; }
10072 };
10073 class C2Tuple_BlindedPayInfoBlindedPathZ {
10074 private:
10075         LDKC2Tuple_BlindedPayInfoBlindedPathZ self;
10076 public:
10077         C2Tuple_BlindedPayInfoBlindedPathZ(const C2Tuple_BlindedPayInfoBlindedPathZ&) = delete;
10078         C2Tuple_BlindedPayInfoBlindedPathZ(C2Tuple_BlindedPayInfoBlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BlindedPayInfoBlindedPathZ)); }
10079         C2Tuple_BlindedPayInfoBlindedPathZ(LDKC2Tuple_BlindedPayInfoBlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ)); }
10080         operator LDKC2Tuple_BlindedPayInfoBlindedPathZ() && { LDKC2Tuple_BlindedPayInfoBlindedPathZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ)); return res; }
10081         ~C2Tuple_BlindedPayInfoBlindedPathZ() { C2Tuple_BlindedPayInfoBlindedPathZ_free(self); }
10082         C2Tuple_BlindedPayInfoBlindedPathZ& operator=(C2Tuple_BlindedPayInfoBlindedPathZ&& o) { C2Tuple_BlindedPayInfoBlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BlindedPayInfoBlindedPathZ)); return *this; }
10083         LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator &() { return &self; }
10084         LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator ->() { return &self; }
10085         const LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator &() const { return &self; }
10086         const LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator ->() const { return &self; }
10087 };
10088 class CResult_ReplyChannelRangeDecodeErrorZ {
10089 private:
10090         LDKCResult_ReplyChannelRangeDecodeErrorZ self;
10091 public:
10092         CResult_ReplyChannelRangeDecodeErrorZ(const CResult_ReplyChannelRangeDecodeErrorZ&) = delete;
10093         CResult_ReplyChannelRangeDecodeErrorZ(CResult_ReplyChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); }
10094         CResult_ReplyChannelRangeDecodeErrorZ(LDKCResult_ReplyChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); }
10095         operator LDKCResult_ReplyChannelRangeDecodeErrorZ() && { LDKCResult_ReplyChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); return res; }
10096         ~CResult_ReplyChannelRangeDecodeErrorZ() { CResult_ReplyChannelRangeDecodeErrorZ_free(self); }
10097         CResult_ReplyChannelRangeDecodeErrorZ& operator=(CResult_ReplyChannelRangeDecodeErrorZ&& o) { CResult_ReplyChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); return *this; }
10098         LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() { return &self; }
10099         LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() { return &self; }
10100         const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() const { return &self; }
10101         const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() const { return &self; }
10102 };
10103 class CResult_UnsignedNodeAnnouncementDecodeErrorZ {
10104 private:
10105         LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ self;
10106 public:
10107         CResult_UnsignedNodeAnnouncementDecodeErrorZ(const CResult_UnsignedNodeAnnouncementDecodeErrorZ&) = delete;
10108         CResult_UnsignedNodeAnnouncementDecodeErrorZ(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
10109         CResult_UnsignedNodeAnnouncementDecodeErrorZ(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
10110         operator LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); return res; }
10111         ~CResult_UnsignedNodeAnnouncementDecodeErrorZ() { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); }
10112         CResult_UnsignedNodeAnnouncementDecodeErrorZ& operator=(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); return *this; }
10113         LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() { return &self; }
10114         LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
10115         const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
10116         const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
10117 };
10118 class CResult_TrustedClosingTransactionNoneZ {
10119 private:
10120         LDKCResult_TrustedClosingTransactionNoneZ self;
10121 public:
10122         CResult_TrustedClosingTransactionNoneZ(const CResult_TrustedClosingTransactionNoneZ&) = delete;
10123         CResult_TrustedClosingTransactionNoneZ(CResult_TrustedClosingTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedClosingTransactionNoneZ)); }
10124         CResult_TrustedClosingTransactionNoneZ(LDKCResult_TrustedClosingTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedClosingTransactionNoneZ)); }
10125         operator LDKCResult_TrustedClosingTransactionNoneZ() && { LDKCResult_TrustedClosingTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedClosingTransactionNoneZ)); return res; }
10126         ~CResult_TrustedClosingTransactionNoneZ() { CResult_TrustedClosingTransactionNoneZ_free(self); }
10127         CResult_TrustedClosingTransactionNoneZ& operator=(CResult_TrustedClosingTransactionNoneZ&& o) { CResult_TrustedClosingTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedClosingTransactionNoneZ)); return *this; }
10128         LDKCResult_TrustedClosingTransactionNoneZ* operator &() { return &self; }
10129         LDKCResult_TrustedClosingTransactionNoneZ* operator ->() { return &self; }
10130         const LDKCResult_TrustedClosingTransactionNoneZ* operator &() const { return &self; }
10131         const LDKCResult_TrustedClosingTransactionNoneZ* operator ->() const { return &self; }
10132 };
10133 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ {
10134 private:
10135         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ self;
10136 public:
10137         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(const CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&) = delete;
10138         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); }
10139         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); }
10140         operator LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); return res; }
10141         ~CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ() { CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(self); }
10142         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; }
10143         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator &() { return &self; }
10144         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator ->() { return &self; }
10145         const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator &() const { return &self; }
10146         const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator ->() const { return &self; }
10147 };
10148 class C2Tuple_PublicKeyTypeZ {
10149 private:
10150         LDKC2Tuple_PublicKeyTypeZ self;
10151 public:
10152         C2Tuple_PublicKeyTypeZ(const C2Tuple_PublicKeyTypeZ&) = delete;
10153         C2Tuple_PublicKeyTypeZ(C2Tuple_PublicKeyTypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyTypeZ)); }
10154         C2Tuple_PublicKeyTypeZ(LDKC2Tuple_PublicKeyTypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyTypeZ)); }
10155         operator LDKC2Tuple_PublicKeyTypeZ() && { LDKC2Tuple_PublicKeyTypeZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyTypeZ)); return res; }
10156         ~C2Tuple_PublicKeyTypeZ() { C2Tuple_PublicKeyTypeZ_free(self); }
10157         C2Tuple_PublicKeyTypeZ& operator=(C2Tuple_PublicKeyTypeZ&& o) { C2Tuple_PublicKeyTypeZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyTypeZ)); return *this; }
10158         LDKC2Tuple_PublicKeyTypeZ* operator &() { return &self; }
10159         LDKC2Tuple_PublicKeyTypeZ* operator ->() { return &self; }
10160         const LDKC2Tuple_PublicKeyTypeZ* operator &() const { return &self; }
10161         const LDKC2Tuple_PublicKeyTypeZ* operator ->() const { return &self; }
10162 };
10163 class CResult_TxRemoveOutputDecodeErrorZ {
10164 private:
10165         LDKCResult_TxRemoveOutputDecodeErrorZ self;
10166 public:
10167         CResult_TxRemoveOutputDecodeErrorZ(const CResult_TxRemoveOutputDecodeErrorZ&) = delete;
10168         CResult_TxRemoveOutputDecodeErrorZ(CResult_TxRemoveOutputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxRemoveOutputDecodeErrorZ)); }
10169         CResult_TxRemoveOutputDecodeErrorZ(LDKCResult_TxRemoveOutputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxRemoveOutputDecodeErrorZ)); }
10170         operator LDKCResult_TxRemoveOutputDecodeErrorZ() && { LDKCResult_TxRemoveOutputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxRemoveOutputDecodeErrorZ)); return res; }
10171         ~CResult_TxRemoveOutputDecodeErrorZ() { CResult_TxRemoveOutputDecodeErrorZ_free(self); }
10172         CResult_TxRemoveOutputDecodeErrorZ& operator=(CResult_TxRemoveOutputDecodeErrorZ&& o) { CResult_TxRemoveOutputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxRemoveOutputDecodeErrorZ)); return *this; }
10173         LDKCResult_TxRemoveOutputDecodeErrorZ* operator &() { return &self; }
10174         LDKCResult_TxRemoveOutputDecodeErrorZ* operator ->() { return &self; }
10175         const LDKCResult_TxRemoveOutputDecodeErrorZ* operator &() const { return &self; }
10176         const LDKCResult_TxRemoveOutputDecodeErrorZ* operator ->() const { return &self; }
10177 };
10178 class CResult_ChannelReestablishDecodeErrorZ {
10179 private:
10180         LDKCResult_ChannelReestablishDecodeErrorZ self;
10181 public:
10182         CResult_ChannelReestablishDecodeErrorZ(const CResult_ChannelReestablishDecodeErrorZ&) = delete;
10183         CResult_ChannelReestablishDecodeErrorZ(CResult_ChannelReestablishDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelReestablishDecodeErrorZ)); }
10184         CResult_ChannelReestablishDecodeErrorZ(LDKCResult_ChannelReestablishDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelReestablishDecodeErrorZ)); }
10185         operator LDKCResult_ChannelReestablishDecodeErrorZ() && { LDKCResult_ChannelReestablishDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelReestablishDecodeErrorZ)); return res; }
10186         ~CResult_ChannelReestablishDecodeErrorZ() { CResult_ChannelReestablishDecodeErrorZ_free(self); }
10187         CResult_ChannelReestablishDecodeErrorZ& operator=(CResult_ChannelReestablishDecodeErrorZ&& o) { CResult_ChannelReestablishDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelReestablishDecodeErrorZ)); return *this; }
10188         LDKCResult_ChannelReestablishDecodeErrorZ* operator &() { return &self; }
10189         LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() { return &self; }
10190         const LDKCResult_ChannelReestablishDecodeErrorZ* operator &() const { return &self; }
10191         const LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() const { return &self; }
10192 };
10193 class CResult_OnionMessageDecodeErrorZ {
10194 private:
10195         LDKCResult_OnionMessageDecodeErrorZ self;
10196 public:
10197         CResult_OnionMessageDecodeErrorZ(const CResult_OnionMessageDecodeErrorZ&) = delete;
10198         CResult_OnionMessageDecodeErrorZ(CResult_OnionMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionMessageDecodeErrorZ)); }
10199         CResult_OnionMessageDecodeErrorZ(LDKCResult_OnionMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionMessageDecodeErrorZ)); }
10200         operator LDKCResult_OnionMessageDecodeErrorZ() && { LDKCResult_OnionMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionMessageDecodeErrorZ)); return res; }
10201         ~CResult_OnionMessageDecodeErrorZ() { CResult_OnionMessageDecodeErrorZ_free(self); }
10202         CResult_OnionMessageDecodeErrorZ& operator=(CResult_OnionMessageDecodeErrorZ&& o) { CResult_OnionMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionMessageDecodeErrorZ)); return *this; }
10203         LDKCResult_OnionMessageDecodeErrorZ* operator &() { return &self; }
10204         LDKCResult_OnionMessageDecodeErrorZ* operator ->() { return &self; }
10205         const LDKCResult_OnionMessageDecodeErrorZ* operator &() const { return &self; }
10206         const LDKCResult_OnionMessageDecodeErrorZ* operator ->() const { return &self; }
10207 };
10208 class CResult_Bolt11InvoiceParseOrSemanticErrorZ {
10209 private:
10210         LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ self;
10211 public:
10212         CResult_Bolt11InvoiceParseOrSemanticErrorZ(const CResult_Bolt11InvoiceParseOrSemanticErrorZ&) = delete;
10213         CResult_Bolt11InvoiceParseOrSemanticErrorZ(CResult_Bolt11InvoiceParseOrSemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceParseOrSemanticErrorZ)); }
10214         CResult_Bolt11InvoiceParseOrSemanticErrorZ(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ)); }
10215         operator LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ() && { LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ)); return res; }
10216         ~CResult_Bolt11InvoiceParseOrSemanticErrorZ() { CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(self); }
10217         CResult_Bolt11InvoiceParseOrSemanticErrorZ& operator=(CResult_Bolt11InvoiceParseOrSemanticErrorZ&& o) { CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceParseOrSemanticErrorZ)); return *this; }
10218         LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator &() { return &self; }
10219         LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator ->() { return &self; }
10220         const LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator &() const { return &self; }
10221         const LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator ->() const { return &self; }
10222 };
10223 class CResult_InitFeaturesDecodeErrorZ {
10224 private:
10225         LDKCResult_InitFeaturesDecodeErrorZ self;
10226 public:
10227         CResult_InitFeaturesDecodeErrorZ(const CResult_InitFeaturesDecodeErrorZ&) = delete;
10228         CResult_InitFeaturesDecodeErrorZ(CResult_InitFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); }
10229         CResult_InitFeaturesDecodeErrorZ(LDKCResult_InitFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); }
10230         operator LDKCResult_InitFeaturesDecodeErrorZ() && { LDKCResult_InitFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); return res; }
10231         ~CResult_InitFeaturesDecodeErrorZ() { CResult_InitFeaturesDecodeErrorZ_free(self); }
10232         CResult_InitFeaturesDecodeErrorZ& operator=(CResult_InitFeaturesDecodeErrorZ&& o) { CResult_InitFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); return *this; }
10233         LDKCResult_InitFeaturesDecodeErrorZ* operator &() { return &self; }
10234         LDKCResult_InitFeaturesDecodeErrorZ* operator ->() { return &self; }
10235         const LDKCResult_InitFeaturesDecodeErrorZ* operator &() const { return &self; }
10236         const LDKCResult_InitFeaturesDecodeErrorZ* operator ->() const { return &self; }
10237 };
10238 class CResult_PublicKeyNoneZ {
10239 private:
10240         LDKCResult_PublicKeyNoneZ self;
10241 public:
10242         CResult_PublicKeyNoneZ(const CResult_PublicKeyNoneZ&) = delete;
10243         CResult_PublicKeyNoneZ(CResult_PublicKeyNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PublicKeyNoneZ)); }
10244         CResult_PublicKeyNoneZ(LDKCResult_PublicKeyNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PublicKeyNoneZ)); }
10245         operator LDKCResult_PublicKeyNoneZ() && { LDKCResult_PublicKeyNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_PublicKeyNoneZ)); return res; }
10246         ~CResult_PublicKeyNoneZ() { CResult_PublicKeyNoneZ_free(self); }
10247         CResult_PublicKeyNoneZ& operator=(CResult_PublicKeyNoneZ&& o) { CResult_PublicKeyNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PublicKeyNoneZ)); return *this; }
10248         LDKCResult_PublicKeyNoneZ* operator &() { return &self; }
10249         LDKCResult_PublicKeyNoneZ* operator ->() { return &self; }
10250         const LDKCResult_PublicKeyNoneZ* operator &() const { return &self; }
10251         const LDKCResult_PublicKeyNoneZ* operator ->() const { return &self; }
10252 };
10253 class CResult_PingDecodeErrorZ {
10254 private:
10255         LDKCResult_PingDecodeErrorZ self;
10256 public:
10257         CResult_PingDecodeErrorZ(const CResult_PingDecodeErrorZ&) = delete;
10258         CResult_PingDecodeErrorZ(CResult_PingDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PingDecodeErrorZ)); }
10259         CResult_PingDecodeErrorZ(LDKCResult_PingDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PingDecodeErrorZ)); }
10260         operator LDKCResult_PingDecodeErrorZ() && { LDKCResult_PingDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PingDecodeErrorZ)); return res; }
10261         ~CResult_PingDecodeErrorZ() { CResult_PingDecodeErrorZ_free(self); }
10262         CResult_PingDecodeErrorZ& operator=(CResult_PingDecodeErrorZ&& o) { CResult_PingDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PingDecodeErrorZ)); return *this; }
10263         LDKCResult_PingDecodeErrorZ* operator &() { return &self; }
10264         LDKCResult_PingDecodeErrorZ* operator ->() { return &self; }
10265         const LDKCResult_PingDecodeErrorZ* operator &() const { return &self; }
10266         const LDKCResult_PingDecodeErrorZ* operator ->() const { return &self; }
10267 };
10268 class CResult_RevocationKeyDecodeErrorZ {
10269 private:
10270         LDKCResult_RevocationKeyDecodeErrorZ self;
10271 public:
10272         CResult_RevocationKeyDecodeErrorZ(const CResult_RevocationKeyDecodeErrorZ&) = delete;
10273         CResult_RevocationKeyDecodeErrorZ(CResult_RevocationKeyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevocationKeyDecodeErrorZ)); }
10274         CResult_RevocationKeyDecodeErrorZ(LDKCResult_RevocationKeyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevocationKeyDecodeErrorZ)); }
10275         operator LDKCResult_RevocationKeyDecodeErrorZ() && { LDKCResult_RevocationKeyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevocationKeyDecodeErrorZ)); return res; }
10276         ~CResult_RevocationKeyDecodeErrorZ() { CResult_RevocationKeyDecodeErrorZ_free(self); }
10277         CResult_RevocationKeyDecodeErrorZ& operator=(CResult_RevocationKeyDecodeErrorZ&& o) { CResult_RevocationKeyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevocationKeyDecodeErrorZ)); return *this; }
10278         LDKCResult_RevocationKeyDecodeErrorZ* operator &() { return &self; }
10279         LDKCResult_RevocationKeyDecodeErrorZ* operator ->() { return &self; }
10280         const LDKCResult_RevocationKeyDecodeErrorZ* operator &() const { return &self; }
10281         const LDKCResult_RevocationKeyDecodeErrorZ* operator ->() const { return &self; }
10282 };
10283 class CResult_ChannelIdDecodeErrorZ {
10284 private:
10285         LDKCResult_ChannelIdDecodeErrorZ self;
10286 public:
10287         CResult_ChannelIdDecodeErrorZ(const CResult_ChannelIdDecodeErrorZ&) = delete;
10288         CResult_ChannelIdDecodeErrorZ(CResult_ChannelIdDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelIdDecodeErrorZ)); }
10289         CResult_ChannelIdDecodeErrorZ(LDKCResult_ChannelIdDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelIdDecodeErrorZ)); }
10290         operator LDKCResult_ChannelIdDecodeErrorZ() && { LDKCResult_ChannelIdDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelIdDecodeErrorZ)); return res; }
10291         ~CResult_ChannelIdDecodeErrorZ() { CResult_ChannelIdDecodeErrorZ_free(self); }
10292         CResult_ChannelIdDecodeErrorZ& operator=(CResult_ChannelIdDecodeErrorZ&& o) { CResult_ChannelIdDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelIdDecodeErrorZ)); return *this; }
10293         LDKCResult_ChannelIdDecodeErrorZ* operator &() { return &self; }
10294         LDKCResult_ChannelIdDecodeErrorZ* operator ->() { return &self; }
10295         const LDKCResult_ChannelIdDecodeErrorZ* operator &() const { return &self; }
10296         const LDKCResult_ChannelIdDecodeErrorZ* operator ->() const { return &self; }
10297 };
10298 class CResult_BlindedHopFeaturesDecodeErrorZ {
10299 private:
10300         LDKCResult_BlindedHopFeaturesDecodeErrorZ self;
10301 public:
10302         CResult_BlindedHopFeaturesDecodeErrorZ(const CResult_BlindedHopFeaturesDecodeErrorZ&) = delete;
10303         CResult_BlindedHopFeaturesDecodeErrorZ(CResult_BlindedHopFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedHopFeaturesDecodeErrorZ)); }
10304         CResult_BlindedHopFeaturesDecodeErrorZ(LDKCResult_BlindedHopFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ)); }
10305         operator LDKCResult_BlindedHopFeaturesDecodeErrorZ() && { LDKCResult_BlindedHopFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ)); return res; }
10306         ~CResult_BlindedHopFeaturesDecodeErrorZ() { CResult_BlindedHopFeaturesDecodeErrorZ_free(self); }
10307         CResult_BlindedHopFeaturesDecodeErrorZ& operator=(CResult_BlindedHopFeaturesDecodeErrorZ&& o) { CResult_BlindedHopFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedHopFeaturesDecodeErrorZ)); return *this; }
10308         LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator &() { return &self; }
10309         LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator ->() { return &self; }
10310         const LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator &() const { return &self; }
10311         const LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator ->() const { return &self; }
10312 };
10313 class CVec_TransactionOutputsZ {
10314 private:
10315         LDKCVec_TransactionOutputsZ self;
10316 public:
10317         CVec_TransactionOutputsZ(const CVec_TransactionOutputsZ&) = delete;
10318         CVec_TransactionOutputsZ(CVec_TransactionOutputsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionOutputsZ)); }
10319         CVec_TransactionOutputsZ(LDKCVec_TransactionOutputsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionOutputsZ)); }
10320         operator LDKCVec_TransactionOutputsZ() && { LDKCVec_TransactionOutputsZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionOutputsZ)); return res; }
10321         ~CVec_TransactionOutputsZ() { CVec_TransactionOutputsZ_free(self); }
10322         CVec_TransactionOutputsZ& operator=(CVec_TransactionOutputsZ&& o) { CVec_TransactionOutputsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionOutputsZ)); return *this; }
10323         LDKCVec_TransactionOutputsZ* operator &() { return &self; }
10324         LDKCVec_TransactionOutputsZ* operator ->() { return &self; }
10325         const LDKCVec_TransactionOutputsZ* operator &() const { return &self; }
10326         const LDKCVec_TransactionOutputsZ* operator ->() const { return &self; }
10327 };
10328 class COption_HTLCClaimZ {
10329 private:
10330         LDKCOption_HTLCClaimZ self;
10331 public:
10332         COption_HTLCClaimZ(const COption_HTLCClaimZ&) = delete;
10333         COption_HTLCClaimZ(COption_HTLCClaimZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_HTLCClaimZ)); }
10334         COption_HTLCClaimZ(LDKCOption_HTLCClaimZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_HTLCClaimZ)); }
10335         operator LDKCOption_HTLCClaimZ() && { LDKCOption_HTLCClaimZ res = self; memset(&self, 0, sizeof(LDKCOption_HTLCClaimZ)); return res; }
10336         ~COption_HTLCClaimZ() { COption_HTLCClaimZ_free(self); }
10337         COption_HTLCClaimZ& operator=(COption_HTLCClaimZ&& o) { COption_HTLCClaimZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_HTLCClaimZ)); return *this; }
10338         LDKCOption_HTLCClaimZ* operator &() { return &self; }
10339         LDKCOption_HTLCClaimZ* operator ->() { return &self; }
10340         const LDKCOption_HTLCClaimZ* operator &() const { return &self; }
10341         const LDKCOption_HTLCClaimZ* operator ->() const { return &self; }
10342 };
10343 class COption_boolZ {
10344 private:
10345         LDKCOption_boolZ self;
10346 public:
10347         COption_boolZ(const COption_boolZ&) = delete;
10348         COption_boolZ(COption_boolZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_boolZ)); }
10349         COption_boolZ(LDKCOption_boolZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_boolZ)); }
10350         operator LDKCOption_boolZ() && { LDKCOption_boolZ res = self; memset(&self, 0, sizeof(LDKCOption_boolZ)); return res; }
10351         ~COption_boolZ() { COption_boolZ_free(self); }
10352         COption_boolZ& operator=(COption_boolZ&& o) { COption_boolZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_boolZ)); return *this; }
10353         LDKCOption_boolZ* operator &() { return &self; }
10354         LDKCOption_boolZ* operator ->() { return &self; }
10355         const LDKCOption_boolZ* operator &() const { return &self; }
10356         const LDKCOption_boolZ* operator ->() const { return &self; }
10357 };
10358 class COption_StrZ {
10359 private:
10360         LDKCOption_StrZ self;
10361 public:
10362         COption_StrZ(const COption_StrZ&) = delete;
10363         COption_StrZ(COption_StrZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_StrZ)); }
10364         COption_StrZ(LDKCOption_StrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_StrZ)); }
10365         operator LDKCOption_StrZ() && { LDKCOption_StrZ res = self; memset(&self, 0, sizeof(LDKCOption_StrZ)); return res; }
10366         ~COption_StrZ() { COption_StrZ_free(self); }
10367         COption_StrZ& operator=(COption_StrZ&& o) { COption_StrZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_StrZ)); return *this; }
10368         LDKCOption_StrZ* operator &() { return &self; }
10369         LDKCOption_StrZ* operator ->() { return &self; }
10370         const LDKCOption_StrZ* operator &() const { return &self; }
10371         const LDKCOption_StrZ* operator ->() const { return &self; }
10372 };
10373 class CResult_ProbabilisticScorerDecodeErrorZ {
10374 private:
10375         LDKCResult_ProbabilisticScorerDecodeErrorZ self;
10376 public:
10377         CResult_ProbabilisticScorerDecodeErrorZ(const CResult_ProbabilisticScorerDecodeErrorZ&) = delete;
10378         CResult_ProbabilisticScorerDecodeErrorZ(CResult_ProbabilisticScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ProbabilisticScorerDecodeErrorZ)); }
10379         CResult_ProbabilisticScorerDecodeErrorZ(LDKCResult_ProbabilisticScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ)); }
10380         operator LDKCResult_ProbabilisticScorerDecodeErrorZ() && { LDKCResult_ProbabilisticScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ)); return res; }
10381         ~CResult_ProbabilisticScorerDecodeErrorZ() { CResult_ProbabilisticScorerDecodeErrorZ_free(self); }
10382         CResult_ProbabilisticScorerDecodeErrorZ& operator=(CResult_ProbabilisticScorerDecodeErrorZ&& o) { CResult_ProbabilisticScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ProbabilisticScorerDecodeErrorZ)); return *this; }
10383         LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() { return &self; }
10384         LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() { return &self; }
10385         const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() const { return &self; }
10386         const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() const { return &self; }
10387 };
10388 class CResult_ShutdownScriptDecodeErrorZ {
10389 private:
10390         LDKCResult_ShutdownScriptDecodeErrorZ self;
10391 public:
10392         CResult_ShutdownScriptDecodeErrorZ(const CResult_ShutdownScriptDecodeErrorZ&) = delete;
10393         CResult_ShutdownScriptDecodeErrorZ(CResult_ShutdownScriptDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); }
10394         CResult_ShutdownScriptDecodeErrorZ(LDKCResult_ShutdownScriptDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); }
10395         operator LDKCResult_ShutdownScriptDecodeErrorZ() && { LDKCResult_ShutdownScriptDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); return res; }
10396         ~CResult_ShutdownScriptDecodeErrorZ() { CResult_ShutdownScriptDecodeErrorZ_free(self); }
10397         CResult_ShutdownScriptDecodeErrorZ& operator=(CResult_ShutdownScriptDecodeErrorZ&& o) { CResult_ShutdownScriptDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); return *this; }
10398         LDKCResult_ShutdownScriptDecodeErrorZ* operator &() { return &self; }
10399         LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() { return &self; }
10400         const LDKCResult_ShutdownScriptDecodeErrorZ* operator &() const { return &self; }
10401         const LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() const { return &self; }
10402 };
10403 class CResult_SiPrefixBolt11ParseErrorZ {
10404 private:
10405         LDKCResult_SiPrefixBolt11ParseErrorZ self;
10406 public:
10407         CResult_SiPrefixBolt11ParseErrorZ(const CResult_SiPrefixBolt11ParseErrorZ&) = delete;
10408         CResult_SiPrefixBolt11ParseErrorZ(CResult_SiPrefixBolt11ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SiPrefixBolt11ParseErrorZ)); }
10409         CResult_SiPrefixBolt11ParseErrorZ(LDKCResult_SiPrefixBolt11ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ)); }
10410         operator LDKCResult_SiPrefixBolt11ParseErrorZ() && { LDKCResult_SiPrefixBolt11ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ)); return res; }
10411         ~CResult_SiPrefixBolt11ParseErrorZ() { CResult_SiPrefixBolt11ParseErrorZ_free(self); }
10412         CResult_SiPrefixBolt11ParseErrorZ& operator=(CResult_SiPrefixBolt11ParseErrorZ&& o) { CResult_SiPrefixBolt11ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SiPrefixBolt11ParseErrorZ)); return *this; }
10413         LDKCResult_SiPrefixBolt11ParseErrorZ* operator &() { return &self; }
10414         LDKCResult_SiPrefixBolt11ParseErrorZ* operator ->() { return &self; }
10415         const LDKCResult_SiPrefixBolt11ParseErrorZ* operator &() const { return &self; }
10416         const LDKCResult_SiPrefixBolt11ParseErrorZ* operator ->() const { return &self; }
10417 };
10418 class C2Tuple_usizeTransactionZ {
10419 private:
10420         LDKC2Tuple_usizeTransactionZ self;
10421 public:
10422         C2Tuple_usizeTransactionZ(const C2Tuple_usizeTransactionZ&) = delete;
10423         C2Tuple_usizeTransactionZ(C2Tuple_usizeTransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_usizeTransactionZ)); }
10424         C2Tuple_usizeTransactionZ(LDKC2Tuple_usizeTransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_usizeTransactionZ)); }
10425         operator LDKC2Tuple_usizeTransactionZ() && { LDKC2Tuple_usizeTransactionZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_usizeTransactionZ)); return res; }
10426         ~C2Tuple_usizeTransactionZ() { C2Tuple_usizeTransactionZ_free(self); }
10427         C2Tuple_usizeTransactionZ& operator=(C2Tuple_usizeTransactionZ&& o) { C2Tuple_usizeTransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_usizeTransactionZ)); return *this; }
10428         LDKC2Tuple_usizeTransactionZ* operator &() { return &self; }
10429         LDKC2Tuple_usizeTransactionZ* operator ->() { return &self; }
10430         const LDKC2Tuple_usizeTransactionZ* operator &() const { return &self; }
10431         const LDKC2Tuple_usizeTransactionZ* operator ->() const { return &self; }
10432 };
10433 class CResult_NodeAnnouncementDecodeErrorZ {
10434 private:
10435         LDKCResult_NodeAnnouncementDecodeErrorZ self;
10436 public:
10437         CResult_NodeAnnouncementDecodeErrorZ(const CResult_NodeAnnouncementDecodeErrorZ&) = delete;
10438         CResult_NodeAnnouncementDecodeErrorZ(CResult_NodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); }
10439         CResult_NodeAnnouncementDecodeErrorZ(LDKCResult_NodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); }
10440         operator LDKCResult_NodeAnnouncementDecodeErrorZ() && { LDKCResult_NodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); return res; }
10441         ~CResult_NodeAnnouncementDecodeErrorZ() { CResult_NodeAnnouncementDecodeErrorZ_free(self); }
10442         CResult_NodeAnnouncementDecodeErrorZ& operator=(CResult_NodeAnnouncementDecodeErrorZ&& o) { CResult_NodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); return *this; }
10443         LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() { return &self; }
10444         LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
10445         const LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
10446         const LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
10447 };
10448 class CVec_FutureZ {
10449 private:
10450         LDKCVec_FutureZ self;
10451 public:
10452         CVec_FutureZ(const CVec_FutureZ&) = delete;
10453         CVec_FutureZ(CVec_FutureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_FutureZ)); }
10454         CVec_FutureZ(LDKCVec_FutureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_FutureZ)); }
10455         operator LDKCVec_FutureZ() && { LDKCVec_FutureZ res = self; memset(&self, 0, sizeof(LDKCVec_FutureZ)); return res; }
10456         ~CVec_FutureZ() { CVec_FutureZ_free(self); }
10457         CVec_FutureZ& operator=(CVec_FutureZ&& o) { CVec_FutureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_FutureZ)); return *this; }
10458         LDKCVec_FutureZ* operator &() { return &self; }
10459         LDKCVec_FutureZ* operator ->() { return &self; }
10460         const LDKCVec_FutureZ* operator &() const { return &self; }
10461         const LDKCVec_FutureZ* operator ->() const { return &self; }
10462 };
10463 class CVec_ChannelMonitorZ {
10464 private:
10465         LDKCVec_ChannelMonitorZ self;
10466 public:
10467         CVec_ChannelMonitorZ(const CVec_ChannelMonitorZ&) = delete;
10468         CVec_ChannelMonitorZ(CVec_ChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); }
10469         CVec_ChannelMonitorZ(LDKCVec_ChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelMonitorZ)); }
10470         operator LDKCVec_ChannelMonitorZ() && { LDKCVec_ChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelMonitorZ)); return res; }
10471         ~CVec_ChannelMonitorZ() { CVec_ChannelMonitorZ_free(self); }
10472         CVec_ChannelMonitorZ& operator=(CVec_ChannelMonitorZ&& o) { CVec_ChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); return *this; }
10473         LDKCVec_ChannelMonitorZ* operator &() { return &self; }
10474         LDKCVec_ChannelMonitorZ* operator ->() { return &self; }
10475         const LDKCVec_ChannelMonitorZ* operator &() const { return &self; }
10476         const LDKCVec_ChannelMonitorZ* operator ->() const { return &self; }
10477 };
10478 class CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ {
10479 private:
10480         LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ self;
10481 public:
10482         CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ(const CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ&) = delete;
10483         CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ(CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ)); }
10484         CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ(LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ)); }
10485         operator LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ() && { LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ)); return res; }
10486         ~CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ() { CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ_free(self); }
10487         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; }
10488         LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ* operator &() { return &self; }
10489         LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ* operator ->() { return &self; }
10490         const LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ* operator &() const { return &self; }
10491         const LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ* operator ->() const { return &self; }
10492 };
10493 class CResult_AcceptChannelV2DecodeErrorZ {
10494 private:
10495         LDKCResult_AcceptChannelV2DecodeErrorZ self;
10496 public:
10497         CResult_AcceptChannelV2DecodeErrorZ(const CResult_AcceptChannelV2DecodeErrorZ&) = delete;
10498         CResult_AcceptChannelV2DecodeErrorZ(CResult_AcceptChannelV2DecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AcceptChannelV2DecodeErrorZ)); }
10499         CResult_AcceptChannelV2DecodeErrorZ(LDKCResult_AcceptChannelV2DecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AcceptChannelV2DecodeErrorZ)); }
10500         operator LDKCResult_AcceptChannelV2DecodeErrorZ() && { LDKCResult_AcceptChannelV2DecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AcceptChannelV2DecodeErrorZ)); return res; }
10501         ~CResult_AcceptChannelV2DecodeErrorZ() { CResult_AcceptChannelV2DecodeErrorZ_free(self); }
10502         CResult_AcceptChannelV2DecodeErrorZ& operator=(CResult_AcceptChannelV2DecodeErrorZ&& o) { CResult_AcceptChannelV2DecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AcceptChannelV2DecodeErrorZ)); return *this; }
10503         LDKCResult_AcceptChannelV2DecodeErrorZ* operator &() { return &self; }
10504         LDKCResult_AcceptChannelV2DecodeErrorZ* operator ->() { return &self; }
10505         const LDKCResult_AcceptChannelV2DecodeErrorZ* operator &() const { return &self; }
10506         const LDKCResult_AcceptChannelV2DecodeErrorZ* operator ->() const { return &self; }
10507 };
10508 class CResult_RouteHopDecodeErrorZ {
10509 private:
10510         LDKCResult_RouteHopDecodeErrorZ self;
10511 public:
10512         CResult_RouteHopDecodeErrorZ(const CResult_RouteHopDecodeErrorZ&) = delete;
10513         CResult_RouteHopDecodeErrorZ(CResult_RouteHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHopDecodeErrorZ)); }
10514         CResult_RouteHopDecodeErrorZ(LDKCResult_RouteHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHopDecodeErrorZ)); }
10515         operator LDKCResult_RouteHopDecodeErrorZ() && { LDKCResult_RouteHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHopDecodeErrorZ)); return res; }
10516         ~CResult_RouteHopDecodeErrorZ() { CResult_RouteHopDecodeErrorZ_free(self); }
10517         CResult_RouteHopDecodeErrorZ& operator=(CResult_RouteHopDecodeErrorZ&& o) { CResult_RouteHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHopDecodeErrorZ)); return *this; }
10518         LDKCResult_RouteHopDecodeErrorZ* operator &() { return &self; }
10519         LDKCResult_RouteHopDecodeErrorZ* operator ->() { return &self; }
10520         const LDKCResult_RouteHopDecodeErrorZ* operator &() const { return &self; }
10521         const LDKCResult_RouteHopDecodeErrorZ* operator ->() const { return &self; }
10522 };
10523 class CResult_OfferIdDecodeErrorZ {
10524 private:
10525         LDKCResult_OfferIdDecodeErrorZ self;
10526 public:
10527         CResult_OfferIdDecodeErrorZ(const CResult_OfferIdDecodeErrorZ&) = delete;
10528         CResult_OfferIdDecodeErrorZ(CResult_OfferIdDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OfferIdDecodeErrorZ)); }
10529         CResult_OfferIdDecodeErrorZ(LDKCResult_OfferIdDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OfferIdDecodeErrorZ)); }
10530         operator LDKCResult_OfferIdDecodeErrorZ() && { LDKCResult_OfferIdDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OfferIdDecodeErrorZ)); return res; }
10531         ~CResult_OfferIdDecodeErrorZ() { CResult_OfferIdDecodeErrorZ_free(self); }
10532         CResult_OfferIdDecodeErrorZ& operator=(CResult_OfferIdDecodeErrorZ&& o) { CResult_OfferIdDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OfferIdDecodeErrorZ)); return *this; }
10533         LDKCResult_OfferIdDecodeErrorZ* operator &() { return &self; }
10534         LDKCResult_OfferIdDecodeErrorZ* operator ->() { return &self; }
10535         const LDKCResult_OfferIdDecodeErrorZ* operator &() const { return &self; }
10536         const LDKCResult_OfferIdDecodeErrorZ* operator ->() const { return &self; }
10537 };
10538 class CVec_HTLCOutputInCommitmentZ {
10539 private:
10540         LDKCVec_HTLCOutputInCommitmentZ self;
10541 public:
10542         CVec_HTLCOutputInCommitmentZ(const CVec_HTLCOutputInCommitmentZ&) = delete;
10543         CVec_HTLCOutputInCommitmentZ(CVec_HTLCOutputInCommitmentZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_HTLCOutputInCommitmentZ)); }
10544         CVec_HTLCOutputInCommitmentZ(LDKCVec_HTLCOutputInCommitmentZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_HTLCOutputInCommitmentZ)); }
10545         operator LDKCVec_HTLCOutputInCommitmentZ() && { LDKCVec_HTLCOutputInCommitmentZ res = self; memset(&self, 0, sizeof(LDKCVec_HTLCOutputInCommitmentZ)); return res; }
10546         ~CVec_HTLCOutputInCommitmentZ() { CVec_HTLCOutputInCommitmentZ_free(self); }
10547         CVec_HTLCOutputInCommitmentZ& operator=(CVec_HTLCOutputInCommitmentZ&& o) { CVec_HTLCOutputInCommitmentZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_HTLCOutputInCommitmentZ)); return *this; }
10548         LDKCVec_HTLCOutputInCommitmentZ* operator &() { return &self; }
10549         LDKCVec_HTLCOutputInCommitmentZ* operator ->() { return &self; }
10550         const LDKCVec_HTLCOutputInCommitmentZ* operator &() const { return &self; }
10551         const LDKCVec_HTLCOutputInCommitmentZ* operator ->() const { return &self; }
10552 };
10553 class CResult_CoinSelectionNoneZ {
10554 private:
10555         LDKCResult_CoinSelectionNoneZ self;
10556 public:
10557         CResult_CoinSelectionNoneZ(const CResult_CoinSelectionNoneZ&) = delete;
10558         CResult_CoinSelectionNoneZ(CResult_CoinSelectionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CoinSelectionNoneZ)); }
10559         CResult_CoinSelectionNoneZ(LDKCResult_CoinSelectionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CoinSelectionNoneZ)); }
10560         operator LDKCResult_CoinSelectionNoneZ() && { LDKCResult_CoinSelectionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CoinSelectionNoneZ)); return res; }
10561         ~CResult_CoinSelectionNoneZ() { CResult_CoinSelectionNoneZ_free(self); }
10562         CResult_CoinSelectionNoneZ& operator=(CResult_CoinSelectionNoneZ&& o) { CResult_CoinSelectionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CoinSelectionNoneZ)); return *this; }
10563         LDKCResult_CoinSelectionNoneZ* operator &() { return &self; }
10564         LDKCResult_CoinSelectionNoneZ* operator ->() { return &self; }
10565         const LDKCResult_CoinSelectionNoneZ* operator &() const { return &self; }
10566         const LDKCResult_CoinSelectionNoneZ* operator ->() const { return &self; }
10567 };
10568 class CResult_TxCreationKeysDecodeErrorZ {
10569 private:
10570         LDKCResult_TxCreationKeysDecodeErrorZ self;
10571 public:
10572         CResult_TxCreationKeysDecodeErrorZ(const CResult_TxCreationKeysDecodeErrorZ&) = delete;
10573         CResult_TxCreationKeysDecodeErrorZ(CResult_TxCreationKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); }
10574         CResult_TxCreationKeysDecodeErrorZ(LDKCResult_TxCreationKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); }
10575         operator LDKCResult_TxCreationKeysDecodeErrorZ() && { LDKCResult_TxCreationKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); return res; }
10576         ~CResult_TxCreationKeysDecodeErrorZ() { CResult_TxCreationKeysDecodeErrorZ_free(self); }
10577         CResult_TxCreationKeysDecodeErrorZ& operator=(CResult_TxCreationKeysDecodeErrorZ&& o) { CResult_TxCreationKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); return *this; }
10578         LDKCResult_TxCreationKeysDecodeErrorZ* operator &() { return &self; }
10579         LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() { return &self; }
10580         const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
10581         const LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() const { return &self; }
10582 };
10583 class CResult_BlindedPathDecodeErrorZ {
10584 private:
10585         LDKCResult_BlindedPathDecodeErrorZ self;
10586 public:
10587         CResult_BlindedPathDecodeErrorZ(const CResult_BlindedPathDecodeErrorZ&) = delete;
10588         CResult_BlindedPathDecodeErrorZ(CResult_BlindedPathDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPathDecodeErrorZ)); }
10589         CResult_BlindedPathDecodeErrorZ(LDKCResult_BlindedPathDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPathDecodeErrorZ)); }
10590         operator LDKCResult_BlindedPathDecodeErrorZ() && { LDKCResult_BlindedPathDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPathDecodeErrorZ)); return res; }
10591         ~CResult_BlindedPathDecodeErrorZ() { CResult_BlindedPathDecodeErrorZ_free(self); }
10592         CResult_BlindedPathDecodeErrorZ& operator=(CResult_BlindedPathDecodeErrorZ&& o) { CResult_BlindedPathDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPathDecodeErrorZ)); return *this; }
10593         LDKCResult_BlindedPathDecodeErrorZ* operator &() { return &self; }
10594         LDKCResult_BlindedPathDecodeErrorZ* operator ->() { return &self; }
10595         const LDKCResult_BlindedPathDecodeErrorZ* operator &() const { return &self; }
10596         const LDKCResult_BlindedPathDecodeErrorZ* operator ->() const { return &self; }
10597 };
10598 class CResult_RefundBolt12SemanticErrorZ {
10599 private:
10600         LDKCResult_RefundBolt12SemanticErrorZ self;
10601 public:
10602         CResult_RefundBolt12SemanticErrorZ(const CResult_RefundBolt12SemanticErrorZ&) = delete;
10603         CResult_RefundBolt12SemanticErrorZ(CResult_RefundBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RefundBolt12SemanticErrorZ)); }
10604         CResult_RefundBolt12SemanticErrorZ(LDKCResult_RefundBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RefundBolt12SemanticErrorZ)); }
10605         operator LDKCResult_RefundBolt12SemanticErrorZ() && { LDKCResult_RefundBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RefundBolt12SemanticErrorZ)); return res; }
10606         ~CResult_RefundBolt12SemanticErrorZ() { CResult_RefundBolt12SemanticErrorZ_free(self); }
10607         CResult_RefundBolt12SemanticErrorZ& operator=(CResult_RefundBolt12SemanticErrorZ&& o) { CResult_RefundBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RefundBolt12SemanticErrorZ)); return *this; }
10608         LDKCResult_RefundBolt12SemanticErrorZ* operator &() { return &self; }
10609         LDKCResult_RefundBolt12SemanticErrorZ* operator ->() { return &self; }
10610         const LDKCResult_RefundBolt12SemanticErrorZ* operator &() const { return &self; }
10611         const LDKCResult_RefundBolt12SemanticErrorZ* operator ->() const { return &self; }
10612 };
10613 class CResult_NoneIOErrorZ {
10614 private:
10615         LDKCResult_NoneIOErrorZ self;
10616 public:
10617         CResult_NoneIOErrorZ(const CResult_NoneIOErrorZ&) = delete;
10618         CResult_NoneIOErrorZ(CResult_NoneIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneIOErrorZ)); }
10619         CResult_NoneIOErrorZ(LDKCResult_NoneIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneIOErrorZ)); }
10620         operator LDKCResult_NoneIOErrorZ() && { LDKCResult_NoneIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneIOErrorZ)); return res; }
10621         ~CResult_NoneIOErrorZ() { CResult_NoneIOErrorZ_free(self); }
10622         CResult_NoneIOErrorZ& operator=(CResult_NoneIOErrorZ&& o) { CResult_NoneIOErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneIOErrorZ)); return *this; }
10623         LDKCResult_NoneIOErrorZ* operator &() { return &self; }
10624         LDKCResult_NoneIOErrorZ* operator ->() { return &self; }
10625         const LDKCResult_NoneIOErrorZ* operator &() const { return &self; }
10626         const LDKCResult_NoneIOErrorZ* operator ->() const { return &self; }
10627 };
10628 class CResult_MaxDustHTLCExposureDecodeErrorZ {
10629 private:
10630         LDKCResult_MaxDustHTLCExposureDecodeErrorZ self;
10631 public:
10632         CResult_MaxDustHTLCExposureDecodeErrorZ(const CResult_MaxDustHTLCExposureDecodeErrorZ&) = delete;
10633         CResult_MaxDustHTLCExposureDecodeErrorZ(CResult_MaxDustHTLCExposureDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_MaxDustHTLCExposureDecodeErrorZ)); }
10634         CResult_MaxDustHTLCExposureDecodeErrorZ(LDKCResult_MaxDustHTLCExposureDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_MaxDustHTLCExposureDecodeErrorZ)); }
10635         operator LDKCResult_MaxDustHTLCExposureDecodeErrorZ() && { LDKCResult_MaxDustHTLCExposureDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_MaxDustHTLCExposureDecodeErrorZ)); return res; }
10636         ~CResult_MaxDustHTLCExposureDecodeErrorZ() { CResult_MaxDustHTLCExposureDecodeErrorZ_free(self); }
10637         CResult_MaxDustHTLCExposureDecodeErrorZ& operator=(CResult_MaxDustHTLCExposureDecodeErrorZ&& o) { CResult_MaxDustHTLCExposureDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_MaxDustHTLCExposureDecodeErrorZ)); return *this; }
10638         LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator &() { return &self; }
10639         LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator ->() { return &self; }
10640         const LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator &() const { return &self; }
10641         const LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator ->() const { return &self; }
10642 };
10643 class CVec_BalanceZ {
10644 private:
10645         LDKCVec_BalanceZ self;
10646 public:
10647         CVec_BalanceZ(const CVec_BalanceZ&) = delete;
10648         CVec_BalanceZ(CVec_BalanceZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BalanceZ)); }
10649         CVec_BalanceZ(LDKCVec_BalanceZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BalanceZ)); }
10650         operator LDKCVec_BalanceZ() && { LDKCVec_BalanceZ res = self; memset(&self, 0, sizeof(LDKCVec_BalanceZ)); return res; }
10651         ~CVec_BalanceZ() { CVec_BalanceZ_free(self); }
10652         CVec_BalanceZ& operator=(CVec_BalanceZ&& o) { CVec_BalanceZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BalanceZ)); return *this; }
10653         LDKCVec_BalanceZ* operator &() { return &self; }
10654         LDKCVec_BalanceZ* operator ->() { return &self; }
10655         const LDKCVec_BalanceZ* operator &() const { return &self; }
10656         const LDKCVec_BalanceZ* operator ->() const { return &self; }
10657 };
10658 class CVec_CommitmentTransactionZ {
10659 private:
10660         LDKCVec_CommitmentTransactionZ self;
10661 public:
10662         CVec_CommitmentTransactionZ(const CVec_CommitmentTransactionZ&) = delete;
10663         CVec_CommitmentTransactionZ(CVec_CommitmentTransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CommitmentTransactionZ)); }
10664         CVec_CommitmentTransactionZ(LDKCVec_CommitmentTransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CommitmentTransactionZ)); }
10665         operator LDKCVec_CommitmentTransactionZ() && { LDKCVec_CommitmentTransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_CommitmentTransactionZ)); return res; }
10666         ~CVec_CommitmentTransactionZ() { CVec_CommitmentTransactionZ_free(self); }
10667         CVec_CommitmentTransactionZ& operator=(CVec_CommitmentTransactionZ&& o) { CVec_CommitmentTransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CommitmentTransactionZ)); return *this; }
10668         LDKCVec_CommitmentTransactionZ* operator &() { return &self; }
10669         LDKCVec_CommitmentTransactionZ* operator ->() { return &self; }
10670         const LDKCVec_CommitmentTransactionZ* operator &() const { return &self; }
10671         const LDKCVec_CommitmentTransactionZ* operator ->() const { return &self; }
10672 };
10673 class CResult_FundingSignedDecodeErrorZ {
10674 private:
10675         LDKCResult_FundingSignedDecodeErrorZ self;
10676 public:
10677         CResult_FundingSignedDecodeErrorZ(const CResult_FundingSignedDecodeErrorZ&) = delete;
10678         CResult_FundingSignedDecodeErrorZ(CResult_FundingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); }
10679         CResult_FundingSignedDecodeErrorZ(LDKCResult_FundingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); }
10680         operator LDKCResult_FundingSignedDecodeErrorZ() && { LDKCResult_FundingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); return res; }
10681         ~CResult_FundingSignedDecodeErrorZ() { CResult_FundingSignedDecodeErrorZ_free(self); }
10682         CResult_FundingSignedDecodeErrorZ& operator=(CResult_FundingSignedDecodeErrorZ&& o) { CResult_FundingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); return *this; }
10683         LDKCResult_FundingSignedDecodeErrorZ* operator &() { return &self; }
10684         LDKCResult_FundingSignedDecodeErrorZ* operator ->() { return &self; }
10685         const LDKCResult_FundingSignedDecodeErrorZ* operator &() const { return &self; }
10686         const LDKCResult_FundingSignedDecodeErrorZ* operator ->() const { return &self; }
10687 };
10688 class CResult_RecoverableSignatureNoneZ {
10689 private:
10690         LDKCResult_RecoverableSignatureNoneZ self;
10691 public:
10692         CResult_RecoverableSignatureNoneZ(const CResult_RecoverableSignatureNoneZ&) = delete;
10693         CResult_RecoverableSignatureNoneZ(CResult_RecoverableSignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecoverableSignatureNoneZ)); }
10694         CResult_RecoverableSignatureNoneZ(LDKCResult_RecoverableSignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecoverableSignatureNoneZ)); }
10695         operator LDKCResult_RecoverableSignatureNoneZ() && { LDKCResult_RecoverableSignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_RecoverableSignatureNoneZ)); return res; }
10696         ~CResult_RecoverableSignatureNoneZ() { CResult_RecoverableSignatureNoneZ_free(self); }
10697         CResult_RecoverableSignatureNoneZ& operator=(CResult_RecoverableSignatureNoneZ&& o) { CResult_RecoverableSignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecoverableSignatureNoneZ)); return *this; }
10698         LDKCResult_RecoverableSignatureNoneZ* operator &() { return &self; }
10699         LDKCResult_RecoverableSignatureNoneZ* operator ->() { return &self; }
10700         const LDKCResult_RecoverableSignatureNoneZ* operator &() const { return &self; }
10701         const LDKCResult_RecoverableSignatureNoneZ* operator ->() const { return &self; }
10702 };
10703 class CResult_SocketAddressDecodeErrorZ {
10704 private:
10705         LDKCResult_SocketAddressDecodeErrorZ self;
10706 public:
10707         CResult_SocketAddressDecodeErrorZ(const CResult_SocketAddressDecodeErrorZ&) = delete;
10708         CResult_SocketAddressDecodeErrorZ(CResult_SocketAddressDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SocketAddressDecodeErrorZ)); }
10709         CResult_SocketAddressDecodeErrorZ(LDKCResult_SocketAddressDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SocketAddressDecodeErrorZ)); }
10710         operator LDKCResult_SocketAddressDecodeErrorZ() && { LDKCResult_SocketAddressDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SocketAddressDecodeErrorZ)); return res; }
10711         ~CResult_SocketAddressDecodeErrorZ() { CResult_SocketAddressDecodeErrorZ_free(self); }
10712         CResult_SocketAddressDecodeErrorZ& operator=(CResult_SocketAddressDecodeErrorZ&& o) { CResult_SocketAddressDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SocketAddressDecodeErrorZ)); return *this; }
10713         LDKCResult_SocketAddressDecodeErrorZ* operator &() { return &self; }
10714         LDKCResult_SocketAddressDecodeErrorZ* operator ->() { return &self; }
10715         const LDKCResult_SocketAddressDecodeErrorZ* operator &() const { return &self; }
10716         const LDKCResult_SocketAddressDecodeErrorZ* operator ->() const { return &self; }
10717 };
10718 class C2Tuple_Z {
10719 private:
10720         LDKC2Tuple_Z self;
10721 public:
10722         C2Tuple_Z(const C2Tuple_Z&) = delete;
10723         C2Tuple_Z(C2Tuple_Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_Z)); }
10724         C2Tuple_Z(LDKC2Tuple_Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_Z)); }
10725         operator LDKC2Tuple_Z() && { LDKC2Tuple_Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_Z)); return res; }
10726         ~C2Tuple_Z() { C2Tuple_Z_free(self); }
10727         C2Tuple_Z& operator=(C2Tuple_Z&& o) { C2Tuple_Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_Z)); return *this; }
10728         LDKC2Tuple_Z* operator &() { return &self; }
10729         LDKC2Tuple_Z* operator ->() { return &self; }
10730         const LDKC2Tuple_Z* operator &() const { return &self; }
10731         const LDKC2Tuple_Z* operator ->() const { return &self; }
10732 };
10733 class C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ {
10734 private:
10735         LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ self;
10736 public:
10737         C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(const C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&) = delete;
10738         C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); }
10739         C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); }
10740         operator LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ() && { LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); return res; }
10741         ~C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ() { C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(self); }
10742         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; }
10743         LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator &() { return &self; }
10744         LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator ->() { return &self; }
10745         const LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator &() const { return &self; }
10746         const LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator ->() const { return &self; }
10747 };
10748 class CVec_PathZ {
10749 private:
10750         LDKCVec_PathZ self;
10751 public:
10752         CVec_PathZ(const CVec_PathZ&) = delete;
10753         CVec_PathZ(CVec_PathZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PathZ)); }
10754         CVec_PathZ(LDKCVec_PathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PathZ)); }
10755         operator LDKCVec_PathZ() && { LDKCVec_PathZ res = self; memset(&self, 0, sizeof(LDKCVec_PathZ)); return res; }
10756         ~CVec_PathZ() { CVec_PathZ_free(self); }
10757         CVec_PathZ& operator=(CVec_PathZ&& o) { CVec_PathZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PathZ)); return *this; }
10758         LDKCVec_PathZ* operator &() { return &self; }
10759         LDKCVec_PathZ* operator ->() { return &self; }
10760         const LDKCVec_PathZ* operator &() const { return &self; }
10761         const LDKCVec_PathZ* operator ->() const { return &self; }
10762 };
10763 class CResult_NetworkGraphDecodeErrorZ {
10764 private:
10765         LDKCResult_NetworkGraphDecodeErrorZ self;
10766 public:
10767         CResult_NetworkGraphDecodeErrorZ(const CResult_NetworkGraphDecodeErrorZ&) = delete;
10768         CResult_NetworkGraphDecodeErrorZ(CResult_NetworkGraphDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NetworkGraphDecodeErrorZ)); }
10769         CResult_NetworkGraphDecodeErrorZ(LDKCResult_NetworkGraphDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NetworkGraphDecodeErrorZ)); }
10770         operator LDKCResult_NetworkGraphDecodeErrorZ() && { LDKCResult_NetworkGraphDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NetworkGraphDecodeErrorZ)); return res; }
10771         ~CResult_NetworkGraphDecodeErrorZ() { CResult_NetworkGraphDecodeErrorZ_free(self); }
10772         CResult_NetworkGraphDecodeErrorZ& operator=(CResult_NetworkGraphDecodeErrorZ&& o) { CResult_NetworkGraphDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NetworkGraphDecodeErrorZ)); return *this; }
10773         LDKCResult_NetworkGraphDecodeErrorZ* operator &() { return &self; }
10774         LDKCResult_NetworkGraphDecodeErrorZ* operator ->() { return &self; }
10775         const LDKCResult_NetworkGraphDecodeErrorZ* operator &() const { return &self; }
10776         const LDKCResult_NetworkGraphDecodeErrorZ* operator ->() const { return &self; }
10777 };
10778 class CResult_NodeInfoDecodeErrorZ {
10779 private:
10780         LDKCResult_NodeInfoDecodeErrorZ self;
10781 public:
10782         CResult_NodeInfoDecodeErrorZ(const CResult_NodeInfoDecodeErrorZ&) = delete;
10783         CResult_NodeInfoDecodeErrorZ(CResult_NodeInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); }
10784         CResult_NodeInfoDecodeErrorZ(LDKCResult_NodeInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); }
10785         operator LDKCResult_NodeInfoDecodeErrorZ() && { LDKCResult_NodeInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); return res; }
10786         ~CResult_NodeInfoDecodeErrorZ() { CResult_NodeInfoDecodeErrorZ_free(self); }
10787         CResult_NodeInfoDecodeErrorZ& operator=(CResult_NodeInfoDecodeErrorZ&& o) { CResult_NodeInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); return *this; }
10788         LDKCResult_NodeInfoDecodeErrorZ* operator &() { return &self; }
10789         LDKCResult_NodeInfoDecodeErrorZ* operator ->() { return &self; }
10790         const LDKCResult_NodeInfoDecodeErrorZ* operator &() const { return &self; }
10791         const LDKCResult_NodeInfoDecodeErrorZ* operator ->() const { return &self; }
10792 };
10793 class CVec_NodeIdZ {
10794 private:
10795         LDKCVec_NodeIdZ self;
10796 public:
10797         CVec_NodeIdZ(const CVec_NodeIdZ&) = delete;
10798         CVec_NodeIdZ(CVec_NodeIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_NodeIdZ)); }
10799         CVec_NodeIdZ(LDKCVec_NodeIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_NodeIdZ)); }
10800         operator LDKCVec_NodeIdZ() && { LDKCVec_NodeIdZ res = self; memset(&self, 0, sizeof(LDKCVec_NodeIdZ)); return res; }
10801         ~CVec_NodeIdZ() { CVec_NodeIdZ_free(self); }
10802         CVec_NodeIdZ& operator=(CVec_NodeIdZ&& o) { CVec_NodeIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_NodeIdZ)); return *this; }
10803         LDKCVec_NodeIdZ* operator &() { return &self; }
10804         LDKCVec_NodeIdZ* operator ->() { return &self; }
10805         const LDKCVec_NodeIdZ* operator &() const { return &self; }
10806         const LDKCVec_NodeIdZ* operator ->() const { return &self; }
10807 };
10808 class CVec_u8Z {
10809 private:
10810         LDKCVec_u8Z self;
10811 public:
10812         CVec_u8Z(const CVec_u8Z&) = delete;
10813         CVec_u8Z(CVec_u8Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u8Z)); }
10814         CVec_u8Z(LDKCVec_u8Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u8Z)); }
10815         operator LDKCVec_u8Z() && { LDKCVec_u8Z res = self; memset(&self, 0, sizeof(LDKCVec_u8Z)); return res; }
10816         ~CVec_u8Z() { CVec_u8Z_free(self); }
10817         CVec_u8Z& operator=(CVec_u8Z&& o) { CVec_u8Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u8Z)); return *this; }
10818         LDKCVec_u8Z* operator &() { return &self; }
10819         LDKCVec_u8Z* operator ->() { return &self; }
10820         const LDKCVec_u8Z* operator &() const { return &self; }
10821         const LDKCVec_u8Z* operator ->() const { return &self; }
10822 };
10823 class CResult_RouteLightningErrorZ {
10824 private:
10825         LDKCResult_RouteLightningErrorZ self;
10826 public:
10827         CResult_RouteLightningErrorZ(const CResult_RouteLightningErrorZ&) = delete;
10828         CResult_RouteLightningErrorZ(CResult_RouteLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); }
10829         CResult_RouteLightningErrorZ(LDKCResult_RouteLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); }
10830         operator LDKCResult_RouteLightningErrorZ() && { LDKCResult_RouteLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); return res; }
10831         ~CResult_RouteLightningErrorZ() { CResult_RouteLightningErrorZ_free(self); }
10832         CResult_RouteLightningErrorZ& operator=(CResult_RouteLightningErrorZ&& o) { CResult_RouteLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); return *this; }
10833         LDKCResult_RouteLightningErrorZ* operator &() { return &self; }
10834         LDKCResult_RouteLightningErrorZ* operator ->() { return &self; }
10835         const LDKCResult_RouteLightningErrorZ* operator &() const { return &self; }
10836         const LDKCResult_RouteLightningErrorZ* operator ->() const { return &self; }
10837 };
10838 class CResult_NonePaymentSendFailureZ {
10839 private:
10840         LDKCResult_NonePaymentSendFailureZ self;
10841 public:
10842         CResult_NonePaymentSendFailureZ(const CResult_NonePaymentSendFailureZ&) = delete;
10843         CResult_NonePaymentSendFailureZ(CResult_NonePaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); }
10844         CResult_NonePaymentSendFailureZ(LDKCResult_NonePaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); }
10845         operator LDKCResult_NonePaymentSendFailureZ() && { LDKCResult_NonePaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); return res; }
10846         ~CResult_NonePaymentSendFailureZ() { CResult_NonePaymentSendFailureZ_free(self); }
10847         CResult_NonePaymentSendFailureZ& operator=(CResult_NonePaymentSendFailureZ&& o) { CResult_NonePaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); return *this; }
10848         LDKCResult_NonePaymentSendFailureZ* operator &() { return &self; }
10849         LDKCResult_NonePaymentSendFailureZ* operator ->() { return &self; }
10850         const LDKCResult_NonePaymentSendFailureZ* operator &() const { return &self; }
10851         const LDKCResult_NonePaymentSendFailureZ* operator ->() const { return &self; }
10852 };
10853 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ {
10854 private:
10855         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ self;
10856 public:
10857         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&) = delete;
10858         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); }
10859         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); }
10860         operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); return res; }
10861         ~CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(self); }
10862         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; }
10863         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator &() { return &self; }
10864         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator ->() { return &self; }
10865         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator &() const { return &self; }
10866         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator ->() const { return &self; }
10867 };
10868 class CResult_ChannelPublicKeysDecodeErrorZ {
10869 private:
10870         LDKCResult_ChannelPublicKeysDecodeErrorZ self;
10871 public:
10872         CResult_ChannelPublicKeysDecodeErrorZ(const CResult_ChannelPublicKeysDecodeErrorZ&) = delete;
10873         CResult_ChannelPublicKeysDecodeErrorZ(CResult_ChannelPublicKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelPublicKeysDecodeErrorZ)); }
10874         CResult_ChannelPublicKeysDecodeErrorZ(LDKCResult_ChannelPublicKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ)); }
10875         operator LDKCResult_ChannelPublicKeysDecodeErrorZ() && { LDKCResult_ChannelPublicKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ)); return res; }
10876         ~CResult_ChannelPublicKeysDecodeErrorZ() { CResult_ChannelPublicKeysDecodeErrorZ_free(self); }
10877         CResult_ChannelPublicKeysDecodeErrorZ& operator=(CResult_ChannelPublicKeysDecodeErrorZ&& o) { CResult_ChannelPublicKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelPublicKeysDecodeErrorZ)); return *this; }
10878         LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() { return &self; }
10879         LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() { return &self; }
10880         const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() const { return &self; }
10881         const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() const { return &self; }
10882 };
10883 class CVec_ClaimedHTLCZ {
10884 private:
10885         LDKCVec_ClaimedHTLCZ self;
10886 public:
10887         CVec_ClaimedHTLCZ(const CVec_ClaimedHTLCZ&) = delete;
10888         CVec_ClaimedHTLCZ(CVec_ClaimedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ClaimedHTLCZ)); }
10889         CVec_ClaimedHTLCZ(LDKCVec_ClaimedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ClaimedHTLCZ)); }
10890         operator LDKCVec_ClaimedHTLCZ() && { LDKCVec_ClaimedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_ClaimedHTLCZ)); return res; }
10891         ~CVec_ClaimedHTLCZ() { CVec_ClaimedHTLCZ_free(self); }
10892         CVec_ClaimedHTLCZ& operator=(CVec_ClaimedHTLCZ&& o) { CVec_ClaimedHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ClaimedHTLCZ)); return *this; }
10893         LDKCVec_ClaimedHTLCZ* operator &() { return &self; }
10894         LDKCVec_ClaimedHTLCZ* operator ->() { return &self; }
10895         const LDKCVec_ClaimedHTLCZ* operator &() const { return &self; }
10896         const LDKCVec_ClaimedHTLCZ* operator ->() const { return &self; }
10897 };
10898 class COption_CVec_ThirtyTwoBytesZZ {
10899 private:
10900         LDKCOption_CVec_ThirtyTwoBytesZZ self;
10901 public:
10902         COption_CVec_ThirtyTwoBytesZZ(const COption_CVec_ThirtyTwoBytesZZ&) = delete;
10903         COption_CVec_ThirtyTwoBytesZZ(COption_CVec_ThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_ThirtyTwoBytesZZ)); }
10904         COption_CVec_ThirtyTwoBytesZZ(LDKCOption_CVec_ThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ)); }
10905         operator LDKCOption_CVec_ThirtyTwoBytesZZ() && { LDKCOption_CVec_ThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ)); return res; }
10906         ~COption_CVec_ThirtyTwoBytesZZ() { COption_CVec_ThirtyTwoBytesZZ_free(self); }
10907         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; }
10908         LDKCOption_CVec_ThirtyTwoBytesZZ* operator &() { return &self; }
10909         LDKCOption_CVec_ThirtyTwoBytesZZ* operator ->() { return &self; }
10910         const LDKCOption_CVec_ThirtyTwoBytesZZ* operator &() const { return &self; }
10911         const LDKCOption_CVec_ThirtyTwoBytesZZ* operator ->() const { return &self; }
10912 };
10913 class CVec_SocketAddressZ {
10914 private:
10915         LDKCVec_SocketAddressZ self;
10916 public:
10917         CVec_SocketAddressZ(const CVec_SocketAddressZ&) = delete;
10918         CVec_SocketAddressZ(CVec_SocketAddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SocketAddressZ)); }
10919         CVec_SocketAddressZ(LDKCVec_SocketAddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SocketAddressZ)); }
10920         operator LDKCVec_SocketAddressZ() && { LDKCVec_SocketAddressZ res = self; memset(&self, 0, sizeof(LDKCVec_SocketAddressZ)); return res; }
10921         ~CVec_SocketAddressZ() { CVec_SocketAddressZ_free(self); }
10922         CVec_SocketAddressZ& operator=(CVec_SocketAddressZ&& o) { CVec_SocketAddressZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_SocketAddressZ)); return *this; }
10923         LDKCVec_SocketAddressZ* operator &() { return &self; }
10924         LDKCVec_SocketAddressZ* operator ->() { return &self; }
10925         const LDKCVec_SocketAddressZ* operator &() const { return &self; }
10926         const LDKCVec_SocketAddressZ* operator ->() const { return &self; }
10927 };
10928 class CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ {
10929 private:
10930         LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ self;
10931 public:
10932         CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ(const CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ&) = delete;
10933         CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ(CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ)); }
10934         CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ(LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ)); }
10935         operator LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ() && { LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ)); return res; }
10936         ~CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ() { CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ_free(self); }
10937         CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ& operator=(CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ&& o) { CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ)); return *this; }
10938         LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ* operator &() { return &self; }
10939         LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ* operator ->() { return &self; }
10940         const LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ* operator &() const { return &self; }
10941         const LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ* operator ->() const { return &self; }
10942 };
10943 class CResult_ThirtyTwoBytesPaymentSendFailureZ {
10944 private:
10945         LDKCResult_ThirtyTwoBytesPaymentSendFailureZ self;
10946 public:
10947         CResult_ThirtyTwoBytesPaymentSendFailureZ(const CResult_ThirtyTwoBytesPaymentSendFailureZ&) = delete;
10948         CResult_ThirtyTwoBytesPaymentSendFailureZ(CResult_ThirtyTwoBytesPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentSendFailureZ)); }
10949         CResult_ThirtyTwoBytesPaymentSendFailureZ(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ)); }
10950         operator LDKCResult_ThirtyTwoBytesPaymentSendFailureZ() && { LDKCResult_ThirtyTwoBytesPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ)); return res; }
10951         ~CResult_ThirtyTwoBytesPaymentSendFailureZ() { CResult_ThirtyTwoBytesPaymentSendFailureZ_free(self); }
10952         CResult_ThirtyTwoBytesPaymentSendFailureZ& operator=(CResult_ThirtyTwoBytesPaymentSendFailureZ&& o) { CResult_ThirtyTwoBytesPaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentSendFailureZ)); return *this; }
10953         LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator &() { return &self; }
10954         LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator ->() { return &self; }
10955         const LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator &() const { return &self; }
10956         const LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator ->() const { return &self; }
10957 };
10958 class CResult_WarningMessageDecodeErrorZ {
10959 private:
10960         LDKCResult_WarningMessageDecodeErrorZ self;
10961 public:
10962         CResult_WarningMessageDecodeErrorZ(const CResult_WarningMessageDecodeErrorZ&) = delete;
10963         CResult_WarningMessageDecodeErrorZ(CResult_WarningMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WarningMessageDecodeErrorZ)); }
10964         CResult_WarningMessageDecodeErrorZ(LDKCResult_WarningMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WarningMessageDecodeErrorZ)); }
10965         operator LDKCResult_WarningMessageDecodeErrorZ() && { LDKCResult_WarningMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_WarningMessageDecodeErrorZ)); return res; }
10966         ~CResult_WarningMessageDecodeErrorZ() { CResult_WarningMessageDecodeErrorZ_free(self); }
10967         CResult_WarningMessageDecodeErrorZ& operator=(CResult_WarningMessageDecodeErrorZ&& o) { CResult_WarningMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WarningMessageDecodeErrorZ)); return *this; }
10968         LDKCResult_WarningMessageDecodeErrorZ* operator &() { return &self; }
10969         LDKCResult_WarningMessageDecodeErrorZ* operator ->() { return &self; }
10970         const LDKCResult_WarningMessageDecodeErrorZ* operator &() const { return &self; }
10971         const LDKCResult_WarningMessageDecodeErrorZ* operator ->() const { return &self; }
10972 };
10973 class CResult_ChannelCounterpartyDecodeErrorZ {
10974 private:
10975         LDKCResult_ChannelCounterpartyDecodeErrorZ self;
10976 public:
10977         CResult_ChannelCounterpartyDecodeErrorZ(const CResult_ChannelCounterpartyDecodeErrorZ&) = delete;
10978         CResult_ChannelCounterpartyDecodeErrorZ(CResult_ChannelCounterpartyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); }
10979         CResult_ChannelCounterpartyDecodeErrorZ(LDKCResult_ChannelCounterpartyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); }
10980         operator LDKCResult_ChannelCounterpartyDecodeErrorZ() && { LDKCResult_ChannelCounterpartyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); return res; }
10981         ~CResult_ChannelCounterpartyDecodeErrorZ() { CResult_ChannelCounterpartyDecodeErrorZ_free(self); }
10982         CResult_ChannelCounterpartyDecodeErrorZ& operator=(CResult_ChannelCounterpartyDecodeErrorZ&& o) { CResult_ChannelCounterpartyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); return *this; }
10983         LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() { return &self; }
10984         LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() { return &self; }
10985         const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() const { return &self; }
10986         const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() const { return &self; }
10987 };
10988 class CResult_HolderCommitmentTransactionDecodeErrorZ {
10989 private:
10990         LDKCResult_HolderCommitmentTransactionDecodeErrorZ self;
10991 public:
10992         CResult_HolderCommitmentTransactionDecodeErrorZ(const CResult_HolderCommitmentTransactionDecodeErrorZ&) = delete;
10993         CResult_HolderCommitmentTransactionDecodeErrorZ(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); }
10994         CResult_HolderCommitmentTransactionDecodeErrorZ(LDKCResult_HolderCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); }
10995         operator LDKCResult_HolderCommitmentTransactionDecodeErrorZ() && { LDKCResult_HolderCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); return res; }
10996         ~CResult_HolderCommitmentTransactionDecodeErrorZ() { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); }
10997         CResult_HolderCommitmentTransactionDecodeErrorZ& operator=(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); return *this; }
10998         LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
10999         LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
11000         const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
11001         const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
11002 };
11003 class CVec_ForwardNodeZ {
11004 private:
11005         LDKCVec_ForwardNodeZ self;
11006 public:
11007         CVec_ForwardNodeZ(const CVec_ForwardNodeZ&) = delete;
11008         CVec_ForwardNodeZ(CVec_ForwardNodeZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ForwardNodeZ)); }
11009         CVec_ForwardNodeZ(LDKCVec_ForwardNodeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ForwardNodeZ)); }
11010         operator LDKCVec_ForwardNodeZ() && { LDKCVec_ForwardNodeZ res = self; memset(&self, 0, sizeof(LDKCVec_ForwardNodeZ)); return res; }
11011         ~CVec_ForwardNodeZ() { CVec_ForwardNodeZ_free(self); }
11012         CVec_ForwardNodeZ& operator=(CVec_ForwardNodeZ&& o) { CVec_ForwardNodeZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ForwardNodeZ)); return *this; }
11013         LDKCVec_ForwardNodeZ* operator &() { return &self; }
11014         LDKCVec_ForwardNodeZ* operator ->() { return &self; }
11015         const LDKCVec_ForwardNodeZ* operator &() const { return &self; }
11016         const LDKCVec_ForwardNodeZ* operator ->() const { return &self; }
11017 };
11018 class CResult_DelayedPaymentKeyDecodeErrorZ {
11019 private:
11020         LDKCResult_DelayedPaymentKeyDecodeErrorZ self;
11021 public:
11022         CResult_DelayedPaymentKeyDecodeErrorZ(const CResult_DelayedPaymentKeyDecodeErrorZ&) = delete;
11023         CResult_DelayedPaymentKeyDecodeErrorZ(CResult_DelayedPaymentKeyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentKeyDecodeErrorZ)); }
11024         CResult_DelayedPaymentKeyDecodeErrorZ(LDKCResult_DelayedPaymentKeyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentKeyDecodeErrorZ)); }
11025         operator LDKCResult_DelayedPaymentKeyDecodeErrorZ() && { LDKCResult_DelayedPaymentKeyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentKeyDecodeErrorZ)); return res; }
11026         ~CResult_DelayedPaymentKeyDecodeErrorZ() { CResult_DelayedPaymentKeyDecodeErrorZ_free(self); }
11027         CResult_DelayedPaymentKeyDecodeErrorZ& operator=(CResult_DelayedPaymentKeyDecodeErrorZ&& o) { CResult_DelayedPaymentKeyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentKeyDecodeErrorZ)); return *this; }
11028         LDKCResult_DelayedPaymentKeyDecodeErrorZ* operator &() { return &self; }
11029         LDKCResult_DelayedPaymentKeyDecodeErrorZ* operator ->() { return &self; }
11030         const LDKCResult_DelayedPaymentKeyDecodeErrorZ* operator &() const { return &self; }
11031         const LDKCResult_DelayedPaymentKeyDecodeErrorZ* operator ->() const { return &self; }
11032 };
11033 class CResult_InitDecodeErrorZ {
11034 private:
11035         LDKCResult_InitDecodeErrorZ self;
11036 public:
11037         CResult_InitDecodeErrorZ(const CResult_InitDecodeErrorZ&) = delete;
11038         CResult_InitDecodeErrorZ(CResult_InitDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); }
11039         CResult_InitDecodeErrorZ(LDKCResult_InitDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); }
11040         operator LDKCResult_InitDecodeErrorZ() && { LDKCResult_InitDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); return res; }
11041         ~CResult_InitDecodeErrorZ() { CResult_InitDecodeErrorZ_free(self); }
11042         CResult_InitDecodeErrorZ& operator=(CResult_InitDecodeErrorZ&& o) { CResult_InitDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); return *this; }
11043         LDKCResult_InitDecodeErrorZ* operator &() { return &self; }
11044         LDKCResult_InitDecodeErrorZ* operator ->() { return &self; }
11045         const LDKCResult_InitDecodeErrorZ* operator &() const { return &self; }
11046         const LDKCResult_InitDecodeErrorZ* operator ->() const { return &self; }
11047 };
11048 class CResult_OfferBolt12SemanticErrorZ {
11049 private:
11050         LDKCResult_OfferBolt12SemanticErrorZ self;
11051 public:
11052         CResult_OfferBolt12SemanticErrorZ(const CResult_OfferBolt12SemanticErrorZ&) = delete;
11053         CResult_OfferBolt12SemanticErrorZ(CResult_OfferBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OfferBolt12SemanticErrorZ)); }
11054         CResult_OfferBolt12SemanticErrorZ(LDKCResult_OfferBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OfferBolt12SemanticErrorZ)); }
11055         operator LDKCResult_OfferBolt12SemanticErrorZ() && { LDKCResult_OfferBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OfferBolt12SemanticErrorZ)); return res; }
11056         ~CResult_OfferBolt12SemanticErrorZ() { CResult_OfferBolt12SemanticErrorZ_free(self); }
11057         CResult_OfferBolt12SemanticErrorZ& operator=(CResult_OfferBolt12SemanticErrorZ&& o) { CResult_OfferBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OfferBolt12SemanticErrorZ)); return *this; }
11058         LDKCResult_OfferBolt12SemanticErrorZ* operator &() { return &self; }
11059         LDKCResult_OfferBolt12SemanticErrorZ* operator ->() { return &self; }
11060         const LDKCResult_OfferBolt12SemanticErrorZ* operator &() const { return &self; }
11061         const LDKCResult_OfferBolt12SemanticErrorZ* operator ->() const { return &self; }
11062 };
11063 class CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ {
11064 private:
11065         LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ self;
11066 public:
11067         CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&) = delete;
11068         CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); }
11069         CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); }
11070         operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); return res; }
11071         ~CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(self); }
11072         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; }
11073         LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator &() { return &self; }
11074         LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator ->() { return &self; }
11075         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator &() const { return &self; }
11076         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator ->() const { return &self; }
11077 };
11078 class CResult_SpliceDecodeErrorZ {
11079 private:
11080         LDKCResult_SpliceDecodeErrorZ self;
11081 public:
11082         CResult_SpliceDecodeErrorZ(const CResult_SpliceDecodeErrorZ&) = delete;
11083         CResult_SpliceDecodeErrorZ(CResult_SpliceDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpliceDecodeErrorZ)); }
11084         CResult_SpliceDecodeErrorZ(LDKCResult_SpliceDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpliceDecodeErrorZ)); }
11085         operator LDKCResult_SpliceDecodeErrorZ() && { LDKCResult_SpliceDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpliceDecodeErrorZ)); return res; }
11086         ~CResult_SpliceDecodeErrorZ() { CResult_SpliceDecodeErrorZ_free(self); }
11087         CResult_SpliceDecodeErrorZ& operator=(CResult_SpliceDecodeErrorZ&& o) { CResult_SpliceDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpliceDecodeErrorZ)); return *this; }
11088         LDKCResult_SpliceDecodeErrorZ* operator &() { return &self; }
11089         LDKCResult_SpliceDecodeErrorZ* operator ->() { return &self; }
11090         const LDKCResult_SpliceDecodeErrorZ* operator &() const { return &self; }
11091         const LDKCResult_SpliceDecodeErrorZ* operator ->() const { return &self; }
11092 };
11093 class CResult_PaymentPurposeDecodeErrorZ {
11094 private:
11095         LDKCResult_PaymentPurposeDecodeErrorZ self;
11096 public:
11097         CResult_PaymentPurposeDecodeErrorZ(const CResult_PaymentPurposeDecodeErrorZ&) = delete;
11098         CResult_PaymentPurposeDecodeErrorZ(CResult_PaymentPurposeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentPurposeDecodeErrorZ)); }
11099         CResult_PaymentPurposeDecodeErrorZ(LDKCResult_PaymentPurposeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentPurposeDecodeErrorZ)); }
11100         operator LDKCResult_PaymentPurposeDecodeErrorZ() && { LDKCResult_PaymentPurposeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentPurposeDecodeErrorZ)); return res; }
11101         ~CResult_PaymentPurposeDecodeErrorZ() { CResult_PaymentPurposeDecodeErrorZ_free(self); }
11102         CResult_PaymentPurposeDecodeErrorZ& operator=(CResult_PaymentPurposeDecodeErrorZ&& o) { CResult_PaymentPurposeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentPurposeDecodeErrorZ)); return *this; }
11103         LDKCResult_PaymentPurposeDecodeErrorZ* operator &() { return &self; }
11104         LDKCResult_PaymentPurposeDecodeErrorZ* operator ->() { return &self; }
11105         const LDKCResult_PaymentPurposeDecodeErrorZ* operator &() const { return &self; }
11106         const LDKCResult_PaymentPurposeDecodeErrorZ* operator ->() const { return &self; }
11107 };
11108 class CResult_ClaimedHTLCDecodeErrorZ {
11109 private:
11110         LDKCResult_ClaimedHTLCDecodeErrorZ self;
11111 public:
11112         CResult_ClaimedHTLCDecodeErrorZ(const CResult_ClaimedHTLCDecodeErrorZ&) = delete;
11113         CResult_ClaimedHTLCDecodeErrorZ(CResult_ClaimedHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClaimedHTLCDecodeErrorZ)); }
11114         CResult_ClaimedHTLCDecodeErrorZ(LDKCResult_ClaimedHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ)); }
11115         operator LDKCResult_ClaimedHTLCDecodeErrorZ() && { LDKCResult_ClaimedHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ)); return res; }
11116         ~CResult_ClaimedHTLCDecodeErrorZ() { CResult_ClaimedHTLCDecodeErrorZ_free(self); }
11117         CResult_ClaimedHTLCDecodeErrorZ& operator=(CResult_ClaimedHTLCDecodeErrorZ&& o) { CResult_ClaimedHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClaimedHTLCDecodeErrorZ)); return *this; }
11118         LDKCResult_ClaimedHTLCDecodeErrorZ* operator &() { return &self; }
11119         LDKCResult_ClaimedHTLCDecodeErrorZ* operator ->() { return &self; }
11120         const LDKCResult_ClaimedHTLCDecodeErrorZ* operator &() const { return &self; }
11121         const LDKCResult_ClaimedHTLCDecodeErrorZ* operator ->() const { return &self; }
11122 };
11123 class CResult_OutPointDecodeErrorZ {
11124 private:
11125         LDKCResult_OutPointDecodeErrorZ self;
11126 public:
11127         CResult_OutPointDecodeErrorZ(const CResult_OutPointDecodeErrorZ&) = delete;
11128         CResult_OutPointDecodeErrorZ(CResult_OutPointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OutPointDecodeErrorZ)); }
11129         CResult_OutPointDecodeErrorZ(LDKCResult_OutPointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OutPointDecodeErrorZ)); }
11130         operator LDKCResult_OutPointDecodeErrorZ() && { LDKCResult_OutPointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OutPointDecodeErrorZ)); return res; }
11131         ~CResult_OutPointDecodeErrorZ() { CResult_OutPointDecodeErrorZ_free(self); }
11132         CResult_OutPointDecodeErrorZ& operator=(CResult_OutPointDecodeErrorZ&& o) { CResult_OutPointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OutPointDecodeErrorZ)); return *this; }
11133         LDKCResult_OutPointDecodeErrorZ* operator &() { return &self; }
11134         LDKCResult_OutPointDecodeErrorZ* operator ->() { return &self; }
11135         const LDKCResult_OutPointDecodeErrorZ* operator &() const { return &self; }
11136         const LDKCResult_OutPointDecodeErrorZ* operator ->() const { return &self; }
11137 };
11138 class CVec_ChannelDetailsZ {
11139 private:
11140         LDKCVec_ChannelDetailsZ self;
11141 public:
11142         CVec_ChannelDetailsZ(const CVec_ChannelDetailsZ&) = delete;
11143         CVec_ChannelDetailsZ(CVec_ChannelDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelDetailsZ)); }
11144         CVec_ChannelDetailsZ(LDKCVec_ChannelDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelDetailsZ)); }
11145         operator LDKCVec_ChannelDetailsZ() && { LDKCVec_ChannelDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelDetailsZ)); return res; }
11146         ~CVec_ChannelDetailsZ() { CVec_ChannelDetailsZ_free(self); }
11147         CVec_ChannelDetailsZ& operator=(CVec_ChannelDetailsZ&& o) { CVec_ChannelDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelDetailsZ)); return *this; }
11148         LDKCVec_ChannelDetailsZ* operator &() { return &self; }
11149         LDKCVec_ChannelDetailsZ* operator ->() { return &self; }
11150         const LDKCVec_ChannelDetailsZ* operator &() const { return &self; }
11151         const LDKCVec_ChannelDetailsZ* operator ->() const { return &self; }
11152 };
11153 class C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ {
11154 private:
11155         LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ self;
11156 public:
11157         C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ(const C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ&) = delete;
11158         C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ(C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ)); }
11159         C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ)); }
11160         operator LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ() && { LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ)); return res; }
11161         ~C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ() { C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_free(self); }
11162         C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ& operator=(C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ&& o) { C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ)); return *this; }
11163         LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ* operator &() { return &self; }
11164         LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ* operator ->() { return &self; }
11165         const LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ* operator &() const { return &self; }
11166         const LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ* operator ->() const { return &self; }
11167 };
11168 class CResult_Bolt11InvoiceFeaturesDecodeErrorZ {
11169 private:
11170         LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ self;
11171 public:
11172         CResult_Bolt11InvoiceFeaturesDecodeErrorZ(const CResult_Bolt11InvoiceFeaturesDecodeErrorZ&) = delete;
11173         CResult_Bolt11InvoiceFeaturesDecodeErrorZ(CResult_Bolt11InvoiceFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceFeaturesDecodeErrorZ)); }
11174         CResult_Bolt11InvoiceFeaturesDecodeErrorZ(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ)); }
11175         operator LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ() && { LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ)); return res; }
11176         ~CResult_Bolt11InvoiceFeaturesDecodeErrorZ() { CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(self); }
11177         CResult_Bolt11InvoiceFeaturesDecodeErrorZ& operator=(CResult_Bolt11InvoiceFeaturesDecodeErrorZ&& o) { CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceFeaturesDecodeErrorZ)); return *this; }
11178         LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator &() { return &self; }
11179         LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator ->() { return &self; }
11180         const LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
11181         const LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
11182 };
11183 class CVec_MessageSendEventZ {
11184 private:
11185         LDKCVec_MessageSendEventZ self;
11186 public:
11187         CVec_MessageSendEventZ(const CVec_MessageSendEventZ&) = delete;
11188         CVec_MessageSendEventZ(CVec_MessageSendEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MessageSendEventZ)); }
11189         CVec_MessageSendEventZ(LDKCVec_MessageSendEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MessageSendEventZ)); }
11190         operator LDKCVec_MessageSendEventZ() && { LDKCVec_MessageSendEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MessageSendEventZ)); return res; }
11191         ~CVec_MessageSendEventZ() { CVec_MessageSendEventZ_free(self); }
11192         CVec_MessageSendEventZ& operator=(CVec_MessageSendEventZ&& o) { CVec_MessageSendEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MessageSendEventZ)); return *this; }
11193         LDKCVec_MessageSendEventZ* operator &() { return &self; }
11194         LDKCVec_MessageSendEventZ* operator ->() { return &self; }
11195         const LDKCVec_MessageSendEventZ* operator &() const { return &self; }
11196         const LDKCVec_MessageSendEventZ* operator ->() const { return &self; }
11197 };
11198 class CVec_MonitorUpdateIdZ {
11199 private:
11200         LDKCVec_MonitorUpdateIdZ self;
11201 public:
11202         CVec_MonitorUpdateIdZ(const CVec_MonitorUpdateIdZ&) = delete;
11203         CVec_MonitorUpdateIdZ(CVec_MonitorUpdateIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorUpdateIdZ)); }
11204         CVec_MonitorUpdateIdZ(LDKCVec_MonitorUpdateIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorUpdateIdZ)); }
11205         operator LDKCVec_MonitorUpdateIdZ() && { LDKCVec_MonitorUpdateIdZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorUpdateIdZ)); return res; }
11206         ~CVec_MonitorUpdateIdZ() { CVec_MonitorUpdateIdZ_free(self); }
11207         CVec_MonitorUpdateIdZ& operator=(CVec_MonitorUpdateIdZ&& o) { CVec_MonitorUpdateIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MonitorUpdateIdZ)); return *this; }
11208         LDKCVec_MonitorUpdateIdZ* operator &() { return &self; }
11209         LDKCVec_MonitorUpdateIdZ* operator ->() { return &self; }
11210         const LDKCVec_MonitorUpdateIdZ* operator &() const { return &self; }
11211         const LDKCVec_MonitorUpdateIdZ* operator ->() const { return &self; }
11212 };
11213 class CResult_RouteHintHopDecodeErrorZ {
11214 private:
11215         LDKCResult_RouteHintHopDecodeErrorZ self;
11216 public:
11217         CResult_RouteHintHopDecodeErrorZ(const CResult_RouteHintHopDecodeErrorZ&) = delete;
11218         CResult_RouteHintHopDecodeErrorZ(CResult_RouteHintHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHintHopDecodeErrorZ)); }
11219         CResult_RouteHintHopDecodeErrorZ(LDKCResult_RouteHintHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHintHopDecodeErrorZ)); }
11220         operator LDKCResult_RouteHintHopDecodeErrorZ() && { LDKCResult_RouteHintHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHintHopDecodeErrorZ)); return res; }
11221         ~CResult_RouteHintHopDecodeErrorZ() { CResult_RouteHintHopDecodeErrorZ_free(self); }
11222         CResult_RouteHintHopDecodeErrorZ& operator=(CResult_RouteHintHopDecodeErrorZ&& o) { CResult_RouteHintHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHintHopDecodeErrorZ)); return *this; }
11223         LDKCResult_RouteHintHopDecodeErrorZ* operator &() { return &self; }
11224         LDKCResult_RouteHintHopDecodeErrorZ* operator ->() { return &self; }
11225         const LDKCResult_RouteHintHopDecodeErrorZ* operator &() const { return &self; }
11226         const LDKCResult_RouteHintHopDecodeErrorZ* operator ->() const { return &self; }
11227 };
11228 class CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ {
11229 private:
11230         LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ self;
11231 public:
11232         CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ(const CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ&) = delete;
11233         CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ(CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ)); }
11234         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)); }
11235         operator LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ() && { LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ)); return res; }
11236         ~CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ() { CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_free(self); }
11237         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; }
11238         LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ* operator &() { return &self; }
11239         LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ* operator ->() { return &self; }
11240         const LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ* operator &() const { return &self; }
11241         const LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ* operator ->() const { return &self; }
11242 };
11243 class CResult_UpdateFailMalformedHTLCDecodeErrorZ {
11244 private:
11245         LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ self;
11246 public:
11247         CResult_UpdateFailMalformedHTLCDecodeErrorZ(const CResult_UpdateFailMalformedHTLCDecodeErrorZ&) = delete;
11248         CResult_UpdateFailMalformedHTLCDecodeErrorZ(CResult_UpdateFailMalformedHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFailMalformedHTLCDecodeErrorZ)); }
11249         CResult_UpdateFailMalformedHTLCDecodeErrorZ(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ)); }
11250         operator LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ() && { LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ)); return res; }
11251         ~CResult_UpdateFailMalformedHTLCDecodeErrorZ() { CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(self); }
11252         CResult_UpdateFailMalformedHTLCDecodeErrorZ& operator=(CResult_UpdateFailMalformedHTLCDecodeErrorZ&& o) { CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFailMalformedHTLCDecodeErrorZ)); return *this; }
11253         LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() { return &self; }
11254         LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() { return &self; }
11255         const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() const { return &self; }
11256         const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() const { return &self; }
11257 };
11258 class CResult_BlindedPayInfoDecodeErrorZ {
11259 private:
11260         LDKCResult_BlindedPayInfoDecodeErrorZ self;
11261 public:
11262         CResult_BlindedPayInfoDecodeErrorZ(const CResult_BlindedPayInfoDecodeErrorZ&) = delete;
11263         CResult_BlindedPayInfoDecodeErrorZ(CResult_BlindedPayInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPayInfoDecodeErrorZ)); }
11264         CResult_BlindedPayInfoDecodeErrorZ(LDKCResult_BlindedPayInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ)); }
11265         operator LDKCResult_BlindedPayInfoDecodeErrorZ() && { LDKCResult_BlindedPayInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ)); return res; }
11266         ~CResult_BlindedPayInfoDecodeErrorZ() { CResult_BlindedPayInfoDecodeErrorZ_free(self); }
11267         CResult_BlindedPayInfoDecodeErrorZ& operator=(CResult_BlindedPayInfoDecodeErrorZ&& o) { CResult_BlindedPayInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPayInfoDecodeErrorZ)); return *this; }
11268         LDKCResult_BlindedPayInfoDecodeErrorZ* operator &() { return &self; }
11269         LDKCResult_BlindedPayInfoDecodeErrorZ* operator ->() { return &self; }
11270         const LDKCResult_BlindedPayInfoDecodeErrorZ* operator &() const { return &self; }
11271         const LDKCResult_BlindedPayInfoDecodeErrorZ* operator ->() const { return &self; }
11272 };
11273 class CResult_ThirtyTwoBytesAPIErrorZ {
11274 private:
11275         LDKCResult_ThirtyTwoBytesAPIErrorZ self;
11276 public:
11277         CResult_ThirtyTwoBytesAPIErrorZ(const CResult_ThirtyTwoBytesAPIErrorZ&) = delete;
11278         CResult_ThirtyTwoBytesAPIErrorZ(CResult_ThirtyTwoBytesAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesAPIErrorZ)); }
11279         CResult_ThirtyTwoBytesAPIErrorZ(LDKCResult_ThirtyTwoBytesAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesAPIErrorZ)); }
11280         operator LDKCResult_ThirtyTwoBytesAPIErrorZ() && { LDKCResult_ThirtyTwoBytesAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesAPIErrorZ)); return res; }
11281         ~CResult_ThirtyTwoBytesAPIErrorZ() { CResult_ThirtyTwoBytesAPIErrorZ_free(self); }
11282         CResult_ThirtyTwoBytesAPIErrorZ& operator=(CResult_ThirtyTwoBytesAPIErrorZ&& o) { CResult_ThirtyTwoBytesAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesAPIErrorZ)); return *this; }
11283         LDKCResult_ThirtyTwoBytesAPIErrorZ* operator &() { return &self; }
11284         LDKCResult_ThirtyTwoBytesAPIErrorZ* operator ->() { return &self; }
11285         const LDKCResult_ThirtyTwoBytesAPIErrorZ* operator &() const { return &self; }
11286         const LDKCResult_ThirtyTwoBytesAPIErrorZ* operator ->() const { return &self; }
11287 };
11288 class COption_ChannelShutdownStateZ {
11289 private:
11290         LDKCOption_ChannelShutdownStateZ self;
11291 public:
11292         COption_ChannelShutdownStateZ(const COption_ChannelShutdownStateZ&) = delete;
11293         COption_ChannelShutdownStateZ(COption_ChannelShutdownStateZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ChannelShutdownStateZ)); }
11294         COption_ChannelShutdownStateZ(LDKCOption_ChannelShutdownStateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ChannelShutdownStateZ)); }
11295         operator LDKCOption_ChannelShutdownStateZ() && { LDKCOption_ChannelShutdownStateZ res = self; memset(&self, 0, sizeof(LDKCOption_ChannelShutdownStateZ)); return res; }
11296         ~COption_ChannelShutdownStateZ() { COption_ChannelShutdownStateZ_free(self); }
11297         COption_ChannelShutdownStateZ& operator=(COption_ChannelShutdownStateZ&& o) { COption_ChannelShutdownStateZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ChannelShutdownStateZ)); return *this; }
11298         LDKCOption_ChannelShutdownStateZ* operator &() { return &self; }
11299         LDKCOption_ChannelShutdownStateZ* operator ->() { return &self; }
11300         const LDKCOption_ChannelShutdownStateZ* operator &() const { return &self; }
11301         const LDKCOption_ChannelShutdownStateZ* operator ->() const { return &self; }
11302 };
11303 class CResult_Bolt12InvoiceBolt12SemanticErrorZ {
11304 private:
11305         LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ self;
11306 public:
11307         CResult_Bolt12InvoiceBolt12SemanticErrorZ(const CResult_Bolt12InvoiceBolt12SemanticErrorZ&) = delete;
11308         CResult_Bolt12InvoiceBolt12SemanticErrorZ(CResult_Bolt12InvoiceBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt12InvoiceBolt12SemanticErrorZ)); }
11309         CResult_Bolt12InvoiceBolt12SemanticErrorZ(LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ)); }
11310         operator LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ() && { LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ)); return res; }
11311         ~CResult_Bolt12InvoiceBolt12SemanticErrorZ() { CResult_Bolt12InvoiceBolt12SemanticErrorZ_free(self); }
11312         CResult_Bolt12InvoiceBolt12SemanticErrorZ& operator=(CResult_Bolt12InvoiceBolt12SemanticErrorZ&& o) { CResult_Bolt12InvoiceBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt12InvoiceBolt12SemanticErrorZ)); return *this; }
11313         LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ* operator &() { return &self; }
11314         LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ* operator ->() { return &self; }
11315         const LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ* operator &() const { return &self; }
11316         const LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ* operator ->() const { return &self; }
11317 };
11318 class CResult_InvoiceRequestFieldsDecodeErrorZ {
11319 private:
11320         LDKCResult_InvoiceRequestFieldsDecodeErrorZ self;
11321 public:
11322         CResult_InvoiceRequestFieldsDecodeErrorZ(const CResult_InvoiceRequestFieldsDecodeErrorZ&) = delete;
11323         CResult_InvoiceRequestFieldsDecodeErrorZ(CResult_InvoiceRequestFieldsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceRequestFieldsDecodeErrorZ)); }
11324         CResult_InvoiceRequestFieldsDecodeErrorZ(LDKCResult_InvoiceRequestFieldsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceRequestFieldsDecodeErrorZ)); }
11325         operator LDKCResult_InvoiceRequestFieldsDecodeErrorZ() && { LDKCResult_InvoiceRequestFieldsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceRequestFieldsDecodeErrorZ)); return res; }
11326         ~CResult_InvoiceRequestFieldsDecodeErrorZ() { CResult_InvoiceRequestFieldsDecodeErrorZ_free(self); }
11327         CResult_InvoiceRequestFieldsDecodeErrorZ& operator=(CResult_InvoiceRequestFieldsDecodeErrorZ&& o) { CResult_InvoiceRequestFieldsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceRequestFieldsDecodeErrorZ)); return *this; }
11328         LDKCResult_InvoiceRequestFieldsDecodeErrorZ* operator &() { return &self; }
11329         LDKCResult_InvoiceRequestFieldsDecodeErrorZ* operator ->() { return &self; }
11330         const LDKCResult_InvoiceRequestFieldsDecodeErrorZ* operator &() const { return &self; }
11331         const LDKCResult_InvoiceRequestFieldsDecodeErrorZ* operator ->() const { return &self; }
11332 };
11333 class CResult_AcceptChannelDecodeErrorZ {
11334 private:
11335         LDKCResult_AcceptChannelDecodeErrorZ self;
11336 public:
11337         CResult_AcceptChannelDecodeErrorZ(const CResult_AcceptChannelDecodeErrorZ&) = delete;
11338         CResult_AcceptChannelDecodeErrorZ(CResult_AcceptChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); }
11339         CResult_AcceptChannelDecodeErrorZ(LDKCResult_AcceptChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); }
11340         operator LDKCResult_AcceptChannelDecodeErrorZ() && { LDKCResult_AcceptChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); return res; }
11341         ~CResult_AcceptChannelDecodeErrorZ() { CResult_AcceptChannelDecodeErrorZ_free(self); }
11342         CResult_AcceptChannelDecodeErrorZ& operator=(CResult_AcceptChannelDecodeErrorZ&& o) { CResult_AcceptChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); return *this; }
11343         LDKCResult_AcceptChannelDecodeErrorZ* operator &() { return &self; }
11344         LDKCResult_AcceptChannelDecodeErrorZ* operator ->() { return &self; }
11345         const LDKCResult_AcceptChannelDecodeErrorZ* operator &() const { return &self; }
11346         const LDKCResult_AcceptChannelDecodeErrorZ* operator ->() const { return &self; }
11347 };
11348 class CResult_HostnameDecodeErrorZ {
11349 private:
11350         LDKCResult_HostnameDecodeErrorZ self;
11351 public:
11352         CResult_HostnameDecodeErrorZ(const CResult_HostnameDecodeErrorZ&) = delete;
11353         CResult_HostnameDecodeErrorZ(CResult_HostnameDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HostnameDecodeErrorZ)); }
11354         CResult_HostnameDecodeErrorZ(LDKCResult_HostnameDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HostnameDecodeErrorZ)); }
11355         operator LDKCResult_HostnameDecodeErrorZ() && { LDKCResult_HostnameDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HostnameDecodeErrorZ)); return res; }
11356         ~CResult_HostnameDecodeErrorZ() { CResult_HostnameDecodeErrorZ_free(self); }
11357         CResult_HostnameDecodeErrorZ& operator=(CResult_HostnameDecodeErrorZ&& o) { CResult_HostnameDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HostnameDecodeErrorZ)); return *this; }
11358         LDKCResult_HostnameDecodeErrorZ* operator &() { return &self; }
11359         LDKCResult_HostnameDecodeErrorZ* operator ->() { return &self; }
11360         const LDKCResult_HostnameDecodeErrorZ* operator &() const { return &self; }
11361         const LDKCResult_HostnameDecodeErrorZ* operator ->() const { return &self; }
11362 };
11363 class C2Tuple_u64u16Z {
11364 private:
11365         LDKC2Tuple_u64u16Z self;
11366 public:
11367         C2Tuple_u64u16Z(const C2Tuple_u64u16Z&) = delete;
11368         C2Tuple_u64u16Z(C2Tuple_u64u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64u16Z)); }
11369         C2Tuple_u64u16Z(LDKC2Tuple_u64u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64u16Z)); }
11370         operator LDKC2Tuple_u64u16Z() && { LDKC2Tuple_u64u16Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64u16Z)); return res; }
11371         ~C2Tuple_u64u16Z() { C2Tuple_u64u16Z_free(self); }
11372         C2Tuple_u64u16Z& operator=(C2Tuple_u64u16Z&& o) { C2Tuple_u64u16Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u64u16Z)); return *this; }
11373         LDKC2Tuple_u64u16Z* operator &() { return &self; }
11374         LDKC2Tuple_u64u16Z* operator ->() { return &self; }
11375         const LDKC2Tuple_u64u16Z* operator &() const { return &self; }
11376         const LDKC2Tuple_u64u16Z* operator ->() const { return &self; }
11377 };
11378 class COption_ThirtyTwoBytesZ {
11379 private:
11380         LDKCOption_ThirtyTwoBytesZ self;
11381 public:
11382         COption_ThirtyTwoBytesZ(const COption_ThirtyTwoBytesZ&) = delete;
11383         COption_ThirtyTwoBytesZ(COption_ThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ThirtyTwoBytesZ)); }
11384         COption_ThirtyTwoBytesZ(LDKCOption_ThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ThirtyTwoBytesZ)); }
11385         operator LDKCOption_ThirtyTwoBytesZ() && { LDKCOption_ThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKCOption_ThirtyTwoBytesZ)); return res; }
11386         ~COption_ThirtyTwoBytesZ() { COption_ThirtyTwoBytesZ_free(self); }
11387         COption_ThirtyTwoBytesZ& operator=(COption_ThirtyTwoBytesZ&& o) { COption_ThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ThirtyTwoBytesZ)); return *this; }
11388         LDKCOption_ThirtyTwoBytesZ* operator &() { return &self; }
11389         LDKCOption_ThirtyTwoBytesZ* operator ->() { return &self; }
11390         const LDKCOption_ThirtyTwoBytesZ* operator &() const { return &self; }
11391         const LDKCOption_ThirtyTwoBytesZ* operator ->() const { return &self; }
11392 };
11393 class CVec_u64Z {
11394 private:
11395         LDKCVec_u64Z self;
11396 public:
11397         CVec_u64Z(const CVec_u64Z&) = delete;
11398         CVec_u64Z(CVec_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u64Z)); }
11399         CVec_u64Z(LDKCVec_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u64Z)); }
11400         operator LDKCVec_u64Z() && { LDKCVec_u64Z res = self; memset(&self, 0, sizeof(LDKCVec_u64Z)); return res; }
11401         ~CVec_u64Z() { CVec_u64Z_free(self); }
11402         CVec_u64Z& operator=(CVec_u64Z&& o) { CVec_u64Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u64Z)); return *this; }
11403         LDKCVec_u64Z* operator &() { return &self; }
11404         LDKCVec_u64Z* operator ->() { return &self; }
11405         const LDKCVec_u64Z* operator &() const { return &self; }
11406         const LDKCVec_u64Z* operator ->() const { return &self; }
11407 };
11408 class CResult_NoneBolt12SemanticErrorZ {
11409 private:
11410         LDKCResult_NoneBolt12SemanticErrorZ self;
11411 public:
11412         CResult_NoneBolt12SemanticErrorZ(const CResult_NoneBolt12SemanticErrorZ&) = delete;
11413         CResult_NoneBolt12SemanticErrorZ(CResult_NoneBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneBolt12SemanticErrorZ)); }
11414         CResult_NoneBolt12SemanticErrorZ(LDKCResult_NoneBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneBolt12SemanticErrorZ)); }
11415         operator LDKCResult_NoneBolt12SemanticErrorZ() && { LDKCResult_NoneBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneBolt12SemanticErrorZ)); return res; }
11416         ~CResult_NoneBolt12SemanticErrorZ() { CResult_NoneBolt12SemanticErrorZ_free(self); }
11417         CResult_NoneBolt12SemanticErrorZ& operator=(CResult_NoneBolt12SemanticErrorZ&& o) { CResult_NoneBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneBolt12SemanticErrorZ)); return *this; }
11418         LDKCResult_NoneBolt12SemanticErrorZ* operator &() { return &self; }
11419         LDKCResult_NoneBolt12SemanticErrorZ* operator ->() { return &self; }
11420         const LDKCResult_NoneBolt12SemanticErrorZ* operator &() const { return &self; }
11421         const LDKCResult_NoneBolt12SemanticErrorZ* operator ->() const { return &self; }
11422 };
11423 class COption_SecretKeyZ {
11424 private:
11425         LDKCOption_SecretKeyZ self;
11426 public:
11427         COption_SecretKeyZ(const COption_SecretKeyZ&) = delete;
11428         COption_SecretKeyZ(COption_SecretKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_SecretKeyZ)); }
11429         COption_SecretKeyZ(LDKCOption_SecretKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_SecretKeyZ)); }
11430         operator LDKCOption_SecretKeyZ() && { LDKCOption_SecretKeyZ res = self; memset(&self, 0, sizeof(LDKCOption_SecretKeyZ)); return res; }
11431         ~COption_SecretKeyZ() { COption_SecretKeyZ_free(self); }
11432         COption_SecretKeyZ& operator=(COption_SecretKeyZ&& o) { COption_SecretKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_SecretKeyZ)); return *this; }
11433         LDKCOption_SecretKeyZ* operator &() { return &self; }
11434         LDKCOption_SecretKeyZ* operator ->() { return &self; }
11435         const LDKCOption_SecretKeyZ* operator &() const { return &self; }
11436         const LDKCOption_SecretKeyZ* operator ->() const { return &self; }
11437 };
11438 class CResult_UnknownPaymentContextDecodeErrorZ {
11439 private:
11440         LDKCResult_UnknownPaymentContextDecodeErrorZ self;
11441 public:
11442         CResult_UnknownPaymentContextDecodeErrorZ(const CResult_UnknownPaymentContextDecodeErrorZ&) = delete;
11443         CResult_UnknownPaymentContextDecodeErrorZ(CResult_UnknownPaymentContextDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnknownPaymentContextDecodeErrorZ)); }
11444         CResult_UnknownPaymentContextDecodeErrorZ(LDKCResult_UnknownPaymentContextDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnknownPaymentContextDecodeErrorZ)); }
11445         operator LDKCResult_UnknownPaymentContextDecodeErrorZ() && { LDKCResult_UnknownPaymentContextDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnknownPaymentContextDecodeErrorZ)); return res; }
11446         ~CResult_UnknownPaymentContextDecodeErrorZ() { CResult_UnknownPaymentContextDecodeErrorZ_free(self); }
11447         CResult_UnknownPaymentContextDecodeErrorZ& operator=(CResult_UnknownPaymentContextDecodeErrorZ&& o) { CResult_UnknownPaymentContextDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnknownPaymentContextDecodeErrorZ)); return *this; }
11448         LDKCResult_UnknownPaymentContextDecodeErrorZ* operator &() { return &self; }
11449         LDKCResult_UnknownPaymentContextDecodeErrorZ* operator ->() { return &self; }
11450         const LDKCResult_UnknownPaymentContextDecodeErrorZ* operator &() const { return &self; }
11451         const LDKCResult_UnknownPaymentContextDecodeErrorZ* operator ->() const { return &self; }
11452 };
11453 class CResult_OutputSweeperDecodeErrorZ {
11454 private:
11455         LDKCResult_OutputSweeperDecodeErrorZ self;
11456 public:
11457         CResult_OutputSweeperDecodeErrorZ(const CResult_OutputSweeperDecodeErrorZ&) = delete;
11458         CResult_OutputSweeperDecodeErrorZ(CResult_OutputSweeperDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OutputSweeperDecodeErrorZ)); }
11459         CResult_OutputSweeperDecodeErrorZ(LDKCResult_OutputSweeperDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OutputSweeperDecodeErrorZ)); }
11460         operator LDKCResult_OutputSweeperDecodeErrorZ() && { LDKCResult_OutputSweeperDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OutputSweeperDecodeErrorZ)); return res; }
11461         ~CResult_OutputSweeperDecodeErrorZ() { CResult_OutputSweeperDecodeErrorZ_free(self); }
11462         CResult_OutputSweeperDecodeErrorZ& operator=(CResult_OutputSweeperDecodeErrorZ&& o) { CResult_OutputSweeperDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OutputSweeperDecodeErrorZ)); return *this; }
11463         LDKCResult_OutputSweeperDecodeErrorZ* operator &() { return &self; }
11464         LDKCResult_OutputSweeperDecodeErrorZ* operator ->() { return &self; }
11465         const LDKCResult_OutputSweeperDecodeErrorZ* operator &() const { return &self; }
11466         const LDKCResult_OutputSweeperDecodeErrorZ* operator ->() const { return &self; }
11467 };
11468 class CResult_C2Tuple_CVec_u8Zu64ZNoneZ {
11469 private:
11470         LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ self;
11471 public:
11472         CResult_C2Tuple_CVec_u8Zu64ZNoneZ(const CResult_C2Tuple_CVec_u8Zu64ZNoneZ&) = delete;
11473         CResult_C2Tuple_CVec_u8Zu64ZNoneZ(CResult_C2Tuple_CVec_u8Zu64ZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_CVec_u8Zu64ZNoneZ)); }
11474         CResult_C2Tuple_CVec_u8Zu64ZNoneZ(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ)); }
11475         operator LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ() && { LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ)); return res; }
11476         ~CResult_C2Tuple_CVec_u8Zu64ZNoneZ() { CResult_C2Tuple_CVec_u8Zu64ZNoneZ_free(self); }
11477         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; }
11478         LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ* operator &() { return &self; }
11479         LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ* operator ->() { return &self; }
11480         const LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ* operator &() const { return &self; }
11481         const LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ* operator ->() const { return &self; }
11482 };
11483 class COption_EventZ {
11484 private:
11485         LDKCOption_EventZ self;
11486 public:
11487         COption_EventZ(const COption_EventZ&) = delete;
11488         COption_EventZ(COption_EventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_EventZ)); }
11489         COption_EventZ(LDKCOption_EventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_EventZ)); }
11490         operator LDKCOption_EventZ() && { LDKCOption_EventZ res = self; memset(&self, 0, sizeof(LDKCOption_EventZ)); return res; }
11491         ~COption_EventZ() { COption_EventZ_free(self); }
11492         COption_EventZ& operator=(COption_EventZ&& o) { COption_EventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_EventZ)); return *this; }
11493         LDKCOption_EventZ* operator &() { return &self; }
11494         LDKCOption_EventZ* operator ->() { return &self; }
11495         const LDKCOption_EventZ* operator &() const { return &self; }
11496         const LDKCOption_EventZ* operator ->() const { return &self; }
11497 };
11498 class CResult_ChannelTypeFeaturesDecodeErrorZ {
11499 private:
11500         LDKCResult_ChannelTypeFeaturesDecodeErrorZ self;
11501 public:
11502         CResult_ChannelTypeFeaturesDecodeErrorZ(const CResult_ChannelTypeFeaturesDecodeErrorZ&) = delete;
11503         CResult_ChannelTypeFeaturesDecodeErrorZ(CResult_ChannelTypeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTypeFeaturesDecodeErrorZ)); }
11504         CResult_ChannelTypeFeaturesDecodeErrorZ(LDKCResult_ChannelTypeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ)); }
11505         operator LDKCResult_ChannelTypeFeaturesDecodeErrorZ() && { LDKCResult_ChannelTypeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ)); return res; }
11506         ~CResult_ChannelTypeFeaturesDecodeErrorZ() { CResult_ChannelTypeFeaturesDecodeErrorZ_free(self); }
11507         CResult_ChannelTypeFeaturesDecodeErrorZ& operator=(CResult_ChannelTypeFeaturesDecodeErrorZ&& o) { CResult_ChannelTypeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTypeFeaturesDecodeErrorZ)); return *this; }
11508         LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() { return &self; }
11509         LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() { return &self; }
11510         const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() const { return &self; }
11511         const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() const { return &self; }
11512 };
11513 class COption_CVec_SocketAddressZZ {
11514 private:
11515         LDKCOption_CVec_SocketAddressZZ self;
11516 public:
11517         COption_CVec_SocketAddressZZ(const COption_CVec_SocketAddressZZ&) = delete;
11518         COption_CVec_SocketAddressZZ(COption_CVec_SocketAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_SocketAddressZZ)); }
11519         COption_CVec_SocketAddressZZ(LDKCOption_CVec_SocketAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_SocketAddressZZ)); }
11520         operator LDKCOption_CVec_SocketAddressZZ() && { LDKCOption_CVec_SocketAddressZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_SocketAddressZZ)); return res; }
11521         ~COption_CVec_SocketAddressZZ() { COption_CVec_SocketAddressZZ_free(self); }
11522         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; }
11523         LDKCOption_CVec_SocketAddressZZ* operator &() { return &self; }
11524         LDKCOption_CVec_SocketAddressZZ* operator ->() { return &self; }
11525         const LDKCOption_CVec_SocketAddressZZ* operator &() const { return &self; }
11526         const LDKCOption_CVec_SocketAddressZZ* operator ->() const { return &self; }
11527 };
11528 class CVec_RouteHintZ {
11529 private:
11530         LDKCVec_RouteHintZ self;
11531 public:
11532         CVec_RouteHintZ(const CVec_RouteHintZ&) = delete;
11533         CVec_RouteHintZ(CVec_RouteHintZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintZ)); }
11534         CVec_RouteHintZ(LDKCVec_RouteHintZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintZ)); }
11535         operator LDKCVec_RouteHintZ() && { LDKCVec_RouteHintZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintZ)); return res; }
11536         ~CVec_RouteHintZ() { CVec_RouteHintZ_free(self); }
11537         CVec_RouteHintZ& operator=(CVec_RouteHintZ&& o) { CVec_RouteHintZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintZ)); return *this; }
11538         LDKCVec_RouteHintZ* operator &() { return &self; }
11539         LDKCVec_RouteHintZ* operator ->() { return &self; }
11540         const LDKCVec_RouteHintZ* operator &() const { return &self; }
11541         const LDKCVec_RouteHintZ* operator ->() const { return &self; }
11542 };
11543 class COption_u16Z {
11544 private:
11545         LDKCOption_u16Z self;
11546 public:
11547         COption_u16Z(const COption_u16Z&) = delete;
11548         COption_u16Z(COption_u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u16Z)); }
11549         COption_u16Z(LDKCOption_u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u16Z)); }
11550         operator LDKCOption_u16Z() && { LDKCOption_u16Z res = self; memset(&self, 0, sizeof(LDKCOption_u16Z)); return res; }
11551         ~COption_u16Z() { COption_u16Z_free(self); }
11552         COption_u16Z& operator=(COption_u16Z&& o) { COption_u16Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u16Z)); return *this; }
11553         LDKCOption_u16Z* operator &() { return &self; }
11554         LDKCOption_u16Z* operator ->() { return &self; }
11555         const LDKCOption_u16Z* operator &() const { return &self; }
11556         const LDKCOption_u16Z* operator ->() const { return &self; }
11557 };
11558 class COption_PaymentFailureReasonZ {
11559 private:
11560         LDKCOption_PaymentFailureReasonZ self;
11561 public:
11562         COption_PaymentFailureReasonZ(const COption_PaymentFailureReasonZ&) = delete;
11563         COption_PaymentFailureReasonZ(COption_PaymentFailureReasonZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_PaymentFailureReasonZ)); }
11564         COption_PaymentFailureReasonZ(LDKCOption_PaymentFailureReasonZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_PaymentFailureReasonZ)); }
11565         operator LDKCOption_PaymentFailureReasonZ() && { LDKCOption_PaymentFailureReasonZ res = self; memset(&self, 0, sizeof(LDKCOption_PaymentFailureReasonZ)); return res; }
11566         ~COption_PaymentFailureReasonZ() { COption_PaymentFailureReasonZ_free(self); }
11567         COption_PaymentFailureReasonZ& operator=(COption_PaymentFailureReasonZ&& o) { COption_PaymentFailureReasonZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_PaymentFailureReasonZ)); return *this; }
11568         LDKCOption_PaymentFailureReasonZ* operator &() { return &self; }
11569         LDKCOption_PaymentFailureReasonZ* operator ->() { return &self; }
11570         const LDKCOption_PaymentFailureReasonZ* operator &() const { return &self; }
11571         const LDKCOption_PaymentFailureReasonZ* operator ->() const { return &self; }
11572 };
11573 class CResult_Bolt12RefundContextDecodeErrorZ {
11574 private:
11575         LDKCResult_Bolt12RefundContextDecodeErrorZ self;
11576 public:
11577         CResult_Bolt12RefundContextDecodeErrorZ(const CResult_Bolt12RefundContextDecodeErrorZ&) = delete;
11578         CResult_Bolt12RefundContextDecodeErrorZ(CResult_Bolt12RefundContextDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt12RefundContextDecodeErrorZ)); }
11579         CResult_Bolt12RefundContextDecodeErrorZ(LDKCResult_Bolt12RefundContextDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt12RefundContextDecodeErrorZ)); }
11580         operator LDKCResult_Bolt12RefundContextDecodeErrorZ() && { LDKCResult_Bolt12RefundContextDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt12RefundContextDecodeErrorZ)); return res; }
11581         ~CResult_Bolt12RefundContextDecodeErrorZ() { CResult_Bolt12RefundContextDecodeErrorZ_free(self); }
11582         CResult_Bolt12RefundContextDecodeErrorZ& operator=(CResult_Bolt12RefundContextDecodeErrorZ&& o) { CResult_Bolt12RefundContextDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt12RefundContextDecodeErrorZ)); return *this; }
11583         LDKCResult_Bolt12RefundContextDecodeErrorZ* operator &() { return &self; }
11584         LDKCResult_Bolt12RefundContextDecodeErrorZ* operator ->() { return &self; }
11585         const LDKCResult_Bolt12RefundContextDecodeErrorZ* operator &() const { return &self; }
11586         const LDKCResult_Bolt12RefundContextDecodeErrorZ* operator ->() const { return &self; }
11587 };
11588 class CResult_ECDSASignatureNoneZ {
11589 private:
11590         LDKCResult_ECDSASignatureNoneZ self;
11591 public:
11592         CResult_ECDSASignatureNoneZ(const CResult_ECDSASignatureNoneZ&) = delete;
11593         CResult_ECDSASignatureNoneZ(CResult_ECDSASignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ECDSASignatureNoneZ)); }
11594         CResult_ECDSASignatureNoneZ(LDKCResult_ECDSASignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ECDSASignatureNoneZ)); }
11595         operator LDKCResult_ECDSASignatureNoneZ() && { LDKCResult_ECDSASignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ECDSASignatureNoneZ)); return res; }
11596         ~CResult_ECDSASignatureNoneZ() { CResult_ECDSASignatureNoneZ_free(self); }
11597         CResult_ECDSASignatureNoneZ& operator=(CResult_ECDSASignatureNoneZ&& o) { CResult_ECDSASignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ECDSASignatureNoneZ)); return *this; }
11598         LDKCResult_ECDSASignatureNoneZ* operator &() { return &self; }
11599         LDKCResult_ECDSASignatureNoneZ* operator ->() { return &self; }
11600         const LDKCResult_ECDSASignatureNoneZ* operator &() const { return &self; }
11601         const LDKCResult_ECDSASignatureNoneZ* operator ->() const { return &self; }
11602 };
11603 class CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ {
11604 private:
11605         LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ self;
11606 public:
11607         CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ(const CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ&) = delete;
11608         CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ(CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ)); }
11609         CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ(LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ)); }
11610         operator LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ() && { LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ)); return res; }
11611         ~CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ() { CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_free(self); }
11612         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; }
11613         LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ* operator &() { return &self; }
11614         LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ* operator ->() { return &self; }
11615         const LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ* operator &() const { return &self; }
11616         const LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ* operator ->() const { return &self; }
11617 };
11618 class C2Tuple_ChannelIdPublicKeyZ {
11619 private:
11620         LDKC2Tuple_ChannelIdPublicKeyZ self;
11621 public:
11622         C2Tuple_ChannelIdPublicKeyZ(const C2Tuple_ChannelIdPublicKeyZ&) = delete;
11623         C2Tuple_ChannelIdPublicKeyZ(C2Tuple_ChannelIdPublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ChannelIdPublicKeyZ)); }
11624         C2Tuple_ChannelIdPublicKeyZ(LDKC2Tuple_ChannelIdPublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ChannelIdPublicKeyZ)); }
11625         operator LDKC2Tuple_ChannelIdPublicKeyZ() && { LDKC2Tuple_ChannelIdPublicKeyZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ChannelIdPublicKeyZ)); return res; }
11626         ~C2Tuple_ChannelIdPublicKeyZ() { C2Tuple_ChannelIdPublicKeyZ_free(self); }
11627         C2Tuple_ChannelIdPublicKeyZ& operator=(C2Tuple_ChannelIdPublicKeyZ&& o) { C2Tuple_ChannelIdPublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ChannelIdPublicKeyZ)); return *this; }
11628         LDKC2Tuple_ChannelIdPublicKeyZ* operator &() { return &self; }
11629         LDKC2Tuple_ChannelIdPublicKeyZ* operator ->() { return &self; }
11630         const LDKC2Tuple_ChannelIdPublicKeyZ* operator &() const { return &self; }
11631         const LDKC2Tuple_ChannelIdPublicKeyZ* operator ->() const { return &self; }
11632 };
11633 class CVec_WitnessZ {
11634 private:
11635         LDKCVec_WitnessZ self;
11636 public:
11637         CVec_WitnessZ(const CVec_WitnessZ&) = delete;
11638         CVec_WitnessZ(CVec_WitnessZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_WitnessZ)); }
11639         CVec_WitnessZ(LDKCVec_WitnessZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_WitnessZ)); }
11640         operator LDKCVec_WitnessZ() && { LDKCVec_WitnessZ res = self; memset(&self, 0, sizeof(LDKCVec_WitnessZ)); return res; }
11641         ~CVec_WitnessZ() { CVec_WitnessZ_free(self); }
11642         CVec_WitnessZ& operator=(CVec_WitnessZ&& o) { CVec_WitnessZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_WitnessZ)); return *this; }
11643         LDKCVec_WitnessZ* operator &() { return &self; }
11644         LDKCVec_WitnessZ* operator ->() { return &self; }
11645         const LDKCVec_WitnessZ* operator &() const { return &self; }
11646         const LDKCVec_WitnessZ* operator ->() const { return &self; }
11647 };
11648 class CResult_BlindedTailDecodeErrorZ {
11649 private:
11650         LDKCResult_BlindedTailDecodeErrorZ self;
11651 public:
11652         CResult_BlindedTailDecodeErrorZ(const CResult_BlindedTailDecodeErrorZ&) = delete;
11653         CResult_BlindedTailDecodeErrorZ(CResult_BlindedTailDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedTailDecodeErrorZ)); }
11654         CResult_BlindedTailDecodeErrorZ(LDKCResult_BlindedTailDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedTailDecodeErrorZ)); }
11655         operator LDKCResult_BlindedTailDecodeErrorZ() && { LDKCResult_BlindedTailDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedTailDecodeErrorZ)); return res; }
11656         ~CResult_BlindedTailDecodeErrorZ() { CResult_BlindedTailDecodeErrorZ_free(self); }
11657         CResult_BlindedTailDecodeErrorZ& operator=(CResult_BlindedTailDecodeErrorZ&& o) { CResult_BlindedTailDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedTailDecodeErrorZ)); return *this; }
11658         LDKCResult_BlindedTailDecodeErrorZ* operator &() { return &self; }
11659         LDKCResult_BlindedTailDecodeErrorZ* operator ->() { return &self; }
11660         const LDKCResult_BlindedTailDecodeErrorZ* operator &() const { return &self; }
11661         const LDKCResult_BlindedTailDecodeErrorZ* operator ->() const { return &self; }
11662 };
11663 class CResult_SocketAddressSocketAddressParseErrorZ {
11664 private:
11665         LDKCResult_SocketAddressSocketAddressParseErrorZ self;
11666 public:
11667         CResult_SocketAddressSocketAddressParseErrorZ(const CResult_SocketAddressSocketAddressParseErrorZ&) = delete;
11668         CResult_SocketAddressSocketAddressParseErrorZ(CResult_SocketAddressSocketAddressParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SocketAddressSocketAddressParseErrorZ)); }
11669         CResult_SocketAddressSocketAddressParseErrorZ(LDKCResult_SocketAddressSocketAddressParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ)); }
11670         operator LDKCResult_SocketAddressSocketAddressParseErrorZ() && { LDKCResult_SocketAddressSocketAddressParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ)); return res; }
11671         ~CResult_SocketAddressSocketAddressParseErrorZ() { CResult_SocketAddressSocketAddressParseErrorZ_free(self); }
11672         CResult_SocketAddressSocketAddressParseErrorZ& operator=(CResult_SocketAddressSocketAddressParseErrorZ&& o) { CResult_SocketAddressSocketAddressParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SocketAddressSocketAddressParseErrorZ)); return *this; }
11673         LDKCResult_SocketAddressSocketAddressParseErrorZ* operator &() { return &self; }
11674         LDKCResult_SocketAddressSocketAddressParseErrorZ* operator ->() { return &self; }
11675         const LDKCResult_SocketAddressSocketAddressParseErrorZ* operator &() const { return &self; }
11676         const LDKCResult_SocketAddressSocketAddressParseErrorZ* operator ->() const { return &self; }
11677 };
11678 class COption_C2Tuple_u64u16ZZ {
11679 private:
11680         LDKCOption_C2Tuple_u64u16ZZ self;
11681 public:
11682         COption_C2Tuple_u64u16ZZ(const COption_C2Tuple_u64u16ZZ&) = delete;
11683         COption_C2Tuple_u64u16ZZ(COption_C2Tuple_u64u16ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_u64u16ZZ)); }
11684         COption_C2Tuple_u64u16ZZ(LDKCOption_C2Tuple_u64u16ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_u64u16ZZ)); }
11685         operator LDKCOption_C2Tuple_u64u16ZZ() && { LDKCOption_C2Tuple_u64u16ZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_u64u16ZZ)); return res; }
11686         ~COption_C2Tuple_u64u16ZZ() { COption_C2Tuple_u64u16ZZ_free(self); }
11687         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; }
11688         LDKCOption_C2Tuple_u64u16ZZ* operator &() { return &self; }
11689         LDKCOption_C2Tuple_u64u16ZZ* operator ->() { return &self; }
11690         const LDKCOption_C2Tuple_u64u16ZZ* operator &() const { return &self; }
11691         const LDKCOption_C2Tuple_u64u16ZZ* operator ->() const { return &self; }
11692 };
11693 class CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ {
11694 private:
11695         LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ self;
11696 public:
11697         CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(const CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&) = delete;
11698         CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); }
11699         CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); }
11700         operator LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ() && { LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); return res; }
11701         ~CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ() { CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(self); }
11702         CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ& operator=(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& o) { CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); return *this; }
11703         LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator &() { return &self; }
11704         LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator ->() { return &self; }
11705         const LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator &() const { return &self; }
11706         const LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator ->() const { return &self; }
11707 };
11708 class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ {
11709 private:
11710         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ self;
11711 public:
11712         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(const CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&) = delete;
11713         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); }
11714         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); }
11715         operator LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ() && { LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); return res; }
11716         ~CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ() { CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(self); }
11717         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; }
11718         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator &() { return &self; }
11719         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator ->() { return &self; }
11720         const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator &() const { return &self; }
11721         const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator ->() const { return &self; }
11722 };
11723 class CResult_ChannelDerivationParametersDecodeErrorZ {
11724 private:
11725         LDKCResult_ChannelDerivationParametersDecodeErrorZ self;
11726 public:
11727         CResult_ChannelDerivationParametersDecodeErrorZ(const CResult_ChannelDerivationParametersDecodeErrorZ&) = delete;
11728         CResult_ChannelDerivationParametersDecodeErrorZ(CResult_ChannelDerivationParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelDerivationParametersDecodeErrorZ)); }
11729         CResult_ChannelDerivationParametersDecodeErrorZ(LDKCResult_ChannelDerivationParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelDerivationParametersDecodeErrorZ)); }
11730         operator LDKCResult_ChannelDerivationParametersDecodeErrorZ() && { LDKCResult_ChannelDerivationParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelDerivationParametersDecodeErrorZ)); return res; }
11731         ~CResult_ChannelDerivationParametersDecodeErrorZ() { CResult_ChannelDerivationParametersDecodeErrorZ_free(self); }
11732         CResult_ChannelDerivationParametersDecodeErrorZ& operator=(CResult_ChannelDerivationParametersDecodeErrorZ&& o) { CResult_ChannelDerivationParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelDerivationParametersDecodeErrorZ)); return *this; }
11733         LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator &() { return &self; }
11734         LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator ->() { return &self; }
11735         const LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator &() const { return &self; }
11736         const LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator ->() const { return &self; }
11737 };
11738 class CResult_PaymentConstraintsDecodeErrorZ {
11739 private:
11740         LDKCResult_PaymentConstraintsDecodeErrorZ self;
11741 public:
11742         CResult_PaymentConstraintsDecodeErrorZ(const CResult_PaymentConstraintsDecodeErrorZ&) = delete;
11743         CResult_PaymentConstraintsDecodeErrorZ(CResult_PaymentConstraintsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentConstraintsDecodeErrorZ)); }
11744         CResult_PaymentConstraintsDecodeErrorZ(LDKCResult_PaymentConstraintsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ)); }
11745         operator LDKCResult_PaymentConstraintsDecodeErrorZ() && { LDKCResult_PaymentConstraintsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ)); return res; }
11746         ~CResult_PaymentConstraintsDecodeErrorZ() { CResult_PaymentConstraintsDecodeErrorZ_free(self); }
11747         CResult_PaymentConstraintsDecodeErrorZ& operator=(CResult_PaymentConstraintsDecodeErrorZ&& o) { CResult_PaymentConstraintsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentConstraintsDecodeErrorZ)); return *this; }
11748         LDKCResult_PaymentConstraintsDecodeErrorZ* operator &() { return &self; }
11749         LDKCResult_PaymentConstraintsDecodeErrorZ* operator ->() { return &self; }
11750         const LDKCResult_PaymentConstraintsDecodeErrorZ* operator &() const { return &self; }
11751         const LDKCResult_PaymentConstraintsDecodeErrorZ* operator ->() const { return &self; }
11752 };
11753 class CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ {
11754 private:
11755         LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ self;
11756 public:
11757         CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ(const CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ&) = delete;
11758         CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ(CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ)); }
11759         CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ(LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ)); }
11760         operator LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ() && { LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ)); return res; }
11761         ~CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ() { CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_free(self); }
11762         CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ& operator=(CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ&& o) { CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ)); return *this; }
11763         LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ* operator &() { return &self; }
11764         LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ* operator ->() { return &self; }
11765         const LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ* operator &() const { return &self; }
11766         const LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ* operator ->() const { return &self; }
11767 };
11768 class CResult_OnionMessagePathNoneZ {
11769 private:
11770         LDKCResult_OnionMessagePathNoneZ self;
11771 public:
11772         CResult_OnionMessagePathNoneZ(const CResult_OnionMessagePathNoneZ&) = delete;
11773         CResult_OnionMessagePathNoneZ(CResult_OnionMessagePathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionMessagePathNoneZ)); }
11774         CResult_OnionMessagePathNoneZ(LDKCResult_OnionMessagePathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionMessagePathNoneZ)); }
11775         operator LDKCResult_OnionMessagePathNoneZ() && { LDKCResult_OnionMessagePathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionMessagePathNoneZ)); return res; }
11776         ~CResult_OnionMessagePathNoneZ() { CResult_OnionMessagePathNoneZ_free(self); }
11777         CResult_OnionMessagePathNoneZ& operator=(CResult_OnionMessagePathNoneZ&& o) { CResult_OnionMessagePathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionMessagePathNoneZ)); return *this; }
11778         LDKCResult_OnionMessagePathNoneZ* operator &() { return &self; }
11779         LDKCResult_OnionMessagePathNoneZ* operator ->() { return &self; }
11780         const LDKCResult_OnionMessagePathNoneZ* operator &() const { return &self; }
11781         const LDKCResult_OnionMessagePathNoneZ* operator ->() const { return &self; }
11782 };
11783 class C2Tuple_u32CVec_u8ZZ {
11784 private:
11785         LDKC2Tuple_u32CVec_u8ZZ self;
11786 public:
11787         C2Tuple_u32CVec_u8ZZ(const C2Tuple_u32CVec_u8ZZ&) = delete;
11788         C2Tuple_u32CVec_u8ZZ(C2Tuple_u32CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u32CVec_u8ZZ)); }
11789         C2Tuple_u32CVec_u8ZZ(LDKC2Tuple_u32CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u32CVec_u8ZZ)); }
11790         operator LDKC2Tuple_u32CVec_u8ZZ() && { LDKC2Tuple_u32CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u32CVec_u8ZZ)); return res; }
11791         ~C2Tuple_u32CVec_u8ZZ() { C2Tuple_u32CVec_u8ZZ_free(self); }
11792         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; }
11793         LDKC2Tuple_u32CVec_u8ZZ* operator &() { return &self; }
11794         LDKC2Tuple_u32CVec_u8ZZ* operator ->() { return &self; }
11795         const LDKC2Tuple_u32CVec_u8ZZ* operator &() const { return &self; }
11796         const LDKC2Tuple_u32CVec_u8ZZ* operator ->() const { return &self; }
11797 };
11798 class CVec_C2Tuple_PublicKeyTypeZZ {
11799 private:
11800         LDKCVec_C2Tuple_PublicKeyTypeZZ self;
11801 public:
11802         CVec_C2Tuple_PublicKeyTypeZZ(const CVec_C2Tuple_PublicKeyTypeZZ&) = delete;
11803         CVec_C2Tuple_PublicKeyTypeZZ(CVec_C2Tuple_PublicKeyTypeZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyTypeZZ)); }
11804         CVec_C2Tuple_PublicKeyTypeZZ(LDKCVec_C2Tuple_PublicKeyTypeZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ)); }
11805         operator LDKCVec_C2Tuple_PublicKeyTypeZZ() && { LDKCVec_C2Tuple_PublicKeyTypeZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ)); return res; }
11806         ~CVec_C2Tuple_PublicKeyTypeZZ() { CVec_C2Tuple_PublicKeyTypeZZ_free(self); }
11807         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; }
11808         LDKCVec_C2Tuple_PublicKeyTypeZZ* operator &() { return &self; }
11809         LDKCVec_C2Tuple_PublicKeyTypeZZ* operator ->() { return &self; }
11810         const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator &() const { return &self; }
11811         const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator ->() const { return &self; }
11812 };
11813 class CResult_RefundBolt12ParseErrorZ {
11814 private:
11815         LDKCResult_RefundBolt12ParseErrorZ self;
11816 public:
11817         CResult_RefundBolt12ParseErrorZ(const CResult_RefundBolt12ParseErrorZ&) = delete;
11818         CResult_RefundBolt12ParseErrorZ(CResult_RefundBolt12ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RefundBolt12ParseErrorZ)); }
11819         CResult_RefundBolt12ParseErrorZ(LDKCResult_RefundBolt12ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RefundBolt12ParseErrorZ)); }
11820         operator LDKCResult_RefundBolt12ParseErrorZ() && { LDKCResult_RefundBolt12ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RefundBolt12ParseErrorZ)); return res; }
11821         ~CResult_RefundBolt12ParseErrorZ() { CResult_RefundBolt12ParseErrorZ_free(self); }
11822         CResult_RefundBolt12ParseErrorZ& operator=(CResult_RefundBolt12ParseErrorZ&& o) { CResult_RefundBolt12ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RefundBolt12ParseErrorZ)); return *this; }
11823         LDKCResult_RefundBolt12ParseErrorZ* operator &() { return &self; }
11824         LDKCResult_RefundBolt12ParseErrorZ* operator ->() { return &self; }
11825         const LDKCResult_RefundBolt12ParseErrorZ* operator &() const { return &self; }
11826         const LDKCResult_RefundBolt12ParseErrorZ* operator ->() const { return &self; }
11827 };
11828 class CResult_u32GraphSyncErrorZ {
11829 private:
11830         LDKCResult_u32GraphSyncErrorZ self;
11831 public:
11832         CResult_u32GraphSyncErrorZ(const CResult_u32GraphSyncErrorZ&) = delete;
11833         CResult_u32GraphSyncErrorZ(CResult_u32GraphSyncErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); }
11834         CResult_u32GraphSyncErrorZ(LDKCResult_u32GraphSyncErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); }
11835         operator LDKCResult_u32GraphSyncErrorZ() && { LDKCResult_u32GraphSyncErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); return res; }
11836         ~CResult_u32GraphSyncErrorZ() { CResult_u32GraphSyncErrorZ_free(self); }
11837         CResult_u32GraphSyncErrorZ& operator=(CResult_u32GraphSyncErrorZ&& o) { CResult_u32GraphSyncErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); return *this; }
11838         LDKCResult_u32GraphSyncErrorZ* operator &() { return &self; }
11839         LDKCResult_u32GraphSyncErrorZ* operator ->() { return &self; }
11840         const LDKCResult_u32GraphSyncErrorZ* operator &() const { return &self; }
11841         const LDKCResult_u32GraphSyncErrorZ* operator ->() const { return &self; }
11842 };
11843 class CVec_C2Tuple_u64CVec_u8ZZZ {
11844 private:
11845         LDKCVec_C2Tuple_u64CVec_u8ZZZ self;
11846 public:
11847         CVec_C2Tuple_u64CVec_u8ZZZ(const CVec_C2Tuple_u64CVec_u8ZZZ&) = delete;
11848         CVec_C2Tuple_u64CVec_u8ZZZ(CVec_C2Tuple_u64CVec_u8ZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u64CVec_u8ZZZ)); }
11849         CVec_C2Tuple_u64CVec_u8ZZZ(LDKCVec_C2Tuple_u64CVec_u8ZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u64CVec_u8ZZZ)); }
11850         operator LDKCVec_C2Tuple_u64CVec_u8ZZZ() && { LDKCVec_C2Tuple_u64CVec_u8ZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u64CVec_u8ZZZ)); return res; }
11851         ~CVec_C2Tuple_u64CVec_u8ZZZ() { CVec_C2Tuple_u64CVec_u8ZZZ_free(self); }
11852         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; }
11853         LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator &() { return &self; }
11854         LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator ->() { return &self; }
11855         const LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator &() const { return &self; }
11856         const LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator ->() const { return &self; }
11857 };
11858 class CVec_PhantomRouteHintsZ {
11859 private:
11860         LDKCVec_PhantomRouteHintsZ self;
11861 public:
11862         CVec_PhantomRouteHintsZ(const CVec_PhantomRouteHintsZ&) = delete;
11863         CVec_PhantomRouteHintsZ(CVec_PhantomRouteHintsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); }
11864         CVec_PhantomRouteHintsZ(LDKCVec_PhantomRouteHintsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); }
11865         operator LDKCVec_PhantomRouteHintsZ() && { LDKCVec_PhantomRouteHintsZ res = self; memset(&self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); return res; }
11866         ~CVec_PhantomRouteHintsZ() { CVec_PhantomRouteHintsZ_free(self); }
11867         CVec_PhantomRouteHintsZ& operator=(CVec_PhantomRouteHintsZ&& o) { CVec_PhantomRouteHintsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); return *this; }
11868         LDKCVec_PhantomRouteHintsZ* operator &() { return &self; }
11869         LDKCVec_PhantomRouteHintsZ* operator ->() { return &self; }
11870         const LDKCVec_PhantomRouteHintsZ* operator &() const { return &self; }
11871         const LDKCVec_PhantomRouteHintsZ* operator ->() const { return &self; }
11872 };
11873 class CResult_OffersMessageDecodeErrorZ {
11874 private:
11875         LDKCResult_OffersMessageDecodeErrorZ self;
11876 public:
11877         CResult_OffersMessageDecodeErrorZ(const CResult_OffersMessageDecodeErrorZ&) = delete;
11878         CResult_OffersMessageDecodeErrorZ(CResult_OffersMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OffersMessageDecodeErrorZ)); }
11879         CResult_OffersMessageDecodeErrorZ(LDKCResult_OffersMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OffersMessageDecodeErrorZ)); }
11880         operator LDKCResult_OffersMessageDecodeErrorZ() && { LDKCResult_OffersMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OffersMessageDecodeErrorZ)); return res; }
11881         ~CResult_OffersMessageDecodeErrorZ() { CResult_OffersMessageDecodeErrorZ_free(self); }
11882         CResult_OffersMessageDecodeErrorZ& operator=(CResult_OffersMessageDecodeErrorZ&& o) { CResult_OffersMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OffersMessageDecodeErrorZ)); return *this; }
11883         LDKCResult_OffersMessageDecodeErrorZ* operator &() { return &self; }
11884         LDKCResult_OffersMessageDecodeErrorZ* operator ->() { return &self; }
11885         const LDKCResult_OffersMessageDecodeErrorZ* operator &() const { return &self; }
11886         const LDKCResult_OffersMessageDecodeErrorZ* operator ->() const { return &self; }
11887 };
11888 class CResult_NoneAPIErrorZ {
11889 private:
11890         LDKCResult_NoneAPIErrorZ self;
11891 public:
11892         CResult_NoneAPIErrorZ(const CResult_NoneAPIErrorZ&) = delete;
11893         CResult_NoneAPIErrorZ(CResult_NoneAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); }
11894         CResult_NoneAPIErrorZ(LDKCResult_NoneAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); }
11895         operator LDKCResult_NoneAPIErrorZ() && { LDKCResult_NoneAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); return res; }
11896         ~CResult_NoneAPIErrorZ() { CResult_NoneAPIErrorZ_free(self); }
11897         CResult_NoneAPIErrorZ& operator=(CResult_NoneAPIErrorZ&& o) { CResult_NoneAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); return *this; }
11898         LDKCResult_NoneAPIErrorZ* operator &() { return &self; }
11899         LDKCResult_NoneAPIErrorZ* operator ->() { return &self; }
11900         const LDKCResult_NoneAPIErrorZ* operator &() const { return &self; }
11901         const LDKCResult_NoneAPIErrorZ* operator ->() const { return &self; }
11902 };
11903 class CResult_Bolt12InvoiceFeaturesDecodeErrorZ {
11904 private:
11905         LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ self;
11906 public:
11907         CResult_Bolt12InvoiceFeaturesDecodeErrorZ(const CResult_Bolt12InvoiceFeaturesDecodeErrorZ&) = delete;
11908         CResult_Bolt12InvoiceFeaturesDecodeErrorZ(CResult_Bolt12InvoiceFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt12InvoiceFeaturesDecodeErrorZ)); }
11909         CResult_Bolt12InvoiceFeaturesDecodeErrorZ(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ)); }
11910         operator LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ() && { LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ)); return res; }
11911         ~CResult_Bolt12InvoiceFeaturesDecodeErrorZ() { CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(self); }
11912         CResult_Bolt12InvoiceFeaturesDecodeErrorZ& operator=(CResult_Bolt12InvoiceFeaturesDecodeErrorZ&& o) { CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt12InvoiceFeaturesDecodeErrorZ)); return *this; }
11913         LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator &() { return &self; }
11914         LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator ->() { return &self; }
11915         const LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
11916         const LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
11917 };
11918 class COption_f64Z {
11919 private:
11920         LDKCOption_f64Z self;
11921 public:
11922         COption_f64Z(const COption_f64Z&) = delete;
11923         COption_f64Z(COption_f64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_f64Z)); }
11924         COption_f64Z(LDKCOption_f64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_f64Z)); }
11925         operator LDKCOption_f64Z() && { LDKCOption_f64Z res = self; memset(&self, 0, sizeof(LDKCOption_f64Z)); return res; }
11926         ~COption_f64Z() { COption_f64Z_free(self); }
11927         COption_f64Z& operator=(COption_f64Z&& o) { COption_f64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_f64Z)); return *this; }
11928         LDKCOption_f64Z* operator &() { return &self; }
11929         LDKCOption_f64Z* operator ->() { return &self; }
11930         const LDKCOption_f64Z* operator &() const { return &self; }
11931         const LDKCOption_f64Z* operator ->() const { return &self; }
11932 };
11933 class CResult_ChannelDetailsDecodeErrorZ {
11934 private:
11935         LDKCResult_ChannelDetailsDecodeErrorZ self;
11936 public:
11937         CResult_ChannelDetailsDecodeErrorZ(const CResult_ChannelDetailsDecodeErrorZ&) = delete;
11938         CResult_ChannelDetailsDecodeErrorZ(CResult_ChannelDetailsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelDetailsDecodeErrorZ)); }
11939         CResult_ChannelDetailsDecodeErrorZ(LDKCResult_ChannelDetailsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelDetailsDecodeErrorZ)); }
11940         operator LDKCResult_ChannelDetailsDecodeErrorZ() && { LDKCResult_ChannelDetailsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelDetailsDecodeErrorZ)); return res; }
11941         ~CResult_ChannelDetailsDecodeErrorZ() { CResult_ChannelDetailsDecodeErrorZ_free(self); }
11942         CResult_ChannelDetailsDecodeErrorZ& operator=(CResult_ChannelDetailsDecodeErrorZ&& o) { CResult_ChannelDetailsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelDetailsDecodeErrorZ)); return *this; }
11943         LDKCResult_ChannelDetailsDecodeErrorZ* operator &() { return &self; }
11944         LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() { return &self; }
11945         const LDKCResult_ChannelDetailsDecodeErrorZ* operator &() const { return &self; }
11946         const LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() const { return &self; }
11947 };
11948 class CVec_PublicKeyZ {
11949 private:
11950         LDKCVec_PublicKeyZ self;
11951 public:
11952         CVec_PublicKeyZ(const CVec_PublicKeyZ&) = delete;
11953         CVec_PublicKeyZ(CVec_PublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PublicKeyZ)); }
11954         CVec_PublicKeyZ(LDKCVec_PublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PublicKeyZ)); }
11955         operator LDKCVec_PublicKeyZ() && { LDKCVec_PublicKeyZ res = self; memset(&self, 0, sizeof(LDKCVec_PublicKeyZ)); return res; }
11956         ~CVec_PublicKeyZ() { CVec_PublicKeyZ_free(self); }
11957         CVec_PublicKeyZ& operator=(CVec_PublicKeyZ&& o) { CVec_PublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PublicKeyZ)); return *this; }
11958         LDKCVec_PublicKeyZ* operator &() { return &self; }
11959         LDKCVec_PublicKeyZ* operator ->() { return &self; }
11960         const LDKCVec_PublicKeyZ* operator &() const { return &self; }
11961         const LDKCVec_PublicKeyZ* operator ->() const { return &self; }
11962 };
11963 class C2Tuple_CVec_u8Zu64Z {
11964 private:
11965         LDKC2Tuple_CVec_u8Zu64Z self;
11966 public:
11967         C2Tuple_CVec_u8Zu64Z(const C2Tuple_CVec_u8Zu64Z&) = delete;
11968         C2Tuple_CVec_u8Zu64Z(C2Tuple_CVec_u8Zu64Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_CVec_u8Zu64Z)); }
11969         C2Tuple_CVec_u8Zu64Z(LDKC2Tuple_CVec_u8Zu64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_CVec_u8Zu64Z)); }
11970         operator LDKC2Tuple_CVec_u8Zu64Z() && { LDKC2Tuple_CVec_u8Zu64Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_CVec_u8Zu64Z)); return res; }
11971         ~C2Tuple_CVec_u8Zu64Z() { C2Tuple_CVec_u8Zu64Z_free(self); }
11972         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; }
11973         LDKC2Tuple_CVec_u8Zu64Z* operator &() { return &self; }
11974         LDKC2Tuple_CVec_u8Zu64Z* operator ->() { return &self; }
11975         const LDKC2Tuple_CVec_u8Zu64Z* operator &() const { return &self; }
11976         const LDKC2Tuple_CVec_u8Zu64Z* operator ->() const { return &self; }
11977 };
11978 class CVec_C2Tuple_usizeTransactionZZ {
11979 private:
11980         LDKCVec_C2Tuple_usizeTransactionZZ self;
11981 public:
11982         CVec_C2Tuple_usizeTransactionZZ(const CVec_C2Tuple_usizeTransactionZZ&) = delete;
11983         CVec_C2Tuple_usizeTransactionZZ(CVec_C2Tuple_usizeTransactionZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_usizeTransactionZZ)); }
11984         CVec_C2Tuple_usizeTransactionZZ(LDKCVec_C2Tuple_usizeTransactionZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_usizeTransactionZZ)); }
11985         operator LDKCVec_C2Tuple_usizeTransactionZZ() && { LDKCVec_C2Tuple_usizeTransactionZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_usizeTransactionZZ)); return res; }
11986         ~CVec_C2Tuple_usizeTransactionZZ() { CVec_C2Tuple_usizeTransactionZZ_free(self); }
11987         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; }
11988         LDKCVec_C2Tuple_usizeTransactionZZ* operator &() { return &self; }
11989         LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() { return &self; }
11990         const LDKCVec_C2Tuple_usizeTransactionZZ* operator &() const { return &self; }
11991         const LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() const { return &self; }
11992 };
11993 class CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ {
11994 private:
11995         LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ self;
11996 public:
11997         CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(const CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&) = delete;
11998         CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); }
11999         CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); }
12000         operator LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); return res; }
12001         ~CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ() { CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(self); }
12002         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; }
12003         LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator &() { return &self; }
12004         LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator ->() { return &self; }
12005         const LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator &() const { return &self; }
12006         const LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator ->() const { return &self; }
12007 };
12008 class CResult_PendingHTLCRoutingDecodeErrorZ {
12009 private:
12010         LDKCResult_PendingHTLCRoutingDecodeErrorZ self;
12011 public:
12012         CResult_PendingHTLCRoutingDecodeErrorZ(const CResult_PendingHTLCRoutingDecodeErrorZ&) = delete;
12013         CResult_PendingHTLCRoutingDecodeErrorZ(CResult_PendingHTLCRoutingDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PendingHTLCRoutingDecodeErrorZ)); }
12014         CResult_PendingHTLCRoutingDecodeErrorZ(LDKCResult_PendingHTLCRoutingDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PendingHTLCRoutingDecodeErrorZ)); }
12015         operator LDKCResult_PendingHTLCRoutingDecodeErrorZ() && { LDKCResult_PendingHTLCRoutingDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PendingHTLCRoutingDecodeErrorZ)); return res; }
12016         ~CResult_PendingHTLCRoutingDecodeErrorZ() { CResult_PendingHTLCRoutingDecodeErrorZ_free(self); }
12017         CResult_PendingHTLCRoutingDecodeErrorZ& operator=(CResult_PendingHTLCRoutingDecodeErrorZ&& o) { CResult_PendingHTLCRoutingDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PendingHTLCRoutingDecodeErrorZ)); return *this; }
12018         LDKCResult_PendingHTLCRoutingDecodeErrorZ* operator &() { return &self; }
12019         LDKCResult_PendingHTLCRoutingDecodeErrorZ* operator ->() { return &self; }
12020         const LDKCResult_PendingHTLCRoutingDecodeErrorZ* operator &() const { return &self; }
12021         const LDKCResult_PendingHTLCRoutingDecodeErrorZ* operator ->() const { return &self; }
12022 };
12023 class C2Tuple_u64u64Z {
12024 private:
12025         LDKC2Tuple_u64u64Z self;
12026 public:
12027         C2Tuple_u64u64Z(const C2Tuple_u64u64Z&) = delete;
12028         C2Tuple_u64u64Z(C2Tuple_u64u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64u64Z)); }
12029         C2Tuple_u64u64Z(LDKC2Tuple_u64u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64u64Z)); }
12030         operator LDKC2Tuple_u64u64Z() && { LDKC2Tuple_u64u64Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64u64Z)); return res; }
12031         ~C2Tuple_u64u64Z() { C2Tuple_u64u64Z_free(self); }
12032         C2Tuple_u64u64Z& operator=(C2Tuple_u64u64Z&& o) { C2Tuple_u64u64Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u64u64Z)); return *this; }
12033         LDKC2Tuple_u64u64Z* operator &() { return &self; }
12034         LDKC2Tuple_u64u64Z* operator ->() { return &self; }
12035         const LDKC2Tuple_u64u64Z* operator &() const { return &self; }
12036         const LDKC2Tuple_u64u64Z* operator ->() const { return &self; }
12037 };
12038 class CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ {
12039 private:
12040         LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ self;
12041 public:
12042         CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ(const CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ&) = delete;
12043         CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ(CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ)); }
12044         CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ(LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ)); }
12045         operator LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ() && { LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ)); return res; }
12046         ~CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ() { CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_free(self); }
12047         CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ& operator=(CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ&& o) { CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ)); return *this; }
12048         LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ* operator &() { return &self; }
12049         LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ* operator ->() { return &self; }
12050         const LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ* operator &() const { return &self; }
12051         const LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ* operator ->() const { return &self; }
12052 };
12053 class CResult_TxRemoveInputDecodeErrorZ {
12054 private:
12055         LDKCResult_TxRemoveInputDecodeErrorZ self;
12056 public:
12057         CResult_TxRemoveInputDecodeErrorZ(const CResult_TxRemoveInputDecodeErrorZ&) = delete;
12058         CResult_TxRemoveInputDecodeErrorZ(CResult_TxRemoveInputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxRemoveInputDecodeErrorZ)); }
12059         CResult_TxRemoveInputDecodeErrorZ(LDKCResult_TxRemoveInputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxRemoveInputDecodeErrorZ)); }
12060         operator LDKCResult_TxRemoveInputDecodeErrorZ() && { LDKCResult_TxRemoveInputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxRemoveInputDecodeErrorZ)); return res; }
12061         ~CResult_TxRemoveInputDecodeErrorZ() { CResult_TxRemoveInputDecodeErrorZ_free(self); }
12062         CResult_TxRemoveInputDecodeErrorZ& operator=(CResult_TxRemoveInputDecodeErrorZ&& o) { CResult_TxRemoveInputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxRemoveInputDecodeErrorZ)); return *this; }
12063         LDKCResult_TxRemoveInputDecodeErrorZ* operator &() { return &self; }
12064         LDKCResult_TxRemoveInputDecodeErrorZ* operator ->() { return &self; }
12065         const LDKCResult_TxRemoveInputDecodeErrorZ* operator &() const { return &self; }
12066         const LDKCResult_TxRemoveInputDecodeErrorZ* operator ->() const { return &self; }
12067 };
12068 class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
12069 private:
12070         LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ self;
12071 public:
12072         CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(const CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&) = delete;
12073         CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
12074         CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
12075         operator LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ() && { LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return res; }
12076         ~CResult_CounterpartyChannelTransactionParametersDecodeErrorZ() { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); }
12077         CResult_CounterpartyChannelTransactionParametersDecodeErrorZ& operator=(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return *this; }
12078         LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
12079         LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
12080         const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
12081         const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
12082 };
12083 class CResult_RecipientOnionFieldsDecodeErrorZ {
12084 private:
12085         LDKCResult_RecipientOnionFieldsDecodeErrorZ self;
12086 public:
12087         CResult_RecipientOnionFieldsDecodeErrorZ(const CResult_RecipientOnionFieldsDecodeErrorZ&) = delete;
12088         CResult_RecipientOnionFieldsDecodeErrorZ(CResult_RecipientOnionFieldsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecipientOnionFieldsDecodeErrorZ)); }
12089         CResult_RecipientOnionFieldsDecodeErrorZ(LDKCResult_RecipientOnionFieldsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ)); }
12090         operator LDKCResult_RecipientOnionFieldsDecodeErrorZ() && { LDKCResult_RecipientOnionFieldsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ)); return res; }
12091         ~CResult_RecipientOnionFieldsDecodeErrorZ() { CResult_RecipientOnionFieldsDecodeErrorZ_free(self); }
12092         CResult_RecipientOnionFieldsDecodeErrorZ& operator=(CResult_RecipientOnionFieldsDecodeErrorZ&& o) { CResult_RecipientOnionFieldsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecipientOnionFieldsDecodeErrorZ)); return *this; }
12093         LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator &() { return &self; }
12094         LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator ->() { return &self; }
12095         const LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator &() const { return &self; }
12096         const LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator ->() const { return &self; }
12097 };
12098 class C2Tuple_u32TxOutZ {
12099 private:
12100         LDKC2Tuple_u32TxOutZ self;
12101 public:
12102         C2Tuple_u32TxOutZ(const C2Tuple_u32TxOutZ&) = delete;
12103         C2Tuple_u32TxOutZ(C2Tuple_u32TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u32TxOutZ)); }
12104         C2Tuple_u32TxOutZ(LDKC2Tuple_u32TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u32TxOutZ)); }
12105         operator LDKC2Tuple_u32TxOutZ() && { LDKC2Tuple_u32TxOutZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u32TxOutZ)); return res; }
12106         ~C2Tuple_u32TxOutZ() { C2Tuple_u32TxOutZ_free(self); }
12107         C2Tuple_u32TxOutZ& operator=(C2Tuple_u32TxOutZ&& o) { C2Tuple_u32TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u32TxOutZ)); return *this; }
12108         LDKC2Tuple_u32TxOutZ* operator &() { return &self; }
12109         LDKC2Tuple_u32TxOutZ* operator ->() { return &self; }
12110         const LDKC2Tuple_u32TxOutZ* operator &() const { return &self; }
12111         const LDKC2Tuple_u32TxOutZ* operator ->() const { return &self; }
12112 };
12113 class CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ {
12114 private:
12115         LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ self;
12116 public:
12117         CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ(const CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ&) = delete;
12118         CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ(CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ)); }
12119         CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ(LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ)); }
12120         operator LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ() && { LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ)); return res; }
12121         ~CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ() { CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_free(self); }
12122         CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ& operator=(CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ&& o) { CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ)); return *this; }
12123         LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ* operator &() { return &self; }
12124         LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ* operator ->() { return &self; }
12125         const LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ* operator &() const { return &self; }
12126         const LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ* operator ->() const { return &self; }
12127 };
12128 class CResult_PaymentContextDecodeErrorZ {
12129 private:
12130         LDKCResult_PaymentContextDecodeErrorZ self;
12131 public:
12132         CResult_PaymentContextDecodeErrorZ(const CResult_PaymentContextDecodeErrorZ&) = delete;
12133         CResult_PaymentContextDecodeErrorZ(CResult_PaymentContextDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentContextDecodeErrorZ)); }
12134         CResult_PaymentContextDecodeErrorZ(LDKCResult_PaymentContextDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentContextDecodeErrorZ)); }
12135         operator LDKCResult_PaymentContextDecodeErrorZ() && { LDKCResult_PaymentContextDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentContextDecodeErrorZ)); return res; }
12136         ~CResult_PaymentContextDecodeErrorZ() { CResult_PaymentContextDecodeErrorZ_free(self); }
12137         CResult_PaymentContextDecodeErrorZ& operator=(CResult_PaymentContextDecodeErrorZ&& o) { CResult_PaymentContextDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentContextDecodeErrorZ)); return *this; }
12138         LDKCResult_PaymentContextDecodeErrorZ* operator &() { return &self; }
12139         LDKCResult_PaymentContextDecodeErrorZ* operator ->() { return &self; }
12140         const LDKCResult_PaymentContextDecodeErrorZ* operator &() const { return &self; }
12141         const LDKCResult_PaymentContextDecodeErrorZ* operator ->() const { return &self; }
12142 };
12143 class CVec_UtxoZ {
12144 private:
12145         LDKCVec_UtxoZ self;
12146 public:
12147         CVec_UtxoZ(const CVec_UtxoZ&) = delete;
12148         CVec_UtxoZ(CVec_UtxoZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UtxoZ)); }
12149         CVec_UtxoZ(LDKCVec_UtxoZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UtxoZ)); }
12150         operator LDKCVec_UtxoZ() && { LDKCVec_UtxoZ res = self; memset(&self, 0, sizeof(LDKCVec_UtxoZ)); return res; }
12151         ~CVec_UtxoZ() { CVec_UtxoZ_free(self); }
12152         CVec_UtxoZ& operator=(CVec_UtxoZ&& o) { CVec_UtxoZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UtxoZ)); return *this; }
12153         LDKCVec_UtxoZ* operator &() { return &self; }
12154         LDKCVec_UtxoZ* operator ->() { return &self; }
12155         const LDKCVec_UtxoZ* operator &() const { return &self; }
12156         const LDKCVec_UtxoZ* operator ->() const { return &self; }
12157 };
12158 class CResult_ChannelConfigDecodeErrorZ {
12159 private:
12160         LDKCResult_ChannelConfigDecodeErrorZ self;
12161 public:
12162         CResult_ChannelConfigDecodeErrorZ(const CResult_ChannelConfigDecodeErrorZ&) = delete;
12163         CResult_ChannelConfigDecodeErrorZ(CResult_ChannelConfigDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelConfigDecodeErrorZ)); }
12164         CResult_ChannelConfigDecodeErrorZ(LDKCResult_ChannelConfigDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelConfigDecodeErrorZ)); }
12165         operator LDKCResult_ChannelConfigDecodeErrorZ() && { LDKCResult_ChannelConfigDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelConfigDecodeErrorZ)); return res; }
12166         ~CResult_ChannelConfigDecodeErrorZ() { CResult_ChannelConfigDecodeErrorZ_free(self); }
12167         CResult_ChannelConfigDecodeErrorZ& operator=(CResult_ChannelConfigDecodeErrorZ&& o) { CResult_ChannelConfigDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelConfigDecodeErrorZ)); return *this; }
12168         LDKCResult_ChannelConfigDecodeErrorZ* operator &() { return &self; }
12169         LDKCResult_ChannelConfigDecodeErrorZ* operator ->() { return &self; }
12170         const LDKCResult_ChannelConfigDecodeErrorZ* operator &() const { return &self; }
12171         const LDKCResult_ChannelConfigDecodeErrorZ* operator ->() const { return &self; }
12172 };
12173 class CVec_PrivateRouteZ {
12174 private:
12175         LDKCVec_PrivateRouteZ self;
12176 public:
12177         CVec_PrivateRouteZ(const CVec_PrivateRouteZ&) = delete;
12178         CVec_PrivateRouteZ(CVec_PrivateRouteZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PrivateRouteZ)); }
12179         CVec_PrivateRouteZ(LDKCVec_PrivateRouteZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PrivateRouteZ)); }
12180         operator LDKCVec_PrivateRouteZ() && { LDKCVec_PrivateRouteZ res = self; memset(&self, 0, sizeof(LDKCVec_PrivateRouteZ)); return res; }
12181         ~CVec_PrivateRouteZ() { CVec_PrivateRouteZ_free(self); }
12182         CVec_PrivateRouteZ& operator=(CVec_PrivateRouteZ&& o) { CVec_PrivateRouteZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PrivateRouteZ)); return *this; }
12183         LDKCVec_PrivateRouteZ* operator &() { return &self; }
12184         LDKCVec_PrivateRouteZ* operator ->() { return &self; }
12185         const LDKCVec_PrivateRouteZ* operator &() const { return &self; }
12186         const LDKCVec_PrivateRouteZ* operator ->() const { return &self; }
12187 };
12188 class COption_i64Z {
12189 private:
12190         LDKCOption_i64Z self;
12191 public:
12192         COption_i64Z(const COption_i64Z&) = delete;
12193         COption_i64Z(COption_i64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_i64Z)); }
12194         COption_i64Z(LDKCOption_i64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_i64Z)); }
12195         operator LDKCOption_i64Z() && { LDKCOption_i64Z res = self; memset(&self, 0, sizeof(LDKCOption_i64Z)); return res; }
12196         ~COption_i64Z() { COption_i64Z_free(self); }
12197         COption_i64Z& operator=(COption_i64Z&& o) { COption_i64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_i64Z)); return *this; }
12198         LDKCOption_i64Z* operator &() { return &self; }
12199         LDKCOption_i64Z* operator ->() { return &self; }
12200         const LDKCOption_i64Z* operator &() const { return &self; }
12201         const LDKCOption_i64Z* operator ->() const { return &self; }
12202 };
12203 class C2Tuple_ThirtyTwoBytesChannelManagerZ {
12204 private:
12205         LDKC2Tuple_ThirtyTwoBytesChannelManagerZ self;
12206 public:
12207         C2Tuple_ThirtyTwoBytesChannelManagerZ(const C2Tuple_ThirtyTwoBytesChannelManagerZ&) = delete;
12208         C2Tuple_ThirtyTwoBytesChannelManagerZ(C2Tuple_ThirtyTwoBytesChannelManagerZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelManagerZ)); }
12209         C2Tuple_ThirtyTwoBytesChannelManagerZ(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ)); }
12210         operator LDKC2Tuple_ThirtyTwoBytesChannelManagerZ() && { LDKC2Tuple_ThirtyTwoBytesChannelManagerZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ)); return res; }
12211         ~C2Tuple_ThirtyTwoBytesChannelManagerZ() { C2Tuple_ThirtyTwoBytesChannelManagerZ_free(self); }
12212         C2Tuple_ThirtyTwoBytesChannelManagerZ& operator=(C2Tuple_ThirtyTwoBytesChannelManagerZ&& o) { C2Tuple_ThirtyTwoBytesChannelManagerZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelManagerZ)); return *this; }
12213         LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator &() { return &self; }
12214         LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator ->() { return &self; }
12215         const LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator &() const { return &self; }
12216         const LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator ->() const { return &self; }
12217 };
12218 class CResult_COption_OnionMessageContentsZDecodeErrorZ {
12219 private:
12220         LDKCResult_COption_OnionMessageContentsZDecodeErrorZ self;
12221 public:
12222         CResult_COption_OnionMessageContentsZDecodeErrorZ(const CResult_COption_OnionMessageContentsZDecodeErrorZ&) = delete;
12223         CResult_COption_OnionMessageContentsZDecodeErrorZ(CResult_COption_OnionMessageContentsZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_OnionMessageContentsZDecodeErrorZ)); }
12224         CResult_COption_OnionMessageContentsZDecodeErrorZ(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ)); }
12225         operator LDKCResult_COption_OnionMessageContentsZDecodeErrorZ() && { LDKCResult_COption_OnionMessageContentsZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ)); return res; }
12226         ~CResult_COption_OnionMessageContentsZDecodeErrorZ() { CResult_COption_OnionMessageContentsZDecodeErrorZ_free(self); }
12227         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; }
12228         LDKCResult_COption_OnionMessageContentsZDecodeErrorZ* operator &() { return &self; }
12229         LDKCResult_COption_OnionMessageContentsZDecodeErrorZ* operator ->() { return &self; }
12230         const LDKCResult_COption_OnionMessageContentsZDecodeErrorZ* operator &() const { return &self; }
12231         const LDKCResult_COption_OnionMessageContentsZDecodeErrorZ* operator ->() const { return &self; }
12232 };
12233 class C2Tuple_u64CVec_u8ZZ {
12234 private:
12235         LDKC2Tuple_u64CVec_u8ZZ self;
12236 public:
12237         C2Tuple_u64CVec_u8ZZ(const C2Tuple_u64CVec_u8ZZ&) = delete;
12238         C2Tuple_u64CVec_u8ZZ(C2Tuple_u64CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64CVec_u8ZZ)); }
12239         C2Tuple_u64CVec_u8ZZ(LDKC2Tuple_u64CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64CVec_u8ZZ)); }
12240         operator LDKC2Tuple_u64CVec_u8ZZ() && { LDKC2Tuple_u64CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64CVec_u8ZZ)); return res; }
12241         ~C2Tuple_u64CVec_u8ZZ() { C2Tuple_u64CVec_u8ZZ_free(self); }
12242         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; }
12243         LDKC2Tuple_u64CVec_u8ZZ* operator &() { return &self; }
12244         LDKC2Tuple_u64CVec_u8ZZ* operator ->() { return &self; }
12245         const LDKC2Tuple_u64CVec_u8ZZ* operator &() const { return &self; }
12246         const LDKC2Tuple_u64CVec_u8ZZ* operator ->() const { return &self; }
12247 };
12248 class CResult_OfferBolt12ParseErrorZ {
12249 private:
12250         LDKCResult_OfferBolt12ParseErrorZ self;
12251 public:
12252         CResult_OfferBolt12ParseErrorZ(const CResult_OfferBolt12ParseErrorZ&) = delete;
12253         CResult_OfferBolt12ParseErrorZ(CResult_OfferBolt12ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OfferBolt12ParseErrorZ)); }
12254         CResult_OfferBolt12ParseErrorZ(LDKCResult_OfferBolt12ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OfferBolt12ParseErrorZ)); }
12255         operator LDKCResult_OfferBolt12ParseErrorZ() && { LDKCResult_OfferBolt12ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OfferBolt12ParseErrorZ)); return res; }
12256         ~CResult_OfferBolt12ParseErrorZ() { CResult_OfferBolt12ParseErrorZ_free(self); }
12257         CResult_OfferBolt12ParseErrorZ& operator=(CResult_OfferBolt12ParseErrorZ&& o) { CResult_OfferBolt12ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OfferBolt12ParseErrorZ)); return *this; }
12258         LDKCResult_OfferBolt12ParseErrorZ* operator &() { return &self; }
12259         LDKCResult_OfferBolt12ParseErrorZ* operator ->() { return &self; }
12260         const LDKCResult_OfferBolt12ParseErrorZ* operator &() const { return &self; }
12261         const LDKCResult_OfferBolt12ParseErrorZ* operator ->() const { return &self; }
12262 };
12263 class CResult_ThirtyTwoBytesRetryableSendFailureZ {
12264 private:
12265         LDKCResult_ThirtyTwoBytesRetryableSendFailureZ self;
12266 public:
12267         CResult_ThirtyTwoBytesRetryableSendFailureZ(const CResult_ThirtyTwoBytesRetryableSendFailureZ&) = delete;
12268         CResult_ThirtyTwoBytesRetryableSendFailureZ(CResult_ThirtyTwoBytesRetryableSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesRetryableSendFailureZ)); }
12269         CResult_ThirtyTwoBytesRetryableSendFailureZ(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ)); }
12270         operator LDKCResult_ThirtyTwoBytesRetryableSendFailureZ() && { LDKCResult_ThirtyTwoBytesRetryableSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ)); return res; }
12271         ~CResult_ThirtyTwoBytesRetryableSendFailureZ() { CResult_ThirtyTwoBytesRetryableSendFailureZ_free(self); }
12272         CResult_ThirtyTwoBytesRetryableSendFailureZ& operator=(CResult_ThirtyTwoBytesRetryableSendFailureZ&& o) { CResult_ThirtyTwoBytesRetryableSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesRetryableSendFailureZ)); return *this; }
12273         LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator &() { return &self; }
12274         LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator ->() { return &self; }
12275         const LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator &() const { return &self; }
12276         const LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator ->() const { return &self; }
12277 };
12278 class CVec_MonitorEventZ {
12279 private:
12280         LDKCVec_MonitorEventZ self;
12281 public:
12282         CVec_MonitorEventZ(const CVec_MonitorEventZ&) = delete;
12283         CVec_MonitorEventZ(CVec_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorEventZ)); }
12284         CVec_MonitorEventZ(LDKCVec_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorEventZ)); }
12285         operator LDKCVec_MonitorEventZ() && { LDKCVec_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorEventZ)); return res; }
12286         ~CVec_MonitorEventZ() { CVec_MonitorEventZ_free(self); }
12287         CVec_MonitorEventZ& operator=(CVec_MonitorEventZ&& o) { CVec_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MonitorEventZ)); return *this; }
12288         LDKCVec_MonitorEventZ* operator &() { return &self; }
12289         LDKCVec_MonitorEventZ* operator ->() { return &self; }
12290         const LDKCVec_MonitorEventZ* operator &() const { return &self; }
12291         const LDKCVec_MonitorEventZ* operator ->() const { return &self; }
12292 };
12293 class CResult_ShutdownDecodeErrorZ {
12294 private:
12295         LDKCResult_ShutdownDecodeErrorZ self;
12296 public:
12297         CResult_ShutdownDecodeErrorZ(const CResult_ShutdownDecodeErrorZ&) = delete;
12298         CResult_ShutdownDecodeErrorZ(CResult_ShutdownDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownDecodeErrorZ)); }
12299         CResult_ShutdownDecodeErrorZ(LDKCResult_ShutdownDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownDecodeErrorZ)); }
12300         operator LDKCResult_ShutdownDecodeErrorZ() && { LDKCResult_ShutdownDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownDecodeErrorZ)); return res; }
12301         ~CResult_ShutdownDecodeErrorZ() { CResult_ShutdownDecodeErrorZ_free(self); }
12302         CResult_ShutdownDecodeErrorZ& operator=(CResult_ShutdownDecodeErrorZ&& o) { CResult_ShutdownDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownDecodeErrorZ)); return *this; }
12303         LDKCResult_ShutdownDecodeErrorZ* operator &() { return &self; }
12304         LDKCResult_ShutdownDecodeErrorZ* operator ->() { return &self; }
12305         const LDKCResult_ShutdownDecodeErrorZ* operator &() const { return &self; }
12306         const LDKCResult_ShutdownDecodeErrorZ* operator ->() const { return &self; }
12307 };
12308 class CResult_BigSizeDecodeErrorZ {
12309 private:
12310         LDKCResult_BigSizeDecodeErrorZ self;
12311 public:
12312         CResult_BigSizeDecodeErrorZ(const CResult_BigSizeDecodeErrorZ&) = delete;
12313         CResult_BigSizeDecodeErrorZ(CResult_BigSizeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BigSizeDecodeErrorZ)); }
12314         CResult_BigSizeDecodeErrorZ(LDKCResult_BigSizeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BigSizeDecodeErrorZ)); }
12315         operator LDKCResult_BigSizeDecodeErrorZ() && { LDKCResult_BigSizeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BigSizeDecodeErrorZ)); return res; }
12316         ~CResult_BigSizeDecodeErrorZ() { CResult_BigSizeDecodeErrorZ_free(self); }
12317         CResult_BigSizeDecodeErrorZ& operator=(CResult_BigSizeDecodeErrorZ&& o) { CResult_BigSizeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BigSizeDecodeErrorZ)); return *this; }
12318         LDKCResult_BigSizeDecodeErrorZ* operator &() { return &self; }
12319         LDKCResult_BigSizeDecodeErrorZ* operator ->() { return &self; }
12320         const LDKCResult_BigSizeDecodeErrorZ* operator &() const { return &self; }
12321         const LDKCResult_BigSizeDecodeErrorZ* operator ->() const { return &self; }
12322 };
12323 class CResult_TxOutUtxoLookupErrorZ {
12324 private:
12325         LDKCResult_TxOutUtxoLookupErrorZ self;
12326 public:
12327         CResult_TxOutUtxoLookupErrorZ(const CResult_TxOutUtxoLookupErrorZ&) = delete;
12328         CResult_TxOutUtxoLookupErrorZ(CResult_TxOutUtxoLookupErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxOutUtxoLookupErrorZ)); }
12329         CResult_TxOutUtxoLookupErrorZ(LDKCResult_TxOutUtxoLookupErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxOutUtxoLookupErrorZ)); }
12330         operator LDKCResult_TxOutUtxoLookupErrorZ() && { LDKCResult_TxOutUtxoLookupErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxOutUtxoLookupErrorZ)); return res; }
12331         ~CResult_TxOutUtxoLookupErrorZ() { CResult_TxOutUtxoLookupErrorZ_free(self); }
12332         CResult_TxOutUtxoLookupErrorZ& operator=(CResult_TxOutUtxoLookupErrorZ&& o) { CResult_TxOutUtxoLookupErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxOutUtxoLookupErrorZ)); return *this; }
12333         LDKCResult_TxOutUtxoLookupErrorZ* operator &() { return &self; }
12334         LDKCResult_TxOutUtxoLookupErrorZ* operator ->() { return &self; }
12335         const LDKCResult_TxOutUtxoLookupErrorZ* operator &() const { return &self; }
12336         const LDKCResult_TxOutUtxoLookupErrorZ* operator ->() const { return &self; }
12337 };
12338 class CResult_BlindedPathNoneZ {
12339 private:
12340         LDKCResult_BlindedPathNoneZ self;
12341 public:
12342         CResult_BlindedPathNoneZ(const CResult_BlindedPathNoneZ&) = delete;
12343         CResult_BlindedPathNoneZ(CResult_BlindedPathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPathNoneZ)); }
12344         CResult_BlindedPathNoneZ(LDKCResult_BlindedPathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPathNoneZ)); }
12345         operator LDKCResult_BlindedPathNoneZ() && { LDKCResult_BlindedPathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPathNoneZ)); return res; }
12346         ~CResult_BlindedPathNoneZ() { CResult_BlindedPathNoneZ_free(self); }
12347         CResult_BlindedPathNoneZ& operator=(CResult_BlindedPathNoneZ&& o) { CResult_BlindedPathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPathNoneZ)); return *this; }
12348         LDKCResult_BlindedPathNoneZ* operator &() { return &self; }
12349         LDKCResult_BlindedPathNoneZ* operator ->() { return &self; }
12350         const LDKCResult_BlindedPathNoneZ* operator &() const { return &self; }
12351         const LDKCResult_BlindedPathNoneZ* operator ->() const { return &self; }
12352 };
12353 class COption_usizeZ {
12354 private:
12355         LDKCOption_usizeZ self;
12356 public:
12357         COption_usizeZ(const COption_usizeZ&) = delete;
12358         COption_usizeZ(COption_usizeZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_usizeZ)); }
12359         COption_usizeZ(LDKCOption_usizeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_usizeZ)); }
12360         operator LDKCOption_usizeZ() && { LDKCOption_usizeZ res = self; memset(&self, 0, sizeof(LDKCOption_usizeZ)); return res; }
12361         ~COption_usizeZ() { COption_usizeZ_free(self); }
12362         COption_usizeZ& operator=(COption_usizeZ&& o) { COption_usizeZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_usizeZ)); return *this; }
12363         LDKCOption_usizeZ* operator &() { return &self; }
12364         LDKCOption_usizeZ* operator ->() { return &self; }
12365         const LDKCOption_usizeZ* operator &() const { return &self; }
12366         const LDKCOption_usizeZ* operator ->() const { return &self; }
12367 };
12368 class CResult_NoneNoneZ {
12369 private:
12370         LDKCResult_NoneNoneZ self;
12371 public:
12372         CResult_NoneNoneZ(const CResult_NoneNoneZ&) = delete;
12373         CResult_NoneNoneZ(CResult_NoneNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneNoneZ)); }
12374         CResult_NoneNoneZ(LDKCResult_NoneNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneNoneZ)); }
12375         operator LDKCResult_NoneNoneZ() && { LDKCResult_NoneNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneNoneZ)); return res; }
12376         ~CResult_NoneNoneZ() { CResult_NoneNoneZ_free(self); }
12377         CResult_NoneNoneZ& operator=(CResult_NoneNoneZ&& o) { CResult_NoneNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneNoneZ)); return *this; }
12378         LDKCResult_NoneNoneZ* operator &() { return &self; }
12379         LDKCResult_NoneNoneZ* operator ->() { return &self; }
12380         const LDKCResult_NoneNoneZ* operator &() const { return &self; }
12381         const LDKCResult_NoneNoneZ* operator ->() const { return &self; }
12382 };
12383 class CResult_boolPeerHandleErrorZ {
12384 private:
12385         LDKCResult_boolPeerHandleErrorZ self;
12386 public:
12387         CResult_boolPeerHandleErrorZ(const CResult_boolPeerHandleErrorZ&) = delete;
12388         CResult_boolPeerHandleErrorZ(CResult_boolPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); }
12389         CResult_boolPeerHandleErrorZ(LDKCResult_boolPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); }
12390         operator LDKCResult_boolPeerHandleErrorZ() && { LDKCResult_boolPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); return res; }
12391         ~CResult_boolPeerHandleErrorZ() { CResult_boolPeerHandleErrorZ_free(self); }
12392         CResult_boolPeerHandleErrorZ& operator=(CResult_boolPeerHandleErrorZ&& o) { CResult_boolPeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); return *this; }
12393         LDKCResult_boolPeerHandleErrorZ* operator &() { return &self; }
12394         LDKCResult_boolPeerHandleErrorZ* operator ->() { return &self; }
12395         const LDKCResult_boolPeerHandleErrorZ* operator &() const { return &self; }
12396         const LDKCResult_boolPeerHandleErrorZ* operator ->() const { return &self; }
12397 };
12398 class CResult_ChannelUpdateDecodeErrorZ {
12399 private:
12400         LDKCResult_ChannelUpdateDecodeErrorZ self;
12401 public:
12402         CResult_ChannelUpdateDecodeErrorZ(const CResult_ChannelUpdateDecodeErrorZ&) = delete;
12403         CResult_ChannelUpdateDecodeErrorZ(CResult_ChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); }
12404         CResult_ChannelUpdateDecodeErrorZ(LDKCResult_ChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); }
12405         operator LDKCResult_ChannelUpdateDecodeErrorZ() && { LDKCResult_ChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); return res; }
12406         ~CResult_ChannelUpdateDecodeErrorZ() { CResult_ChannelUpdateDecodeErrorZ_free(self); }
12407         CResult_ChannelUpdateDecodeErrorZ& operator=(CResult_ChannelUpdateDecodeErrorZ&& o) { CResult_ChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); return *this; }
12408         LDKCResult_ChannelUpdateDecodeErrorZ* operator &() { return &self; }
12409         LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() { return &self; }
12410         const LDKCResult_ChannelUpdateDecodeErrorZ* operator &() const { return &self; }
12411         const LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
12412 };
12413 class CVec_APIErrorZ {
12414 private:
12415         LDKCVec_APIErrorZ self;
12416 public:
12417         CVec_APIErrorZ(const CVec_APIErrorZ&) = delete;
12418         CVec_APIErrorZ(CVec_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_APIErrorZ)); }
12419         CVec_APIErrorZ(LDKCVec_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_APIErrorZ)); }
12420         operator LDKCVec_APIErrorZ() && { LDKCVec_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCVec_APIErrorZ)); return res; }
12421         ~CVec_APIErrorZ() { CVec_APIErrorZ_free(self); }
12422         CVec_APIErrorZ& operator=(CVec_APIErrorZ&& o) { CVec_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_APIErrorZ)); return *this; }
12423         LDKCVec_APIErrorZ* operator &() { return &self; }
12424         LDKCVec_APIErrorZ* operator ->() { return &self; }
12425         const LDKCVec_APIErrorZ* operator &() const { return &self; }
12426         const LDKCVec_APIErrorZ* operator ->() const { return &self; }
12427 };
12428 class COption_TxOutZ {
12429 private:
12430         LDKCOption_TxOutZ self;
12431 public:
12432         COption_TxOutZ(const COption_TxOutZ&) = delete;
12433         COption_TxOutZ(COption_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_TxOutZ)); }
12434         COption_TxOutZ(LDKCOption_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_TxOutZ)); }
12435         operator LDKCOption_TxOutZ() && { LDKCOption_TxOutZ res = self; memset(&self, 0, sizeof(LDKCOption_TxOutZ)); return res; }
12436         ~COption_TxOutZ() { COption_TxOutZ_free(self); }
12437         COption_TxOutZ& operator=(COption_TxOutZ&& o) { COption_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_TxOutZ)); return *this; }
12438         LDKCOption_TxOutZ* operator &() { return &self; }
12439         LDKCOption_TxOutZ* operator ->() { return &self; }
12440         const LDKCOption_TxOutZ* operator &() const { return &self; }
12441         const LDKCOption_TxOutZ* operator ->() const { return &self; }
12442 };
12443 class COption_ClosureReasonZ {
12444 private:
12445         LDKCOption_ClosureReasonZ self;
12446 public:
12447         COption_ClosureReasonZ(const COption_ClosureReasonZ&) = delete;
12448         COption_ClosureReasonZ(COption_ClosureReasonZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ClosureReasonZ)); }
12449         COption_ClosureReasonZ(LDKCOption_ClosureReasonZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ClosureReasonZ)); }
12450         operator LDKCOption_ClosureReasonZ() && { LDKCOption_ClosureReasonZ res = self; memset(&self, 0, sizeof(LDKCOption_ClosureReasonZ)); return res; }
12451         ~COption_ClosureReasonZ() { COption_ClosureReasonZ_free(self); }
12452         COption_ClosureReasonZ& operator=(COption_ClosureReasonZ&& o) { COption_ClosureReasonZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ClosureReasonZ)); return *this; }
12453         LDKCOption_ClosureReasonZ* operator &() { return &self; }
12454         LDKCOption_ClosureReasonZ* operator ->() { return &self; }
12455         const LDKCOption_ClosureReasonZ* operator &() const { return &self; }
12456         const LDKCOption_ClosureReasonZ* operator ->() const { return &self; }
12457 };
12458 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ {
12459 private:
12460         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ self;
12461 public:
12462         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&) = delete;
12463         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); }
12464         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); }
12465         operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); return res; }
12466         ~CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(self); }
12467         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; }
12468         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator &() { return &self; }
12469         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator ->() { return &self; }
12470         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator &() const { return &self; }
12471         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator ->() const { return &self; }
12472 };
12473 class CResult_TransactionU16LenLimitedDecodeErrorZ {
12474 private:
12475         LDKCResult_TransactionU16LenLimitedDecodeErrorZ self;
12476 public:
12477         CResult_TransactionU16LenLimitedDecodeErrorZ(const CResult_TransactionU16LenLimitedDecodeErrorZ&) = delete;
12478         CResult_TransactionU16LenLimitedDecodeErrorZ(CResult_TransactionU16LenLimitedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedDecodeErrorZ)); }
12479         CResult_TransactionU16LenLimitedDecodeErrorZ(LDKCResult_TransactionU16LenLimitedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionU16LenLimitedDecodeErrorZ)); }
12480         operator LDKCResult_TransactionU16LenLimitedDecodeErrorZ() && { LDKCResult_TransactionU16LenLimitedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionU16LenLimitedDecodeErrorZ)); return res; }
12481         ~CResult_TransactionU16LenLimitedDecodeErrorZ() { CResult_TransactionU16LenLimitedDecodeErrorZ_free(self); }
12482         CResult_TransactionU16LenLimitedDecodeErrorZ& operator=(CResult_TransactionU16LenLimitedDecodeErrorZ&& o) { CResult_TransactionU16LenLimitedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedDecodeErrorZ)); return *this; }
12483         LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator &() { return &self; }
12484         LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator ->() { return &self; }
12485         const LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator &() const { return &self; }
12486         const LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator ->() const { return &self; }
12487 };
12488 class COption_AmountZ {
12489 private:
12490         LDKCOption_AmountZ self;
12491 public:
12492         COption_AmountZ(const COption_AmountZ&) = delete;
12493         COption_AmountZ(COption_AmountZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_AmountZ)); }
12494         COption_AmountZ(LDKCOption_AmountZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_AmountZ)); }
12495         operator LDKCOption_AmountZ() && { LDKCOption_AmountZ res = self; memset(&self, 0, sizeof(LDKCOption_AmountZ)); return res; }
12496         ~COption_AmountZ() { COption_AmountZ_free(self); }
12497         COption_AmountZ& operator=(COption_AmountZ&& o) { COption_AmountZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_AmountZ)); return *this; }
12498         LDKCOption_AmountZ* operator &() { return &self; }
12499         LDKCOption_AmountZ* operator ->() { return &self; }
12500         const LDKCOption_AmountZ* operator &() const { return &self; }
12501         const LDKCOption_AmountZ* operator ->() const { return &self; }
12502 };
12503 class CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ {
12504 private:
12505         LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ self;
12506 public:
12507         CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(const CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&) = delete;
12508         CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); }
12509         CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); }
12510         operator LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ() && { LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); return res; }
12511         ~CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ() { CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(self); }
12512         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; }
12513         LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator &() { return &self; }
12514         LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator ->() { return &self; }
12515         const LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator &() const { return &self; }
12516         const LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator ->() const { return &self; }
12517 };
12518 class CResult_CounterpartyForwardingInfoDecodeErrorZ {
12519 private:
12520         LDKCResult_CounterpartyForwardingInfoDecodeErrorZ self;
12521 public:
12522         CResult_CounterpartyForwardingInfoDecodeErrorZ(const CResult_CounterpartyForwardingInfoDecodeErrorZ&) = delete;
12523         CResult_CounterpartyForwardingInfoDecodeErrorZ(CResult_CounterpartyForwardingInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyForwardingInfoDecodeErrorZ)); }
12524         CResult_CounterpartyForwardingInfoDecodeErrorZ(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ)); }
12525         operator LDKCResult_CounterpartyForwardingInfoDecodeErrorZ() && { LDKCResult_CounterpartyForwardingInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ)); return res; }
12526         ~CResult_CounterpartyForwardingInfoDecodeErrorZ() { CResult_CounterpartyForwardingInfoDecodeErrorZ_free(self); }
12527         CResult_CounterpartyForwardingInfoDecodeErrorZ& operator=(CResult_CounterpartyForwardingInfoDecodeErrorZ&& o) { CResult_CounterpartyForwardingInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyForwardingInfoDecodeErrorZ)); return *this; }
12528         LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator &() { return &self; }
12529         LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator ->() { return &self; }
12530         const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator &() const { return &self; }
12531         const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator ->() const { return &self; }
12532 };
12533 class CResult_BestBlockDecodeErrorZ {
12534 private:
12535         LDKCResult_BestBlockDecodeErrorZ self;
12536 public:
12537         CResult_BestBlockDecodeErrorZ(const CResult_BestBlockDecodeErrorZ&) = delete;
12538         CResult_BestBlockDecodeErrorZ(CResult_BestBlockDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BestBlockDecodeErrorZ)); }
12539         CResult_BestBlockDecodeErrorZ(LDKCResult_BestBlockDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BestBlockDecodeErrorZ)); }
12540         operator LDKCResult_BestBlockDecodeErrorZ() && { LDKCResult_BestBlockDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BestBlockDecodeErrorZ)); return res; }
12541         ~CResult_BestBlockDecodeErrorZ() { CResult_BestBlockDecodeErrorZ_free(self); }
12542         CResult_BestBlockDecodeErrorZ& operator=(CResult_BestBlockDecodeErrorZ&& o) { CResult_BestBlockDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BestBlockDecodeErrorZ)); return *this; }
12543         LDKCResult_BestBlockDecodeErrorZ* operator &() { return &self; }
12544         LDKCResult_BestBlockDecodeErrorZ* operator ->() { return &self; }
12545         const LDKCResult_BestBlockDecodeErrorZ* operator &() const { return &self; }
12546         const LDKCResult_BestBlockDecodeErrorZ* operator ->() const { return &self; }
12547 };
12548 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ {
12549 private:
12550         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ self;
12551 public:
12552         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(const CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&) = delete;
12553         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); }
12554         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); }
12555         operator LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); return res; }
12556         ~CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ() { CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(self); }
12557         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; }
12558         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator &() { return &self; }
12559         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator ->() { return &self; }
12560         const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator &() const { return &self; }
12561         const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator ->() const { return &self; }
12562 };
12563 class CResult_OpenChannelV2DecodeErrorZ {
12564 private:
12565         LDKCResult_OpenChannelV2DecodeErrorZ self;
12566 public:
12567         CResult_OpenChannelV2DecodeErrorZ(const CResult_OpenChannelV2DecodeErrorZ&) = delete;
12568         CResult_OpenChannelV2DecodeErrorZ(CResult_OpenChannelV2DecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OpenChannelV2DecodeErrorZ)); }
12569         CResult_OpenChannelV2DecodeErrorZ(LDKCResult_OpenChannelV2DecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OpenChannelV2DecodeErrorZ)); }
12570         operator LDKCResult_OpenChannelV2DecodeErrorZ() && { LDKCResult_OpenChannelV2DecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OpenChannelV2DecodeErrorZ)); return res; }
12571         ~CResult_OpenChannelV2DecodeErrorZ() { CResult_OpenChannelV2DecodeErrorZ_free(self); }
12572         CResult_OpenChannelV2DecodeErrorZ& operator=(CResult_OpenChannelV2DecodeErrorZ&& o) { CResult_OpenChannelV2DecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OpenChannelV2DecodeErrorZ)); return *this; }
12573         LDKCResult_OpenChannelV2DecodeErrorZ* operator &() { return &self; }
12574         LDKCResult_OpenChannelV2DecodeErrorZ* operator ->() { return &self; }
12575         const LDKCResult_OpenChannelV2DecodeErrorZ* operator &() const { return &self; }
12576         const LDKCResult_OpenChannelV2DecodeErrorZ* operator ->() const { return &self; }
12577 };
12578 class CResult_OutputSpendStatusDecodeErrorZ {
12579 private:
12580         LDKCResult_OutputSpendStatusDecodeErrorZ self;
12581 public:
12582         CResult_OutputSpendStatusDecodeErrorZ(const CResult_OutputSpendStatusDecodeErrorZ&) = delete;
12583         CResult_OutputSpendStatusDecodeErrorZ(CResult_OutputSpendStatusDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OutputSpendStatusDecodeErrorZ)); }
12584         CResult_OutputSpendStatusDecodeErrorZ(LDKCResult_OutputSpendStatusDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OutputSpendStatusDecodeErrorZ)); }
12585         operator LDKCResult_OutputSpendStatusDecodeErrorZ() && { LDKCResult_OutputSpendStatusDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OutputSpendStatusDecodeErrorZ)); return res; }
12586         ~CResult_OutputSpendStatusDecodeErrorZ() { CResult_OutputSpendStatusDecodeErrorZ_free(self); }
12587         CResult_OutputSpendStatusDecodeErrorZ& operator=(CResult_OutputSpendStatusDecodeErrorZ&& o) { CResult_OutputSpendStatusDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OutputSpendStatusDecodeErrorZ)); return *this; }
12588         LDKCResult_OutputSpendStatusDecodeErrorZ* operator &() { return &self; }
12589         LDKCResult_OutputSpendStatusDecodeErrorZ* operator ->() { return &self; }
12590         const LDKCResult_OutputSpendStatusDecodeErrorZ* operator &() const { return &self; }
12591         const LDKCResult_OutputSpendStatusDecodeErrorZ* operator ->() const { return &self; }
12592 };
12593 class C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ {
12594 private:
12595         LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ self;
12596 public:
12597         C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ(const C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ&) = delete;
12598         C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ(C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ)); }
12599         C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ(LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ)); }
12600         operator LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ() && { LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ res = self; memset(&self, 0, sizeof(LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ)); return res; }
12601         ~C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ() { C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_free(self); }
12602         C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ& operator=(C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ&& o) { C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ)); return *this; }
12603         LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ* operator &() { return &self; }
12604         LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ* operator ->() { return &self; }
12605         const LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ* operator &() const { return &self; }
12606         const LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ* operator ->() const { return &self; }
12607 };
12608 class CResult_RouteDecodeErrorZ {
12609 private:
12610         LDKCResult_RouteDecodeErrorZ self;
12611 public:
12612         CResult_RouteDecodeErrorZ(const CResult_RouteDecodeErrorZ&) = delete;
12613         CResult_RouteDecodeErrorZ(CResult_RouteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); }
12614         CResult_RouteDecodeErrorZ(LDKCResult_RouteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); }
12615         operator LDKCResult_RouteDecodeErrorZ() && { LDKCResult_RouteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); return res; }
12616         ~CResult_RouteDecodeErrorZ() { CResult_RouteDecodeErrorZ_free(self); }
12617         CResult_RouteDecodeErrorZ& operator=(CResult_RouteDecodeErrorZ&& o) { CResult_RouteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); return *this; }
12618         LDKCResult_RouteDecodeErrorZ* operator &() { return &self; }
12619         LDKCResult_RouteDecodeErrorZ* operator ->() { return &self; }
12620         const LDKCResult_RouteDecodeErrorZ* operator &() const { return &self; }
12621         const LDKCResult_RouteDecodeErrorZ* operator ->() const { return &self; }
12622 };
12623 class CResult_BlindedFailureDecodeErrorZ {
12624 private:
12625         LDKCResult_BlindedFailureDecodeErrorZ self;
12626 public:
12627         CResult_BlindedFailureDecodeErrorZ(const CResult_BlindedFailureDecodeErrorZ&) = delete;
12628         CResult_BlindedFailureDecodeErrorZ(CResult_BlindedFailureDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedFailureDecodeErrorZ)); }
12629         CResult_BlindedFailureDecodeErrorZ(LDKCResult_BlindedFailureDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedFailureDecodeErrorZ)); }
12630         operator LDKCResult_BlindedFailureDecodeErrorZ() && { LDKCResult_BlindedFailureDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedFailureDecodeErrorZ)); return res; }
12631         ~CResult_BlindedFailureDecodeErrorZ() { CResult_BlindedFailureDecodeErrorZ_free(self); }
12632         CResult_BlindedFailureDecodeErrorZ& operator=(CResult_BlindedFailureDecodeErrorZ&& o) { CResult_BlindedFailureDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedFailureDecodeErrorZ)); return *this; }
12633         LDKCResult_BlindedFailureDecodeErrorZ* operator &() { return &self; }
12634         LDKCResult_BlindedFailureDecodeErrorZ* operator ->() { return &self; }
12635         const LDKCResult_BlindedFailureDecodeErrorZ* operator &() const { return &self; }
12636         const LDKCResult_BlindedFailureDecodeErrorZ* operator ->() const { return &self; }
12637 };
12638 class CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ {
12639 private:
12640         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ self;
12641 public:
12642         CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(const CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&) = delete;
12643         CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); }
12644         CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); }
12645         operator LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ() && { LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); return res; }
12646         ~CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ() { CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(self); }
12647         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; }
12648         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator &() { return &self; }
12649         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator ->() { return &self; }
12650         const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator &() const { return &self; }
12651         const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator ->() const { return &self; }
12652 };
12653 class COption_NoneZ {
12654 private:
12655         LDKCOption_NoneZ self;
12656 public:
12657         COption_NoneZ(const COption_NoneZ&) = delete;
12658         COption_NoneZ(COption_NoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NoneZ)); }
12659         COption_NoneZ(LDKCOption_NoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NoneZ)); }
12660         operator LDKCOption_NoneZ() && { LDKCOption_NoneZ res = self; memset(&self, 0, sizeof(LDKCOption_NoneZ)); return res; }
12661         ~COption_NoneZ() { COption_NoneZ_free(self); }
12662         COption_NoneZ& operator=(COption_NoneZ&& o) { COption_NoneZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NoneZ)); return *this; }
12663         LDKCOption_NoneZ* operator &() { return &self; }
12664         LDKCOption_NoneZ* operator ->() { return &self; }
12665         const LDKCOption_NoneZ* operator &() const { return &self; }
12666         const LDKCOption_NoneZ* operator ->() const { return &self; }
12667 };
12668 class CResult_SpliceLockedDecodeErrorZ {
12669 private:
12670         LDKCResult_SpliceLockedDecodeErrorZ self;
12671 public:
12672         CResult_SpliceLockedDecodeErrorZ(const CResult_SpliceLockedDecodeErrorZ&) = delete;
12673         CResult_SpliceLockedDecodeErrorZ(CResult_SpliceLockedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpliceLockedDecodeErrorZ)); }
12674         CResult_SpliceLockedDecodeErrorZ(LDKCResult_SpliceLockedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpliceLockedDecodeErrorZ)); }
12675         operator LDKCResult_SpliceLockedDecodeErrorZ() && { LDKCResult_SpliceLockedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpliceLockedDecodeErrorZ)); return res; }
12676         ~CResult_SpliceLockedDecodeErrorZ() { CResult_SpliceLockedDecodeErrorZ_free(self); }
12677         CResult_SpliceLockedDecodeErrorZ& operator=(CResult_SpliceLockedDecodeErrorZ&& o) { CResult_SpliceLockedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpliceLockedDecodeErrorZ)); return *this; }
12678         LDKCResult_SpliceLockedDecodeErrorZ* operator &() { return &self; }
12679         LDKCResult_SpliceLockedDecodeErrorZ* operator ->() { return &self; }
12680         const LDKCResult_SpliceLockedDecodeErrorZ* operator &() const { return &self; }
12681         const LDKCResult_SpliceLockedDecodeErrorZ* operator ->() const { return &self; }
12682 };
12683 class COption_CVec_u8ZZ {
12684 private:
12685         LDKCOption_CVec_u8ZZ self;
12686 public:
12687         COption_CVec_u8ZZ(const COption_CVec_u8ZZ&) = delete;
12688         COption_CVec_u8ZZ(COption_CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_u8ZZ)); }
12689         COption_CVec_u8ZZ(LDKCOption_CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_u8ZZ)); }
12690         operator LDKCOption_CVec_u8ZZ() && { LDKCOption_CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_u8ZZ)); return res; }
12691         ~COption_CVec_u8ZZ() { COption_CVec_u8ZZ_free(self); }
12692         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; }
12693         LDKCOption_CVec_u8ZZ* operator &() { return &self; }
12694         LDKCOption_CVec_u8ZZ* operator ->() { return &self; }
12695         const LDKCOption_CVec_u8ZZ* operator &() const { return &self; }
12696         const LDKCOption_CVec_u8ZZ* operator ->() const { return &self; }
12697 };
12698 class COption_QuantityZ {
12699 private:
12700         LDKCOption_QuantityZ self;
12701 public:
12702         COption_QuantityZ(const COption_QuantityZ&) = delete;
12703         COption_QuantityZ(COption_QuantityZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_QuantityZ)); }
12704         COption_QuantityZ(LDKCOption_QuantityZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_QuantityZ)); }
12705         operator LDKCOption_QuantityZ() && { LDKCOption_QuantityZ res = self; memset(&self, 0, sizeof(LDKCOption_QuantityZ)); return res; }
12706         ~COption_QuantityZ() { COption_QuantityZ_free(self); }
12707         COption_QuantityZ& operator=(COption_QuantityZ&& o) { COption_QuantityZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_QuantityZ)); return *this; }
12708         LDKCOption_QuantityZ* operator &() { return &self; }
12709         LDKCOption_QuantityZ* operator ->() { return &self; }
12710         const LDKCOption_QuantityZ* operator &() const { return &self; }
12711         const LDKCOption_QuantityZ* operator ->() const { return &self; }
12712 };
12713 class CResult_TxAddOutputDecodeErrorZ {
12714 private:
12715         LDKCResult_TxAddOutputDecodeErrorZ self;
12716 public:
12717         CResult_TxAddOutputDecodeErrorZ(const CResult_TxAddOutputDecodeErrorZ&) = delete;
12718         CResult_TxAddOutputDecodeErrorZ(CResult_TxAddOutputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAddOutputDecodeErrorZ)); }
12719         CResult_TxAddOutputDecodeErrorZ(LDKCResult_TxAddOutputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAddOutputDecodeErrorZ)); }
12720         operator LDKCResult_TxAddOutputDecodeErrorZ() && { LDKCResult_TxAddOutputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAddOutputDecodeErrorZ)); return res; }
12721         ~CResult_TxAddOutputDecodeErrorZ() { CResult_TxAddOutputDecodeErrorZ_free(self); }
12722         CResult_TxAddOutputDecodeErrorZ& operator=(CResult_TxAddOutputDecodeErrorZ&& o) { CResult_TxAddOutputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAddOutputDecodeErrorZ)); return *this; }
12723         LDKCResult_TxAddOutputDecodeErrorZ* operator &() { return &self; }
12724         LDKCResult_TxAddOutputDecodeErrorZ* operator ->() { return &self; }
12725         const LDKCResult_TxAddOutputDecodeErrorZ* operator &() const { return &self; }
12726         const LDKCResult_TxAddOutputDecodeErrorZ* operator ->() const { return &self; }
12727 };
12728 class CResult_HtlcBasepointDecodeErrorZ {
12729 private:
12730         LDKCResult_HtlcBasepointDecodeErrorZ self;
12731 public:
12732         CResult_HtlcBasepointDecodeErrorZ(const CResult_HtlcBasepointDecodeErrorZ&) = delete;
12733         CResult_HtlcBasepointDecodeErrorZ(CResult_HtlcBasepointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HtlcBasepointDecodeErrorZ)); }
12734         CResult_HtlcBasepointDecodeErrorZ(LDKCResult_HtlcBasepointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HtlcBasepointDecodeErrorZ)); }
12735         operator LDKCResult_HtlcBasepointDecodeErrorZ() && { LDKCResult_HtlcBasepointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HtlcBasepointDecodeErrorZ)); return res; }
12736         ~CResult_HtlcBasepointDecodeErrorZ() { CResult_HtlcBasepointDecodeErrorZ_free(self); }
12737         CResult_HtlcBasepointDecodeErrorZ& operator=(CResult_HtlcBasepointDecodeErrorZ&& o) { CResult_HtlcBasepointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HtlcBasepointDecodeErrorZ)); return *this; }
12738         LDKCResult_HtlcBasepointDecodeErrorZ* operator &() { return &self; }
12739         LDKCResult_HtlcBasepointDecodeErrorZ* operator ->() { return &self; }
12740         const LDKCResult_HtlcBasepointDecodeErrorZ* operator &() const { return &self; }
12741         const LDKCResult_HtlcBasepointDecodeErrorZ* operator ->() const { return &self; }
12742 };
12743 class C2Tuple_OutPointChannelIdZ {
12744 private:
12745         LDKC2Tuple_OutPointChannelIdZ self;
12746 public:
12747         C2Tuple_OutPointChannelIdZ(const C2Tuple_OutPointChannelIdZ&) = delete;
12748         C2Tuple_OutPointChannelIdZ(C2Tuple_OutPointChannelIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointChannelIdZ)); }
12749         C2Tuple_OutPointChannelIdZ(LDKC2Tuple_OutPointChannelIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointChannelIdZ)); }
12750         operator LDKC2Tuple_OutPointChannelIdZ() && { LDKC2Tuple_OutPointChannelIdZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointChannelIdZ)); return res; }
12751         ~C2Tuple_OutPointChannelIdZ() { C2Tuple_OutPointChannelIdZ_free(self); }
12752         C2Tuple_OutPointChannelIdZ& operator=(C2Tuple_OutPointChannelIdZ&& o) { C2Tuple_OutPointChannelIdZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OutPointChannelIdZ)); return *this; }
12753         LDKC2Tuple_OutPointChannelIdZ* operator &() { return &self; }
12754         LDKC2Tuple_OutPointChannelIdZ* operator ->() { return &self; }
12755         const LDKC2Tuple_OutPointChannelIdZ* operator &() const { return &self; }
12756         const LDKC2Tuple_OutPointChannelIdZ* operator ->() const { return &self; }
12757 };
12758
12759 inline LDK::CResult_SchnorrSignatureNoneZ SignBolt12InvoiceFn::sign_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR message) {
12760         LDK::CResult_SchnorrSignatureNoneZ ret = (self.sign_invoice)(self.this_arg, message);
12761         return ret;
12762 }
12763 inline LDKPublicKey ChannelSigner::get_per_commitment_point(uint64_t idx) {
12764         LDKPublicKey ret = (self.get_per_commitment_point)(self.this_arg, idx);
12765         return ret;
12766 }
12767 inline LDKThirtyTwoBytes ChannelSigner::release_commitment_secret(uint64_t idx) {
12768         LDKThirtyTwoBytes ret = (self.release_commitment_secret)(self.this_arg, idx);
12769         return ret;
12770 }
12771 inline LDK::CResult_NoneNoneZ ChannelSigner::validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages) {
12772         LDK::CResult_NoneNoneZ ret = (self.validate_holder_commitment)(self.this_arg, holder_tx, outbound_htlc_preimages);
12773         return ret;
12774 }
12775 inline LDK::CResult_NoneNoneZ ChannelSigner::validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]) {
12776         LDK::CResult_NoneNoneZ ret = (self.validate_counterparty_revocation)(self.this_arg, idx, secret);
12777         return ret;
12778 }
12779 inline LDKThirtyTwoBytes ChannelSigner::channel_keys_id() {
12780         LDKThirtyTwoBytes ret = (self.channel_keys_id)(self.this_arg);
12781         return ret;
12782 }
12783 inline void ChannelSigner::provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters) {
12784         (self.provide_channel_parameters)(self.this_arg, channel_parameters);
12785 }
12786 inline LDKThirtyTwoBytes EntropySource::get_secure_random_bytes() {
12787         LDKThirtyTwoBytes ret = (self.get_secure_random_bytes)(self.this_arg);
12788         return ret;
12789 }
12790 inline LDKThirtyTwoBytes NodeSigner::get_inbound_payment_key_material() {
12791         LDKThirtyTwoBytes ret = (self.get_inbound_payment_key_material)(self.this_arg);
12792         return ret;
12793 }
12794 inline LDK::CResult_PublicKeyNoneZ NodeSigner::get_node_id(enum LDKRecipient recipient) {
12795         LDK::CResult_PublicKeyNoneZ ret = (self.get_node_id)(self.this_arg, recipient);
12796         return ret;
12797 }
12798 inline LDK::CResult_ThirtyTwoBytesNoneZ NodeSigner::ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak) {
12799         LDK::CResult_ThirtyTwoBytesNoneZ ret = (self.ecdh)(self.this_arg, recipient, other_key, tweak);
12800         return ret;
12801 }
12802 inline LDK::CResult_RecoverableSignatureNoneZ NodeSigner::sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient) {
12803         LDK::CResult_RecoverableSignatureNoneZ ret = (self.sign_invoice)(self.this_arg, hrp_bytes, invoice_data, recipient);
12804         return ret;
12805 }
12806 inline LDK::CResult_SchnorrSignatureNoneZ NodeSigner::sign_bolt12_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR invoice_request) {
12807         LDK::CResult_SchnorrSignatureNoneZ ret = (self.sign_bolt12_invoice_request)(self.this_arg, invoice_request);
12808         return ret;
12809 }
12810 inline LDK::CResult_SchnorrSignatureNoneZ NodeSigner::sign_bolt12_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR invoice) {
12811         LDK::CResult_SchnorrSignatureNoneZ ret = (self.sign_bolt12_invoice)(self.this_arg, invoice);
12812         return ret;
12813 }
12814 inline LDK::CResult_ECDSASignatureNoneZ NodeSigner::sign_gossip_message(struct LDKUnsignedGossipMessage msg) {
12815         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_gossip_message)(self.this_arg, msg);
12816         return ret;
12817 }
12818 inline LDK::CResult_TransactionNoneZ OutputSpender::spend_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ descriptors, struct LDKCVec_TxOutZ outputs, struct LDKCVec_u8Z change_destination_script, uint32_t feerate_sat_per_1000_weight, struct LDKCOption_u32Z locktime) {
12819         LDK::CResult_TransactionNoneZ ret = (self.spend_spendable_outputs)(self.this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight, locktime);
12820         return ret;
12821 }
12822 inline LDKThirtyTwoBytes SignerProvider::generate_channel_keys_id(bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id) {
12823         LDKThirtyTwoBytes ret = (self.generate_channel_keys_id)(self.this_arg, inbound, channel_value_satoshis, user_channel_id);
12824         return ret;
12825 }
12826 inline LDK::WriteableEcdsaChannelSigner SignerProvider::derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id) {
12827         LDK::WriteableEcdsaChannelSigner ret = (self.derive_channel_signer)(self.this_arg, channel_value_satoshis, channel_keys_id);
12828         return ret;
12829 }
12830 inline LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ SignerProvider::read_chan_signer(struct LDKu8slice reader) {
12831         LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ ret = (self.read_chan_signer)(self.this_arg, reader);
12832         return ret;
12833 }
12834 inline LDK::CResult_CVec_u8ZNoneZ SignerProvider::get_destination_script(struct LDKThirtyTwoBytes channel_keys_id) {
12835         LDK::CResult_CVec_u8ZNoneZ ret = (self.get_destination_script)(self.this_arg, channel_keys_id);
12836         return ret;
12837 }
12838 inline LDK::CResult_ShutdownScriptNoneZ SignerProvider::get_shutdown_scriptpubkey() {
12839         LDK::CResult_ShutdownScriptNoneZ ret = (self.get_shutdown_scriptpubkey)(self.this_arg);
12840         return ret;
12841 }
12842 inline LDK::CResult_CVec_u8ZNoneZ ChangeDestinationSource::get_change_destination_script() {
12843         LDK::CResult_CVec_u8ZNoneZ ret = (self.get_change_destination_script)(self.this_arg);
12844         return ret;
12845 }
12846 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) {
12847         LDK::CResult_RouteLightningErrorZ ret = (self.find_route)(self.this_arg, payer, route_params, first_hops, inflight_htlcs);
12848         return ret;
12849 }
12850 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) {
12851         LDK::CResult_RouteLightningErrorZ ret = (self.find_route_with_id)(self.this_arg, payer, route_params, first_hops, inflight_htlcs, _payment_hash, _payment_id);
12852         return ret;
12853 }
12854 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) {
12855         LDK::CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ ret = (self.create_blinded_payment_paths)(self.this_arg, recipient, first_hops, tlvs, amount_msats);
12856         return ret;
12857 }
12858 inline uint64_t ScoreLookUp::channel_penalty_msat(const struct LDKCandidateRouteHop *NONNULL_PTR candidate, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params) {
12859         uint64_t ret = (self.channel_penalty_msat)(self.this_arg, candidate, usage, score_params);
12860         return ret;
12861 }
12862 inline void ScoreUpdate::payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch) {
12863         (self.payment_path_failed)(self.this_arg, path, short_channel_id, duration_since_epoch);
12864 }
12865 inline void ScoreUpdate::payment_path_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch) {
12866         (self.payment_path_successful)(self.this_arg, path, duration_since_epoch);
12867 }
12868 inline void ScoreUpdate::probe_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch) {
12869         (self.probe_failed)(self.this_arg, path, short_channel_id, duration_since_epoch);
12870 }
12871 inline void ScoreUpdate::probe_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch) {
12872         (self.probe_successful)(self.this_arg, path, duration_since_epoch);
12873 }
12874 inline void ScoreUpdate::time_passed(uint64_t duration_since_epoch) {
12875         (self.time_passed)(self.this_arg, duration_since_epoch);
12876 }
12877 inline LDK::ScoreLookUp LockableScore::read_lock() {
12878         LDK::ScoreLookUp ret = (self.read_lock)(self.this_arg);
12879         return ret;
12880 }
12881 inline LDK::ScoreUpdate LockableScore::write_lock() {
12882         LDK::ScoreUpdate ret = (self.write_lock)(self.this_arg);
12883         return ret;
12884 }
12885 inline void Listen::filtered_block_connected(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
12886         (self.filtered_block_connected)(self.this_arg, header, txdata, height);
12887 }
12888 inline void Listen::block_connected(struct LDKu8slice block, uint32_t height) {
12889         (self.block_connected)(self.this_arg, block, height);
12890 }
12891 inline void Listen::block_disconnected(const uint8_t (*header)[80], uint32_t height) {
12892         (self.block_disconnected)(self.this_arg, header, height);
12893 }
12894 inline void Confirm::transactions_confirmed(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
12895         (self.transactions_confirmed)(self.this_arg, header, txdata, height);
12896 }
12897 inline void Confirm::transaction_unconfirmed(const uint8_t (*txid)[32]) {
12898         (self.transaction_unconfirmed)(self.this_arg, txid);
12899 }
12900 inline void Confirm::best_block_updated(const uint8_t (*header)[80], uint32_t height) {
12901         (self.best_block_updated)(self.this_arg, header, height);
12902 }
12903 inline LDK::CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ Confirm::get_relevant_txids() {
12904         LDK::CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ ret = (self.get_relevant_txids)(self.this_arg);
12905         return ret;
12906 }
12907 inline LDK::CResult_ChannelMonitorUpdateStatusNoneZ Watch::watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor) {
12908         LDK::CResult_ChannelMonitorUpdateStatusNoneZ ret = (self.watch_channel)(self.this_arg, funding_txo, monitor);
12909         return ret;
12910 }
12911 inline LDK::ChannelMonitorUpdateStatus Watch::update_channel(struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update) {
12912         LDK::ChannelMonitorUpdateStatus ret = (self.update_channel)(self.this_arg, funding_txo, update);
12913         return ret;
12914 }
12915 inline LDK::CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ Watch::release_pending_monitor_events() {
12916         LDK::CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ ret = (self.release_pending_monitor_events)(self.this_arg);
12917         return ret;
12918 }
12919 inline void Filter::register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey) {
12920         (self.register_tx)(self.this_arg, txid, script_pubkey);
12921 }
12922 inline void Filter::register_output(struct LDKWatchedOutput output) {
12923         (self.register_output)(self.this_arg, output);
12924 }
12925 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) {
12926         LDK::CResult_CoinSelectionNoneZ ret = (self.select_confirmed_utxos)(self.this_arg, claim_id, must_spend, must_pay_to, target_feerate_sat_per_1000_weight);
12927         return ret;
12928 }
12929 inline LDK::CResult_TransactionNoneZ CoinSelectionSource::sign_psbt(struct LDKCVec_u8Z psbt) {
12930         LDK::CResult_TransactionNoneZ ret = (self.sign_psbt)(self.this_arg, psbt);
12931         return ret;
12932 }
12933 inline LDK::CResult_CVec_UtxoZNoneZ WalletSource::list_confirmed_utxos() {
12934         LDK::CResult_CVec_UtxoZNoneZ ret = (self.list_confirmed_utxos)(self.this_arg);
12935         return ret;
12936 }
12937 inline LDK::CResult_CVec_u8ZNoneZ WalletSource::get_change_script() {
12938         LDK::CResult_CVec_u8ZNoneZ ret = (self.get_change_script)(self.this_arg);
12939         return ret;
12940 }
12941 inline LDK::CResult_TransactionNoneZ WalletSource::sign_psbt(struct LDKCVec_u8Z psbt) {
12942         LDK::CResult_TransactionNoneZ ret = (self.sign_psbt)(self.this_arg, psbt);
12943         return ret;
12944 }
12945 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) {
12946         LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ ret = (self.sign_counterparty_commitment)(self.this_arg, commitment_tx, inbound_htlc_preimages, outbound_htlc_preimages);
12947         return ret;
12948 }
12949 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx) {
12950         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_commitment)(self.this_arg, commitment_tx);
12951         return ret;
12952 }
12953 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]) {
12954         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_justice_revoked_output)(self.this_arg, justice_tx, input, amount, per_commitment_key);
12955         return ret;
12956 }
12957 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) {
12958         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_justice_revoked_htlc)(self.this_arg, justice_tx, input, amount, per_commitment_key, htlc);
12959         return ret;
12960 }
12961 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor) {
12962         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_htlc_transaction)(self.this_arg, htlc_tx, input, htlc_descriptor);
12963         return ret;
12964 }
12965 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) {
12966         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_counterparty_htlc_transaction)(self.this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
12967         return ret;
12968 }
12969 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx) {
12970         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_closing_transaction)(self.this_arg, closing_tx);
12971         return ret;
12972 }
12973 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input) {
12974         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_anchor_input)(self.this_arg, anchor_tx, input);
12975         return ret;
12976 }
12977 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg) {
12978         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_channel_announcement_with_funding_key)(self.this_arg, msg);
12979         return ret;
12980 }
12981 inline LDK::CResult_NoneLightningErrorZ CustomMessageHandler::handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id) {
12982         LDK::CResult_NoneLightningErrorZ ret = (self.handle_custom_message)(self.this_arg, msg, sender_node_id);
12983         return ret;
12984 }
12985 inline LDK::CVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler::get_and_clear_pending_msg() {
12986         LDK::CVec_C2Tuple_PublicKeyTypeZZ ret = (self.get_and_clear_pending_msg)(self.this_arg);
12987         return ret;
12988 }
12989 inline LDK::NodeFeatures CustomMessageHandler::provided_node_features() {
12990         LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
12991         return ret;
12992 }
12993 inline LDK::InitFeatures CustomMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
12994         LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
12995         return ret;
12996 }
12997 inline uintptr_t SocketDescriptor::send_data(struct LDKu8slice data, bool resume_read) {
12998         uintptr_t ret = (self.send_data)(self.this_arg, data, resume_read);
12999         return ret;
13000 }
13001 inline void SocketDescriptor::disconnect_socket() {
13002         (self.disconnect_socket)(self.this_arg);
13003 }
13004 inline bool SocketDescriptor::eq(const struct LDKSocketDescriptor *NONNULL_PTR other_arg) {
13005         bool ret = (self.eq)(self.this_arg, other_arg);
13006         return ret;
13007 }
13008 inline uint64_t SocketDescriptor::hash() {
13009         uint64_t ret = (self.hash)(self.this_arg);
13010         return ret;
13011 }
13012 inline LDK::CResult_CVec_u8ZIOErrorZ KVStore::read(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key) {
13013         LDK::CResult_CVec_u8ZIOErrorZ ret = (self.read)(self.this_arg, primary_namespace, secondary_namespace, key);
13014         return ret;
13015 }
13016 inline LDK::CResult_NoneIOErrorZ KVStore::write(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, struct LDKu8slice buf) {
13017         LDK::CResult_NoneIOErrorZ ret = (self.write)(self.this_arg, primary_namespace, secondary_namespace, key, buf);
13018         return ret;
13019 }
13020 inline LDK::CResult_NoneIOErrorZ KVStore::remove(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, bool lazy) {
13021         LDK::CResult_NoneIOErrorZ ret = (self.remove)(self.this_arg, primary_namespace, secondary_namespace, key, lazy);
13022         return ret;
13023 }
13024 inline LDK::CResult_CVec_StrZIOErrorZ KVStore::list(struct LDKStr primary_namespace, struct LDKStr secondary_namespace) {
13025         LDK::CResult_CVec_StrZIOErrorZ ret = (self.list)(self.this_arg, primary_namespace, secondary_namespace);
13026         return ret;
13027 }
13028 inline LDK::CResult_NoneIOErrorZ Persister::persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager) {
13029         LDK::CResult_NoneIOErrorZ ret = (self.persist_manager)(self.this_arg, channel_manager);
13030         return ret;
13031 }
13032 inline LDK::CResult_NoneIOErrorZ Persister::persist_graph(const struct LDKNetworkGraph *NONNULL_PTR network_graph) {
13033         LDK::CResult_NoneIOErrorZ ret = (self.persist_graph)(self.this_arg, network_graph);
13034         return ret;
13035 }
13036 inline LDK::CResult_NoneIOErrorZ Persister::persist_scorer(const struct LDKWriteableScore *NONNULL_PTR scorer) {
13037         LDK::CResult_NoneIOErrorZ ret = (self.persist_scorer)(self.this_arg, scorer);
13038         return ret;
13039 }
13040 inline LDK::CResult_SchnorrSignatureNoneZ SignInvoiceRequestFn::sign_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR message) {
13041         LDK::CResult_SchnorrSignatureNoneZ ret = (self.sign_invoice_request)(self.this_arg, message);
13042         return ret;
13043 }
13044 inline void ChannelMessageHandler::handle_open_channel(struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg) {
13045         (self.handle_open_channel)(self.this_arg, their_node_id, msg);
13046 }
13047 inline void ChannelMessageHandler::handle_open_channel_v2(struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg) {
13048         (self.handle_open_channel_v2)(self.this_arg, their_node_id, msg);
13049 }
13050 inline void ChannelMessageHandler::handle_accept_channel(struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg) {
13051         (self.handle_accept_channel)(self.this_arg, their_node_id, msg);
13052 }
13053 inline void ChannelMessageHandler::handle_accept_channel_v2(struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg) {
13054         (self.handle_accept_channel_v2)(self.this_arg, their_node_id, msg);
13055 }
13056 inline void ChannelMessageHandler::handle_funding_created(struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg) {
13057         (self.handle_funding_created)(self.this_arg, their_node_id, msg);
13058 }
13059 inline void ChannelMessageHandler::handle_funding_signed(struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg) {
13060         (self.handle_funding_signed)(self.this_arg, their_node_id, msg);
13061 }
13062 inline void ChannelMessageHandler::handle_channel_ready(struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg) {
13063         (self.handle_channel_ready)(self.this_arg, their_node_id, msg);
13064 }
13065 inline void ChannelMessageHandler::handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg) {
13066         (self.handle_shutdown)(self.this_arg, their_node_id, msg);
13067 }
13068 inline void ChannelMessageHandler::handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg) {
13069         (self.handle_closing_signed)(self.this_arg, their_node_id, msg);
13070 }
13071 inline void ChannelMessageHandler::handle_stfu(struct LDKPublicKey their_node_id, const struct LDKStfu *NONNULL_PTR msg) {
13072         (self.handle_stfu)(self.this_arg, their_node_id, msg);
13073 }
13074 inline void ChannelMessageHandler::handle_tx_add_input(struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg) {
13075         (self.handle_tx_add_input)(self.this_arg, their_node_id, msg);
13076 }
13077 inline void ChannelMessageHandler::handle_tx_add_output(struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg) {
13078         (self.handle_tx_add_output)(self.this_arg, their_node_id, msg);
13079 }
13080 inline void ChannelMessageHandler::handle_tx_remove_input(struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg) {
13081         (self.handle_tx_remove_input)(self.this_arg, their_node_id, msg);
13082 }
13083 inline void ChannelMessageHandler::handle_tx_remove_output(struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg) {
13084         (self.handle_tx_remove_output)(self.this_arg, their_node_id, msg);
13085 }
13086 inline void ChannelMessageHandler::handle_tx_complete(struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg) {
13087         (self.handle_tx_complete)(self.this_arg, their_node_id, msg);
13088 }
13089 inline void ChannelMessageHandler::handle_tx_signatures(struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg) {
13090         (self.handle_tx_signatures)(self.this_arg, their_node_id, msg);
13091 }
13092 inline void ChannelMessageHandler::handle_tx_init_rbf(struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg) {
13093         (self.handle_tx_init_rbf)(self.this_arg, their_node_id, msg);
13094 }
13095 inline void ChannelMessageHandler::handle_tx_ack_rbf(struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg) {
13096         (self.handle_tx_ack_rbf)(self.this_arg, their_node_id, msg);
13097 }
13098 inline void ChannelMessageHandler::handle_tx_abort(struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg) {
13099         (self.handle_tx_abort)(self.this_arg, their_node_id, msg);
13100 }
13101 inline void ChannelMessageHandler::handle_update_add_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg) {
13102         (self.handle_update_add_htlc)(self.this_arg, their_node_id, msg);
13103 }
13104 inline void ChannelMessageHandler::handle_update_fulfill_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg) {
13105         (self.handle_update_fulfill_htlc)(self.this_arg, their_node_id, msg);
13106 }
13107 inline void ChannelMessageHandler::handle_update_fail_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg) {
13108         (self.handle_update_fail_htlc)(self.this_arg, their_node_id, msg);
13109 }
13110 inline void ChannelMessageHandler::handle_update_fail_malformed_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg) {
13111         (self.handle_update_fail_malformed_htlc)(self.this_arg, their_node_id, msg);
13112 }
13113 inline void ChannelMessageHandler::handle_commitment_signed(struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg) {
13114         (self.handle_commitment_signed)(self.this_arg, their_node_id, msg);
13115 }
13116 inline void ChannelMessageHandler::handle_revoke_and_ack(struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg) {
13117         (self.handle_revoke_and_ack)(self.this_arg, their_node_id, msg);
13118 }
13119 inline void ChannelMessageHandler::handle_update_fee(struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg) {
13120         (self.handle_update_fee)(self.this_arg, their_node_id, msg);
13121 }
13122 inline void ChannelMessageHandler::handle_announcement_signatures(struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg) {
13123         (self.handle_announcement_signatures)(self.this_arg, their_node_id, msg);
13124 }
13125 inline void ChannelMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id) {
13126         (self.peer_disconnected)(self.this_arg, their_node_id);
13127 }
13128 inline LDK::CResult_NoneNoneZ ChannelMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound) {
13129         LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, msg, inbound);
13130         return ret;
13131 }
13132 inline void ChannelMessageHandler::handle_channel_reestablish(struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg) {
13133         (self.handle_channel_reestablish)(self.this_arg, their_node_id, msg);
13134 }
13135 inline void ChannelMessageHandler::handle_channel_update(struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg) {
13136         (self.handle_channel_update)(self.this_arg, their_node_id, msg);
13137 }
13138 inline void ChannelMessageHandler::handle_error(struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg) {
13139         (self.handle_error)(self.this_arg, their_node_id, msg);
13140 }
13141 inline LDK::NodeFeatures ChannelMessageHandler::provided_node_features() {
13142         LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
13143         return ret;
13144 }
13145 inline LDK::InitFeatures ChannelMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
13146         LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
13147         return ret;
13148 }
13149 inline LDK::COption_CVec_ThirtyTwoBytesZZ ChannelMessageHandler::get_chain_hashes() {
13150         LDK::COption_CVec_ThirtyTwoBytesZZ ret = (self.get_chain_hashes)(self.this_arg);
13151         return ret;
13152 }
13153 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg) {
13154         LDK::CResult_boolLightningErrorZ ret = (self.handle_node_announcement)(self.this_arg, msg);
13155         return ret;
13156 }
13157 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg) {
13158         LDK::CResult_boolLightningErrorZ ret = (self.handle_channel_announcement)(self.this_arg, msg);
13159         return ret;
13160 }
13161 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_channel_update(const struct LDKChannelUpdate *NONNULL_PTR msg) {
13162         LDK::CResult_boolLightningErrorZ ret = (self.handle_channel_update)(self.this_arg, msg);
13163         return ret;
13164 }
13165 inline LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler::get_next_channel_announcement(uint64_t starting_point) {
13166         LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = (self.get_next_channel_announcement)(self.this_arg, starting_point);
13167         return ret;
13168 }
13169 inline LDK::NodeAnnouncement RoutingMessageHandler::get_next_node_announcement(struct LDKNodeId starting_point) {
13170         LDK::NodeAnnouncement ret = (self.get_next_node_announcement)(self.this_arg, starting_point);
13171         return ret;
13172 }
13173 inline LDK::CResult_NoneNoneZ RoutingMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound) {
13174         LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, init, inbound);
13175         return ret;
13176 }
13177 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_reply_channel_range(struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg) {
13178         LDK::CResult_NoneLightningErrorZ ret = (self.handle_reply_channel_range)(self.this_arg, their_node_id, msg);
13179         return ret;
13180 }
13181 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_reply_short_channel_ids_end(struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg) {
13182         LDK::CResult_NoneLightningErrorZ ret = (self.handle_reply_short_channel_ids_end)(self.this_arg, their_node_id, msg);
13183         return ret;
13184 }
13185 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_query_channel_range(struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg) {
13186         LDK::CResult_NoneLightningErrorZ ret = (self.handle_query_channel_range)(self.this_arg, their_node_id, msg);
13187         return ret;
13188 }
13189 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg) {
13190         LDK::CResult_NoneLightningErrorZ ret = (self.handle_query_short_channel_ids)(self.this_arg, their_node_id, msg);
13191         return ret;
13192 }
13193 inline bool RoutingMessageHandler::processing_queue_high() {
13194         bool ret = (self.processing_queue_high)(self.this_arg);
13195         return ret;
13196 }
13197 inline LDK::NodeFeatures RoutingMessageHandler::provided_node_features() {
13198         LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
13199         return ret;
13200 }
13201 inline LDK::InitFeatures RoutingMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
13202         LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
13203         return ret;
13204 }
13205 inline LDK::CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ OnionMessageHandler::get_and_clear_connections_needed() {
13206         LDK::CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ ret = (self.get_and_clear_connections_needed)(self.this_arg);
13207         return ret;
13208 }
13209 inline void OnionMessageHandler::handle_onion_message(struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg) {
13210         (self.handle_onion_message)(self.this_arg, peer_node_id, msg);
13211 }
13212 inline LDK::OnionMessage OnionMessageHandler::next_onion_message_for_peer(struct LDKPublicKey peer_node_id) {
13213         LDK::OnionMessage ret = (self.next_onion_message_for_peer)(self.this_arg, peer_node_id);
13214         return ret;
13215 }
13216 inline LDK::CResult_NoneNoneZ OnionMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound) {
13217         LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, init, inbound);
13218         return ret;
13219 }
13220 inline void OnionMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id) {
13221         (self.peer_disconnected)(self.this_arg, their_node_id);
13222 }
13223 inline void OnionMessageHandler::timer_tick_occurred() {
13224         (self.timer_tick_occurred)(self.this_arg);
13225 }
13226 inline LDK::NodeFeatures OnionMessageHandler::provided_node_features() {
13227         LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
13228         return ret;
13229 }
13230 inline LDK::InitFeatures OnionMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
13231         LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
13232         return ret;
13233 }
13234 inline void Logger::log(struct LDKRecord record) {
13235         (self.log)(self.this_arg, record);
13236 }
13237 inline void FutureCallback::call() {
13238         (self.call)(self.this_arg);
13239 }
13240 inline LDK::COption_OffersMessageZ OffersMessageHandler::handle_message(struct LDKOffersMessage message) {
13241         LDK::COption_OffersMessageZ ret = (self.handle_message)(self.this_arg, message);
13242         return ret;
13243 }
13244 inline LDK::CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ OffersMessageHandler::release_pending_messages() {
13245         LDK::CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ ret = (self.release_pending_messages)(self.this_arg);
13246         return ret;
13247 }
13248 inline void BroadcasterInterface::broadcast_transactions(struct LDKCVec_TransactionZ txs) {
13249         (self.broadcast_transactions)(self.this_arg, txs);
13250 }
13251 inline uint32_t FeeEstimator::get_est_sat_per_1000_weight(enum LDKConfirmationTarget confirmation_target) {
13252         uint32_t ret = (self.get_est_sat_per_1000_weight)(self.this_arg, confirmation_target);
13253         return ret;
13254 }
13255 inline uint64_t OnionMessageContents::tlv_type() {
13256         uint64_t ret = (self.tlv_type)(self.this_arg);
13257         return ret;
13258 }
13259 inline LDK::Str OnionMessageContents::debug_str() {
13260         LDK::Str ret = (self.debug_str)(self.this_arg);
13261         return ret;
13262 }
13263 inline LDK::CVec_MessageSendEventZ MessageSendEventsProvider::get_and_clear_pending_msg_events() {
13264         LDK::CVec_MessageSendEventZ ret = (self.get_and_clear_pending_msg_events)(self.this_arg);
13265         return ret;
13266 }
13267 inline void EventsProvider::process_pending_events(struct LDKEventHandler handler) {
13268         (self.process_pending_events)(self.this_arg, handler);
13269 }
13270 inline void EventHandler::handle_event(struct LDKEvent event) {
13271         (self.handle_event)(self.this_arg, event);
13272 }
13273 inline LDK::CResult_COption_TypeZDecodeErrorZ CustomMessageReader::read(uint16_t message_type, struct LDKu8slice buffer) {
13274         LDK::CResult_COption_TypeZDecodeErrorZ ret = (self.read)(self.this_arg, message_type, buffer);
13275         return ret;
13276 }
13277 inline uint16_t Type::type_id() {
13278         uint16_t ret = (self.type_id)(self.this_arg);
13279         return ret;
13280 }
13281 inline LDK::Str Type::debug_str() {
13282         LDK::Str ret = (self.debug_str)(self.this_arg);
13283         return ret;
13284 }
13285 inline LDK::UtxoResult UtxoLookup::get_utxo(const uint8_t (*chain_hash)[32], uint64_t short_channel_id) {
13286         LDK::UtxoResult ret = (self.get_utxo)(self.this_arg, chain_hash, short_channel_id);
13287         return ret;
13288 }
13289 inline LDK::CResult_OnionMessagePathNoneZ MessageRouter::find_path(struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination) {
13290         LDK::CResult_OnionMessagePathNoneZ ret = (self.find_path)(self.this_arg, sender, peers, destination);
13291         return ret;
13292 }
13293 inline LDK::CResult_CVec_BlindedPathZNoneZ MessageRouter::create_blinded_paths(struct LDKPublicKey recipient, struct LDKCVec_PublicKeyZ peers) {
13294         LDK::CResult_CVec_BlindedPathZNoneZ ret = (self.create_blinded_paths)(self.this_arg, recipient, peers);
13295         return ret;
13296 }
13297 inline LDK::COption_OnionMessageContentsZ CustomOnionMessageHandler::handle_custom_message(struct LDKOnionMessageContents msg) {
13298         LDK::COption_OnionMessageContentsZ ret = (self.handle_custom_message)(self.this_arg, msg);
13299         return ret;
13300 }
13301 inline LDK::CResult_COption_OnionMessageContentsZDecodeErrorZ CustomOnionMessageHandler::read_custom_message(uint64_t message_type, struct LDKu8slice buffer) {
13302         LDK::CResult_COption_OnionMessageContentsZDecodeErrorZ ret = (self.read_custom_message)(self.this_arg, message_type, buffer);
13303         return ret;
13304 }
13305 inline LDK::CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ CustomOnionMessageHandler::release_pending_custom_messages() {
13306         LDK::CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ ret = (self.release_pending_custom_messages)(self.this_arg);
13307         return ret;
13308 }
13309 inline LDKPublicKey NodeIdLookUp::next_node_id(uint64_t short_channel_id) {
13310         LDKPublicKey ret = (self.next_node_id)(self.this_arg, short_channel_id);
13311         return ret;
13312 }
13313 inline LDK::ChannelMonitorUpdateStatus Persist::persist_new_channel(struct LDKOutPoint channel_funding_outpoint, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
13314         LDK::ChannelMonitorUpdateStatus ret = (self.persist_new_channel)(self.this_arg, channel_funding_outpoint, data, update_id);
13315         return ret;
13316 }
13317 inline LDK::ChannelMonitorUpdateStatus Persist::update_persisted_channel(struct LDKOutPoint channel_funding_outpoint, struct LDKChannelMonitorUpdate update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
13318         LDK::ChannelMonitorUpdateStatus ret = (self.update_persisted_channel)(self.this_arg, channel_funding_outpoint, update, data, update_id);
13319         return ret;
13320 }
13321 inline void Persist::archive_persisted_channel(struct LDKOutPoint channel_funding_outpoint) {
13322         (self.archive_persisted_channel)(self.this_arg, channel_funding_outpoint);
13323 }
13324 }