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

   1 #include <string.h>
   2 namespace LDK {
   3 // Forward declarations
   4 class Str;
   5 class Refund;
   6 class Retry;
   7 class RetryableSendFailure;
   8 class PaymentSendFailure;
   9 class ProbeSendFailure;
  10 class RecipientOnionFields;
  11 class UnsignedBolt12Invoice;
  12 class Bolt12Invoice;
  13 class BlindedPayInfo;
  14 class DelayedPaymentOutputDescriptor;
  15 class StaticPaymentOutputDescriptor;
  16 class SpendableOutputDescriptor;
  17 class ChannelSigner;
  18 class EcdsaChannelSigner;
  19 class WriteableEcdsaChannelSigner;
  20 class Recipient;
  21 class EntropySource;
  22 class NodeSigner;
  23 class SignerProvider;
  24 class InMemorySigner;
  25 class KeysManager;
  26 class PhantomKeysManager;
  27 class BackgroundProcessor;
  28 class GossipSync;
  29 class DefaultRouter;
  30 class Router;
  31 class ScorerAccountingForInFlightHtlcs;
  32 class InFlightHtlcs;
  33 class RouteHop;
  34 class BlindedTail;
  35 class Path;
  36 class Route;
  37 class RouteParameters;
  38 class PaymentParameters;
  39 class Payee;
  40 class RouteHint;
  41 class RouteHintHop;
  42 class ScoreLookUp;
  43 class ScoreUpdate;
  44 class Score;
  45 class LockableScore;
  46 class WriteableScore;
  47 class MultiThreadedLockableScore;
  48 class MultiThreadedScoreLockRead;
  49 class MultiThreadedScoreLockWrite;
  50 class ChannelUsage;
  51 class FixedPenaltyScorer;
  52 class ProbabilisticScorer;
  53 class ProbabilisticScoringFeeParameters;
  54 class ProbabilisticScoringDecayParameters;
  55 class BestBlock;
  56 class Listen;
  57 class Confirm;
  58 class ChannelMonitorUpdateStatus;
  59 class Watch;
  60 class Filter;
  61 class WatchedOutput;
  62 class InitFeatures;
  63 class NodeFeatures;
  64 class ChannelFeatures;
  65 class Bolt11InvoiceFeatures;
  66 class OfferFeatures;
  67 class InvoiceRequestFeatures;
  68 class Bolt12InvoiceFeatures;
  69 class BlindedHopFeatures;
  70 class ChannelTypeFeatures;
  71 class Offer;
  72 class Amount;
  73 class Quantity;
  74 class NodeId;
  75 class NetworkGraph;
  76 class ReadOnlyNetworkGraph;
  77 class NetworkUpdate;
  78 class P2PGossipSync;
  79 class ChannelUpdateInfo;
  80 class ChannelInfo;
  81 class DirectedChannelInfo;
  82 class EffectiveCapacity;
  83 class RoutingFees;
  84 class NodeAnnouncementInfo;
  85 class NodeAlias;
  86 class NodeInfo;
  87 class ChannelDerivationParameters;
  88 class AnchorDescriptor;
  89 class HTLCDescriptor;
  90 class BumpTransactionEvent;
  91 class Input;
  92 class Utxo;
  93 class CoinSelection;
  94 class CoinSelectionSource;
  95 class WalletSource;
  96 class Wallet;
  97 class BumpTransactionEventHandler;
  98 class FailureCode;
  99 class ChannelManager;
 100 class ChainParameters;
 101 class CounterpartyForwardingInfo;
 102 class ChannelCounterparty;
 103 class ChannelDetails;
 104 class ChannelShutdownState;
 105 class RecentPaymentDetails;
 106 class PhantomRouteHints;
 107 class ChannelManagerReadArgs;
 108 class ChannelHandshakeConfig;
 109 class ChannelHandshakeLimits;
 110 class MaxDustHTLCExposure;
 111 class ChannelConfig;
 112 class ChannelConfigUpdate;
 113 class UserConfig;
 114 class APIError;
 115 class TaggedHash;
 116 class ChannelMonitorUpdate;
 117 class MonitorEvent;
 118 class HTLCUpdate;
 119 class Balance;
 120 class ChannelMonitor;
 121 class ExpandedKey;
 122 class CustomMessageHandler;
 123 class IgnoringMessageHandler;
 124 class ErroringMessageHandler;
 125 class MessageHandler;
 126 class SocketDescriptor;
 127 class PeerHandleError;
 128 class PeerManager;
 129 class RapidGossipSync;
 130 class KVStore;
 131 class Persister;
 132 class MonitorUpdatingPersister;
 133 class UnsignedInvoiceRequest;
 134 class InvoiceRequest;
 135 class VerifiedInvoiceRequest;
 136 class DecodeError;
 137 class Init;
 138 class ErrorMessage;
 139 class WarningMessage;
 140 class Ping;
 141 class Pong;
 142 class OpenChannel;
 143 class OpenChannelV2;
 144 class AcceptChannel;
 145 class AcceptChannelV2;
 146 class FundingCreated;
 147 class FundingSigned;
 148 class ChannelReady;
 149 class TxAddInput;
 150 class TxAddOutput;
 151 class TxRemoveInput;
 152 class TxRemoveOutput;
 153 class TxComplete;
 154 class TxSignatures;
 155 class TxInitRbf;
 156 class TxAckRbf;
 157 class TxAbort;
 158 class Shutdown;
 159 class ClosingSignedFeeRange;
 160 class ClosingSigned;
 161 class UpdateAddHTLC;
 162 class OnionMessage;
 163 class UpdateFulfillHTLC;
 164 class UpdateFailHTLC;
 165 class UpdateFailMalformedHTLC;
 166 class CommitmentSigned;
 167 class RevokeAndACK;
 168 class UpdateFee;
 169 class ChannelReestablish;
 170 class AnnouncementSignatures;
 171 class SocketAddress;
 172 class SocketAddressParseError;
 173 class UnsignedGossipMessage;
 174 class UnsignedNodeAnnouncement;
 175 class NodeAnnouncement;
 176 class UnsignedChannelAnnouncement;
 177 class ChannelAnnouncement;
 178 class UnsignedChannelUpdate;
 179 class ChannelUpdate;
 180 class QueryChannelRange;
 181 class ReplyChannelRange;
 182 class QueryShortChannelIds;
 183 class ReplyShortChannelIdsEnd;
 184 class GossipTimestampFilter;
 185 class ErrorAction;
 186 class LightningError;
 187 class CommitmentUpdate;
 188 class ChannelMessageHandler;
 189 class RoutingMessageHandler;
 190 class OnionMessageHandler;
 191 class Level;
 192 class Record;
 193 class Logger;
 194 class FutureCallback;
 195 class Future;
 196 class Sleeper;
 197 class OffersMessageHandler;
 198 class OffersMessage;
 199 class HTLCClaim;
 200 class CounterpartyCommitmentSecrets;
 201 class TxCreationKeys;
 202 class ChannelPublicKeys;
 203 class HTLCOutputInCommitment;
 204 class ChannelTransactionParameters;
 205 class CounterpartyChannelTransactionParameters;
 206 class DirectedChannelTransactionParameters;
 207 class HolderCommitmentTransaction;
 208 class BuiltCommitmentTransaction;
 209 class ClosingTransaction;
 210 class TrustedClosingTransaction;
 211 class CommitmentTransaction;
 212 class TrustedCommitmentTransaction;
 213 class ShutdownScript;
 214 class InvalidShutdownScript;
 215 class Bolt12ParseError;
 216 class Bolt12SemanticError;
 217 class BroadcasterInterface;
 218 class ConfirmationTarget;
 219 class FeeEstimator;
 220 class Packet;
 221 class OnionMessageContents;
 222 class CustomOnionMessageContents;
 223 class PaymentPurpose;
 224 class ClaimedHTLC;
 225 class PathFailure;
 226 class ClosureReason;
 227 class HTLCDestination;
 228 class PaymentFailureReason;
 229 class Event;
 230 class MessageSendEvent;
 231 class MessageSendEventsProvider;
 232 class OnionMessageProvider;
 233 class EventsProvider;
 234 class EventHandler;
 235 class Bolt11ParseError;
 236 class ParseOrSemanticError;
 237 class Bolt11Invoice;
 238 class SignedRawBolt11Invoice;
 239 class RawBolt11Invoice;
 240 class RawDataPart;
 241 class PositiveTimestamp;
 242 class SiPrefix;
 243 class Currency;
 244 class Sha256;
 245 class Description;
 246 class PayeePubKey;
 247 class ExpiryTime;
 248 class MinFinalCltvExpiryDelta;
 249 class Fallback;
 250 class Bolt11InvoiceSignature;
 251 class PrivateRoute;
 252 class CreationError;
 253 class Bolt11SemanticError;
 254 class SignOrCreationError;
 255 class OutPoint;
 256 class BigSize;
 257 class Hostname;
 258 class TransactionU16LenLimited;
 259 class UntrustedString;
 260 class PrintableString;
 261 class CustomMessageReader;
 262 class Type;
 263 class ForwardNode;
 264 class ForwardTlvs;
 265 class ReceiveTlvs;
 266 class PaymentRelay;
 267 class PaymentConstraints;
 268 class PaymentError;
 269 class ProbingError;
 270 class UtxoLookupError;
 271 class UtxoResult;
 272 class UtxoLookup;
 273 class UtxoFuture;
 274 class OnionMessenger;
 275 class MessageRouter;
 276 class DefaultMessageRouter;
 277 class OnionMessagePath;
 278 class Destination;
 279 class SendError;
 280 class CustomOnionMessageHandler;
 281 class FilesystemStore;
 282 class BlindedPath;
 283 class BlindedHop;
 284 class GraphSyncError;
 285 class InvoiceError;
 286 class ErroneousField;
 287 class MonitorUpdateId;
 288 class Persist;
 289 class LockedChannelMonitor;
 290 class ChainMonitor;
 291 class CResult_LockedChannelMonitorNoneZ;
 292 class CResult_TransactionU16LenLimitedNoneZ;
 293 class CVec_C2Tuple_BlindedPayInfoBlindedPathZZ;
 294 class CResult_PhantomRouteHintsDecodeErrorZ;
 295 class CResult_FundingCreatedDecodeErrorZ;
 296 class CVec_C2Tuple_u32TxOutZZ;
 297 class CResult_RetryDecodeErrorZ;
 298 class CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ;
 299 class CResult_ChannelInfoDecodeErrorZ;
 300 class COption_MaxDustHTLCExposureZ;
 301 class CResult_NoneSendErrorZ;
 302 class C2Tuple_CVec_u8ZusizeZ;
 303 class COption_OffersMessageZ;
 304 class COption_NetworkUpdateZ;
 305 class COption_u64Z;
 306 class CResult_CVec_u8ZPeerHandleErrorZ;
 307 class CResult_GossipTimestampFilterDecodeErrorZ;
 308 class CResult_RouteHintDecodeErrorZ;
 309 class COption_FilterZ;
 310 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ;
 311 class COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ;
 312 class CResult_COption_APIErrorZDecodeErrorZ;
 313 class CVec_UpdateAddHTLCZ;
 314 class CResult_TxAbortDecodeErrorZ;
 315 class CResult_StaticPaymentOutputDescriptorDecodeErrorZ;
 316 class COption_u32Z;
 317 class CResult_RecipientOnionFieldsNoneZ;
 318 class C2Tuple__u1632_u1632Z;
 319 class CResult_CVec_StrZIOErrorZ;
 320 class CResult_ClosingSignedFeeRangeDecodeErrorZ;
 321 class CResult_TransactionNoneZ;
 322 class CResult_CommitmentSignedDecodeErrorZ;
 323 class CResult_CommitmentTransactionDecodeErrorZ;
 324 class CResult_ErrorMessageDecodeErrorZ;
 325 class CResult_OpenChannelDecodeErrorZ;
 326 class COption_APIErrorZ;
 327 class CResult_QueryChannelRangeDecodeErrorZ;
 328 class CVec_TransactionZ;
 329 class CVec_InputZ;
 330 class CResult_ChannelFeaturesDecodeErrorZ;
 331 class CResult_ChannelReadyDecodeErrorZ;
 332 class CResult_UpdateFeeDecodeErrorZ;
 333 class CResult_NoneBolt11SemanticErrorZ;
 334 class CResult_NoneRetryableSendFailureZ;
 335 class CResult_boolLightningErrorZ;
 336 class CResult_NodeIdDecodeErrorZ;
 337 class CResult_ChannelShutdownStateDecodeErrorZ;
 338 class CResult_HTLCOutputInCommitmentDecodeErrorZ;
 339 class CResult_NodeAnnouncementInfoDecodeErrorZ;
 340 class CResult_ShutdownScriptInvalidShutdownScriptZ;
 341 class CResult_COption_NetworkUpdateZDecodeErrorZ;
 342 class CVec_UpdateFailMalformedHTLCZ;
 343 class CResult_ShutdownScriptNoneZ;
 344 class COption_HTLCDestinationZ;
 345 class CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ;
 346 class CVec_RouteHopZ;
 347 class CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ;
 348 class CResult_CVec_UtxoZNoneZ;
 349 class CResult_CVec_u8ZIOErrorZ;
 350 class COption_CustomOnionMessageContentsZ;
 351 class CVec_ThirtyTwoBytesZ;
 352 class CResult_ChannelMonitorUpdateStatusNoneZ;
 353 class CResult_ClosingSignedDecodeErrorZ;
 354 class CResult_NonePaymentErrorZ;
 355 class CVec_CResult_NoneAPIErrorZZ;
 356 class CResult_SchnorrSignatureNoneZ;
 357 class CResult_CounterpartyCommitmentSecretsDecodeErrorZ;
 358 class CResult_ReceiveTlvsDecodeErrorZ;
 359 class CResult_HTLCDescriptorDecodeErrorZ;
 360 class CVec_RecentPaymentDetailsZ;
 361 class CVec_RouteHintHopZ;
 362 class CResult_UntrustedStringDecodeErrorZ;
 363 class CVec_U5Z;
 364 class CResult_PaymentParametersDecodeErrorZ;
 365 class C2Tuple_ThirtyTwoBytesChannelMonitorZ;
 366 class COption_U128Z;
 367 class C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ;
 368 class CResult_TxAckRbfDecodeErrorZ;
 369 class CResult_Bolt11InvoiceBolt11SemanticErrorZ;
 370 class COption_UtxoLookupZ;
 371 class CResult_PongDecodeErrorZ;
 372 class CResult_UnsignedChannelAnnouncementDecodeErrorZ;
 373 class C2Tuple_OutPointCVec_MonitorUpdateIdZZ;
 374 class CResult_CVec_u8ZNoneZ;
 375 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ;
 376 class CResult_ChannelTransactionParametersDecodeErrorZ;
 377 class CResult_WriteableEcdsaChannelSignerDecodeErrorZ;
 378 class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ;
 379 class CResult_InFlightHtlcsDecodeErrorZ;
 380 class CResult_COption_HTLCDestinationZDecodeErrorZ;
 381 class CResult_ThirtyTwoBytesNoneZ;
 382 class C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ;
 383 class CResult_BlindedHopDecodeErrorZ;
 384 class C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ;
 385 class CResult_FixedPenaltyScorerDecodeErrorZ;
 386 class CVec_BlindedPathZ;
 387 class CResult_NoneLightningErrorZ;
 388 class CResult_NonePeerHandleErrorZ;
 389 class CResult_TrustedCommitmentTransactionNoneZ;
 390 class CResult_COption_EventZDecodeErrorZ;
 391 class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ;
 392 class CResult_PaymentFailureReasonDecodeErrorZ;
 393 class COption_SocketAddressZ;
 394 class CResult_COption_MonitorEventZDecodeErrorZ;
 395 class COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ;
 396 class CResult_DescriptionCreationErrorZ;
 397 class CResult_RoutingFeesDecodeErrorZ;
 398 class CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ;
 399 class CResult_PaymentRelayDecodeErrorZ;
 400 class CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ;
 401 class CResult_QueryShortChannelIdsDecodeErrorZ;
 402 class CResult_VerifiedInvoiceRequestNoneZ;
 403 class CResult_UpdateAddHTLCDecodeErrorZ;
 404 class COption_MonitorEventZ;
 405 class COption_TypeZ;
 406 class CResult_COption_TypeZDecodeErrorZ;
 407 class CResult_COption_PathFailureZDecodeErrorZ;
 408 class CResult_Bolt11InvoiceSignOrCreationErrorZ;
 409 class CResult_UpdateFailHTLCDecodeErrorZ;
 410 class CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ;
 411 class CResult_RevokeAndACKDecodeErrorZ;
 412 class CResult_SpendableOutputDescriptorDecodeErrorZ;
 413 class C2Tuple_PublicKeyCOption_SocketAddressZZ;
 414 class CResult_UnsignedChannelUpdateDecodeErrorZ;
 415 class CResult_PayeePubKeySecp256k1ErrorZ;
 416 class COption_BigEndianScalarZ;
 417 class CResult_PublicKeySecp256k1ErrorZ;
 418 class CResult_CVec_ECDSASignatureZNoneZ;
 419 class CVec_BlindedHopZ;
 420 class CResult_COption_ClosureReasonZDecodeErrorZ;
 421 class CResult_InvoiceErrorDecodeErrorZ;
 422 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
 423 class CResult_RouteParametersDecodeErrorZ;
 424 class CResult_PrivateRouteCreationErrorZ;
 425 class CResult_NodeAliasDecodeErrorZ;
 426 class CVec_UpdateFulfillHTLCZ;
 427 class CVec_C2Tuple_u32CVec_u8ZZZ;
 428 class CResult_AnnouncementSignaturesDecodeErrorZ;
 429 class CResult_UpdateFulfillHTLCDecodeErrorZ;
 430 class CResult_TxCompleteDecodeErrorZ;
 431 class CResult_StrSecp256k1ErrorZ;
 432 class CResult_NodeFeaturesDecodeErrorZ;
 433 class CResult_InMemorySignerDecodeErrorZ;
 434 class CResult_TxSignaturesDecodeErrorZ;
 435 class CVec_HTLCDescriptorZ;
 436 class CResult_ReplyShortChannelIdsEndDecodeErrorZ;
 437 class COption_PathFailureZ;
 438 class CVec_ECDSASignatureZ;
 439 class CResult_ChannelUpdateInfoDecodeErrorZ;
 440 class CVec_UpdateFailHTLCZ;
 441 class CVec_TxOutZ;
 442 class CResult_BuiltCommitmentTransactionDecodeErrorZ;
 443 class CVec_SpendableOutputDescriptorZ;
 444 class C2Tuple_OutPointCVec_u8ZZ;
 445 class COption_C2Tuple_u64u64ZZ;
 446 class CResult_ChannelAnnouncementDecodeErrorZ;
 447 class CResult_HTLCUpdateDecodeErrorZ;
 448 class CResult_TxAddInputDecodeErrorZ;
 449 class CVec_OutPointZ;
 450 class CResult_TxInitRbfDecodeErrorZ;
 451 class COption_WriteableScoreZ;
 452 class CVec_StrZ;
 453 class CResult_PositiveTimestampCreationErrorZ;
 454 class CResult_ChannelMonitorUpdateDecodeErrorZ;
 455 class C2Tuple_BlindedPayInfoBlindedPathZ;
 456 class CResult_ReplyChannelRangeDecodeErrorZ;
 457 class CResult_UnsignedNodeAnnouncementDecodeErrorZ;
 458 class CResult_TrustedClosingTransactionNoneZ;
 459 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ;
 460 class C2Tuple_PublicKeyTypeZ;
 461 class CResult_TxRemoveOutputDecodeErrorZ;
 462 class CResult_ChannelReestablishDecodeErrorZ;
 463 class CResult_OnionMessageDecodeErrorZ;
 464 class CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ;
 465 class CResult_C2Tuple_CVec_u8ZusizeZNoneZ;
 466 class CResult_Bolt11InvoiceParseOrSemanticErrorZ;
 467 class CResult_InitFeaturesDecodeErrorZ;
 468 class CResult_PublicKeyNoneZ;
 469 class CResult_PingDecodeErrorZ;
 470 class CResult_BlindedHopFeaturesDecodeErrorZ;
 471 class CVec_TransactionOutputsZ;
 472 class COption_HTLCClaimZ;
 473 class COption_boolZ;
 474 class CVec_CVec_u8ZZ;
 475 class CResult_ProbabilisticScorerDecodeErrorZ;
 476 class CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ;
 477 class CResult_COption_CustomOnionMessageContentsZDecodeErrorZ;
 478 class CResult_ShutdownScriptDecodeErrorZ;
 479 class C2Tuple_usizeTransactionZ;
 480 class CResult_NodeAnnouncementDecodeErrorZ;
 481 class CVec_FutureZ;
 482 class CVec_ChannelMonitorZ;
 483 class CResult_AcceptChannelV2DecodeErrorZ;
 484 class CResult_TxCreationKeysDecodeErrorZ;
 485 class CResult_RouteHopDecodeErrorZ;
 486 class CVec_HTLCOutputInCommitmentZ;
 487 class CResult_CoinSelectionNoneZ;
 488 class C2Tuple_ThirtyTwoBytesPublicKeyZ;
 489 class CResult_SiPrefixBolt11ParseErrorZ;
 490 class CResult_BlindedPathDecodeErrorZ;
 491 class CVec_BalanceZ;
 492 class CResult_NoneIOErrorZ;
 493 class CResult_MaxDustHTLCExposureDecodeErrorZ;
 494 class CVec_CommitmentTransactionZ;
 495 class CResult_FundingSignedDecodeErrorZ;
 496 class CResult_RecoverableSignatureNoneZ;
 497 class CResult_SocketAddressDecodeErrorZ;
 498 class C2Tuple_Z;
 499 class C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ;
 500 class CVec_PathZ;
 501 class CResult_NetworkGraphDecodeErrorZ;
 502 class CResult_NodeInfoDecodeErrorZ;
 503 class CVec_NodeIdZ;
 504 class CVec_u8Z;
 505 class CResult_RouteLightningErrorZ;
 506 class CResult_NonePaymentSendFailureZ;
 507 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ;
 508 class CResult_ChannelPublicKeysDecodeErrorZ;
 509 class CVec_ClaimedHTLCZ;
 510 class COption_CVec_ThirtyTwoBytesZZ;
 511 class CVec_SocketAddressZ;
 512 class CResult_ThirtyTwoBytesPaymentSendFailureZ;
 513 class CResult_HolderCommitmentTransactionDecodeErrorZ;
 514 class CResult_WarningMessageDecodeErrorZ;
 515 class CResult_ChannelCounterpartyDecodeErrorZ;
 516 class CResult_InitDecodeErrorZ;
 517 class CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ;
 518 class CResult_ClaimedHTLCDecodeErrorZ;
 519 class CResult_PaymentPurposeDecodeErrorZ;
 520 class CVec_MonitorUpdateIdZ;
 521 class CResult_OutPointDecodeErrorZ;
 522 class CVec_ChannelDetailsZ;
 523 class CResult_Bolt11InvoiceFeaturesDecodeErrorZ;
 524 class CVec_MessageSendEventZ;
 525 class CResult_RouteHintHopDecodeErrorZ;
 526 class CResult_UpdateFailMalformedHTLCDecodeErrorZ;
 527 class CResult_BlindedPayInfoDecodeErrorZ;
 528 class CResult_ThirtyTwoBytesAPIErrorZ;
 529 class COption_ChannelShutdownStateZ;
 530 class CResult_CVec_CVec_u8ZZNoneZ;
 531 class CResult_AcceptChannelDecodeErrorZ;
 532 class CResult_HostnameDecodeErrorZ;
 533 class C2Tuple_u64u16Z;
 534 class COption_ThirtyTwoBytesZ;
 535 class CVec_u64Z;
 536 class COption_SecretKeyZ;
 537 class CResult_ThirtyTwoBytesPaymentErrorZ;
 538 class COption_EventZ;
 539 class CResult_ChannelTypeFeaturesDecodeErrorZ;
 540 class COption_CVec_SocketAddressZZ;
 541 class CVec_RouteHintZ;
 542 class COption_u16Z;
 543 class COption_PaymentFailureReasonZ;
 544 class CResult_ECDSASignatureNoneZ;
 545 class CVec_WitnessZ;
 546 class CResult_BlindedTailDecodeErrorZ;
 547 class CResult_SocketAddressSocketAddressParseErrorZ;
 548 class COption_C2Tuple_u64u16ZZ;
 549 class CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ;
 550 class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ;
 551 class CResult_ChannelDerivationParametersDecodeErrorZ;
 552 class CResult_PaymentConstraintsDecodeErrorZ;
 553 class C2Tuple_u32CVec_u8ZZ;
 554 class CVec_C2Tuple_PublicKeyTypeZZ;
 555 class CResult_OnionMessagePathNoneZ;
 556 class CResult_RefundBolt12ParseErrorZ;
 557 class C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ;
 558 class CVec_C2Tuple_u64CVec_u8ZZZ;
 559 class CResult_u32GraphSyncErrorZ;
 560 class CVec_PhantomRouteHintsZ;
 561 class CResult_NoneAPIErrorZ;
 562 class CResult_Bolt12InvoiceFeaturesDecodeErrorZ;
 563 class COption_f64Z;
 564 class CResult_ChannelDetailsDecodeErrorZ;
 565 class CVec_PublicKeyZ;
 566 class CVec_C2Tuple_usizeTransactionZZ;
 567 class CResult_TxRemoveInputDecodeErrorZ;
 568 class CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ;
 569 class CResult_OffersMessageDecodeErrorZ;
 570 class C2Tuple_u64u64Z;
 571 class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ;
 572 class CResult_RecipientOnionFieldsDecodeErrorZ;
 573 class C2Tuple_u32TxOutZ;
 574 class CVec_UtxoZ;
 575 class CResult_ChannelConfigDecodeErrorZ;
 576 class CVec_PrivateRouteZ;
 577 class COption_i64Z;
 578 class C2Tuple_ThirtyTwoBytesChannelManagerZ;
 579 class CResult_ShutdownDecodeErrorZ;
 580 class C2Tuple_u64CVec_u8ZZ;
 581 class CResult_OfferBolt12ParseErrorZ;
 582 class CResult_ThirtyTwoBytesRetryableSendFailureZ;
 583 class CVec_MonitorEventZ;
 584 class CResult_BigSizeDecodeErrorZ;
 585 class CResult_TxOutUtxoLookupErrorZ;
 586 class CResult_BlindedPathNoneZ;
 587 class COption_usizeZ;
 588 class CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ;
 589 class CResult_NoneNoneZ;
 590 class CResult_boolPeerHandleErrorZ;
 591 class CResult_ChannelUpdateDecodeErrorZ;
 592 class CVec_APIErrorZ;
 593 class COption_TxOutZ;
 594 class COption_ClosureReasonZ;
 595 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ;
 596 class CResult_TransactionU16LenLimitedDecodeErrorZ;
 597 class CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ;
 598 class CResult_CounterpartyForwardingInfoDecodeErrorZ;
 599 class CResult_OpenChannelV2DecodeErrorZ;
 600 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ;
 601 class C2Tuple_PublicKeyOnionMessageZ;
 602 class CResult_RouteDecodeErrorZ;
 603 class CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ;
 604 class COption_NoneZ;
 605 class CResult_TxAddOutputDecodeErrorZ;
 606 class COption_CVec_u8ZZ;
 607
 608 class Str {
 609 private:
 610         LDKStr self;
 611 public:
 612         Str(const Str&) = delete;
 613         Str(Str&& o) : self(o.self) { memset(&o, 0, sizeof(Str)); }
 614         Str(LDKStr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStr)); }
 615         operator LDKStr() && { LDKStr res = self; memset(&self, 0, sizeof(LDKStr)); return res; }
 616         ~Str() { Str_free(self); }
 617         Str& operator=(Str&& o) { Str_free(self); self = o.self; memset(&o, 0, sizeof(Str)); return *this; }
 618         LDKStr* operator &() { return &self; }
 619         LDKStr* operator ->() { return &self; }
 620         const LDKStr* operator &() const { return &self; }
 621         const LDKStr* operator ->() const { return &self; }
 622 };
 623 class Refund {
 624 private:
 625         LDKRefund self;
 626 public:
 627         Refund(const Refund&) = delete;
 628         Refund(Refund&& o) : self(o.self) { memset(&o, 0, sizeof(Refund)); }
 629         Refund(LDKRefund&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRefund)); }
 630         operator LDKRefund() && { LDKRefund res = self; memset(&self, 0, sizeof(LDKRefund)); return res; }
 631         ~Refund() { Refund_free(self); }
 632         Refund& operator=(Refund&& o) { Refund_free(self); self = o.self; memset(&o, 0, sizeof(Refund)); return *this; }
 633         LDKRefund* operator &() { return &self; }
 634         LDKRefund* operator ->() { return &self; }
 635         const LDKRefund* operator &() const { return &self; }
 636         const LDKRefund* operator ->() const { return &self; }
 637 };
 638 class Retry {
 639 private:
 640         LDKRetry self;
 641 public:
 642         Retry(const Retry&) = delete;
 643         Retry(Retry&& o) : self(o.self) { memset(&o, 0, sizeof(Retry)); }
 644         Retry(LDKRetry&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetry)); }
 645         operator LDKRetry() && { LDKRetry res = self; memset(&self, 0, sizeof(LDKRetry)); return res; }
 646         ~Retry() { Retry_free(self); }
 647         Retry& operator=(Retry&& o) { Retry_free(self); self = o.self; memset(&o, 0, sizeof(Retry)); return *this; }
 648         LDKRetry* operator &() { return &self; }
 649         LDKRetry* operator ->() { return &self; }
 650         const LDKRetry* operator &() const { return &self; }
 651         const LDKRetry* operator ->() const { return &self; }
 652 };
 653 class RetryableSendFailure {
 654 private:
 655         LDKRetryableSendFailure self;
 656 public:
 657         RetryableSendFailure(const RetryableSendFailure&) = delete;
 658         RetryableSendFailure(RetryableSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(RetryableSendFailure)); }
 659         RetryableSendFailure(LDKRetryableSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetryableSendFailure)); }
 660         operator LDKRetryableSendFailure() && { LDKRetryableSendFailure res = self; memset(&self, 0, sizeof(LDKRetryableSendFailure)); return res; }
 661         RetryableSendFailure& operator=(RetryableSendFailure&& o) { self = o.self; memset(&o, 0, sizeof(RetryableSendFailure)); return *this; }
 662         LDKRetryableSendFailure* operator &() { return &self; }
 663         LDKRetryableSendFailure* operator ->() { return &self; }
 664         const LDKRetryableSendFailure* operator &() const { return &self; }
 665         const LDKRetryableSendFailure* operator ->() const { return &self; }
 666 };
 667 class PaymentSendFailure {
 668 private:
 669         LDKPaymentSendFailure self;
 670 public:
 671         PaymentSendFailure(const PaymentSendFailure&) = delete;
 672         PaymentSendFailure(PaymentSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentSendFailure)); }
 673         PaymentSendFailure(LDKPaymentSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentSendFailure)); }
 674         operator LDKPaymentSendFailure() && { LDKPaymentSendFailure res = self; memset(&self, 0, sizeof(LDKPaymentSendFailure)); return res; }
 675         ~PaymentSendFailure() { PaymentSendFailure_free(self); }
 676         PaymentSendFailure& operator=(PaymentSendFailure&& o) { PaymentSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(PaymentSendFailure)); return *this; }
 677         LDKPaymentSendFailure* operator &() { return &self; }
 678         LDKPaymentSendFailure* operator ->() { return &self; }
 679         const LDKPaymentSendFailure* operator &() const { return &self; }
 680         const LDKPaymentSendFailure* operator ->() const { return &self; }
 681 };
 682 class ProbeSendFailure {
 683 private:
 684         LDKProbeSendFailure self;
 685 public:
 686         ProbeSendFailure(const ProbeSendFailure&) = delete;
 687         ProbeSendFailure(ProbeSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(ProbeSendFailure)); }
 688         ProbeSendFailure(LDKProbeSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbeSendFailure)); }
 689         operator LDKProbeSendFailure() && { LDKProbeSendFailure res = self; memset(&self, 0, sizeof(LDKProbeSendFailure)); return res; }
 690         ~ProbeSendFailure() { ProbeSendFailure_free(self); }
 691         ProbeSendFailure& operator=(ProbeSendFailure&& o) { ProbeSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(ProbeSendFailure)); return *this; }
 692         LDKProbeSendFailure* operator &() { return &self; }
 693         LDKProbeSendFailure* operator ->() { return &self; }
 694         const LDKProbeSendFailure* operator &() const { return &self; }
 695         const LDKProbeSendFailure* operator ->() const { return &self; }
 696 };
 697 class RecipientOnionFields {
 698 private:
 699         LDKRecipientOnionFields self;
 700 public:
 701         RecipientOnionFields(const RecipientOnionFields&) = delete;
 702         RecipientOnionFields(RecipientOnionFields&& o) : self(o.self) { memset(&o, 0, sizeof(RecipientOnionFields)); }
 703         RecipientOnionFields(LDKRecipientOnionFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecipientOnionFields)); }
 704         operator LDKRecipientOnionFields() && { LDKRecipientOnionFields res = self; memset(&self, 0, sizeof(LDKRecipientOnionFields)); return res; }
 705         ~RecipientOnionFields() { RecipientOnionFields_free(self); }
 706         RecipientOnionFields& operator=(RecipientOnionFields&& o) { RecipientOnionFields_free(self); self = o.self; memset(&o, 0, sizeof(RecipientOnionFields)); return *this; }
 707         LDKRecipientOnionFields* operator &() { return &self; }
 708         LDKRecipientOnionFields* operator ->() { return &self; }
 709         const LDKRecipientOnionFields* operator &() const { return &self; }
 710         const LDKRecipientOnionFields* operator ->() const { return &self; }
 711 };
 712 class UnsignedBolt12Invoice {
 713 private:
 714         LDKUnsignedBolt12Invoice self;
 715 public:
 716         UnsignedBolt12Invoice(const UnsignedBolt12Invoice&) = delete;
 717         UnsignedBolt12Invoice(UnsignedBolt12Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedBolt12Invoice)); }
 718         UnsignedBolt12Invoice(LDKUnsignedBolt12Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedBolt12Invoice)); }
 719         operator LDKUnsignedBolt12Invoice() && { LDKUnsignedBolt12Invoice res = self; memset(&self, 0, sizeof(LDKUnsignedBolt12Invoice)); return res; }
 720         ~UnsignedBolt12Invoice() { UnsignedBolt12Invoice_free(self); }
 721         UnsignedBolt12Invoice& operator=(UnsignedBolt12Invoice&& o) { UnsignedBolt12Invoice_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedBolt12Invoice)); return *this; }
 722         LDKUnsignedBolt12Invoice* operator &() { return &self; }
 723         LDKUnsignedBolt12Invoice* operator ->() { return &self; }
 724         const LDKUnsignedBolt12Invoice* operator &() const { return &self; }
 725         const LDKUnsignedBolt12Invoice* operator ->() const { return &self; }
 726 };
 727 class Bolt12Invoice {
 728 private:
 729         LDKBolt12Invoice self;
 730 public:
 731         Bolt12Invoice(const Bolt12Invoice&) = delete;
 732         Bolt12Invoice(Bolt12Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12Invoice)); }
 733         Bolt12Invoice(LDKBolt12Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12Invoice)); }
 734         operator LDKBolt12Invoice() && { LDKBolt12Invoice res = self; memset(&self, 0, sizeof(LDKBolt12Invoice)); return res; }
 735         ~Bolt12Invoice() { Bolt12Invoice_free(self); }
 736         Bolt12Invoice& operator=(Bolt12Invoice&& o) { Bolt12Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12Invoice)); return *this; }
 737         LDKBolt12Invoice* operator &() { return &self; }
 738         LDKBolt12Invoice* operator ->() { return &self; }
 739         const LDKBolt12Invoice* operator &() const { return &self; }
 740         const LDKBolt12Invoice* operator ->() const { return &self; }
 741 };
 742 class BlindedPayInfo {
 743 private:
 744         LDKBlindedPayInfo self;
 745 public:
 746         BlindedPayInfo(const BlindedPayInfo&) = delete;
 747         BlindedPayInfo(BlindedPayInfo&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPayInfo)); }
 748         BlindedPayInfo(LDKBlindedPayInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPayInfo)); }
 749         operator LDKBlindedPayInfo() && { LDKBlindedPayInfo res = self; memset(&self, 0, sizeof(LDKBlindedPayInfo)); return res; }
 750         ~BlindedPayInfo() { BlindedPayInfo_free(self); }
 751         BlindedPayInfo& operator=(BlindedPayInfo&& o) { BlindedPayInfo_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPayInfo)); return *this; }
 752         LDKBlindedPayInfo* operator &() { return &self; }
 753         LDKBlindedPayInfo* operator ->() { return &self; }
 754         const LDKBlindedPayInfo* operator &() const { return &self; }
 755         const LDKBlindedPayInfo* operator ->() const { return &self; }
 756 };
 757 class DelayedPaymentOutputDescriptor {
 758 private:
 759         LDKDelayedPaymentOutputDescriptor self;
 760 public:
 761         DelayedPaymentOutputDescriptor(const DelayedPaymentOutputDescriptor&) = delete;
 762         DelayedPaymentOutputDescriptor(DelayedPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); }
 763         DelayedPaymentOutputDescriptor(LDKDelayedPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); }
 764         operator LDKDelayedPaymentOutputDescriptor() && { LDKDelayedPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); return res; }
 765         ~DelayedPaymentOutputDescriptor() { DelayedPaymentOutputDescriptor_free(self); }
 766         DelayedPaymentOutputDescriptor& operator=(DelayedPaymentOutputDescriptor&& o) { DelayedPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); return *this; }
 767         LDKDelayedPaymentOutputDescriptor* operator &() { return &self; }
 768         LDKDelayedPaymentOutputDescriptor* operator ->() { return &self; }
 769         const LDKDelayedPaymentOutputDescriptor* operator &() const { return &self; }
 770         const LDKDelayedPaymentOutputDescriptor* operator ->() const { return &self; }
 771 };
 772 class StaticPaymentOutputDescriptor {
 773 private:
 774         LDKStaticPaymentOutputDescriptor self;
 775 public:
 776         StaticPaymentOutputDescriptor(const StaticPaymentOutputDescriptor&) = delete;
 777         StaticPaymentOutputDescriptor(StaticPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); }
 778         StaticPaymentOutputDescriptor(LDKStaticPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); }
 779         operator LDKStaticPaymentOutputDescriptor() && { LDKStaticPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); return res; }
 780         ~StaticPaymentOutputDescriptor() { StaticPaymentOutputDescriptor_free(self); }
 781         StaticPaymentOutputDescriptor& operator=(StaticPaymentOutputDescriptor&& o) { StaticPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); return *this; }
 782         LDKStaticPaymentOutputDescriptor* operator &() { return &self; }
 783         LDKStaticPaymentOutputDescriptor* operator ->() { return &self; }
 784         const LDKStaticPaymentOutputDescriptor* operator &() const { return &self; }
 785         const LDKStaticPaymentOutputDescriptor* operator ->() const { return &self; }
 786 };
 787 class SpendableOutputDescriptor {
 788 private:
 789         LDKSpendableOutputDescriptor self;
 790 public:
 791         SpendableOutputDescriptor(const SpendableOutputDescriptor&) = delete;
 792         SpendableOutputDescriptor(SpendableOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SpendableOutputDescriptor)); }
 793         SpendableOutputDescriptor(LDKSpendableOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendableOutputDescriptor)); }
 794         operator LDKSpendableOutputDescriptor() && { LDKSpendableOutputDescriptor res = self; memset(&self, 0, sizeof(LDKSpendableOutputDescriptor)); return res; }
 795         ~SpendableOutputDescriptor() { SpendableOutputDescriptor_free(self); }
 796         SpendableOutputDescriptor& operator=(SpendableOutputDescriptor&& o) { SpendableOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SpendableOutputDescriptor)); return *this; }
 797         LDKSpendableOutputDescriptor* operator &() { return &self; }
 798         LDKSpendableOutputDescriptor* operator ->() { return &self; }
 799         const LDKSpendableOutputDescriptor* operator &() const { return &self; }
 800         const LDKSpendableOutputDescriptor* operator ->() const { return &self; }
 801 };
 802 class ChannelSigner {
 803 private:
 804         LDKChannelSigner self;
 805 public:
 806         ChannelSigner(const ChannelSigner&) = delete;
 807         ChannelSigner(ChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelSigner)); }
 808         ChannelSigner(LDKChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelSigner)); }
 809         operator LDKChannelSigner() && { LDKChannelSigner res = self; memset(&self, 0, sizeof(LDKChannelSigner)); return res; }
 810         ~ChannelSigner() { ChannelSigner_free(self); }
 811         ChannelSigner& operator=(ChannelSigner&& o) { ChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(ChannelSigner)); return *this; }
 812         LDKChannelSigner* operator &() { return &self; }
 813         LDKChannelSigner* operator ->() { return &self; }
 814         const LDKChannelSigner* operator &() const { return &self; }
 815         const LDKChannelSigner* operator ->() const { return &self; }
 816         /**
 817          *  Gets the per-commitment point for a specific commitment number
 818          *
 819          *  Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.
 820          */
 821         inline LDKPublicKey get_per_commitment_point(uint64_t idx);
 822         /**
 823          *  Gets the commitment secret for a specific commitment number as part of the revocation process
 824          *
 825          *  An external signer implementation should error here if the commitment was already signed
 826          *  and should refuse to sign it in the future.
 827          *
 828          *  May be called more than once for the same index.
 829          *
 830          *  Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.
 831          */
 832         inline LDKThirtyTwoBytes release_commitment_secret(uint64_t idx);
 833         /**
 834          *  Validate the counterparty's signatures on the holder commitment transaction and HTLCs.
 835          *
 836          *  This is required in order for the signer to make sure that releasing a commitment
 837          *  secret won't leave us without a broadcastable holder transaction.
 838          *  Policy checks should be implemented in this function, including checking the amount
 839          *  sent to us and checking the HTLCs.
 840          *
 841          *  The preimages of outgoing HTLCs that were fulfilled since the last commitment are provided.
 842          *  A validating signer should ensure that an HTLC output is removed only when the matching
 843          *  preimage is provided, or when the value to holder is restored.
 844          *
 845          *  Note that all the relevant preimages will be provided, but there may also be additional
 846          *  irrelevant or duplicate preimages.
 847          */
 848         inline LDK::CResult_NoneNoneZ validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ preimages);
 849         /**
 850          *  Returns an arbitrary identifier describing the set of keys which are provided back to you in
 851          *  some [`SpendableOutputDescriptor`] types. This should be sufficient to identify this
 852          *  [`EcdsaChannelSigner`] object uniquely and lookup or re-derive its keys.
 853          */
 854         inline LDKThirtyTwoBytes channel_keys_id();
 855         /**
 856          *  Set the counterparty static channel data, including basepoints,
 857          *  `counterparty_selected`/`holder_selected_contest_delay` and funding outpoint.
 858          *
 859          *  This data is static, and will never change for a channel once set. For a given [`ChannelSigner`]
 860          *  instance, LDK will call this method exactly once - either immediately after construction
 861          *  (not including if done via [`SignerProvider::read_chan_signer`]) or when the funding
 862          *  information has been generated.
 863          *
 864          *  channel_parameters.is_populated() MUST be true.
 865          */
 866         inline void provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters);
 867 };
 868 class EcdsaChannelSigner {
 869 private:
 870         LDKEcdsaChannelSigner self;
 871 public:
 872         EcdsaChannelSigner(const EcdsaChannelSigner&) = delete;
 873         EcdsaChannelSigner(EcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(EcdsaChannelSigner)); }
 874         EcdsaChannelSigner(LDKEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEcdsaChannelSigner)); }
 875         operator LDKEcdsaChannelSigner() && { LDKEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKEcdsaChannelSigner)); return res; }
 876         ~EcdsaChannelSigner() { EcdsaChannelSigner_free(self); }
 877         EcdsaChannelSigner& operator=(EcdsaChannelSigner&& o) { EcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(EcdsaChannelSigner)); return *this; }
 878         LDKEcdsaChannelSigner* operator &() { return &self; }
 879         LDKEcdsaChannelSigner* operator ->() { return &self; }
 880         const LDKEcdsaChannelSigner* operator &() const { return &self; }
 881         const LDKEcdsaChannelSigner* operator ->() const { return &self; }
 882         /**
 883          *  Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
 884          *
 885          *  Note that if signing fails or is rejected, the channel will be force-closed.
 886          *
 887          *  Policy checks should be implemented in this function, including checking the amount
 888          *  sent to us and checking the HTLCs.
 889          *
 890          *  The preimages of outgoing HTLCs that were fulfilled since the last commitment are provided.
 891          *  A validating signer should ensure that an HTLC output is removed only when the matching
 892          *  preimage is provided, or when the value to holder is restored.
 893          *
 894          *  Note that all the relevant preimages will be provided, but there may also be additional
 895          *  irrelevant or duplicate preimages.
 896          */
 897         inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ preimages);
 898         /**
 899          *  Validate the counterparty's revocation.
 900          *
 901          *  This is required in order for the signer to make sure that the state has moved
 902          *  forward and it is safe to sign the next counterparty commitment.
 903          */
 904         inline LDK::CResult_NoneNoneZ validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]);
 905         /**
 906          *  Creates a signature for a holder's commitment transaction and its claiming HTLC transactions.
 907          *
 908          *  This will be called
 909          *  - with a non-revoked `commitment_tx`.
 910          *  - with the latest `commitment_tx` when we initiate a force-close.
 911          *  - with the previous `commitment_tx`, just to get claiming HTLC
 912          *    signatures, if we are reacting to a [`ChannelMonitor`]
 913          *    [replica](https://github.com/lightningdevkit/rust-lightning/blob/main/GLOSSARY.md#monitor-replicas)
 914          *    that decided to broadcast before it had been updated to the latest `commitment_tx`.
 915          *
 916          *  This may be called multiple times for the same transaction.
 917          *
 918          *  An external signer implementation should check that the commitment has not been revoked.
 919          *
 920          *  [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
 921          */
 922         inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ sign_holder_commitment_and_htlcs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx);
 923         /**
 924          *  Create a signature for the given input in a transaction spending an HTLC transaction output
 925          *  or a commitment transaction `to_local` output when our counterparty broadcasts an old state.
 926          *
 927          *  A justice transaction may claim multiple outputs at the same time if timelocks are
 928          *  similar, but only a signature for the input at index `input` should be signed for here.
 929          *  It may be called multiple times for same output(s) if a fee-bump is needed with regards
 930          *  to an upcoming timelock expiration.
 931          *
 932          *  Amount is value of the output spent by this input, committed to in the BIP 143 signature.
 933          *
 934          *  `per_commitment_key` is revocation secret which was provided by our counterparty when they
 935          *  revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
 936          *  not allow the spending of any funds by itself (you need our holder `revocation_secret` to do
 937          *  so).
 938          */
 939         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]);
 940         /**
 941          *  Create a signature for the given input in a transaction spending a commitment transaction
 942          *  HTLC output when our counterparty broadcasts an old state.
 943          *
 944          *  A justice transaction may claim multiple outputs at the same time if timelocks are
 945          *  similar, but only a signature for the input at index `input` should be signed for here.
 946          *  It may be called multiple times for same output(s) if a fee-bump is needed with regards
 947          *  to an upcoming timelock expiration.
 948          *
 949          *  `amount` is the value of the output spent by this input, committed to in the BIP 143
 950          *  signature.
 951          *
 952          *  `per_commitment_key` is revocation secret which was provided by our counterparty when they
 953          *  revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
 954          *  not allow the spending of any funds by itself (you need our holder revocation_secret to do
 955          *  so).
 956          *
 957          *  `htlc` holds HTLC elements (hash, timelock), thus changing the format of the witness script
 958          *  (which is committed to in the BIP 143 signatures).
 959          */
 960         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);
 961         /**
 962          *  Computes the signature for a commitment transaction's HTLC output used as an input within
 963          *  `htlc_tx`, which spends the commitment transaction at index `input`. The signature returned
 964          *  must be be computed using [`EcdsaSighashType::All`]. Note that this should only be used to
 965          *  sign HTLC transactions from channels supporting anchor outputs after all additional
 966          *  inputs/outputs have been added to the transaction.
 967          *
 968          *  [`EcdsaSighashType::All`]: bitcoin::blockdata::transaction::EcdsaSighashType::All
 969          */
 970         inline LDK::CResult_ECDSASignatureNoneZ sign_holder_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor);
 971         /**
 972          *  Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment
 973          *  transaction, either offered or received.
 974          *
 975          *  Such a transaction may claim multiples offered outputs at same time if we know the
 976          *  preimage for each when we create it, but only the input at index `input` should be
 977          *  signed for here. It may be called multiple times for same output(s) if a fee-bump is
 978          *  needed with regards to an upcoming timelock expiration.
 979          *
 980          *  `witness_script` is either an offered or received script as defined in BOLT3 for HTLC
 981          *  outputs.
 982          *
 983          *  `amount` is value of the output spent by this input, committed to in the BIP 143 signature.
 984          *
 985          *  `per_commitment_point` is the dynamic point corresponding to the channel state
 986          *  detected onchain. It has been generated by our counterparty and is used to derive
 987          *  channel state keys, which are then included in the witness script and committed to in the
 988          *  BIP 143 signature.
 989          */
 990         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);
 991         /**
 992          *  Create a signature for a (proposed) closing transaction.
 993          *
 994          *  Note that, due to rounding, there may be one "missing" satoshi, and either party may have
 995          *  chosen to forgo their output as dust.
 996          */
 997         inline LDK::CResult_ECDSASignatureNoneZ sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx);
 998         /**
 999          *  Computes the signature for a commitment transaction's anchor output used as an
1000          *  input within `anchor_tx`, which spends the commitment transaction, at index `input`.
1001          */
1002         inline LDK::CResult_ECDSASignatureNoneZ sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input);
1003         /**
1004          *  Signs a channel announcement message with our funding key proving it comes from one of the
1005          *  channel participants.
1006          *
1007          *  Channel announcements also require a signature from each node's network key. Our node
1008          *  signature is computed through [`NodeSigner::sign_gossip_message`].
1009          *
1010          *  Note that if this fails or is rejected, the channel will not be publicly announced and
1011          *  our counterparty may (though likely will not) close the channel on us for violating the
1012          *  protocol.
1013          */
1014         inline LDK::CResult_ECDSASignatureNoneZ sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
1015 };
1016 class WriteableEcdsaChannelSigner {
1017 private:
1018         LDKWriteableEcdsaChannelSigner self;
1019 public:
1020         WriteableEcdsaChannelSigner(const WriteableEcdsaChannelSigner&) = delete;
1021         WriteableEcdsaChannelSigner(WriteableEcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(WriteableEcdsaChannelSigner)); }
1022         WriteableEcdsaChannelSigner(LDKWriteableEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWriteableEcdsaChannelSigner)); }
1023         operator LDKWriteableEcdsaChannelSigner() && { LDKWriteableEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKWriteableEcdsaChannelSigner)); return res; }
1024         ~WriteableEcdsaChannelSigner() { WriteableEcdsaChannelSigner_free(self); }
1025         WriteableEcdsaChannelSigner& operator=(WriteableEcdsaChannelSigner&& o) { WriteableEcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(WriteableEcdsaChannelSigner)); return *this; }
1026         LDKWriteableEcdsaChannelSigner* operator &() { return &self; }
1027         LDKWriteableEcdsaChannelSigner* operator ->() { return &self; }
1028         const LDKWriteableEcdsaChannelSigner* operator &() const { return &self; }
1029         const LDKWriteableEcdsaChannelSigner* operator ->() const { return &self; }
1030 };
1031 class Recipient {
1032 private:
1033         LDKRecipient self;
1034 public:
1035         Recipient(const Recipient&) = delete;
1036         Recipient(Recipient&& o) : self(o.self) { memset(&o, 0, sizeof(Recipient)); }
1037         Recipient(LDKRecipient&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecipient)); }
1038         operator LDKRecipient() && { LDKRecipient res = self; memset(&self, 0, sizeof(LDKRecipient)); return res; }
1039         Recipient& operator=(Recipient&& o) { self = o.self; memset(&o, 0, sizeof(Recipient)); return *this; }
1040         LDKRecipient* operator &() { return &self; }
1041         LDKRecipient* operator ->() { return &self; }
1042         const LDKRecipient* operator &() const { return &self; }
1043         const LDKRecipient* operator ->() const { return &self; }
1044 };
1045 class EntropySource {
1046 private:
1047         LDKEntropySource self;
1048 public:
1049         EntropySource(const EntropySource&) = delete;
1050         EntropySource(EntropySource&& o) : self(o.self) { memset(&o, 0, sizeof(EntropySource)); }
1051         EntropySource(LDKEntropySource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEntropySource)); }
1052         operator LDKEntropySource() && { LDKEntropySource res = self; memset(&self, 0, sizeof(LDKEntropySource)); return res; }
1053         ~EntropySource() { EntropySource_free(self); }
1054         EntropySource& operator=(EntropySource&& o) { EntropySource_free(self); self = o.self; memset(&o, 0, sizeof(EntropySource)); return *this; }
1055         LDKEntropySource* operator &() { return &self; }
1056         LDKEntropySource* operator ->() { return &self; }
1057         const LDKEntropySource* operator &() const { return &self; }
1058         const LDKEntropySource* operator ->() const { return &self; }
1059         /**
1060          *  Gets a unique, cryptographically-secure, random 32-byte value. This method must return a
1061          *  different value each time it is called.
1062          */
1063         inline LDKThirtyTwoBytes get_secure_random_bytes();
1064 };
1065 class NodeSigner {
1066 private:
1067         LDKNodeSigner self;
1068 public:
1069         NodeSigner(const NodeSigner&) = delete;
1070         NodeSigner(NodeSigner&& o) : self(o.self) { memset(&o, 0, sizeof(NodeSigner)); }
1071         NodeSigner(LDKNodeSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeSigner)); }
1072         operator LDKNodeSigner() && { LDKNodeSigner res = self; memset(&self, 0, sizeof(LDKNodeSigner)); return res; }
1073         ~NodeSigner() { NodeSigner_free(self); }
1074         NodeSigner& operator=(NodeSigner&& o) { NodeSigner_free(self); self = o.self; memset(&o, 0, sizeof(NodeSigner)); return *this; }
1075         LDKNodeSigner* operator &() { return &self; }
1076         LDKNodeSigner* operator ->() { return &self; }
1077         const LDKNodeSigner* operator &() const { return &self; }
1078         const LDKNodeSigner* operator ->() const { return &self; }
1079         /**
1080          *  Get secret key material as bytes for use in encrypting and decrypting inbound payment data.
1081          *
1082          *  If the implementor of this trait supports [phantom node payments], then every node that is
1083          *  intended to be included in the phantom invoice route hints must return the same value from
1084          *  this method.
1085          *
1086          *  This method must return the same value each time it is called.
1087          *
1088          *  [phantom node payments]: PhantomKeysManager
1089          */
1090         inline LDKThirtyTwoBytes get_inbound_payment_key_material();
1091         /**
1092          *  Get node id based on the provided [`Recipient`].
1093          *
1094          *  This method must return the same value each time it is called with a given [`Recipient`]
1095          *  parameter.
1096          *
1097          *  Errors if the [`Recipient`] variant is not supported by the implementation.
1098          */
1099         inline LDK::CResult_PublicKeyNoneZ get_node_id(enum LDKRecipient recipient);
1100         /**
1101          *  Gets the ECDH shared secret of our node secret and `other_key`, multiplying by `tweak` if
1102          *  one is provided. Note that this tweak can be applied to `other_key` instead of our node
1103          *  secret, though this is less efficient.
1104          *
1105          *  Note that if this fails while attempting to forward an HTLC, LDK will panic. The error
1106          *  should be resolved to allow LDK to resume forwarding HTLCs.
1107          *
1108          *  Errors if the [`Recipient`] variant is not supported by the implementation.
1109          */
1110         inline LDK::CResult_ThirtyTwoBytesNoneZ ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak);
1111         /**
1112          *  Sign an invoice.
1113          *
1114          *  By parameterizing by the raw invoice bytes instead of the hash, we allow implementors of
1115          *  this trait to parse the invoice and make sure they're signing what they expect, rather than
1116          *  blindly signing the hash.
1117          *
1118          *  The `hrp_bytes` are ASCII bytes, while the `invoice_data` is base32.
1119          *
1120          *  The secret key used to sign the invoice is dependent on the [`Recipient`].
1121          *
1122          *  Errors if the [`Recipient`] variant is not supported by the implementation.
1123          */
1124         inline LDK::CResult_RecoverableSignatureNoneZ sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient);
1125         /**
1126          *  Signs the [`TaggedHash`] of a BOLT 12 invoice request.
1127          *
1128          *  May be called by a function passed to [`UnsignedInvoiceRequest::sign`] where
1129          *  `invoice_request` is the callee.
1130          *
1131          *  Implementors may check that the `invoice_request` is expected rather than blindly signing
1132          *  the tagged hash. An `Ok` result should sign `invoice_request.tagged_hash().as_digest()` with
1133          *  the node's signing key or an ephemeral key to preserve privacy, whichever is associated with
1134          *  [`UnsignedInvoiceRequest::payer_id`].
1135          *
1136          *  [`TaggedHash`]: crate::offers::merkle::TaggedHash
1137          */
1138         inline LDK::CResult_SchnorrSignatureNoneZ sign_bolt12_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR invoice_request);
1139         /**
1140          *  Signs the [`TaggedHash`] of a BOLT 12 invoice.
1141          *
1142          *  May be called by a function passed to [`UnsignedBolt12Invoice::sign`] where `invoice` is the
1143          *  callee.
1144          *
1145          *  Implementors may check that the `invoice` is expected rather than blindly signing the tagged
1146          *  hash. An `Ok` result should sign `invoice.tagged_hash().as_digest()` with the node's signing
1147          *  key or an ephemeral key to preserve privacy, whichever is associated with
1148          *  [`UnsignedBolt12Invoice::signing_pubkey`].
1149          *
1150          *  [`TaggedHash`]: crate::offers::merkle::TaggedHash
1151          */
1152         inline LDK::CResult_SchnorrSignatureNoneZ sign_bolt12_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR invoice);
1153         /**
1154          *  Sign a gossip message.
1155          *
1156          *  Note that if this fails, LDK may panic and the message will not be broadcast to the network
1157          *  or a possible channel counterparty. If LDK panics, the error should be resolved to allow the
1158          *  message to be broadcast, as otherwise it may prevent one from receiving funds over the
1159          *  corresponding channel.
1160          */
1161         inline LDK::CResult_ECDSASignatureNoneZ sign_gossip_message(struct LDKUnsignedGossipMessage msg);
1162 };
1163 class SignerProvider {
1164 private:
1165         LDKSignerProvider self;
1166 public:
1167         SignerProvider(const SignerProvider&) = delete;
1168         SignerProvider(SignerProvider&& o) : self(o.self) { memset(&o, 0, sizeof(SignerProvider)); }
1169         SignerProvider(LDKSignerProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignerProvider)); }
1170         operator LDKSignerProvider() && { LDKSignerProvider res = self; memset(&self, 0, sizeof(LDKSignerProvider)); return res; }
1171         ~SignerProvider() { SignerProvider_free(self); }
1172         SignerProvider& operator=(SignerProvider&& o) { SignerProvider_free(self); self = o.self; memset(&o, 0, sizeof(SignerProvider)); return *this; }
1173         LDKSignerProvider* operator &() { return &self; }
1174         LDKSignerProvider* operator ->() { return &self; }
1175         const LDKSignerProvider* operator &() const { return &self; }
1176         const LDKSignerProvider* operator ->() const { return &self; }
1177         /**
1178          *  Generates a unique `channel_keys_id` that can be used to obtain a [`Self::Signer`] through
1179          *  [`SignerProvider::derive_channel_signer`]. The `user_channel_id` is provided to allow
1180          *  implementations of [`SignerProvider`] to maintain a mapping between itself and the generated
1181          *  `channel_keys_id`.
1182          *
1183          *  This method must return a different value each time it is called.
1184          */
1185         inline LDKThirtyTwoBytes generate_channel_keys_id(bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id);
1186         /**
1187          *  Derives the private key material backing a `Signer`.
1188          *
1189          *  To derive a new `Signer`, a fresh `channel_keys_id` should be obtained through
1190          *  [`SignerProvider::generate_channel_keys_id`]. Otherwise, an existing `Signer` can be
1191          *  re-derived from its `channel_keys_id`, which can be obtained through its trait method
1192          *  [`ChannelSigner::channel_keys_id`].
1193          */
1194         inline LDK::WriteableEcdsaChannelSigner derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id);
1195         /**
1196          *  Reads a [`Signer`] for this [`SignerProvider`] from the given input stream.
1197          *  This is only called during deserialization of other objects which contain
1198          *  [`WriteableEcdsaChannelSigner`]-implementing objects (i.e., [`ChannelMonitor`]s and [`ChannelManager`]s).
1199          *  The bytes are exactly those which `<Self::Signer as Writeable>::write()` writes, and
1200          *  contain no versioning scheme. You may wish to include your own version prefix and ensure
1201          *  you've read all of the provided bytes to ensure no corruption occurred.
1202          *
1203          *  This method is slowly being phased out -- it will only be called when reading objects
1204          *  written by LDK versions prior to 0.0.113.
1205          *
1206          *  [`Signer`]: Self::Signer
1207          *  [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
1208          *  [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
1209          */
1210         inline LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ read_chan_signer(struct LDKu8slice reader);
1211         /**
1212          *  Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
1213          *
1214          *  If this function returns an error, this will result in a channel failing to open.
1215          *
1216          *  This method should return a different value each time it is called, to avoid linking
1217          *  on-chain funds across channels as controlled to the same user.
1218          */
1219         inline LDK::CResult_CVec_u8ZNoneZ get_destination_script();
1220         /**
1221          *  Get a script pubkey which we will send funds to when closing a channel.
1222          *
1223          *  If this function returns an error, this will result in a channel failing to open or close.
1224          *  In the event of a failure when the counterparty is initiating a close, this can result in a
1225          *  channel force close.
1226          *
1227          *  This method should return a different value each time it is called, to avoid linking
1228          *  on-chain funds across channels as controlled to the same user.
1229          */
1230         inline LDK::CResult_ShutdownScriptNoneZ get_shutdown_scriptpubkey();
1231 };
1232 class InMemorySigner {
1233 private:
1234         LDKInMemorySigner self;
1235 public:
1236         InMemorySigner(const InMemorySigner&) = delete;
1237         InMemorySigner(InMemorySigner&& o) : self(o.self) { memset(&o, 0, sizeof(InMemorySigner)); }
1238         InMemorySigner(LDKInMemorySigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInMemorySigner)); }
1239         operator LDKInMemorySigner() && { LDKInMemorySigner res = self; memset(&self, 0, sizeof(LDKInMemorySigner)); return res; }
1240         ~InMemorySigner() { InMemorySigner_free(self); }
1241         InMemorySigner& operator=(InMemorySigner&& o) { InMemorySigner_free(self); self = o.self; memset(&o, 0, sizeof(InMemorySigner)); return *this; }
1242         LDKInMemorySigner* operator &() { return &self; }
1243         LDKInMemorySigner* operator ->() { return &self; }
1244         const LDKInMemorySigner* operator &() const { return &self; }
1245         const LDKInMemorySigner* operator ->() const { return &self; }
1246 };
1247 class KeysManager {
1248 private:
1249         LDKKeysManager self;
1250 public:
1251         KeysManager(const KeysManager&) = delete;
1252         KeysManager(KeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(KeysManager)); }
1253         KeysManager(LDKKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysManager)); }
1254         operator LDKKeysManager() && { LDKKeysManager res = self; memset(&self, 0, sizeof(LDKKeysManager)); return res; }
1255         ~KeysManager() { KeysManager_free(self); }
1256         KeysManager& operator=(KeysManager&& o) { KeysManager_free(self); self = o.self; memset(&o, 0, sizeof(KeysManager)); return *this; }
1257         LDKKeysManager* operator &() { return &self; }
1258         LDKKeysManager* operator ->() { return &self; }
1259         const LDKKeysManager* operator &() const { return &self; }
1260         const LDKKeysManager* operator ->() const { return &self; }
1261 };
1262 class PhantomKeysManager {
1263 private:
1264         LDKPhantomKeysManager self;
1265 public:
1266         PhantomKeysManager(const PhantomKeysManager&) = delete;
1267         PhantomKeysManager(PhantomKeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomKeysManager)); }
1268         PhantomKeysManager(LDKPhantomKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomKeysManager)); }
1269         operator LDKPhantomKeysManager() && { LDKPhantomKeysManager res = self; memset(&self, 0, sizeof(LDKPhantomKeysManager)); return res; }
1270         ~PhantomKeysManager() { PhantomKeysManager_free(self); }
1271         PhantomKeysManager& operator=(PhantomKeysManager&& o) { PhantomKeysManager_free(self); self = o.self; memset(&o, 0, sizeof(PhantomKeysManager)); return *this; }
1272         LDKPhantomKeysManager* operator &() { return &self; }
1273         LDKPhantomKeysManager* operator ->() { return &self; }
1274         const LDKPhantomKeysManager* operator &() const { return &self; }
1275         const LDKPhantomKeysManager* operator ->() const { return &self; }
1276 };
1277 class BackgroundProcessor {
1278 private:
1279         LDKBackgroundProcessor self;
1280 public:
1281         BackgroundProcessor(const BackgroundProcessor&) = delete;
1282         BackgroundProcessor(BackgroundProcessor&& o) : self(o.self) { memset(&o, 0, sizeof(BackgroundProcessor)); }
1283         BackgroundProcessor(LDKBackgroundProcessor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBackgroundProcessor)); }
1284         operator LDKBackgroundProcessor() && { LDKBackgroundProcessor res = self; memset(&self, 0, sizeof(LDKBackgroundProcessor)); return res; }
1285         ~BackgroundProcessor() { BackgroundProcessor_free(self); }
1286         BackgroundProcessor& operator=(BackgroundProcessor&& o) { BackgroundProcessor_free(self); self = o.self; memset(&o, 0, sizeof(BackgroundProcessor)); return *this; }
1287         LDKBackgroundProcessor* operator &() { return &self; }
1288         LDKBackgroundProcessor* operator ->() { return &self; }
1289         const LDKBackgroundProcessor* operator &() const { return &self; }
1290         const LDKBackgroundProcessor* operator ->() const { return &self; }
1291 };
1292 class GossipSync {
1293 private:
1294         LDKGossipSync self;
1295 public:
1296         GossipSync(const GossipSync&) = delete;
1297         GossipSync(GossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(GossipSync)); }
1298         GossipSync(LDKGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipSync)); }
1299         operator LDKGossipSync() && { LDKGossipSync res = self; memset(&self, 0, sizeof(LDKGossipSync)); return res; }
1300         ~GossipSync() { GossipSync_free(self); }
1301         GossipSync& operator=(GossipSync&& o) { GossipSync_free(self); self = o.self; memset(&o, 0, sizeof(GossipSync)); return *this; }
1302         LDKGossipSync* operator &() { return &self; }
1303         LDKGossipSync* operator ->() { return &self; }
1304         const LDKGossipSync* operator &() const { return &self; }
1305         const LDKGossipSync* operator ->() const { return &self; }
1306 };
1307 class DefaultRouter {
1308 private:
1309         LDKDefaultRouter self;
1310 public:
1311         DefaultRouter(const DefaultRouter&) = delete;
1312         DefaultRouter(DefaultRouter&& o) : self(o.self) { memset(&o, 0, sizeof(DefaultRouter)); }
1313         DefaultRouter(LDKDefaultRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDefaultRouter)); }
1314         operator LDKDefaultRouter() && { LDKDefaultRouter res = self; memset(&self, 0, sizeof(LDKDefaultRouter)); return res; }
1315         ~DefaultRouter() { DefaultRouter_free(self); }
1316         DefaultRouter& operator=(DefaultRouter&& o) { DefaultRouter_free(self); self = o.self; memset(&o, 0, sizeof(DefaultRouter)); return *this; }
1317         LDKDefaultRouter* operator &() { return &self; }
1318         LDKDefaultRouter* operator ->() { return &self; }
1319         const LDKDefaultRouter* operator &() const { return &self; }
1320         const LDKDefaultRouter* operator ->() const { return &self; }
1321 };
1322 class Router {
1323 private:
1324         LDKRouter self;
1325 public:
1326         Router(const Router&) = delete;
1327         Router(Router&& o) : self(o.self) { memset(&o, 0, sizeof(Router)); }
1328         Router(LDKRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouter)); }
1329         operator LDKRouter() && { LDKRouter res = self; memset(&self, 0, sizeof(LDKRouter)); return res; }
1330         ~Router() { Router_free(self); }
1331         Router& operator=(Router&& o) { Router_free(self); self = o.self; memset(&o, 0, sizeof(Router)); return *this; }
1332         LDKRouter* operator &() { return &self; }
1333         LDKRouter* operator ->() { return &self; }
1334         const LDKRouter* operator &() const { return &self; }
1335         const LDKRouter* operator ->() const { return &self; }
1336         /**
1337          *  Finds a [`Route`] for a payment between the given `payer` and a payee.
1338          *
1339          *  The `payee` and the payment's value are given in [`RouteParameters::payment_params`]
1340          *  and [`RouteParameters::final_value_msat`], respectively.
1341          *
1342          *  Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
1343          */
1344         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);
1345         /**
1346          *  Finds a [`Route`] for a payment between the given `payer` and a payee.
1347          *
1348          *  The `payee` and the payment's value are given in [`RouteParameters::payment_params`]
1349          *  and [`RouteParameters::final_value_msat`], respectively.
1350          *
1351          *  Includes a [`PaymentHash`] and a [`PaymentId`] to be able to correlate the request with a specific
1352          *  payment.
1353          *
1354          *  Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
1355          */
1356         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);
1357 };
1358 class ScorerAccountingForInFlightHtlcs {
1359 private:
1360         LDKScorerAccountingForInFlightHtlcs self;
1361 public:
1362         ScorerAccountingForInFlightHtlcs(const ScorerAccountingForInFlightHtlcs&) = delete;
1363         ScorerAccountingForInFlightHtlcs(ScorerAccountingForInFlightHtlcs&& o) : self(o.self) { memset(&o, 0, sizeof(ScorerAccountingForInFlightHtlcs)); }
1364         ScorerAccountingForInFlightHtlcs(LDKScorerAccountingForInFlightHtlcs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScorerAccountingForInFlightHtlcs)); }
1365         operator LDKScorerAccountingForInFlightHtlcs() && { LDKScorerAccountingForInFlightHtlcs res = self; memset(&self, 0, sizeof(LDKScorerAccountingForInFlightHtlcs)); return res; }
1366         ~ScorerAccountingForInFlightHtlcs() { ScorerAccountingForInFlightHtlcs_free(self); }
1367         ScorerAccountingForInFlightHtlcs& operator=(ScorerAccountingForInFlightHtlcs&& o) { ScorerAccountingForInFlightHtlcs_free(self); self = o.self; memset(&o, 0, sizeof(ScorerAccountingForInFlightHtlcs)); return *this; }
1368         LDKScorerAccountingForInFlightHtlcs* operator &() { return &self; }
1369         LDKScorerAccountingForInFlightHtlcs* operator ->() { return &self; }
1370         const LDKScorerAccountingForInFlightHtlcs* operator &() const { return &self; }
1371         const LDKScorerAccountingForInFlightHtlcs* operator ->() const { return &self; }
1372 };
1373 class InFlightHtlcs {
1374 private:
1375         LDKInFlightHtlcs self;
1376 public:
1377         InFlightHtlcs(const InFlightHtlcs&) = delete;
1378         InFlightHtlcs(InFlightHtlcs&& o) : self(o.self) { memset(&o, 0, sizeof(InFlightHtlcs)); }
1379         InFlightHtlcs(LDKInFlightHtlcs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInFlightHtlcs)); }
1380         operator LDKInFlightHtlcs() && { LDKInFlightHtlcs res = self; memset(&self, 0, sizeof(LDKInFlightHtlcs)); return res; }
1381         ~InFlightHtlcs() { InFlightHtlcs_free(self); }
1382         InFlightHtlcs& operator=(InFlightHtlcs&& o) { InFlightHtlcs_free(self); self = o.self; memset(&o, 0, sizeof(InFlightHtlcs)); return *this; }
1383         LDKInFlightHtlcs* operator &() { return &self; }
1384         LDKInFlightHtlcs* operator ->() { return &self; }
1385         const LDKInFlightHtlcs* operator &() const { return &self; }
1386         const LDKInFlightHtlcs* operator ->() const { return &self; }
1387 };
1388 class RouteHop {
1389 private:
1390         LDKRouteHop self;
1391 public:
1392         RouteHop(const RouteHop&) = delete;
1393         RouteHop(RouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHop)); }
1394         RouteHop(LDKRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHop)); }
1395         operator LDKRouteHop() && { LDKRouteHop res = self; memset(&self, 0, sizeof(LDKRouteHop)); return res; }
1396         ~RouteHop() { RouteHop_free(self); }
1397         RouteHop& operator=(RouteHop&& o) { RouteHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHop)); return *this; }
1398         LDKRouteHop* operator &() { return &self; }
1399         LDKRouteHop* operator ->() { return &self; }
1400         const LDKRouteHop* operator &() const { return &self; }
1401         const LDKRouteHop* operator ->() const { return &self; }
1402 };
1403 class BlindedTail {
1404 private:
1405         LDKBlindedTail self;
1406 public:
1407         BlindedTail(const BlindedTail&) = delete;
1408         BlindedTail(BlindedTail&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedTail)); }
1409         BlindedTail(LDKBlindedTail&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedTail)); }
1410         operator LDKBlindedTail() && { LDKBlindedTail res = self; memset(&self, 0, sizeof(LDKBlindedTail)); return res; }
1411         ~BlindedTail() { BlindedTail_free(self); }
1412         BlindedTail& operator=(BlindedTail&& o) { BlindedTail_free(self); self = o.self; memset(&o, 0, sizeof(BlindedTail)); return *this; }
1413         LDKBlindedTail* operator &() { return &self; }
1414         LDKBlindedTail* operator ->() { return &self; }
1415         const LDKBlindedTail* operator &() const { return &self; }
1416         const LDKBlindedTail* operator ->() const { return &self; }
1417 };
1418 class Path {
1419 private:
1420         LDKPath self;
1421 public:
1422         Path(const Path&) = delete;
1423         Path(Path&& o) : self(o.self) { memset(&o, 0, sizeof(Path)); }
1424         Path(LDKPath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPath)); }
1425         operator LDKPath() && { LDKPath res = self; memset(&self, 0, sizeof(LDKPath)); return res; }
1426         ~Path() { Path_free(self); }
1427         Path& operator=(Path&& o) { Path_free(self); self = o.self; memset(&o, 0, sizeof(Path)); return *this; }
1428         LDKPath* operator &() { return &self; }
1429         LDKPath* operator ->() { return &self; }
1430         const LDKPath* operator &() const { return &self; }
1431         const LDKPath* operator ->() const { return &self; }
1432 };
1433 class Route {
1434 private:
1435         LDKRoute self;
1436 public:
1437         Route(const Route&) = delete;
1438         Route(Route&& o) : self(o.self) { memset(&o, 0, sizeof(Route)); }
1439         Route(LDKRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoute)); }
1440         operator LDKRoute() && { LDKRoute res = self; memset(&self, 0, sizeof(LDKRoute)); return res; }
1441         ~Route() { Route_free(self); }
1442         Route& operator=(Route&& o) { Route_free(self); self = o.self; memset(&o, 0, sizeof(Route)); return *this; }
1443         LDKRoute* operator &() { return &self; }
1444         LDKRoute* operator ->() { return &self; }
1445         const LDKRoute* operator &() const { return &self; }
1446         const LDKRoute* operator ->() const { return &self; }
1447 };
1448 class RouteParameters {
1449 private:
1450         LDKRouteParameters self;
1451 public:
1452         RouteParameters(const RouteParameters&) = delete;
1453         RouteParameters(RouteParameters&& o) : self(o.self) { memset(&o, 0, sizeof(RouteParameters)); }
1454         RouteParameters(LDKRouteParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteParameters)); }
1455         operator LDKRouteParameters() && { LDKRouteParameters res = self; memset(&self, 0, sizeof(LDKRouteParameters)); return res; }
1456         ~RouteParameters() { RouteParameters_free(self); }
1457         RouteParameters& operator=(RouteParameters&& o) { RouteParameters_free(self); self = o.self; memset(&o, 0, sizeof(RouteParameters)); return *this; }
1458         LDKRouteParameters* operator &() { return &self; }
1459         LDKRouteParameters* operator ->() { return &self; }
1460         const LDKRouteParameters* operator &() const { return &self; }
1461         const LDKRouteParameters* operator ->() const { return &self; }
1462 };
1463 class PaymentParameters {
1464 private:
1465         LDKPaymentParameters self;
1466 public:
1467         PaymentParameters(const PaymentParameters&) = delete;
1468         PaymentParameters(PaymentParameters&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentParameters)); }
1469         PaymentParameters(LDKPaymentParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentParameters)); }
1470         operator LDKPaymentParameters() && { LDKPaymentParameters res = self; memset(&self, 0, sizeof(LDKPaymentParameters)); return res; }
1471         ~PaymentParameters() { PaymentParameters_free(self); }
1472         PaymentParameters& operator=(PaymentParameters&& o) { PaymentParameters_free(self); self = o.self; memset(&o, 0, sizeof(PaymentParameters)); return *this; }
1473         LDKPaymentParameters* operator &() { return &self; }
1474         LDKPaymentParameters* operator ->() { return &self; }
1475         const LDKPaymentParameters* operator &() const { return &self; }
1476         const LDKPaymentParameters* operator ->() const { return &self; }
1477 };
1478 class Payee {
1479 private:
1480         LDKPayee self;
1481 public:
1482         Payee(const Payee&) = delete;
1483         Payee(Payee&& o) : self(o.self) { memset(&o, 0, sizeof(Payee)); }
1484         Payee(LDKPayee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayee)); }
1485         operator LDKPayee() && { LDKPayee res = self; memset(&self, 0, sizeof(LDKPayee)); return res; }
1486         ~Payee() { Payee_free(self); }
1487         Payee& operator=(Payee&& o) { Payee_free(self); self = o.self; memset(&o, 0, sizeof(Payee)); return *this; }
1488         LDKPayee* operator &() { return &self; }
1489         LDKPayee* operator ->() { return &self; }
1490         const LDKPayee* operator &() const { return &self; }
1491         const LDKPayee* operator ->() const { return &self; }
1492 };
1493 class RouteHint {
1494 private:
1495         LDKRouteHint self;
1496 public:
1497         RouteHint(const RouteHint&) = delete;
1498         RouteHint(RouteHint&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHint)); }
1499         RouteHint(LDKRouteHint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHint)); }
1500         operator LDKRouteHint() && { LDKRouteHint res = self; memset(&self, 0, sizeof(LDKRouteHint)); return res; }
1501         ~RouteHint() { RouteHint_free(self); }
1502         RouteHint& operator=(RouteHint&& o) { RouteHint_free(self); self = o.self; memset(&o, 0, sizeof(RouteHint)); return *this; }
1503         LDKRouteHint* operator &() { return &self; }
1504         LDKRouteHint* operator ->() { return &self; }
1505         const LDKRouteHint* operator &() const { return &self; }
1506         const LDKRouteHint* operator ->() const { return &self; }
1507 };
1508 class RouteHintHop {
1509 private:
1510         LDKRouteHintHop self;
1511 public:
1512         RouteHintHop(const RouteHintHop&) = delete;
1513         RouteHintHop(RouteHintHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHintHop)); }
1514         RouteHintHop(LDKRouteHintHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHintHop)); }
1515         operator LDKRouteHintHop() && { LDKRouteHintHop res = self; memset(&self, 0, sizeof(LDKRouteHintHop)); return res; }
1516         ~RouteHintHop() { RouteHintHop_free(self); }
1517         RouteHintHop& operator=(RouteHintHop&& o) { RouteHintHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHintHop)); return *this; }
1518         LDKRouteHintHop* operator &() { return &self; }
1519         LDKRouteHintHop* operator ->() { return &self; }
1520         const LDKRouteHintHop* operator &() const { return &self; }
1521         const LDKRouteHintHop* operator ->() const { return &self; }
1522 };
1523 class ScoreLookUp {
1524 private:
1525         LDKScoreLookUp self;
1526 public:
1527         ScoreLookUp(const ScoreLookUp&) = delete;
1528         ScoreLookUp(ScoreLookUp&& o) : self(o.self) { memset(&o, 0, sizeof(ScoreLookUp)); }
1529         ScoreLookUp(LDKScoreLookUp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScoreLookUp)); }
1530         operator LDKScoreLookUp() && { LDKScoreLookUp res = self; memset(&self, 0, sizeof(LDKScoreLookUp)); return res; }
1531         ~ScoreLookUp() { ScoreLookUp_free(self); }
1532         ScoreLookUp& operator=(ScoreLookUp&& o) { ScoreLookUp_free(self); self = o.self; memset(&o, 0, sizeof(ScoreLookUp)); return *this; }
1533         LDKScoreLookUp* operator &() { return &self; }
1534         LDKScoreLookUp* operator ->() { return &self; }
1535         const LDKScoreLookUp* operator &() const { return &self; }
1536         const LDKScoreLookUp* operator ->() const { return &self; }
1537         /**
1538          *  Returns the fee in msats willing to be paid to avoid routing `send_amt_msat` through the
1539          *  given channel in the direction from `source` to `target`.
1540          *
1541          *  The channel's capacity (less any other MPP parts that are also being considered for use in
1542          *  the same payment) is given by `capacity_msat`. It may be determined from various sources
1543          *  such as a chain data, network gossip, or invoice hints. For invoice hints, a capacity near
1544          *  [`u64::max_value`] is given to indicate sufficient capacity for the invoice's full amount.
1545          *  Thus, implementations should be overflow-safe.
1546          */
1547         inline uint64_t channel_penalty_msat(uint64_t short_channel_id, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params);
1548 };
1549 class ScoreUpdate {
1550 private:
1551         LDKScoreUpdate self;
1552 public:
1553         ScoreUpdate(const ScoreUpdate&) = delete;
1554         ScoreUpdate(ScoreUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ScoreUpdate)); }
1555         ScoreUpdate(LDKScoreUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScoreUpdate)); }
1556         operator LDKScoreUpdate() && { LDKScoreUpdate res = self; memset(&self, 0, sizeof(LDKScoreUpdate)); return res; }
1557         ~ScoreUpdate() { ScoreUpdate_free(self); }
1558         ScoreUpdate& operator=(ScoreUpdate&& o) { ScoreUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ScoreUpdate)); return *this; }
1559         LDKScoreUpdate* operator &() { return &self; }
1560         LDKScoreUpdate* operator ->() { return &self; }
1561         const LDKScoreUpdate* operator &() const { return &self; }
1562         const LDKScoreUpdate* operator ->() const { return &self; }
1563         /**
1564          *  Handles updating channel penalties after failing to route through a channel.
1565          */
1566         inline void payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id);
1567         /**
1568          *  Handles updating channel penalties after successfully routing along a path.
1569          */
1570         inline void payment_path_successful(const struct LDKPath *NONNULL_PTR path);
1571         /**
1572          *  Handles updating channel penalties after a probe over the given path failed.
1573          */
1574         inline void probe_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id);
1575         /**
1576          *  Handles updating channel penalties after a probe over the given path succeeded.
1577          */
1578         inline void probe_successful(const struct LDKPath *NONNULL_PTR path);
1579 };
1580 class Score {
1581 private:
1582         LDKScore self;
1583 public:
1584         Score(const Score&) = delete;
1585         Score(Score&& o) : self(o.self) { memset(&o, 0, sizeof(Score)); }
1586         Score(LDKScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScore)); }
1587         operator LDKScore() && { LDKScore res = self; memset(&self, 0, sizeof(LDKScore)); return res; }
1588         ~Score() { Score_free(self); }
1589         Score& operator=(Score&& o) { Score_free(self); self = o.self; memset(&o, 0, sizeof(Score)); return *this; }
1590         LDKScore* operator &() { return &self; }
1591         LDKScore* operator ->() { return &self; }
1592         const LDKScore* operator &() const { return &self; }
1593         const LDKScore* operator ->() const { return &self; }
1594 };
1595 class LockableScore {
1596 private:
1597         LDKLockableScore self;
1598 public:
1599         LockableScore(const LockableScore&) = delete;
1600         LockableScore(LockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(LockableScore)); }
1601         LockableScore(LDKLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockableScore)); }
1602         operator LDKLockableScore() && { LDKLockableScore res = self; memset(&self, 0, sizeof(LDKLockableScore)); return res; }
1603         ~LockableScore() { LockableScore_free(self); }
1604         LockableScore& operator=(LockableScore&& o) { LockableScore_free(self); self = o.self; memset(&o, 0, sizeof(LockableScore)); return *this; }
1605         LDKLockableScore* operator &() { return &self; }
1606         LDKLockableScore* operator ->() { return &self; }
1607         const LDKLockableScore* operator &() const { return &self; }
1608         const LDKLockableScore* operator ->() const { return &self; }
1609         /**
1610          *  Returns read locked scorer.
1611          */
1612         inline LDK::ScoreLookUp read_lock();
1613         /**
1614          *  Returns write locked scorer.
1615          */
1616         inline LDK::ScoreUpdate write_lock();
1617 };
1618 class WriteableScore {
1619 private:
1620         LDKWriteableScore self;
1621 public:
1622         WriteableScore(const WriteableScore&) = delete;
1623         WriteableScore(WriteableScore&& o) : self(o.self) { memset(&o, 0, sizeof(WriteableScore)); }
1624         WriteableScore(LDKWriteableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWriteableScore)); }
1625         operator LDKWriteableScore() && { LDKWriteableScore res = self; memset(&self, 0, sizeof(LDKWriteableScore)); return res; }
1626         ~WriteableScore() { WriteableScore_free(self); }
1627         WriteableScore& operator=(WriteableScore&& o) { WriteableScore_free(self); self = o.self; memset(&o, 0, sizeof(WriteableScore)); return *this; }
1628         LDKWriteableScore* operator &() { return &self; }
1629         LDKWriteableScore* operator ->() { return &self; }
1630         const LDKWriteableScore* operator &() const { return &self; }
1631         const LDKWriteableScore* operator ->() const { return &self; }
1632 };
1633 class MultiThreadedLockableScore {
1634 private:
1635         LDKMultiThreadedLockableScore self;
1636 public:
1637         MultiThreadedLockableScore(const MultiThreadedLockableScore&) = delete;
1638         MultiThreadedLockableScore(MultiThreadedLockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedLockableScore)); }
1639         MultiThreadedLockableScore(LDKMultiThreadedLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedLockableScore)); }
1640         operator LDKMultiThreadedLockableScore() && { LDKMultiThreadedLockableScore res = self; memset(&self, 0, sizeof(LDKMultiThreadedLockableScore)); return res; }
1641         ~MultiThreadedLockableScore() { MultiThreadedLockableScore_free(self); }
1642         MultiThreadedLockableScore& operator=(MultiThreadedLockableScore&& o) { MultiThreadedLockableScore_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedLockableScore)); return *this; }
1643         LDKMultiThreadedLockableScore* operator &() { return &self; }
1644         LDKMultiThreadedLockableScore* operator ->() { return &self; }
1645         const LDKMultiThreadedLockableScore* operator &() const { return &self; }
1646         const LDKMultiThreadedLockableScore* operator ->() const { return &self; }
1647 };
1648 class MultiThreadedScoreLockRead {
1649 private:
1650         LDKMultiThreadedScoreLockRead self;
1651 public:
1652         MultiThreadedScoreLockRead(const MultiThreadedScoreLockRead&) = delete;
1653         MultiThreadedScoreLockRead(MultiThreadedScoreLockRead&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedScoreLockRead)); }
1654         MultiThreadedScoreLockRead(LDKMultiThreadedScoreLockRead&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedScoreLockRead)); }
1655         operator LDKMultiThreadedScoreLockRead() && { LDKMultiThreadedScoreLockRead res = self; memset(&self, 0, sizeof(LDKMultiThreadedScoreLockRead)); return res; }
1656         ~MultiThreadedScoreLockRead() { MultiThreadedScoreLockRead_free(self); }
1657         MultiThreadedScoreLockRead& operator=(MultiThreadedScoreLockRead&& o) { MultiThreadedScoreLockRead_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedScoreLockRead)); return *this; }
1658         LDKMultiThreadedScoreLockRead* operator &() { return &self; }
1659         LDKMultiThreadedScoreLockRead* operator ->() { return &self; }
1660         const LDKMultiThreadedScoreLockRead* operator &() const { return &self; }
1661         const LDKMultiThreadedScoreLockRead* operator ->() const { return &self; }
1662 };
1663 class MultiThreadedScoreLockWrite {
1664 private:
1665         LDKMultiThreadedScoreLockWrite self;
1666 public:
1667         MultiThreadedScoreLockWrite(const MultiThreadedScoreLockWrite&) = delete;
1668         MultiThreadedScoreLockWrite(MultiThreadedScoreLockWrite&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedScoreLockWrite)); }
1669         MultiThreadedScoreLockWrite(LDKMultiThreadedScoreLockWrite&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedScoreLockWrite)); }
1670         operator LDKMultiThreadedScoreLockWrite() && { LDKMultiThreadedScoreLockWrite res = self; memset(&self, 0, sizeof(LDKMultiThreadedScoreLockWrite)); return res; }
1671         ~MultiThreadedScoreLockWrite() { MultiThreadedScoreLockWrite_free(self); }
1672         MultiThreadedScoreLockWrite& operator=(MultiThreadedScoreLockWrite&& o) { MultiThreadedScoreLockWrite_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedScoreLockWrite)); return *this; }
1673         LDKMultiThreadedScoreLockWrite* operator &() { return &self; }
1674         LDKMultiThreadedScoreLockWrite* operator ->() { return &self; }
1675         const LDKMultiThreadedScoreLockWrite* operator &() const { return &self; }
1676         const LDKMultiThreadedScoreLockWrite* operator ->() const { return &self; }
1677 };
1678 class ChannelUsage {
1679 private:
1680         LDKChannelUsage self;
1681 public:
1682         ChannelUsage(const ChannelUsage&) = delete;
1683         ChannelUsage(ChannelUsage&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUsage)); }
1684         ChannelUsage(LDKChannelUsage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUsage)); }
1685         operator LDKChannelUsage() && { LDKChannelUsage res = self; memset(&self, 0, sizeof(LDKChannelUsage)); return res; }
1686         ~ChannelUsage() { ChannelUsage_free(self); }
1687         ChannelUsage& operator=(ChannelUsage&& o) { ChannelUsage_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUsage)); return *this; }
1688         LDKChannelUsage* operator &() { return &self; }
1689         LDKChannelUsage* operator ->() { return &self; }
1690         const LDKChannelUsage* operator &() const { return &self; }
1691         const LDKChannelUsage* operator ->() const { return &self; }
1692 };
1693 class FixedPenaltyScorer {
1694 private:
1695         LDKFixedPenaltyScorer self;
1696 public:
1697         FixedPenaltyScorer(const FixedPenaltyScorer&) = delete;
1698         FixedPenaltyScorer(FixedPenaltyScorer&& o) : self(o.self) { memset(&o, 0, sizeof(FixedPenaltyScorer)); }
1699         FixedPenaltyScorer(LDKFixedPenaltyScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFixedPenaltyScorer)); }
1700         operator LDKFixedPenaltyScorer() && { LDKFixedPenaltyScorer res = self; memset(&self, 0, sizeof(LDKFixedPenaltyScorer)); return res; }
1701         ~FixedPenaltyScorer() { FixedPenaltyScorer_free(self); }
1702         FixedPenaltyScorer& operator=(FixedPenaltyScorer&& o) { FixedPenaltyScorer_free(self); self = o.self; memset(&o, 0, sizeof(FixedPenaltyScorer)); return *this; }
1703         LDKFixedPenaltyScorer* operator &() { return &self; }
1704         LDKFixedPenaltyScorer* operator ->() { return &self; }
1705         const LDKFixedPenaltyScorer* operator &() const { return &self; }
1706         const LDKFixedPenaltyScorer* operator ->() const { return &self; }
1707 };
1708 class ProbabilisticScorer {
1709 private:
1710         LDKProbabilisticScorer self;
1711 public:
1712         ProbabilisticScorer(const ProbabilisticScorer&) = delete;
1713         ProbabilisticScorer(ProbabilisticScorer&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScorer)); }
1714         ProbabilisticScorer(LDKProbabilisticScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScorer)); }
1715         operator LDKProbabilisticScorer() && { LDKProbabilisticScorer res = self; memset(&self, 0, sizeof(LDKProbabilisticScorer)); return res; }
1716         ~ProbabilisticScorer() { ProbabilisticScorer_free(self); }
1717         ProbabilisticScorer& operator=(ProbabilisticScorer&& o) { ProbabilisticScorer_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScorer)); return *this; }
1718         LDKProbabilisticScorer* operator &() { return &self; }
1719         LDKProbabilisticScorer* operator ->() { return &self; }
1720         const LDKProbabilisticScorer* operator &() const { return &self; }
1721         const LDKProbabilisticScorer* operator ->() const { return &self; }
1722 };
1723 class ProbabilisticScoringFeeParameters {
1724 private:
1725         LDKProbabilisticScoringFeeParameters self;
1726 public:
1727         ProbabilisticScoringFeeParameters(const ProbabilisticScoringFeeParameters&) = delete;
1728         ProbabilisticScoringFeeParameters(ProbabilisticScoringFeeParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScoringFeeParameters)); }
1729         ProbabilisticScoringFeeParameters(LDKProbabilisticScoringFeeParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScoringFeeParameters)); }
1730         operator LDKProbabilisticScoringFeeParameters() && { LDKProbabilisticScoringFeeParameters res = self; memset(&self, 0, sizeof(LDKProbabilisticScoringFeeParameters)); return res; }
1731         ~ProbabilisticScoringFeeParameters() { ProbabilisticScoringFeeParameters_free(self); }
1732         ProbabilisticScoringFeeParameters& operator=(ProbabilisticScoringFeeParameters&& o) { ProbabilisticScoringFeeParameters_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScoringFeeParameters)); return *this; }
1733         LDKProbabilisticScoringFeeParameters* operator &() { return &self; }
1734         LDKProbabilisticScoringFeeParameters* operator ->() { return &self; }
1735         const LDKProbabilisticScoringFeeParameters* operator &() const { return &self; }
1736         const LDKProbabilisticScoringFeeParameters* operator ->() const { return &self; }
1737 };
1738 class ProbabilisticScoringDecayParameters {
1739 private:
1740         LDKProbabilisticScoringDecayParameters self;
1741 public:
1742         ProbabilisticScoringDecayParameters(const ProbabilisticScoringDecayParameters&) = delete;
1743         ProbabilisticScoringDecayParameters(ProbabilisticScoringDecayParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScoringDecayParameters)); }
1744         ProbabilisticScoringDecayParameters(LDKProbabilisticScoringDecayParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScoringDecayParameters)); }
1745         operator LDKProbabilisticScoringDecayParameters() && { LDKProbabilisticScoringDecayParameters res = self; memset(&self, 0, sizeof(LDKProbabilisticScoringDecayParameters)); return res; }
1746         ~ProbabilisticScoringDecayParameters() { ProbabilisticScoringDecayParameters_free(self); }
1747         ProbabilisticScoringDecayParameters& operator=(ProbabilisticScoringDecayParameters&& o) { ProbabilisticScoringDecayParameters_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScoringDecayParameters)); return *this; }
1748         LDKProbabilisticScoringDecayParameters* operator &() { return &self; }
1749         LDKProbabilisticScoringDecayParameters* operator ->() { return &self; }
1750         const LDKProbabilisticScoringDecayParameters* operator &() const { return &self; }
1751         const LDKProbabilisticScoringDecayParameters* operator ->() const { return &self; }
1752 };
1753 class BestBlock {
1754 private:
1755         LDKBestBlock self;
1756 public:
1757         BestBlock(const BestBlock&) = delete;
1758         BestBlock(BestBlock&& o) : self(o.self) { memset(&o, 0, sizeof(BestBlock)); }
1759         BestBlock(LDKBestBlock&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBestBlock)); }
1760         operator LDKBestBlock() && { LDKBestBlock res = self; memset(&self, 0, sizeof(LDKBestBlock)); return res; }
1761         ~BestBlock() { BestBlock_free(self); }
1762         BestBlock& operator=(BestBlock&& o) { BestBlock_free(self); self = o.self; memset(&o, 0, sizeof(BestBlock)); return *this; }
1763         LDKBestBlock* operator &() { return &self; }
1764         LDKBestBlock* operator ->() { return &self; }
1765         const LDKBestBlock* operator &() const { return &self; }
1766         const LDKBestBlock* operator ->() const { return &self; }
1767 };
1768 class Listen {
1769 private:
1770         LDKListen self;
1771 public:
1772         Listen(const Listen&) = delete;
1773         Listen(Listen&& o) : self(o.self) { memset(&o, 0, sizeof(Listen)); }
1774         Listen(LDKListen&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKListen)); }
1775         operator LDKListen() && { LDKListen res = self; memset(&self, 0, sizeof(LDKListen)); return res; }
1776         ~Listen() { Listen_free(self); }
1777         Listen& operator=(Listen&& o) { Listen_free(self); self = o.self; memset(&o, 0, sizeof(Listen)); return *this; }
1778         LDKListen* operator &() { return &self; }
1779         LDKListen* operator ->() { return &self; }
1780         const LDKListen* operator &() const { return &self; }
1781         const LDKListen* operator ->() const { return &self; }
1782         /**
1783          *  Notifies the listener that a block was added at the given height, with the transaction data
1784          *  possibly filtered.
1785          */
1786         inline void filtered_block_connected(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
1787         /**
1788          *  Notifies the listener that a block was added at the given height.
1789          */
1790         inline void block_connected(struct LDKu8slice block, uint32_t height);
1791         /**
1792          *  Notifies the listener that a block was removed at the given height.
1793          */
1794         inline void block_disconnected(const uint8_t (*header)[80], uint32_t height);
1795 };
1796 class Confirm {
1797 private:
1798         LDKConfirm self;
1799 public:
1800         Confirm(const Confirm&) = delete;
1801         Confirm(Confirm&& o) : self(o.self) { memset(&o, 0, sizeof(Confirm)); }
1802         Confirm(LDKConfirm&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirm)); }
1803         operator LDKConfirm() && { LDKConfirm res = self; memset(&self, 0, sizeof(LDKConfirm)); return res; }
1804         ~Confirm() { Confirm_free(self); }
1805         Confirm& operator=(Confirm&& o) { Confirm_free(self); self = o.self; memset(&o, 0, sizeof(Confirm)); return *this; }
1806         LDKConfirm* operator &() { return &self; }
1807         LDKConfirm* operator ->() { return &self; }
1808         const LDKConfirm* operator &() const { return &self; }
1809         const LDKConfirm* operator ->() const { return &self; }
1810         /**
1811          *  Notifies LDK of transactions confirmed in a block with a given header and height.
1812          *
1813          *  Must be called for any transactions registered by [`Filter::register_tx`] or any
1814          *  transactions spending an output registered by [`Filter::register_output`]. Such transactions
1815          *  appearing in the same block do not need to be included in the same call; instead, multiple
1816          *  calls with additional transactions may be made so long as they are made in [chain order].
1817          *
1818          *  May be called before or after [`best_block_updated`] for the corresponding block. However,
1819          *  in the event of a chain reorganization, it must not be called with a `header` that is no
1820          *  longer in the chain as of the last call to [`best_block_updated`].
1821          *
1822          *  [chain order]: Confirm#order
1823          *  [`best_block_updated`]: Self::best_block_updated
1824          */
1825         inline void transactions_confirmed(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
1826         /**
1827          *  Notifies LDK of a transaction that is no longer confirmed as result of a chain reorganization.
1828          *
1829          *  Must be called for any transaction returned by [`get_relevant_txids`] if it has been
1830          *  reorganized out of the best chain or if it is no longer confirmed in the block with the
1831          *  given block hash. Once called, the given transaction will not be returned
1832          *  by [`get_relevant_txids`], unless it has been reconfirmed via [`transactions_confirmed`].
1833          *
1834          *  [`get_relevant_txids`]: Self::get_relevant_txids
1835          *  [`transactions_confirmed`]: Self::transactions_confirmed
1836          */
1837         inline void transaction_unconfirmed(const uint8_t (*txid)[32]);
1838         /**
1839          *  Notifies LDK of an update to the best header connected at the given height.
1840          *
1841          *  Must be called whenever a new chain tip becomes available. May be skipped for intermediary
1842          *  blocks.
1843          */
1844         inline void best_block_updated(const uint8_t (*header)[80], uint32_t height);
1845         /**
1846          *  Returns transactions that must be monitored for reorganization out of the chain along
1847          *  with the hash of the block as part of which it had been previously confirmed.
1848          *
1849          *  Note that the returned `Option<BlockHash>` might be `None` for channels created with LDK
1850          *  0.0.112 and prior, in which case you need to manually track previous confirmations.
1851          *
1852          *  Will include any transactions passed to [`transactions_confirmed`] that have insufficient
1853          *  confirmations to be safe from a chain reorganization. Will not include any transactions
1854          *  passed to [`transaction_unconfirmed`], unless later reconfirmed.
1855          *
1856          *  Must be called to determine the subset of transactions that must be monitored for
1857          *  reorganization. Will be idempotent between calls but may change as a result of calls to the
1858          *  other interface methods. Thus, this is useful to determine which transactions must be
1859          *  given to [`transaction_unconfirmed`].
1860          *
1861          *  If any of the returned transactions are confirmed in a block other than the one with the
1862          *  given hash, they need to be unconfirmed and reconfirmed via [`transaction_unconfirmed`] and
1863          *  [`transactions_confirmed`], respectively.
1864          *
1865          *  [`transactions_confirmed`]: Self::transactions_confirmed
1866          *  [`transaction_unconfirmed`]: Self::transaction_unconfirmed
1867          */
1868         inline LDK::CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ get_relevant_txids();
1869 };
1870 class ChannelMonitorUpdateStatus {
1871 private:
1872         LDKChannelMonitorUpdateStatus self;
1873 public:
1874         ChannelMonitorUpdateStatus(const ChannelMonitorUpdateStatus&) = delete;
1875         ChannelMonitorUpdateStatus(ChannelMonitorUpdateStatus&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateStatus)); }
1876         ChannelMonitorUpdateStatus(LDKChannelMonitorUpdateStatus&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateStatus)); }
1877         operator LDKChannelMonitorUpdateStatus() && { LDKChannelMonitorUpdateStatus res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateStatus)); return res; }
1878         ChannelMonitorUpdateStatus& operator=(ChannelMonitorUpdateStatus&& o) { self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdateStatus)); return *this; }
1879         LDKChannelMonitorUpdateStatus* operator &() { return &self; }
1880         LDKChannelMonitorUpdateStatus* operator ->() { return &self; }
1881         const LDKChannelMonitorUpdateStatus* operator &() const { return &self; }
1882         const LDKChannelMonitorUpdateStatus* operator ->() const { return &self; }
1883 };
1884 class Watch {
1885 private:
1886         LDKWatch self;
1887 public:
1888         Watch(const Watch&) = delete;
1889         Watch(Watch&& o) : self(o.self) { memset(&o, 0, sizeof(Watch)); }
1890         Watch(LDKWatch&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatch)); }
1891         operator LDKWatch() && { LDKWatch res = self; memset(&self, 0, sizeof(LDKWatch)); return res; }
1892         ~Watch() { Watch_free(self); }
1893         Watch& operator=(Watch&& o) { Watch_free(self); self = o.self; memset(&o, 0, sizeof(Watch)); return *this; }
1894         LDKWatch* operator &() { return &self; }
1895         LDKWatch* operator ->() { return &self; }
1896         const LDKWatch* operator &() const { return &self; }
1897         const LDKWatch* operator ->() const { return &self; }
1898         /**
1899          *  Watches a channel identified by `funding_txo` using `monitor`.
1900          *
1901          *  Implementations are responsible for watching the chain for the funding transaction along
1902          *  with any spends of outputs returned by [`get_outputs_to_watch`]. In practice, this means
1903          *  calling [`block_connected`] and [`block_disconnected`] on the monitor.
1904          *
1905          *  A return of `Err(())` indicates that the channel should immediately be force-closed without
1906          *  broadcasting the funding transaction.
1907          *
1908          *  If the given `funding_txo` has previously been registered via `watch_channel`, `Err(())`
1909          *  must be returned.
1910          *
1911          *  [`get_outputs_to_watch`]: channelmonitor::ChannelMonitor::get_outputs_to_watch
1912          *  [`block_connected`]: channelmonitor::ChannelMonitor::block_connected
1913          *  [`block_disconnected`]: channelmonitor::ChannelMonitor::block_disconnected
1914          */
1915         inline LDK::CResult_ChannelMonitorUpdateStatusNoneZ watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor);
1916         /**
1917          *  Updates a channel identified by `funding_txo` by applying `update` to its monitor.
1918          *
1919          *  Implementations must call [`ChannelMonitor::update_monitor`] with the given update. This
1920          *  may fail (returning an `Err(())`), in which case this should return
1921          *  [`ChannelMonitorUpdateStatus::InProgress`] (and the update should never complete). This
1922          *  generally implies the channel has been closed (either by the funding outpoint being spent
1923          *  on-chain or the [`ChannelMonitor`] having decided to do so and broadcasted a transaction),
1924          *  and the [`ChannelManager`] state will be updated once it sees the funding spend on-chain.
1925          *
1926          *  In general, persistence failures should be retried after returning
1927          *  [`ChannelMonitorUpdateStatus::InProgress`] and eventually complete. If a failure truly
1928          *  cannot be retried, the node should shut down immediately after returning
1929          *  [`ChannelMonitorUpdateStatus::UnrecoverableError`], see its documentation for more info.
1930          *
1931          *  [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
1932          */
1933         inline LDK::ChannelMonitorUpdateStatus update_channel(struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update);
1934         /**
1935          *  Returns any monitor events since the last call. Subsequent calls must only return new
1936          *  events.
1937          *
1938          *  Note that after any block- or transaction-connection calls to a [`ChannelMonitor`], no
1939          *  further events may be returned here until the [`ChannelMonitor`] has been fully persisted
1940          *  to disk.
1941          *
1942          *  For details on asynchronous [`ChannelMonitor`] updating and returning
1943          *  [`MonitorEvent::Completed`] here, see [`ChannelMonitorUpdateStatus::InProgress`].
1944          */
1945         inline LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ release_pending_monitor_events();
1946 };
1947 class Filter {
1948 private:
1949         LDKFilter self;
1950 public:
1951         Filter(const Filter&) = delete;
1952         Filter(Filter&& o) : self(o.self) { memset(&o, 0, sizeof(Filter)); }
1953         Filter(LDKFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilter)); }
1954         operator LDKFilter() && { LDKFilter res = self; memset(&self, 0, sizeof(LDKFilter)); return res; }
1955         ~Filter() { Filter_free(self); }
1956         Filter& operator=(Filter&& o) { Filter_free(self); self = o.self; memset(&o, 0, sizeof(Filter)); return *this; }
1957         LDKFilter* operator &() { return &self; }
1958         LDKFilter* operator ->() { return &self; }
1959         const LDKFilter* operator &() const { return &self; }
1960         const LDKFilter* operator ->() const { return &self; }
1961         /**
1962          *  Registers interest in a transaction with `txid` and having an output with `script_pubkey` as
1963          *  a spending condition.
1964          */
1965         inline void register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey);
1966         /**
1967          *  Registers interest in spends of a transaction output.
1968          *
1969          *  Note that this method might be called during processing of a new block. You therefore need
1970          *  to ensure that also dependent output spents within an already connected block are correctly
1971          *  handled, e.g., by re-scanning the block in question whenever new outputs have been
1972          *  registered mid-processing.
1973          */
1974         inline void register_output(struct LDKWatchedOutput output);
1975 };
1976 class WatchedOutput {
1977 private:
1978         LDKWatchedOutput self;
1979 public:
1980         WatchedOutput(const WatchedOutput&) = delete;
1981         WatchedOutput(WatchedOutput&& o) : self(o.self) { memset(&o, 0, sizeof(WatchedOutput)); }
1982         WatchedOutput(LDKWatchedOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatchedOutput)); }
1983         operator LDKWatchedOutput() && { LDKWatchedOutput res = self; memset(&self, 0, sizeof(LDKWatchedOutput)); return res; }
1984         ~WatchedOutput() { WatchedOutput_free(self); }
1985         WatchedOutput& operator=(WatchedOutput&& o) { WatchedOutput_free(self); self = o.self; memset(&o, 0, sizeof(WatchedOutput)); return *this; }
1986         LDKWatchedOutput* operator &() { return &self; }
1987         LDKWatchedOutput* operator ->() { return &self; }
1988         const LDKWatchedOutput* operator &() const { return &self; }
1989         const LDKWatchedOutput* operator ->() const { return &self; }
1990 };
1991 class InitFeatures {
1992 private:
1993         LDKInitFeatures self;
1994 public:
1995         InitFeatures(const InitFeatures&) = delete;
1996         InitFeatures(InitFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InitFeatures)); }
1997         InitFeatures(LDKInitFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInitFeatures)); }
1998         operator LDKInitFeatures() && { LDKInitFeatures res = self; memset(&self, 0, sizeof(LDKInitFeatures)); return res; }
1999         ~InitFeatures() { InitFeatures_free(self); }
2000         InitFeatures& operator=(InitFeatures&& o) { InitFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InitFeatures)); return *this; }
2001         LDKInitFeatures* operator &() { return &self; }
2002         LDKInitFeatures* operator ->() { return &self; }
2003         const LDKInitFeatures* operator &() const { return &self; }
2004         const LDKInitFeatures* operator ->() const { return &self; }
2005 };
2006 class NodeFeatures {
2007 private:
2008         LDKNodeFeatures self;
2009 public:
2010         NodeFeatures(const NodeFeatures&) = delete;
2011         NodeFeatures(NodeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(NodeFeatures)); }
2012         NodeFeatures(LDKNodeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeFeatures)); }
2013         operator LDKNodeFeatures() && { LDKNodeFeatures res = self; memset(&self, 0, sizeof(LDKNodeFeatures)); return res; }
2014         ~NodeFeatures() { NodeFeatures_free(self); }
2015         NodeFeatures& operator=(NodeFeatures&& o) { NodeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(NodeFeatures)); return *this; }
2016         LDKNodeFeatures* operator &() { return &self; }
2017         LDKNodeFeatures* operator ->() { return &self; }
2018         const LDKNodeFeatures* operator &() const { return &self; }
2019         const LDKNodeFeatures* operator ->() const { return &self; }
2020 };
2021 class ChannelFeatures {
2022 private:
2023         LDKChannelFeatures self;
2024 public:
2025         ChannelFeatures(const ChannelFeatures&) = delete;
2026         ChannelFeatures(ChannelFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelFeatures)); }
2027         ChannelFeatures(LDKChannelFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelFeatures)); }
2028         operator LDKChannelFeatures() && { LDKChannelFeatures res = self; memset(&self, 0, sizeof(LDKChannelFeatures)); return res; }
2029         ~ChannelFeatures() { ChannelFeatures_free(self); }
2030         ChannelFeatures& operator=(ChannelFeatures&& o) { ChannelFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelFeatures)); return *this; }
2031         LDKChannelFeatures* operator &() { return &self; }
2032         LDKChannelFeatures* operator ->() { return &self; }
2033         const LDKChannelFeatures* operator &() const { return &self; }
2034         const LDKChannelFeatures* operator ->() const { return &self; }
2035 };
2036 class Bolt11InvoiceFeatures {
2037 private:
2038         LDKBolt11InvoiceFeatures self;
2039 public:
2040         Bolt11InvoiceFeatures(const Bolt11InvoiceFeatures&) = delete;
2041         Bolt11InvoiceFeatures(Bolt11InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11InvoiceFeatures)); }
2042         Bolt11InvoiceFeatures(LDKBolt11InvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11InvoiceFeatures)); }
2043         operator LDKBolt11InvoiceFeatures() && { LDKBolt11InvoiceFeatures res = self; memset(&self, 0, sizeof(LDKBolt11InvoiceFeatures)); return res; }
2044         ~Bolt11InvoiceFeatures() { Bolt11InvoiceFeatures_free(self); }
2045         Bolt11InvoiceFeatures& operator=(Bolt11InvoiceFeatures&& o) { Bolt11InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11InvoiceFeatures)); return *this; }
2046         LDKBolt11InvoiceFeatures* operator &() { return &self; }
2047         LDKBolt11InvoiceFeatures* operator ->() { return &self; }
2048         const LDKBolt11InvoiceFeatures* operator &() const { return &self; }
2049         const LDKBolt11InvoiceFeatures* operator ->() const { return &self; }
2050 };
2051 class OfferFeatures {
2052 private:
2053         LDKOfferFeatures self;
2054 public:
2055         OfferFeatures(const OfferFeatures&) = delete;
2056         OfferFeatures(OfferFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(OfferFeatures)); }
2057         OfferFeatures(LDKOfferFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferFeatures)); }
2058         operator LDKOfferFeatures() && { LDKOfferFeatures res = self; memset(&self, 0, sizeof(LDKOfferFeatures)); return res; }
2059         ~OfferFeatures() { OfferFeatures_free(self); }
2060         OfferFeatures& operator=(OfferFeatures&& o) { OfferFeatures_free(self); self = o.self; memset(&o, 0, sizeof(OfferFeatures)); return *this; }
2061         LDKOfferFeatures* operator &() { return &self; }
2062         LDKOfferFeatures* operator ->() { return &self; }
2063         const LDKOfferFeatures* operator &() const { return &self; }
2064         const LDKOfferFeatures* operator ->() const { return &self; }
2065 };
2066 class InvoiceRequestFeatures {
2067 private:
2068         LDKInvoiceRequestFeatures self;
2069 public:
2070         InvoiceRequestFeatures(const InvoiceRequestFeatures&) = delete;
2071         InvoiceRequestFeatures(InvoiceRequestFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestFeatures)); }
2072         InvoiceRequestFeatures(LDKInvoiceRequestFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestFeatures)); }
2073         operator LDKInvoiceRequestFeatures() && { LDKInvoiceRequestFeatures res = self; memset(&self, 0, sizeof(LDKInvoiceRequestFeatures)); return res; }
2074         ~InvoiceRequestFeatures() { InvoiceRequestFeatures_free(self); }
2075         InvoiceRequestFeatures& operator=(InvoiceRequestFeatures&& o) { InvoiceRequestFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestFeatures)); return *this; }
2076         LDKInvoiceRequestFeatures* operator &() { return &self; }
2077         LDKInvoiceRequestFeatures* operator ->() { return &self; }
2078         const LDKInvoiceRequestFeatures* operator &() const { return &self; }
2079         const LDKInvoiceRequestFeatures* operator ->() const { return &self; }
2080 };
2081 class Bolt12InvoiceFeatures {
2082 private:
2083         LDKBolt12InvoiceFeatures self;
2084 public:
2085         Bolt12InvoiceFeatures(const Bolt12InvoiceFeatures&) = delete;
2086         Bolt12InvoiceFeatures(Bolt12InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12InvoiceFeatures)); }
2087         Bolt12InvoiceFeatures(LDKBolt12InvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12InvoiceFeatures)); }
2088         operator LDKBolt12InvoiceFeatures() && { LDKBolt12InvoiceFeatures res = self; memset(&self, 0, sizeof(LDKBolt12InvoiceFeatures)); return res; }
2089         ~Bolt12InvoiceFeatures() { Bolt12InvoiceFeatures_free(self); }
2090         Bolt12InvoiceFeatures& operator=(Bolt12InvoiceFeatures&& o) { Bolt12InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12InvoiceFeatures)); return *this; }
2091         LDKBolt12InvoiceFeatures* operator &() { return &self; }
2092         LDKBolt12InvoiceFeatures* operator ->() { return &self; }
2093         const LDKBolt12InvoiceFeatures* operator &() const { return &self; }
2094         const LDKBolt12InvoiceFeatures* operator ->() const { return &self; }
2095 };
2096 class BlindedHopFeatures {
2097 private:
2098         LDKBlindedHopFeatures self;
2099 public:
2100         BlindedHopFeatures(const BlindedHopFeatures&) = delete;
2101         BlindedHopFeatures(BlindedHopFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedHopFeatures)); }
2102         BlindedHopFeatures(LDKBlindedHopFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedHopFeatures)); }
2103         operator LDKBlindedHopFeatures() && { LDKBlindedHopFeatures res = self; memset(&self, 0, sizeof(LDKBlindedHopFeatures)); return res; }
2104         ~BlindedHopFeatures() { BlindedHopFeatures_free(self); }
2105         BlindedHopFeatures& operator=(BlindedHopFeatures&& o) { BlindedHopFeatures_free(self); self = o.self; memset(&o, 0, sizeof(BlindedHopFeatures)); return *this; }
2106         LDKBlindedHopFeatures* operator &() { return &self; }
2107         LDKBlindedHopFeatures* operator ->() { return &self; }
2108         const LDKBlindedHopFeatures* operator &() const { return &self; }
2109         const LDKBlindedHopFeatures* operator ->() const { return &self; }
2110 };
2111 class ChannelTypeFeatures {
2112 private:
2113         LDKChannelTypeFeatures self;
2114 public:
2115         ChannelTypeFeatures(const ChannelTypeFeatures&) = delete;
2116         ChannelTypeFeatures(ChannelTypeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTypeFeatures)); }
2117         ChannelTypeFeatures(LDKChannelTypeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTypeFeatures)); }
2118         operator LDKChannelTypeFeatures() && { LDKChannelTypeFeatures res = self; memset(&self, 0, sizeof(LDKChannelTypeFeatures)); return res; }
2119         ~ChannelTypeFeatures() { ChannelTypeFeatures_free(self); }
2120         ChannelTypeFeatures& operator=(ChannelTypeFeatures&& o) { ChannelTypeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTypeFeatures)); return *this; }
2121         LDKChannelTypeFeatures* operator &() { return &self; }
2122         LDKChannelTypeFeatures* operator ->() { return &self; }
2123         const LDKChannelTypeFeatures* operator &() const { return &self; }
2124         const LDKChannelTypeFeatures* operator ->() const { return &self; }
2125 };
2126 class Offer {
2127 private:
2128         LDKOffer self;
2129 public:
2130         Offer(const Offer&) = delete;
2131         Offer(Offer&& o) : self(o.self) { memset(&o, 0, sizeof(Offer)); }
2132         Offer(LDKOffer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffer)); }
2133         operator LDKOffer() && { LDKOffer res = self; memset(&self, 0, sizeof(LDKOffer)); return res; }
2134         ~Offer() { Offer_free(self); }
2135         Offer& operator=(Offer&& o) { Offer_free(self); self = o.self; memset(&o, 0, sizeof(Offer)); return *this; }
2136         LDKOffer* operator &() { return &self; }
2137         LDKOffer* operator ->() { return &self; }
2138         const LDKOffer* operator &() const { return &self; }
2139         const LDKOffer* operator ->() const { return &self; }
2140 };
2141 class Amount {
2142 private:
2143         LDKAmount self;
2144 public:
2145         Amount(const Amount&) = delete;
2146         Amount(Amount&& o) : self(o.self) { memset(&o, 0, sizeof(Amount)); }
2147         Amount(LDKAmount&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAmount)); }
2148         operator LDKAmount() && { LDKAmount res = self; memset(&self, 0, sizeof(LDKAmount)); return res; }
2149         ~Amount() { Amount_free(self); }
2150         Amount& operator=(Amount&& o) { Amount_free(self); self = o.self; memset(&o, 0, sizeof(Amount)); return *this; }
2151         LDKAmount* operator &() { return &self; }
2152         LDKAmount* operator ->() { return &self; }
2153         const LDKAmount* operator &() const { return &self; }
2154         const LDKAmount* operator ->() const { return &self; }
2155 };
2156 class Quantity {
2157 private:
2158         LDKQuantity self;
2159 public:
2160         Quantity(const Quantity&) = delete;
2161         Quantity(Quantity&& o) : self(o.self) { memset(&o, 0, sizeof(Quantity)); }
2162         Quantity(LDKQuantity&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQuantity)); }
2163         operator LDKQuantity() && { LDKQuantity res = self; memset(&self, 0, sizeof(LDKQuantity)); return res; }
2164         ~Quantity() { Quantity_free(self); }
2165         Quantity& operator=(Quantity&& o) { Quantity_free(self); self = o.self; memset(&o, 0, sizeof(Quantity)); return *this; }
2166         LDKQuantity* operator &() { return &self; }
2167         LDKQuantity* operator ->() { return &self; }
2168         const LDKQuantity* operator &() const { return &self; }
2169         const LDKQuantity* operator ->() const { return &self; }
2170 };
2171 class NodeId {
2172 private:
2173         LDKNodeId self;
2174 public:
2175         NodeId(const NodeId&) = delete;
2176         NodeId(NodeId&& o) : self(o.self) { memset(&o, 0, sizeof(NodeId)); }
2177         NodeId(LDKNodeId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeId)); }
2178         operator LDKNodeId() && { LDKNodeId res = self; memset(&self, 0, sizeof(LDKNodeId)); return res; }
2179         ~NodeId() { NodeId_free(self); }
2180         NodeId& operator=(NodeId&& o) { NodeId_free(self); self = o.self; memset(&o, 0, sizeof(NodeId)); return *this; }
2181         LDKNodeId* operator &() { return &self; }
2182         LDKNodeId* operator ->() { return &self; }
2183         const LDKNodeId* operator &() const { return &self; }
2184         const LDKNodeId* operator ->() const { return &self; }
2185 };
2186 class NetworkGraph {
2187 private:
2188         LDKNetworkGraph self;
2189 public:
2190         NetworkGraph(const NetworkGraph&) = delete;
2191         NetworkGraph(NetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkGraph)); }
2192         NetworkGraph(LDKNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkGraph)); }
2193         operator LDKNetworkGraph() && { LDKNetworkGraph res = self; memset(&self, 0, sizeof(LDKNetworkGraph)); return res; }
2194         ~NetworkGraph() { NetworkGraph_free(self); }
2195         NetworkGraph& operator=(NetworkGraph&& o) { NetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(NetworkGraph)); return *this; }
2196         LDKNetworkGraph* operator &() { return &self; }
2197         LDKNetworkGraph* operator ->() { return &self; }
2198         const LDKNetworkGraph* operator &() const { return &self; }
2199         const LDKNetworkGraph* operator ->() const { return &self; }
2200 };
2201 class ReadOnlyNetworkGraph {
2202 private:
2203         LDKReadOnlyNetworkGraph self;
2204 public:
2205         ReadOnlyNetworkGraph(const ReadOnlyNetworkGraph&) = delete;
2206         ReadOnlyNetworkGraph(ReadOnlyNetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); }
2207         ReadOnlyNetworkGraph(LDKReadOnlyNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReadOnlyNetworkGraph)); }
2208         operator LDKReadOnlyNetworkGraph() && { LDKReadOnlyNetworkGraph res = self; memset(&self, 0, sizeof(LDKReadOnlyNetworkGraph)); return res; }
2209         ~ReadOnlyNetworkGraph() { ReadOnlyNetworkGraph_free(self); }
2210         ReadOnlyNetworkGraph& operator=(ReadOnlyNetworkGraph&& o) { ReadOnlyNetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); return *this; }
2211         LDKReadOnlyNetworkGraph* operator &() { return &self; }
2212         LDKReadOnlyNetworkGraph* operator ->() { return &self; }
2213         const LDKReadOnlyNetworkGraph* operator &() const { return &self; }
2214         const LDKReadOnlyNetworkGraph* operator ->() const { return &self; }
2215 };
2216 class NetworkUpdate {
2217 private:
2218         LDKNetworkUpdate self;
2219 public:
2220         NetworkUpdate(const NetworkUpdate&) = delete;
2221         NetworkUpdate(NetworkUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkUpdate)); }
2222         NetworkUpdate(LDKNetworkUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkUpdate)); }
2223         operator LDKNetworkUpdate() && { LDKNetworkUpdate res = self; memset(&self, 0, sizeof(LDKNetworkUpdate)); return res; }
2224         ~NetworkUpdate() { NetworkUpdate_free(self); }
2225         NetworkUpdate& operator=(NetworkUpdate&& o) { NetworkUpdate_free(self); self = o.self; memset(&o, 0, sizeof(NetworkUpdate)); return *this; }
2226         LDKNetworkUpdate* operator &() { return &self; }
2227         LDKNetworkUpdate* operator ->() { return &self; }
2228         const LDKNetworkUpdate* operator &() const { return &self; }
2229         const LDKNetworkUpdate* operator ->() const { return &self; }
2230 };
2231 class P2PGossipSync {
2232 private:
2233         LDKP2PGossipSync self;
2234 public:
2235         P2PGossipSync(const P2PGossipSync&) = delete;
2236         P2PGossipSync(P2PGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(P2PGossipSync)); }
2237         P2PGossipSync(LDKP2PGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKP2PGossipSync)); }
2238         operator LDKP2PGossipSync() && { LDKP2PGossipSync res = self; memset(&self, 0, sizeof(LDKP2PGossipSync)); return res; }
2239         ~P2PGossipSync() { P2PGossipSync_free(self); }
2240         P2PGossipSync& operator=(P2PGossipSync&& o) { P2PGossipSync_free(self); self = o.self; memset(&o, 0, sizeof(P2PGossipSync)); return *this; }
2241         LDKP2PGossipSync* operator &() { return &self; }
2242         LDKP2PGossipSync* operator ->() { return &self; }
2243         const LDKP2PGossipSync* operator &() const { return &self; }
2244         const LDKP2PGossipSync* operator ->() const { return &self; }
2245 };
2246 class ChannelUpdateInfo {
2247 private:
2248         LDKChannelUpdateInfo self;
2249 public:
2250         ChannelUpdateInfo(const ChannelUpdateInfo&) = delete;
2251         ChannelUpdateInfo(ChannelUpdateInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdateInfo)); }
2252         ChannelUpdateInfo(LDKChannelUpdateInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdateInfo)); }
2253         operator LDKChannelUpdateInfo() && { LDKChannelUpdateInfo res = self; memset(&self, 0, sizeof(LDKChannelUpdateInfo)); return res; }
2254         ~ChannelUpdateInfo() { ChannelUpdateInfo_free(self); }
2255         ChannelUpdateInfo& operator=(ChannelUpdateInfo&& o) { ChannelUpdateInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdateInfo)); return *this; }
2256         LDKChannelUpdateInfo* operator &() { return &self; }
2257         LDKChannelUpdateInfo* operator ->() { return &self; }
2258         const LDKChannelUpdateInfo* operator &() const { return &self; }
2259         const LDKChannelUpdateInfo* operator ->() const { return &self; }
2260 };
2261 class ChannelInfo {
2262 private:
2263         LDKChannelInfo self;
2264 public:
2265         ChannelInfo(const ChannelInfo&) = delete;
2266         ChannelInfo(ChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelInfo)); }
2267         ChannelInfo(LDKChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelInfo)); }
2268         operator LDKChannelInfo() && { LDKChannelInfo res = self; memset(&self, 0, sizeof(LDKChannelInfo)); return res; }
2269         ~ChannelInfo() { ChannelInfo_free(self); }
2270         ChannelInfo& operator=(ChannelInfo&& o) { ChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelInfo)); return *this; }
2271         LDKChannelInfo* operator &() { return &self; }
2272         LDKChannelInfo* operator ->() { return &self; }
2273         const LDKChannelInfo* operator &() const { return &self; }
2274         const LDKChannelInfo* operator ->() const { return &self; }
2275 };
2276 class DirectedChannelInfo {
2277 private:
2278         LDKDirectedChannelInfo self;
2279 public:
2280         DirectedChannelInfo(const DirectedChannelInfo&) = delete;
2281         DirectedChannelInfo(DirectedChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(DirectedChannelInfo)); }
2282         DirectedChannelInfo(LDKDirectedChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectedChannelInfo)); }
2283         operator LDKDirectedChannelInfo() && { LDKDirectedChannelInfo res = self; memset(&self, 0, sizeof(LDKDirectedChannelInfo)); return res; }
2284         ~DirectedChannelInfo() { DirectedChannelInfo_free(self); }
2285         DirectedChannelInfo& operator=(DirectedChannelInfo&& o) { DirectedChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(DirectedChannelInfo)); return *this; }
2286         LDKDirectedChannelInfo* operator &() { return &self; }
2287         LDKDirectedChannelInfo* operator ->() { return &self; }
2288         const LDKDirectedChannelInfo* operator &() const { return &self; }
2289         const LDKDirectedChannelInfo* operator ->() const { return &self; }
2290 };
2291 class EffectiveCapacity {
2292 private:
2293         LDKEffectiveCapacity self;
2294 public:
2295         EffectiveCapacity(const EffectiveCapacity&) = delete;
2296         EffectiveCapacity(EffectiveCapacity&& o) : self(o.self) { memset(&o, 0, sizeof(EffectiveCapacity)); }
2297         EffectiveCapacity(LDKEffectiveCapacity&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEffectiveCapacity)); }
2298         operator LDKEffectiveCapacity() && { LDKEffectiveCapacity res = self; memset(&self, 0, sizeof(LDKEffectiveCapacity)); return res; }
2299         ~EffectiveCapacity() { EffectiveCapacity_free(self); }
2300         EffectiveCapacity& operator=(EffectiveCapacity&& o) { EffectiveCapacity_free(self); self = o.self; memset(&o, 0, sizeof(EffectiveCapacity)); return *this; }
2301         LDKEffectiveCapacity* operator &() { return &self; }
2302         LDKEffectiveCapacity* operator ->() { return &self; }
2303         const LDKEffectiveCapacity* operator &() const { return &self; }
2304         const LDKEffectiveCapacity* operator ->() const { return &self; }
2305 };
2306 class RoutingFees {
2307 private:
2308         LDKRoutingFees self;
2309 public:
2310         RoutingFees(const RoutingFees&) = delete;
2311         RoutingFees(RoutingFees&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingFees)); }
2312         RoutingFees(LDKRoutingFees&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingFees)); }
2313         operator LDKRoutingFees() && { LDKRoutingFees res = self; memset(&self, 0, sizeof(LDKRoutingFees)); return res; }
2314         ~RoutingFees() { RoutingFees_free(self); }
2315         RoutingFees& operator=(RoutingFees&& o) { RoutingFees_free(self); self = o.self; memset(&o, 0, sizeof(RoutingFees)); return *this; }
2316         LDKRoutingFees* operator &() { return &self; }
2317         LDKRoutingFees* operator ->() { return &self; }
2318         const LDKRoutingFees* operator &() const { return &self; }
2319         const LDKRoutingFees* operator ->() const { return &self; }
2320 };
2321 class NodeAnnouncementInfo {
2322 private:
2323         LDKNodeAnnouncementInfo self;
2324 public:
2325         NodeAnnouncementInfo(const NodeAnnouncementInfo&) = delete;
2326         NodeAnnouncementInfo(NodeAnnouncementInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncementInfo)); }
2327         NodeAnnouncementInfo(LDKNodeAnnouncementInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncementInfo)); }
2328         operator LDKNodeAnnouncementInfo() && { LDKNodeAnnouncementInfo res = self; memset(&self, 0, sizeof(LDKNodeAnnouncementInfo)); return res; }
2329         ~NodeAnnouncementInfo() { NodeAnnouncementInfo_free(self); }
2330         NodeAnnouncementInfo& operator=(NodeAnnouncementInfo&& o) { NodeAnnouncementInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncementInfo)); return *this; }
2331         LDKNodeAnnouncementInfo* operator &() { return &self; }
2332         LDKNodeAnnouncementInfo* operator ->() { return &self; }
2333         const LDKNodeAnnouncementInfo* operator &() const { return &self; }
2334         const LDKNodeAnnouncementInfo* operator ->() const { return &self; }
2335 };
2336 class NodeAlias {
2337 private:
2338         LDKNodeAlias self;
2339 public:
2340         NodeAlias(const NodeAlias&) = delete;
2341         NodeAlias(NodeAlias&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAlias)); }
2342         NodeAlias(LDKNodeAlias&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAlias)); }
2343         operator LDKNodeAlias() && { LDKNodeAlias res = self; memset(&self, 0, sizeof(LDKNodeAlias)); return res; }
2344         ~NodeAlias() { NodeAlias_free(self); }
2345         NodeAlias& operator=(NodeAlias&& o) { NodeAlias_free(self); self = o.self; memset(&o, 0, sizeof(NodeAlias)); return *this; }
2346         LDKNodeAlias* operator &() { return &self; }
2347         LDKNodeAlias* operator ->() { return &self; }
2348         const LDKNodeAlias* operator &() const { return &self; }
2349         const LDKNodeAlias* operator ->() const { return &self; }
2350 };
2351 class NodeInfo {
2352 private:
2353         LDKNodeInfo self;
2354 public:
2355         NodeInfo(const NodeInfo&) = delete;
2356         NodeInfo(NodeInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeInfo)); }
2357         NodeInfo(LDKNodeInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeInfo)); }
2358         operator LDKNodeInfo() && { LDKNodeInfo res = self; memset(&self, 0, sizeof(LDKNodeInfo)); return res; }
2359         ~NodeInfo() { NodeInfo_free(self); }
2360         NodeInfo& operator=(NodeInfo&& o) { NodeInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeInfo)); return *this; }
2361         LDKNodeInfo* operator &() { return &self; }
2362         LDKNodeInfo* operator ->() { return &self; }
2363         const LDKNodeInfo* operator &() const { return &self; }
2364         const LDKNodeInfo* operator ->() const { return &self; }
2365 };
2366 class ChannelDerivationParameters {
2367 private:
2368         LDKChannelDerivationParameters self;
2369 public:
2370         ChannelDerivationParameters(const ChannelDerivationParameters&) = delete;
2371         ChannelDerivationParameters(ChannelDerivationParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDerivationParameters)); }
2372         ChannelDerivationParameters(LDKChannelDerivationParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDerivationParameters)); }
2373         operator LDKChannelDerivationParameters() && { LDKChannelDerivationParameters res = self; memset(&self, 0, sizeof(LDKChannelDerivationParameters)); return res; }
2374         ~ChannelDerivationParameters() { ChannelDerivationParameters_free(self); }
2375         ChannelDerivationParameters& operator=(ChannelDerivationParameters&& o) { ChannelDerivationParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDerivationParameters)); return *this; }
2376         LDKChannelDerivationParameters* operator &() { return &self; }
2377         LDKChannelDerivationParameters* operator ->() { return &self; }
2378         const LDKChannelDerivationParameters* operator &() const { return &self; }
2379         const LDKChannelDerivationParameters* operator ->() const { return &self; }
2380 };
2381 class AnchorDescriptor {
2382 private:
2383         LDKAnchorDescriptor self;
2384 public:
2385         AnchorDescriptor(const AnchorDescriptor&) = delete;
2386         AnchorDescriptor(AnchorDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(AnchorDescriptor)); }
2387         AnchorDescriptor(LDKAnchorDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnchorDescriptor)); }
2388         operator LDKAnchorDescriptor() && { LDKAnchorDescriptor res = self; memset(&self, 0, sizeof(LDKAnchorDescriptor)); return res; }
2389         ~AnchorDescriptor() { AnchorDescriptor_free(self); }
2390         AnchorDescriptor& operator=(AnchorDescriptor&& o) { AnchorDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(AnchorDescriptor)); return *this; }
2391         LDKAnchorDescriptor* operator &() { return &self; }
2392         LDKAnchorDescriptor* operator ->() { return &self; }
2393         const LDKAnchorDescriptor* operator &() const { return &self; }
2394         const LDKAnchorDescriptor* operator ->() const { return &self; }
2395 };
2396 class HTLCDescriptor {
2397 private:
2398         LDKHTLCDescriptor self;
2399 public:
2400         HTLCDescriptor(const HTLCDescriptor&) = delete;
2401         HTLCDescriptor(HTLCDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCDescriptor)); }
2402         HTLCDescriptor(LDKHTLCDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCDescriptor)); }
2403         operator LDKHTLCDescriptor() && { LDKHTLCDescriptor res = self; memset(&self, 0, sizeof(LDKHTLCDescriptor)); return res; }
2404         ~HTLCDescriptor() { HTLCDescriptor_free(self); }
2405         HTLCDescriptor& operator=(HTLCDescriptor&& o) { HTLCDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(HTLCDescriptor)); return *this; }
2406         LDKHTLCDescriptor* operator &() { return &self; }
2407         LDKHTLCDescriptor* operator ->() { return &self; }
2408         const LDKHTLCDescriptor* operator &() const { return &self; }
2409         const LDKHTLCDescriptor* operator ->() const { return &self; }
2410 };
2411 class BumpTransactionEvent {
2412 private:
2413         LDKBumpTransactionEvent self;
2414 public:
2415         BumpTransactionEvent(const BumpTransactionEvent&) = delete;
2416         BumpTransactionEvent(BumpTransactionEvent&& o) : self(o.self) { memset(&o, 0, sizeof(BumpTransactionEvent)); }
2417         BumpTransactionEvent(LDKBumpTransactionEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBumpTransactionEvent)); }
2418         operator LDKBumpTransactionEvent() && { LDKBumpTransactionEvent res = self; memset(&self, 0, sizeof(LDKBumpTransactionEvent)); return res; }
2419         ~BumpTransactionEvent() { BumpTransactionEvent_free(self); }
2420         BumpTransactionEvent& operator=(BumpTransactionEvent&& o) { BumpTransactionEvent_free(self); self = o.self; memset(&o, 0, sizeof(BumpTransactionEvent)); return *this; }
2421         LDKBumpTransactionEvent* operator &() { return &self; }
2422         LDKBumpTransactionEvent* operator ->() { return &self; }
2423         const LDKBumpTransactionEvent* operator &() const { return &self; }
2424         const LDKBumpTransactionEvent* operator ->() const { return &self; }
2425 };
2426 class Input {
2427 private:
2428         LDKInput self;
2429 public:
2430         Input(const Input&) = delete;
2431         Input(Input&& o) : self(o.self) { memset(&o, 0, sizeof(Input)); }
2432         Input(LDKInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInput)); }
2433         operator LDKInput() && { LDKInput res = self; memset(&self, 0, sizeof(LDKInput)); return res; }
2434         ~Input() { Input_free(self); }
2435         Input& operator=(Input&& o) { Input_free(self); self = o.self; memset(&o, 0, sizeof(Input)); return *this; }
2436         LDKInput* operator &() { return &self; }
2437         LDKInput* operator ->() { return &self; }
2438         const LDKInput* operator &() const { return &self; }
2439         const LDKInput* operator ->() const { return &self; }
2440 };
2441 class Utxo {
2442 private:
2443         LDKUtxo self;
2444 public:
2445         Utxo(const Utxo&) = delete;
2446         Utxo(Utxo&& o) : self(o.self) { memset(&o, 0, sizeof(Utxo)); }
2447         Utxo(LDKUtxo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxo)); }
2448         operator LDKUtxo() && { LDKUtxo res = self; memset(&self, 0, sizeof(LDKUtxo)); return res; }
2449         ~Utxo() { Utxo_free(self); }
2450         Utxo& operator=(Utxo&& o) { Utxo_free(self); self = o.self; memset(&o, 0, sizeof(Utxo)); return *this; }
2451         LDKUtxo* operator &() { return &self; }
2452         LDKUtxo* operator ->() { return &self; }
2453         const LDKUtxo* operator &() const { return &self; }
2454         const LDKUtxo* operator ->() const { return &self; }
2455 };
2456 class CoinSelection {
2457 private:
2458         LDKCoinSelection self;
2459 public:
2460         CoinSelection(const CoinSelection&) = delete;
2461         CoinSelection(CoinSelection&& o) : self(o.self) { memset(&o, 0, sizeof(CoinSelection)); }
2462         CoinSelection(LDKCoinSelection&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCoinSelection)); }
2463         operator LDKCoinSelection() && { LDKCoinSelection res = self; memset(&self, 0, sizeof(LDKCoinSelection)); return res; }
2464         ~CoinSelection() { CoinSelection_free(self); }
2465         CoinSelection& operator=(CoinSelection&& o) { CoinSelection_free(self); self = o.self; memset(&o, 0, sizeof(CoinSelection)); return *this; }
2466         LDKCoinSelection* operator &() { return &self; }
2467         LDKCoinSelection* operator ->() { return &self; }
2468         const LDKCoinSelection* operator &() const { return &self; }
2469         const LDKCoinSelection* operator ->() const { return &self; }
2470 };
2471 class CoinSelectionSource {
2472 private:
2473         LDKCoinSelectionSource self;
2474 public:
2475         CoinSelectionSource(const CoinSelectionSource&) = delete;
2476         CoinSelectionSource(CoinSelectionSource&& o) : self(o.self) { memset(&o, 0, sizeof(CoinSelectionSource)); }
2477         CoinSelectionSource(LDKCoinSelectionSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCoinSelectionSource)); }
2478         operator LDKCoinSelectionSource() && { LDKCoinSelectionSource res = self; memset(&self, 0, sizeof(LDKCoinSelectionSource)); return res; }
2479         ~CoinSelectionSource() { CoinSelectionSource_free(self); }
2480         CoinSelectionSource& operator=(CoinSelectionSource&& o) { CoinSelectionSource_free(self); self = o.self; memset(&o, 0, sizeof(CoinSelectionSource)); return *this; }
2481         LDKCoinSelectionSource* operator &() { return &self; }
2482         LDKCoinSelectionSource* operator ->() { return &self; }
2483         const LDKCoinSelectionSource* operator &() const { return &self; }
2484         const LDKCoinSelectionSource* operator ->() const { return &self; }
2485         /**
2486          *  Performs coin selection of a set of UTXOs, with at least 1 confirmation each, that are
2487          *  available to spend. Implementations are free to pick their coin selection algorithm of
2488          *  choice, as long as the following requirements are met:
2489          *
2490          *  1. `must_spend` contains a set of [`Input`]s that must be included in the transaction
2491          *     throughout coin selection, but must not be returned as part of the result.
2492          *  2. `must_pay_to` contains a set of [`TxOut`]s that must be included in the transaction
2493          *     throughout coin selection. In some cases, like when funding an anchor transaction, this
2494          *     set is empty. Implementations should ensure they handle this correctly on their end,
2495          *     e.g., Bitcoin Core's `fundrawtransaction` RPC requires at least one output to be
2496          *     provided, in which case a zero-value empty OP_RETURN output can be used instead.
2497          *  3. Enough inputs must be selected/contributed for the resulting transaction (including the
2498          *     inputs and outputs noted above) to meet `target_feerate_sat_per_1000_weight`.
2499          *
2500          *  Implementations must take note that [`Input::satisfaction_weight`] only tracks the weight of
2501          *  the input's `script_sig` and `witness`. Some wallets, like Bitcoin Core's, may require
2502          *  providing the full input weight. Failing to do so may lead to underestimating fee bumps and
2503          *  delaying block inclusion.
2504          *
2505          *  The `claim_id` must map to the set of external UTXOs assigned to the claim, such that they
2506          *  can be re-used within new fee-bumped iterations of the original claiming transaction,
2507          *  ensuring that claims don't double spend each other. If a specific `claim_id` has never had a
2508          *  transaction associated with it, and all of the available UTXOs have already been assigned to
2509          *  other claims, implementations must be willing to double spend their UTXOs. The choice of
2510          *  which UTXOs to double spend is left to the implementation, but it must strive to keep the
2511          *  set of other claims being double spent to a minimum.
2512          */
2513         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);
2514         /**
2515          *  Signs and provides the full witness for all inputs within the transaction known to the
2516          *  trait (i.e., any provided via [`CoinSelectionSource::select_confirmed_utxos`]).
2517          */
2518         inline LDK::CResult_TransactionNoneZ sign_tx(struct LDKTransaction tx);
2519 };
2520 class WalletSource {
2521 private:
2522         LDKWalletSource self;
2523 public:
2524         WalletSource(const WalletSource&) = delete;
2525         WalletSource(WalletSource&& o) : self(o.self) { memset(&o, 0, sizeof(WalletSource)); }
2526         WalletSource(LDKWalletSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWalletSource)); }
2527         operator LDKWalletSource() && { LDKWalletSource res = self; memset(&self, 0, sizeof(LDKWalletSource)); return res; }
2528         ~WalletSource() { WalletSource_free(self); }
2529         WalletSource& operator=(WalletSource&& o) { WalletSource_free(self); self = o.self; memset(&o, 0, sizeof(WalletSource)); return *this; }
2530         LDKWalletSource* operator &() { return &self; }
2531         LDKWalletSource* operator ->() { return &self; }
2532         const LDKWalletSource* operator &() const { return &self; }
2533         const LDKWalletSource* operator ->() const { return &self; }
2534         /**
2535          *  Returns all UTXOs, with at least 1 confirmation each, that are available to spend.
2536          */
2537         inline LDK::CResult_CVec_UtxoZNoneZ list_confirmed_utxos();
2538         /**
2539          *  Returns a script to use for change above dust resulting from a successful coin selection
2540          *  attempt.
2541          */
2542         inline LDK::CResult_CVec_u8ZNoneZ get_change_script();
2543         /**
2544          *  Signs and provides the full [`TxIn::script_sig`] and [`TxIn::witness`] for all inputs within
2545          *  the transaction known to the wallet (i.e., any provided via
2546          *  [`WalletSource::list_confirmed_utxos`]).
2547          */
2548         inline LDK::CResult_TransactionNoneZ sign_tx(struct LDKTransaction tx);
2549 };
2550 class Wallet {
2551 private:
2552         LDKWallet self;
2553 public:
2554         Wallet(const Wallet&) = delete;
2555         Wallet(Wallet&& o) : self(o.self) { memset(&o, 0, sizeof(Wallet)); }
2556         Wallet(LDKWallet&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWallet)); }
2557         operator LDKWallet() && { LDKWallet res = self; memset(&self, 0, sizeof(LDKWallet)); return res; }
2558         ~Wallet() { Wallet_free(self); }
2559         Wallet& operator=(Wallet&& o) { Wallet_free(self); self = o.self; memset(&o, 0, sizeof(Wallet)); return *this; }
2560         LDKWallet* operator &() { return &self; }
2561         LDKWallet* operator ->() { return &self; }
2562         const LDKWallet* operator &() const { return &self; }
2563         const LDKWallet* operator ->() const { return &self; }
2564 };
2565 class BumpTransactionEventHandler {
2566 private:
2567         LDKBumpTransactionEventHandler self;
2568 public:
2569         BumpTransactionEventHandler(const BumpTransactionEventHandler&) = delete;
2570         BumpTransactionEventHandler(BumpTransactionEventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(BumpTransactionEventHandler)); }
2571         BumpTransactionEventHandler(LDKBumpTransactionEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBumpTransactionEventHandler)); }
2572         operator LDKBumpTransactionEventHandler() && { LDKBumpTransactionEventHandler res = self; memset(&self, 0, sizeof(LDKBumpTransactionEventHandler)); return res; }
2573         ~BumpTransactionEventHandler() { BumpTransactionEventHandler_free(self); }
2574         BumpTransactionEventHandler& operator=(BumpTransactionEventHandler&& o) { BumpTransactionEventHandler_free(self); self = o.self; memset(&o, 0, sizeof(BumpTransactionEventHandler)); return *this; }
2575         LDKBumpTransactionEventHandler* operator &() { return &self; }
2576         LDKBumpTransactionEventHandler* operator ->() { return &self; }
2577         const LDKBumpTransactionEventHandler* operator &() const { return &self; }
2578         const LDKBumpTransactionEventHandler* operator ->() const { return &self; }
2579 };
2580 class FailureCode {
2581 private:
2582         LDKFailureCode self;
2583 public:
2584         FailureCode(const FailureCode&) = delete;
2585         FailureCode(FailureCode&& o) : self(o.self) { memset(&o, 0, sizeof(FailureCode)); }
2586         FailureCode(LDKFailureCode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFailureCode)); }
2587         operator LDKFailureCode() && { LDKFailureCode res = self; memset(&self, 0, sizeof(LDKFailureCode)); return res; }
2588         ~FailureCode() { FailureCode_free(self); }
2589         FailureCode& operator=(FailureCode&& o) { FailureCode_free(self); self = o.self; memset(&o, 0, sizeof(FailureCode)); return *this; }
2590         LDKFailureCode* operator &() { return &self; }
2591         LDKFailureCode* operator ->() { return &self; }
2592         const LDKFailureCode* operator &() const { return &self; }
2593         const LDKFailureCode* operator ->() const { return &self; }
2594 };
2595 class ChannelManager {
2596 private:
2597         LDKChannelManager self;
2598 public:
2599         ChannelManager(const ChannelManager&) = delete;
2600         ChannelManager(ChannelManager&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManager)); }
2601         ChannelManager(LDKChannelManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManager)); }
2602         operator LDKChannelManager() && { LDKChannelManager res = self; memset(&self, 0, sizeof(LDKChannelManager)); return res; }
2603         ~ChannelManager() { ChannelManager_free(self); }
2604         ChannelManager& operator=(ChannelManager&& o) { ChannelManager_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManager)); return *this; }
2605         LDKChannelManager* operator &() { return &self; }
2606         LDKChannelManager* operator ->() { return &self; }
2607         const LDKChannelManager* operator &() const { return &self; }
2608         const LDKChannelManager* operator ->() const { return &self; }
2609 };
2610 class ChainParameters {
2611 private:
2612         LDKChainParameters self;
2613 public:
2614         ChainParameters(const ChainParameters&) = delete;
2615         ChainParameters(ChainParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChainParameters)); }
2616         ChainParameters(LDKChainParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainParameters)); }
2617         operator LDKChainParameters() && { LDKChainParameters res = self; memset(&self, 0, sizeof(LDKChainParameters)); return res; }
2618         ~ChainParameters() { ChainParameters_free(self); }
2619         ChainParameters& operator=(ChainParameters&& o) { ChainParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChainParameters)); return *this; }
2620         LDKChainParameters* operator &() { return &self; }
2621         LDKChainParameters* operator ->() { return &self; }
2622         const LDKChainParameters* operator &() const { return &self; }
2623         const LDKChainParameters* operator ->() const { return &self; }
2624 };
2625 class CounterpartyForwardingInfo {
2626 private:
2627         LDKCounterpartyForwardingInfo self;
2628 public:
2629         CounterpartyForwardingInfo(const CounterpartyForwardingInfo&) = delete;
2630         CounterpartyForwardingInfo(CounterpartyForwardingInfo&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyForwardingInfo)); }
2631         CounterpartyForwardingInfo(LDKCounterpartyForwardingInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyForwardingInfo)); }
2632         operator LDKCounterpartyForwardingInfo() && { LDKCounterpartyForwardingInfo res = self; memset(&self, 0, sizeof(LDKCounterpartyForwardingInfo)); return res; }
2633         ~CounterpartyForwardingInfo() { CounterpartyForwardingInfo_free(self); }
2634         CounterpartyForwardingInfo& operator=(CounterpartyForwardingInfo&& o) { CounterpartyForwardingInfo_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyForwardingInfo)); return *this; }
2635         LDKCounterpartyForwardingInfo* operator &() { return &self; }
2636         LDKCounterpartyForwardingInfo* operator ->() { return &self; }
2637         const LDKCounterpartyForwardingInfo* operator &() const { return &self; }
2638         const LDKCounterpartyForwardingInfo* operator ->() const { return &self; }
2639 };
2640 class ChannelCounterparty {
2641 private:
2642         LDKChannelCounterparty self;
2643 public:
2644         ChannelCounterparty(const ChannelCounterparty&) = delete;
2645         ChannelCounterparty(ChannelCounterparty&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelCounterparty)); }
2646         ChannelCounterparty(LDKChannelCounterparty&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelCounterparty)); }
2647         operator LDKChannelCounterparty() && { LDKChannelCounterparty res = self; memset(&self, 0, sizeof(LDKChannelCounterparty)); return res; }
2648         ~ChannelCounterparty() { ChannelCounterparty_free(self); }
2649         ChannelCounterparty& operator=(ChannelCounterparty&& o) { ChannelCounterparty_free(self); self = o.self; memset(&o, 0, sizeof(ChannelCounterparty)); return *this; }
2650         LDKChannelCounterparty* operator &() { return &self; }
2651         LDKChannelCounterparty* operator ->() { return &self; }
2652         const LDKChannelCounterparty* operator &() const { return &self; }
2653         const LDKChannelCounterparty* operator ->() const { return &self; }
2654 };
2655 class ChannelDetails {
2656 private:
2657         LDKChannelDetails self;
2658 public:
2659         ChannelDetails(const ChannelDetails&) = delete;
2660         ChannelDetails(ChannelDetails&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDetails)); }
2661         ChannelDetails(LDKChannelDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDetails)); }
2662         operator LDKChannelDetails() && { LDKChannelDetails res = self; memset(&self, 0, sizeof(LDKChannelDetails)); return res; }
2663         ~ChannelDetails() { ChannelDetails_free(self); }
2664         ChannelDetails& operator=(ChannelDetails&& o) { ChannelDetails_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDetails)); return *this; }
2665         LDKChannelDetails* operator &() { return &self; }
2666         LDKChannelDetails* operator ->() { return &self; }
2667         const LDKChannelDetails* operator &() const { return &self; }
2668         const LDKChannelDetails* operator ->() const { return &self; }
2669 };
2670 class ChannelShutdownState {
2671 private:
2672         LDKChannelShutdownState self;
2673 public:
2674         ChannelShutdownState(const ChannelShutdownState&) = delete;
2675         ChannelShutdownState(ChannelShutdownState&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelShutdownState)); }
2676         ChannelShutdownState(LDKChannelShutdownState&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelShutdownState)); }
2677         operator LDKChannelShutdownState() && { LDKChannelShutdownState res = self; memset(&self, 0, sizeof(LDKChannelShutdownState)); return res; }
2678         ChannelShutdownState& operator=(ChannelShutdownState&& o) { self = o.self; memset(&o, 0, sizeof(ChannelShutdownState)); return *this; }
2679         LDKChannelShutdownState* operator &() { return &self; }
2680         LDKChannelShutdownState* operator ->() { return &self; }
2681         const LDKChannelShutdownState* operator &() const { return &self; }
2682         const LDKChannelShutdownState* operator ->() const { return &self; }
2683 };
2684 class RecentPaymentDetails {
2685 private:
2686         LDKRecentPaymentDetails self;
2687 public:
2688         RecentPaymentDetails(const RecentPaymentDetails&) = delete;
2689         RecentPaymentDetails(RecentPaymentDetails&& o) : self(o.self) { memset(&o, 0, sizeof(RecentPaymentDetails)); }
2690         RecentPaymentDetails(LDKRecentPaymentDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecentPaymentDetails)); }
2691         operator LDKRecentPaymentDetails() && { LDKRecentPaymentDetails res = self; memset(&self, 0, sizeof(LDKRecentPaymentDetails)); return res; }
2692         ~RecentPaymentDetails() { RecentPaymentDetails_free(self); }
2693         RecentPaymentDetails& operator=(RecentPaymentDetails&& o) { RecentPaymentDetails_free(self); self = o.self; memset(&o, 0, sizeof(RecentPaymentDetails)); return *this; }
2694         LDKRecentPaymentDetails* operator &() { return &self; }
2695         LDKRecentPaymentDetails* operator ->() { return &self; }
2696         const LDKRecentPaymentDetails* operator &() const { return &self; }
2697         const LDKRecentPaymentDetails* operator ->() const { return &self; }
2698 };
2699 class PhantomRouteHints {
2700 private:
2701         LDKPhantomRouteHints self;
2702 public:
2703         PhantomRouteHints(const PhantomRouteHints&) = delete;
2704         PhantomRouteHints(PhantomRouteHints&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomRouteHints)); }
2705         PhantomRouteHints(LDKPhantomRouteHints&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomRouteHints)); }
2706         operator LDKPhantomRouteHints() && { LDKPhantomRouteHints res = self; memset(&self, 0, sizeof(LDKPhantomRouteHints)); return res; }
2707         ~PhantomRouteHints() { PhantomRouteHints_free(self); }
2708         PhantomRouteHints& operator=(PhantomRouteHints&& o) { PhantomRouteHints_free(self); self = o.self; memset(&o, 0, sizeof(PhantomRouteHints)); return *this; }
2709         LDKPhantomRouteHints* operator &() { return &self; }
2710         LDKPhantomRouteHints* operator ->() { return &self; }
2711         const LDKPhantomRouteHints* operator &() const { return &self; }
2712         const LDKPhantomRouteHints* operator ->() const { return &self; }
2713 };
2714 class ChannelManagerReadArgs {
2715 private:
2716         LDKChannelManagerReadArgs self;
2717 public:
2718         ChannelManagerReadArgs(const ChannelManagerReadArgs&) = delete;
2719         ChannelManagerReadArgs(ChannelManagerReadArgs&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerReadArgs)); }
2720         ChannelManagerReadArgs(LDKChannelManagerReadArgs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerReadArgs)); }
2721         operator LDKChannelManagerReadArgs() && { LDKChannelManagerReadArgs res = self; memset(&self, 0, sizeof(LDKChannelManagerReadArgs)); return res; }
2722         ~ChannelManagerReadArgs() { ChannelManagerReadArgs_free(self); }
2723         ChannelManagerReadArgs& operator=(ChannelManagerReadArgs&& o) { ChannelManagerReadArgs_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManagerReadArgs)); return *this; }
2724         LDKChannelManagerReadArgs* operator &() { return &self; }
2725         LDKChannelManagerReadArgs* operator ->() { return &self; }
2726         const LDKChannelManagerReadArgs* operator &() const { return &self; }
2727         const LDKChannelManagerReadArgs* operator ->() const { return &self; }
2728 };
2729 class ChannelHandshakeConfig {
2730 private:
2731         LDKChannelHandshakeConfig self;
2732 public:
2733         ChannelHandshakeConfig(const ChannelHandshakeConfig&) = delete;
2734         ChannelHandshakeConfig(ChannelHandshakeConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeConfig)); }
2735         ChannelHandshakeConfig(LDKChannelHandshakeConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeConfig)); }
2736         operator LDKChannelHandshakeConfig() && { LDKChannelHandshakeConfig res = self; memset(&self, 0, sizeof(LDKChannelHandshakeConfig)); return res; }
2737         ~ChannelHandshakeConfig() { ChannelHandshakeConfig_free(self); }
2738         ChannelHandshakeConfig& operator=(ChannelHandshakeConfig&& o) { ChannelHandshakeConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeConfig)); return *this; }
2739         LDKChannelHandshakeConfig* operator &() { return &self; }
2740         LDKChannelHandshakeConfig* operator ->() { return &self; }
2741         const LDKChannelHandshakeConfig* operator &() const { return &self; }
2742         const LDKChannelHandshakeConfig* operator ->() const { return &self; }
2743 };
2744 class ChannelHandshakeLimits {
2745 private:
2746         LDKChannelHandshakeLimits self;
2747 public:
2748         ChannelHandshakeLimits(const ChannelHandshakeLimits&) = delete;
2749         ChannelHandshakeLimits(ChannelHandshakeLimits&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeLimits)); }
2750         ChannelHandshakeLimits(LDKChannelHandshakeLimits&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeLimits)); }
2751         operator LDKChannelHandshakeLimits() && { LDKChannelHandshakeLimits res = self; memset(&self, 0, sizeof(LDKChannelHandshakeLimits)); return res; }
2752         ~ChannelHandshakeLimits() { ChannelHandshakeLimits_free(self); }
2753         ChannelHandshakeLimits& operator=(ChannelHandshakeLimits&& o) { ChannelHandshakeLimits_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeLimits)); return *this; }
2754         LDKChannelHandshakeLimits* operator &() { return &self; }
2755         LDKChannelHandshakeLimits* operator ->() { return &self; }
2756         const LDKChannelHandshakeLimits* operator &() const { return &self; }
2757         const LDKChannelHandshakeLimits* operator ->() const { return &self; }
2758 };
2759 class MaxDustHTLCExposure {
2760 private:
2761         LDKMaxDustHTLCExposure self;
2762 public:
2763         MaxDustHTLCExposure(const MaxDustHTLCExposure&) = delete;
2764         MaxDustHTLCExposure(MaxDustHTLCExposure&& o) : self(o.self) { memset(&o, 0, sizeof(MaxDustHTLCExposure)); }
2765         MaxDustHTLCExposure(LDKMaxDustHTLCExposure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMaxDustHTLCExposure)); }
2766         operator LDKMaxDustHTLCExposure() && { LDKMaxDustHTLCExposure res = self; memset(&self, 0, sizeof(LDKMaxDustHTLCExposure)); return res; }
2767         ~MaxDustHTLCExposure() { MaxDustHTLCExposure_free(self); }
2768         MaxDustHTLCExposure& operator=(MaxDustHTLCExposure&& o) { MaxDustHTLCExposure_free(self); self = o.self; memset(&o, 0, sizeof(MaxDustHTLCExposure)); return *this; }
2769         LDKMaxDustHTLCExposure* operator &() { return &self; }
2770         LDKMaxDustHTLCExposure* operator ->() { return &self; }
2771         const LDKMaxDustHTLCExposure* operator &() const { return &self; }
2772         const LDKMaxDustHTLCExposure* operator ->() const { return &self; }
2773 };
2774 class ChannelConfig {
2775 private:
2776         LDKChannelConfig self;
2777 public:
2778         ChannelConfig(const ChannelConfig&) = delete;
2779         ChannelConfig(ChannelConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfig)); }
2780         ChannelConfig(LDKChannelConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfig)); }
2781         operator LDKChannelConfig() && { LDKChannelConfig res = self; memset(&self, 0, sizeof(LDKChannelConfig)); return res; }
2782         ~ChannelConfig() { ChannelConfig_free(self); }
2783         ChannelConfig& operator=(ChannelConfig&& o) { ChannelConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfig)); return *this; }
2784         LDKChannelConfig* operator &() { return &self; }
2785         LDKChannelConfig* operator ->() { return &self; }
2786         const LDKChannelConfig* operator &() const { return &self; }
2787         const LDKChannelConfig* operator ->() const { return &self; }
2788 };
2789 class ChannelConfigUpdate {
2790 private:
2791         LDKChannelConfigUpdate self;
2792 public:
2793         ChannelConfigUpdate(const ChannelConfigUpdate&) = delete;
2794         ChannelConfigUpdate(ChannelConfigUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfigUpdate)); }
2795         ChannelConfigUpdate(LDKChannelConfigUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfigUpdate)); }
2796         operator LDKChannelConfigUpdate() && { LDKChannelConfigUpdate res = self; memset(&self, 0, sizeof(LDKChannelConfigUpdate)); return res; }
2797         ~ChannelConfigUpdate() { ChannelConfigUpdate_free(self); }
2798         ChannelConfigUpdate& operator=(ChannelConfigUpdate&& o) { ChannelConfigUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfigUpdate)); return *this; }
2799         LDKChannelConfigUpdate* operator &() { return &self; }
2800         LDKChannelConfigUpdate* operator ->() { return &self; }
2801         const LDKChannelConfigUpdate* operator &() const { return &self; }
2802         const LDKChannelConfigUpdate* operator ->() const { return &self; }
2803 };
2804 class UserConfig {
2805 private:
2806         LDKUserConfig self;
2807 public:
2808         UserConfig(const UserConfig&) = delete;
2809         UserConfig(UserConfig&& o) : self(o.self) { memset(&o, 0, sizeof(UserConfig)); }
2810         UserConfig(LDKUserConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUserConfig)); }
2811         operator LDKUserConfig() && { LDKUserConfig res = self; memset(&self, 0, sizeof(LDKUserConfig)); return res; }
2812         ~UserConfig() { UserConfig_free(self); }
2813         UserConfig& operator=(UserConfig&& o) { UserConfig_free(self); self = o.self; memset(&o, 0, sizeof(UserConfig)); return *this; }
2814         LDKUserConfig* operator &() { return &self; }
2815         LDKUserConfig* operator ->() { return &self; }
2816         const LDKUserConfig* operator &() const { return &self; }
2817         const LDKUserConfig* operator ->() const { return &self; }
2818 };
2819 class APIError {
2820 private:
2821         LDKAPIError self;
2822 public:
2823         APIError(const APIError&) = delete;
2824         APIError(APIError&& o) : self(o.self) { memset(&o, 0, sizeof(APIError)); }
2825         APIError(LDKAPIError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAPIError)); }
2826         operator LDKAPIError() && { LDKAPIError res = self; memset(&self, 0, sizeof(LDKAPIError)); return res; }
2827         ~APIError() { APIError_free(self); }
2828         APIError& operator=(APIError&& o) { APIError_free(self); self = o.self; memset(&o, 0, sizeof(APIError)); return *this; }
2829         LDKAPIError* operator &() { return &self; }
2830         LDKAPIError* operator ->() { return &self; }
2831         const LDKAPIError* operator &() const { return &self; }
2832         const LDKAPIError* operator ->() const { return &self; }
2833 };
2834 class TaggedHash {
2835 private:
2836         LDKTaggedHash self;
2837 public:
2838         TaggedHash(const TaggedHash&) = delete;
2839         TaggedHash(TaggedHash&& o) : self(o.self) { memset(&o, 0, sizeof(TaggedHash)); }
2840         TaggedHash(LDKTaggedHash&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTaggedHash)); }
2841         operator LDKTaggedHash() && { LDKTaggedHash res = self; memset(&self, 0, sizeof(LDKTaggedHash)); return res; }
2842         ~TaggedHash() { TaggedHash_free(self); }
2843         TaggedHash& operator=(TaggedHash&& o) { TaggedHash_free(self); self = o.self; memset(&o, 0, sizeof(TaggedHash)); return *this; }
2844         LDKTaggedHash* operator &() { return &self; }
2845         LDKTaggedHash* operator ->() { return &self; }
2846         const LDKTaggedHash* operator &() const { return &self; }
2847         const LDKTaggedHash* operator ->() const { return &self; }
2848 };
2849 class ChannelMonitorUpdate {
2850 private:
2851         LDKChannelMonitorUpdate self;
2852 public:
2853         ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete;
2854         ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); }
2855         ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); }
2856         operator LDKChannelMonitorUpdate() && { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; }
2857         ~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); }
2858         ChannelMonitorUpdate& operator=(ChannelMonitorUpdate&& o) { ChannelMonitorUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdate)); return *this; }
2859         LDKChannelMonitorUpdate* operator &() { return &self; }
2860         LDKChannelMonitorUpdate* operator ->() { return &self; }
2861         const LDKChannelMonitorUpdate* operator &() const { return &self; }
2862         const LDKChannelMonitorUpdate* operator ->() const { return &self; }
2863 };
2864 class MonitorEvent {
2865 private:
2866         LDKMonitorEvent self;
2867 public:
2868         MonitorEvent(const MonitorEvent&) = delete;
2869         MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); }
2870         MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); }
2871         operator LDKMonitorEvent() && { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; }
2872         ~MonitorEvent() { MonitorEvent_free(self); }
2873         MonitorEvent& operator=(MonitorEvent&& o) { MonitorEvent_free(self); self = o.self; memset(&o, 0, sizeof(MonitorEvent)); return *this; }
2874         LDKMonitorEvent* operator &() { return &self; }
2875         LDKMonitorEvent* operator ->() { return &self; }
2876         const LDKMonitorEvent* operator &() const { return &self; }
2877         const LDKMonitorEvent* operator ->() const { return &self; }
2878 };
2879 class HTLCUpdate {
2880 private:
2881         LDKHTLCUpdate self;
2882 public:
2883         HTLCUpdate(const HTLCUpdate&) = delete;
2884         HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); }
2885         HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); }
2886         operator LDKHTLCUpdate() && { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; }
2887         ~HTLCUpdate() { HTLCUpdate_free(self); }
2888         HTLCUpdate& operator=(HTLCUpdate&& o) { HTLCUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCUpdate)); return *this; }
2889         LDKHTLCUpdate* operator &() { return &self; }
2890         LDKHTLCUpdate* operator ->() { return &self; }
2891         const LDKHTLCUpdate* operator &() const { return &self; }
2892         const LDKHTLCUpdate* operator ->() const { return &self; }
2893 };
2894 class Balance {
2895 private:
2896         LDKBalance self;
2897 public:
2898         Balance(const Balance&) = delete;
2899         Balance(Balance&& o) : self(o.self) { memset(&o, 0, sizeof(Balance)); }
2900         Balance(LDKBalance&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBalance)); }
2901         operator LDKBalance() && { LDKBalance res = self; memset(&self, 0, sizeof(LDKBalance)); return res; }
2902         ~Balance() { Balance_free(self); }
2903         Balance& operator=(Balance&& o) { Balance_free(self); self = o.self; memset(&o, 0, sizeof(Balance)); return *this; }
2904         LDKBalance* operator &() { return &self; }
2905         LDKBalance* operator ->() { return &self; }
2906         const LDKBalance* operator &() const { return &self; }
2907         const LDKBalance* operator ->() const { return &self; }
2908 };
2909 class ChannelMonitor {
2910 private:
2911         LDKChannelMonitor self;
2912 public:
2913         ChannelMonitor(const ChannelMonitor&) = delete;
2914         ChannelMonitor(ChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitor)); }
2915         ChannelMonitor(LDKChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitor)); }
2916         operator LDKChannelMonitor() && { LDKChannelMonitor res = self; memset(&self, 0, sizeof(LDKChannelMonitor)); return res; }
2917         ~ChannelMonitor() { ChannelMonitor_free(self); }
2918         ChannelMonitor& operator=(ChannelMonitor&& o) { ChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitor)); return *this; }
2919         LDKChannelMonitor* operator &() { return &self; }
2920         LDKChannelMonitor* operator ->() { return &self; }
2921         const LDKChannelMonitor* operator &() const { return &self; }
2922         const LDKChannelMonitor* operator ->() const { return &self; }
2923 };
2924 class ExpandedKey {
2925 private:
2926         LDKExpandedKey self;
2927 public:
2928         ExpandedKey(const ExpandedKey&) = delete;
2929         ExpandedKey(ExpandedKey&& o) : self(o.self) { memset(&o, 0, sizeof(ExpandedKey)); }
2930         ExpandedKey(LDKExpandedKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpandedKey)); }
2931         operator LDKExpandedKey() && { LDKExpandedKey res = self; memset(&self, 0, sizeof(LDKExpandedKey)); return res; }
2932         ~ExpandedKey() { ExpandedKey_free(self); }
2933         ExpandedKey& operator=(ExpandedKey&& o) { ExpandedKey_free(self); self = o.self; memset(&o, 0, sizeof(ExpandedKey)); return *this; }
2934         LDKExpandedKey* operator &() { return &self; }
2935         LDKExpandedKey* operator ->() { return &self; }
2936         const LDKExpandedKey* operator &() const { return &self; }
2937         const LDKExpandedKey* operator ->() const { return &self; }
2938 };
2939 class CustomMessageHandler {
2940 private:
2941         LDKCustomMessageHandler self;
2942 public:
2943         CustomMessageHandler(const CustomMessageHandler&) = delete;
2944         CustomMessageHandler(CustomMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(CustomMessageHandler)); }
2945         CustomMessageHandler(LDKCustomMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomMessageHandler)); }
2946         operator LDKCustomMessageHandler() && { LDKCustomMessageHandler res = self; memset(&self, 0, sizeof(LDKCustomMessageHandler)); return res; }
2947         ~CustomMessageHandler() { CustomMessageHandler_free(self); }
2948         CustomMessageHandler& operator=(CustomMessageHandler&& o) { CustomMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(CustomMessageHandler)); return *this; }
2949         LDKCustomMessageHandler* operator &() { return &self; }
2950         LDKCustomMessageHandler* operator ->() { return &self; }
2951         const LDKCustomMessageHandler* operator &() const { return &self; }
2952         const LDKCustomMessageHandler* operator ->() const { return &self; }
2953         /**
2954          *  Handles the given message sent from `sender_node_id`, possibly producing messages for
2955          *  [`CustomMessageHandler::get_and_clear_pending_msg`] to return and thus for [`PeerManager`]
2956          *  to send.
2957          */
2958         inline LDK::CResult_NoneLightningErrorZ handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id);
2959         /**
2960          *  Returns the list of pending messages that were generated by the handler, clearing the list
2961          *  in the process. Each message is paired with the node id of the intended recipient. If no
2962          *  connection to the node exists, then the message is simply not sent.
2963          */
2964         inline LDK::CVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg();
2965         /**
2966          *  Gets the node feature flags which this handler itself supports. All available handlers are
2967          *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
2968          *  which are broadcasted in our [`NodeAnnouncement`] message.
2969          *
2970          *  [`NodeAnnouncement`]: crate::ln::msgs::NodeAnnouncement
2971          */
2972         inline LDK::NodeFeatures provided_node_features();
2973         /**
2974          *  Gets the init feature flags which should be sent to the given peer. All available handlers
2975          *  are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
2976          *  which are sent in our [`Init`] message.
2977          *
2978          *  [`Init`]: crate::ln::msgs::Init
2979          */
2980         inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
2981 };
2982 class IgnoringMessageHandler {
2983 private:
2984         LDKIgnoringMessageHandler self;
2985 public:
2986         IgnoringMessageHandler(const IgnoringMessageHandler&) = delete;
2987         IgnoringMessageHandler(IgnoringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(IgnoringMessageHandler)); }
2988         IgnoringMessageHandler(LDKIgnoringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKIgnoringMessageHandler)); }
2989         operator LDKIgnoringMessageHandler() && { LDKIgnoringMessageHandler res = self; memset(&self, 0, sizeof(LDKIgnoringMessageHandler)); return res; }
2990         ~IgnoringMessageHandler() { IgnoringMessageHandler_free(self); }
2991         IgnoringMessageHandler& operator=(IgnoringMessageHandler&& o) { IgnoringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(IgnoringMessageHandler)); return *this; }
2992         LDKIgnoringMessageHandler* operator &() { return &self; }
2993         LDKIgnoringMessageHandler* operator ->() { return &self; }
2994         const LDKIgnoringMessageHandler* operator &() const { return &self; }
2995         const LDKIgnoringMessageHandler* operator ->() const { return &self; }
2996 };
2997 class ErroringMessageHandler {
2998 private:
2999         LDKErroringMessageHandler self;
3000 public:
3001         ErroringMessageHandler(const ErroringMessageHandler&) = delete;
3002         ErroringMessageHandler(ErroringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ErroringMessageHandler)); }
3003         ErroringMessageHandler(LDKErroringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroringMessageHandler)); }
3004         operator LDKErroringMessageHandler() && { LDKErroringMessageHandler res = self; memset(&self, 0, sizeof(LDKErroringMessageHandler)); return res; }
3005         ~ErroringMessageHandler() { ErroringMessageHandler_free(self); }
3006         ErroringMessageHandler& operator=(ErroringMessageHandler&& o) { ErroringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ErroringMessageHandler)); return *this; }
3007         LDKErroringMessageHandler* operator &() { return &self; }
3008         LDKErroringMessageHandler* operator ->() { return &self; }
3009         const LDKErroringMessageHandler* operator &() const { return &self; }
3010         const LDKErroringMessageHandler* operator ->() const { return &self; }
3011 };
3012 class MessageHandler {
3013 private:
3014         LDKMessageHandler self;
3015 public:
3016         MessageHandler(const MessageHandler&) = delete;
3017         MessageHandler(MessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(MessageHandler)); }
3018         MessageHandler(LDKMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageHandler)); }
3019         operator LDKMessageHandler() && { LDKMessageHandler res = self; memset(&self, 0, sizeof(LDKMessageHandler)); return res; }
3020         ~MessageHandler() { MessageHandler_free(self); }
3021         MessageHandler& operator=(MessageHandler&& o) { MessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(MessageHandler)); return *this; }
3022         LDKMessageHandler* operator &() { return &self; }
3023         LDKMessageHandler* operator ->() { return &self; }
3024         const LDKMessageHandler* operator &() const { return &self; }
3025         const LDKMessageHandler* operator ->() const { return &self; }
3026 };
3027 class SocketDescriptor {
3028 private:
3029         LDKSocketDescriptor self;
3030 public:
3031         SocketDescriptor(const SocketDescriptor&) = delete;
3032         SocketDescriptor(SocketDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SocketDescriptor)); }
3033         SocketDescriptor(LDKSocketDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketDescriptor)); }
3034         operator LDKSocketDescriptor() && { LDKSocketDescriptor res = self; memset(&self, 0, sizeof(LDKSocketDescriptor)); return res; }
3035         ~SocketDescriptor() { SocketDescriptor_free(self); }
3036         SocketDescriptor& operator=(SocketDescriptor&& o) { SocketDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SocketDescriptor)); return *this; }
3037         LDKSocketDescriptor* operator &() { return &self; }
3038         LDKSocketDescriptor* operator ->() { return &self; }
3039         const LDKSocketDescriptor* operator &() const { return &self; }
3040         const LDKSocketDescriptor* operator ->() const { return &self; }
3041         /**
3042          *  Attempts to send some data from the given slice to the peer.
3043          *
3044          *  Returns the amount of data which was sent, possibly 0 if the socket has since disconnected.
3045          *  Note that in the disconnected case, [`PeerManager::socket_disconnected`] must still be
3046          *  called and further write attempts may occur until that time.
3047          *
3048          *  If the returned size is smaller than `data.len()`, a
3049          *  [`PeerManager::write_buffer_space_avail`] call must be made the next time more data can be
3050          *  written. Additionally, until a `send_data` event completes fully, no further
3051          *  [`PeerManager::read_event`] calls should be made for the same peer! Because this is to
3052          *  prevent denial-of-service issues, you should not read or buffer any data from the socket
3053          *  until then.
3054          *
3055          *  If a [`PeerManager::read_event`] call on this descriptor had previously returned true
3056          *  (indicating that read events should be paused to prevent DoS in the send buffer),
3057          *  `resume_read` may be set indicating that read events on this descriptor should resume. A
3058          *  `resume_read` of false carries no meaning, and should not cause any action.
3059          */
3060         inline uintptr_t send_data(struct LDKu8slice data, bool resume_read);
3061         /**
3062          *  Disconnect the socket pointed to by this SocketDescriptor.
3063          *
3064          *  You do *not* need to call [`PeerManager::socket_disconnected`] with this socket after this
3065          *  call (doing so is a noop).
3066          */
3067         inline void disconnect_socket();
3068         /** Checks if two objects are equal given this object's this_arg pointer and another object. */
3069         inline bool eq(const struct LDKSocketDescriptor *NONNULL_PTR other_arg);
3070         /**
3071          * Calculate a succinct non-cryptographic hash for an object given its this_arg pointer.
3072          * This is used, for example, for inclusion of this object in a hash map.
3073          */
3074         inline uint64_t hash();
3075 };
3076 class PeerHandleError {
3077 private:
3078         LDKPeerHandleError self;
3079 public:
3080         PeerHandleError(const PeerHandleError&) = delete;
3081         PeerHandleError(PeerHandleError&& o) : self(o.self) { memset(&o, 0, sizeof(PeerHandleError)); }
3082         PeerHandleError(LDKPeerHandleError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerHandleError)); }
3083         operator LDKPeerHandleError() && { LDKPeerHandleError res = self; memset(&self, 0, sizeof(LDKPeerHandleError)); return res; }
3084         ~PeerHandleError() { PeerHandleError_free(self); }
3085         PeerHandleError& operator=(PeerHandleError&& o) { PeerHandleError_free(self); self = o.self; memset(&o, 0, sizeof(PeerHandleError)); return *this; }
3086         LDKPeerHandleError* operator &() { return &self; }
3087         LDKPeerHandleError* operator ->() { return &self; }
3088         const LDKPeerHandleError* operator &() const { return &self; }
3089         const LDKPeerHandleError* operator ->() const { return &self; }
3090 };
3091 class PeerManager {
3092 private:
3093         LDKPeerManager self;
3094 public:
3095         PeerManager(const PeerManager&) = delete;
3096         PeerManager(PeerManager&& o) : self(o.self) { memset(&o, 0, sizeof(PeerManager)); }
3097         PeerManager(LDKPeerManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerManager)); }
3098         operator LDKPeerManager() && { LDKPeerManager res = self; memset(&self, 0, sizeof(LDKPeerManager)); return res; }
3099         ~PeerManager() { PeerManager_free(self); }
3100         PeerManager& operator=(PeerManager&& o) { PeerManager_free(self); self = o.self; memset(&o, 0, sizeof(PeerManager)); return *this; }
3101         LDKPeerManager* operator &() { return &self; }
3102         LDKPeerManager* operator ->() { return &self; }
3103         const LDKPeerManager* operator &() const { return &self; }
3104         const LDKPeerManager* operator ->() const { return &self; }
3105 };
3106 class RapidGossipSync {
3107 private:
3108         LDKRapidGossipSync self;
3109 public:
3110         RapidGossipSync(const RapidGossipSync&) = delete;
3111         RapidGossipSync(RapidGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(RapidGossipSync)); }
3112         RapidGossipSync(LDKRapidGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRapidGossipSync)); }
3113         operator LDKRapidGossipSync() && { LDKRapidGossipSync res = self; memset(&self, 0, sizeof(LDKRapidGossipSync)); return res; }
3114         ~RapidGossipSync() { RapidGossipSync_free(self); }
3115         RapidGossipSync& operator=(RapidGossipSync&& o) { RapidGossipSync_free(self); self = o.self; memset(&o, 0, sizeof(RapidGossipSync)); return *this; }
3116         LDKRapidGossipSync* operator &() { return &self; }
3117         LDKRapidGossipSync* operator ->() { return &self; }
3118         const LDKRapidGossipSync* operator &() const { return &self; }
3119         const LDKRapidGossipSync* operator ->() const { return &self; }
3120 };
3121 class KVStore {
3122 private:
3123         LDKKVStore self;
3124 public:
3125         KVStore(const KVStore&) = delete;
3126         KVStore(KVStore&& o) : self(o.self) { memset(&o, 0, sizeof(KVStore)); }
3127         KVStore(LDKKVStore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKVStore)); }
3128         operator LDKKVStore() && { LDKKVStore res = self; memset(&self, 0, sizeof(LDKKVStore)); return res; }
3129         ~KVStore() { KVStore_free(self); }
3130         KVStore& operator=(KVStore&& o) { KVStore_free(self); self = o.self; memset(&o, 0, sizeof(KVStore)); return *this; }
3131         LDKKVStore* operator &() { return &self; }
3132         LDKKVStore* operator ->() { return &self; }
3133         const LDKKVStore* operator &() const { return &self; }
3134         const LDKKVStore* operator ->() const { return &self; }
3135         /**
3136          *  Returns the data stored for the given `primary_namespace`, `secondary_namespace`, and
3137          *  `key`.
3138          *
3139          *  Returns an [`ErrorKind::NotFound`] if the given `key` could not be found in the given
3140          *  `primary_namespace` and `secondary_namespace`.
3141          *
3142          *  [`ErrorKind::NotFound`]: io::ErrorKind::NotFound
3143          */
3144         inline LDK::CResult_CVec_u8ZIOErrorZ read(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key);
3145         /**
3146          *  Persists the given data under the given `key`.
3147          *
3148          *  Will create the given `primary_namespace` and `secondary_namespace` if not already present
3149          *  in the store.
3150          */
3151         inline LDK::CResult_NoneIOErrorZ write(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, struct LDKu8slice buf);
3152         /**
3153          *  Removes any data that had previously been persisted under the given `key`.
3154          *
3155          *  If the `lazy` flag is set to `true`, the backend implementation might choose to lazily
3156          *  remove the given `key` at some point in time after the method returns, e.g., as part of an
3157          *  eventual batch deletion of multiple keys. As a consequence, subsequent calls to
3158          *  [`KVStore::list`] might include the removed key until the changes are actually persisted.
3159          *
3160          *  Note that while setting the `lazy` flag reduces the I/O burden of multiple subsequent
3161          *  `remove` calls, it also influences the atomicity guarantees as lazy `remove`s could
3162          *  potentially get lost on crash after the method returns. Therefore, this flag should only be
3163          *  set for `remove` operations that can be safely replayed at a later time.
3164          *
3165          *  Returns successfully if no data will be stored for the given `primary_namespace`,
3166          *  `secondary_namespace`, and `key`, independently of whether it was present before its
3167          *  invokation or not.
3168          */
3169         inline LDK::CResult_NoneIOErrorZ remove(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, bool lazy);
3170         /**
3171          *  Returns a list of keys that are stored under the given `secondary_namespace` in
3172          *  `primary_namespace`.
3173          *
3174          *  Returns the keys in arbitrary order, so users requiring a particular order need to sort the
3175          *  returned keys. Returns an empty list if `primary_namespace` or `secondary_namespace` is unknown.
3176          */
3177         inline LDK::CResult_CVec_StrZIOErrorZ list(struct LDKStr primary_namespace, struct LDKStr secondary_namespace);
3178 };
3179 class Persister {
3180 private:
3181         LDKPersister self;
3182 public:
3183         Persister(const Persister&) = delete;
3184         Persister(Persister&& o) : self(o.self) { memset(&o, 0, sizeof(Persister)); }
3185         Persister(LDKPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersister)); }
3186         operator LDKPersister() && { LDKPersister res = self; memset(&self, 0, sizeof(LDKPersister)); return res; }
3187         ~Persister() { Persister_free(self); }
3188         Persister& operator=(Persister&& o) { Persister_free(self); self = o.self; memset(&o, 0, sizeof(Persister)); return *this; }
3189         LDKPersister* operator &() { return &self; }
3190         LDKPersister* operator ->() { return &self; }
3191         const LDKPersister* operator &() const { return &self; }
3192         const LDKPersister* operator ->() const { return &self; }
3193         /**
3194          *  Persist the given ['ChannelManager'] to disk, returning an error if persistence failed.
3195          */
3196         inline LDK::CResult_NoneIOErrorZ persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager);
3197         /**
3198          *  Persist the given [`NetworkGraph`] to disk, returning an error if persistence failed.
3199          */
3200         inline LDK::CResult_NoneIOErrorZ persist_graph(const struct LDKNetworkGraph *NONNULL_PTR network_graph);
3201         /**
3202          *  Persist the given [`WriteableScore`] to disk, returning an error if persistence failed.
3203          */
3204         inline LDK::CResult_NoneIOErrorZ persist_scorer(const struct LDKWriteableScore *NONNULL_PTR scorer);
3205 };
3206 class MonitorUpdatingPersister {
3207 private:
3208         LDKMonitorUpdatingPersister self;
3209 public:
3210         MonitorUpdatingPersister(const MonitorUpdatingPersister&) = delete;
3211         MonitorUpdatingPersister(MonitorUpdatingPersister&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdatingPersister)); }
3212         MonitorUpdatingPersister(LDKMonitorUpdatingPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdatingPersister)); }
3213         operator LDKMonitorUpdatingPersister() && { LDKMonitorUpdatingPersister res = self; memset(&self, 0, sizeof(LDKMonitorUpdatingPersister)); return res; }
3214         ~MonitorUpdatingPersister() { MonitorUpdatingPersister_free(self); }
3215         MonitorUpdatingPersister& operator=(MonitorUpdatingPersister&& o) { MonitorUpdatingPersister_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdatingPersister)); return *this; }
3216         LDKMonitorUpdatingPersister* operator &() { return &self; }
3217         LDKMonitorUpdatingPersister* operator ->() { return &self; }
3218         const LDKMonitorUpdatingPersister* operator &() const { return &self; }
3219         const LDKMonitorUpdatingPersister* operator ->() const { return &self; }
3220 };
3221 class UnsignedInvoiceRequest {
3222 private:
3223         LDKUnsignedInvoiceRequest self;
3224 public:
3225         UnsignedInvoiceRequest(const UnsignedInvoiceRequest&) = delete;
3226         UnsignedInvoiceRequest(UnsignedInvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedInvoiceRequest)); }
3227         UnsignedInvoiceRequest(LDKUnsignedInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedInvoiceRequest)); }
3228         operator LDKUnsignedInvoiceRequest() && { LDKUnsignedInvoiceRequest res = self; memset(&self, 0, sizeof(LDKUnsignedInvoiceRequest)); return res; }
3229         ~UnsignedInvoiceRequest() { UnsignedInvoiceRequest_free(self); }
3230         UnsignedInvoiceRequest& operator=(UnsignedInvoiceRequest&& o) { UnsignedInvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedInvoiceRequest)); return *this; }
3231         LDKUnsignedInvoiceRequest* operator &() { return &self; }
3232         LDKUnsignedInvoiceRequest* operator ->() { return &self; }
3233         const LDKUnsignedInvoiceRequest* operator &() const { return &self; }
3234         const LDKUnsignedInvoiceRequest* operator ->() const { return &self; }
3235 };
3236 class InvoiceRequest {
3237 private:
3238         LDKInvoiceRequest self;
3239 public:
3240         InvoiceRequest(const InvoiceRequest&) = delete;
3241         InvoiceRequest(InvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequest)); }
3242         InvoiceRequest(LDKInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequest)); }
3243         operator LDKInvoiceRequest() && { LDKInvoiceRequest res = self; memset(&self, 0, sizeof(LDKInvoiceRequest)); return res; }
3244         ~InvoiceRequest() { InvoiceRequest_free(self); }
3245         InvoiceRequest& operator=(InvoiceRequest&& o) { InvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequest)); return *this; }
3246         LDKInvoiceRequest* operator &() { return &self; }
3247         LDKInvoiceRequest* operator ->() { return &self; }
3248         const LDKInvoiceRequest* operator &() const { return &self; }
3249         const LDKInvoiceRequest* operator ->() const { return &self; }
3250 };
3251 class VerifiedInvoiceRequest {
3252 private:
3253         LDKVerifiedInvoiceRequest self;
3254 public:
3255         VerifiedInvoiceRequest(const VerifiedInvoiceRequest&) = delete;
3256         VerifiedInvoiceRequest(VerifiedInvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(VerifiedInvoiceRequest)); }
3257         VerifiedInvoiceRequest(LDKVerifiedInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKVerifiedInvoiceRequest)); }
3258         operator LDKVerifiedInvoiceRequest() && { LDKVerifiedInvoiceRequest res = self; memset(&self, 0, sizeof(LDKVerifiedInvoiceRequest)); return res; }
3259         ~VerifiedInvoiceRequest() { VerifiedInvoiceRequest_free(self); }
3260         VerifiedInvoiceRequest& operator=(VerifiedInvoiceRequest&& o) { VerifiedInvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(VerifiedInvoiceRequest)); return *this; }
3261         LDKVerifiedInvoiceRequest* operator &() { return &self; }
3262         LDKVerifiedInvoiceRequest* operator ->() { return &self; }
3263         const LDKVerifiedInvoiceRequest* operator &() const { return &self; }
3264         const LDKVerifiedInvoiceRequest* operator ->() const { return &self; }
3265 };
3266 class DecodeError {
3267 private:
3268         LDKDecodeError self;
3269 public:
3270         DecodeError(const DecodeError&) = delete;
3271         DecodeError(DecodeError&& o) : self(o.self) { memset(&o, 0, sizeof(DecodeError)); }
3272         DecodeError(LDKDecodeError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDecodeError)); }
3273         operator LDKDecodeError() && { LDKDecodeError res = self; memset(&self, 0, sizeof(LDKDecodeError)); return res; }
3274         ~DecodeError() { DecodeError_free(self); }
3275         DecodeError& operator=(DecodeError&& o) { DecodeError_free(self); self = o.self; memset(&o, 0, sizeof(DecodeError)); return *this; }
3276         LDKDecodeError* operator &() { return &self; }
3277         LDKDecodeError* operator ->() { return &self; }
3278         const LDKDecodeError* operator &() const { return &self; }
3279         const LDKDecodeError* operator ->() const { return &self; }
3280 };
3281 class Init {
3282 private:
3283         LDKInit self;
3284 public:
3285         Init(const Init&) = delete;
3286         Init(Init&& o) : self(o.self) { memset(&o, 0, sizeof(Init)); }
3287         Init(LDKInit&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInit)); }
3288         operator LDKInit() && { LDKInit res = self; memset(&self, 0, sizeof(LDKInit)); return res; }
3289         ~Init() { Init_free(self); }
3290         Init& operator=(Init&& o) { Init_free(self); self = o.self; memset(&o, 0, sizeof(Init)); return *this; }
3291         LDKInit* operator &() { return &self; }
3292         LDKInit* operator ->() { return &self; }
3293         const LDKInit* operator &() const { return &self; }
3294         const LDKInit* operator ->() const { return &self; }
3295 };
3296 class ErrorMessage {
3297 private:
3298         LDKErrorMessage self;
3299 public:
3300         ErrorMessage(const ErrorMessage&) = delete;
3301         ErrorMessage(ErrorMessage&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorMessage)); }
3302         ErrorMessage(LDKErrorMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorMessage)); }
3303         operator LDKErrorMessage() && { LDKErrorMessage res = self; memset(&self, 0, sizeof(LDKErrorMessage)); return res; }
3304         ~ErrorMessage() { ErrorMessage_free(self); }
3305         ErrorMessage& operator=(ErrorMessage&& o) { ErrorMessage_free(self); self = o.self; memset(&o, 0, sizeof(ErrorMessage)); return *this; }
3306         LDKErrorMessage* operator &() { return &self; }
3307         LDKErrorMessage* operator ->() { return &self; }
3308         const LDKErrorMessage* operator &() const { return &self; }
3309         const LDKErrorMessage* operator ->() const { return &self; }
3310 };
3311 class WarningMessage {
3312 private:
3313         LDKWarningMessage self;
3314 public:
3315         WarningMessage(const WarningMessage&) = delete;
3316         WarningMessage(WarningMessage&& o) : self(o.self) { memset(&o, 0, sizeof(WarningMessage)); }
3317         WarningMessage(LDKWarningMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWarningMessage)); }
3318         operator LDKWarningMessage() && { LDKWarningMessage res = self; memset(&self, 0, sizeof(LDKWarningMessage)); return res; }
3319         ~WarningMessage() { WarningMessage_free(self); }
3320         WarningMessage& operator=(WarningMessage&& o) { WarningMessage_free(self); self = o.self; memset(&o, 0, sizeof(WarningMessage)); return *this; }
3321         LDKWarningMessage* operator &() { return &self; }
3322         LDKWarningMessage* operator ->() { return &self; }
3323         const LDKWarningMessage* operator &() const { return &self; }
3324         const LDKWarningMessage* operator ->() const { return &self; }
3325 };
3326 class Ping {
3327 private:
3328         LDKPing self;
3329 public:
3330         Ping(const Ping&) = delete;
3331         Ping(Ping&& o) : self(o.self) { memset(&o, 0, sizeof(Ping)); }
3332         Ping(LDKPing&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPing)); }
3333         operator LDKPing() && { LDKPing res = self; memset(&self, 0, sizeof(LDKPing)); return res; }
3334         ~Ping() { Ping_free(self); }
3335         Ping& operator=(Ping&& o) { Ping_free(self); self = o.self; memset(&o, 0, sizeof(Ping)); return *this; }
3336         LDKPing* operator &() { return &self; }
3337         LDKPing* operator ->() { return &self; }
3338         const LDKPing* operator &() const { return &self; }
3339         const LDKPing* operator ->() const { return &self; }
3340 };
3341 class Pong {
3342 private:
3343         LDKPong self;
3344 public:
3345         Pong(const Pong&) = delete;
3346         Pong(Pong&& o) : self(o.self) { memset(&o, 0, sizeof(Pong)); }
3347         Pong(LDKPong&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPong)); }
3348         operator LDKPong() && { LDKPong res = self; memset(&self, 0, sizeof(LDKPong)); return res; }
3349         ~Pong() { Pong_free(self); }
3350         Pong& operator=(Pong&& o) { Pong_free(self); self = o.self; memset(&o, 0, sizeof(Pong)); return *this; }
3351         LDKPong* operator &() { return &self; }
3352         LDKPong* operator ->() { return &self; }
3353         const LDKPong* operator &() const { return &self; }
3354         const LDKPong* operator ->() const { return &self; }
3355 };
3356 class OpenChannel {
3357 private:
3358         LDKOpenChannel self;
3359 public:
3360         OpenChannel(const OpenChannel&) = delete;
3361         OpenChannel(OpenChannel&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannel)); }
3362         OpenChannel(LDKOpenChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannel)); }
3363         operator LDKOpenChannel() && { LDKOpenChannel res = self; memset(&self, 0, sizeof(LDKOpenChannel)); return res; }
3364         ~OpenChannel() { OpenChannel_free(self); }
3365         OpenChannel& operator=(OpenChannel&& o) { OpenChannel_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannel)); return *this; }
3366         LDKOpenChannel* operator &() { return &self; }
3367         LDKOpenChannel* operator ->() { return &self; }
3368         const LDKOpenChannel* operator &() const { return &self; }
3369         const LDKOpenChannel* operator ->() const { return &self; }
3370 };
3371 class OpenChannelV2 {
3372 private:
3373         LDKOpenChannelV2 self;
3374 public:
3375         OpenChannelV2(const OpenChannelV2&) = delete;
3376         OpenChannelV2(OpenChannelV2&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannelV2)); }
3377         OpenChannelV2(LDKOpenChannelV2&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannelV2)); }
3378         operator LDKOpenChannelV2() && { LDKOpenChannelV2 res = self; memset(&self, 0, sizeof(LDKOpenChannelV2)); return res; }
3379         ~OpenChannelV2() { OpenChannelV2_free(self); }
3380         OpenChannelV2& operator=(OpenChannelV2&& o) { OpenChannelV2_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannelV2)); return *this; }
3381         LDKOpenChannelV2* operator &() { return &self; }
3382         LDKOpenChannelV2* operator ->() { return &self; }
3383         const LDKOpenChannelV2* operator &() const { return &self; }
3384         const LDKOpenChannelV2* operator ->() const { return &self; }
3385 };
3386 class AcceptChannel {
3387 private:
3388         LDKAcceptChannel self;
3389 public:
3390         AcceptChannel(const AcceptChannel&) = delete;
3391         AcceptChannel(AcceptChannel&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannel)); }
3392         AcceptChannel(LDKAcceptChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannel)); }
3393         operator LDKAcceptChannel() && { LDKAcceptChannel res = self; memset(&self, 0, sizeof(LDKAcceptChannel)); return res; }
3394         ~AcceptChannel() { AcceptChannel_free(self); }
3395         AcceptChannel& operator=(AcceptChannel&& o) { AcceptChannel_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannel)); return *this; }
3396         LDKAcceptChannel* operator &() { return &self; }
3397         LDKAcceptChannel* operator ->() { return &self; }
3398         const LDKAcceptChannel* operator &() const { return &self; }
3399         const LDKAcceptChannel* operator ->() const { return &self; }
3400 };
3401 class AcceptChannelV2 {
3402 private:
3403         LDKAcceptChannelV2 self;
3404 public:
3405         AcceptChannelV2(const AcceptChannelV2&) = delete;
3406         AcceptChannelV2(AcceptChannelV2&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannelV2)); }
3407         AcceptChannelV2(LDKAcceptChannelV2&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannelV2)); }
3408         operator LDKAcceptChannelV2() && { LDKAcceptChannelV2 res = self; memset(&self, 0, sizeof(LDKAcceptChannelV2)); return res; }
3409         ~AcceptChannelV2() { AcceptChannelV2_free(self); }
3410         AcceptChannelV2& operator=(AcceptChannelV2&& o) { AcceptChannelV2_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannelV2)); return *this; }
3411         LDKAcceptChannelV2* operator &() { return &self; }
3412         LDKAcceptChannelV2* operator ->() { return &self; }
3413         const LDKAcceptChannelV2* operator &() const { return &self; }
3414         const LDKAcceptChannelV2* operator ->() const { return &self; }
3415 };
3416 class FundingCreated {
3417 private:
3418         LDKFundingCreated self;
3419 public:
3420         FundingCreated(const FundingCreated&) = delete;
3421         FundingCreated(FundingCreated&& o) : self(o.self) { memset(&o, 0, sizeof(FundingCreated)); }
3422         FundingCreated(LDKFundingCreated&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingCreated)); }
3423         operator LDKFundingCreated() && { LDKFundingCreated res = self; memset(&self, 0, sizeof(LDKFundingCreated)); return res; }
3424         ~FundingCreated() { FundingCreated_free(self); }
3425         FundingCreated& operator=(FundingCreated&& o) { FundingCreated_free(self); self = o.self; memset(&o, 0, sizeof(FundingCreated)); return *this; }
3426         LDKFundingCreated* operator &() { return &self; }
3427         LDKFundingCreated* operator ->() { return &self; }
3428         const LDKFundingCreated* operator &() const { return &self; }
3429         const LDKFundingCreated* operator ->() const { return &self; }
3430 };
3431 class FundingSigned {
3432 private:
3433         LDKFundingSigned self;
3434 public:
3435         FundingSigned(const FundingSigned&) = delete;
3436         FundingSigned(FundingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(FundingSigned)); }
3437         FundingSigned(LDKFundingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingSigned)); }
3438         operator LDKFundingSigned() && { LDKFundingSigned res = self; memset(&self, 0, sizeof(LDKFundingSigned)); return res; }
3439         ~FundingSigned() { FundingSigned_free(self); }
3440         FundingSigned& operator=(FundingSigned&& o) { FundingSigned_free(self); self = o.self; memset(&o, 0, sizeof(FundingSigned)); return *this; }
3441         LDKFundingSigned* operator &() { return &self; }
3442         LDKFundingSigned* operator ->() { return &self; }
3443         const LDKFundingSigned* operator &() const { return &self; }
3444         const LDKFundingSigned* operator ->() const { return &self; }
3445 };
3446 class ChannelReady {
3447 private:
3448         LDKChannelReady self;
3449 public:
3450         ChannelReady(const ChannelReady&) = delete;
3451         ChannelReady(ChannelReady&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReady)); }
3452         ChannelReady(LDKChannelReady&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReady)); }
3453         operator LDKChannelReady() && { LDKChannelReady res = self; memset(&self, 0, sizeof(LDKChannelReady)); return res; }
3454         ~ChannelReady() { ChannelReady_free(self); }
3455         ChannelReady& operator=(ChannelReady&& o) { ChannelReady_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReady)); return *this; }
3456         LDKChannelReady* operator &() { return &self; }
3457         LDKChannelReady* operator ->() { return &self; }
3458         const LDKChannelReady* operator &() const { return &self; }
3459         const LDKChannelReady* operator ->() const { return &self; }
3460 };
3461 class TxAddInput {
3462 private:
3463         LDKTxAddInput self;
3464 public:
3465         TxAddInput(const TxAddInput&) = delete;
3466         TxAddInput(TxAddInput&& o) : self(o.self) { memset(&o, 0, sizeof(TxAddInput)); }
3467         TxAddInput(LDKTxAddInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAddInput)); }
3468         operator LDKTxAddInput() && { LDKTxAddInput res = self; memset(&self, 0, sizeof(LDKTxAddInput)); return res; }
3469         ~TxAddInput() { TxAddInput_free(self); }
3470         TxAddInput& operator=(TxAddInput&& o) { TxAddInput_free(self); self = o.self; memset(&o, 0, sizeof(TxAddInput)); return *this; }
3471         LDKTxAddInput* operator &() { return &self; }
3472         LDKTxAddInput* operator ->() { return &self; }
3473         const LDKTxAddInput* operator &() const { return &self; }
3474         const LDKTxAddInput* operator ->() const { return &self; }
3475 };
3476 class TxAddOutput {
3477 private:
3478         LDKTxAddOutput self;
3479 public:
3480         TxAddOutput(const TxAddOutput&) = delete;
3481         TxAddOutput(TxAddOutput&& o) : self(o.self) { memset(&o, 0, sizeof(TxAddOutput)); }
3482         TxAddOutput(LDKTxAddOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAddOutput)); }
3483         operator LDKTxAddOutput() && { LDKTxAddOutput res = self; memset(&self, 0, sizeof(LDKTxAddOutput)); return res; }
3484         ~TxAddOutput() { TxAddOutput_free(self); }
3485         TxAddOutput& operator=(TxAddOutput&& o) { TxAddOutput_free(self); self = o.self; memset(&o, 0, sizeof(TxAddOutput)); return *this; }
3486         LDKTxAddOutput* operator &() { return &self; }
3487         LDKTxAddOutput* operator ->() { return &self; }
3488         const LDKTxAddOutput* operator &() const { return &self; }
3489         const LDKTxAddOutput* operator ->() const { return &self; }
3490 };
3491 class TxRemoveInput {
3492 private:
3493         LDKTxRemoveInput self;
3494 public:
3495         TxRemoveInput(const TxRemoveInput&) = delete;
3496         TxRemoveInput(TxRemoveInput&& o) : self(o.self) { memset(&o, 0, sizeof(TxRemoveInput)); }
3497         TxRemoveInput(LDKTxRemoveInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxRemoveInput)); }
3498         operator LDKTxRemoveInput() && { LDKTxRemoveInput res = self; memset(&self, 0, sizeof(LDKTxRemoveInput)); return res; }
3499         ~TxRemoveInput() { TxRemoveInput_free(self); }
3500         TxRemoveInput& operator=(TxRemoveInput&& o) { TxRemoveInput_free(self); self = o.self; memset(&o, 0, sizeof(TxRemoveInput)); return *this; }
3501         LDKTxRemoveInput* operator &() { return &self; }
3502         LDKTxRemoveInput* operator ->() { return &self; }
3503         const LDKTxRemoveInput* operator &() const { return &self; }
3504         const LDKTxRemoveInput* operator ->() const { return &self; }
3505 };
3506 class TxRemoveOutput {
3507 private:
3508         LDKTxRemoveOutput self;
3509 public:
3510         TxRemoveOutput(const TxRemoveOutput&) = delete;
3511         TxRemoveOutput(TxRemoveOutput&& o) : self(o.self) { memset(&o, 0, sizeof(TxRemoveOutput)); }
3512         TxRemoveOutput(LDKTxRemoveOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxRemoveOutput)); }
3513         operator LDKTxRemoveOutput() && { LDKTxRemoveOutput res = self; memset(&self, 0, sizeof(LDKTxRemoveOutput)); return res; }
3514         ~TxRemoveOutput() { TxRemoveOutput_free(self); }
3515         TxRemoveOutput& operator=(TxRemoveOutput&& o) { TxRemoveOutput_free(self); self = o.self; memset(&o, 0, sizeof(TxRemoveOutput)); return *this; }
3516         LDKTxRemoveOutput* operator &() { return &self; }
3517         LDKTxRemoveOutput* operator ->() { return &self; }
3518         const LDKTxRemoveOutput* operator &() const { return &self; }
3519         const LDKTxRemoveOutput* operator ->() const { return &self; }
3520 };
3521 class TxComplete {
3522 private:
3523         LDKTxComplete self;
3524 public:
3525         TxComplete(const TxComplete&) = delete;
3526         TxComplete(TxComplete&& o) : self(o.self) { memset(&o, 0, sizeof(TxComplete)); }
3527         TxComplete(LDKTxComplete&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxComplete)); }
3528         operator LDKTxComplete() && { LDKTxComplete res = self; memset(&self, 0, sizeof(LDKTxComplete)); return res; }
3529         ~TxComplete() { TxComplete_free(self); }
3530         TxComplete& operator=(TxComplete&& o) { TxComplete_free(self); self = o.self; memset(&o, 0, sizeof(TxComplete)); return *this; }
3531         LDKTxComplete* operator &() { return &self; }
3532         LDKTxComplete* operator ->() { return &self; }
3533         const LDKTxComplete* operator &() const { return &self; }
3534         const LDKTxComplete* operator ->() const { return &self; }
3535 };
3536 class TxSignatures {
3537 private:
3538         LDKTxSignatures self;
3539 public:
3540         TxSignatures(const TxSignatures&) = delete;
3541         TxSignatures(TxSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(TxSignatures)); }
3542         TxSignatures(LDKTxSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxSignatures)); }
3543         operator LDKTxSignatures() && { LDKTxSignatures res = self; memset(&self, 0, sizeof(LDKTxSignatures)); return res; }
3544         ~TxSignatures() { TxSignatures_free(self); }
3545         TxSignatures& operator=(TxSignatures&& o) { TxSignatures_free(self); self = o.self; memset(&o, 0, sizeof(TxSignatures)); return *this; }
3546         LDKTxSignatures* operator &() { return &self; }
3547         LDKTxSignatures* operator ->() { return &self; }
3548         const LDKTxSignatures* operator &() const { return &self; }
3549         const LDKTxSignatures* operator ->() const { return &self; }
3550 };
3551 class TxInitRbf {
3552 private:
3553         LDKTxInitRbf self;
3554 public:
3555         TxInitRbf(const TxInitRbf&) = delete;
3556         TxInitRbf(TxInitRbf&& o) : self(o.self) { memset(&o, 0, sizeof(TxInitRbf)); }
3557         TxInitRbf(LDKTxInitRbf&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxInitRbf)); }
3558         operator LDKTxInitRbf() && { LDKTxInitRbf res = self; memset(&self, 0, sizeof(LDKTxInitRbf)); return res; }
3559         ~TxInitRbf() { TxInitRbf_free(self); }
3560         TxInitRbf& operator=(TxInitRbf&& o) { TxInitRbf_free(self); self = o.self; memset(&o, 0, sizeof(TxInitRbf)); return *this; }
3561         LDKTxInitRbf* operator &() { return &self; }
3562         LDKTxInitRbf* operator ->() { return &self; }
3563         const LDKTxInitRbf* operator &() const { return &self; }
3564         const LDKTxInitRbf* operator ->() const { return &self; }
3565 };
3566 class TxAckRbf {
3567 private:
3568         LDKTxAckRbf self;
3569 public:
3570         TxAckRbf(const TxAckRbf&) = delete;
3571         TxAckRbf(TxAckRbf&& o) : self(o.self) { memset(&o, 0, sizeof(TxAckRbf)); }
3572         TxAckRbf(LDKTxAckRbf&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAckRbf)); }
3573         operator LDKTxAckRbf() && { LDKTxAckRbf res = self; memset(&self, 0, sizeof(LDKTxAckRbf)); return res; }
3574         ~TxAckRbf() { TxAckRbf_free(self); }
3575         TxAckRbf& operator=(TxAckRbf&& o) { TxAckRbf_free(self); self = o.self; memset(&o, 0, sizeof(TxAckRbf)); return *this; }
3576         LDKTxAckRbf* operator &() { return &self; }
3577         LDKTxAckRbf* operator ->() { return &self; }
3578         const LDKTxAckRbf* operator &() const { return &self; }
3579         const LDKTxAckRbf* operator ->() const { return &self; }
3580 };
3581 class TxAbort {
3582 private:
3583         LDKTxAbort self;
3584 public:
3585         TxAbort(const TxAbort&) = delete;
3586         TxAbort(TxAbort&& o) : self(o.self) { memset(&o, 0, sizeof(TxAbort)); }
3587         TxAbort(LDKTxAbort&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAbort)); }
3588         operator LDKTxAbort() && { LDKTxAbort res = self; memset(&self, 0, sizeof(LDKTxAbort)); return res; }
3589         ~TxAbort() { TxAbort_free(self); }
3590         TxAbort& operator=(TxAbort&& o) { TxAbort_free(self); self = o.self; memset(&o, 0, sizeof(TxAbort)); return *this; }
3591         LDKTxAbort* operator &() { return &self; }
3592         LDKTxAbort* operator ->() { return &self; }
3593         const LDKTxAbort* operator &() const { return &self; }
3594         const LDKTxAbort* operator ->() const { return &self; }
3595 };
3596 class Shutdown {
3597 private:
3598         LDKShutdown self;
3599 public:
3600         Shutdown(const Shutdown&) = delete;
3601         Shutdown(Shutdown&& o) : self(o.self) { memset(&o, 0, sizeof(Shutdown)); }
3602         Shutdown(LDKShutdown&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdown)); }
3603         operator LDKShutdown() && { LDKShutdown res = self; memset(&self, 0, sizeof(LDKShutdown)); return res; }
3604         ~Shutdown() { Shutdown_free(self); }
3605         Shutdown& operator=(Shutdown&& o) { Shutdown_free(self); self = o.self; memset(&o, 0, sizeof(Shutdown)); return *this; }
3606         LDKShutdown* operator &() { return &self; }
3607         LDKShutdown* operator ->() { return &self; }
3608         const LDKShutdown* operator &() const { return &self; }
3609         const LDKShutdown* operator ->() const { return &self; }
3610 };
3611 class ClosingSignedFeeRange {
3612 private:
3613         LDKClosingSignedFeeRange self;
3614 public:
3615         ClosingSignedFeeRange(const ClosingSignedFeeRange&) = delete;
3616         ClosingSignedFeeRange(ClosingSignedFeeRange&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSignedFeeRange)); }
3617         ClosingSignedFeeRange(LDKClosingSignedFeeRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSignedFeeRange)); }
3618         operator LDKClosingSignedFeeRange() && { LDKClosingSignedFeeRange res = self; memset(&self, 0, sizeof(LDKClosingSignedFeeRange)); return res; }
3619         ~ClosingSignedFeeRange() { ClosingSignedFeeRange_free(self); }
3620         ClosingSignedFeeRange& operator=(ClosingSignedFeeRange&& o) { ClosingSignedFeeRange_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSignedFeeRange)); return *this; }
3621         LDKClosingSignedFeeRange* operator &() { return &self; }
3622         LDKClosingSignedFeeRange* operator ->() { return &self; }
3623         const LDKClosingSignedFeeRange* operator &() const { return &self; }
3624         const LDKClosingSignedFeeRange* operator ->() const { return &self; }
3625 };
3626 class ClosingSigned {
3627 private:
3628         LDKClosingSigned self;
3629 public:
3630         ClosingSigned(const ClosingSigned&) = delete;
3631         ClosingSigned(ClosingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSigned)); }
3632         ClosingSigned(LDKClosingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSigned)); }
3633         operator LDKClosingSigned() && { LDKClosingSigned res = self; memset(&self, 0, sizeof(LDKClosingSigned)); return res; }
3634         ~ClosingSigned() { ClosingSigned_free(self); }
3635         ClosingSigned& operator=(ClosingSigned&& o) { ClosingSigned_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSigned)); return *this; }
3636         LDKClosingSigned* operator &() { return &self; }
3637         LDKClosingSigned* operator ->() { return &self; }
3638         const LDKClosingSigned* operator &() const { return &self; }
3639         const LDKClosingSigned* operator ->() const { return &self; }
3640 };
3641 class UpdateAddHTLC {
3642 private:
3643         LDKUpdateAddHTLC self;
3644 public:
3645         UpdateAddHTLC(const UpdateAddHTLC&) = delete;
3646         UpdateAddHTLC(UpdateAddHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateAddHTLC)); }
3647         UpdateAddHTLC(LDKUpdateAddHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateAddHTLC)); }
3648         operator LDKUpdateAddHTLC() && { LDKUpdateAddHTLC res = self; memset(&self, 0, sizeof(LDKUpdateAddHTLC)); return res; }
3649         ~UpdateAddHTLC() { UpdateAddHTLC_free(self); }
3650         UpdateAddHTLC& operator=(UpdateAddHTLC&& o) { UpdateAddHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateAddHTLC)); return *this; }
3651         LDKUpdateAddHTLC* operator &() { return &self; }
3652         LDKUpdateAddHTLC* operator ->() { return &self; }
3653         const LDKUpdateAddHTLC* operator &() const { return &self; }
3654         const LDKUpdateAddHTLC* operator ->() const { return &self; }
3655 };
3656 class OnionMessage {
3657 private:
3658         LDKOnionMessage self;
3659 public:
3660         OnionMessage(const OnionMessage&) = delete;
3661         OnionMessage(OnionMessage&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessage)); }
3662         OnionMessage(LDKOnionMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessage)); }
3663         operator LDKOnionMessage() && { LDKOnionMessage res = self; memset(&self, 0, sizeof(LDKOnionMessage)); return res; }
3664         ~OnionMessage() { OnionMessage_free(self); }
3665         OnionMessage& operator=(OnionMessage&& o) { OnionMessage_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessage)); return *this; }
3666         LDKOnionMessage* operator &() { return &self; }
3667         LDKOnionMessage* operator ->() { return &self; }
3668         const LDKOnionMessage* operator &() const { return &self; }
3669         const LDKOnionMessage* operator ->() const { return &self; }
3670 };
3671 class UpdateFulfillHTLC {
3672 private:
3673         LDKUpdateFulfillHTLC self;
3674 public:
3675         UpdateFulfillHTLC(const UpdateFulfillHTLC&) = delete;
3676         UpdateFulfillHTLC(UpdateFulfillHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFulfillHTLC)); }
3677         UpdateFulfillHTLC(LDKUpdateFulfillHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFulfillHTLC)); }
3678         operator LDKUpdateFulfillHTLC() && { LDKUpdateFulfillHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFulfillHTLC)); return res; }
3679         ~UpdateFulfillHTLC() { UpdateFulfillHTLC_free(self); }
3680         UpdateFulfillHTLC& operator=(UpdateFulfillHTLC&& o) { UpdateFulfillHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFulfillHTLC)); return *this; }
3681         LDKUpdateFulfillHTLC* operator &() { return &self; }
3682         LDKUpdateFulfillHTLC* operator ->() { return &self; }
3683         const LDKUpdateFulfillHTLC* operator &() const { return &self; }
3684         const LDKUpdateFulfillHTLC* operator ->() const { return &self; }
3685 };
3686 class UpdateFailHTLC {
3687 private:
3688         LDKUpdateFailHTLC self;
3689 public:
3690         UpdateFailHTLC(const UpdateFailHTLC&) = delete;
3691         UpdateFailHTLC(UpdateFailHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailHTLC)); }
3692         UpdateFailHTLC(LDKUpdateFailHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailHTLC)); }
3693         operator LDKUpdateFailHTLC() && { LDKUpdateFailHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailHTLC)); return res; }
3694         ~UpdateFailHTLC() { UpdateFailHTLC_free(self); }
3695         UpdateFailHTLC& operator=(UpdateFailHTLC&& o) { UpdateFailHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailHTLC)); return *this; }
3696         LDKUpdateFailHTLC* operator &() { return &self; }
3697         LDKUpdateFailHTLC* operator ->() { return &self; }
3698         const LDKUpdateFailHTLC* operator &() const { return &self; }
3699         const LDKUpdateFailHTLC* operator ->() const { return &self; }
3700 };
3701 class UpdateFailMalformedHTLC {
3702 private:
3703         LDKUpdateFailMalformedHTLC self;
3704 public:
3705         UpdateFailMalformedHTLC(const UpdateFailMalformedHTLC&) = delete;
3706         UpdateFailMalformedHTLC(UpdateFailMalformedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); }
3707         UpdateFailMalformedHTLC(LDKUpdateFailMalformedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailMalformedHTLC)); }
3708         operator LDKUpdateFailMalformedHTLC() && { LDKUpdateFailMalformedHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailMalformedHTLC)); return res; }
3709         ~UpdateFailMalformedHTLC() { UpdateFailMalformedHTLC_free(self); }
3710         UpdateFailMalformedHTLC& operator=(UpdateFailMalformedHTLC&& o) { UpdateFailMalformedHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); return *this; }
3711         LDKUpdateFailMalformedHTLC* operator &() { return &self; }
3712         LDKUpdateFailMalformedHTLC* operator ->() { return &self; }
3713         const LDKUpdateFailMalformedHTLC* operator &() const { return &self; }
3714         const LDKUpdateFailMalformedHTLC* operator ->() const { return &self; }
3715 };
3716 class CommitmentSigned {
3717 private:
3718         LDKCommitmentSigned self;
3719 public:
3720         CommitmentSigned(const CommitmentSigned&) = delete;
3721         CommitmentSigned(CommitmentSigned&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentSigned)); }
3722         CommitmentSigned(LDKCommitmentSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentSigned)); }
3723         operator LDKCommitmentSigned() && { LDKCommitmentSigned res = self; memset(&self, 0, sizeof(LDKCommitmentSigned)); return res; }
3724         ~CommitmentSigned() { CommitmentSigned_free(self); }
3725         CommitmentSigned& operator=(CommitmentSigned&& o) { CommitmentSigned_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentSigned)); return *this; }
3726         LDKCommitmentSigned* operator &() { return &self; }
3727         LDKCommitmentSigned* operator ->() { return &self; }
3728         const LDKCommitmentSigned* operator &() const { return &self; }
3729         const LDKCommitmentSigned* operator ->() const { return &self; }
3730 };
3731 class RevokeAndACK {
3732 private:
3733         LDKRevokeAndACK self;
3734 public:
3735         RevokeAndACK(const RevokeAndACK&) = delete;
3736         RevokeAndACK(RevokeAndACK&& o) : self(o.self) { memset(&o, 0, sizeof(RevokeAndACK)); }
3737         RevokeAndACK(LDKRevokeAndACK&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevokeAndACK)); }
3738         operator LDKRevokeAndACK() && { LDKRevokeAndACK res = self; memset(&self, 0, sizeof(LDKRevokeAndACK)); return res; }
3739         ~RevokeAndACK() { RevokeAndACK_free(self); }
3740         RevokeAndACK& operator=(RevokeAndACK&& o) { RevokeAndACK_free(self); self = o.self; memset(&o, 0, sizeof(RevokeAndACK)); return *this; }
3741         LDKRevokeAndACK* operator &() { return &self; }
3742         LDKRevokeAndACK* operator ->() { return &self; }
3743         const LDKRevokeAndACK* operator &() const { return &self; }
3744         const LDKRevokeAndACK* operator ->() const { return &self; }
3745 };
3746 class UpdateFee {
3747 private:
3748         LDKUpdateFee self;
3749 public:
3750         UpdateFee(const UpdateFee&) = delete;
3751         UpdateFee(UpdateFee&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFee)); }
3752         UpdateFee(LDKUpdateFee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFee)); }
3753         operator LDKUpdateFee() && { LDKUpdateFee res = self; memset(&self, 0, sizeof(LDKUpdateFee)); return res; }
3754         ~UpdateFee() { UpdateFee_free(self); }
3755         UpdateFee& operator=(UpdateFee&& o) { UpdateFee_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFee)); return *this; }
3756         LDKUpdateFee* operator &() { return &self; }
3757         LDKUpdateFee* operator ->() { return &self; }
3758         const LDKUpdateFee* operator &() const { return &self; }
3759         const LDKUpdateFee* operator ->() const { return &self; }
3760 };
3761 class ChannelReestablish {
3762 private:
3763         LDKChannelReestablish self;
3764 public:
3765         ChannelReestablish(const ChannelReestablish&) = delete;
3766         ChannelReestablish(ChannelReestablish&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReestablish)); }
3767         ChannelReestablish(LDKChannelReestablish&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReestablish)); }
3768         operator LDKChannelReestablish() && { LDKChannelReestablish res = self; memset(&self, 0, sizeof(LDKChannelReestablish)); return res; }
3769         ~ChannelReestablish() { ChannelReestablish_free(self); }
3770         ChannelReestablish& operator=(ChannelReestablish&& o) { ChannelReestablish_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReestablish)); return *this; }
3771         LDKChannelReestablish* operator &() { return &self; }
3772         LDKChannelReestablish* operator ->() { return &self; }
3773         const LDKChannelReestablish* operator &() const { return &self; }
3774         const LDKChannelReestablish* operator ->() const { return &self; }
3775 };
3776 class AnnouncementSignatures {
3777 private:
3778         LDKAnnouncementSignatures self;
3779 public:
3780         AnnouncementSignatures(const AnnouncementSignatures&) = delete;
3781         AnnouncementSignatures(AnnouncementSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(AnnouncementSignatures)); }
3782         AnnouncementSignatures(LDKAnnouncementSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnnouncementSignatures)); }
3783         operator LDKAnnouncementSignatures() && { LDKAnnouncementSignatures res = self; memset(&self, 0, sizeof(LDKAnnouncementSignatures)); return res; }
3784         ~AnnouncementSignatures() { AnnouncementSignatures_free(self); }
3785         AnnouncementSignatures& operator=(AnnouncementSignatures&& o) { AnnouncementSignatures_free(self); self = o.self; memset(&o, 0, sizeof(AnnouncementSignatures)); return *this; }
3786         LDKAnnouncementSignatures* operator &() { return &self; }
3787         LDKAnnouncementSignatures* operator ->() { return &self; }
3788         const LDKAnnouncementSignatures* operator &() const { return &self; }
3789         const LDKAnnouncementSignatures* operator ->() const { return &self; }
3790 };
3791 class SocketAddress {
3792 private:
3793         LDKSocketAddress self;
3794 public:
3795         SocketAddress(const SocketAddress&) = delete;
3796         SocketAddress(SocketAddress&& o) : self(o.self) { memset(&o, 0, sizeof(SocketAddress)); }
3797         SocketAddress(LDKSocketAddress&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketAddress)); }
3798         operator LDKSocketAddress() && { LDKSocketAddress res = self; memset(&self, 0, sizeof(LDKSocketAddress)); return res; }
3799         ~SocketAddress() { SocketAddress_free(self); }
3800         SocketAddress& operator=(SocketAddress&& o) { SocketAddress_free(self); self = o.self; memset(&o, 0, sizeof(SocketAddress)); return *this; }
3801         LDKSocketAddress* operator &() { return &self; }
3802         LDKSocketAddress* operator ->() { return &self; }
3803         const LDKSocketAddress* operator &() const { return &self; }
3804         const LDKSocketAddress* operator ->() const { return &self; }
3805 };
3806 class SocketAddressParseError {
3807 private:
3808         LDKSocketAddressParseError self;
3809 public:
3810         SocketAddressParseError(const SocketAddressParseError&) = delete;
3811         SocketAddressParseError(SocketAddressParseError&& o) : self(o.self) { memset(&o, 0, sizeof(SocketAddressParseError)); }
3812         SocketAddressParseError(LDKSocketAddressParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketAddressParseError)); }
3813         operator LDKSocketAddressParseError() && { LDKSocketAddressParseError res = self; memset(&self, 0, sizeof(LDKSocketAddressParseError)); return res; }
3814         SocketAddressParseError& operator=(SocketAddressParseError&& o) { self = o.self; memset(&o, 0, sizeof(SocketAddressParseError)); return *this; }
3815         LDKSocketAddressParseError* operator &() { return &self; }
3816         LDKSocketAddressParseError* operator ->() { return &self; }
3817         const LDKSocketAddressParseError* operator &() const { return &self; }
3818         const LDKSocketAddressParseError* operator ->() const { return &self; }
3819 };
3820 class UnsignedGossipMessage {
3821 private:
3822         LDKUnsignedGossipMessage self;
3823 public:
3824         UnsignedGossipMessage(const UnsignedGossipMessage&) = delete;
3825         UnsignedGossipMessage(UnsignedGossipMessage&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedGossipMessage)); }
3826         UnsignedGossipMessage(LDKUnsignedGossipMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedGossipMessage)); }
3827         operator LDKUnsignedGossipMessage() && { LDKUnsignedGossipMessage res = self; memset(&self, 0, sizeof(LDKUnsignedGossipMessage)); return res; }
3828         ~UnsignedGossipMessage() { UnsignedGossipMessage_free(self); }
3829         UnsignedGossipMessage& operator=(UnsignedGossipMessage&& o) { UnsignedGossipMessage_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedGossipMessage)); return *this; }
3830         LDKUnsignedGossipMessage* operator &() { return &self; }
3831         LDKUnsignedGossipMessage* operator ->() { return &self; }
3832         const LDKUnsignedGossipMessage* operator &() const { return &self; }
3833         const LDKUnsignedGossipMessage* operator ->() const { return &self; }
3834 };
3835 class UnsignedNodeAnnouncement {
3836 private:
3837         LDKUnsignedNodeAnnouncement self;
3838 public:
3839         UnsignedNodeAnnouncement(const UnsignedNodeAnnouncement&) = delete;
3840         UnsignedNodeAnnouncement(UnsignedNodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); }
3841         UnsignedNodeAnnouncement(LDKUnsignedNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedNodeAnnouncement)); }
3842         operator LDKUnsignedNodeAnnouncement() && { LDKUnsignedNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedNodeAnnouncement)); return res; }
3843         ~UnsignedNodeAnnouncement() { UnsignedNodeAnnouncement_free(self); }
3844         UnsignedNodeAnnouncement& operator=(UnsignedNodeAnnouncement&& o) { UnsignedNodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); return *this; }
3845         LDKUnsignedNodeAnnouncement* operator &() { return &self; }
3846         LDKUnsignedNodeAnnouncement* operator ->() { return &self; }
3847         const LDKUnsignedNodeAnnouncement* operator &() const { return &self; }
3848         const LDKUnsignedNodeAnnouncement* operator ->() const { return &self; }
3849 };
3850 class NodeAnnouncement {
3851 private:
3852         LDKNodeAnnouncement self;
3853 public:
3854         NodeAnnouncement(const NodeAnnouncement&) = delete;
3855         NodeAnnouncement(NodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncement)); }
3856         NodeAnnouncement(LDKNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncement)); }
3857         operator LDKNodeAnnouncement() && { LDKNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKNodeAnnouncement)); return res; }
3858         ~NodeAnnouncement() { NodeAnnouncement_free(self); }
3859         NodeAnnouncement& operator=(NodeAnnouncement&& o) { NodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncement)); return *this; }
3860         LDKNodeAnnouncement* operator &() { return &self; }
3861         LDKNodeAnnouncement* operator ->() { return &self; }
3862         const LDKNodeAnnouncement* operator &() const { return &self; }
3863         const LDKNodeAnnouncement* operator ->() const { return &self; }
3864 };
3865 class UnsignedChannelAnnouncement {
3866 private:
3867         LDKUnsignedChannelAnnouncement self;
3868 public:
3869         UnsignedChannelAnnouncement(const UnsignedChannelAnnouncement&) = delete;
3870         UnsignedChannelAnnouncement(UnsignedChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); }
3871         UnsignedChannelAnnouncement(LDKUnsignedChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelAnnouncement)); }
3872         operator LDKUnsignedChannelAnnouncement() && { LDKUnsignedChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedChannelAnnouncement)); return res; }
3873         ~UnsignedChannelAnnouncement() { UnsignedChannelAnnouncement_free(self); }
3874         UnsignedChannelAnnouncement& operator=(UnsignedChannelAnnouncement&& o) { UnsignedChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); return *this; }
3875         LDKUnsignedChannelAnnouncement* operator &() { return &self; }
3876         LDKUnsignedChannelAnnouncement* operator ->() { return &self; }
3877         const LDKUnsignedChannelAnnouncement* operator &() const { return &self; }
3878         const LDKUnsignedChannelAnnouncement* operator ->() const { return &self; }
3879 };
3880 class ChannelAnnouncement {
3881 private:
3882         LDKChannelAnnouncement self;
3883 public:
3884         ChannelAnnouncement(const ChannelAnnouncement&) = delete;
3885         ChannelAnnouncement(ChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelAnnouncement)); }
3886         ChannelAnnouncement(LDKChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelAnnouncement)); }
3887         operator LDKChannelAnnouncement() && { LDKChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKChannelAnnouncement)); return res; }
3888         ~ChannelAnnouncement() { ChannelAnnouncement_free(self); }
3889         ChannelAnnouncement& operator=(ChannelAnnouncement&& o) { ChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(ChannelAnnouncement)); return *this; }
3890         LDKChannelAnnouncement* operator &() { return &self; }
3891         LDKChannelAnnouncement* operator ->() { return &self; }
3892         const LDKChannelAnnouncement* operator &() const { return &self; }
3893         const LDKChannelAnnouncement* operator ->() const { return &self; }
3894 };
3895 class UnsignedChannelUpdate {
3896 private:
3897         LDKUnsignedChannelUpdate self;
3898 public:
3899         UnsignedChannelUpdate(const UnsignedChannelUpdate&) = delete;
3900         UnsignedChannelUpdate(UnsignedChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelUpdate)); }
3901         UnsignedChannelUpdate(LDKUnsignedChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelUpdate)); }
3902         operator LDKUnsignedChannelUpdate() && { LDKUnsignedChannelUpdate res = self; memset(&self, 0, sizeof(LDKUnsignedChannelUpdate)); return res; }
3903         ~UnsignedChannelUpdate() { UnsignedChannelUpdate_free(self); }
3904         UnsignedChannelUpdate& operator=(UnsignedChannelUpdate&& o) { UnsignedChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelUpdate)); return *this; }
3905         LDKUnsignedChannelUpdate* operator &() { return &self; }
3906         LDKUnsignedChannelUpdate* operator ->() { return &self; }
3907         const LDKUnsignedChannelUpdate* operator &() const { return &self; }
3908         const LDKUnsignedChannelUpdate* operator ->() const { return &self; }
3909 };
3910 class ChannelUpdate {
3911 private:
3912         LDKChannelUpdate self;
3913 public:
3914         ChannelUpdate(const ChannelUpdate&) = delete;
3915         ChannelUpdate(ChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdate)); }
3916         ChannelUpdate(LDKChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdate)); }
3917         operator LDKChannelUpdate() && { LDKChannelUpdate res = self; memset(&self, 0, sizeof(LDKChannelUpdate)); return res; }
3918         ~ChannelUpdate() { ChannelUpdate_free(self); }
3919         ChannelUpdate& operator=(ChannelUpdate&& o) { ChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdate)); return *this; }
3920         LDKChannelUpdate* operator &() { return &self; }
3921         LDKChannelUpdate* operator ->() { return &self; }
3922         const LDKChannelUpdate* operator &() const { return &self; }
3923         const LDKChannelUpdate* operator ->() const { return &self; }
3924 };
3925 class QueryChannelRange {
3926 private:
3927         LDKQueryChannelRange self;
3928 public:
3929         QueryChannelRange(const QueryChannelRange&) = delete;
3930         QueryChannelRange(QueryChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(QueryChannelRange)); }
3931         QueryChannelRange(LDKQueryChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryChannelRange)); }
3932         operator LDKQueryChannelRange() && { LDKQueryChannelRange res = self; memset(&self, 0, sizeof(LDKQueryChannelRange)); return res; }
3933         ~QueryChannelRange() { QueryChannelRange_free(self); }
3934         QueryChannelRange& operator=(QueryChannelRange&& o) { QueryChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(QueryChannelRange)); return *this; }
3935         LDKQueryChannelRange* operator &() { return &self; }
3936         LDKQueryChannelRange* operator ->() { return &self; }
3937         const LDKQueryChannelRange* operator &() const { return &self; }
3938         const LDKQueryChannelRange* operator ->() const { return &self; }
3939 };
3940 class ReplyChannelRange {
3941 private:
3942         LDKReplyChannelRange self;
3943 public:
3944         ReplyChannelRange(const ReplyChannelRange&) = delete;
3945         ReplyChannelRange(ReplyChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyChannelRange)); }
3946         ReplyChannelRange(LDKReplyChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyChannelRange)); }
3947         operator LDKReplyChannelRange() && { LDKReplyChannelRange res = self; memset(&self, 0, sizeof(LDKReplyChannelRange)); return res; }
3948         ~ReplyChannelRange() { ReplyChannelRange_free(self); }
3949         ReplyChannelRange& operator=(ReplyChannelRange&& o) { ReplyChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(ReplyChannelRange)); return *this; }
3950         LDKReplyChannelRange* operator &() { return &self; }
3951         LDKReplyChannelRange* operator ->() { return &self; }
3952         const LDKReplyChannelRange* operator &() const { return &self; }
3953         const LDKReplyChannelRange* operator ->() const { return &self; }
3954 };
3955 class QueryShortChannelIds {
3956 private:
3957         LDKQueryShortChannelIds self;
3958 public:
3959         QueryShortChannelIds(const QueryShortChannelIds&) = delete;
3960         QueryShortChannelIds(QueryShortChannelIds&& o) : self(o.self) { memset(&o, 0, sizeof(QueryShortChannelIds)); }
3961         QueryShortChannelIds(LDKQueryShortChannelIds&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryShortChannelIds)); }
3962         operator LDKQueryShortChannelIds() && { LDKQueryShortChannelIds res = self; memset(&self, 0, sizeof(LDKQueryShortChannelIds)); return res; }
3963         ~QueryShortChannelIds() { QueryShortChannelIds_free(self); }
3964         QueryShortChannelIds& operator=(QueryShortChannelIds&& o) { QueryShortChannelIds_free(self); self = o.self; memset(&o, 0, sizeof(QueryShortChannelIds)); return *this; }
3965         LDKQueryShortChannelIds* operator &() { return &self; }
3966         LDKQueryShortChannelIds* operator ->() { return &self; }
3967         const LDKQueryShortChannelIds* operator &() const { return &self; }
3968         const LDKQueryShortChannelIds* operator ->() const { return &self; }
3969 };
3970 class ReplyShortChannelIdsEnd {
3971 private:
3972         LDKReplyShortChannelIdsEnd self;
3973 public:
3974         ReplyShortChannelIdsEnd(const ReplyShortChannelIdsEnd&) = delete;
3975         ReplyShortChannelIdsEnd(ReplyShortChannelIdsEnd&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); }
3976         ReplyShortChannelIdsEnd(LDKReplyShortChannelIdsEnd&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyShortChannelIdsEnd)); }
3977         operator LDKReplyShortChannelIdsEnd() && { LDKReplyShortChannelIdsEnd res = self; memset(&self, 0, sizeof(LDKReplyShortChannelIdsEnd)); return res; }
3978         ~ReplyShortChannelIdsEnd() { ReplyShortChannelIdsEnd_free(self); }
3979         ReplyShortChannelIdsEnd& operator=(ReplyShortChannelIdsEnd&& o) { ReplyShortChannelIdsEnd_free(self); self = o.self; memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); return *this; }
3980         LDKReplyShortChannelIdsEnd* operator &() { return &self; }
3981         LDKReplyShortChannelIdsEnd* operator ->() { return &self; }
3982         const LDKReplyShortChannelIdsEnd* operator &() const { return &self; }
3983         const LDKReplyShortChannelIdsEnd* operator ->() const { return &self; }
3984 };
3985 class GossipTimestampFilter {
3986 private:
3987         LDKGossipTimestampFilter self;
3988 public:
3989         GossipTimestampFilter(const GossipTimestampFilter&) = delete;
3990         GossipTimestampFilter(GossipTimestampFilter&& o) : self(o.self) { memset(&o, 0, sizeof(GossipTimestampFilter)); }
3991         GossipTimestampFilter(LDKGossipTimestampFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipTimestampFilter)); }
3992         operator LDKGossipTimestampFilter() && { LDKGossipTimestampFilter res = self; memset(&self, 0, sizeof(LDKGossipTimestampFilter)); return res; }
3993         ~GossipTimestampFilter() { GossipTimestampFilter_free(self); }
3994         GossipTimestampFilter& operator=(GossipTimestampFilter&& o) { GossipTimestampFilter_free(self); self = o.self; memset(&o, 0, sizeof(GossipTimestampFilter)); return *this; }
3995         LDKGossipTimestampFilter* operator &() { return &self; }
3996         LDKGossipTimestampFilter* operator ->() { return &self; }
3997         const LDKGossipTimestampFilter* operator &() const { return &self; }
3998         const LDKGossipTimestampFilter* operator ->() const { return &self; }
3999 };
4000 class ErrorAction {
4001 private:
4002         LDKErrorAction self;
4003 public:
4004         ErrorAction(const ErrorAction&) = delete;
4005         ErrorAction(ErrorAction&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorAction)); }
4006         ErrorAction(LDKErrorAction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorAction)); }
4007         operator LDKErrorAction() && { LDKErrorAction res = self; memset(&self, 0, sizeof(LDKErrorAction)); return res; }
4008         ~ErrorAction() { ErrorAction_free(self); }
4009         ErrorAction& operator=(ErrorAction&& o) { ErrorAction_free(self); self = o.self; memset(&o, 0, sizeof(ErrorAction)); return *this; }
4010         LDKErrorAction* operator &() { return &self; }
4011         LDKErrorAction* operator ->() { return &self; }
4012         const LDKErrorAction* operator &() const { return &self; }
4013         const LDKErrorAction* operator ->() const { return &self; }
4014 };
4015 class LightningError {
4016 private:
4017         LDKLightningError self;
4018 public:
4019         LightningError(const LightningError&) = delete;
4020         LightningError(LightningError&& o) : self(o.self) { memset(&o, 0, sizeof(LightningError)); }
4021         LightningError(LDKLightningError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLightningError)); }
4022         operator LDKLightningError() && { LDKLightningError res = self; memset(&self, 0, sizeof(LDKLightningError)); return res; }
4023         ~LightningError() { LightningError_free(self); }
4024         LightningError& operator=(LightningError&& o) { LightningError_free(self); self = o.self; memset(&o, 0, sizeof(LightningError)); return *this; }
4025         LDKLightningError* operator &() { return &self; }
4026         LDKLightningError* operator ->() { return &self; }
4027         const LDKLightningError* operator &() const { return &self; }
4028         const LDKLightningError* operator ->() const { return &self; }
4029 };
4030 class CommitmentUpdate {
4031 private:
4032         LDKCommitmentUpdate self;
4033 public:
4034         CommitmentUpdate(const CommitmentUpdate&) = delete;
4035         CommitmentUpdate(CommitmentUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentUpdate)); }
4036         CommitmentUpdate(LDKCommitmentUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentUpdate)); }
4037         operator LDKCommitmentUpdate() && { LDKCommitmentUpdate res = self; memset(&self, 0, sizeof(LDKCommitmentUpdate)); return res; }
4038         ~CommitmentUpdate() { CommitmentUpdate_free(self); }
4039         CommitmentUpdate& operator=(CommitmentUpdate&& o) { CommitmentUpdate_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentUpdate)); return *this; }
4040         LDKCommitmentUpdate* operator &() { return &self; }
4041         LDKCommitmentUpdate* operator ->() { return &self; }
4042         const LDKCommitmentUpdate* operator &() const { return &self; }
4043         const LDKCommitmentUpdate* operator ->() const { return &self; }
4044 };
4045 class ChannelMessageHandler {
4046 private:
4047         LDKChannelMessageHandler self;
4048 public:
4049         ChannelMessageHandler(const ChannelMessageHandler&) = delete;
4050         ChannelMessageHandler(ChannelMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMessageHandler)); }
4051         ChannelMessageHandler(LDKChannelMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMessageHandler)); }
4052         operator LDKChannelMessageHandler() && { LDKChannelMessageHandler res = self; memset(&self, 0, sizeof(LDKChannelMessageHandler)); return res; }
4053         ~ChannelMessageHandler() { ChannelMessageHandler_free(self); }
4054         ChannelMessageHandler& operator=(ChannelMessageHandler&& o) { ChannelMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMessageHandler)); return *this; }
4055         LDKChannelMessageHandler* operator &() { return &self; }
4056         LDKChannelMessageHandler* operator ->() { return &self; }
4057         const LDKChannelMessageHandler* operator &() const { return &self; }
4058         const LDKChannelMessageHandler* operator ->() const { return &self; }
4059         /**
4060          *  Handle an incoming `open_channel` message from the given peer.
4061          */
4062         inline void handle_open_channel(struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg);
4063         /**
4064          *  Handle an incoming `open_channel2` message from the given peer.
4065          */
4066         inline void handle_open_channel_v2(struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg);
4067         /**
4068          *  Handle an incoming `accept_channel` message from the given peer.
4069          */
4070         inline void handle_accept_channel(struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg);
4071         /**
4072          *  Handle an incoming `accept_channel2` message from the given peer.
4073          */
4074         inline void handle_accept_channel_v2(struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg);
4075         /**
4076          *  Handle an incoming `funding_created` message from the given peer.
4077          */
4078         inline void handle_funding_created(struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg);
4079         /**
4080          *  Handle an incoming `funding_signed` message from the given peer.
4081          */
4082         inline void handle_funding_signed(struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg);
4083         /**
4084          *  Handle an incoming `channel_ready` message from the given peer.
4085          */
4086         inline void handle_channel_ready(struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg);
4087         /**
4088          *  Handle an incoming `shutdown` message from the given peer.
4089          */
4090         inline void handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg);
4091         /**
4092          *  Handle an incoming `closing_signed` message from the given peer.
4093          */
4094         inline void handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg);
4095         /**
4096          *  Handle an incoming `tx_add_input message` from the given peer.
4097          */
4098         inline void handle_tx_add_input(struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg);
4099         /**
4100          *  Handle an incoming `tx_add_output` message from the given peer.
4101          */
4102         inline void handle_tx_add_output(struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg);
4103         /**
4104          *  Handle an incoming `tx_remove_input` message from the given peer.
4105          */
4106         inline void handle_tx_remove_input(struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg);
4107         /**
4108          *  Handle an incoming `tx_remove_output` message from the given peer.
4109          */
4110         inline void handle_tx_remove_output(struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg);
4111         /**
4112          *  Handle an incoming `tx_complete message` from the given peer.
4113          */
4114         inline void handle_tx_complete(struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg);
4115         /**
4116          *  Handle an incoming `tx_signatures` message from the given peer.
4117          */
4118         inline void handle_tx_signatures(struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg);
4119         /**
4120          *  Handle an incoming `tx_init_rbf` message from the given peer.
4121          */
4122         inline void handle_tx_init_rbf(struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg);
4123         /**
4124          *  Handle an incoming `tx_ack_rbf` message from the given peer.
4125          */
4126         inline void handle_tx_ack_rbf(struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg);
4127         /**
4128          *  Handle an incoming `tx_abort message` from the given peer.
4129          */
4130         inline void handle_tx_abort(struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg);
4131         /**
4132          *  Handle an incoming `update_add_htlc` message from the given peer.
4133          */
4134         inline void handle_update_add_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg);
4135         /**
4136          *  Handle an incoming `update_fulfill_htlc` message from the given peer.
4137          */
4138         inline void handle_update_fulfill_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg);
4139         /**
4140          *  Handle an incoming `update_fail_htlc` message from the given peer.
4141          */
4142         inline void handle_update_fail_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg);
4143         /**
4144          *  Handle an incoming `update_fail_malformed_htlc` message from the given peer.
4145          */
4146         inline void handle_update_fail_malformed_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg);
4147         /**
4148          *  Handle an incoming `commitment_signed` message from the given peer.
4149          */
4150         inline void handle_commitment_signed(struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg);
4151         /**
4152          *  Handle an incoming `revoke_and_ack` message from the given peer.
4153          */
4154         inline void handle_revoke_and_ack(struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg);
4155         /**
4156          *  Handle an incoming `update_fee` message from the given peer.
4157          */
4158         inline void handle_update_fee(struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg);
4159         /**
4160          *  Handle an incoming `announcement_signatures` message from the given peer.
4161          */
4162         inline void handle_announcement_signatures(struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg);
4163         /**
4164          *  Indicates a connection to the peer failed/an existing connection was lost.
4165          */
4166         inline void peer_disconnected(struct LDKPublicKey their_node_id);
4167         /**
4168          *  Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
4169          *
4170          *  May return an `Err(())` if the features the peer supports are not sufficient to communicate
4171          *  with us. Implementors should be somewhat conservative about doing so, however, as other
4172          *  message handlers may still wish to communicate with this peer.
4173          */
4174         inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound);
4175         /**
4176          *  Handle an incoming `channel_reestablish` message from the given peer.
4177          */
4178         inline void handle_channel_reestablish(struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg);
4179         /**
4180          *  Handle an incoming `channel_update` message from the given peer.
4181          */
4182         inline void handle_channel_update(struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg);
4183         /**
4184          *  Handle an incoming `error` message from the given peer.
4185          */
4186         inline void handle_error(struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg);
4187         /**
4188          *  Gets the node feature flags which this handler itself supports. All available handlers are
4189          *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
4190          *  which are broadcasted in our [`NodeAnnouncement`] message.
4191          */
4192         inline LDK::NodeFeatures provided_node_features();
4193         /**
4194          *  Gets the init feature flags which should be sent to the given peer. All available handlers
4195          *  are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
4196          *  which are sent in our [`Init`] message.
4197          *
4198          *  Note that this method is called before [`Self::peer_connected`].
4199          */
4200         inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
4201         /**
4202          *  Gets the genesis hashes for this `ChannelMessageHandler` indicating which chains it supports.
4203          *
4204          *  If it's `None`, then no particular network chain hash compatibility will be enforced when
4205          *  connecting to peers.
4206          */
4207         inline LDK::COption_CVec_ThirtyTwoBytesZZ get_genesis_hashes();
4208 };
4209 class RoutingMessageHandler {
4210 private:
4211         LDKRoutingMessageHandler self;
4212 public:
4213         RoutingMessageHandler(const RoutingMessageHandler&) = delete;
4214         RoutingMessageHandler(RoutingMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingMessageHandler)); }
4215         RoutingMessageHandler(LDKRoutingMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingMessageHandler)); }
4216         operator LDKRoutingMessageHandler() && { LDKRoutingMessageHandler res = self; memset(&self, 0, sizeof(LDKRoutingMessageHandler)); return res; }
4217         ~RoutingMessageHandler() { RoutingMessageHandler_free(self); }
4218         RoutingMessageHandler& operator=(RoutingMessageHandler&& o) { RoutingMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(RoutingMessageHandler)); return *this; }
4219         LDKRoutingMessageHandler* operator &() { return &self; }
4220         LDKRoutingMessageHandler* operator ->() { return &self; }
4221         const LDKRoutingMessageHandler* operator &() const { return &self; }
4222         const LDKRoutingMessageHandler* operator ->() const { return &self; }
4223         /**
4224          *  Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
4225          *  `false` or returning an `Err` otherwise.
4226          */
4227         inline LDK::CResult_boolLightningErrorZ handle_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg);
4228         /**
4229          *  Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
4230          *  or returning an `Err` otherwise.
4231          */
4232         inline LDK::CResult_boolLightningErrorZ handle_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg);
4233         /**
4234          *  Handle an incoming `channel_update` message, returning true if it should be forwarded on,
4235          *  `false` or returning an `Err` otherwise.
4236          */
4237         inline LDK::CResult_boolLightningErrorZ handle_channel_update(const struct LDKChannelUpdate *NONNULL_PTR msg);
4238         /**
4239          *  Gets channel announcements and updates required to dump our routing table to a remote node,
4240          *  starting at the `short_channel_id` indicated by `starting_point` and including announcements
4241          *  for a single channel.
4242          */
4243         inline LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcement(uint64_t starting_point);
4244         /**
4245          *  Gets a node announcement required to dump our routing table to a remote node, starting at
4246          *  the node *after* the provided pubkey and including up to one announcement immediately
4247          *  higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
4248          *  If `None` is provided for `starting_point`, we start at the first node.
4249          *
4250          *  Note that starting_point (or a relevant inner pointer) may be NULL or all-0s to represent None
4251          *  Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
4252          */
4253         inline LDK::NodeAnnouncement get_next_node_announcement(struct LDKNodeId starting_point);
4254         /**
4255          *  Called when a connection is established with a peer. This can be used to
4256          *  perform routing table synchronization using a strategy defined by the
4257          *  implementor.
4258          *
4259          *  May return an `Err(())` if the features the peer supports are not sufficient to communicate
4260          *  with us. Implementors should be somewhat conservative about doing so, however, as other
4261          *  message handlers may still wish to communicate with this peer.
4262          */
4263         inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound);
4264         /**
4265          *  Handles the reply of a query we initiated to learn about channels
4266          *  for a given range of blocks. We can expect to receive one or more
4267          *  replies to a single query.
4268          */
4269         inline LDK::CResult_NoneLightningErrorZ handle_reply_channel_range(struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg);
4270         /**
4271          *  Handles the reply of a query we initiated asking for routing gossip
4272          *  messages for a list of channels. We should receive this message when
4273          *  a node has completed its best effort to send us the pertaining routing
4274          *  gossip messages.
4275          */
4276         inline LDK::CResult_NoneLightningErrorZ handle_reply_short_channel_ids_end(struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg);
4277         /**
4278          *  Handles when a peer asks us to send a list of `short_channel_id`s
4279          *  for the requested range of blocks.
4280          */
4281         inline LDK::CResult_NoneLightningErrorZ handle_query_channel_range(struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg);
4282         /**
4283          *  Handles when a peer asks us to send routing gossip messages for a
4284          *  list of `short_channel_id`s.
4285          */
4286         inline LDK::CResult_NoneLightningErrorZ handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg);
4287         /**
4288          *  Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
4289          *  pending some async action. While there is no guarantee of the rate of future messages, the
4290          *  caller should seek to reduce the rate of new gossip messages handled, especially
4291          *  [`ChannelAnnouncement`]s.
4292          */
4293         inline bool processing_queue_high();
4294         /**
4295          *  Gets the node feature flags which this handler itself supports. All available handlers are
4296          *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
4297          *  which are broadcasted in our [`NodeAnnouncement`] message.
4298          */
4299         inline LDK::NodeFeatures provided_node_features();
4300         /**
4301          *  Gets the init feature flags which should be sent to the given peer. All available handlers
4302          *  are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
4303          *  which are sent in our [`Init`] message.
4304          *
4305          *  Note that this method is called before [`Self::peer_connected`].
4306          */
4307         inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
4308 };
4309 class OnionMessageHandler {
4310 private:
4311         LDKOnionMessageHandler self;
4312 public:
4313         OnionMessageHandler(const OnionMessageHandler&) = delete;
4314         OnionMessageHandler(OnionMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageHandler)); }
4315         OnionMessageHandler(LDKOnionMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageHandler)); }
4316         operator LDKOnionMessageHandler() && { LDKOnionMessageHandler res = self; memset(&self, 0, sizeof(LDKOnionMessageHandler)); return res; }
4317         ~OnionMessageHandler() { OnionMessageHandler_free(self); }
4318         OnionMessageHandler& operator=(OnionMessageHandler&& o) { OnionMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageHandler)); return *this; }
4319         LDKOnionMessageHandler* operator &() { return &self; }
4320         LDKOnionMessageHandler* operator ->() { return &self; }
4321         const LDKOnionMessageHandler* operator &() const { return &self; }
4322         const LDKOnionMessageHandler* operator ->() const { return &self; }
4323         /**
4324          *  Handle an incoming `onion_message` message from the given peer.
4325          */
4326         inline void handle_onion_message(struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg);
4327         /**
4328          *  Called when a connection is established with a peer. Can be used to track which peers
4329          *  advertise onion message support and are online.
4330          *
4331          *  May return an `Err(())` if the features the peer supports are not sufficient to communicate
4332          *  with us. Implementors should be somewhat conservative about doing so, however, as other
4333          *  message handlers may still wish to communicate with this peer.
4334          */
4335         inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound);
4336         /**
4337          *  Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
4338          *  drop and refuse to forward onion messages to this peer.
4339          */
4340         inline void peer_disconnected(struct LDKPublicKey their_node_id);
4341         /**
4342          *  Gets the node feature flags which this handler itself supports. All available handlers are
4343          *  queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
4344          *  which are broadcasted in our [`NodeAnnouncement`] message.
4345          */
4346         inline LDK::NodeFeatures provided_node_features();
4347         /**
4348          *  Gets the init feature flags which should be sent to the given peer. All available handlers
4349          *  are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
4350          *  which are sent in our [`Init`] message.
4351          *
4352          *  Note that this method is called before [`Self::peer_connected`].
4353          */
4354         inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
4355 };
4356 class Level {
4357 private:
4358         LDKLevel self;
4359 public:
4360         Level(const Level&) = delete;
4361         Level(Level&& o) : self(o.self) { memset(&o, 0, sizeof(Level)); }
4362         Level(LDKLevel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLevel)); }
4363         operator LDKLevel() && { LDKLevel res = self; memset(&self, 0, sizeof(LDKLevel)); return res; }
4364         Level& operator=(Level&& o) { self = o.self; memset(&o, 0, sizeof(Level)); return *this; }
4365         LDKLevel* operator &() { return &self; }
4366         LDKLevel* operator ->() { return &self; }
4367         const LDKLevel* operator &() const { return &self; }
4368         const LDKLevel* operator ->() const { return &self; }
4369 };
4370 class Record {
4371 private:
4372         LDKRecord self;
4373 public:
4374         Record(const Record&) = delete;
4375         Record(Record&& o) : self(o.self) { memset(&o, 0, sizeof(Record)); }
4376         Record(LDKRecord&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecord)); }
4377         operator LDKRecord() && { LDKRecord res = self; memset(&self, 0, sizeof(LDKRecord)); return res; }
4378         ~Record() { Record_free(self); }
4379         Record& operator=(Record&& o) { Record_free(self); self = o.self; memset(&o, 0, sizeof(Record)); return *this; }
4380         LDKRecord* operator &() { return &self; }
4381         LDKRecord* operator ->() { return &self; }
4382         const LDKRecord* operator &() const { return &self; }
4383         const LDKRecord* operator ->() const { return &self; }
4384 };
4385 class Logger {
4386 private:
4387         LDKLogger self;
4388 public:
4389         Logger(const Logger&) = delete;
4390         Logger(Logger&& o) : self(o.self) { memset(&o, 0, sizeof(Logger)); }
4391         Logger(LDKLogger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLogger)); }
4392         operator LDKLogger() && { LDKLogger res = self; memset(&self, 0, sizeof(LDKLogger)); return res; }
4393         ~Logger() { Logger_free(self); }
4394         Logger& operator=(Logger&& o) { Logger_free(self); self = o.self; memset(&o, 0, sizeof(Logger)); return *this; }
4395         LDKLogger* operator &() { return &self; }
4396         LDKLogger* operator ->() { return &self; }
4397         const LDKLogger* operator &() const { return &self; }
4398         const LDKLogger* operator ->() const { return &self; }
4399         /**
4400          *  Logs the `Record`
4401          */
4402         inline void log(const struct LDKRecord *NONNULL_PTR record);
4403 };
4404 class FutureCallback {
4405 private:
4406         LDKFutureCallback self;
4407 public:
4408         FutureCallback(const FutureCallback&) = delete;
4409         FutureCallback(FutureCallback&& o) : self(o.self) { memset(&o, 0, sizeof(FutureCallback)); }
4410         FutureCallback(LDKFutureCallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFutureCallback)); }
4411         operator LDKFutureCallback() && { LDKFutureCallback res = self; memset(&self, 0, sizeof(LDKFutureCallback)); return res; }
4412         ~FutureCallback() { FutureCallback_free(self); }
4413         FutureCallback& operator=(FutureCallback&& o) { FutureCallback_free(self); self = o.self; memset(&o, 0, sizeof(FutureCallback)); return *this; }
4414         LDKFutureCallback* operator &() { return &self; }
4415         LDKFutureCallback* operator ->() { return &self; }
4416         const LDKFutureCallback* operator &() const { return &self; }
4417         const LDKFutureCallback* operator ->() const { return &self; }
4418         /**
4419          *  The method which is called.
4420          */
4421         inline void call();
4422 };
4423 class Future {
4424 private:
4425         LDKFuture self;
4426 public:
4427         Future(const Future&) = delete;
4428         Future(Future&& o) : self(o.self) { memset(&o, 0, sizeof(Future)); }
4429         Future(LDKFuture&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFuture)); }
4430         operator LDKFuture() && { LDKFuture res = self; memset(&self, 0, sizeof(LDKFuture)); return res; }
4431         ~Future() { Future_free(self); }
4432         Future& operator=(Future&& o) { Future_free(self); self = o.self; memset(&o, 0, sizeof(Future)); return *this; }
4433         LDKFuture* operator &() { return &self; }
4434         LDKFuture* operator ->() { return &self; }
4435         const LDKFuture* operator &() const { return &self; }
4436         const LDKFuture* operator ->() const { return &self; }
4437 };
4438 class Sleeper {
4439 private:
4440         LDKSleeper self;
4441 public:
4442         Sleeper(const Sleeper&) = delete;
4443         Sleeper(Sleeper&& o) : self(o.self) { memset(&o, 0, sizeof(Sleeper)); }
4444         Sleeper(LDKSleeper&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSleeper)); }
4445         operator LDKSleeper() && { LDKSleeper res = self; memset(&self, 0, sizeof(LDKSleeper)); return res; }
4446         ~Sleeper() { Sleeper_free(self); }
4447         Sleeper& operator=(Sleeper&& o) { Sleeper_free(self); self = o.self; memset(&o, 0, sizeof(Sleeper)); return *this; }
4448         LDKSleeper* operator &() { return &self; }
4449         LDKSleeper* operator ->() { return &self; }
4450         const LDKSleeper* operator &() const { return &self; }
4451         const LDKSleeper* operator ->() const { return &self; }
4452 };
4453 class OffersMessageHandler {
4454 private:
4455         LDKOffersMessageHandler self;
4456 public:
4457         OffersMessageHandler(const OffersMessageHandler&) = delete;
4458         OffersMessageHandler(OffersMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(OffersMessageHandler)); }
4459         OffersMessageHandler(LDKOffersMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffersMessageHandler)); }
4460         operator LDKOffersMessageHandler() && { LDKOffersMessageHandler res = self; memset(&self, 0, sizeof(LDKOffersMessageHandler)); return res; }
4461         ~OffersMessageHandler() { OffersMessageHandler_free(self); }
4462         OffersMessageHandler& operator=(OffersMessageHandler&& o) { OffersMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(OffersMessageHandler)); return *this; }
4463         LDKOffersMessageHandler* operator &() { return &self; }
4464         LDKOffersMessageHandler* operator ->() { return &self; }
4465         const LDKOffersMessageHandler* operator &() const { return &self; }
4466         const LDKOffersMessageHandler* operator ->() const { return &self; }
4467         /**
4468          *  Handles the given message by either responding with an [`Bolt12Invoice`], sending a payment,
4469          *  or replying with an error.
4470          */
4471         inline LDK::COption_OffersMessageZ handle_message(struct LDKOffersMessage message);
4472 };
4473 class OffersMessage {
4474 private:
4475         LDKOffersMessage self;
4476 public:
4477         OffersMessage(const OffersMessage&) = delete;
4478         OffersMessage(OffersMessage&& o) : self(o.self) { memset(&o, 0, sizeof(OffersMessage)); }
4479         OffersMessage(LDKOffersMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffersMessage)); }
4480         operator LDKOffersMessage() && { LDKOffersMessage res = self; memset(&self, 0, sizeof(LDKOffersMessage)); return res; }
4481         ~OffersMessage() { OffersMessage_free(self); }
4482         OffersMessage& operator=(OffersMessage&& o) { OffersMessage_free(self); self = o.self; memset(&o, 0, sizeof(OffersMessage)); return *this; }
4483         LDKOffersMessage* operator &() { return &self; }
4484         LDKOffersMessage* operator ->() { return &self; }
4485         const LDKOffersMessage* operator &() const { return &self; }
4486         const LDKOffersMessage* operator ->() const { return &self; }
4487 };
4488 class HTLCClaim {
4489 private:
4490         LDKHTLCClaim self;
4491 public:
4492         HTLCClaim(const HTLCClaim&) = delete;
4493         HTLCClaim(HTLCClaim&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCClaim)); }
4494         HTLCClaim(LDKHTLCClaim&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCClaim)); }
4495         operator LDKHTLCClaim() && { LDKHTLCClaim res = self; memset(&self, 0, sizeof(LDKHTLCClaim)); return res; }
4496         HTLCClaim& operator=(HTLCClaim&& o) { self = o.self; memset(&o, 0, sizeof(HTLCClaim)); return *this; }
4497         LDKHTLCClaim* operator &() { return &self; }
4498         LDKHTLCClaim* operator ->() { return &self; }
4499         const LDKHTLCClaim* operator &() const { return &self; }
4500         const LDKHTLCClaim* operator ->() const { return &self; }
4501 };
4502 class CounterpartyCommitmentSecrets {
4503 private:
4504         LDKCounterpartyCommitmentSecrets self;
4505 public:
4506         CounterpartyCommitmentSecrets(const CounterpartyCommitmentSecrets&) = delete;
4507         CounterpartyCommitmentSecrets(CounterpartyCommitmentSecrets&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); }
4508         CounterpartyCommitmentSecrets(LDKCounterpartyCommitmentSecrets&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); }
4509         operator LDKCounterpartyCommitmentSecrets() && { LDKCounterpartyCommitmentSecrets res = self; memset(&self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); return res; }
4510         ~CounterpartyCommitmentSecrets() { CounterpartyCommitmentSecrets_free(self); }
4511         CounterpartyCommitmentSecrets& operator=(CounterpartyCommitmentSecrets&& o) { CounterpartyCommitmentSecrets_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); return *this; }
4512         LDKCounterpartyCommitmentSecrets* operator &() { return &self; }
4513         LDKCounterpartyCommitmentSecrets* operator ->() { return &self; }
4514         const LDKCounterpartyCommitmentSecrets* operator &() const { return &self; }
4515         const LDKCounterpartyCommitmentSecrets* operator ->() const { return &self; }
4516 };
4517 class TxCreationKeys {
4518 private:
4519         LDKTxCreationKeys self;
4520 public:
4521         TxCreationKeys(const TxCreationKeys&) = delete;
4522         TxCreationKeys(TxCreationKeys&& o) : self(o.self) { memset(&o, 0, sizeof(TxCreationKeys)); }
4523         TxCreationKeys(LDKTxCreationKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxCreationKeys)); }
4524         operator LDKTxCreationKeys() && { LDKTxCreationKeys res = self; memset(&self, 0, sizeof(LDKTxCreationKeys)); return res; }
4525         ~TxCreationKeys() { TxCreationKeys_free(self); }
4526         TxCreationKeys& operator=(TxCreationKeys&& o) { TxCreationKeys_free(self); self = o.self; memset(&o, 0, sizeof(TxCreationKeys)); return *this; }
4527         LDKTxCreationKeys* operator &() { return &self; }
4528         LDKTxCreationKeys* operator ->() { return &self; }
4529         const LDKTxCreationKeys* operator &() const { return &self; }
4530         const LDKTxCreationKeys* operator ->() const { return &self; }
4531 };
4532 class ChannelPublicKeys {
4533 private:
4534         LDKChannelPublicKeys self;
4535 public:
4536         ChannelPublicKeys(const ChannelPublicKeys&) = delete;
4537         ChannelPublicKeys(ChannelPublicKeys&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelPublicKeys)); }
4538         ChannelPublicKeys(LDKChannelPublicKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelPublicKeys)); }
4539         operator LDKChannelPublicKeys() && { LDKChannelPublicKeys res = self; memset(&self, 0, sizeof(LDKChannelPublicKeys)); return res; }
4540         ~ChannelPublicKeys() { ChannelPublicKeys_free(self); }
4541         ChannelPublicKeys& operator=(ChannelPublicKeys&& o) { ChannelPublicKeys_free(self); self = o.self; memset(&o, 0, sizeof(ChannelPublicKeys)); return *this; }
4542         LDKChannelPublicKeys* operator &() { return &self; }
4543         LDKChannelPublicKeys* operator ->() { return &self; }
4544         const LDKChannelPublicKeys* operator &() const { return &self; }
4545         const LDKChannelPublicKeys* operator ->() const { return &self; }
4546 };
4547 class HTLCOutputInCommitment {
4548 private:
4549         LDKHTLCOutputInCommitment self;
4550 public:
4551         HTLCOutputInCommitment(const HTLCOutputInCommitment&) = delete;
4552         HTLCOutputInCommitment(HTLCOutputInCommitment&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCOutputInCommitment)); }
4553         HTLCOutputInCommitment(LDKHTLCOutputInCommitment&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCOutputInCommitment)); }
4554         operator LDKHTLCOutputInCommitment() && { LDKHTLCOutputInCommitment res = self; memset(&self, 0, sizeof(LDKHTLCOutputInCommitment)); return res; }
4555         ~HTLCOutputInCommitment() { HTLCOutputInCommitment_free(self); }
4556         HTLCOutputInCommitment& operator=(HTLCOutputInCommitment&& o) { HTLCOutputInCommitment_free(self); self = o.self; memset(&o, 0, sizeof(HTLCOutputInCommitment)); return *this; }
4557         LDKHTLCOutputInCommitment* operator &() { return &self; }
4558         LDKHTLCOutputInCommitment* operator ->() { return &self; }
4559         const LDKHTLCOutputInCommitment* operator &() const { return &self; }
4560         const LDKHTLCOutputInCommitment* operator ->() const { return &self; }
4561 };
4562 class ChannelTransactionParameters {
4563 private:
4564         LDKChannelTransactionParameters self;
4565 public:
4566         ChannelTransactionParameters(const ChannelTransactionParameters&) = delete;
4567         ChannelTransactionParameters(ChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTransactionParameters)); }
4568         ChannelTransactionParameters(LDKChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTransactionParameters)); }
4569         operator LDKChannelTransactionParameters() && { LDKChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKChannelTransactionParameters)); return res; }
4570         ~ChannelTransactionParameters() { ChannelTransactionParameters_free(self); }
4571         ChannelTransactionParameters& operator=(ChannelTransactionParameters&& o) { ChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTransactionParameters)); return *this; }
4572         LDKChannelTransactionParameters* operator &() { return &self; }
4573         LDKChannelTransactionParameters* operator ->() { return &self; }
4574         const LDKChannelTransactionParameters* operator &() const { return &self; }
4575         const LDKChannelTransactionParameters* operator ->() const { return &self; }
4576 };
4577 class CounterpartyChannelTransactionParameters {
4578 private:
4579         LDKCounterpartyChannelTransactionParameters self;
4580 public:
4581         CounterpartyChannelTransactionParameters(const CounterpartyChannelTransactionParameters&) = delete;
4582         CounterpartyChannelTransactionParameters(CounterpartyChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyChannelTransactionParameters)); }
4583         CounterpartyChannelTransactionParameters(LDKCounterpartyChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyChannelTransactionParameters)); }
4584         operator LDKCounterpartyChannelTransactionParameters() && { LDKCounterpartyChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKCounterpartyChannelTransactionParameters)); return res; }
4585         ~CounterpartyChannelTransactionParameters() { CounterpartyChannelTransactionParameters_free(self); }
4586         CounterpartyChannelTransactionParameters& operator=(CounterpartyChannelTransactionParameters&& o) { CounterpartyChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyChannelTransactionParameters)); return *this; }
4587         LDKCounterpartyChannelTransactionParameters* operator &() { return &self; }
4588         LDKCounterpartyChannelTransactionParameters* operator ->() { return &self; }
4589         const LDKCounterpartyChannelTransactionParameters* operator &() const { return &self; }
4590         const LDKCounterpartyChannelTransactionParameters* operator ->() const { return &self; }
4591 };
4592 class DirectedChannelTransactionParameters {
4593 private:
4594         LDKDirectedChannelTransactionParameters self;
4595 public:
4596         DirectedChannelTransactionParameters(const DirectedChannelTransactionParameters&) = delete;
4597         DirectedChannelTransactionParameters(DirectedChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(DirectedChannelTransactionParameters)); }
4598         DirectedChannelTransactionParameters(LDKDirectedChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectedChannelTransactionParameters)); }
4599         operator LDKDirectedChannelTransactionParameters() && { LDKDirectedChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKDirectedChannelTransactionParameters)); return res; }
4600         ~DirectedChannelTransactionParameters() { DirectedChannelTransactionParameters_free(self); }
4601         DirectedChannelTransactionParameters& operator=(DirectedChannelTransactionParameters&& o) { DirectedChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(DirectedChannelTransactionParameters)); return *this; }
4602         LDKDirectedChannelTransactionParameters* operator &() { return &self; }
4603         LDKDirectedChannelTransactionParameters* operator ->() { return &self; }
4604         const LDKDirectedChannelTransactionParameters* operator &() const { return &self; }
4605         const LDKDirectedChannelTransactionParameters* operator ->() const { return &self; }
4606 };
4607 class HolderCommitmentTransaction {
4608 private:
4609         LDKHolderCommitmentTransaction self;
4610 public:
4611         HolderCommitmentTransaction(const HolderCommitmentTransaction&) = delete;
4612         HolderCommitmentTransaction(HolderCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(HolderCommitmentTransaction)); }
4613         HolderCommitmentTransaction(LDKHolderCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHolderCommitmentTransaction)); }
4614         operator LDKHolderCommitmentTransaction() && { LDKHolderCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKHolderCommitmentTransaction)); return res; }
4615         ~HolderCommitmentTransaction() { HolderCommitmentTransaction_free(self); }
4616         HolderCommitmentTransaction& operator=(HolderCommitmentTransaction&& o) { HolderCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(HolderCommitmentTransaction)); return *this; }
4617         LDKHolderCommitmentTransaction* operator &() { return &self; }
4618         LDKHolderCommitmentTransaction* operator ->() { return &self; }
4619         const LDKHolderCommitmentTransaction* operator &() const { return &self; }
4620         const LDKHolderCommitmentTransaction* operator ->() const { return &self; }
4621 };
4622 class BuiltCommitmentTransaction {
4623 private:
4624         LDKBuiltCommitmentTransaction self;
4625 public:
4626         BuiltCommitmentTransaction(const BuiltCommitmentTransaction&) = delete;
4627         BuiltCommitmentTransaction(BuiltCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(BuiltCommitmentTransaction)); }
4628         BuiltCommitmentTransaction(LDKBuiltCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBuiltCommitmentTransaction)); }
4629         operator LDKBuiltCommitmentTransaction() && { LDKBuiltCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKBuiltCommitmentTransaction)); return res; }
4630         ~BuiltCommitmentTransaction() { BuiltCommitmentTransaction_free(self); }
4631         BuiltCommitmentTransaction& operator=(BuiltCommitmentTransaction&& o) { BuiltCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(BuiltCommitmentTransaction)); return *this; }
4632         LDKBuiltCommitmentTransaction* operator &() { return &self; }
4633         LDKBuiltCommitmentTransaction* operator ->() { return &self; }
4634         const LDKBuiltCommitmentTransaction* operator &() const { return &self; }
4635         const LDKBuiltCommitmentTransaction* operator ->() const { return &self; }
4636 };
4637 class ClosingTransaction {
4638 private:
4639         LDKClosingTransaction self;
4640 public:
4641         ClosingTransaction(const ClosingTransaction&) = delete;
4642         ClosingTransaction(ClosingTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingTransaction)); }
4643         ClosingTransaction(LDKClosingTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingTransaction)); }
4644         operator LDKClosingTransaction() && { LDKClosingTransaction res = self; memset(&self, 0, sizeof(LDKClosingTransaction)); return res; }
4645         ~ClosingTransaction() { ClosingTransaction_free(self); }
4646         ClosingTransaction& operator=(ClosingTransaction&& o) { ClosingTransaction_free(self); self = o.self; memset(&o, 0, sizeof(ClosingTransaction)); return *this; }
4647         LDKClosingTransaction* operator &() { return &self; }
4648         LDKClosingTransaction* operator ->() { return &self; }
4649         const LDKClosingTransaction* operator &() const { return &self; }
4650         const LDKClosingTransaction* operator ->() const { return &self; }
4651 };
4652 class TrustedClosingTransaction {
4653 private:
4654         LDKTrustedClosingTransaction self;
4655 public:
4656         TrustedClosingTransaction(const TrustedClosingTransaction&) = delete;
4657         TrustedClosingTransaction(TrustedClosingTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(TrustedClosingTransaction)); }
4658         TrustedClosingTransaction(LDKTrustedClosingTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrustedClosingTransaction)); }
4659         operator LDKTrustedClosingTransaction() && { LDKTrustedClosingTransaction res = self; memset(&self, 0, sizeof(LDKTrustedClosingTransaction)); return res; }
4660         ~TrustedClosingTransaction() { TrustedClosingTransaction_free(self); }
4661         TrustedClosingTransaction& operator=(TrustedClosingTransaction&& o) { TrustedClosingTransaction_free(self); self = o.self; memset(&o, 0, sizeof(TrustedClosingTransaction)); return *this; }
4662         LDKTrustedClosingTransaction* operator &() { return &self; }
4663         LDKTrustedClosingTransaction* operator ->() { return &self; }
4664         const LDKTrustedClosingTransaction* operator &() const { return &self; }
4665         const LDKTrustedClosingTransaction* operator ->() const { return &self; }
4666 };
4667 class CommitmentTransaction {
4668 private:
4669         LDKCommitmentTransaction self;
4670 public:
4671         CommitmentTransaction(const CommitmentTransaction&) = delete;
4672         CommitmentTransaction(CommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentTransaction)); }
4673         CommitmentTransaction(LDKCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentTransaction)); }
4674         operator LDKCommitmentTransaction() && { LDKCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKCommitmentTransaction)); return res; }
4675         ~CommitmentTransaction() { CommitmentTransaction_free(self); }
4676         CommitmentTransaction& operator=(CommitmentTransaction&& o) { CommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentTransaction)); return *this; }
4677         LDKCommitmentTransaction* operator &() { return &self; }
4678         LDKCommitmentTransaction* operator ->() { return &self; }
4679         const LDKCommitmentTransaction* operator &() const { return &self; }
4680         const LDKCommitmentTransaction* operator ->() const { return &self; }
4681 };
4682 class TrustedCommitmentTransaction {
4683 private:
4684         LDKTrustedCommitmentTransaction self;
4685 public:
4686         TrustedCommitmentTransaction(const TrustedCommitmentTransaction&) = delete;
4687         TrustedCommitmentTransaction(TrustedCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(TrustedCommitmentTransaction)); }
4688         TrustedCommitmentTransaction(LDKTrustedCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrustedCommitmentTransaction)); }
4689         operator LDKTrustedCommitmentTransaction() && { LDKTrustedCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKTrustedCommitmentTransaction)); return res; }
4690         ~TrustedCommitmentTransaction() { TrustedCommitmentTransaction_free(self); }
4691         TrustedCommitmentTransaction& operator=(TrustedCommitmentTransaction&& o) { TrustedCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(TrustedCommitmentTransaction)); return *this; }
4692         LDKTrustedCommitmentTransaction* operator &() { return &self; }
4693         LDKTrustedCommitmentTransaction* operator ->() { return &self; }
4694         const LDKTrustedCommitmentTransaction* operator &() const { return &self; }
4695         const LDKTrustedCommitmentTransaction* operator ->() const { return &self; }
4696 };
4697 class ShutdownScript {
4698 private:
4699         LDKShutdownScript self;
4700 public:
4701         ShutdownScript(const ShutdownScript&) = delete;
4702         ShutdownScript(ShutdownScript&& o) : self(o.self) { memset(&o, 0, sizeof(ShutdownScript)); }
4703         ShutdownScript(LDKShutdownScript&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdownScript)); }
4704         operator LDKShutdownScript() && { LDKShutdownScript res = self; memset(&self, 0, sizeof(LDKShutdownScript)); return res; }
4705         ~ShutdownScript() { ShutdownScript_free(self); }
4706         ShutdownScript& operator=(ShutdownScript&& o) { ShutdownScript_free(self); self = o.self; memset(&o, 0, sizeof(ShutdownScript)); return *this; }
4707         LDKShutdownScript* operator &() { return &self; }
4708         LDKShutdownScript* operator ->() { return &self; }
4709         const LDKShutdownScript* operator &() const { return &self; }
4710         const LDKShutdownScript* operator ->() const { return &self; }
4711 };
4712 class InvalidShutdownScript {
4713 private:
4714         LDKInvalidShutdownScript self;
4715 public:
4716         InvalidShutdownScript(const InvalidShutdownScript&) = delete;
4717         InvalidShutdownScript(InvalidShutdownScript&& o) : self(o.self) { memset(&o, 0, sizeof(InvalidShutdownScript)); }
4718         InvalidShutdownScript(LDKInvalidShutdownScript&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvalidShutdownScript)); }
4719         operator LDKInvalidShutdownScript() && { LDKInvalidShutdownScript res = self; memset(&self, 0, sizeof(LDKInvalidShutdownScript)); return res; }
4720         ~InvalidShutdownScript() { InvalidShutdownScript_free(self); }
4721         InvalidShutdownScript& operator=(InvalidShutdownScript&& o) { InvalidShutdownScript_free(self); self = o.self; memset(&o, 0, sizeof(InvalidShutdownScript)); return *this; }
4722         LDKInvalidShutdownScript* operator &() { return &self; }
4723         LDKInvalidShutdownScript* operator ->() { return &self; }
4724         const LDKInvalidShutdownScript* operator &() const { return &self; }
4725         const LDKInvalidShutdownScript* operator ->() const { return &self; }
4726 };
4727 class Bolt12ParseError {
4728 private:
4729         LDKBolt12ParseError self;
4730 public:
4731         Bolt12ParseError(const Bolt12ParseError&) = delete;
4732         Bolt12ParseError(Bolt12ParseError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12ParseError)); }
4733         Bolt12ParseError(LDKBolt12ParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12ParseError)); }
4734         operator LDKBolt12ParseError() && { LDKBolt12ParseError res = self; memset(&self, 0, sizeof(LDKBolt12ParseError)); return res; }
4735         ~Bolt12ParseError() { Bolt12ParseError_free(self); }
4736         Bolt12ParseError& operator=(Bolt12ParseError&& o) { Bolt12ParseError_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12ParseError)); return *this; }
4737         LDKBolt12ParseError* operator &() { return &self; }
4738         LDKBolt12ParseError* operator ->() { return &self; }
4739         const LDKBolt12ParseError* operator &() const { return &self; }
4740         const LDKBolt12ParseError* operator ->() const { return &self; }
4741 };
4742 class Bolt12SemanticError {
4743 private:
4744         LDKBolt12SemanticError self;
4745 public:
4746         Bolt12SemanticError(const Bolt12SemanticError&) = delete;
4747         Bolt12SemanticError(Bolt12SemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12SemanticError)); }
4748         Bolt12SemanticError(LDKBolt12SemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12SemanticError)); }
4749         operator LDKBolt12SemanticError() && { LDKBolt12SemanticError res = self; memset(&self, 0, sizeof(LDKBolt12SemanticError)); return res; }
4750         Bolt12SemanticError& operator=(Bolt12SemanticError&& o) { self = o.self; memset(&o, 0, sizeof(Bolt12SemanticError)); return *this; }
4751         LDKBolt12SemanticError* operator &() { return &self; }
4752         LDKBolt12SemanticError* operator ->() { return &self; }
4753         const LDKBolt12SemanticError* operator &() const { return &self; }
4754         const LDKBolt12SemanticError* operator ->() const { return &self; }
4755 };
4756 class BroadcasterInterface {
4757 private:
4758         LDKBroadcasterInterface self;
4759 public:
4760         BroadcasterInterface(const BroadcasterInterface&) = delete;
4761         BroadcasterInterface(BroadcasterInterface&& o) : self(o.self) { memset(&o, 0, sizeof(BroadcasterInterface)); }
4762         BroadcasterInterface(LDKBroadcasterInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBroadcasterInterface)); }
4763         operator LDKBroadcasterInterface() && { LDKBroadcasterInterface res = self; memset(&self, 0, sizeof(LDKBroadcasterInterface)); return res; }
4764         ~BroadcasterInterface() { BroadcasterInterface_free(self); }
4765         BroadcasterInterface& operator=(BroadcasterInterface&& o) { BroadcasterInterface_free(self); self = o.self; memset(&o, 0, sizeof(BroadcasterInterface)); return *this; }
4766         LDKBroadcasterInterface* operator &() { return &self; }
4767         LDKBroadcasterInterface* operator ->() { return &self; }
4768         const LDKBroadcasterInterface* operator &() const { return &self; }
4769         const LDKBroadcasterInterface* operator ->() const { return &self; }
4770         /**
4771          *  Sends a list of transactions out to (hopefully) be mined.
4772          *  This only needs to handle the actual broadcasting of transactions, LDK will automatically
4773          *  rebroadcast transactions that haven't made it into a block.
4774          *
4775          *  In some cases LDK may attempt to broadcast a transaction which double-spends another
4776          *  and this isn't a bug and can be safely ignored.
4777          *
4778          *  If more than one transaction is given, these transactions should be considered to be a
4779          *  package and broadcast together. Some of the transactions may or may not depend on each other,
4780          *  be sure to manage both cases correctly.
4781          *
4782          *  Bitcoin transaction packages are defined in BIP 331 and here:
4783          *  https://github.com/bitcoin/bitcoin/blob/master/doc/policy/packages.md
4784          */
4785         inline void broadcast_transactions(struct LDKCVec_TransactionZ txs);
4786 };
4787 class ConfirmationTarget {
4788 private:
4789         LDKConfirmationTarget self;
4790 public:
4791         ConfirmationTarget(const ConfirmationTarget&) = delete;
4792         ConfirmationTarget(ConfirmationTarget&& o) : self(o.self) { memset(&o, 0, sizeof(ConfirmationTarget)); }
4793         ConfirmationTarget(LDKConfirmationTarget&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirmationTarget)); }
4794         operator LDKConfirmationTarget() && { LDKConfirmationTarget res = self; memset(&self, 0, sizeof(LDKConfirmationTarget)); return res; }
4795         ConfirmationTarget& operator=(ConfirmationTarget&& o) { self = o.self; memset(&o, 0, sizeof(ConfirmationTarget)); return *this; }
4796         LDKConfirmationTarget* operator &() { return &self; }
4797         LDKConfirmationTarget* operator ->() { return &self; }
4798         const LDKConfirmationTarget* operator &() const { return &self; }
4799         const LDKConfirmationTarget* operator ->() const { return &self; }
4800 };
4801 class FeeEstimator {
4802 private:
4803         LDKFeeEstimator self;
4804 public:
4805         FeeEstimator(const FeeEstimator&) = delete;
4806         FeeEstimator(FeeEstimator&& o) : self(o.self) { memset(&o, 0, sizeof(FeeEstimator)); }
4807         FeeEstimator(LDKFeeEstimator&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFeeEstimator)); }
4808         operator LDKFeeEstimator() && { LDKFeeEstimator res = self; memset(&self, 0, sizeof(LDKFeeEstimator)); return res; }
4809         ~FeeEstimator() { FeeEstimator_free(self); }
4810         FeeEstimator& operator=(FeeEstimator&& o) { FeeEstimator_free(self); self = o.self; memset(&o, 0, sizeof(FeeEstimator)); return *this; }
4811         LDKFeeEstimator* operator &() { return &self; }
4812         LDKFeeEstimator* operator ->() { return &self; }
4813         const LDKFeeEstimator* operator &() const { return &self; }
4814         const LDKFeeEstimator* operator ->() const { return &self; }
4815         /**
4816          *  Gets estimated satoshis of fee required per 1000 Weight-Units.
4817          *
4818          *  LDK will wrap this method and ensure that the value returned is no smaller than 253
4819          *  (ie 1 satoshi-per-byte rounded up to ensure later round-downs don't put us below 1 satoshi-per-byte).
4820          *
4821          *  The following unit conversions can be used to convert to sats/KW:
4822          *   * satoshis-per-byte * 250
4823          *   * satoshis-per-kbyte / 4
4824          */
4825         inline uint32_t get_est_sat_per_1000_weight(enum LDKConfirmationTarget confirmation_target);
4826 };
4827 class Packet {
4828 private:
4829         LDKPacket self;
4830 public:
4831         Packet(const Packet&) = delete;
4832         Packet(Packet&& o) : self(o.self) { memset(&o, 0, sizeof(Packet)); }
4833         Packet(LDKPacket&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPacket)); }
4834         operator LDKPacket() && { LDKPacket res = self; memset(&self, 0, sizeof(LDKPacket)); return res; }
4835         ~Packet() { Packet_free(self); }
4836         Packet& operator=(Packet&& o) { Packet_free(self); self = o.self; memset(&o, 0, sizeof(Packet)); return *this; }
4837         LDKPacket* operator &() { return &self; }
4838         LDKPacket* operator ->() { return &self; }
4839         const LDKPacket* operator &() const { return &self; }
4840         const LDKPacket* operator ->() const { return &self; }
4841 };
4842 class OnionMessageContents {
4843 private:
4844         LDKOnionMessageContents self;
4845 public:
4846         OnionMessageContents(const OnionMessageContents&) = delete;
4847         OnionMessageContents(OnionMessageContents&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageContents)); }
4848         OnionMessageContents(LDKOnionMessageContents&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageContents)); }
4849         operator LDKOnionMessageContents() && { LDKOnionMessageContents res = self; memset(&self, 0, sizeof(LDKOnionMessageContents)); return res; }
4850         ~OnionMessageContents() { OnionMessageContents_free(self); }
4851         OnionMessageContents& operator=(OnionMessageContents&& o) { OnionMessageContents_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageContents)); return *this; }
4852         LDKOnionMessageContents* operator &() { return &self; }
4853         LDKOnionMessageContents* operator ->() { return &self; }
4854         const LDKOnionMessageContents* operator &() const { return &self; }
4855         const LDKOnionMessageContents* operator ->() const { return &self; }
4856 };
4857 class CustomOnionMessageContents {
4858 private:
4859         LDKCustomOnionMessageContents self;
4860 public:
4861         CustomOnionMessageContents(const CustomOnionMessageContents&) = delete;
4862         CustomOnionMessageContents(CustomOnionMessageContents&& o) : self(o.self) { memset(&o, 0, sizeof(CustomOnionMessageContents)); }
4863         CustomOnionMessageContents(LDKCustomOnionMessageContents&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomOnionMessageContents)); }
4864         operator LDKCustomOnionMessageContents() && { LDKCustomOnionMessageContents res = self; memset(&self, 0, sizeof(LDKCustomOnionMessageContents)); return res; }
4865         ~CustomOnionMessageContents() { CustomOnionMessageContents_free(self); }
4866         CustomOnionMessageContents& operator=(CustomOnionMessageContents&& o) { CustomOnionMessageContents_free(self); self = o.self; memset(&o, 0, sizeof(CustomOnionMessageContents)); return *this; }
4867         LDKCustomOnionMessageContents* operator &() { return &self; }
4868         LDKCustomOnionMessageContents* operator ->() { return &self; }
4869         const LDKCustomOnionMessageContents* operator &() const { return &self; }
4870         const LDKCustomOnionMessageContents* operator ->() const { return &self; }
4871         /**
4872          *  Returns the TLV type identifying the message contents. MUST be >= 64.
4873          */
4874         inline uint64_t tlv_type();
4875 };
4876 class PaymentPurpose {
4877 private:
4878         LDKPaymentPurpose self;
4879 public:
4880         PaymentPurpose(const PaymentPurpose&) = delete;
4881         PaymentPurpose(PaymentPurpose&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentPurpose)); }
4882         PaymentPurpose(LDKPaymentPurpose&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentPurpose)); }
4883         operator LDKPaymentPurpose() && { LDKPaymentPurpose res = self; memset(&self, 0, sizeof(LDKPaymentPurpose)); return res; }
4884         ~PaymentPurpose() { PaymentPurpose_free(self); }
4885         PaymentPurpose& operator=(PaymentPurpose&& o) { PaymentPurpose_free(self); self = o.self; memset(&o, 0, sizeof(PaymentPurpose)); return *this; }
4886         LDKPaymentPurpose* operator &() { return &self; }
4887         LDKPaymentPurpose* operator ->() { return &self; }
4888         const LDKPaymentPurpose* operator &() const { return &self; }
4889         const LDKPaymentPurpose* operator ->() const { return &self; }
4890 };
4891 class ClaimedHTLC {
4892 private:
4893         LDKClaimedHTLC self;
4894 public:
4895         ClaimedHTLC(const ClaimedHTLC&) = delete;
4896         ClaimedHTLC(ClaimedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(ClaimedHTLC)); }
4897         ClaimedHTLC(LDKClaimedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClaimedHTLC)); }
4898         operator LDKClaimedHTLC() && { LDKClaimedHTLC res = self; memset(&self, 0, sizeof(LDKClaimedHTLC)); return res; }
4899         ~ClaimedHTLC() { ClaimedHTLC_free(self); }
4900         ClaimedHTLC& operator=(ClaimedHTLC&& o) { ClaimedHTLC_free(self); self = o.self; memset(&o, 0, sizeof(ClaimedHTLC)); return *this; }
4901         LDKClaimedHTLC* operator &() { return &self; }
4902         LDKClaimedHTLC* operator ->() { return &self; }
4903         const LDKClaimedHTLC* operator &() const { return &self; }
4904         const LDKClaimedHTLC* operator ->() const { return &self; }
4905 };
4906 class PathFailure {
4907 private:
4908         LDKPathFailure self;
4909 public:
4910         PathFailure(const PathFailure&) = delete;
4911         PathFailure(PathFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PathFailure)); }
4912         PathFailure(LDKPathFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPathFailure)); }
4913         operator LDKPathFailure() && { LDKPathFailure res = self; memset(&self, 0, sizeof(LDKPathFailure)); return res; }
4914         ~PathFailure() { PathFailure_free(self); }
4915         PathFailure& operator=(PathFailure&& o) { PathFailure_free(self); self = o.self; memset(&o, 0, sizeof(PathFailure)); return *this; }
4916         LDKPathFailure* operator &() { return &self; }
4917         LDKPathFailure* operator ->() { return &self; }
4918         const LDKPathFailure* operator &() const { return &self; }
4919         const LDKPathFailure* operator ->() const { return &self; }
4920 };
4921 class ClosureReason {
4922 private:
4923         LDKClosureReason self;
4924 public:
4925         ClosureReason(const ClosureReason&) = delete;
4926         ClosureReason(ClosureReason&& o) : self(o.self) { memset(&o, 0, sizeof(ClosureReason)); }
4927         ClosureReason(LDKClosureReason&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosureReason)); }
4928         operator LDKClosureReason() && { LDKClosureReason res = self; memset(&self, 0, sizeof(LDKClosureReason)); return res; }
4929         ~ClosureReason() { ClosureReason_free(self); }
4930         ClosureReason& operator=(ClosureReason&& o) { ClosureReason_free(self); self = o.self; memset(&o, 0, sizeof(ClosureReason)); return *this; }
4931         LDKClosureReason* operator &() { return &self; }
4932         LDKClosureReason* operator ->() { return &self; }
4933         const LDKClosureReason* operator &() const { return &self; }
4934         const LDKClosureReason* operator ->() const { return &self; }
4935 };
4936 class HTLCDestination {
4937 private:
4938         LDKHTLCDestination self;
4939 public:
4940         HTLCDestination(const HTLCDestination&) = delete;
4941         HTLCDestination(HTLCDestination&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCDestination)); }
4942         HTLCDestination(LDKHTLCDestination&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCDestination)); }
4943         operator LDKHTLCDestination() && { LDKHTLCDestination res = self; memset(&self, 0, sizeof(LDKHTLCDestination)); return res; }
4944         ~HTLCDestination() { HTLCDestination_free(self); }
4945         HTLCDestination& operator=(HTLCDestination&& o) { HTLCDestination_free(self); self = o.self; memset(&o, 0, sizeof(HTLCDestination)); return *this; }
4946         LDKHTLCDestination* operator &() { return &self; }
4947         LDKHTLCDestination* operator ->() { return &self; }
4948         const LDKHTLCDestination* operator &() const { return &self; }
4949         const LDKHTLCDestination* operator ->() const { return &self; }
4950 };
4951 class PaymentFailureReason {
4952 private:
4953         LDKPaymentFailureReason self;
4954 public:
4955         PaymentFailureReason(const PaymentFailureReason&) = delete;
4956         PaymentFailureReason(PaymentFailureReason&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentFailureReason)); }
4957         PaymentFailureReason(LDKPaymentFailureReason&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentFailureReason)); }
4958         operator LDKPaymentFailureReason() && { LDKPaymentFailureReason res = self; memset(&self, 0, sizeof(LDKPaymentFailureReason)); return res; }
4959         PaymentFailureReason& operator=(PaymentFailureReason&& o) { self = o.self; memset(&o, 0, sizeof(PaymentFailureReason)); return *this; }
4960         LDKPaymentFailureReason* operator &() { return &self; }
4961         LDKPaymentFailureReason* operator ->() { return &self; }
4962         const LDKPaymentFailureReason* operator &() const { return &self; }
4963         const LDKPaymentFailureReason* operator ->() const { return &self; }
4964 };
4965 class Event {
4966 private:
4967         LDKEvent self;
4968 public:
4969         Event(const Event&) = delete;
4970         Event(Event&& o) : self(o.self) { memset(&o, 0, sizeof(Event)); }
4971         Event(LDKEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEvent)); }
4972         operator LDKEvent() && { LDKEvent res = self; memset(&self, 0, sizeof(LDKEvent)); return res; }
4973         ~Event() { Event_free(self); }
4974         Event& operator=(Event&& o) { Event_free(self); self = o.self; memset(&o, 0, sizeof(Event)); return *this; }
4975         LDKEvent* operator &() { return &self; }
4976         LDKEvent* operator ->() { return &self; }
4977         const LDKEvent* operator &() const { return &self; }
4978         const LDKEvent* operator ->() const { return &self; }
4979 };
4980 class MessageSendEvent {
4981 private:
4982         LDKMessageSendEvent self;
4983 public:
4984         MessageSendEvent(const MessageSendEvent&) = delete;
4985         MessageSendEvent(MessageSendEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEvent)); }
4986         MessageSendEvent(LDKMessageSendEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEvent)); }
4987         operator LDKMessageSendEvent() && { LDKMessageSendEvent res = self; memset(&self, 0, sizeof(LDKMessageSendEvent)); return res; }
4988         ~MessageSendEvent() { MessageSendEvent_free(self); }
4989         MessageSendEvent& operator=(MessageSendEvent&& o) { MessageSendEvent_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEvent)); return *this; }
4990         LDKMessageSendEvent* operator &() { return &self; }
4991         LDKMessageSendEvent* operator ->() { return &self; }
4992         const LDKMessageSendEvent* operator &() const { return &self; }
4993         const LDKMessageSendEvent* operator ->() const { return &self; }
4994 };
4995 class MessageSendEventsProvider {
4996 private:
4997         LDKMessageSendEventsProvider self;
4998 public:
4999         MessageSendEventsProvider(const MessageSendEventsProvider&) = delete;
5000         MessageSendEventsProvider(MessageSendEventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEventsProvider)); }
5001         MessageSendEventsProvider(LDKMessageSendEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEventsProvider)); }
5002         operator LDKMessageSendEventsProvider() && { LDKMessageSendEventsProvider res = self; memset(&self, 0, sizeof(LDKMessageSendEventsProvider)); return res; }
5003         ~MessageSendEventsProvider() { MessageSendEventsProvider_free(self); }
5004         MessageSendEventsProvider& operator=(MessageSendEventsProvider&& o) { MessageSendEventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEventsProvider)); return *this; }
5005         LDKMessageSendEventsProvider* operator &() { return &self; }
5006         LDKMessageSendEventsProvider* operator ->() { return &self; }
5007         const LDKMessageSendEventsProvider* operator &() const { return &self; }
5008         const LDKMessageSendEventsProvider* operator ->() const { return &self; }
5009         /**
5010          *  Gets the list of pending events which were generated by previous actions, clearing the list
5011          *  in the process.
5012          */
5013         inline LDK::CVec_MessageSendEventZ get_and_clear_pending_msg_events();
5014 };
5015 class OnionMessageProvider {
5016 private:
5017         LDKOnionMessageProvider self;
5018 public:
5019         OnionMessageProvider(const OnionMessageProvider&) = delete;
5020         OnionMessageProvider(OnionMessageProvider&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageProvider)); }
5021         OnionMessageProvider(LDKOnionMessageProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageProvider)); }
5022         operator LDKOnionMessageProvider() && { LDKOnionMessageProvider res = self; memset(&self, 0, sizeof(LDKOnionMessageProvider)); return res; }
5023         ~OnionMessageProvider() { OnionMessageProvider_free(self); }
5024         OnionMessageProvider& operator=(OnionMessageProvider&& o) { OnionMessageProvider_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageProvider)); return *this; }
5025         LDKOnionMessageProvider* operator &() { return &self; }
5026         LDKOnionMessageProvider* operator ->() { return &self; }
5027         const LDKOnionMessageProvider* operator &() const { return &self; }
5028         const LDKOnionMessageProvider* operator ->() const { return &self; }
5029         /**
5030          *  Gets the next pending onion message for the peer with the given node id.
5031          *
5032          *  Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
5033          */
5034         inline LDK::OnionMessage next_onion_message_for_peer(struct LDKPublicKey peer_node_id);
5035 };
5036 class EventsProvider {
5037 private:
5038         LDKEventsProvider self;
5039 public:
5040         EventsProvider(const EventsProvider&) = delete;
5041         EventsProvider(EventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(EventsProvider)); }
5042         EventsProvider(LDKEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventsProvider)); }
5043         operator LDKEventsProvider() && { LDKEventsProvider res = self; memset(&self, 0, sizeof(LDKEventsProvider)); return res; }
5044         ~EventsProvider() { EventsProvider_free(self); }
5045         EventsProvider& operator=(EventsProvider&& o) { EventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(EventsProvider)); return *this; }
5046         LDKEventsProvider* operator &() { return &self; }
5047         LDKEventsProvider* operator ->() { return &self; }
5048         const LDKEventsProvider* operator &() const { return &self; }
5049         const LDKEventsProvider* operator ->() const { return &self; }
5050         /**
5051          *  Processes any events generated since the last call using the given event handler.
5052          *
5053          *  See the trait-level documentation for requirements.
5054          */
5055         inline void process_pending_events(struct LDKEventHandler handler);
5056 };
5057 class EventHandler {
5058 private:
5059         LDKEventHandler self;
5060 public:
5061         EventHandler(const EventHandler&) = delete;
5062         EventHandler(EventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(EventHandler)); }
5063         EventHandler(LDKEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventHandler)); }
5064         operator LDKEventHandler() && { LDKEventHandler res = self; memset(&self, 0, sizeof(LDKEventHandler)); return res; }
5065         ~EventHandler() { EventHandler_free(self); }
5066         EventHandler& operator=(EventHandler&& o) { EventHandler_free(self); self = o.self; memset(&o, 0, sizeof(EventHandler)); return *this; }
5067         LDKEventHandler* operator &() { return &self; }
5068         LDKEventHandler* operator ->() { return &self; }
5069         const LDKEventHandler* operator &() const { return &self; }
5070         const LDKEventHandler* operator ->() const { return &self; }
5071         /**
5072          *  Handles the given [`Event`].
5073          *
5074          *  See [`EventsProvider`] for details that must be considered when implementing this method.
5075          */
5076         inline void handle_event(struct LDKEvent event);
5077 };
5078 class Bolt11ParseError {
5079 private:
5080         LDKBolt11ParseError self;
5081 public:
5082         Bolt11ParseError(const Bolt11ParseError&) = delete;
5083         Bolt11ParseError(Bolt11ParseError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11ParseError)); }
5084         Bolt11ParseError(LDKBolt11ParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11ParseError)); }
5085         operator LDKBolt11ParseError() && { LDKBolt11ParseError res = self; memset(&self, 0, sizeof(LDKBolt11ParseError)); return res; }
5086         ~Bolt11ParseError() { Bolt11ParseError_free(self); }
5087         Bolt11ParseError& operator=(Bolt11ParseError&& o) { Bolt11ParseError_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11ParseError)); return *this; }
5088         LDKBolt11ParseError* operator &() { return &self; }
5089         LDKBolt11ParseError* operator ->() { return &self; }
5090         const LDKBolt11ParseError* operator &() const { return &self; }
5091         const LDKBolt11ParseError* operator ->() const { return &self; }
5092 };
5093 class ParseOrSemanticError {
5094 private:
5095         LDKParseOrSemanticError self;
5096 public:
5097         ParseOrSemanticError(const ParseOrSemanticError&) = delete;
5098         ParseOrSemanticError(ParseOrSemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(ParseOrSemanticError)); }
5099         ParseOrSemanticError(LDKParseOrSemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKParseOrSemanticError)); }
5100         operator LDKParseOrSemanticError() && { LDKParseOrSemanticError res = self; memset(&self, 0, sizeof(LDKParseOrSemanticError)); return res; }
5101         ~ParseOrSemanticError() { ParseOrSemanticError_free(self); }
5102         ParseOrSemanticError& operator=(ParseOrSemanticError&& o) { ParseOrSemanticError_free(self); self = o.self; memset(&o, 0, sizeof(ParseOrSemanticError)); return *this; }
5103         LDKParseOrSemanticError* operator &() { return &self; }
5104         LDKParseOrSemanticError* operator ->() { return &self; }
5105         const LDKParseOrSemanticError* operator &() const { return &self; }
5106         const LDKParseOrSemanticError* operator ->() const { return &self; }
5107 };
5108 class Bolt11Invoice {
5109 private:
5110         LDKBolt11Invoice self;
5111 public:
5112         Bolt11Invoice(const Bolt11Invoice&) = delete;
5113         Bolt11Invoice(Bolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11Invoice)); }
5114         Bolt11Invoice(LDKBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11Invoice)); }
5115         operator LDKBolt11Invoice() && { LDKBolt11Invoice res = self; memset(&self, 0, sizeof(LDKBolt11Invoice)); return res; }
5116         ~Bolt11Invoice() { Bolt11Invoice_free(self); }
5117         Bolt11Invoice& operator=(Bolt11Invoice&& o) { Bolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11Invoice)); return *this; }
5118         LDKBolt11Invoice* operator &() { return &self; }
5119         LDKBolt11Invoice* operator ->() { return &self; }
5120         const LDKBolt11Invoice* operator &() const { return &self; }
5121         const LDKBolt11Invoice* operator ->() const { return &self; }
5122 };
5123 class SignedRawBolt11Invoice {
5124 private:
5125         LDKSignedRawBolt11Invoice self;
5126 public:
5127         SignedRawBolt11Invoice(const SignedRawBolt11Invoice&) = delete;
5128         SignedRawBolt11Invoice(SignedRawBolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(SignedRawBolt11Invoice)); }
5129         SignedRawBolt11Invoice(LDKSignedRawBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignedRawBolt11Invoice)); }
5130         operator LDKSignedRawBolt11Invoice() && { LDKSignedRawBolt11Invoice res = self; memset(&self, 0, sizeof(LDKSignedRawBolt11Invoice)); return res; }
5131         ~SignedRawBolt11Invoice() { SignedRawBolt11Invoice_free(self); }
5132         SignedRawBolt11Invoice& operator=(SignedRawBolt11Invoice&& o) { SignedRawBolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(SignedRawBolt11Invoice)); return *this; }
5133         LDKSignedRawBolt11Invoice* operator &() { return &self; }
5134         LDKSignedRawBolt11Invoice* operator ->() { return &self; }
5135         const LDKSignedRawBolt11Invoice* operator &() const { return &self; }
5136         const LDKSignedRawBolt11Invoice* operator ->() const { return &self; }
5137 };
5138 class RawBolt11Invoice {
5139 private:
5140         LDKRawBolt11Invoice self;
5141 public:
5142         RawBolt11Invoice(const RawBolt11Invoice&) = delete;
5143         RawBolt11Invoice(RawBolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(RawBolt11Invoice)); }
5144         RawBolt11Invoice(LDKRawBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawBolt11Invoice)); }
5145         operator LDKRawBolt11Invoice() && { LDKRawBolt11Invoice res = self; memset(&self, 0, sizeof(LDKRawBolt11Invoice)); return res; }
5146         ~RawBolt11Invoice() { RawBolt11Invoice_free(self); }
5147         RawBolt11Invoice& operator=(RawBolt11Invoice&& o) { RawBolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(RawBolt11Invoice)); return *this; }
5148         LDKRawBolt11Invoice* operator &() { return &self; }
5149         LDKRawBolt11Invoice* operator ->() { return &self; }
5150         const LDKRawBolt11Invoice* operator &() const { return &self; }
5151         const LDKRawBolt11Invoice* operator ->() const { return &self; }
5152 };
5153 class RawDataPart {
5154 private:
5155         LDKRawDataPart self;
5156 public:
5157         RawDataPart(const RawDataPart&) = delete;
5158         RawDataPart(RawDataPart&& o) : self(o.self) { memset(&o, 0, sizeof(RawDataPart)); }
5159         RawDataPart(LDKRawDataPart&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawDataPart)); }
5160         operator LDKRawDataPart() && { LDKRawDataPart res = self; memset(&self, 0, sizeof(LDKRawDataPart)); return res; }
5161         ~RawDataPart() { RawDataPart_free(self); }
5162         RawDataPart& operator=(RawDataPart&& o) { RawDataPart_free(self); self = o.self; memset(&o, 0, sizeof(RawDataPart)); return *this; }
5163         LDKRawDataPart* operator &() { return &self; }
5164         LDKRawDataPart* operator ->() { return &self; }
5165         const LDKRawDataPart* operator &() const { return &self; }
5166         const LDKRawDataPart* operator ->() const { return &self; }
5167 };
5168 class PositiveTimestamp {
5169 private:
5170         LDKPositiveTimestamp self;
5171 public:
5172         PositiveTimestamp(const PositiveTimestamp&) = delete;
5173         PositiveTimestamp(PositiveTimestamp&& o) : self(o.self) { memset(&o, 0, sizeof(PositiveTimestamp)); }
5174         PositiveTimestamp(LDKPositiveTimestamp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPositiveTimestamp)); }
5175         operator LDKPositiveTimestamp() && { LDKPositiveTimestamp res = self; memset(&self, 0, sizeof(LDKPositiveTimestamp)); return res; }
5176         ~PositiveTimestamp() { PositiveTimestamp_free(self); }
5177         PositiveTimestamp& operator=(PositiveTimestamp&& o) { PositiveTimestamp_free(self); self = o.self; memset(&o, 0, sizeof(PositiveTimestamp)); return *this; }
5178         LDKPositiveTimestamp* operator &() { return &self; }
5179         LDKPositiveTimestamp* operator ->() { return &self; }
5180         const LDKPositiveTimestamp* operator &() const { return &self; }
5181         const LDKPositiveTimestamp* operator ->() const { return &self; }
5182 };
5183 class SiPrefix {
5184 private:
5185         LDKSiPrefix self;
5186 public:
5187         SiPrefix(const SiPrefix&) = delete;
5188         SiPrefix(SiPrefix&& o) : self(o.self) { memset(&o, 0, sizeof(SiPrefix)); }
5189         SiPrefix(LDKSiPrefix&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSiPrefix)); }
5190         operator LDKSiPrefix() && { LDKSiPrefix res = self; memset(&self, 0, sizeof(LDKSiPrefix)); return res; }
5191         SiPrefix& operator=(SiPrefix&& o) { self = o.self; memset(&o, 0, sizeof(SiPrefix)); return *this; }
5192         LDKSiPrefix* operator &() { return &self; }
5193         LDKSiPrefix* operator ->() { return &self; }
5194         const LDKSiPrefix* operator &() const { return &self; }
5195         const LDKSiPrefix* operator ->() const { return &self; }
5196 };
5197 class Currency {
5198 private:
5199         LDKCurrency self;
5200 public:
5201         Currency(const Currency&) = delete;
5202         Currency(Currency&& o) : self(o.self) { memset(&o, 0, sizeof(Currency)); }
5203         Currency(LDKCurrency&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCurrency)); }
5204         operator LDKCurrency() && { LDKCurrency res = self; memset(&self, 0, sizeof(LDKCurrency)); return res; }
5205         Currency& operator=(Currency&& o) { self = o.self; memset(&o, 0, sizeof(Currency)); return *this; }
5206         LDKCurrency* operator &() { return &self; }
5207         LDKCurrency* operator ->() { return &self; }
5208         const LDKCurrency* operator &() const { return &self; }
5209         const LDKCurrency* operator ->() const { return &self; }
5210 };
5211 class Sha256 {
5212 private:
5213         LDKSha256 self;
5214 public:
5215         Sha256(const Sha256&) = delete;
5216         Sha256(Sha256&& o) : self(o.self) { memset(&o, 0, sizeof(Sha256)); }
5217         Sha256(LDKSha256&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSha256)); }
5218         operator LDKSha256() && { LDKSha256 res = self; memset(&self, 0, sizeof(LDKSha256)); return res; }
5219         ~Sha256() { Sha256_free(self); }
5220         Sha256& operator=(Sha256&& o) { Sha256_free(self); self = o.self; memset(&o, 0, sizeof(Sha256)); return *this; }
5221         LDKSha256* operator &() { return &self; }
5222         LDKSha256* operator ->() { return &self; }
5223         const LDKSha256* operator &() const { return &self; }
5224         const LDKSha256* operator ->() const { return &self; }
5225 };
5226 class Description {
5227 private:
5228         LDKDescription self;
5229 public:
5230         Description(const Description&) = delete;
5231         Description(Description&& o) : self(o.self) { memset(&o, 0, sizeof(Description)); }
5232         Description(LDKDescription&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDescription)); }
5233         operator LDKDescription() && { LDKDescription res = self; memset(&self, 0, sizeof(LDKDescription)); return res; }
5234         ~Description() { Description_free(self); }
5235         Description& operator=(Description&& o) { Description_free(self); self = o.self; memset(&o, 0, sizeof(Description)); return *this; }
5236         LDKDescription* operator &() { return &self; }
5237         LDKDescription* operator ->() { return &self; }
5238         const LDKDescription* operator &() const { return &self; }
5239         const LDKDescription* operator ->() const { return &self; }
5240 };
5241 class PayeePubKey {
5242 private:
5243         LDKPayeePubKey self;
5244 public:
5245         PayeePubKey(const PayeePubKey&) = delete;
5246         PayeePubKey(PayeePubKey&& o) : self(o.self) { memset(&o, 0, sizeof(PayeePubKey)); }
5247         PayeePubKey(LDKPayeePubKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayeePubKey)); }
5248         operator LDKPayeePubKey() && { LDKPayeePubKey res = self; memset(&self, 0, sizeof(LDKPayeePubKey)); return res; }
5249         ~PayeePubKey() { PayeePubKey_free(self); }
5250         PayeePubKey& operator=(PayeePubKey&& o) { PayeePubKey_free(self); self = o.self; memset(&o, 0, sizeof(PayeePubKey)); return *this; }
5251         LDKPayeePubKey* operator &() { return &self; }
5252         LDKPayeePubKey* operator ->() { return &self; }
5253         const LDKPayeePubKey* operator &() const { return &self; }
5254         const LDKPayeePubKey* operator ->() const { return &self; }
5255 };
5256 class ExpiryTime {
5257 private:
5258         LDKExpiryTime self;
5259 public:
5260         ExpiryTime(const ExpiryTime&) = delete;
5261         ExpiryTime(ExpiryTime&& o) : self(o.self) { memset(&o, 0, sizeof(ExpiryTime)); }
5262         ExpiryTime(LDKExpiryTime&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpiryTime)); }
5263         operator LDKExpiryTime() && { LDKExpiryTime res = self; memset(&self, 0, sizeof(LDKExpiryTime)); return res; }
5264         ~ExpiryTime() { ExpiryTime_free(self); }
5265         ExpiryTime& operator=(ExpiryTime&& o) { ExpiryTime_free(self); self = o.self; memset(&o, 0, sizeof(ExpiryTime)); return *this; }
5266         LDKExpiryTime* operator &() { return &self; }
5267         LDKExpiryTime* operator ->() { return &self; }
5268         const LDKExpiryTime* operator &() const { return &self; }
5269         const LDKExpiryTime* operator ->() const { return &self; }
5270 };
5271 class MinFinalCltvExpiryDelta {
5272 private:
5273         LDKMinFinalCltvExpiryDelta self;
5274 public:
5275         MinFinalCltvExpiryDelta(const MinFinalCltvExpiryDelta&) = delete;
5276         MinFinalCltvExpiryDelta(MinFinalCltvExpiryDelta&& o) : self(o.self) { memset(&o, 0, sizeof(MinFinalCltvExpiryDelta)); }
5277         MinFinalCltvExpiryDelta(LDKMinFinalCltvExpiryDelta&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMinFinalCltvExpiryDelta)); }
5278         operator LDKMinFinalCltvExpiryDelta() && { LDKMinFinalCltvExpiryDelta res = self; memset(&self, 0, sizeof(LDKMinFinalCltvExpiryDelta)); return res; }
5279         ~MinFinalCltvExpiryDelta() { MinFinalCltvExpiryDelta_free(self); }
5280         MinFinalCltvExpiryDelta& operator=(MinFinalCltvExpiryDelta&& o) { MinFinalCltvExpiryDelta_free(self); self = o.self; memset(&o, 0, sizeof(MinFinalCltvExpiryDelta)); return *this; }
5281         LDKMinFinalCltvExpiryDelta* operator &() { return &self; }
5282         LDKMinFinalCltvExpiryDelta* operator ->() { return &self; }
5283         const LDKMinFinalCltvExpiryDelta* operator &() const { return &self; }
5284         const LDKMinFinalCltvExpiryDelta* operator ->() const { return &self; }
5285 };
5286 class Fallback {
5287 private:
5288         LDKFallback self;
5289 public:
5290         Fallback(const Fallback&) = delete;
5291         Fallback(Fallback&& o) : self(o.self) { memset(&o, 0, sizeof(Fallback)); }
5292         Fallback(LDKFallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFallback)); }
5293         operator LDKFallback() && { LDKFallback res = self; memset(&self, 0, sizeof(LDKFallback)); return res; }
5294         ~Fallback() { Fallback_free(self); }
5295         Fallback& operator=(Fallback&& o) { Fallback_free(self); self = o.self; memset(&o, 0, sizeof(Fallback)); return *this; }
5296         LDKFallback* operator &() { return &self; }
5297         LDKFallback* operator ->() { return &self; }
5298         const LDKFallback* operator &() const { return &self; }
5299         const LDKFallback* operator ->() const { return &self; }
5300 };
5301 class Bolt11InvoiceSignature {
5302 private:
5303         LDKBolt11InvoiceSignature self;
5304 public:
5305         Bolt11InvoiceSignature(const Bolt11InvoiceSignature&) = delete;
5306         Bolt11InvoiceSignature(Bolt11InvoiceSignature&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11InvoiceSignature)); }
5307         Bolt11InvoiceSignature(LDKBolt11InvoiceSignature&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11InvoiceSignature)); }
5308         operator LDKBolt11InvoiceSignature() && { LDKBolt11InvoiceSignature res = self; memset(&self, 0, sizeof(LDKBolt11InvoiceSignature)); return res; }
5309         ~Bolt11InvoiceSignature() { Bolt11InvoiceSignature_free(self); }
5310         Bolt11InvoiceSignature& operator=(Bolt11InvoiceSignature&& o) { Bolt11InvoiceSignature_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11InvoiceSignature)); return *this; }
5311         LDKBolt11InvoiceSignature* operator &() { return &self; }
5312         LDKBolt11InvoiceSignature* operator ->() { return &self; }
5313         const LDKBolt11InvoiceSignature* operator &() const { return &self; }
5314         const LDKBolt11InvoiceSignature* operator ->() const { return &self; }
5315 };
5316 class PrivateRoute {
5317 private:
5318         LDKPrivateRoute self;
5319 public:
5320         PrivateRoute(const PrivateRoute&) = delete;
5321         PrivateRoute(PrivateRoute&& o) : self(o.self) { memset(&o, 0, sizeof(PrivateRoute)); }
5322         PrivateRoute(LDKPrivateRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrivateRoute)); }
5323         operator LDKPrivateRoute() && { LDKPrivateRoute res = self; memset(&self, 0, sizeof(LDKPrivateRoute)); return res; }
5324         ~PrivateRoute() { PrivateRoute_free(self); }
5325         PrivateRoute& operator=(PrivateRoute&& o) { PrivateRoute_free(self); self = o.self; memset(&o, 0, sizeof(PrivateRoute)); return *this; }
5326         LDKPrivateRoute* operator &() { return &self; }
5327         LDKPrivateRoute* operator ->() { return &self; }
5328         const LDKPrivateRoute* operator &() const { return &self; }
5329         const LDKPrivateRoute* operator ->() const { return &self; }
5330 };
5331 class CreationError {
5332 private:
5333         LDKCreationError self;
5334 public:
5335         CreationError(const CreationError&) = delete;
5336         CreationError(CreationError&& o) : self(o.self) { memset(&o, 0, sizeof(CreationError)); }
5337         CreationError(LDKCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCreationError)); }
5338         operator LDKCreationError() && { LDKCreationError res = self; memset(&self, 0, sizeof(LDKCreationError)); return res; }
5339         CreationError& operator=(CreationError&& o) { self = o.self; memset(&o, 0, sizeof(CreationError)); return *this; }
5340         LDKCreationError* operator &() { return &self; }
5341         LDKCreationError* operator ->() { return &self; }
5342         const LDKCreationError* operator &() const { return &self; }
5343         const LDKCreationError* operator ->() const { return &self; }
5344 };
5345 class Bolt11SemanticError {
5346 private:
5347         LDKBolt11SemanticError self;
5348 public:
5349         Bolt11SemanticError(const Bolt11SemanticError&) = delete;
5350         Bolt11SemanticError(Bolt11SemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11SemanticError)); }
5351         Bolt11SemanticError(LDKBolt11SemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11SemanticError)); }
5352         operator LDKBolt11SemanticError() && { LDKBolt11SemanticError res = self; memset(&self, 0, sizeof(LDKBolt11SemanticError)); return res; }
5353         Bolt11SemanticError& operator=(Bolt11SemanticError&& o) { self = o.self; memset(&o, 0, sizeof(Bolt11SemanticError)); return *this; }
5354         LDKBolt11SemanticError* operator &() { return &self; }
5355         LDKBolt11SemanticError* operator ->() { return &self; }
5356         const LDKBolt11SemanticError* operator &() const { return &self; }
5357         const LDKBolt11SemanticError* operator ->() const { return &self; }
5358 };
5359 class SignOrCreationError {
5360 private:
5361         LDKSignOrCreationError self;
5362 public:
5363         SignOrCreationError(const SignOrCreationError&) = delete;
5364         SignOrCreationError(SignOrCreationError&& o) : self(o.self) { memset(&o, 0, sizeof(SignOrCreationError)); }
5365         SignOrCreationError(LDKSignOrCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignOrCreationError)); }
5366         operator LDKSignOrCreationError() && { LDKSignOrCreationError res = self; memset(&self, 0, sizeof(LDKSignOrCreationError)); return res; }
5367         ~SignOrCreationError() { SignOrCreationError_free(self); }
5368         SignOrCreationError& operator=(SignOrCreationError&& o) { SignOrCreationError_free(self); self = o.self; memset(&o, 0, sizeof(SignOrCreationError)); return *this; }
5369         LDKSignOrCreationError* operator &() { return &self; }
5370         LDKSignOrCreationError* operator ->() { return &self; }
5371         const LDKSignOrCreationError* operator &() const { return &self; }
5372         const LDKSignOrCreationError* operator ->() const { return &self; }
5373 };
5374 class OutPoint {
5375 private:
5376         LDKOutPoint self;
5377 public:
5378         OutPoint(const OutPoint&) = delete;
5379         OutPoint(OutPoint&& o) : self(o.self) { memset(&o, 0, sizeof(OutPoint)); }
5380         OutPoint(LDKOutPoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutPoint)); }
5381         operator LDKOutPoint() && { LDKOutPoint res = self; memset(&self, 0, sizeof(LDKOutPoint)); return res; }
5382         ~OutPoint() { OutPoint_free(self); }
5383         OutPoint& operator=(OutPoint&& o) { OutPoint_free(self); self = o.self; memset(&o, 0, sizeof(OutPoint)); return *this; }
5384         LDKOutPoint* operator &() { return &self; }
5385         LDKOutPoint* operator ->() { return &self; }
5386         const LDKOutPoint* operator &() const { return &self; }
5387         const LDKOutPoint* operator ->() const { return &self; }
5388 };
5389 class BigSize {
5390 private:
5391         LDKBigSize self;
5392 public:
5393         BigSize(const BigSize&) = delete;
5394         BigSize(BigSize&& o) : self(o.self) { memset(&o, 0, sizeof(BigSize)); }
5395         BigSize(LDKBigSize&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBigSize)); }
5396         operator LDKBigSize() && { LDKBigSize res = self; memset(&self, 0, sizeof(LDKBigSize)); return res; }
5397         ~BigSize() { BigSize_free(self); }
5398         BigSize& operator=(BigSize&& o) { BigSize_free(self); self = o.self; memset(&o, 0, sizeof(BigSize)); return *this; }
5399         LDKBigSize* operator &() { return &self; }
5400         LDKBigSize* operator ->() { return &self; }
5401         const LDKBigSize* operator &() const { return &self; }
5402         const LDKBigSize* operator ->() const { return &self; }
5403 };
5404 class Hostname {
5405 private:
5406         LDKHostname self;
5407 public:
5408         Hostname(const Hostname&) = delete;
5409         Hostname(Hostname&& o) : self(o.self) { memset(&o, 0, sizeof(Hostname)); }
5410         Hostname(LDKHostname&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHostname)); }
5411         operator LDKHostname() && { LDKHostname res = self; memset(&self, 0, sizeof(LDKHostname)); return res; }
5412         ~Hostname() { Hostname_free(self); }
5413         Hostname& operator=(Hostname&& o) { Hostname_free(self); self = o.self; memset(&o, 0, sizeof(Hostname)); return *this; }
5414         LDKHostname* operator &() { return &self; }
5415         LDKHostname* operator ->() { return &self; }
5416         const LDKHostname* operator &() const { return &self; }
5417         const LDKHostname* operator ->() const { return &self; }
5418 };
5419 class TransactionU16LenLimited {
5420 private:
5421         LDKTransactionU16LenLimited self;
5422 public:
5423         TransactionU16LenLimited(const TransactionU16LenLimited&) = delete;
5424         TransactionU16LenLimited(TransactionU16LenLimited&& o) : self(o.self) { memset(&o, 0, sizeof(TransactionU16LenLimited)); }
5425         TransactionU16LenLimited(LDKTransactionU16LenLimited&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTransactionU16LenLimited)); }
5426         operator LDKTransactionU16LenLimited() && { LDKTransactionU16LenLimited res = self; memset(&self, 0, sizeof(LDKTransactionU16LenLimited)); return res; }
5427         ~TransactionU16LenLimited() { TransactionU16LenLimited_free(self); }
5428         TransactionU16LenLimited& operator=(TransactionU16LenLimited&& o) { TransactionU16LenLimited_free(self); self = o.self; memset(&o, 0, sizeof(TransactionU16LenLimited)); return *this; }
5429         LDKTransactionU16LenLimited* operator &() { return &self; }
5430         LDKTransactionU16LenLimited* operator ->() { return &self; }
5431         const LDKTransactionU16LenLimited* operator &() const { return &self; }
5432         const LDKTransactionU16LenLimited* operator ->() const { return &self; }
5433 };
5434 class UntrustedString {
5435 private:
5436         LDKUntrustedString self;
5437 public:
5438         UntrustedString(const UntrustedString&) = delete;
5439         UntrustedString(UntrustedString&& o) : self(o.self) { memset(&o, 0, sizeof(UntrustedString)); }
5440         UntrustedString(LDKUntrustedString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUntrustedString)); }
5441         operator LDKUntrustedString() && { LDKUntrustedString res = self; memset(&self, 0, sizeof(LDKUntrustedString)); return res; }
5442         ~UntrustedString() { UntrustedString_free(self); }
5443         UntrustedString& operator=(UntrustedString&& o) { UntrustedString_free(self); self = o.self; memset(&o, 0, sizeof(UntrustedString)); return *this; }
5444         LDKUntrustedString* operator &() { return &self; }
5445         LDKUntrustedString* operator ->() { return &self; }
5446         const LDKUntrustedString* operator &() const { return &self; }
5447         const LDKUntrustedString* operator ->() const { return &self; }
5448 };
5449 class PrintableString {
5450 private:
5451         LDKPrintableString self;
5452 public:
5453         PrintableString(const PrintableString&) = delete;
5454         PrintableString(PrintableString&& o) : self(o.self) { memset(&o, 0, sizeof(PrintableString)); }
5455         PrintableString(LDKPrintableString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrintableString)); }
5456         operator LDKPrintableString() && { LDKPrintableString res = self; memset(&self, 0, sizeof(LDKPrintableString)); return res; }
5457         ~PrintableString() { PrintableString_free(self); }
5458         PrintableString& operator=(PrintableString&& o) { PrintableString_free(self); self = o.self; memset(&o, 0, sizeof(PrintableString)); return *this; }
5459         LDKPrintableString* operator &() { return &self; }
5460         LDKPrintableString* operator ->() { return &self; }
5461         const LDKPrintableString* operator &() const { return &self; }
5462         const LDKPrintableString* operator ->() const { return &self; }
5463 };
5464 class CustomMessageReader {
5465 private:
5466         LDKCustomMessageReader self;
5467 public:
5468         CustomMessageReader(const CustomMessageReader&) = delete;
5469         CustomMessageReader(CustomMessageReader&& o) : self(o.self) { memset(&o, 0, sizeof(CustomMessageReader)); }
5470         CustomMessageReader(LDKCustomMessageReader&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomMessageReader)); }
5471         operator LDKCustomMessageReader() && { LDKCustomMessageReader res = self; memset(&self, 0, sizeof(LDKCustomMessageReader)); return res; }
5472         ~CustomMessageReader() { CustomMessageReader_free(self); }
5473         CustomMessageReader& operator=(CustomMessageReader&& o) { CustomMessageReader_free(self); self = o.self; memset(&o, 0, sizeof(CustomMessageReader)); return *this; }
5474         LDKCustomMessageReader* operator &() { return &self; }
5475         LDKCustomMessageReader* operator ->() { return &self; }
5476         const LDKCustomMessageReader* operator &() const { return &self; }
5477         const LDKCustomMessageReader* operator ->() const { return &self; }
5478         /**
5479          *  Decodes a custom message to `CustomMessageType`. If the given message type is known to the
5480          *  implementation and the message could be decoded, must return `Ok(Some(message))`. If the
5481          *  message type is unknown to the implementation, must return `Ok(None)`. If a decoding error
5482          *  occur, must return `Err(DecodeError::X)` where `X` details the encountered error.
5483          */
5484         inline LDK::CResult_COption_TypeZDecodeErrorZ read(uint16_t message_type, struct LDKu8slice buffer);
5485 };
5486 class Type {
5487 private:
5488         LDKType self;
5489 public:
5490         Type(const Type&) = delete;
5491         Type(Type&& o) : self(o.self) { memset(&o, 0, sizeof(Type)); }
5492         Type(LDKType&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKType)); }
5493         operator LDKType() && { LDKType res = self; memset(&self, 0, sizeof(LDKType)); return res; }
5494         ~Type() { Type_free(self); }
5495         Type& operator=(Type&& o) { Type_free(self); self = o.self; memset(&o, 0, sizeof(Type)); return *this; }
5496         LDKType* operator &() { return &self; }
5497         LDKType* operator ->() { return &self; }
5498         const LDKType* operator &() const { return &self; }
5499         const LDKType* operator ->() const { return &self; }
5500         /**
5501          *  Returns the type identifying the message payload.
5502          */
5503         inline uint16_t type_id();
5504         /**
5505          * Return a human-readable "debug" string describing this object
5506          */
5507         inline LDK::Str debug_str();
5508 };
5509 class ForwardNode {
5510 private:
5511         LDKForwardNode self;
5512 public:
5513         ForwardNode(const ForwardNode&) = delete;
5514         ForwardNode(ForwardNode&& o) : self(o.self) { memset(&o, 0, sizeof(ForwardNode)); }
5515         ForwardNode(LDKForwardNode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKForwardNode)); }
5516         operator LDKForwardNode() && { LDKForwardNode res = self; memset(&self, 0, sizeof(LDKForwardNode)); return res; }
5517         ~ForwardNode() { ForwardNode_free(self); }
5518         ForwardNode& operator=(ForwardNode&& o) { ForwardNode_free(self); self = o.self; memset(&o, 0, sizeof(ForwardNode)); return *this; }
5519         LDKForwardNode* operator &() { return &self; }
5520         LDKForwardNode* operator ->() { return &self; }
5521         const LDKForwardNode* operator &() const { return &self; }
5522         const LDKForwardNode* operator ->() const { return &self; }
5523 };
5524 class ForwardTlvs {
5525 private:
5526         LDKForwardTlvs self;
5527 public:
5528         ForwardTlvs(const ForwardTlvs&) = delete;
5529         ForwardTlvs(ForwardTlvs&& o) : self(o.self) { memset(&o, 0, sizeof(ForwardTlvs)); }
5530         ForwardTlvs(LDKForwardTlvs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKForwardTlvs)); }
5531         operator LDKForwardTlvs() && { LDKForwardTlvs res = self; memset(&self, 0, sizeof(LDKForwardTlvs)); return res; }
5532         ~ForwardTlvs() { ForwardTlvs_free(self); }
5533         ForwardTlvs& operator=(ForwardTlvs&& o) { ForwardTlvs_free(self); self = o.self; memset(&o, 0, sizeof(ForwardTlvs)); return *this; }
5534         LDKForwardTlvs* operator &() { return &self; }
5535         LDKForwardTlvs* operator ->() { return &self; }
5536         const LDKForwardTlvs* operator &() const { return &self; }
5537         const LDKForwardTlvs* operator ->() const { return &self; }
5538 };
5539 class ReceiveTlvs {
5540 private:
5541         LDKReceiveTlvs self;
5542 public:
5543         ReceiveTlvs(const ReceiveTlvs&) = delete;
5544         ReceiveTlvs(ReceiveTlvs&& o) : self(o.self) { memset(&o, 0, sizeof(ReceiveTlvs)); }
5545         ReceiveTlvs(LDKReceiveTlvs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReceiveTlvs)); }
5546         operator LDKReceiveTlvs() && { LDKReceiveTlvs res = self; memset(&self, 0, sizeof(LDKReceiveTlvs)); return res; }
5547         ~ReceiveTlvs() { ReceiveTlvs_free(self); }
5548         ReceiveTlvs& operator=(ReceiveTlvs&& o) { ReceiveTlvs_free(self); self = o.self; memset(&o, 0, sizeof(ReceiveTlvs)); return *this; }
5549         LDKReceiveTlvs* operator &() { return &self; }
5550         LDKReceiveTlvs* operator ->() { return &self; }
5551         const LDKReceiveTlvs* operator &() const { return &self; }
5552         const LDKReceiveTlvs* operator ->() const { return &self; }
5553 };
5554 class PaymentRelay {
5555 private:
5556         LDKPaymentRelay self;
5557 public:
5558         PaymentRelay(const PaymentRelay&) = delete;
5559         PaymentRelay(PaymentRelay&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentRelay)); }
5560         PaymentRelay(LDKPaymentRelay&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentRelay)); }
5561         operator LDKPaymentRelay() && { LDKPaymentRelay res = self; memset(&self, 0, sizeof(LDKPaymentRelay)); return res; }
5562         ~PaymentRelay() { PaymentRelay_free(self); }
5563         PaymentRelay& operator=(PaymentRelay&& o) { PaymentRelay_free(self); self = o.self; memset(&o, 0, sizeof(PaymentRelay)); return *this; }
5564         LDKPaymentRelay* operator &() { return &self; }
5565         LDKPaymentRelay* operator ->() { return &self; }
5566         const LDKPaymentRelay* operator &() const { return &self; }
5567         const LDKPaymentRelay* operator ->() const { return &self; }
5568 };
5569 class PaymentConstraints {
5570 private:
5571         LDKPaymentConstraints self;
5572 public:
5573         PaymentConstraints(const PaymentConstraints&) = delete;
5574         PaymentConstraints(PaymentConstraints&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentConstraints)); }
5575         PaymentConstraints(LDKPaymentConstraints&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentConstraints)); }
5576         operator LDKPaymentConstraints() && { LDKPaymentConstraints res = self; memset(&self, 0, sizeof(LDKPaymentConstraints)); return res; }
5577         ~PaymentConstraints() { PaymentConstraints_free(self); }
5578         PaymentConstraints& operator=(PaymentConstraints&& o) { PaymentConstraints_free(self); self = o.self; memset(&o, 0, sizeof(PaymentConstraints)); return *this; }
5579         LDKPaymentConstraints* operator &() { return &self; }
5580         LDKPaymentConstraints* operator ->() { return &self; }
5581         const LDKPaymentConstraints* operator &() const { return &self; }
5582         const LDKPaymentConstraints* operator ->() const { return &self; }
5583 };
5584 class PaymentError {
5585 private:
5586         LDKPaymentError self;
5587 public:
5588         PaymentError(const PaymentError&) = delete;
5589         PaymentError(PaymentError&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentError)); }
5590         PaymentError(LDKPaymentError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentError)); }
5591         operator LDKPaymentError() && { LDKPaymentError res = self; memset(&self, 0, sizeof(LDKPaymentError)); return res; }
5592         ~PaymentError() { PaymentError_free(self); }
5593         PaymentError& operator=(PaymentError&& o) { PaymentError_free(self); self = o.self; memset(&o, 0, sizeof(PaymentError)); return *this; }
5594         LDKPaymentError* operator &() { return &self; }
5595         LDKPaymentError* operator ->() { return &self; }
5596         const LDKPaymentError* operator &() const { return &self; }
5597         const LDKPaymentError* operator ->() const { return &self; }
5598 };
5599 class ProbingError {
5600 private:
5601         LDKProbingError self;
5602 public:
5603         ProbingError(const ProbingError&) = delete;
5604         ProbingError(ProbingError&& o) : self(o.self) { memset(&o, 0, sizeof(ProbingError)); }
5605         ProbingError(LDKProbingError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbingError)); }
5606         operator LDKProbingError() && { LDKProbingError res = self; memset(&self, 0, sizeof(LDKProbingError)); return res; }
5607         ~ProbingError() { ProbingError_free(self); }
5608         ProbingError& operator=(ProbingError&& o) { ProbingError_free(self); self = o.self; memset(&o, 0, sizeof(ProbingError)); return *this; }
5609         LDKProbingError* operator &() { return &self; }
5610         LDKProbingError* operator ->() { return &self; }
5611         const LDKProbingError* operator &() const { return &self; }
5612         const LDKProbingError* operator ->() const { return &self; }
5613 };
5614 class UtxoLookupError {
5615 private:
5616         LDKUtxoLookupError self;
5617 public:
5618         UtxoLookupError(const UtxoLookupError&) = delete;
5619         UtxoLookupError(UtxoLookupError&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoLookupError)); }
5620         UtxoLookupError(LDKUtxoLookupError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoLookupError)); }
5621         operator LDKUtxoLookupError() && { LDKUtxoLookupError res = self; memset(&self, 0, sizeof(LDKUtxoLookupError)); return res; }
5622         UtxoLookupError& operator=(UtxoLookupError&& o) { self = o.self; memset(&o, 0, sizeof(UtxoLookupError)); return *this; }
5623         LDKUtxoLookupError* operator &() { return &self; }
5624         LDKUtxoLookupError* operator ->() { return &self; }
5625         const LDKUtxoLookupError* operator &() const { return &self; }
5626         const LDKUtxoLookupError* operator ->() const { return &self; }
5627 };
5628 class UtxoResult {
5629 private:
5630         LDKUtxoResult self;
5631 public:
5632         UtxoResult(const UtxoResult&) = delete;
5633         UtxoResult(UtxoResult&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoResult)); }
5634         UtxoResult(LDKUtxoResult&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoResult)); }
5635         operator LDKUtxoResult() && { LDKUtxoResult res = self; memset(&self, 0, sizeof(LDKUtxoResult)); return res; }
5636         ~UtxoResult() { UtxoResult_free(self); }
5637         UtxoResult& operator=(UtxoResult&& o) { UtxoResult_free(self); self = o.self; memset(&o, 0, sizeof(UtxoResult)); return *this; }
5638         LDKUtxoResult* operator &() { return &self; }
5639         LDKUtxoResult* operator ->() { return &self; }
5640         const LDKUtxoResult* operator &() const { return &self; }
5641         const LDKUtxoResult* operator ->() const { return &self; }
5642 };
5643 class UtxoLookup {
5644 private:
5645         LDKUtxoLookup self;
5646 public:
5647         UtxoLookup(const UtxoLookup&) = delete;
5648         UtxoLookup(UtxoLookup&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoLookup)); }
5649         UtxoLookup(LDKUtxoLookup&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoLookup)); }
5650         operator LDKUtxoLookup() && { LDKUtxoLookup res = self; memset(&self, 0, sizeof(LDKUtxoLookup)); return res; }
5651         ~UtxoLookup() { UtxoLookup_free(self); }
5652         UtxoLookup& operator=(UtxoLookup&& o) { UtxoLookup_free(self); self = o.self; memset(&o, 0, sizeof(UtxoLookup)); return *this; }
5653         LDKUtxoLookup* operator &() { return &self; }
5654         LDKUtxoLookup* operator ->() { return &self; }
5655         const LDKUtxoLookup* operator &() const { return &self; }
5656         const LDKUtxoLookup* operator ->() const { return &self; }
5657         /**
5658          *  Returns the transaction output of a funding transaction encoded by [`short_channel_id`].
5659          *  Returns an error if `genesis_hash` is for a different chain or if such a transaction output
5660          *  is unknown.
5661          *
5662          *  [`short_channel_id`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#definition-of-short_channel_id
5663          */
5664         inline LDK::UtxoResult get_utxo(const uint8_t (*genesis_hash)[32], uint64_t short_channel_id);
5665 };
5666 class UtxoFuture {
5667 private:
5668         LDKUtxoFuture self;
5669 public:
5670         UtxoFuture(const UtxoFuture&) = delete;
5671         UtxoFuture(UtxoFuture&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoFuture)); }
5672         UtxoFuture(LDKUtxoFuture&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoFuture)); }
5673         operator LDKUtxoFuture() && { LDKUtxoFuture res = self; memset(&self, 0, sizeof(LDKUtxoFuture)); return res; }
5674         ~UtxoFuture() { UtxoFuture_free(self); }
5675         UtxoFuture& operator=(UtxoFuture&& o) { UtxoFuture_free(self); self = o.self; memset(&o, 0, sizeof(UtxoFuture)); return *this; }
5676         LDKUtxoFuture* operator &() { return &self; }
5677         LDKUtxoFuture* operator ->() { return &self; }
5678         const LDKUtxoFuture* operator &() const { return &self; }
5679         const LDKUtxoFuture* operator ->() const { return &self; }
5680 };
5681 class OnionMessenger {
5682 private:
5683         LDKOnionMessenger self;
5684 public:
5685         OnionMessenger(const OnionMessenger&) = delete;
5686         OnionMessenger(OnionMessenger&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessenger)); }
5687         OnionMessenger(LDKOnionMessenger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessenger)); }
5688         operator LDKOnionMessenger() && { LDKOnionMessenger res = self; memset(&self, 0, sizeof(LDKOnionMessenger)); return res; }
5689         ~OnionMessenger() { OnionMessenger_free(self); }
5690         OnionMessenger& operator=(OnionMessenger&& o) { OnionMessenger_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessenger)); return *this; }
5691         LDKOnionMessenger* operator &() { return &self; }
5692         LDKOnionMessenger* operator ->() { return &self; }
5693         const LDKOnionMessenger* operator &() const { return &self; }
5694         const LDKOnionMessenger* operator ->() const { return &self; }
5695 };
5696 class MessageRouter {
5697 private:
5698         LDKMessageRouter self;
5699 public:
5700         MessageRouter(const MessageRouter&) = delete;
5701         MessageRouter(MessageRouter&& o) : self(o.self) { memset(&o, 0, sizeof(MessageRouter)); }
5702         MessageRouter(LDKMessageRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageRouter)); }
5703         operator LDKMessageRouter() && { LDKMessageRouter res = self; memset(&self, 0, sizeof(LDKMessageRouter)); return res; }
5704         ~MessageRouter() { MessageRouter_free(self); }
5705         MessageRouter& operator=(MessageRouter&& o) { MessageRouter_free(self); self = o.self; memset(&o, 0, sizeof(MessageRouter)); return *this; }
5706         LDKMessageRouter* operator &() { return &self; }
5707         LDKMessageRouter* operator ->() { return &self; }
5708         const LDKMessageRouter* operator &() const { return &self; }
5709         const LDKMessageRouter* operator ->() const { return &self; }
5710         /**
5711          *  Returns a route for sending an [`OnionMessage`] to the given [`Destination`].
5712          *
5713          *  [`OnionMessage`]: msgs::OnionMessage
5714          */
5715         inline LDK::CResult_OnionMessagePathNoneZ find_path(struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination);
5716 };
5717 class DefaultMessageRouter {
5718 private:
5719         LDKDefaultMessageRouter self;
5720 public:
5721         DefaultMessageRouter(const DefaultMessageRouter&) = delete;
5722         DefaultMessageRouter(DefaultMessageRouter&& o) : self(o.self) { memset(&o, 0, sizeof(DefaultMessageRouter)); }
5723         DefaultMessageRouter(LDKDefaultMessageRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDefaultMessageRouter)); }
5724         operator LDKDefaultMessageRouter() && { LDKDefaultMessageRouter res = self; memset(&self, 0, sizeof(LDKDefaultMessageRouter)); return res; }
5725         ~DefaultMessageRouter() { DefaultMessageRouter_free(self); }
5726         DefaultMessageRouter& operator=(DefaultMessageRouter&& o) { DefaultMessageRouter_free(self); self = o.self; memset(&o, 0, sizeof(DefaultMessageRouter)); return *this; }
5727         LDKDefaultMessageRouter* operator &() { return &self; }
5728         LDKDefaultMessageRouter* operator ->() { return &self; }
5729         const LDKDefaultMessageRouter* operator &() const { return &self; }
5730         const LDKDefaultMessageRouter* operator ->() const { return &self; }
5731 };
5732 class OnionMessagePath {
5733 private:
5734         LDKOnionMessagePath self;
5735 public:
5736         OnionMessagePath(const OnionMessagePath&) = delete;
5737         OnionMessagePath(OnionMessagePath&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessagePath)); }
5738         OnionMessagePath(LDKOnionMessagePath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessagePath)); }
5739         operator LDKOnionMessagePath() && { LDKOnionMessagePath res = self; memset(&self, 0, sizeof(LDKOnionMessagePath)); return res; }
5740         ~OnionMessagePath() { OnionMessagePath_free(self); }
5741         OnionMessagePath& operator=(OnionMessagePath&& o) { OnionMessagePath_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessagePath)); return *this; }
5742         LDKOnionMessagePath* operator &() { return &self; }
5743         LDKOnionMessagePath* operator ->() { return &self; }
5744         const LDKOnionMessagePath* operator &() const { return &self; }
5745         const LDKOnionMessagePath* operator ->() const { return &self; }
5746 };
5747 class Destination {
5748 private:
5749         LDKDestination self;
5750 public:
5751         Destination(const Destination&) = delete;
5752         Destination(Destination&& o) : self(o.self) { memset(&o, 0, sizeof(Destination)); }
5753         Destination(LDKDestination&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDestination)); }
5754         operator LDKDestination() && { LDKDestination res = self; memset(&self, 0, sizeof(LDKDestination)); return res; }
5755         ~Destination() { Destination_free(self); }
5756         Destination& operator=(Destination&& o) { Destination_free(self); self = o.self; memset(&o, 0, sizeof(Destination)); return *this; }
5757         LDKDestination* operator &() { return &self; }
5758         LDKDestination* operator ->() { return &self; }
5759         const LDKDestination* operator &() const { return &self; }
5760         const LDKDestination* operator ->() const { return &self; }
5761 };
5762 class SendError {
5763 private:
5764         LDKSendError self;
5765 public:
5766         SendError(const SendError&) = delete;
5767         SendError(SendError&& o) : self(o.self) { memset(&o, 0, sizeof(SendError)); }
5768         SendError(LDKSendError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSendError)); }
5769         operator LDKSendError() && { LDKSendError res = self; memset(&self, 0, sizeof(LDKSendError)); return res; }
5770         ~SendError() { SendError_free(self); }
5771         SendError& operator=(SendError&& o) { SendError_free(self); self = o.self; memset(&o, 0, sizeof(SendError)); return *this; }
5772         LDKSendError* operator &() { return &self; }
5773         LDKSendError* operator ->() { return &self; }
5774         const LDKSendError* operator &() const { return &self; }
5775         const LDKSendError* operator ->() const { return &self; }
5776 };
5777 class CustomOnionMessageHandler {
5778 private:
5779         LDKCustomOnionMessageHandler self;
5780 public:
5781         CustomOnionMessageHandler(const CustomOnionMessageHandler&) = delete;
5782         CustomOnionMessageHandler(CustomOnionMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(CustomOnionMessageHandler)); }
5783         CustomOnionMessageHandler(LDKCustomOnionMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomOnionMessageHandler)); }
5784         operator LDKCustomOnionMessageHandler() && { LDKCustomOnionMessageHandler res = self; memset(&self, 0, sizeof(LDKCustomOnionMessageHandler)); return res; }
5785         ~CustomOnionMessageHandler() { CustomOnionMessageHandler_free(self); }
5786         CustomOnionMessageHandler& operator=(CustomOnionMessageHandler&& o) { CustomOnionMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(CustomOnionMessageHandler)); return *this; }
5787         LDKCustomOnionMessageHandler* operator &() { return &self; }
5788         LDKCustomOnionMessageHandler* operator ->() { return &self; }
5789         const LDKCustomOnionMessageHandler* operator &() const { return &self; }
5790         const LDKCustomOnionMessageHandler* operator ->() const { return &self; }
5791         /**
5792          *  Called with the custom message that was received, returning a response to send, if any.
5793          */
5794         inline LDK::COption_CustomOnionMessageContentsZ handle_custom_message(struct LDKCustomOnionMessageContents msg);
5795         /**
5796          *  Read a custom message of type `message_type` from `buffer`, returning `Ok(None)` if the
5797          *  message type is unknown.
5798          */
5799         inline LDK::CResult_COption_CustomOnionMessageContentsZDecodeErrorZ read_custom_message(uint64_t message_type, struct LDKu8slice buffer);
5800 };
5801 class FilesystemStore {
5802 private:
5803         LDKFilesystemStore self;
5804 public:
5805         FilesystemStore(const FilesystemStore&) = delete;
5806         FilesystemStore(FilesystemStore&& o) : self(o.self) { memset(&o, 0, sizeof(FilesystemStore)); }
5807         FilesystemStore(LDKFilesystemStore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilesystemStore)); }
5808         operator LDKFilesystemStore() && { LDKFilesystemStore res = self; memset(&self, 0, sizeof(LDKFilesystemStore)); return res; }
5809         ~FilesystemStore() { FilesystemStore_free(self); }
5810         FilesystemStore& operator=(FilesystemStore&& o) { FilesystemStore_free(self); self = o.self; memset(&o, 0, sizeof(FilesystemStore)); return *this; }
5811         LDKFilesystemStore* operator &() { return &self; }
5812         LDKFilesystemStore* operator ->() { return &self; }
5813         const LDKFilesystemStore* operator &() const { return &self; }
5814         const LDKFilesystemStore* operator ->() const { return &self; }
5815 };
5816 class BlindedPath {
5817 private:
5818         LDKBlindedPath self;
5819 public:
5820         BlindedPath(const BlindedPath&) = delete;
5821         BlindedPath(BlindedPath&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPath)); }
5822         BlindedPath(LDKBlindedPath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPath)); }
5823         operator LDKBlindedPath() && { LDKBlindedPath res = self; memset(&self, 0, sizeof(LDKBlindedPath)); return res; }
5824         ~BlindedPath() { BlindedPath_free(self); }
5825         BlindedPath& operator=(BlindedPath&& o) { BlindedPath_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPath)); return *this; }
5826         LDKBlindedPath* operator &() { return &self; }
5827         LDKBlindedPath* operator ->() { return &self; }
5828         const LDKBlindedPath* operator &() const { return &self; }
5829         const LDKBlindedPath* operator ->() const { return &self; }
5830 };
5831 class BlindedHop {
5832 private:
5833         LDKBlindedHop self;
5834 public:
5835         BlindedHop(const BlindedHop&) = delete;
5836         BlindedHop(BlindedHop&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedHop)); }
5837         BlindedHop(LDKBlindedHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedHop)); }
5838         operator LDKBlindedHop() && { LDKBlindedHop res = self; memset(&self, 0, sizeof(LDKBlindedHop)); return res; }
5839         ~BlindedHop() { BlindedHop_free(self); }
5840         BlindedHop& operator=(BlindedHop&& o) { BlindedHop_free(self); self = o.self; memset(&o, 0, sizeof(BlindedHop)); return *this; }
5841         LDKBlindedHop* operator &() { return &self; }
5842         LDKBlindedHop* operator ->() { return &self; }
5843         const LDKBlindedHop* operator &() const { return &self; }
5844         const LDKBlindedHop* operator ->() const { return &self; }
5845 };
5846 class GraphSyncError {
5847 private:
5848         LDKGraphSyncError self;
5849 public:
5850         GraphSyncError(const GraphSyncError&) = delete;
5851         GraphSyncError(GraphSyncError&& o) : self(o.self) { memset(&o, 0, sizeof(GraphSyncError)); }
5852         GraphSyncError(LDKGraphSyncError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGraphSyncError)); }
5853         operator LDKGraphSyncError() && { LDKGraphSyncError res = self; memset(&self, 0, sizeof(LDKGraphSyncError)); return res; }
5854         ~GraphSyncError() { GraphSyncError_free(self); }
5855         GraphSyncError& operator=(GraphSyncError&& o) { GraphSyncError_free(self); self = o.self; memset(&o, 0, sizeof(GraphSyncError)); return *this; }
5856         LDKGraphSyncError* operator &() { return &self; }
5857         LDKGraphSyncError* operator ->() { return &self; }
5858         const LDKGraphSyncError* operator &() const { return &self; }
5859         const LDKGraphSyncError* operator ->() const { return &self; }
5860 };
5861 class InvoiceError {
5862 private:
5863         LDKInvoiceError self;
5864 public:
5865         InvoiceError(const InvoiceError&) = delete;
5866         InvoiceError(InvoiceError&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceError)); }
5867         InvoiceError(LDKInvoiceError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceError)); }
5868         operator LDKInvoiceError() && { LDKInvoiceError res = self; memset(&self, 0, sizeof(LDKInvoiceError)); return res; }
5869         ~InvoiceError() { InvoiceError_free(self); }
5870         InvoiceError& operator=(InvoiceError&& o) { InvoiceError_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceError)); return *this; }
5871         LDKInvoiceError* operator &() { return &self; }
5872         LDKInvoiceError* operator ->() { return &self; }
5873         const LDKInvoiceError* operator &() const { return &self; }
5874         const LDKInvoiceError* operator ->() const { return &self; }
5875 };
5876 class ErroneousField {
5877 private:
5878         LDKErroneousField self;
5879 public:
5880         ErroneousField(const ErroneousField&) = delete;
5881         ErroneousField(ErroneousField&& o) : self(o.self) { memset(&o, 0, sizeof(ErroneousField)); }
5882         ErroneousField(LDKErroneousField&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroneousField)); }
5883         operator LDKErroneousField() && { LDKErroneousField res = self; memset(&self, 0, sizeof(LDKErroneousField)); return res; }
5884         ~ErroneousField() { ErroneousField_free(self); }
5885         ErroneousField& operator=(ErroneousField&& o) { ErroneousField_free(self); self = o.self; memset(&o, 0, sizeof(ErroneousField)); return *this; }
5886         LDKErroneousField* operator &() { return &self; }
5887         LDKErroneousField* operator ->() { return &self; }
5888         const LDKErroneousField* operator &() const { return &self; }
5889         const LDKErroneousField* operator ->() const { return &self; }
5890 };
5891 class MonitorUpdateId {
5892 private:
5893         LDKMonitorUpdateId self;
5894 public:
5895         MonitorUpdateId(const MonitorUpdateId&) = delete;
5896         MonitorUpdateId(MonitorUpdateId&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdateId)); }
5897         MonitorUpdateId(LDKMonitorUpdateId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdateId)); }
5898         operator LDKMonitorUpdateId() && { LDKMonitorUpdateId res = self; memset(&self, 0, sizeof(LDKMonitorUpdateId)); return res; }
5899         ~MonitorUpdateId() { MonitorUpdateId_free(self); }
5900         MonitorUpdateId& operator=(MonitorUpdateId&& o) { MonitorUpdateId_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdateId)); return *this; }
5901         LDKMonitorUpdateId* operator &() { return &self; }
5902         LDKMonitorUpdateId* operator ->() { return &self; }
5903         const LDKMonitorUpdateId* operator &() const { return &self; }
5904         const LDKMonitorUpdateId* operator ->() const { return &self; }
5905 };
5906 class Persist {
5907 private:
5908         LDKPersist self;
5909 public:
5910         Persist(const Persist&) = delete;
5911         Persist(Persist&& o) : self(o.self) { memset(&o, 0, sizeof(Persist)); }
5912         Persist(LDKPersist&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersist)); }
5913         operator LDKPersist() && { LDKPersist res = self; memset(&self, 0, sizeof(LDKPersist)); return res; }
5914         ~Persist() { Persist_free(self); }
5915         Persist& operator=(Persist&& o) { Persist_free(self); self = o.self; memset(&o, 0, sizeof(Persist)); return *this; }
5916         LDKPersist* operator &() { return &self; }
5917         LDKPersist* operator ->() { return &self; }
5918         const LDKPersist* operator &() const { return &self; }
5919         const LDKPersist* operator ->() const { return &self; }
5920         /**
5921          *  Persist a new channel's data in response to a [`chain::Watch::watch_channel`] call. This is
5922          *  called by [`ChannelManager`] for new channels, or may be called directly, e.g. on startup.
5923          *
5924          *  The data can be stored any way you want, but the identifier provided by LDK is the
5925          *  channel's outpoint (and it is up to you to maintain a correct mapping between the outpoint
5926          *  and the stored channel data). Note that you **must** persist every new monitor to disk.
5927          *
5928          *  The `update_id` is used to identify this call to [`ChainMonitor::channel_monitor_updated`],
5929          *  if you return [`ChannelMonitorUpdateStatus::InProgress`].
5930          *
5931          *  See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`
5932          *  and [`ChannelMonitorUpdateStatus`] for requirements when returning errors.
5933          *
5934          *  [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
5935          *  [`Writeable::write`]: crate::util::ser::Writeable::write
5936          */
5937         inline LDK::ChannelMonitorUpdateStatus persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
5938         /**
5939          *  Update one channel's data. The provided [`ChannelMonitor`] has already applied the given
5940          *  update.
5941          *
5942          *  Note that on every update, you **must** persist either the [`ChannelMonitorUpdate`] or the
5943          *  updated monitor itself to disk/backups. See the [`Persist`] trait documentation for more
5944          *  details.
5945          *
5946          *  During blockchain synchronization operations, and in some rare cases, this may be called with
5947          *  no [`ChannelMonitorUpdate`], in which case the full [`ChannelMonitor`] needs to be persisted.
5948          *  Note that after the full [`ChannelMonitor`] is persisted any previous
5949          *  [`ChannelMonitorUpdate`]s which were persisted should be discarded - they can no longer be
5950          *  applied to the persisted [`ChannelMonitor`] as they were already applied.
5951          *
5952          *  If an implementer chooses to persist the updates only, they need to make
5953          *  sure that all the updates are applied to the `ChannelMonitors` *before*
5954          *  the set of channel monitors is given to the `ChannelManager`
5955          *  deserialization routine. See [`ChannelMonitor::update_monitor`] for
5956          *  applying a monitor update to a monitor. If full `ChannelMonitors` are
5957          *  persisted, then there is no need to persist individual updates.
5958          *
5959          *  Note that there could be a performance tradeoff between persisting complete
5960          *  channel monitors on every update vs. persisting only updates and applying
5961          *  them in batches. The size of each monitor grows `O(number of state updates)`
5962          *  whereas updates are small and `O(1)`.
5963          *
5964          *  The `update_id` is used to identify this call to [`ChainMonitor::channel_monitor_updated`],
5965          *  if you return [`ChannelMonitorUpdateStatus::InProgress`].
5966          *
5967          *  See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`,
5968          *  [`Writeable::write`] on [`ChannelMonitorUpdate`] for writing out an update, and
5969          *  [`ChannelMonitorUpdateStatus`] for requirements when returning errors.
5970          *
5971          *  [`Writeable::write`]: crate::util::ser::Writeable::write
5972          *
5973          *  Note that update (or a relevant inner pointer) may be NULL or all-0s to represent None
5974          */
5975         inline LDK::ChannelMonitorUpdateStatus update_persisted_channel(struct LDKOutPoint channel_id, struct LDKChannelMonitorUpdate update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
5976 };
5977 class LockedChannelMonitor {
5978 private:
5979         LDKLockedChannelMonitor self;
5980 public:
5981         LockedChannelMonitor(const LockedChannelMonitor&) = delete;
5982         LockedChannelMonitor(LockedChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(LockedChannelMonitor)); }
5983         LockedChannelMonitor(LDKLockedChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockedChannelMonitor)); }
5984         operator LDKLockedChannelMonitor() && { LDKLockedChannelMonitor res = self; memset(&self, 0, sizeof(LDKLockedChannelMonitor)); return res; }
5985         ~LockedChannelMonitor() { LockedChannelMonitor_free(self); }
5986         LockedChannelMonitor& operator=(LockedChannelMonitor&& o) { LockedChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(LockedChannelMonitor)); return *this; }
5987         LDKLockedChannelMonitor* operator &() { return &self; }
5988         LDKLockedChannelMonitor* operator ->() { return &self; }
5989         const LDKLockedChannelMonitor* operator &() const { return &self; }
5990         const LDKLockedChannelMonitor* operator ->() const { return &self; }
5991 };
5992 class ChainMonitor {
5993 private:
5994         LDKChainMonitor self;
5995 public:
5996         ChainMonitor(const ChainMonitor&) = delete;
5997         ChainMonitor(ChainMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChainMonitor)); }
5998         ChainMonitor(LDKChainMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainMonitor)); }
5999         operator LDKChainMonitor() && { LDKChainMonitor res = self; memset(&self, 0, sizeof(LDKChainMonitor)); return res; }
6000         ~ChainMonitor() { ChainMonitor_free(self); }
6001         ChainMonitor& operator=(ChainMonitor&& o) { ChainMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChainMonitor)); return *this; }
6002         LDKChainMonitor* operator &() { return &self; }
6003         LDKChainMonitor* operator ->() { return &self; }
6004         const LDKChainMonitor* operator &() const { return &self; }
6005         const LDKChainMonitor* operator ->() const { return &self; }
6006 };
6007 class CResult_LockedChannelMonitorNoneZ {
6008 private:
6009         LDKCResult_LockedChannelMonitorNoneZ self;
6010 public:
6011         CResult_LockedChannelMonitorNoneZ(const CResult_LockedChannelMonitorNoneZ&) = delete;
6012         CResult_LockedChannelMonitorNoneZ(CResult_LockedChannelMonitorNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); }
6013         CResult_LockedChannelMonitorNoneZ(LDKCResult_LockedChannelMonitorNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); }
6014         operator LDKCResult_LockedChannelMonitorNoneZ() && { LDKCResult_LockedChannelMonitorNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); return res; }
6015         ~CResult_LockedChannelMonitorNoneZ() { CResult_LockedChannelMonitorNoneZ_free(self); }
6016         CResult_LockedChannelMonitorNoneZ& operator=(CResult_LockedChannelMonitorNoneZ&& o) { CResult_LockedChannelMonitorNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); return *this; }
6017         LDKCResult_LockedChannelMonitorNoneZ* operator &() { return &self; }
6018         LDKCResult_LockedChannelMonitorNoneZ* operator ->() { return &self; }
6019         const LDKCResult_LockedChannelMonitorNoneZ* operator &() const { return &self; }
6020         const LDKCResult_LockedChannelMonitorNoneZ* operator ->() const { return &self; }
6021 };
6022 class CResult_TransactionU16LenLimitedNoneZ {
6023 private:
6024         LDKCResult_TransactionU16LenLimitedNoneZ self;
6025 public:
6026         CResult_TransactionU16LenLimitedNoneZ(const CResult_TransactionU16LenLimitedNoneZ&) = delete;
6027         CResult_TransactionU16LenLimitedNoneZ(CResult_TransactionU16LenLimitedNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedNoneZ)); }
6028         CResult_TransactionU16LenLimitedNoneZ(LDKCResult_TransactionU16LenLimitedNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionU16LenLimitedNoneZ)); }
6029         operator LDKCResult_TransactionU16LenLimitedNoneZ() && { LDKCResult_TransactionU16LenLimitedNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionU16LenLimitedNoneZ)); return res; }
6030         ~CResult_TransactionU16LenLimitedNoneZ() { CResult_TransactionU16LenLimitedNoneZ_free(self); }
6031         CResult_TransactionU16LenLimitedNoneZ& operator=(CResult_TransactionU16LenLimitedNoneZ&& o) { CResult_TransactionU16LenLimitedNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedNoneZ)); return *this; }
6032         LDKCResult_TransactionU16LenLimitedNoneZ* operator &() { return &self; }
6033         LDKCResult_TransactionU16LenLimitedNoneZ* operator ->() { return &self; }
6034         const LDKCResult_TransactionU16LenLimitedNoneZ* operator &() const { return &self; }
6035         const LDKCResult_TransactionU16LenLimitedNoneZ* operator ->() const { return &self; }
6036 };
6037 class CVec_C2Tuple_BlindedPayInfoBlindedPathZZ {
6038 private:
6039         LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ self;
6040 public:
6041         CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(const CVec_C2Tuple_BlindedPayInfoBlindedPathZZ&) = delete;
6042         CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); }
6043         CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); }
6044         operator LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ() && { LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); return res; }
6045         ~CVec_C2Tuple_BlindedPayInfoBlindedPathZZ() { CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(self); }
6046         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; }
6047         LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator &() { return &self; }
6048         LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator ->() { return &self; }
6049         const LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator &() const { return &self; }
6050         const LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator ->() const { return &self; }
6051 };
6052 class CResult_PhantomRouteHintsDecodeErrorZ {
6053 private:
6054         LDKCResult_PhantomRouteHintsDecodeErrorZ self;
6055 public:
6056         CResult_PhantomRouteHintsDecodeErrorZ(const CResult_PhantomRouteHintsDecodeErrorZ&) = delete;
6057         CResult_PhantomRouteHintsDecodeErrorZ(CResult_PhantomRouteHintsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); }
6058         CResult_PhantomRouteHintsDecodeErrorZ(LDKCResult_PhantomRouteHintsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); }
6059         operator LDKCResult_PhantomRouteHintsDecodeErrorZ() && { LDKCResult_PhantomRouteHintsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); return res; }
6060         ~CResult_PhantomRouteHintsDecodeErrorZ() { CResult_PhantomRouteHintsDecodeErrorZ_free(self); }
6061         CResult_PhantomRouteHintsDecodeErrorZ& operator=(CResult_PhantomRouteHintsDecodeErrorZ&& o) { CResult_PhantomRouteHintsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); return *this; }
6062         LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() { return &self; }
6063         LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() { return &self; }
6064         const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() const { return &self; }
6065         const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() const { return &self; }
6066 };
6067 class CResult_FundingCreatedDecodeErrorZ {
6068 private:
6069         LDKCResult_FundingCreatedDecodeErrorZ self;
6070 public:
6071         CResult_FundingCreatedDecodeErrorZ(const CResult_FundingCreatedDecodeErrorZ&) = delete;
6072         CResult_FundingCreatedDecodeErrorZ(CResult_FundingCreatedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); }
6073         CResult_FundingCreatedDecodeErrorZ(LDKCResult_FundingCreatedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); }
6074         operator LDKCResult_FundingCreatedDecodeErrorZ() && { LDKCResult_FundingCreatedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); return res; }
6075         ~CResult_FundingCreatedDecodeErrorZ() { CResult_FundingCreatedDecodeErrorZ_free(self); }
6076         CResult_FundingCreatedDecodeErrorZ& operator=(CResult_FundingCreatedDecodeErrorZ&& o) { CResult_FundingCreatedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); return *this; }
6077         LDKCResult_FundingCreatedDecodeErrorZ* operator &() { return &self; }
6078         LDKCResult_FundingCreatedDecodeErrorZ* operator ->() { return &self; }
6079         const LDKCResult_FundingCreatedDecodeErrorZ* operator &() const { return &self; }
6080         const LDKCResult_FundingCreatedDecodeErrorZ* operator ->() const { return &self; }
6081 };
6082 class CVec_C2Tuple_u32TxOutZZ {
6083 private:
6084         LDKCVec_C2Tuple_u32TxOutZZ self;
6085 public:
6086         CVec_C2Tuple_u32TxOutZZ(const CVec_C2Tuple_u32TxOutZZ&) = delete;
6087         CVec_C2Tuple_u32TxOutZZ(CVec_C2Tuple_u32TxOutZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32TxOutZZ)); }
6088         CVec_C2Tuple_u32TxOutZZ(LDKCVec_C2Tuple_u32TxOutZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); }
6089         operator LDKCVec_C2Tuple_u32TxOutZZ() && { LDKCVec_C2Tuple_u32TxOutZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); return res; }
6090         ~CVec_C2Tuple_u32TxOutZZ() { CVec_C2Tuple_u32TxOutZZ_free(self); }
6091         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; }
6092         LDKCVec_C2Tuple_u32TxOutZZ* operator &() { return &self; }
6093         LDKCVec_C2Tuple_u32TxOutZZ* operator ->() { return &self; }
6094         const LDKCVec_C2Tuple_u32TxOutZZ* operator &() const { return &self; }
6095         const LDKCVec_C2Tuple_u32TxOutZZ* operator ->() const { return &self; }
6096 };
6097 class CResult_RetryDecodeErrorZ {
6098 private:
6099         LDKCResult_RetryDecodeErrorZ self;
6100 public:
6101         CResult_RetryDecodeErrorZ(const CResult_RetryDecodeErrorZ&) = delete;
6102         CResult_RetryDecodeErrorZ(CResult_RetryDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RetryDecodeErrorZ)); }
6103         CResult_RetryDecodeErrorZ(LDKCResult_RetryDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RetryDecodeErrorZ)); }
6104         operator LDKCResult_RetryDecodeErrorZ() && { LDKCResult_RetryDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RetryDecodeErrorZ)); return res; }
6105         ~CResult_RetryDecodeErrorZ() { CResult_RetryDecodeErrorZ_free(self); }
6106         CResult_RetryDecodeErrorZ& operator=(CResult_RetryDecodeErrorZ&& o) { CResult_RetryDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RetryDecodeErrorZ)); return *this; }
6107         LDKCResult_RetryDecodeErrorZ* operator &() { return &self; }
6108         LDKCResult_RetryDecodeErrorZ* operator ->() { return &self; }
6109         const LDKCResult_RetryDecodeErrorZ* operator &() const { return &self; }
6110         const LDKCResult_RetryDecodeErrorZ* operator ->() const { return &self; }
6111 };
6112 class CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ {
6113 private:
6114         LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ self;
6115 public:
6116         CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ(const CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ&) = delete;
6117         CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ(CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ)); }
6118         CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ)); }
6119         operator LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ() && { LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ)); return res; }
6120         ~CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ() { CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_free(self); }
6121         CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ& operator=(CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ&& o) { CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ)); return *this; }
6122         LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* operator &() { return &self; }
6123         LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* operator ->() { return &self; }
6124         const LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* operator &() const { return &self; }
6125         const LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* operator ->() const { return &self; }
6126 };
6127 class CResult_ChannelInfoDecodeErrorZ {
6128 private:
6129         LDKCResult_ChannelInfoDecodeErrorZ self;
6130 public:
6131         CResult_ChannelInfoDecodeErrorZ(const CResult_ChannelInfoDecodeErrorZ&) = delete;
6132         CResult_ChannelInfoDecodeErrorZ(CResult_ChannelInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); }
6133         CResult_ChannelInfoDecodeErrorZ(LDKCResult_ChannelInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); }
6134         operator LDKCResult_ChannelInfoDecodeErrorZ() && { LDKCResult_ChannelInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); return res; }
6135         ~CResult_ChannelInfoDecodeErrorZ() { CResult_ChannelInfoDecodeErrorZ_free(self); }
6136         CResult_ChannelInfoDecodeErrorZ& operator=(CResult_ChannelInfoDecodeErrorZ&& o) { CResult_ChannelInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); return *this; }
6137         LDKCResult_ChannelInfoDecodeErrorZ* operator &() { return &self; }
6138         LDKCResult_ChannelInfoDecodeErrorZ* operator ->() { return &self; }
6139         const LDKCResult_ChannelInfoDecodeErrorZ* operator &() const { return &self; }
6140         const LDKCResult_ChannelInfoDecodeErrorZ* operator ->() const { return &self; }
6141 };
6142 class COption_MaxDustHTLCExposureZ {
6143 private:
6144         LDKCOption_MaxDustHTLCExposureZ self;
6145 public:
6146         COption_MaxDustHTLCExposureZ(const COption_MaxDustHTLCExposureZ&) = delete;
6147         COption_MaxDustHTLCExposureZ(COption_MaxDustHTLCExposureZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MaxDustHTLCExposureZ)); }
6148         COption_MaxDustHTLCExposureZ(LDKCOption_MaxDustHTLCExposureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MaxDustHTLCExposureZ)); }
6149         operator LDKCOption_MaxDustHTLCExposureZ() && { LDKCOption_MaxDustHTLCExposureZ res = self; memset(&self, 0, sizeof(LDKCOption_MaxDustHTLCExposureZ)); return res; }
6150         ~COption_MaxDustHTLCExposureZ() { COption_MaxDustHTLCExposureZ_free(self); }
6151         COption_MaxDustHTLCExposureZ& operator=(COption_MaxDustHTLCExposureZ&& o) { COption_MaxDustHTLCExposureZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MaxDustHTLCExposureZ)); return *this; }
6152         LDKCOption_MaxDustHTLCExposureZ* operator &() { return &self; }
6153         LDKCOption_MaxDustHTLCExposureZ* operator ->() { return &self; }
6154         const LDKCOption_MaxDustHTLCExposureZ* operator &() const { return &self; }
6155         const LDKCOption_MaxDustHTLCExposureZ* operator ->() const { return &self; }
6156 };
6157 class CResult_NoneSendErrorZ {
6158 private:
6159         LDKCResult_NoneSendErrorZ self;
6160 public:
6161         CResult_NoneSendErrorZ(const CResult_NoneSendErrorZ&) = delete;
6162         CResult_NoneSendErrorZ(CResult_NoneSendErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneSendErrorZ)); }
6163         CResult_NoneSendErrorZ(LDKCResult_NoneSendErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneSendErrorZ)); }
6164         operator LDKCResult_NoneSendErrorZ() && { LDKCResult_NoneSendErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneSendErrorZ)); return res; }
6165         ~CResult_NoneSendErrorZ() { CResult_NoneSendErrorZ_free(self); }
6166         CResult_NoneSendErrorZ& operator=(CResult_NoneSendErrorZ&& o) { CResult_NoneSendErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneSendErrorZ)); return *this; }
6167         LDKCResult_NoneSendErrorZ* operator &() { return &self; }
6168         LDKCResult_NoneSendErrorZ* operator ->() { return &self; }
6169         const LDKCResult_NoneSendErrorZ* operator &() const { return &self; }
6170         const LDKCResult_NoneSendErrorZ* operator ->() const { return &self; }
6171 };
6172 class C2Tuple_CVec_u8ZusizeZ {
6173 private:
6174         LDKC2Tuple_CVec_u8ZusizeZ self;
6175 public:
6176         C2Tuple_CVec_u8ZusizeZ(const C2Tuple_CVec_u8ZusizeZ&) = delete;
6177         C2Tuple_CVec_u8ZusizeZ(C2Tuple_CVec_u8ZusizeZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_CVec_u8ZusizeZ)); }
6178         C2Tuple_CVec_u8ZusizeZ(LDKC2Tuple_CVec_u8ZusizeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_CVec_u8ZusizeZ)); }
6179         operator LDKC2Tuple_CVec_u8ZusizeZ() && { LDKC2Tuple_CVec_u8ZusizeZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_CVec_u8ZusizeZ)); return res; }
6180         ~C2Tuple_CVec_u8ZusizeZ() { C2Tuple_CVec_u8ZusizeZ_free(self); }
6181         C2Tuple_CVec_u8ZusizeZ& operator=(C2Tuple_CVec_u8ZusizeZ&& o) { C2Tuple_CVec_u8ZusizeZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_CVec_u8ZusizeZ)); return *this; }
6182         LDKC2Tuple_CVec_u8ZusizeZ* operator &() { return &self; }
6183         LDKC2Tuple_CVec_u8ZusizeZ* operator ->() { return &self; }
6184         const LDKC2Tuple_CVec_u8ZusizeZ* operator &() const { return &self; }
6185         const LDKC2Tuple_CVec_u8ZusizeZ* operator ->() const { return &self; }
6186 };
6187 class COption_OffersMessageZ {
6188 private:
6189         LDKCOption_OffersMessageZ self;
6190 public:
6191         COption_OffersMessageZ(const COption_OffersMessageZ&) = delete;
6192         COption_OffersMessageZ(COption_OffersMessageZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_OffersMessageZ)); }
6193         COption_OffersMessageZ(LDKCOption_OffersMessageZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_OffersMessageZ)); }
6194         operator LDKCOption_OffersMessageZ() && { LDKCOption_OffersMessageZ res = self; memset(&self, 0, sizeof(LDKCOption_OffersMessageZ)); return res; }
6195         ~COption_OffersMessageZ() { COption_OffersMessageZ_free(self); }
6196         COption_OffersMessageZ& operator=(COption_OffersMessageZ&& o) { COption_OffersMessageZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_OffersMessageZ)); return *this; }
6197         LDKCOption_OffersMessageZ* operator &() { return &self; }
6198         LDKCOption_OffersMessageZ* operator ->() { return &self; }
6199         const LDKCOption_OffersMessageZ* operator &() const { return &self; }
6200         const LDKCOption_OffersMessageZ* operator ->() const { return &self; }
6201 };
6202 class COption_NetworkUpdateZ {
6203 private:
6204         LDKCOption_NetworkUpdateZ self;
6205 public:
6206         COption_NetworkUpdateZ(const COption_NetworkUpdateZ&) = delete;
6207         COption_NetworkUpdateZ(COption_NetworkUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NetworkUpdateZ)); }
6208         COption_NetworkUpdateZ(LDKCOption_NetworkUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NetworkUpdateZ)); }
6209         operator LDKCOption_NetworkUpdateZ() && { LDKCOption_NetworkUpdateZ res = self; memset(&self, 0, sizeof(LDKCOption_NetworkUpdateZ)); return res; }
6210         ~COption_NetworkUpdateZ() { COption_NetworkUpdateZ_free(self); }
6211         COption_NetworkUpdateZ& operator=(COption_NetworkUpdateZ&& o) { COption_NetworkUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NetworkUpdateZ)); return *this; }
6212         LDKCOption_NetworkUpdateZ* operator &() { return &self; }
6213         LDKCOption_NetworkUpdateZ* operator ->() { return &self; }
6214         const LDKCOption_NetworkUpdateZ* operator &() const { return &self; }
6215         const LDKCOption_NetworkUpdateZ* operator ->() const { return &self; }
6216 };
6217 class COption_u64Z {
6218 private:
6219         LDKCOption_u64Z self;
6220 public:
6221         COption_u64Z(const COption_u64Z&) = delete;
6222         COption_u64Z(COption_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u64Z)); }
6223         COption_u64Z(LDKCOption_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u64Z)); }
6224         operator LDKCOption_u64Z() && { LDKCOption_u64Z res = self; memset(&self, 0, sizeof(LDKCOption_u64Z)); return res; }
6225         ~COption_u64Z() { COption_u64Z_free(self); }
6226         COption_u64Z& operator=(COption_u64Z&& o) { COption_u64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u64Z)); return *this; }
6227         LDKCOption_u64Z* operator &() { return &self; }
6228         LDKCOption_u64Z* operator ->() { return &self; }
6229         const LDKCOption_u64Z* operator &() const { return &self; }
6230         const LDKCOption_u64Z* operator ->() const { return &self; }
6231 };
6232 class CResult_CVec_u8ZPeerHandleErrorZ {
6233 private:
6234         LDKCResult_CVec_u8ZPeerHandleErrorZ self;
6235 public:
6236         CResult_CVec_u8ZPeerHandleErrorZ(const CResult_CVec_u8ZPeerHandleErrorZ&) = delete;
6237         CResult_CVec_u8ZPeerHandleErrorZ(CResult_CVec_u8ZPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); }
6238         CResult_CVec_u8ZPeerHandleErrorZ(LDKCResult_CVec_u8ZPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); }
6239         operator LDKCResult_CVec_u8ZPeerHandleErrorZ() && { LDKCResult_CVec_u8ZPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); return res; }
6240         ~CResult_CVec_u8ZPeerHandleErrorZ() { CResult_CVec_u8ZPeerHandleErrorZ_free(self); }
6241         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; }
6242         LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() { return &self; }
6243         LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() { return &self; }
6244         const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() const { return &self; }
6245         const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() const { return &self; }
6246 };
6247 class CResult_GossipTimestampFilterDecodeErrorZ {
6248 private:
6249         LDKCResult_GossipTimestampFilterDecodeErrorZ self;
6250 public:
6251         CResult_GossipTimestampFilterDecodeErrorZ(const CResult_GossipTimestampFilterDecodeErrorZ&) = delete;
6252         CResult_GossipTimestampFilterDecodeErrorZ(CResult_GossipTimestampFilterDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); }
6253         CResult_GossipTimestampFilterDecodeErrorZ(LDKCResult_GossipTimestampFilterDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); }
6254         operator LDKCResult_GossipTimestampFilterDecodeErrorZ() && { LDKCResult_GossipTimestampFilterDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); return res; }
6255         ~CResult_GossipTimestampFilterDecodeErrorZ() { CResult_GossipTimestampFilterDecodeErrorZ_free(self); }
6256         CResult_GossipTimestampFilterDecodeErrorZ& operator=(CResult_GossipTimestampFilterDecodeErrorZ&& o) { CResult_GossipTimestampFilterDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); return *this; }
6257         LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() { return &self; }
6258         LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() { return &self; }
6259         const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() const { return &self; }
6260         const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() const { return &self; }
6261 };
6262 class CResult_RouteHintDecodeErrorZ {
6263 private:
6264         LDKCResult_RouteHintDecodeErrorZ self;
6265 public:
6266         CResult_RouteHintDecodeErrorZ(const CResult_RouteHintDecodeErrorZ&) = delete;
6267         CResult_RouteHintDecodeErrorZ(CResult_RouteHintDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); }
6268         CResult_RouteHintDecodeErrorZ(LDKCResult_RouteHintDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); }
6269         operator LDKCResult_RouteHintDecodeErrorZ() && { LDKCResult_RouteHintDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); return res; }
6270         ~CResult_RouteHintDecodeErrorZ() { CResult_RouteHintDecodeErrorZ_free(self); }
6271         CResult_RouteHintDecodeErrorZ& operator=(CResult_RouteHintDecodeErrorZ&& o) { CResult_RouteHintDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); return *this; }
6272         LDKCResult_RouteHintDecodeErrorZ* operator &() { return &self; }
6273         LDKCResult_RouteHintDecodeErrorZ* operator ->() { return &self; }
6274         const LDKCResult_RouteHintDecodeErrorZ* operator &() const { return &self; }
6275         const LDKCResult_RouteHintDecodeErrorZ* operator ->() const { return &self; }
6276 };
6277 class COption_FilterZ {
6278 private:
6279         LDKCOption_FilterZ self;
6280 public:
6281         COption_FilterZ(const COption_FilterZ&) = delete;
6282         COption_FilterZ(COption_FilterZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_FilterZ)); }
6283         COption_FilterZ(LDKCOption_FilterZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_FilterZ)); }
6284         operator LDKCOption_FilterZ() && { LDKCOption_FilterZ res = self; memset(&self, 0, sizeof(LDKCOption_FilterZ)); return res; }
6285         ~COption_FilterZ() { COption_FilterZ_free(self); }
6286         COption_FilterZ& operator=(COption_FilterZ&& o) { COption_FilterZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_FilterZ)); return *this; }
6287         LDKCOption_FilterZ* operator &() { return &self; }
6288         LDKCOption_FilterZ* operator ->() { return &self; }
6289         const LDKCOption_FilterZ* operator &() const { return &self; }
6290         const LDKCOption_FilterZ* operator ->() const { return &self; }
6291 };
6292 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ {
6293 private:
6294         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ self;
6295 public:
6296         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ(const C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ&) = delete;
6297         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ)); }
6298         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)); }
6299         operator LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ() && { LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ)); return res; }
6300         ~C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ() { C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(self); }
6301         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; }
6302         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator &() { return &self; }
6303         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator ->() { return &self; }
6304         const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator &() const { return &self; }
6305         const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator ->() const { return &self; }
6306 };
6307 class COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
6308 private:
6309         LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ self;
6310 public:
6311         COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(const COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&) = delete;
6312         COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
6313         COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
6314         operator LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() && { LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ res = self; memset(&self, 0, sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return res; }
6315         ~COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() { COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); }
6316         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; }
6317         LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() { return &self; }
6318         LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() { return &self; }
6319         const LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() const { return &self; }
6320         const LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() const { return &self; }
6321 };
6322 class CResult_COption_APIErrorZDecodeErrorZ {
6323 private:
6324         LDKCResult_COption_APIErrorZDecodeErrorZ self;
6325 public:
6326         CResult_COption_APIErrorZDecodeErrorZ(const CResult_COption_APIErrorZDecodeErrorZ&) = delete;
6327         CResult_COption_APIErrorZDecodeErrorZ(CResult_COption_APIErrorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_APIErrorZDecodeErrorZ)); }
6328         CResult_COption_APIErrorZDecodeErrorZ(LDKCResult_COption_APIErrorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ)); }
6329         operator LDKCResult_COption_APIErrorZDecodeErrorZ() && { LDKCResult_COption_APIErrorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ)); return res; }
6330         ~CResult_COption_APIErrorZDecodeErrorZ() { CResult_COption_APIErrorZDecodeErrorZ_free(self); }
6331         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; }
6332         LDKCResult_COption_APIErrorZDecodeErrorZ* operator &() { return &self; }
6333         LDKCResult_COption_APIErrorZDecodeErrorZ* operator ->() { return &self; }
6334         const LDKCResult_COption_APIErrorZDecodeErrorZ* operator &() const { return &self; }
6335         const LDKCResult_COption_APIErrorZDecodeErrorZ* operator ->() const { return &self; }
6336 };
6337 class CVec_UpdateAddHTLCZ {
6338 private:
6339         LDKCVec_UpdateAddHTLCZ self;
6340 public:
6341         CVec_UpdateAddHTLCZ(const CVec_UpdateAddHTLCZ&) = delete;
6342         CVec_UpdateAddHTLCZ(CVec_UpdateAddHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); }
6343         CVec_UpdateAddHTLCZ(LDKCVec_UpdateAddHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); }
6344         operator LDKCVec_UpdateAddHTLCZ() && { LDKCVec_UpdateAddHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); return res; }
6345         ~CVec_UpdateAddHTLCZ() { CVec_UpdateAddHTLCZ_free(self); }
6346         CVec_UpdateAddHTLCZ& operator=(CVec_UpdateAddHTLCZ&& o) { CVec_UpdateAddHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); return *this; }
6347         LDKCVec_UpdateAddHTLCZ* operator &() { return &self; }
6348         LDKCVec_UpdateAddHTLCZ* operator ->() { return &self; }
6349         const LDKCVec_UpdateAddHTLCZ* operator &() const { return &self; }
6350         const LDKCVec_UpdateAddHTLCZ* operator ->() const { return &self; }
6351 };
6352 class CResult_TxAbortDecodeErrorZ {
6353 private:
6354         LDKCResult_TxAbortDecodeErrorZ self;
6355 public:
6356         CResult_TxAbortDecodeErrorZ(const CResult_TxAbortDecodeErrorZ&) = delete;
6357         CResult_TxAbortDecodeErrorZ(CResult_TxAbortDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAbortDecodeErrorZ)); }
6358         CResult_TxAbortDecodeErrorZ(LDKCResult_TxAbortDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAbortDecodeErrorZ)); }
6359         operator LDKCResult_TxAbortDecodeErrorZ() && { LDKCResult_TxAbortDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAbortDecodeErrorZ)); return res; }
6360         ~CResult_TxAbortDecodeErrorZ() { CResult_TxAbortDecodeErrorZ_free(self); }
6361         CResult_TxAbortDecodeErrorZ& operator=(CResult_TxAbortDecodeErrorZ&& o) { CResult_TxAbortDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAbortDecodeErrorZ)); return *this; }
6362         LDKCResult_TxAbortDecodeErrorZ* operator &() { return &self; }
6363         LDKCResult_TxAbortDecodeErrorZ* operator ->() { return &self; }
6364         const LDKCResult_TxAbortDecodeErrorZ* operator &() const { return &self; }
6365         const LDKCResult_TxAbortDecodeErrorZ* operator ->() const { return &self; }
6366 };
6367 class CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
6368 private:
6369         LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ self;
6370 public:
6371         CResult_StaticPaymentOutputDescriptorDecodeErrorZ(const CResult_StaticPaymentOutputDescriptorDecodeErrorZ&) = delete;
6372         CResult_StaticPaymentOutputDescriptorDecodeErrorZ(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
6373         CResult_StaticPaymentOutputDescriptorDecodeErrorZ(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
6374         operator LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return res; }
6375         ~CResult_StaticPaymentOutputDescriptorDecodeErrorZ() { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); }
6376         CResult_StaticPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return *this; }
6377         LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
6378         LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
6379         const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
6380         const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
6381 };
6382 class COption_u32Z {
6383 private:
6384         LDKCOption_u32Z self;
6385 public:
6386         COption_u32Z(const COption_u32Z&) = delete;
6387         COption_u32Z(COption_u32Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u32Z)); }
6388         COption_u32Z(LDKCOption_u32Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u32Z)); }
6389         operator LDKCOption_u32Z() && { LDKCOption_u32Z res = self; memset(&self, 0, sizeof(LDKCOption_u32Z)); return res; }
6390         ~COption_u32Z() { COption_u32Z_free(self); }
6391         COption_u32Z& operator=(COption_u32Z&& o) { COption_u32Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u32Z)); return *this; }
6392         LDKCOption_u32Z* operator &() { return &self; }
6393         LDKCOption_u32Z* operator ->() { return &self; }
6394         const LDKCOption_u32Z* operator &() const { return &self; }
6395         const LDKCOption_u32Z* operator ->() const { return &self; }
6396 };
6397 class CResult_RecipientOnionFieldsNoneZ {
6398 private:
6399         LDKCResult_RecipientOnionFieldsNoneZ self;
6400 public:
6401         CResult_RecipientOnionFieldsNoneZ(const CResult_RecipientOnionFieldsNoneZ&) = delete;
6402         CResult_RecipientOnionFieldsNoneZ(CResult_RecipientOnionFieldsNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecipientOnionFieldsNoneZ)); }
6403         CResult_RecipientOnionFieldsNoneZ(LDKCResult_RecipientOnionFieldsNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecipientOnionFieldsNoneZ)); }
6404         operator LDKCResult_RecipientOnionFieldsNoneZ() && { LDKCResult_RecipientOnionFieldsNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_RecipientOnionFieldsNoneZ)); return res; }
6405         ~CResult_RecipientOnionFieldsNoneZ() { CResult_RecipientOnionFieldsNoneZ_free(self); }
6406         CResult_RecipientOnionFieldsNoneZ& operator=(CResult_RecipientOnionFieldsNoneZ&& o) { CResult_RecipientOnionFieldsNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecipientOnionFieldsNoneZ)); return *this; }
6407         LDKCResult_RecipientOnionFieldsNoneZ* operator &() { return &self; }
6408         LDKCResult_RecipientOnionFieldsNoneZ* operator ->() { return &self; }
6409         const LDKCResult_RecipientOnionFieldsNoneZ* operator &() const { return &self; }
6410         const LDKCResult_RecipientOnionFieldsNoneZ* operator ->() const { return &self; }
6411 };
6412 class C2Tuple__u1632_u1632Z {
6413 private:
6414         LDKC2Tuple__u1632_u1632Z self;
6415 public:
6416         C2Tuple__u1632_u1632Z(const C2Tuple__u1632_u1632Z&) = delete;
6417         C2Tuple__u1632_u1632Z(C2Tuple__u1632_u1632Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple__u1632_u1632Z)); }
6418         C2Tuple__u1632_u1632Z(LDKC2Tuple__u1632_u1632Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple__u1632_u1632Z)); }
6419         operator LDKC2Tuple__u1632_u1632Z() && { LDKC2Tuple__u1632_u1632Z res = self; memset(&self, 0, sizeof(LDKC2Tuple__u1632_u1632Z)); return res; }
6420         ~C2Tuple__u1632_u1632Z() { C2Tuple__u1632_u1632Z_free(self); }
6421         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; }
6422         LDKC2Tuple__u1632_u1632Z* operator &() { return &self; }
6423         LDKC2Tuple__u1632_u1632Z* operator ->() { return &self; }
6424         const LDKC2Tuple__u1632_u1632Z* operator &() const { return &self; }
6425         const LDKC2Tuple__u1632_u1632Z* operator ->() const { return &self; }
6426 };
6427 class CResult_CVec_StrZIOErrorZ {
6428 private:
6429         LDKCResult_CVec_StrZIOErrorZ self;
6430 public:
6431         CResult_CVec_StrZIOErrorZ(const CResult_CVec_StrZIOErrorZ&) = delete;
6432         CResult_CVec_StrZIOErrorZ(CResult_CVec_StrZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_StrZIOErrorZ)); }
6433         CResult_CVec_StrZIOErrorZ(LDKCResult_CVec_StrZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_StrZIOErrorZ)); }
6434         operator LDKCResult_CVec_StrZIOErrorZ() && { LDKCResult_CVec_StrZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_StrZIOErrorZ)); return res; }
6435         ~CResult_CVec_StrZIOErrorZ() { CResult_CVec_StrZIOErrorZ_free(self); }
6436         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; }
6437         LDKCResult_CVec_StrZIOErrorZ* operator &() { return &self; }
6438         LDKCResult_CVec_StrZIOErrorZ* operator ->() { return &self; }
6439         const LDKCResult_CVec_StrZIOErrorZ* operator &() const { return &self; }
6440         const LDKCResult_CVec_StrZIOErrorZ* operator ->() const { return &self; }
6441 };
6442 class CResult_ClosingSignedFeeRangeDecodeErrorZ {
6443 private:
6444         LDKCResult_ClosingSignedFeeRangeDecodeErrorZ self;
6445 public:
6446         CResult_ClosingSignedFeeRangeDecodeErrorZ(const CResult_ClosingSignedFeeRangeDecodeErrorZ&) = delete;
6447         CResult_ClosingSignedFeeRangeDecodeErrorZ(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); }
6448         CResult_ClosingSignedFeeRangeDecodeErrorZ(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); }
6449         operator LDKCResult_ClosingSignedFeeRangeDecodeErrorZ() && { LDKCResult_ClosingSignedFeeRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); return res; }
6450         ~CResult_ClosingSignedFeeRangeDecodeErrorZ() { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); }
6451         CResult_ClosingSignedFeeRangeDecodeErrorZ& operator=(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); return *this; }
6452         LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() { return &self; }
6453         LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() { return &self; }
6454         const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() const { return &self; }
6455         const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() const { return &self; }
6456 };
6457 class CResult_TransactionNoneZ {
6458 private:
6459         LDKCResult_TransactionNoneZ self;
6460 public:
6461         CResult_TransactionNoneZ(const CResult_TransactionNoneZ&) = delete;
6462         CResult_TransactionNoneZ(CResult_TransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionNoneZ)); }
6463         CResult_TransactionNoneZ(LDKCResult_TransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionNoneZ)); }
6464         operator LDKCResult_TransactionNoneZ() && { LDKCResult_TransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionNoneZ)); return res; }
6465         ~CResult_TransactionNoneZ() { CResult_TransactionNoneZ_free(self); }
6466         CResult_TransactionNoneZ& operator=(CResult_TransactionNoneZ&& o) { CResult_TransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionNoneZ)); return *this; }
6467         LDKCResult_TransactionNoneZ* operator &() { return &self; }
6468         LDKCResult_TransactionNoneZ* operator ->() { return &self; }
6469         const LDKCResult_TransactionNoneZ* operator &() const { return &self; }
6470         const LDKCResult_TransactionNoneZ* operator ->() const { return &self; }
6471 };
6472 class CResult_CommitmentSignedDecodeErrorZ {
6473 private:
6474         LDKCResult_CommitmentSignedDecodeErrorZ self;
6475 public:
6476         CResult_CommitmentSignedDecodeErrorZ(const CResult_CommitmentSignedDecodeErrorZ&) = delete;
6477         CResult_CommitmentSignedDecodeErrorZ(CResult_CommitmentSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); }
6478         CResult_CommitmentSignedDecodeErrorZ(LDKCResult_CommitmentSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); }
6479         operator LDKCResult_CommitmentSignedDecodeErrorZ() && { LDKCResult_CommitmentSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); return res; }
6480         ~CResult_CommitmentSignedDecodeErrorZ() { CResult_CommitmentSignedDecodeErrorZ_free(self); }
6481         CResult_CommitmentSignedDecodeErrorZ& operator=(CResult_CommitmentSignedDecodeErrorZ&& o) { CResult_CommitmentSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); return *this; }
6482         LDKCResult_CommitmentSignedDecodeErrorZ* operator &() { return &self; }
6483         LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() { return &self; }
6484         const LDKCResult_CommitmentSignedDecodeErrorZ* operator &() const { return &self; }
6485         const LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() const { return &self; }
6486 };
6487 class CResult_CommitmentTransactionDecodeErrorZ {
6488 private:
6489         LDKCResult_CommitmentTransactionDecodeErrorZ self;
6490 public:
6491         CResult_CommitmentTransactionDecodeErrorZ(const CResult_CommitmentTransactionDecodeErrorZ&) = delete;
6492         CResult_CommitmentTransactionDecodeErrorZ(CResult_CommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); }
6493         CResult_CommitmentTransactionDecodeErrorZ(LDKCResult_CommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); }
6494         operator LDKCResult_CommitmentTransactionDecodeErrorZ() && { LDKCResult_CommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); return res; }
6495         ~CResult_CommitmentTransactionDecodeErrorZ() { CResult_CommitmentTransactionDecodeErrorZ_free(self); }
6496         CResult_CommitmentTransactionDecodeErrorZ& operator=(CResult_CommitmentTransactionDecodeErrorZ&& o) { CResult_CommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); return *this; }
6497         LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() { return &self; }
6498         LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
6499         const LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
6500         const LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
6501 };
6502 class CResult_ErrorMessageDecodeErrorZ {
6503 private:
6504         LDKCResult_ErrorMessageDecodeErrorZ self;
6505 public:
6506         CResult_ErrorMessageDecodeErrorZ(const CResult_ErrorMessageDecodeErrorZ&) = delete;
6507         CResult_ErrorMessageDecodeErrorZ(CResult_ErrorMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); }
6508         CResult_ErrorMessageDecodeErrorZ(LDKCResult_ErrorMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); }
6509         operator LDKCResult_ErrorMessageDecodeErrorZ() && { LDKCResult_ErrorMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); return res; }
6510         ~CResult_ErrorMessageDecodeErrorZ() { CResult_ErrorMessageDecodeErrorZ_free(self); }
6511         CResult_ErrorMessageDecodeErrorZ& operator=(CResult_ErrorMessageDecodeErrorZ&& o) { CResult_ErrorMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); return *this; }
6512         LDKCResult_ErrorMessageDecodeErrorZ* operator &() { return &self; }
6513         LDKCResult_ErrorMessageDecodeErrorZ* operator ->() { return &self; }
6514         const LDKCResult_ErrorMessageDecodeErrorZ* operator &() const { return &self; }
6515         const LDKCResult_ErrorMessageDecodeErrorZ* operator ->() const { return &self; }
6516 };
6517 class CResult_OpenChannelDecodeErrorZ {
6518 private:
6519         LDKCResult_OpenChannelDecodeErrorZ self;
6520 public:
6521         CResult_OpenChannelDecodeErrorZ(const CResult_OpenChannelDecodeErrorZ&) = delete;
6522         CResult_OpenChannelDecodeErrorZ(CResult_OpenChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); }
6523         CResult_OpenChannelDecodeErrorZ(LDKCResult_OpenChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); }
6524         operator LDKCResult_OpenChannelDecodeErrorZ() && { LDKCResult_OpenChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); return res; }
6525         ~CResult_OpenChannelDecodeErrorZ() { CResult_OpenChannelDecodeErrorZ_free(self); }
6526         CResult_OpenChannelDecodeErrorZ& operator=(CResult_OpenChannelDecodeErrorZ&& o) { CResult_OpenChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); return *this; }
6527         LDKCResult_OpenChannelDecodeErrorZ* operator &() { return &self; }
6528         LDKCResult_OpenChannelDecodeErrorZ* operator ->() { return &self; }
6529         const LDKCResult_OpenChannelDecodeErrorZ* operator &() const { return &self; }
6530         const LDKCResult_OpenChannelDecodeErrorZ* operator ->() const { return &self; }
6531 };
6532 class COption_APIErrorZ {
6533 private:
6534         LDKCOption_APIErrorZ self;
6535 public:
6536         COption_APIErrorZ(const COption_APIErrorZ&) = delete;
6537         COption_APIErrorZ(COption_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_APIErrorZ)); }
6538         COption_APIErrorZ(LDKCOption_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_APIErrorZ)); }
6539         operator LDKCOption_APIErrorZ() && { LDKCOption_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCOption_APIErrorZ)); return res; }
6540         ~COption_APIErrorZ() { COption_APIErrorZ_free(self); }
6541         COption_APIErrorZ& operator=(COption_APIErrorZ&& o) { COption_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_APIErrorZ)); return *this; }
6542         LDKCOption_APIErrorZ* operator &() { return &self; }
6543         LDKCOption_APIErrorZ* operator ->() { return &self; }
6544         const LDKCOption_APIErrorZ* operator &() const { return &self; }
6545         const LDKCOption_APIErrorZ* operator ->() const { return &self; }
6546 };
6547 class CResult_QueryChannelRangeDecodeErrorZ {
6548 private:
6549         LDKCResult_QueryChannelRangeDecodeErrorZ self;
6550 public:
6551         CResult_QueryChannelRangeDecodeErrorZ(const CResult_QueryChannelRangeDecodeErrorZ&) = delete;
6552         CResult_QueryChannelRangeDecodeErrorZ(CResult_QueryChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); }
6553         CResult_QueryChannelRangeDecodeErrorZ(LDKCResult_QueryChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); }
6554         operator LDKCResult_QueryChannelRangeDecodeErrorZ() && { LDKCResult_QueryChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); return res; }
6555         ~CResult_QueryChannelRangeDecodeErrorZ() { CResult_QueryChannelRangeDecodeErrorZ_free(self); }
6556         CResult_QueryChannelRangeDecodeErrorZ& operator=(CResult_QueryChannelRangeDecodeErrorZ&& o) { CResult_QueryChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); return *this; }
6557         LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() { return &self; }
6558         LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() { return &self; }
6559         const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
6560         const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
6561 };
6562 class CVec_TransactionZ {
6563 private:
6564         LDKCVec_TransactionZ self;
6565 public:
6566         CVec_TransactionZ(const CVec_TransactionZ&) = delete;
6567         CVec_TransactionZ(CVec_TransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionZ)); }
6568         CVec_TransactionZ(LDKCVec_TransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionZ)); }
6569         operator LDKCVec_TransactionZ() && { LDKCVec_TransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionZ)); return res; }
6570         ~CVec_TransactionZ() { CVec_TransactionZ_free(self); }
6571         CVec_TransactionZ& operator=(CVec_TransactionZ&& o) { CVec_TransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionZ)); return *this; }
6572         LDKCVec_TransactionZ* operator &() { return &self; }
6573         LDKCVec_TransactionZ* operator ->() { return &self; }
6574         const LDKCVec_TransactionZ* operator &() const { return &self; }
6575         const LDKCVec_TransactionZ* operator ->() const { return &self; }
6576 };
6577 class CVec_InputZ {
6578 private:
6579         LDKCVec_InputZ self;
6580 public:
6581         CVec_InputZ(const CVec_InputZ&) = delete;
6582         CVec_InputZ(CVec_InputZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_InputZ)); }
6583         CVec_InputZ(LDKCVec_InputZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_InputZ)); }
6584         operator LDKCVec_InputZ() && { LDKCVec_InputZ res = self; memset(&self, 0, sizeof(LDKCVec_InputZ)); return res; }
6585         ~CVec_InputZ() { CVec_InputZ_free(self); }
6586         CVec_InputZ& operator=(CVec_InputZ&& o) { CVec_InputZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_InputZ)); return *this; }
6587         LDKCVec_InputZ* operator &() { return &self; }
6588         LDKCVec_InputZ* operator ->() { return &self; }
6589         const LDKCVec_InputZ* operator &() const { return &self; }
6590         const LDKCVec_InputZ* operator ->() const { return &self; }
6591 };
6592 class CResult_ChannelFeaturesDecodeErrorZ {
6593 private:
6594         LDKCResult_ChannelFeaturesDecodeErrorZ self;
6595 public:
6596         CResult_ChannelFeaturesDecodeErrorZ(const CResult_ChannelFeaturesDecodeErrorZ&) = delete;
6597         CResult_ChannelFeaturesDecodeErrorZ(CResult_ChannelFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); }
6598         CResult_ChannelFeaturesDecodeErrorZ(LDKCResult_ChannelFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); }
6599         operator LDKCResult_ChannelFeaturesDecodeErrorZ() && { LDKCResult_ChannelFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); return res; }
6600         ~CResult_ChannelFeaturesDecodeErrorZ() { CResult_ChannelFeaturesDecodeErrorZ_free(self); }
6601         CResult_ChannelFeaturesDecodeErrorZ& operator=(CResult_ChannelFeaturesDecodeErrorZ&& o) { CResult_ChannelFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); return *this; }
6602         LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() { return &self; }
6603         LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() { return &self; }
6604         const LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() const { return &self; }
6605         const LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() const { return &self; }
6606 };
6607 class CResult_ChannelReadyDecodeErrorZ {
6608 private:
6609         LDKCResult_ChannelReadyDecodeErrorZ self;
6610 public:
6611         CResult_ChannelReadyDecodeErrorZ(const CResult_ChannelReadyDecodeErrorZ&) = delete;
6612         CResult_ChannelReadyDecodeErrorZ(CResult_ChannelReadyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelReadyDecodeErrorZ)); }
6613         CResult_ChannelReadyDecodeErrorZ(LDKCResult_ChannelReadyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelReadyDecodeErrorZ)); }
6614         operator LDKCResult_ChannelReadyDecodeErrorZ() && { LDKCResult_ChannelReadyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelReadyDecodeErrorZ)); return res; }
6615         ~CResult_ChannelReadyDecodeErrorZ() { CResult_ChannelReadyDecodeErrorZ_free(self); }
6616         CResult_ChannelReadyDecodeErrorZ& operator=(CResult_ChannelReadyDecodeErrorZ&& o) { CResult_ChannelReadyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelReadyDecodeErrorZ)); return *this; }
6617         LDKCResult_ChannelReadyDecodeErrorZ* operator &() { return &self; }
6618         LDKCResult_ChannelReadyDecodeErrorZ* operator ->() { return &self; }
6619         const LDKCResult_ChannelReadyDecodeErrorZ* operator &() const { return &self; }
6620         const LDKCResult_ChannelReadyDecodeErrorZ* operator ->() const { return &self; }
6621 };
6622 class CResult_UpdateFeeDecodeErrorZ {
6623 private:
6624         LDKCResult_UpdateFeeDecodeErrorZ self;
6625 public:
6626         CResult_UpdateFeeDecodeErrorZ(const CResult_UpdateFeeDecodeErrorZ&) = delete;
6627         CResult_UpdateFeeDecodeErrorZ(CResult_UpdateFeeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); }
6628         CResult_UpdateFeeDecodeErrorZ(LDKCResult_UpdateFeeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); }
6629         operator LDKCResult_UpdateFeeDecodeErrorZ() && { LDKCResult_UpdateFeeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); return res; }
6630         ~CResult_UpdateFeeDecodeErrorZ() { CResult_UpdateFeeDecodeErrorZ_free(self); }
6631         CResult_UpdateFeeDecodeErrorZ& operator=(CResult_UpdateFeeDecodeErrorZ&& o) { CResult_UpdateFeeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); return *this; }
6632         LDKCResult_UpdateFeeDecodeErrorZ* operator &() { return &self; }
6633         LDKCResult_UpdateFeeDecodeErrorZ* operator ->() { return &self; }
6634         const LDKCResult_UpdateFeeDecodeErrorZ* operator &() const { return &self; }
6635         const LDKCResult_UpdateFeeDecodeErrorZ* operator ->() const { return &self; }
6636 };
6637 class CResult_NoneBolt11SemanticErrorZ {
6638 private:
6639         LDKCResult_NoneBolt11SemanticErrorZ self;
6640 public:
6641         CResult_NoneBolt11SemanticErrorZ(const CResult_NoneBolt11SemanticErrorZ&) = delete;
6642         CResult_NoneBolt11SemanticErrorZ(CResult_NoneBolt11SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneBolt11SemanticErrorZ)); }
6643         CResult_NoneBolt11SemanticErrorZ(LDKCResult_NoneBolt11SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneBolt11SemanticErrorZ)); }
6644         operator LDKCResult_NoneBolt11SemanticErrorZ() && { LDKCResult_NoneBolt11SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneBolt11SemanticErrorZ)); return res; }
6645         ~CResult_NoneBolt11SemanticErrorZ() { CResult_NoneBolt11SemanticErrorZ_free(self); }
6646         CResult_NoneBolt11SemanticErrorZ& operator=(CResult_NoneBolt11SemanticErrorZ&& o) { CResult_NoneBolt11SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneBolt11SemanticErrorZ)); return *this; }
6647         LDKCResult_NoneBolt11SemanticErrorZ* operator &() { return &self; }
6648         LDKCResult_NoneBolt11SemanticErrorZ* operator ->() { return &self; }
6649         const LDKCResult_NoneBolt11SemanticErrorZ* operator &() const { return &self; }
6650         const LDKCResult_NoneBolt11SemanticErrorZ* operator ->() const { return &self; }
6651 };
6652 class CResult_NoneRetryableSendFailureZ {
6653 private:
6654         LDKCResult_NoneRetryableSendFailureZ self;
6655 public:
6656         CResult_NoneRetryableSendFailureZ(const CResult_NoneRetryableSendFailureZ&) = delete;
6657         CResult_NoneRetryableSendFailureZ(CResult_NoneRetryableSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneRetryableSendFailureZ)); }
6658         CResult_NoneRetryableSendFailureZ(LDKCResult_NoneRetryableSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneRetryableSendFailureZ)); }
6659         operator LDKCResult_NoneRetryableSendFailureZ() && { LDKCResult_NoneRetryableSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneRetryableSendFailureZ)); return res; }
6660         ~CResult_NoneRetryableSendFailureZ() { CResult_NoneRetryableSendFailureZ_free(self); }
6661         CResult_NoneRetryableSendFailureZ& operator=(CResult_NoneRetryableSendFailureZ&& o) { CResult_NoneRetryableSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneRetryableSendFailureZ)); return *this; }
6662         LDKCResult_NoneRetryableSendFailureZ* operator &() { return &self; }
6663         LDKCResult_NoneRetryableSendFailureZ* operator ->() { return &self; }
6664         const LDKCResult_NoneRetryableSendFailureZ* operator &() const { return &self; }
6665         const LDKCResult_NoneRetryableSendFailureZ* operator ->() const { return &self; }
6666 };
6667 class CResult_boolLightningErrorZ {
6668 private:
6669         LDKCResult_boolLightningErrorZ self;
6670 public:
6671         CResult_boolLightningErrorZ(const CResult_boolLightningErrorZ&) = delete;
6672         CResult_boolLightningErrorZ(CResult_boolLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); }
6673         CResult_boolLightningErrorZ(LDKCResult_boolLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolLightningErrorZ)); }
6674         operator LDKCResult_boolLightningErrorZ() && { LDKCResult_boolLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolLightningErrorZ)); return res; }
6675         ~CResult_boolLightningErrorZ() { CResult_boolLightningErrorZ_free(self); }
6676         CResult_boolLightningErrorZ& operator=(CResult_boolLightningErrorZ&& o) { CResult_boolLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); return *this; }
6677         LDKCResult_boolLightningErrorZ* operator &() { return &self; }
6678         LDKCResult_boolLightningErrorZ* operator ->() { return &self; }
6679         const LDKCResult_boolLightningErrorZ* operator &() const { return &self; }
6680         const LDKCResult_boolLightningErrorZ* operator ->() const { return &self; }
6681 };
6682 class CResult_NodeIdDecodeErrorZ {
6683 private:
6684         LDKCResult_NodeIdDecodeErrorZ self;
6685 public:
6686         CResult_NodeIdDecodeErrorZ(const CResult_NodeIdDecodeErrorZ&) = delete;
6687         CResult_NodeIdDecodeErrorZ(CResult_NodeIdDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); }
6688         CResult_NodeIdDecodeErrorZ(LDKCResult_NodeIdDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); }
6689         operator LDKCResult_NodeIdDecodeErrorZ() && { LDKCResult_NodeIdDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); return res; }
6690         ~CResult_NodeIdDecodeErrorZ() { CResult_NodeIdDecodeErrorZ_free(self); }
6691         CResult_NodeIdDecodeErrorZ& operator=(CResult_NodeIdDecodeErrorZ&& o) { CResult_NodeIdDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); return *this; }
6692         LDKCResult_NodeIdDecodeErrorZ* operator &() { return &self; }
6693         LDKCResult_NodeIdDecodeErrorZ* operator ->() { return &self; }
6694         const LDKCResult_NodeIdDecodeErrorZ* operator &() const { return &self; }
6695         const LDKCResult_NodeIdDecodeErrorZ* operator ->() const { return &self; }
6696 };
6697 class CResult_ChannelShutdownStateDecodeErrorZ {
6698 private:
6699         LDKCResult_ChannelShutdownStateDecodeErrorZ self;
6700 public:
6701         CResult_ChannelShutdownStateDecodeErrorZ(const CResult_ChannelShutdownStateDecodeErrorZ&) = delete;
6702         CResult_ChannelShutdownStateDecodeErrorZ(CResult_ChannelShutdownStateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelShutdownStateDecodeErrorZ)); }
6703         CResult_ChannelShutdownStateDecodeErrorZ(LDKCResult_ChannelShutdownStateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelShutdownStateDecodeErrorZ)); }
6704         operator LDKCResult_ChannelShutdownStateDecodeErrorZ() && { LDKCResult_ChannelShutdownStateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelShutdownStateDecodeErrorZ)); return res; }
6705         ~CResult_ChannelShutdownStateDecodeErrorZ() { CResult_ChannelShutdownStateDecodeErrorZ_free(self); }
6706         CResult_ChannelShutdownStateDecodeErrorZ& operator=(CResult_ChannelShutdownStateDecodeErrorZ&& o) { CResult_ChannelShutdownStateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelShutdownStateDecodeErrorZ)); return *this; }
6707         LDKCResult_ChannelShutdownStateDecodeErrorZ* operator &() { return &self; }
6708         LDKCResult_ChannelShutdownStateDecodeErrorZ* operator ->() { return &self; }
6709         const LDKCResult_ChannelShutdownStateDecodeErrorZ* operator &() const { return &self; }
6710         const LDKCResult_ChannelShutdownStateDecodeErrorZ* operator ->() const { return &self; }
6711 };
6712 class CResult_HTLCOutputInCommitmentDecodeErrorZ {
6713 private:
6714         LDKCResult_HTLCOutputInCommitmentDecodeErrorZ self;
6715 public:
6716         CResult_HTLCOutputInCommitmentDecodeErrorZ(const CResult_HTLCOutputInCommitmentDecodeErrorZ&) = delete;
6717         CResult_HTLCOutputInCommitmentDecodeErrorZ(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); }
6718         CResult_HTLCOutputInCommitmentDecodeErrorZ(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); }
6719         operator LDKCResult_HTLCOutputInCommitmentDecodeErrorZ() && { LDKCResult_HTLCOutputInCommitmentDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); return res; }
6720         ~CResult_HTLCOutputInCommitmentDecodeErrorZ() { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); }
6721         CResult_HTLCOutputInCommitmentDecodeErrorZ& operator=(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); return *this; }
6722         LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() { return &self; }
6723         LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() { return &self; }
6724         const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() const { return &self; }
6725         const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() const { return &self; }
6726 };
6727 class CResult_NodeAnnouncementInfoDecodeErrorZ {
6728 private:
6729         LDKCResult_NodeAnnouncementInfoDecodeErrorZ self;
6730 public:
6731         CResult_NodeAnnouncementInfoDecodeErrorZ(const CResult_NodeAnnouncementInfoDecodeErrorZ&) = delete;
6732         CResult_NodeAnnouncementInfoDecodeErrorZ(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); }
6733         CResult_NodeAnnouncementInfoDecodeErrorZ(LDKCResult_NodeAnnouncementInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); }
6734         operator LDKCResult_NodeAnnouncementInfoDecodeErrorZ() && { LDKCResult_NodeAnnouncementInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); return res; }
6735         ~CResult_NodeAnnouncementInfoDecodeErrorZ() { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); }
6736         CResult_NodeAnnouncementInfoDecodeErrorZ& operator=(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); return *this; }
6737         LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() { return &self; }
6738         LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() { return &self; }
6739         const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() const { return &self; }
6740         const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() const { return &self; }
6741 };
6742 class CResult_ShutdownScriptInvalidShutdownScriptZ {
6743 private:
6744         LDKCResult_ShutdownScriptInvalidShutdownScriptZ self;
6745 public:
6746         CResult_ShutdownScriptInvalidShutdownScriptZ(const CResult_ShutdownScriptInvalidShutdownScriptZ&) = delete;
6747         CResult_ShutdownScriptInvalidShutdownScriptZ(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); }
6748         CResult_ShutdownScriptInvalidShutdownScriptZ(LDKCResult_ShutdownScriptInvalidShutdownScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); }
6749         operator LDKCResult_ShutdownScriptInvalidShutdownScriptZ() && { LDKCResult_ShutdownScriptInvalidShutdownScriptZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); return res; }
6750         ~CResult_ShutdownScriptInvalidShutdownScriptZ() { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); }
6751         CResult_ShutdownScriptInvalidShutdownScriptZ& operator=(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); return *this; }
6752         LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() { return &self; }
6753         LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() { return &self; }
6754         const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() const { return &self; }
6755         const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() const { return &self; }
6756 };
6757 class CResult_COption_NetworkUpdateZDecodeErrorZ {
6758 private:
6759         LDKCResult_COption_NetworkUpdateZDecodeErrorZ self;
6760 public:
6761         CResult_COption_NetworkUpdateZDecodeErrorZ(const CResult_COption_NetworkUpdateZDecodeErrorZ&) = delete;
6762         CResult_COption_NetworkUpdateZDecodeErrorZ(CResult_COption_NetworkUpdateZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_NetworkUpdateZDecodeErrorZ)); }
6763         CResult_COption_NetworkUpdateZDecodeErrorZ(LDKCResult_COption_NetworkUpdateZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); }
6764         operator LDKCResult_COption_NetworkUpdateZDecodeErrorZ() && { LDKCResult_COption_NetworkUpdateZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); return res; }
6765         ~CResult_COption_NetworkUpdateZDecodeErrorZ() { CResult_COption_NetworkUpdateZDecodeErrorZ_free(self); }
6766         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; }
6767         LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() { return &self; }
6768         LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() { return &self; }
6769         const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() const { return &self; }
6770         const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() const { return &self; }
6771 };
6772 class CVec_UpdateFailMalformedHTLCZ {
6773 private:
6774         LDKCVec_UpdateFailMalformedHTLCZ self;
6775 public:
6776         CVec_UpdateFailMalformedHTLCZ(const CVec_UpdateFailMalformedHTLCZ&) = delete;
6777         CVec_UpdateFailMalformedHTLCZ(CVec_UpdateFailMalformedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); }
6778         CVec_UpdateFailMalformedHTLCZ(LDKCVec_UpdateFailMalformedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); }
6779         operator LDKCVec_UpdateFailMalformedHTLCZ() && { LDKCVec_UpdateFailMalformedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); return res; }
6780         ~CVec_UpdateFailMalformedHTLCZ() { CVec_UpdateFailMalformedHTLCZ_free(self); }
6781         CVec_UpdateFailMalformedHTLCZ& operator=(CVec_UpdateFailMalformedHTLCZ&& o) { CVec_UpdateFailMalformedHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); return *this; }
6782         LDKCVec_UpdateFailMalformedHTLCZ* operator &() { return &self; }
6783         LDKCVec_UpdateFailMalformedHTLCZ* operator ->() { return &self; }
6784         const LDKCVec_UpdateFailMalformedHTLCZ* operator &() const { return &self; }
6785         const LDKCVec_UpdateFailMalformedHTLCZ* operator ->() const { return &self; }
6786 };
6787 class CResult_ShutdownScriptNoneZ {
6788 private:
6789         LDKCResult_ShutdownScriptNoneZ self;
6790 public:
6791         CResult_ShutdownScriptNoneZ(const CResult_ShutdownScriptNoneZ&) = delete;
6792         CResult_ShutdownScriptNoneZ(CResult_ShutdownScriptNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptNoneZ)); }
6793         CResult_ShutdownScriptNoneZ(LDKCResult_ShutdownScriptNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptNoneZ)); }
6794         operator LDKCResult_ShutdownScriptNoneZ() && { LDKCResult_ShutdownScriptNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptNoneZ)); return res; }
6795         ~CResult_ShutdownScriptNoneZ() { CResult_ShutdownScriptNoneZ_free(self); }
6796         CResult_ShutdownScriptNoneZ& operator=(CResult_ShutdownScriptNoneZ&& o) { CResult_ShutdownScriptNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptNoneZ)); return *this; }
6797         LDKCResult_ShutdownScriptNoneZ* operator &() { return &self; }
6798         LDKCResult_ShutdownScriptNoneZ* operator ->() { return &self; }
6799         const LDKCResult_ShutdownScriptNoneZ* operator &() const { return &self; }
6800         const LDKCResult_ShutdownScriptNoneZ* operator ->() const { return &self; }
6801 };
6802 class COption_HTLCDestinationZ {
6803 private:
6804         LDKCOption_HTLCDestinationZ self;
6805 public:
6806         COption_HTLCDestinationZ(const COption_HTLCDestinationZ&) = delete;
6807         COption_HTLCDestinationZ(COption_HTLCDestinationZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_HTLCDestinationZ)); }
6808         COption_HTLCDestinationZ(LDKCOption_HTLCDestinationZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_HTLCDestinationZ)); }
6809         operator LDKCOption_HTLCDestinationZ() && { LDKCOption_HTLCDestinationZ res = self; memset(&self, 0, sizeof(LDKCOption_HTLCDestinationZ)); return res; }
6810         ~COption_HTLCDestinationZ() { COption_HTLCDestinationZ_free(self); }
6811         COption_HTLCDestinationZ& operator=(COption_HTLCDestinationZ&& o) { COption_HTLCDestinationZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_HTLCDestinationZ)); return *this; }
6812         LDKCOption_HTLCDestinationZ* operator &() { return &self; }
6813         LDKCOption_HTLCDestinationZ* operator ->() { return &self; }
6814         const LDKCOption_HTLCDestinationZ* operator &() const { return &self; }
6815         const LDKCOption_HTLCDestinationZ* operator ->() const { return &self; }
6816 };
6817 class CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ {
6818 private:
6819         LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ self;
6820 public:
6821         CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(const CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&) = delete;
6822         CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); }
6823         CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); }
6824         operator LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ() && { LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); return res; }
6825         ~CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ() { CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(self); }
6826         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; }
6827         LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator &() { return &self; }
6828         LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator ->() { return &self; }
6829         const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator &() const { return &self; }
6830         const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator ->() const { return &self; }
6831 };
6832 class CVec_RouteHopZ {
6833 private:
6834         LDKCVec_RouteHopZ self;
6835 public:
6836         CVec_RouteHopZ(const CVec_RouteHopZ&) = delete;
6837         CVec_RouteHopZ(CVec_RouteHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHopZ)); }
6838         CVec_RouteHopZ(LDKCVec_RouteHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHopZ)); }
6839         operator LDKCVec_RouteHopZ() && { LDKCVec_RouteHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHopZ)); return res; }
6840         ~CVec_RouteHopZ() { CVec_RouteHopZ_free(self); }
6841         CVec_RouteHopZ& operator=(CVec_RouteHopZ&& o) { CVec_RouteHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHopZ)); return *this; }
6842         LDKCVec_RouteHopZ* operator &() { return &self; }
6843         LDKCVec_RouteHopZ* operator ->() { return &self; }
6844         const LDKCVec_RouteHopZ* operator &() const { return &self; }
6845         const LDKCVec_RouteHopZ* operator ->() const { return &self; }
6846 };
6847 class CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ {
6848 private:
6849         LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ self;
6850 public:
6851         CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ(const CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&) = delete;
6852         CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ(CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); }
6853         CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ(LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); }
6854         operator LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ() && { LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); return res; }
6855         ~CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ() { CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(self); }
6856         CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ& operator=(CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&& o) { CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); return *this; }
6857         LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator &() { return &self; }
6858         LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator ->() { return &self; }
6859         const LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator &() const { return &self; }
6860         const LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator ->() const { return &self; }
6861 };
6862 class CResult_CVec_UtxoZNoneZ {
6863 private:
6864         LDKCResult_CVec_UtxoZNoneZ self;
6865 public:
6866         CResult_CVec_UtxoZNoneZ(const CResult_CVec_UtxoZNoneZ&) = delete;
6867         CResult_CVec_UtxoZNoneZ(CResult_CVec_UtxoZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_UtxoZNoneZ)); }
6868         CResult_CVec_UtxoZNoneZ(LDKCResult_CVec_UtxoZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_UtxoZNoneZ)); }
6869         operator LDKCResult_CVec_UtxoZNoneZ() && { LDKCResult_CVec_UtxoZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_UtxoZNoneZ)); return res; }
6870         ~CResult_CVec_UtxoZNoneZ() { CResult_CVec_UtxoZNoneZ_free(self); }
6871         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; }
6872         LDKCResult_CVec_UtxoZNoneZ* operator &() { return &self; }
6873         LDKCResult_CVec_UtxoZNoneZ* operator ->() { return &self; }
6874         const LDKCResult_CVec_UtxoZNoneZ* operator &() const { return &self; }
6875         const LDKCResult_CVec_UtxoZNoneZ* operator ->() const { return &self; }
6876 };
6877 class CResult_CVec_u8ZIOErrorZ {
6878 private:
6879         LDKCResult_CVec_u8ZIOErrorZ self;
6880 public:
6881         CResult_CVec_u8ZIOErrorZ(const CResult_CVec_u8ZIOErrorZ&) = delete;
6882         CResult_CVec_u8ZIOErrorZ(CResult_CVec_u8ZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZIOErrorZ)); }
6883         CResult_CVec_u8ZIOErrorZ(LDKCResult_CVec_u8ZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZIOErrorZ)); }
6884         operator LDKCResult_CVec_u8ZIOErrorZ() && { LDKCResult_CVec_u8ZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZIOErrorZ)); return res; }
6885         ~CResult_CVec_u8ZIOErrorZ() { CResult_CVec_u8ZIOErrorZ_free(self); }
6886         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; }
6887         LDKCResult_CVec_u8ZIOErrorZ* operator &() { return &self; }
6888         LDKCResult_CVec_u8ZIOErrorZ* operator ->() { return &self; }
6889         const LDKCResult_CVec_u8ZIOErrorZ* operator &() const { return &self; }
6890         const LDKCResult_CVec_u8ZIOErrorZ* operator ->() const { return &self; }
6891 };
6892 class COption_CustomOnionMessageContentsZ {
6893 private:
6894         LDKCOption_CustomOnionMessageContentsZ self;
6895 public:
6896         COption_CustomOnionMessageContentsZ(const COption_CustomOnionMessageContentsZ&) = delete;
6897         COption_CustomOnionMessageContentsZ(COption_CustomOnionMessageContentsZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CustomOnionMessageContentsZ)); }
6898         COption_CustomOnionMessageContentsZ(LDKCOption_CustomOnionMessageContentsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CustomOnionMessageContentsZ)); }
6899         operator LDKCOption_CustomOnionMessageContentsZ() && { LDKCOption_CustomOnionMessageContentsZ res = self; memset(&self, 0, sizeof(LDKCOption_CustomOnionMessageContentsZ)); return res; }
6900         ~COption_CustomOnionMessageContentsZ() { COption_CustomOnionMessageContentsZ_free(self); }
6901         COption_CustomOnionMessageContentsZ& operator=(COption_CustomOnionMessageContentsZ&& o) { COption_CustomOnionMessageContentsZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_CustomOnionMessageContentsZ)); return *this; }
6902         LDKCOption_CustomOnionMessageContentsZ* operator &() { return &self; }
6903         LDKCOption_CustomOnionMessageContentsZ* operator ->() { return &self; }
6904         const LDKCOption_CustomOnionMessageContentsZ* operator &() const { return &self; }
6905         const LDKCOption_CustomOnionMessageContentsZ* operator ->() const { return &self; }
6906 };
6907 class CVec_ThirtyTwoBytesZ {
6908 private:
6909         LDKCVec_ThirtyTwoBytesZ self;
6910 public:
6911         CVec_ThirtyTwoBytesZ(const CVec_ThirtyTwoBytesZ&) = delete;
6912         CVec_ThirtyTwoBytesZ(CVec_ThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); }
6913         CVec_ThirtyTwoBytesZ(LDKCVec_ThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); }
6914         operator LDKCVec_ThirtyTwoBytesZ() && { LDKCVec_ThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); return res; }
6915         ~CVec_ThirtyTwoBytesZ() { CVec_ThirtyTwoBytesZ_free(self); }
6916         CVec_ThirtyTwoBytesZ& operator=(CVec_ThirtyTwoBytesZ&& o) { CVec_ThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); return *this; }
6917         LDKCVec_ThirtyTwoBytesZ* operator &() { return &self; }
6918         LDKCVec_ThirtyTwoBytesZ* operator ->() { return &self; }
6919         const LDKCVec_ThirtyTwoBytesZ* operator &() const { return &self; }
6920         const LDKCVec_ThirtyTwoBytesZ* operator ->() const { return &self; }
6921 };
6922 class CResult_ChannelMonitorUpdateStatusNoneZ {
6923 private:
6924         LDKCResult_ChannelMonitorUpdateStatusNoneZ self;
6925 public:
6926         CResult_ChannelMonitorUpdateStatusNoneZ(const CResult_ChannelMonitorUpdateStatusNoneZ&) = delete;
6927         CResult_ChannelMonitorUpdateStatusNoneZ(CResult_ChannelMonitorUpdateStatusNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateStatusNoneZ)); }
6928         CResult_ChannelMonitorUpdateStatusNoneZ(LDKCResult_ChannelMonitorUpdateStatusNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateStatusNoneZ)); }
6929         operator LDKCResult_ChannelMonitorUpdateStatusNoneZ() && { LDKCResult_ChannelMonitorUpdateStatusNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateStatusNoneZ)); return res; }
6930         ~CResult_ChannelMonitorUpdateStatusNoneZ() { CResult_ChannelMonitorUpdateStatusNoneZ_free(self); }
6931         CResult_ChannelMonitorUpdateStatusNoneZ& operator=(CResult_ChannelMonitorUpdateStatusNoneZ&& o) { CResult_ChannelMonitorUpdateStatusNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateStatusNoneZ)); return *this; }
6932         LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator &() { return &self; }
6933         LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator ->() { return &self; }
6934         const LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator &() const { return &self; }
6935         const LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator ->() const { return &self; }
6936 };
6937 class CResult_ClosingSignedDecodeErrorZ {
6938 private:
6939         LDKCResult_ClosingSignedDecodeErrorZ self;
6940 public:
6941         CResult_ClosingSignedDecodeErrorZ(const CResult_ClosingSignedDecodeErrorZ&) = delete;
6942         CResult_ClosingSignedDecodeErrorZ(CResult_ClosingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); }
6943         CResult_ClosingSignedDecodeErrorZ(LDKCResult_ClosingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); }
6944         operator LDKCResult_ClosingSignedDecodeErrorZ() && { LDKCResult_ClosingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); return res; }
6945         ~CResult_ClosingSignedDecodeErrorZ() { CResult_ClosingSignedDecodeErrorZ_free(self); }
6946         CResult_ClosingSignedDecodeErrorZ& operator=(CResult_ClosingSignedDecodeErrorZ&& o) { CResult_ClosingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); return *this; }
6947         LDKCResult_ClosingSignedDecodeErrorZ* operator &() { return &self; }
6948         LDKCResult_ClosingSignedDecodeErrorZ* operator ->() { return &self; }
6949         const LDKCResult_ClosingSignedDecodeErrorZ* operator &() const { return &self; }
6950         const LDKCResult_ClosingSignedDecodeErrorZ* operator ->() const { return &self; }
6951 };
6952 class CResult_NonePaymentErrorZ {
6953 private:
6954         LDKCResult_NonePaymentErrorZ self;
6955 public:
6956         CResult_NonePaymentErrorZ(const CResult_NonePaymentErrorZ&) = delete;
6957         CResult_NonePaymentErrorZ(CResult_NonePaymentErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentErrorZ)); }
6958         CResult_NonePaymentErrorZ(LDKCResult_NonePaymentErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentErrorZ)); }
6959         operator LDKCResult_NonePaymentErrorZ() && { LDKCResult_NonePaymentErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentErrorZ)); return res; }
6960         ~CResult_NonePaymentErrorZ() { CResult_NonePaymentErrorZ_free(self); }
6961         CResult_NonePaymentErrorZ& operator=(CResult_NonePaymentErrorZ&& o) { CResult_NonePaymentErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentErrorZ)); return *this; }
6962         LDKCResult_NonePaymentErrorZ* operator &() { return &self; }
6963         LDKCResult_NonePaymentErrorZ* operator ->() { return &self; }
6964         const LDKCResult_NonePaymentErrorZ* operator &() const { return &self; }
6965         const LDKCResult_NonePaymentErrorZ* operator ->() const { return &self; }
6966 };
6967 class CVec_CResult_NoneAPIErrorZZ {
6968 private:
6969         LDKCVec_CResult_NoneAPIErrorZZ self;
6970 public:
6971         CVec_CResult_NoneAPIErrorZZ(const CVec_CResult_NoneAPIErrorZZ&) = delete;
6972         CVec_CResult_NoneAPIErrorZZ(CVec_CResult_NoneAPIErrorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CResult_NoneAPIErrorZZ)); }
6973         CVec_CResult_NoneAPIErrorZZ(LDKCVec_CResult_NoneAPIErrorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); }
6974         operator LDKCVec_CResult_NoneAPIErrorZZ() && { LDKCVec_CResult_NoneAPIErrorZZ res = self; memset(&self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); return res; }
6975         ~CVec_CResult_NoneAPIErrorZZ() { CVec_CResult_NoneAPIErrorZZ_free(self); }
6976         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; }
6977         LDKCVec_CResult_NoneAPIErrorZZ* operator &() { return &self; }
6978         LDKCVec_CResult_NoneAPIErrorZZ* operator ->() { return &self; }
6979         const LDKCVec_CResult_NoneAPIErrorZZ* operator &() const { return &self; }
6980         const LDKCVec_CResult_NoneAPIErrorZZ* operator ->() const { return &self; }
6981 };
6982 class CResult_SchnorrSignatureNoneZ {
6983 private:
6984         LDKCResult_SchnorrSignatureNoneZ self;
6985 public:
6986         CResult_SchnorrSignatureNoneZ(const CResult_SchnorrSignatureNoneZ&) = delete;
6987         CResult_SchnorrSignatureNoneZ(CResult_SchnorrSignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SchnorrSignatureNoneZ)); }
6988         CResult_SchnorrSignatureNoneZ(LDKCResult_SchnorrSignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SchnorrSignatureNoneZ)); }
6989         operator LDKCResult_SchnorrSignatureNoneZ() && { LDKCResult_SchnorrSignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SchnorrSignatureNoneZ)); return res; }
6990         ~CResult_SchnorrSignatureNoneZ() { CResult_SchnorrSignatureNoneZ_free(self); }
6991         CResult_SchnorrSignatureNoneZ& operator=(CResult_SchnorrSignatureNoneZ&& o) { CResult_SchnorrSignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SchnorrSignatureNoneZ)); return *this; }
6992         LDKCResult_SchnorrSignatureNoneZ* operator &() { return &self; }
6993         LDKCResult_SchnorrSignatureNoneZ* operator ->() { return &self; }
6994         const LDKCResult_SchnorrSignatureNoneZ* operator &() const { return &self; }
6995         const LDKCResult_SchnorrSignatureNoneZ* operator ->() const { return &self; }
6996 };
6997 class CResult_CounterpartyCommitmentSecretsDecodeErrorZ {
6998 private:
6999         LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ self;
7000 public:
7001         CResult_CounterpartyCommitmentSecretsDecodeErrorZ(const CResult_CounterpartyCommitmentSecretsDecodeErrorZ&) = delete;
7002         CResult_CounterpartyCommitmentSecretsDecodeErrorZ(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
7003         CResult_CounterpartyCommitmentSecretsDecodeErrorZ(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
7004         operator LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ() && { LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return res; }
7005         ~CResult_CounterpartyCommitmentSecretsDecodeErrorZ() { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); }
7006         CResult_CounterpartyCommitmentSecretsDecodeErrorZ& operator=(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return *this; }
7007         LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() { return &self; }
7008         LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() { return &self; }
7009         const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() const { return &self; }
7010         const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() const { return &self; }
7011 };
7012 class CResult_ReceiveTlvsDecodeErrorZ {
7013 private:
7014         LDKCResult_ReceiveTlvsDecodeErrorZ self;
7015 public:
7016         CResult_ReceiveTlvsDecodeErrorZ(const CResult_ReceiveTlvsDecodeErrorZ&) = delete;
7017         CResult_ReceiveTlvsDecodeErrorZ(CResult_ReceiveTlvsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReceiveTlvsDecodeErrorZ)); }
7018         CResult_ReceiveTlvsDecodeErrorZ(LDKCResult_ReceiveTlvsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReceiveTlvsDecodeErrorZ)); }
7019         operator LDKCResult_ReceiveTlvsDecodeErrorZ() && { LDKCResult_ReceiveTlvsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReceiveTlvsDecodeErrorZ)); return res; }
7020         ~CResult_ReceiveTlvsDecodeErrorZ() { CResult_ReceiveTlvsDecodeErrorZ_free(self); }
7021         CResult_ReceiveTlvsDecodeErrorZ& operator=(CResult_ReceiveTlvsDecodeErrorZ&& o) { CResult_ReceiveTlvsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReceiveTlvsDecodeErrorZ)); return *this; }
7022         LDKCResult_ReceiveTlvsDecodeErrorZ* operator &() { return &self; }
7023         LDKCResult_ReceiveTlvsDecodeErrorZ* operator ->() { return &self; }
7024         const LDKCResult_ReceiveTlvsDecodeErrorZ* operator &() const { return &self; }
7025         const LDKCResult_ReceiveTlvsDecodeErrorZ* operator ->() const { return &self; }
7026 };
7027 class CResult_HTLCDescriptorDecodeErrorZ {
7028 private:
7029         LDKCResult_HTLCDescriptorDecodeErrorZ self;
7030 public:
7031         CResult_HTLCDescriptorDecodeErrorZ(const CResult_HTLCDescriptorDecodeErrorZ&) = delete;
7032         CResult_HTLCDescriptorDecodeErrorZ(CResult_HTLCDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCDescriptorDecodeErrorZ)); }
7033         CResult_HTLCDescriptorDecodeErrorZ(LDKCResult_HTLCDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCDescriptorDecodeErrorZ)); }
7034         operator LDKCResult_HTLCDescriptorDecodeErrorZ() && { LDKCResult_HTLCDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCDescriptorDecodeErrorZ)); return res; }
7035         ~CResult_HTLCDescriptorDecodeErrorZ() { CResult_HTLCDescriptorDecodeErrorZ_free(self); }
7036         CResult_HTLCDescriptorDecodeErrorZ& operator=(CResult_HTLCDescriptorDecodeErrorZ&& o) { CResult_HTLCDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCDescriptorDecodeErrorZ)); return *this; }
7037         LDKCResult_HTLCDescriptorDecodeErrorZ* operator &() { return &self; }
7038         LDKCResult_HTLCDescriptorDecodeErrorZ* operator ->() { return &self; }
7039         const LDKCResult_HTLCDescriptorDecodeErrorZ* operator &() const { return &self; }
7040         const LDKCResult_HTLCDescriptorDecodeErrorZ* operator ->() const { return &self; }
7041 };
7042 class CVec_RecentPaymentDetailsZ {
7043 private:
7044         LDKCVec_RecentPaymentDetailsZ self;
7045 public:
7046         CVec_RecentPaymentDetailsZ(const CVec_RecentPaymentDetailsZ&) = delete;
7047         CVec_RecentPaymentDetailsZ(CVec_RecentPaymentDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RecentPaymentDetailsZ)); }
7048         CVec_RecentPaymentDetailsZ(LDKCVec_RecentPaymentDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RecentPaymentDetailsZ)); }
7049         operator LDKCVec_RecentPaymentDetailsZ() && { LDKCVec_RecentPaymentDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_RecentPaymentDetailsZ)); return res; }
7050         ~CVec_RecentPaymentDetailsZ() { CVec_RecentPaymentDetailsZ_free(self); }
7051         CVec_RecentPaymentDetailsZ& operator=(CVec_RecentPaymentDetailsZ&& o) { CVec_RecentPaymentDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RecentPaymentDetailsZ)); return *this; }
7052         LDKCVec_RecentPaymentDetailsZ* operator &() { return &self; }
7053         LDKCVec_RecentPaymentDetailsZ* operator ->() { return &self; }
7054         const LDKCVec_RecentPaymentDetailsZ* operator &() const { return &self; }
7055         const LDKCVec_RecentPaymentDetailsZ* operator ->() const { return &self; }
7056 };
7057 class CVec_RouteHintHopZ {
7058 private:
7059         LDKCVec_RouteHintHopZ self;
7060 public:
7061         CVec_RouteHintHopZ(const CVec_RouteHintHopZ&) = delete;
7062         CVec_RouteHintHopZ(CVec_RouteHintHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintHopZ)); }
7063         CVec_RouteHintHopZ(LDKCVec_RouteHintHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintHopZ)); }
7064         operator LDKCVec_RouteHintHopZ() && { LDKCVec_RouteHintHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintHopZ)); return res; }
7065         ~CVec_RouteHintHopZ() { CVec_RouteHintHopZ_free(self); }
7066         CVec_RouteHintHopZ& operator=(CVec_RouteHintHopZ&& o) { CVec_RouteHintHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintHopZ)); return *this; }
7067         LDKCVec_RouteHintHopZ* operator &() { return &self; }
7068         LDKCVec_RouteHintHopZ* operator ->() { return &self; }
7069         const LDKCVec_RouteHintHopZ* operator &() const { return &self; }
7070         const LDKCVec_RouteHintHopZ* operator ->() const { return &self; }
7071 };
7072 class CResult_UntrustedStringDecodeErrorZ {
7073 private:
7074         LDKCResult_UntrustedStringDecodeErrorZ self;
7075 public:
7076         CResult_UntrustedStringDecodeErrorZ(const CResult_UntrustedStringDecodeErrorZ&) = delete;
7077         CResult_UntrustedStringDecodeErrorZ(CResult_UntrustedStringDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UntrustedStringDecodeErrorZ)); }
7078         CResult_UntrustedStringDecodeErrorZ(LDKCResult_UntrustedStringDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UntrustedStringDecodeErrorZ)); }
7079         operator LDKCResult_UntrustedStringDecodeErrorZ() && { LDKCResult_UntrustedStringDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UntrustedStringDecodeErrorZ)); return res; }
7080         ~CResult_UntrustedStringDecodeErrorZ() { CResult_UntrustedStringDecodeErrorZ_free(self); }
7081         CResult_UntrustedStringDecodeErrorZ& operator=(CResult_UntrustedStringDecodeErrorZ&& o) { CResult_UntrustedStringDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UntrustedStringDecodeErrorZ)); return *this; }
7082         LDKCResult_UntrustedStringDecodeErrorZ* operator &() { return &self; }
7083         LDKCResult_UntrustedStringDecodeErrorZ* operator ->() { return &self; }
7084         const LDKCResult_UntrustedStringDecodeErrorZ* operator &() const { return &self; }
7085         const LDKCResult_UntrustedStringDecodeErrorZ* operator ->() const { return &self; }
7086 };
7087 class CVec_U5Z {
7088 private:
7089         LDKCVec_U5Z self;
7090 public:
7091         CVec_U5Z(const CVec_U5Z&) = delete;
7092         CVec_U5Z(CVec_U5Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_U5Z)); }
7093         CVec_U5Z(LDKCVec_U5Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_U5Z)); }
7094         operator LDKCVec_U5Z() && { LDKCVec_U5Z res = self; memset(&self, 0, sizeof(LDKCVec_U5Z)); return res; }
7095         ~CVec_U5Z() { CVec_U5Z_free(self); }
7096         CVec_U5Z& operator=(CVec_U5Z&& o) { CVec_U5Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_U5Z)); return *this; }
7097         LDKCVec_U5Z* operator &() { return &self; }
7098         LDKCVec_U5Z* operator ->() { return &self; }
7099         const LDKCVec_U5Z* operator &() const { return &self; }
7100         const LDKCVec_U5Z* operator ->() const { return &self; }
7101 };
7102 class CResult_PaymentParametersDecodeErrorZ {
7103 private:
7104         LDKCResult_PaymentParametersDecodeErrorZ self;
7105 public:
7106         CResult_PaymentParametersDecodeErrorZ(const CResult_PaymentParametersDecodeErrorZ&) = delete;
7107         CResult_PaymentParametersDecodeErrorZ(CResult_PaymentParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); }
7108         CResult_PaymentParametersDecodeErrorZ(LDKCResult_PaymentParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); }
7109         operator LDKCResult_PaymentParametersDecodeErrorZ() && { LDKCResult_PaymentParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); return res; }
7110         ~CResult_PaymentParametersDecodeErrorZ() { CResult_PaymentParametersDecodeErrorZ_free(self); }
7111         CResult_PaymentParametersDecodeErrorZ& operator=(CResult_PaymentParametersDecodeErrorZ&& o) { CResult_PaymentParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); return *this; }
7112         LDKCResult_PaymentParametersDecodeErrorZ* operator &() { return &self; }
7113         LDKCResult_PaymentParametersDecodeErrorZ* operator ->() { return &self; }
7114         const LDKCResult_PaymentParametersDecodeErrorZ* operator &() const { return &self; }
7115         const LDKCResult_PaymentParametersDecodeErrorZ* operator ->() const { return &self; }
7116 };
7117 class C2Tuple_ThirtyTwoBytesChannelMonitorZ {
7118 private:
7119         LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ self;
7120 public:
7121         C2Tuple_ThirtyTwoBytesChannelMonitorZ(const C2Tuple_ThirtyTwoBytesChannelMonitorZ&) = delete;
7122         C2Tuple_ThirtyTwoBytesChannelMonitorZ(C2Tuple_ThirtyTwoBytesChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelMonitorZ)); }
7123         C2Tuple_ThirtyTwoBytesChannelMonitorZ(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ)); }
7124         operator LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ() && { LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ)); return res; }
7125         ~C2Tuple_ThirtyTwoBytesChannelMonitorZ() { C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(self); }
7126         C2Tuple_ThirtyTwoBytesChannelMonitorZ& operator=(C2Tuple_ThirtyTwoBytesChannelMonitorZ&& o) { C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelMonitorZ)); return *this; }
7127         LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator &() { return &self; }
7128         LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator ->() { return &self; }
7129         const LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator &() const { return &self; }
7130         const LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator ->() const { return &self; }
7131 };
7132 class COption_U128Z {
7133 private:
7134         LDKCOption_U128Z self;
7135 public:
7136         COption_U128Z(const COption_U128Z&) = delete;
7137         COption_U128Z(COption_U128Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_U128Z)); }
7138         COption_U128Z(LDKCOption_U128Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_U128Z)); }
7139         operator LDKCOption_U128Z() && { LDKCOption_U128Z res = self; memset(&self, 0, sizeof(LDKCOption_U128Z)); return res; }
7140         ~COption_U128Z() { COption_U128Z_free(self); }
7141         COption_U128Z& operator=(COption_U128Z&& o) { COption_U128Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_U128Z)); return *this; }
7142         LDKCOption_U128Z* operator &() { return &self; }
7143         LDKCOption_U128Z* operator ->() { return &self; }
7144         const LDKCOption_U128Z* operator &() const { return &self; }
7145         const LDKCOption_U128Z* operator ->() const { return &self; }
7146 };
7147 class C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ {
7148 private:
7149         LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ self;
7150 public:
7151         C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(const C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&) = delete;
7152         C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); }
7153         C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); }
7154         operator LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ() && { LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); return res; }
7155         ~C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ() { C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(self); }
7156         C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ& operator=(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& o) { C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); return *this; }
7157         LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator &() { return &self; }
7158         LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator ->() { return &self; }
7159         const LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator &() const { return &self; }
7160         const LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator ->() const { return &self; }
7161 };
7162 class CResult_TxAckRbfDecodeErrorZ {
7163 private:
7164         LDKCResult_TxAckRbfDecodeErrorZ self;
7165 public:
7166         CResult_TxAckRbfDecodeErrorZ(const CResult_TxAckRbfDecodeErrorZ&) = delete;
7167         CResult_TxAckRbfDecodeErrorZ(CResult_TxAckRbfDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAckRbfDecodeErrorZ)); }
7168         CResult_TxAckRbfDecodeErrorZ(LDKCResult_TxAckRbfDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAckRbfDecodeErrorZ)); }
7169         operator LDKCResult_TxAckRbfDecodeErrorZ() && { LDKCResult_TxAckRbfDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAckRbfDecodeErrorZ)); return res; }
7170         ~CResult_TxAckRbfDecodeErrorZ() { CResult_TxAckRbfDecodeErrorZ_free(self); }
7171         CResult_TxAckRbfDecodeErrorZ& operator=(CResult_TxAckRbfDecodeErrorZ&& o) { CResult_TxAckRbfDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAckRbfDecodeErrorZ)); return *this; }
7172         LDKCResult_TxAckRbfDecodeErrorZ* operator &() { return &self; }
7173         LDKCResult_TxAckRbfDecodeErrorZ* operator ->() { return &self; }
7174         const LDKCResult_TxAckRbfDecodeErrorZ* operator &() const { return &self; }
7175         const LDKCResult_TxAckRbfDecodeErrorZ* operator ->() const { return &self; }
7176 };
7177 class CResult_Bolt11InvoiceBolt11SemanticErrorZ {
7178 private:
7179         LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ self;
7180 public:
7181         CResult_Bolt11InvoiceBolt11SemanticErrorZ(const CResult_Bolt11InvoiceBolt11SemanticErrorZ&) = delete;
7182         CResult_Bolt11InvoiceBolt11SemanticErrorZ(CResult_Bolt11InvoiceBolt11SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceBolt11SemanticErrorZ)); }
7183         CResult_Bolt11InvoiceBolt11SemanticErrorZ(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ)); }
7184         operator LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ() && { LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ)); return res; }
7185         ~CResult_Bolt11InvoiceBolt11SemanticErrorZ() { CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(self); }
7186         CResult_Bolt11InvoiceBolt11SemanticErrorZ& operator=(CResult_Bolt11InvoiceBolt11SemanticErrorZ&& o) { CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceBolt11SemanticErrorZ)); return *this; }
7187         LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator &() { return &self; }
7188         LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator ->() { return &self; }
7189         const LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator &() const { return &self; }
7190         const LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator ->() const { return &self; }
7191 };
7192 class COption_UtxoLookupZ {
7193 private:
7194         LDKCOption_UtxoLookupZ self;
7195 public:
7196         COption_UtxoLookupZ(const COption_UtxoLookupZ&) = delete;
7197         COption_UtxoLookupZ(COption_UtxoLookupZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_UtxoLookupZ)); }
7198         COption_UtxoLookupZ(LDKCOption_UtxoLookupZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_UtxoLookupZ)); }
7199         operator LDKCOption_UtxoLookupZ() && { LDKCOption_UtxoLookupZ res = self; memset(&self, 0, sizeof(LDKCOption_UtxoLookupZ)); return res; }
7200         ~COption_UtxoLookupZ() { COption_UtxoLookupZ_free(self); }
7201         COption_UtxoLookupZ& operator=(COption_UtxoLookupZ&& o) { COption_UtxoLookupZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_UtxoLookupZ)); return *this; }
7202         LDKCOption_UtxoLookupZ* operator &() { return &self; }
7203         LDKCOption_UtxoLookupZ* operator ->() { return &self; }
7204         const LDKCOption_UtxoLookupZ* operator &() const { return &self; }
7205         const LDKCOption_UtxoLookupZ* operator ->() const { return &self; }
7206 };
7207 class CResult_PongDecodeErrorZ {
7208 private:
7209         LDKCResult_PongDecodeErrorZ self;
7210 public:
7211         CResult_PongDecodeErrorZ(const CResult_PongDecodeErrorZ&) = delete;
7212         CResult_PongDecodeErrorZ(CResult_PongDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); }
7213         CResult_PongDecodeErrorZ(LDKCResult_PongDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); }
7214         operator LDKCResult_PongDecodeErrorZ() && { LDKCResult_PongDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); return res; }
7215         ~CResult_PongDecodeErrorZ() { CResult_PongDecodeErrorZ_free(self); }
7216         CResult_PongDecodeErrorZ& operator=(CResult_PongDecodeErrorZ&& o) { CResult_PongDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); return *this; }
7217         LDKCResult_PongDecodeErrorZ* operator &() { return &self; }
7218         LDKCResult_PongDecodeErrorZ* operator ->() { return &self; }
7219         const LDKCResult_PongDecodeErrorZ* operator &() const { return &self; }
7220         const LDKCResult_PongDecodeErrorZ* operator ->() const { return &self; }
7221 };
7222 class CResult_UnsignedChannelAnnouncementDecodeErrorZ {
7223 private:
7224         LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ self;
7225 public:
7226         CResult_UnsignedChannelAnnouncementDecodeErrorZ(const CResult_UnsignedChannelAnnouncementDecodeErrorZ&) = delete;
7227         CResult_UnsignedChannelAnnouncementDecodeErrorZ(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
7228         CResult_UnsignedChannelAnnouncementDecodeErrorZ(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
7229         operator LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); return res; }
7230         ~CResult_UnsignedChannelAnnouncementDecodeErrorZ() { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); }
7231         CResult_UnsignedChannelAnnouncementDecodeErrorZ& operator=(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); return *this; }
7232         LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
7233         LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
7234         const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
7235         const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
7236 };
7237 class C2Tuple_OutPointCVec_MonitorUpdateIdZZ {
7238 private:
7239         LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ self;
7240 public:
7241         C2Tuple_OutPointCVec_MonitorUpdateIdZZ(const C2Tuple_OutPointCVec_MonitorUpdateIdZZ&) = delete;
7242         C2Tuple_OutPointCVec_MonitorUpdateIdZZ(C2Tuple_OutPointCVec_MonitorUpdateIdZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointCVec_MonitorUpdateIdZZ)); }
7243         C2Tuple_OutPointCVec_MonitorUpdateIdZZ(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ)); }
7244         operator LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ() && { LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ)); return res; }
7245         ~C2Tuple_OutPointCVec_MonitorUpdateIdZZ() { C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(self); }
7246         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; }
7247         LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator &() { return &self; }
7248         LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator ->() { return &self; }
7249         const LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator &() const { return &self; }
7250         const LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator ->() const { return &self; }
7251 };
7252 class CResult_CVec_u8ZNoneZ {
7253 private:
7254         LDKCResult_CVec_u8ZNoneZ self;
7255 public:
7256         CResult_CVec_u8ZNoneZ(const CResult_CVec_u8ZNoneZ&) = delete;
7257         CResult_CVec_u8ZNoneZ(CResult_CVec_u8ZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZNoneZ)); }
7258         CResult_CVec_u8ZNoneZ(LDKCResult_CVec_u8ZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZNoneZ)); }
7259         operator LDKCResult_CVec_u8ZNoneZ() && { LDKCResult_CVec_u8ZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZNoneZ)); return res; }
7260         ~CResult_CVec_u8ZNoneZ() { CResult_CVec_u8ZNoneZ_free(self); }
7261         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; }
7262         LDKCResult_CVec_u8ZNoneZ* operator &() { return &self; }
7263         LDKCResult_CVec_u8ZNoneZ* operator ->() { return &self; }
7264         const LDKCResult_CVec_u8ZNoneZ* operator &() const { return &self; }
7265         const LDKCResult_CVec_u8ZNoneZ* operator ->() const { return &self; }
7266 };
7267 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ {
7268 private:
7269         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ self;
7270 public:
7271         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(const C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&) = delete;
7272         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); }
7273         C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); }
7274         operator LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ() && { LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); return res; }
7275         ~C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ() { C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(self); }
7276         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; }
7277         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator &() { return &self; }
7278         LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator ->() { return &self; }
7279         const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator &() const { return &self; }
7280         const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator ->() const { return &self; }
7281 };
7282 class CResult_ChannelTransactionParametersDecodeErrorZ {
7283 private:
7284         LDKCResult_ChannelTransactionParametersDecodeErrorZ self;
7285 public:
7286         CResult_ChannelTransactionParametersDecodeErrorZ(const CResult_ChannelTransactionParametersDecodeErrorZ&) = delete;
7287         CResult_ChannelTransactionParametersDecodeErrorZ(CResult_ChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); }
7288         CResult_ChannelTransactionParametersDecodeErrorZ(LDKCResult_ChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); }
7289         operator LDKCResult_ChannelTransactionParametersDecodeErrorZ() && { LDKCResult_ChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); return res; }
7290         ~CResult_ChannelTransactionParametersDecodeErrorZ() { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); }
7291         CResult_ChannelTransactionParametersDecodeErrorZ& operator=(CResult_ChannelTransactionParametersDecodeErrorZ&& o) { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); return *this; }
7292         LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
7293         LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
7294         const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
7295         const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
7296 };
7297 class CResult_WriteableEcdsaChannelSignerDecodeErrorZ {
7298 private:
7299         LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ self;
7300 public:
7301         CResult_WriteableEcdsaChannelSignerDecodeErrorZ(const CResult_WriteableEcdsaChannelSignerDecodeErrorZ&) = delete;
7302         CResult_WriteableEcdsaChannelSignerDecodeErrorZ(CResult_WriteableEcdsaChannelSignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WriteableEcdsaChannelSignerDecodeErrorZ)); }
7303         CResult_WriteableEcdsaChannelSignerDecodeErrorZ(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ)); }
7304         operator LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ() && { LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ)); return res; }
7305         ~CResult_WriteableEcdsaChannelSignerDecodeErrorZ() { CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(self); }
7306         CResult_WriteableEcdsaChannelSignerDecodeErrorZ& operator=(CResult_WriteableEcdsaChannelSignerDecodeErrorZ&& o) { CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WriteableEcdsaChannelSignerDecodeErrorZ)); return *this; }
7307         LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator &() { return &self; }
7308         LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator ->() { return &self; }
7309         const LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator &() const { return &self; }
7310         const LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator ->() const { return &self; }
7311 };
7312 class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
7313 private:
7314         LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ self;
7315 public:
7316         CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(const CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&) = delete;
7317         CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
7318         CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
7319         operator LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return res; }
7320         ~CResult_DelayedPaymentOutputDescriptorDecodeErrorZ() { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); }
7321         CResult_DelayedPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return *this; }
7322         LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
7323         LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
7324         const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
7325         const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
7326 };
7327 class CResult_InFlightHtlcsDecodeErrorZ {
7328 private:
7329         LDKCResult_InFlightHtlcsDecodeErrorZ self;
7330 public:
7331         CResult_InFlightHtlcsDecodeErrorZ(const CResult_InFlightHtlcsDecodeErrorZ&) = delete;
7332         CResult_InFlightHtlcsDecodeErrorZ(CResult_InFlightHtlcsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InFlightHtlcsDecodeErrorZ)); }
7333         CResult_InFlightHtlcsDecodeErrorZ(LDKCResult_InFlightHtlcsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ)); }
7334         operator LDKCResult_InFlightHtlcsDecodeErrorZ() && { LDKCResult_InFlightHtlcsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ)); return res; }
7335         ~CResult_InFlightHtlcsDecodeErrorZ() { CResult_InFlightHtlcsDecodeErrorZ_free(self); }
7336         CResult_InFlightHtlcsDecodeErrorZ& operator=(CResult_InFlightHtlcsDecodeErrorZ&& o) { CResult_InFlightHtlcsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InFlightHtlcsDecodeErrorZ)); return *this; }
7337         LDKCResult_InFlightHtlcsDecodeErrorZ* operator &() { return &self; }
7338         LDKCResult_InFlightHtlcsDecodeErrorZ* operator ->() { return &self; }
7339         const LDKCResult_InFlightHtlcsDecodeErrorZ* operator &() const { return &self; }
7340         const LDKCResult_InFlightHtlcsDecodeErrorZ* operator ->() const { return &self; }
7341 };
7342 class CResult_COption_HTLCDestinationZDecodeErrorZ {
7343 private:
7344         LDKCResult_COption_HTLCDestinationZDecodeErrorZ self;
7345 public:
7346         CResult_COption_HTLCDestinationZDecodeErrorZ(const CResult_COption_HTLCDestinationZDecodeErrorZ&) = delete;
7347         CResult_COption_HTLCDestinationZDecodeErrorZ(CResult_COption_HTLCDestinationZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_HTLCDestinationZDecodeErrorZ)); }
7348         CResult_COption_HTLCDestinationZDecodeErrorZ(LDKCResult_COption_HTLCDestinationZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ)); }
7349         operator LDKCResult_COption_HTLCDestinationZDecodeErrorZ() && { LDKCResult_COption_HTLCDestinationZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ)); return res; }
7350         ~CResult_COption_HTLCDestinationZDecodeErrorZ() { CResult_COption_HTLCDestinationZDecodeErrorZ_free(self); }
7351         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; }
7352         LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator &() { return &self; }
7353         LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator ->() { return &self; }
7354         const LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator &() const { return &self; }
7355         const LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator ->() const { return &self; }
7356 };
7357 class CResult_ThirtyTwoBytesNoneZ {
7358 private:
7359         LDKCResult_ThirtyTwoBytesNoneZ self;
7360 public:
7361         CResult_ThirtyTwoBytesNoneZ(const CResult_ThirtyTwoBytesNoneZ&) = delete;
7362         CResult_ThirtyTwoBytesNoneZ(CResult_ThirtyTwoBytesNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesNoneZ)); }
7363         CResult_ThirtyTwoBytesNoneZ(LDKCResult_ThirtyTwoBytesNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesNoneZ)); }
7364         operator LDKCResult_ThirtyTwoBytesNoneZ() && { LDKCResult_ThirtyTwoBytesNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesNoneZ)); return res; }
7365         ~CResult_ThirtyTwoBytesNoneZ() { CResult_ThirtyTwoBytesNoneZ_free(self); }
7366         CResult_ThirtyTwoBytesNoneZ& operator=(CResult_ThirtyTwoBytesNoneZ&& o) { CResult_ThirtyTwoBytesNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesNoneZ)); return *this; }
7367         LDKCResult_ThirtyTwoBytesNoneZ* operator &() { return &self; }
7368         LDKCResult_ThirtyTwoBytesNoneZ* operator ->() { return &self; }
7369         const LDKCResult_ThirtyTwoBytesNoneZ* operator &() const { return &self; }
7370         const LDKCResult_ThirtyTwoBytesNoneZ* operator ->() const { return &self; }
7371 };
7372 class C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ {
7373 private:
7374         LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ self;
7375 public:
7376         C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(const C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&) = delete;
7377         C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); }
7378         C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); }
7379         operator LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ() && { LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); return res; }
7380         ~C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ() { C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(self); }
7381         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; }
7382         LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator &() { return &self; }
7383         LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator ->() { return &self; }
7384         const LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator &() const { return &self; }
7385         const LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator ->() const { return &self; }
7386 };
7387 class CResult_BlindedHopDecodeErrorZ {
7388 private:
7389         LDKCResult_BlindedHopDecodeErrorZ self;
7390 public:
7391         CResult_BlindedHopDecodeErrorZ(const CResult_BlindedHopDecodeErrorZ&) = delete;
7392         CResult_BlindedHopDecodeErrorZ(CResult_BlindedHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedHopDecodeErrorZ)); }
7393         CResult_BlindedHopDecodeErrorZ(LDKCResult_BlindedHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedHopDecodeErrorZ)); }
7394         operator LDKCResult_BlindedHopDecodeErrorZ() && { LDKCResult_BlindedHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedHopDecodeErrorZ)); return res; }
7395         ~CResult_BlindedHopDecodeErrorZ() { CResult_BlindedHopDecodeErrorZ_free(self); }
7396         CResult_BlindedHopDecodeErrorZ& operator=(CResult_BlindedHopDecodeErrorZ&& o) { CResult_BlindedHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedHopDecodeErrorZ)); return *this; }
7397         LDKCResult_BlindedHopDecodeErrorZ* operator &() { return &self; }
7398         LDKCResult_BlindedHopDecodeErrorZ* operator ->() { return &self; }
7399         const LDKCResult_BlindedHopDecodeErrorZ* operator &() const { return &self; }
7400         const LDKCResult_BlindedHopDecodeErrorZ* operator ->() const { return &self; }
7401 };
7402 class C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ {
7403 private:
7404         LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ self;
7405 public:
7406         C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ(const C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ&) = delete;
7407         C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ(C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ)); }
7408         C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ)); }
7409         operator LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ() && { LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ)); return res; }
7410         ~C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ() { C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_free(self); }
7411         C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ& operator=(C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ&& o) { C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ)); return *this; }
7412         LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* operator &() { return &self; }
7413         LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* operator ->() { return &self; }
7414         const LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* operator &() const { return &self; }
7415         const LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* operator ->() const { return &self; }
7416 };
7417 class CResult_FixedPenaltyScorerDecodeErrorZ {
7418 private:
7419         LDKCResult_FixedPenaltyScorerDecodeErrorZ self;
7420 public:
7421         CResult_FixedPenaltyScorerDecodeErrorZ(const CResult_FixedPenaltyScorerDecodeErrorZ&) = delete;
7422         CResult_FixedPenaltyScorerDecodeErrorZ(CResult_FixedPenaltyScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); }
7423         CResult_FixedPenaltyScorerDecodeErrorZ(LDKCResult_FixedPenaltyScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); }
7424         operator LDKCResult_FixedPenaltyScorerDecodeErrorZ() && { LDKCResult_FixedPenaltyScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); return res; }
7425         ~CResult_FixedPenaltyScorerDecodeErrorZ() { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); }
7426         CResult_FixedPenaltyScorerDecodeErrorZ& operator=(CResult_FixedPenaltyScorerDecodeErrorZ&& o) { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); return *this; }
7427         LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() { return &self; }
7428         LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() { return &self; }
7429         const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() const { return &self; }
7430         const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() const { return &self; }
7431 };
7432 class CVec_BlindedPathZ {
7433 private:
7434         LDKCVec_BlindedPathZ self;
7435 public:
7436         CVec_BlindedPathZ(const CVec_BlindedPathZ&) = delete;
7437         CVec_BlindedPathZ(CVec_BlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BlindedPathZ)); }
7438         CVec_BlindedPathZ(LDKCVec_BlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BlindedPathZ)); }
7439         operator LDKCVec_BlindedPathZ() && { LDKCVec_BlindedPathZ res = self; memset(&self, 0, sizeof(LDKCVec_BlindedPathZ)); return res; }
7440         ~CVec_BlindedPathZ() { CVec_BlindedPathZ_free(self); }
7441         CVec_BlindedPathZ& operator=(CVec_BlindedPathZ&& o) { CVec_BlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BlindedPathZ)); return *this; }
7442         LDKCVec_BlindedPathZ* operator &() { return &self; }
7443         LDKCVec_BlindedPathZ* operator ->() { return &self; }
7444         const LDKCVec_BlindedPathZ* operator &() const { return &self; }
7445         const LDKCVec_BlindedPathZ* operator ->() const { return &self; }
7446 };
7447 class CResult_NoneLightningErrorZ {
7448 private:
7449         LDKCResult_NoneLightningErrorZ self;
7450 public:
7451         CResult_NoneLightningErrorZ(const CResult_NoneLightningErrorZ&) = delete;
7452         CResult_NoneLightningErrorZ(CResult_NoneLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); }
7453         CResult_NoneLightningErrorZ(LDKCResult_NoneLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); }
7454         operator LDKCResult_NoneLightningErrorZ() && { LDKCResult_NoneLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); return res; }
7455         ~CResult_NoneLightningErrorZ() { CResult_NoneLightningErrorZ_free(self); }
7456         CResult_NoneLightningErrorZ& operator=(CResult_NoneLightningErrorZ&& o) { CResult_NoneLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); return *this; }
7457         LDKCResult_NoneLightningErrorZ* operator &() { return &self; }
7458         LDKCResult_NoneLightningErrorZ* operator ->() { return &self; }
7459         const LDKCResult_NoneLightningErrorZ* operator &() const { return &self; }
7460         const LDKCResult_NoneLightningErrorZ* operator ->() const { return &self; }
7461 };
7462 class CResult_NonePeerHandleErrorZ {
7463 private:
7464         LDKCResult_NonePeerHandleErrorZ self;
7465 public:
7466         CResult_NonePeerHandleErrorZ(const CResult_NonePeerHandleErrorZ&) = delete;
7467         CResult_NonePeerHandleErrorZ(CResult_NonePeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); }
7468         CResult_NonePeerHandleErrorZ(LDKCResult_NonePeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); }
7469         operator LDKCResult_NonePeerHandleErrorZ() && { LDKCResult_NonePeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); return res; }
7470         ~CResult_NonePeerHandleErrorZ() { CResult_NonePeerHandleErrorZ_free(self); }
7471         CResult_NonePeerHandleErrorZ& operator=(CResult_NonePeerHandleErrorZ&& o) { CResult_NonePeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); return *this; }
7472         LDKCResult_NonePeerHandleErrorZ* operator &() { return &self; }
7473         LDKCResult_NonePeerHandleErrorZ* operator ->() { return &self; }
7474         const LDKCResult_NonePeerHandleErrorZ* operator &() const { return &self; }
7475         const LDKCResult_NonePeerHandleErrorZ* operator ->() const { return &self; }
7476 };
7477 class CResult_TrustedCommitmentTransactionNoneZ {
7478 private:
7479         LDKCResult_TrustedCommitmentTransactionNoneZ self;
7480 public:
7481         CResult_TrustedCommitmentTransactionNoneZ(const CResult_TrustedCommitmentTransactionNoneZ&) = delete;
7482         CResult_TrustedCommitmentTransactionNoneZ(CResult_TrustedCommitmentTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); }
7483         CResult_TrustedCommitmentTransactionNoneZ(LDKCResult_TrustedCommitmentTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); }
7484         operator LDKCResult_TrustedCommitmentTransactionNoneZ() && { LDKCResult_TrustedCommitmentTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); return res; }
7485         ~CResult_TrustedCommitmentTransactionNoneZ() { CResult_TrustedCommitmentTransactionNoneZ_free(self); }
7486         CResult_TrustedCommitmentTransactionNoneZ& operator=(CResult_TrustedCommitmentTransactionNoneZ&& o) { CResult_TrustedCommitmentTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); return *this; }
7487         LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() { return &self; }
7488         LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() { return &self; }
7489         const LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() const { return &self; }
7490         const LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() const { return &self; }
7491 };
7492 class CResult_COption_EventZDecodeErrorZ {
7493 private:
7494         LDKCResult_COption_EventZDecodeErrorZ self;
7495 public:
7496         CResult_COption_EventZDecodeErrorZ(const CResult_COption_EventZDecodeErrorZ&) = delete;
7497         CResult_COption_EventZDecodeErrorZ(CResult_COption_EventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_EventZDecodeErrorZ)); }
7498         CResult_COption_EventZDecodeErrorZ(LDKCResult_COption_EventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); }
7499         operator LDKCResult_COption_EventZDecodeErrorZ() && { LDKCResult_COption_EventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); return res; }
7500         ~CResult_COption_EventZDecodeErrorZ() { CResult_COption_EventZDecodeErrorZ_free(self); }
7501         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; }
7502         LDKCResult_COption_EventZDecodeErrorZ* operator &() { return &self; }
7503         LDKCResult_COption_EventZDecodeErrorZ* operator ->() { return &self; }
7504         const LDKCResult_COption_EventZDecodeErrorZ* operator &() const { return &self; }
7505         const LDKCResult_COption_EventZDecodeErrorZ* operator ->() const { return &self; }
7506 };
7507 class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ {
7508 private:
7509         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ self;
7510 public:
7511         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ(const CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ&) = delete;
7512         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ)); }
7513         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ)); }
7514         operator LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ() && { LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ)); return res; }
7515         ~CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ() { CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_free(self); }
7516         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ& operator=(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ&& o) { CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ)); return *this; }
7517         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* operator &() { return &self; }
7518         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* operator ->() { return &self; }
7519         const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* operator &() const { return &self; }
7520         const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* operator ->() const { return &self; }
7521 };
7522 class CResult_PaymentFailureReasonDecodeErrorZ {
7523 private:
7524         LDKCResult_PaymentFailureReasonDecodeErrorZ self;
7525 public:
7526         CResult_PaymentFailureReasonDecodeErrorZ(const CResult_PaymentFailureReasonDecodeErrorZ&) = delete;
7527         CResult_PaymentFailureReasonDecodeErrorZ(CResult_PaymentFailureReasonDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentFailureReasonDecodeErrorZ)); }
7528         CResult_PaymentFailureReasonDecodeErrorZ(LDKCResult_PaymentFailureReasonDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ)); }
7529         operator LDKCResult_PaymentFailureReasonDecodeErrorZ() && { LDKCResult_PaymentFailureReasonDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ)); return res; }
7530         ~CResult_PaymentFailureReasonDecodeErrorZ() { CResult_PaymentFailureReasonDecodeErrorZ_free(self); }
7531         CResult_PaymentFailureReasonDecodeErrorZ& operator=(CResult_PaymentFailureReasonDecodeErrorZ&& o) { CResult_PaymentFailureReasonDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentFailureReasonDecodeErrorZ)); return *this; }
7532         LDKCResult_PaymentFailureReasonDecodeErrorZ* operator &() { return &self; }
7533         LDKCResult_PaymentFailureReasonDecodeErrorZ* operator ->() { return &self; }
7534         const LDKCResult_PaymentFailureReasonDecodeErrorZ* operator &() const { return &self; }
7535         const LDKCResult_PaymentFailureReasonDecodeErrorZ* operator ->() const { return &self; }
7536 };
7537 class COption_SocketAddressZ {
7538 private:
7539         LDKCOption_SocketAddressZ self;
7540 public:
7541         COption_SocketAddressZ(const COption_SocketAddressZ&) = delete;
7542         COption_SocketAddressZ(COption_SocketAddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_SocketAddressZ)); }
7543         COption_SocketAddressZ(LDKCOption_SocketAddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_SocketAddressZ)); }
7544         operator LDKCOption_SocketAddressZ() && { LDKCOption_SocketAddressZ res = self; memset(&self, 0, sizeof(LDKCOption_SocketAddressZ)); return res; }
7545         ~COption_SocketAddressZ() { COption_SocketAddressZ_free(self); }
7546         COption_SocketAddressZ& operator=(COption_SocketAddressZ&& o) { COption_SocketAddressZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_SocketAddressZ)); return *this; }
7547         LDKCOption_SocketAddressZ* operator &() { return &self; }
7548         LDKCOption_SocketAddressZ* operator ->() { return &self; }
7549         const LDKCOption_SocketAddressZ* operator &() const { return &self; }
7550         const LDKCOption_SocketAddressZ* operator ->() const { return &self; }
7551 };
7552 class CResult_COption_MonitorEventZDecodeErrorZ {
7553 private:
7554         LDKCResult_COption_MonitorEventZDecodeErrorZ self;
7555 public:
7556         CResult_COption_MonitorEventZDecodeErrorZ(const CResult_COption_MonitorEventZDecodeErrorZ&) = delete;
7557         CResult_COption_MonitorEventZDecodeErrorZ(CResult_COption_MonitorEventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_MonitorEventZDecodeErrorZ)); }
7558         CResult_COption_MonitorEventZDecodeErrorZ(LDKCResult_COption_MonitorEventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); }
7559         operator LDKCResult_COption_MonitorEventZDecodeErrorZ() && { LDKCResult_COption_MonitorEventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); return res; }
7560         ~CResult_COption_MonitorEventZDecodeErrorZ() { CResult_COption_MonitorEventZDecodeErrorZ_free(self); }
7561         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; }
7562         LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() { return &self; }
7563         LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() { return &self; }
7564         const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() const { return &self; }
7565         const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() const { return &self; }
7566 };
7567 class COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ {
7568 private:
7569         LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ self;
7570 public:
7571         COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(const COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&) = delete;
7572         COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); }
7573         COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); }
7574         operator LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ() && { LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); return res; }
7575         ~COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ() { COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(self); }
7576         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; }
7577         LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator &() { return &self; }
7578         LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator ->() { return &self; }
7579         const LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator &() const { return &self; }
7580         const LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator ->() const { return &self; }
7581 };
7582 class CResult_DescriptionCreationErrorZ {
7583 private:
7584         LDKCResult_DescriptionCreationErrorZ self;
7585 public:
7586         CResult_DescriptionCreationErrorZ(const CResult_DescriptionCreationErrorZ&) = delete;
7587         CResult_DescriptionCreationErrorZ(CResult_DescriptionCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); }
7588         CResult_DescriptionCreationErrorZ(LDKCResult_DescriptionCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); }
7589         operator LDKCResult_DescriptionCreationErrorZ() && { LDKCResult_DescriptionCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); return res; }
7590         ~CResult_DescriptionCreationErrorZ() { CResult_DescriptionCreationErrorZ_free(self); }
7591         CResult_DescriptionCreationErrorZ& operator=(CResult_DescriptionCreationErrorZ&& o) { CResult_DescriptionCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); return *this; }
7592         LDKCResult_DescriptionCreationErrorZ* operator &() { return &self; }
7593         LDKCResult_DescriptionCreationErrorZ* operator ->() { return &self; }
7594         const LDKCResult_DescriptionCreationErrorZ* operator &() const { return &self; }
7595         const LDKCResult_DescriptionCreationErrorZ* operator ->() const { return &self; }
7596 };
7597 class CResult_RoutingFeesDecodeErrorZ {
7598 private:
7599         LDKCResult_RoutingFeesDecodeErrorZ self;
7600 public:
7601         CResult_RoutingFeesDecodeErrorZ(const CResult_RoutingFeesDecodeErrorZ&) = delete;
7602         CResult_RoutingFeesDecodeErrorZ(CResult_RoutingFeesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); }
7603         CResult_RoutingFeesDecodeErrorZ(LDKCResult_RoutingFeesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); }
7604         operator LDKCResult_RoutingFeesDecodeErrorZ() && { LDKCResult_RoutingFeesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); return res; }
7605         ~CResult_RoutingFeesDecodeErrorZ() { CResult_RoutingFeesDecodeErrorZ_free(self); }
7606         CResult_RoutingFeesDecodeErrorZ& operator=(CResult_RoutingFeesDecodeErrorZ&& o) { CResult_RoutingFeesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); return *this; }
7607         LDKCResult_RoutingFeesDecodeErrorZ* operator &() { return &self; }
7608         LDKCResult_RoutingFeesDecodeErrorZ* operator ->() { return &self; }
7609         const LDKCResult_RoutingFeesDecodeErrorZ* operator &() const { return &self; }
7610         const LDKCResult_RoutingFeesDecodeErrorZ* operator ->() const { return &self; }
7611 };
7612 class CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ {
7613 private:
7614         LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ self;
7615 public:
7616         CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ(const CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ&) = delete;
7617         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)); }
7618         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)); }
7619         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; }
7620         ~CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ() { CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(self); }
7621         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; }
7622         LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator &() { return &self; }
7623         LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator ->() { return &self; }
7624         const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator &() const { return &self; }
7625         const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator ->() const { return &self; }
7626 };
7627 class CResult_PaymentRelayDecodeErrorZ {
7628 private:
7629         LDKCResult_PaymentRelayDecodeErrorZ self;
7630 public:
7631         CResult_PaymentRelayDecodeErrorZ(const CResult_PaymentRelayDecodeErrorZ&) = delete;
7632         CResult_PaymentRelayDecodeErrorZ(CResult_PaymentRelayDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentRelayDecodeErrorZ)); }
7633         CResult_PaymentRelayDecodeErrorZ(LDKCResult_PaymentRelayDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentRelayDecodeErrorZ)); }
7634         operator LDKCResult_PaymentRelayDecodeErrorZ() && { LDKCResult_PaymentRelayDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentRelayDecodeErrorZ)); return res; }
7635         ~CResult_PaymentRelayDecodeErrorZ() { CResult_PaymentRelayDecodeErrorZ_free(self); }
7636         CResult_PaymentRelayDecodeErrorZ& operator=(CResult_PaymentRelayDecodeErrorZ&& o) { CResult_PaymentRelayDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentRelayDecodeErrorZ)); return *this; }
7637         LDKCResult_PaymentRelayDecodeErrorZ* operator &() { return &self; }
7638         LDKCResult_PaymentRelayDecodeErrorZ* operator ->() { return &self; }
7639         const LDKCResult_PaymentRelayDecodeErrorZ* operator &() const { return &self; }
7640         const LDKCResult_PaymentRelayDecodeErrorZ* operator ->() const { return &self; }
7641 };
7642 class CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ {
7643 private:
7644         LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ self;
7645 public:
7646         CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(const CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&) = delete;
7647         CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); }
7648         CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); }
7649         operator LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ() && { LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); return res; }
7650         ~CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ() { CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(self); }
7651         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; }
7652         LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator &() { return &self; }
7653         LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator ->() { return &self; }
7654         const LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator &() const { return &self; }
7655         const LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator ->() const { return &self; }
7656 };
7657 class CResult_QueryShortChannelIdsDecodeErrorZ {
7658 private:
7659         LDKCResult_QueryShortChannelIdsDecodeErrorZ self;
7660 public:
7661         CResult_QueryShortChannelIdsDecodeErrorZ(const CResult_QueryShortChannelIdsDecodeErrorZ&) = delete;
7662         CResult_QueryShortChannelIdsDecodeErrorZ(CResult_QueryShortChannelIdsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); }
7663         CResult_QueryShortChannelIdsDecodeErrorZ(LDKCResult_QueryShortChannelIdsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); }
7664         operator LDKCResult_QueryShortChannelIdsDecodeErrorZ() && { LDKCResult_QueryShortChannelIdsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); return res; }
7665         ~CResult_QueryShortChannelIdsDecodeErrorZ() { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); }
7666         CResult_QueryShortChannelIdsDecodeErrorZ& operator=(CResult_QueryShortChannelIdsDecodeErrorZ&& o) { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); return *this; }
7667         LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() { return &self; }
7668         LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() { return &self; }
7669         const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() const { return &self; }
7670         const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() const { return &self; }
7671 };
7672 class CResult_VerifiedInvoiceRequestNoneZ {
7673 private:
7674         LDKCResult_VerifiedInvoiceRequestNoneZ self;
7675 public:
7676         CResult_VerifiedInvoiceRequestNoneZ(const CResult_VerifiedInvoiceRequestNoneZ&) = delete;
7677         CResult_VerifiedInvoiceRequestNoneZ(CResult_VerifiedInvoiceRequestNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_VerifiedInvoiceRequestNoneZ)); }
7678         CResult_VerifiedInvoiceRequestNoneZ(LDKCResult_VerifiedInvoiceRequestNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_VerifiedInvoiceRequestNoneZ)); }
7679         operator LDKCResult_VerifiedInvoiceRequestNoneZ() && { LDKCResult_VerifiedInvoiceRequestNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_VerifiedInvoiceRequestNoneZ)); return res; }
7680         ~CResult_VerifiedInvoiceRequestNoneZ() { CResult_VerifiedInvoiceRequestNoneZ_free(self); }
7681         CResult_VerifiedInvoiceRequestNoneZ& operator=(CResult_VerifiedInvoiceRequestNoneZ&& o) { CResult_VerifiedInvoiceRequestNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_VerifiedInvoiceRequestNoneZ)); return *this; }
7682         LDKCResult_VerifiedInvoiceRequestNoneZ* operator &() { return &self; }
7683         LDKCResult_VerifiedInvoiceRequestNoneZ* operator ->() { return &self; }
7684         const LDKCResult_VerifiedInvoiceRequestNoneZ* operator &() const { return &self; }
7685         const LDKCResult_VerifiedInvoiceRequestNoneZ* operator ->() const { return &self; }
7686 };
7687 class CResult_UpdateAddHTLCDecodeErrorZ {
7688 private:
7689         LDKCResult_UpdateAddHTLCDecodeErrorZ self;
7690 public:
7691         CResult_UpdateAddHTLCDecodeErrorZ(const CResult_UpdateAddHTLCDecodeErrorZ&) = delete;
7692         CResult_UpdateAddHTLCDecodeErrorZ(CResult_UpdateAddHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); }
7693         CResult_UpdateAddHTLCDecodeErrorZ(LDKCResult_UpdateAddHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); }
7694         operator LDKCResult_UpdateAddHTLCDecodeErrorZ() && { LDKCResult_UpdateAddHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); return res; }
7695         ~CResult_UpdateAddHTLCDecodeErrorZ() { CResult_UpdateAddHTLCDecodeErrorZ_free(self); }
7696         CResult_UpdateAddHTLCDecodeErrorZ& operator=(CResult_UpdateAddHTLCDecodeErrorZ&& o) { CResult_UpdateAddHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); return *this; }
7697         LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() { return &self; }
7698         LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() { return &self; }
7699         const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() const { return &self; }
7700         const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() const { return &self; }
7701 };
7702 class COption_MonitorEventZ {
7703 private:
7704         LDKCOption_MonitorEventZ self;
7705 public:
7706         COption_MonitorEventZ(const COption_MonitorEventZ&) = delete;
7707         COption_MonitorEventZ(COption_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MonitorEventZ)); }
7708         COption_MonitorEventZ(LDKCOption_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MonitorEventZ)); }
7709         operator LDKCOption_MonitorEventZ() && { LDKCOption_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCOption_MonitorEventZ)); return res; }
7710         ~COption_MonitorEventZ() { COption_MonitorEventZ_free(self); }
7711         COption_MonitorEventZ& operator=(COption_MonitorEventZ&& o) { COption_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MonitorEventZ)); return *this; }
7712         LDKCOption_MonitorEventZ* operator &() { return &self; }
7713         LDKCOption_MonitorEventZ* operator ->() { return &self; }
7714         const LDKCOption_MonitorEventZ* operator &() const { return &self; }
7715         const LDKCOption_MonitorEventZ* operator ->() const { return &self; }
7716 };
7717 class COption_TypeZ {
7718 private:
7719         LDKCOption_TypeZ self;
7720 public:
7721         COption_TypeZ(const COption_TypeZ&) = delete;
7722         COption_TypeZ(COption_TypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_TypeZ)); }
7723         COption_TypeZ(LDKCOption_TypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_TypeZ)); }
7724         operator LDKCOption_TypeZ() && { LDKCOption_TypeZ res = self; memset(&self, 0, sizeof(LDKCOption_TypeZ)); return res; }
7725         ~COption_TypeZ() { COption_TypeZ_free(self); }
7726         COption_TypeZ& operator=(COption_TypeZ&& o) { COption_TypeZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_TypeZ)); return *this; }
7727         LDKCOption_TypeZ* operator &() { return &self; }
7728         LDKCOption_TypeZ* operator ->() { return &self; }
7729         const LDKCOption_TypeZ* operator &() const { return &self; }
7730         const LDKCOption_TypeZ* operator ->() const { return &self; }
7731 };
7732 class CResult_COption_TypeZDecodeErrorZ {
7733 private:
7734         LDKCResult_COption_TypeZDecodeErrorZ self;
7735 public:
7736         CResult_COption_TypeZDecodeErrorZ(const CResult_COption_TypeZDecodeErrorZ&) = delete;
7737         CResult_COption_TypeZDecodeErrorZ(CResult_COption_TypeZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_TypeZDecodeErrorZ)); }
7738         CResult_COption_TypeZDecodeErrorZ(LDKCResult_COption_TypeZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); }
7739         operator LDKCResult_COption_TypeZDecodeErrorZ() && { LDKCResult_COption_TypeZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); return res; }
7740         ~CResult_COption_TypeZDecodeErrorZ() { CResult_COption_TypeZDecodeErrorZ_free(self); }
7741         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; }
7742         LDKCResult_COption_TypeZDecodeErrorZ* operator &() { return &self; }
7743         LDKCResult_COption_TypeZDecodeErrorZ* operator ->() { return &self; }
7744         const LDKCResult_COption_TypeZDecodeErrorZ* operator &() const { return &self; }
7745         const LDKCResult_COption_TypeZDecodeErrorZ* operator ->() const { return &self; }
7746 };
7747 class CResult_COption_PathFailureZDecodeErrorZ {
7748 private:
7749         LDKCResult_COption_PathFailureZDecodeErrorZ self;
7750 public:
7751         CResult_COption_PathFailureZDecodeErrorZ(const CResult_COption_PathFailureZDecodeErrorZ&) = delete;
7752         CResult_COption_PathFailureZDecodeErrorZ(CResult_COption_PathFailureZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_PathFailureZDecodeErrorZ)); }
7753         CResult_COption_PathFailureZDecodeErrorZ(LDKCResult_COption_PathFailureZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ)); }
7754         operator LDKCResult_COption_PathFailureZDecodeErrorZ() && { LDKCResult_COption_PathFailureZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ)); return res; }
7755         ~CResult_COption_PathFailureZDecodeErrorZ() { CResult_COption_PathFailureZDecodeErrorZ_free(self); }
7756         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; }
7757         LDKCResult_COption_PathFailureZDecodeErrorZ* operator &() { return &self; }
7758         LDKCResult_COption_PathFailureZDecodeErrorZ* operator ->() { return &self; }
7759         const LDKCResult_COption_PathFailureZDecodeErrorZ* operator &() const { return &self; }
7760         const LDKCResult_COption_PathFailureZDecodeErrorZ* operator ->() const { return &self; }
7761 };
7762 class CResult_Bolt11InvoiceSignOrCreationErrorZ {
7763 private:
7764         LDKCResult_Bolt11InvoiceSignOrCreationErrorZ self;
7765 public:
7766         CResult_Bolt11InvoiceSignOrCreationErrorZ(const CResult_Bolt11InvoiceSignOrCreationErrorZ&) = delete;
7767         CResult_Bolt11InvoiceSignOrCreationErrorZ(CResult_Bolt11InvoiceSignOrCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceSignOrCreationErrorZ)); }
7768         CResult_Bolt11InvoiceSignOrCreationErrorZ(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ)); }
7769         operator LDKCResult_Bolt11InvoiceSignOrCreationErrorZ() && { LDKCResult_Bolt11InvoiceSignOrCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ)); return res; }
7770         ~CResult_Bolt11InvoiceSignOrCreationErrorZ() { CResult_Bolt11InvoiceSignOrCreationErrorZ_free(self); }
7771         CResult_Bolt11InvoiceSignOrCreationErrorZ& operator=(CResult_Bolt11InvoiceSignOrCreationErrorZ&& o) { CResult_Bolt11InvoiceSignOrCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceSignOrCreationErrorZ)); return *this; }
7772         LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator &() { return &self; }
7773         LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator ->() { return &self; }
7774         const LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator &() const { return &self; }
7775         const LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator ->() const { return &self; }
7776 };
7777 class CResult_UpdateFailHTLCDecodeErrorZ {
7778 private:
7779         LDKCResult_UpdateFailHTLCDecodeErrorZ self;
7780 public:
7781         CResult_UpdateFailHTLCDecodeErrorZ(const CResult_UpdateFailHTLCDecodeErrorZ&) = delete;
7782         CResult_UpdateFailHTLCDecodeErrorZ(CResult_UpdateFailHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); }
7783         CResult_UpdateFailHTLCDecodeErrorZ(LDKCResult_UpdateFailHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); }
7784         operator LDKCResult_UpdateFailHTLCDecodeErrorZ() && { LDKCResult_UpdateFailHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); return res; }
7785         ~CResult_UpdateFailHTLCDecodeErrorZ() { CResult_UpdateFailHTLCDecodeErrorZ_free(self); }
7786         CResult_UpdateFailHTLCDecodeErrorZ& operator=(CResult_UpdateFailHTLCDecodeErrorZ&& o) { CResult_UpdateFailHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); return *this; }
7787         LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() { return &self; }
7788         LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() { return &self; }
7789         const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() const { return &self; }
7790         const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() const { return &self; }
7791 };
7792 class CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ {
7793 private:
7794         LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ self;
7795 public:
7796         CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(const CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&) = delete;
7797         CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); }
7798         CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); }
7799         operator LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); return res; }
7800         ~CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ() { CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(self); }
7801         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; }
7802         LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator &() { return &self; }
7803         LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator ->() { return &self; }
7804         const LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator &() const { return &self; }
7805         const LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator ->() const { return &self; }
7806 };
7807 class CResult_RevokeAndACKDecodeErrorZ {
7808 private:
7809         LDKCResult_RevokeAndACKDecodeErrorZ self;
7810 public:
7811         CResult_RevokeAndACKDecodeErrorZ(const CResult_RevokeAndACKDecodeErrorZ&) = delete;
7812         CResult_RevokeAndACKDecodeErrorZ(CResult_RevokeAndACKDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); }
7813         CResult_RevokeAndACKDecodeErrorZ(LDKCResult_RevokeAndACKDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); }
7814         operator LDKCResult_RevokeAndACKDecodeErrorZ() && { LDKCResult_RevokeAndACKDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); return res; }
7815         ~CResult_RevokeAndACKDecodeErrorZ() { CResult_RevokeAndACKDecodeErrorZ_free(self); }
7816         CResult_RevokeAndACKDecodeErrorZ& operator=(CResult_RevokeAndACKDecodeErrorZ&& o) { CResult_RevokeAndACKDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); return *this; }
7817         LDKCResult_RevokeAndACKDecodeErrorZ* operator &() { return &self; }
7818         LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() { return &self; }
7819         const LDKCResult_RevokeAndACKDecodeErrorZ* operator &() const { return &self; }
7820         const LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() const { return &self; }
7821 };
7822 class CResult_SpendableOutputDescriptorDecodeErrorZ {
7823 private:
7824         LDKCResult_SpendableOutputDescriptorDecodeErrorZ self;
7825 public:
7826         CResult_SpendableOutputDescriptorDecodeErrorZ(const CResult_SpendableOutputDescriptorDecodeErrorZ&) = delete;
7827         CResult_SpendableOutputDescriptorDecodeErrorZ(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); }
7828         CResult_SpendableOutputDescriptorDecodeErrorZ(LDKCResult_SpendableOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); }
7829         operator LDKCResult_SpendableOutputDescriptorDecodeErrorZ() && { LDKCResult_SpendableOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); return res; }
7830         ~CResult_SpendableOutputDescriptorDecodeErrorZ() { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); }
7831         CResult_SpendableOutputDescriptorDecodeErrorZ& operator=(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); return *this; }
7832         LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() { return &self; }
7833         LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
7834         const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
7835         const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
7836 };
7837 class C2Tuple_PublicKeyCOption_SocketAddressZZ {
7838 private:
7839         LDKC2Tuple_PublicKeyCOption_SocketAddressZZ self;
7840 public:
7841         C2Tuple_PublicKeyCOption_SocketAddressZZ(const C2Tuple_PublicKeyCOption_SocketAddressZZ&) = delete;
7842         C2Tuple_PublicKeyCOption_SocketAddressZZ(C2Tuple_PublicKeyCOption_SocketAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyCOption_SocketAddressZZ)); }
7843         C2Tuple_PublicKeyCOption_SocketAddressZZ(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ)); }
7844         operator LDKC2Tuple_PublicKeyCOption_SocketAddressZZ() && { LDKC2Tuple_PublicKeyCOption_SocketAddressZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ)); return res; }
7845         ~C2Tuple_PublicKeyCOption_SocketAddressZZ() { C2Tuple_PublicKeyCOption_SocketAddressZZ_free(self); }
7846         C2Tuple_PublicKeyCOption_SocketAddressZZ& operator=(C2Tuple_PublicKeyCOption_SocketAddressZZ&& o) { C2Tuple_PublicKeyCOption_SocketAddressZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyCOption_SocketAddressZZ)); return *this; }
7847         LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator &() { return &self; }
7848         LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator ->() { return &self; }
7849         const LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator &() const { return &self; }
7850         const LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator ->() const { return &self; }
7851 };
7852 class CResult_UnsignedChannelUpdateDecodeErrorZ {
7853 private:
7854         LDKCResult_UnsignedChannelUpdateDecodeErrorZ self;
7855 public:
7856         CResult_UnsignedChannelUpdateDecodeErrorZ(const CResult_UnsignedChannelUpdateDecodeErrorZ&) = delete;
7857         CResult_UnsignedChannelUpdateDecodeErrorZ(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); }
7858         CResult_UnsignedChannelUpdateDecodeErrorZ(LDKCResult_UnsignedChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); }
7859         operator LDKCResult_UnsignedChannelUpdateDecodeErrorZ() && { LDKCResult_UnsignedChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); return res; }
7860         ~CResult_UnsignedChannelUpdateDecodeErrorZ() { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); }
7861         CResult_UnsignedChannelUpdateDecodeErrorZ& operator=(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); return *this; }
7862         LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() { return &self; }
7863         LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() { return &self; }
7864         const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() const { return &self; }
7865         const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
7866 };
7867 class CResult_PayeePubKeySecp256k1ErrorZ {
7868 private:
7869         LDKCResult_PayeePubKeySecp256k1ErrorZ self;
7870 public:
7871         CResult_PayeePubKeySecp256k1ErrorZ(const CResult_PayeePubKeySecp256k1ErrorZ&) = delete;
7872         CResult_PayeePubKeySecp256k1ErrorZ(CResult_PayeePubKeySecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PayeePubKeySecp256k1ErrorZ)); }
7873         CResult_PayeePubKeySecp256k1ErrorZ(LDKCResult_PayeePubKeySecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PayeePubKeySecp256k1ErrorZ)); }
7874         operator LDKCResult_PayeePubKeySecp256k1ErrorZ() && { LDKCResult_PayeePubKeySecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PayeePubKeySecp256k1ErrorZ)); return res; }
7875         ~CResult_PayeePubKeySecp256k1ErrorZ() { CResult_PayeePubKeySecp256k1ErrorZ_free(self); }
7876         CResult_PayeePubKeySecp256k1ErrorZ& operator=(CResult_PayeePubKeySecp256k1ErrorZ&& o) { CResult_PayeePubKeySecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PayeePubKeySecp256k1ErrorZ)); return *this; }
7877         LDKCResult_PayeePubKeySecp256k1ErrorZ* operator &() { return &self; }
7878         LDKCResult_PayeePubKeySecp256k1ErrorZ* operator ->() { return &self; }
7879         const LDKCResult_PayeePubKeySecp256k1ErrorZ* operator &() const { return &self; }
7880         const LDKCResult_PayeePubKeySecp256k1ErrorZ* operator ->() const { return &self; }
7881 };
7882 class COption_BigEndianScalarZ {
7883 private:
7884         LDKCOption_BigEndianScalarZ self;
7885 public:
7886         COption_BigEndianScalarZ(const COption_BigEndianScalarZ&) = delete;
7887         COption_BigEndianScalarZ(COption_BigEndianScalarZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_BigEndianScalarZ)); }
7888         COption_BigEndianScalarZ(LDKCOption_BigEndianScalarZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_BigEndianScalarZ)); }
7889         operator LDKCOption_BigEndianScalarZ() && { LDKCOption_BigEndianScalarZ res = self; memset(&self, 0, sizeof(LDKCOption_BigEndianScalarZ)); return res; }
7890         ~COption_BigEndianScalarZ() { COption_BigEndianScalarZ_free(self); }
7891         COption_BigEndianScalarZ& operator=(COption_BigEndianScalarZ&& o) { COption_BigEndianScalarZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_BigEndianScalarZ)); return *this; }
7892         LDKCOption_BigEndianScalarZ* operator &() { return &self; }
7893         LDKCOption_BigEndianScalarZ* operator ->() { return &self; }
7894         const LDKCOption_BigEndianScalarZ* operator &() const { return &self; }
7895         const LDKCOption_BigEndianScalarZ* operator ->() const { return &self; }
7896 };
7897 class CResult_PublicKeySecp256k1ErrorZ {
7898 private:
7899         LDKCResult_PublicKeySecp256k1ErrorZ self;
7900 public:
7901         CResult_PublicKeySecp256k1ErrorZ(const CResult_PublicKeySecp256k1ErrorZ&) = delete;
7902         CResult_PublicKeySecp256k1ErrorZ(CResult_PublicKeySecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PublicKeySecp256k1ErrorZ)); }
7903         CResult_PublicKeySecp256k1ErrorZ(LDKCResult_PublicKeySecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PublicKeySecp256k1ErrorZ)); }
7904         operator LDKCResult_PublicKeySecp256k1ErrorZ() && { LDKCResult_PublicKeySecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PublicKeySecp256k1ErrorZ)); return res; }
7905         ~CResult_PublicKeySecp256k1ErrorZ() { CResult_PublicKeySecp256k1ErrorZ_free(self); }
7906         CResult_PublicKeySecp256k1ErrorZ& operator=(CResult_PublicKeySecp256k1ErrorZ&& o) { CResult_PublicKeySecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PublicKeySecp256k1ErrorZ)); return *this; }
7907         LDKCResult_PublicKeySecp256k1ErrorZ* operator &() { return &self; }
7908         LDKCResult_PublicKeySecp256k1ErrorZ* operator ->() { return &self; }
7909         const LDKCResult_PublicKeySecp256k1ErrorZ* operator &() const { return &self; }
7910         const LDKCResult_PublicKeySecp256k1ErrorZ* operator ->() const { return &self; }
7911 };
7912 class CResult_CVec_ECDSASignatureZNoneZ {
7913 private:
7914         LDKCResult_CVec_ECDSASignatureZNoneZ self;
7915 public:
7916         CResult_CVec_ECDSASignatureZNoneZ(const CResult_CVec_ECDSASignatureZNoneZ&) = delete;
7917         CResult_CVec_ECDSASignatureZNoneZ(CResult_CVec_ECDSASignatureZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_ECDSASignatureZNoneZ)); }
7918         CResult_CVec_ECDSASignatureZNoneZ(LDKCResult_CVec_ECDSASignatureZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ)); }
7919         operator LDKCResult_CVec_ECDSASignatureZNoneZ() && { LDKCResult_CVec_ECDSASignatureZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ)); return res; }
7920         ~CResult_CVec_ECDSASignatureZNoneZ() { CResult_CVec_ECDSASignatureZNoneZ_free(self); }
7921         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; }
7922         LDKCResult_CVec_ECDSASignatureZNoneZ* operator &() { return &self; }
7923         LDKCResult_CVec_ECDSASignatureZNoneZ* operator ->() { return &self; }
7924         const LDKCResult_CVec_ECDSASignatureZNoneZ* operator &() const { return &self; }
7925         const LDKCResult_CVec_ECDSASignatureZNoneZ* operator ->() const { return &self; }
7926 };
7927 class CVec_BlindedHopZ {
7928 private:
7929         LDKCVec_BlindedHopZ self;
7930 public:
7931         CVec_BlindedHopZ(const CVec_BlindedHopZ&) = delete;
7932         CVec_BlindedHopZ(CVec_BlindedHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BlindedHopZ)); }
7933         CVec_BlindedHopZ(LDKCVec_BlindedHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BlindedHopZ)); }
7934         operator LDKCVec_BlindedHopZ() && { LDKCVec_BlindedHopZ res = self; memset(&self, 0, sizeof(LDKCVec_BlindedHopZ)); return res; }
7935         ~CVec_BlindedHopZ() { CVec_BlindedHopZ_free(self); }
7936         CVec_BlindedHopZ& operator=(CVec_BlindedHopZ&& o) { CVec_BlindedHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BlindedHopZ)); return *this; }
7937         LDKCVec_BlindedHopZ* operator &() { return &self; }
7938         LDKCVec_BlindedHopZ* operator ->() { return &self; }
7939         const LDKCVec_BlindedHopZ* operator &() const { return &self; }
7940         const LDKCVec_BlindedHopZ* operator ->() const { return &self; }
7941 };
7942 class CResult_COption_ClosureReasonZDecodeErrorZ {
7943 private:
7944         LDKCResult_COption_ClosureReasonZDecodeErrorZ self;
7945 public:
7946         CResult_COption_ClosureReasonZDecodeErrorZ(const CResult_COption_ClosureReasonZDecodeErrorZ&) = delete;
7947         CResult_COption_ClosureReasonZDecodeErrorZ(CResult_COption_ClosureReasonZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_ClosureReasonZDecodeErrorZ)); }
7948         CResult_COption_ClosureReasonZDecodeErrorZ(LDKCResult_COption_ClosureReasonZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); }
7949         operator LDKCResult_COption_ClosureReasonZDecodeErrorZ() && { LDKCResult_COption_ClosureReasonZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); return res; }
7950         ~CResult_COption_ClosureReasonZDecodeErrorZ() { CResult_COption_ClosureReasonZDecodeErrorZ_free(self); }
7951         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; }
7952         LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() { return &self; }
7953         LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() { return &self; }
7954         const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() const { return &self; }
7955         const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() const { return &self; }
7956 };
7957 class CResult_InvoiceErrorDecodeErrorZ {
7958 private:
7959         LDKCResult_InvoiceErrorDecodeErrorZ self;
7960 public:
7961         CResult_InvoiceErrorDecodeErrorZ(const CResult_InvoiceErrorDecodeErrorZ&) = delete;
7962         CResult_InvoiceErrorDecodeErrorZ(CResult_InvoiceErrorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceErrorDecodeErrorZ)); }
7963         CResult_InvoiceErrorDecodeErrorZ(LDKCResult_InvoiceErrorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceErrorDecodeErrorZ)); }
7964         operator LDKCResult_InvoiceErrorDecodeErrorZ() && { LDKCResult_InvoiceErrorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceErrorDecodeErrorZ)); return res; }
7965         ~CResult_InvoiceErrorDecodeErrorZ() { CResult_InvoiceErrorDecodeErrorZ_free(self); }
7966         CResult_InvoiceErrorDecodeErrorZ& operator=(CResult_InvoiceErrorDecodeErrorZ&& o) { CResult_InvoiceErrorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceErrorDecodeErrorZ)); return *this; }
7967         LDKCResult_InvoiceErrorDecodeErrorZ* operator &() { return &self; }
7968         LDKCResult_InvoiceErrorDecodeErrorZ* operator ->() { return &self; }
7969         const LDKCResult_InvoiceErrorDecodeErrorZ* operator &() const { return &self; }
7970         const LDKCResult_InvoiceErrorDecodeErrorZ* operator ->() const { return &self; }
7971 };
7972 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
7973 private:
7974         LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ self;
7975 public:
7976         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(const C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&) = delete;
7977         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
7978         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
7979         operator LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() && { LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return res; }
7980         ~C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); }
7981         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ& operator=(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return *this; }
7982         LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() { return &self; }
7983         LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() { return &self; }
7984         const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() const { return &self; }
7985         const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() const { return &self; }
7986 };
7987 class CResult_RouteParametersDecodeErrorZ {
7988 private:
7989         LDKCResult_RouteParametersDecodeErrorZ self;
7990 public:
7991         CResult_RouteParametersDecodeErrorZ(const CResult_RouteParametersDecodeErrorZ&) = delete;
7992         CResult_RouteParametersDecodeErrorZ(CResult_RouteParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); }
7993         CResult_RouteParametersDecodeErrorZ(LDKCResult_RouteParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); }
7994         operator LDKCResult_RouteParametersDecodeErrorZ() && { LDKCResult_RouteParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); return res; }
7995         ~CResult_RouteParametersDecodeErrorZ() { CResult_RouteParametersDecodeErrorZ_free(self); }
7996         CResult_RouteParametersDecodeErrorZ& operator=(CResult_RouteParametersDecodeErrorZ&& o) { CResult_RouteParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); return *this; }
7997         LDKCResult_RouteParametersDecodeErrorZ* operator &() { return &self; }
7998         LDKCResult_RouteParametersDecodeErrorZ* operator ->() { return &self; }
7999         const LDKCResult_RouteParametersDecodeErrorZ* operator &() const { return &self; }
8000         const LDKCResult_RouteParametersDecodeErrorZ* operator ->() const { return &self; }
8001 };
8002 class CResult_PrivateRouteCreationErrorZ {
8003 private:
8004         LDKCResult_PrivateRouteCreationErrorZ self;
8005 public:
8006         CResult_PrivateRouteCreationErrorZ(const CResult_PrivateRouteCreationErrorZ&) = delete;
8007         CResult_PrivateRouteCreationErrorZ(CResult_PrivateRouteCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); }
8008         CResult_PrivateRouteCreationErrorZ(LDKCResult_PrivateRouteCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); }
8009         operator LDKCResult_PrivateRouteCreationErrorZ() && { LDKCResult_PrivateRouteCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); return res; }
8010         ~CResult_PrivateRouteCreationErrorZ() { CResult_PrivateRouteCreationErrorZ_free(self); }
8011         CResult_PrivateRouteCreationErrorZ& operator=(CResult_PrivateRouteCreationErrorZ&& o) { CResult_PrivateRouteCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); return *this; }
8012         LDKCResult_PrivateRouteCreationErrorZ* operator &() { return &self; }
8013         LDKCResult_PrivateRouteCreationErrorZ* operator ->() { return &self; }
8014         const LDKCResult_PrivateRouteCreationErrorZ* operator &() const { return &self; }
8015         const LDKCResult_PrivateRouteCreationErrorZ* operator ->() const { return &self; }
8016 };
8017 class CResult_NodeAliasDecodeErrorZ {
8018 private:
8019         LDKCResult_NodeAliasDecodeErrorZ self;
8020 public:
8021         CResult_NodeAliasDecodeErrorZ(const CResult_NodeAliasDecodeErrorZ&) = delete;
8022         CResult_NodeAliasDecodeErrorZ(CResult_NodeAliasDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); }
8023         CResult_NodeAliasDecodeErrorZ(LDKCResult_NodeAliasDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); }
8024         operator LDKCResult_NodeAliasDecodeErrorZ() && { LDKCResult_NodeAliasDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); return res; }
8025         ~CResult_NodeAliasDecodeErrorZ() { CResult_NodeAliasDecodeErrorZ_free(self); }
8026         CResult_NodeAliasDecodeErrorZ& operator=(CResult_NodeAliasDecodeErrorZ&& o) { CResult_NodeAliasDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); return *this; }
8027         LDKCResult_NodeAliasDecodeErrorZ* operator &() { return &self; }
8028         LDKCResult_NodeAliasDecodeErrorZ* operator ->() { return &self; }
8029         const LDKCResult_NodeAliasDecodeErrorZ* operator &() const { return &self; }
8030         const LDKCResult_NodeAliasDecodeErrorZ* operator ->() const { return &self; }
8031 };
8032 class CVec_UpdateFulfillHTLCZ {
8033 private:
8034         LDKCVec_UpdateFulfillHTLCZ self;
8035 public:
8036         CVec_UpdateFulfillHTLCZ(const CVec_UpdateFulfillHTLCZ&) = delete;
8037         CVec_UpdateFulfillHTLCZ(CVec_UpdateFulfillHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); }
8038         CVec_UpdateFulfillHTLCZ(LDKCVec_UpdateFulfillHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); }
8039         operator LDKCVec_UpdateFulfillHTLCZ() && { LDKCVec_UpdateFulfillHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); return res; }
8040         ~CVec_UpdateFulfillHTLCZ() { CVec_UpdateFulfillHTLCZ_free(self); }
8041         CVec_UpdateFulfillHTLCZ& operator=(CVec_UpdateFulfillHTLCZ&& o) { CVec_UpdateFulfillHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); return *this; }
8042         LDKCVec_UpdateFulfillHTLCZ* operator &() { return &self; }
8043         LDKCVec_UpdateFulfillHTLCZ* operator ->() { return &self; }
8044         const LDKCVec_UpdateFulfillHTLCZ* operator &() const { return &self; }
8045         const LDKCVec_UpdateFulfillHTLCZ* operator ->() const { return &self; }
8046 };
8047 class CVec_C2Tuple_u32CVec_u8ZZZ {
8048 private:
8049         LDKCVec_C2Tuple_u32CVec_u8ZZZ self;
8050 public:
8051         CVec_C2Tuple_u32CVec_u8ZZZ(const CVec_C2Tuple_u32CVec_u8ZZZ&) = delete;
8052         CVec_C2Tuple_u32CVec_u8ZZZ(CVec_C2Tuple_u32CVec_u8ZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32CVec_u8ZZZ)); }
8053         CVec_C2Tuple_u32CVec_u8ZZZ(LDKCVec_C2Tuple_u32CVec_u8ZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32CVec_u8ZZZ)); }
8054         operator LDKCVec_C2Tuple_u32CVec_u8ZZZ() && { LDKCVec_C2Tuple_u32CVec_u8ZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32CVec_u8ZZZ)); return res; }
8055         ~CVec_C2Tuple_u32CVec_u8ZZZ() { CVec_C2Tuple_u32CVec_u8ZZZ_free(self); }
8056         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; }
8057         LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator &() { return &self; }
8058         LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator ->() { return &self; }
8059         const LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator &() const { return &self; }
8060         const LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator ->() const { return &self; }
8061 };
8062 class CResult_AnnouncementSignaturesDecodeErrorZ {
8063 private:
8064         LDKCResult_AnnouncementSignaturesDecodeErrorZ self;
8065 public:
8066         CResult_AnnouncementSignaturesDecodeErrorZ(const CResult_AnnouncementSignaturesDecodeErrorZ&) = delete;
8067         CResult_AnnouncementSignaturesDecodeErrorZ(CResult_AnnouncementSignaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); }
8068         CResult_AnnouncementSignaturesDecodeErrorZ(LDKCResult_AnnouncementSignaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); }
8069         operator LDKCResult_AnnouncementSignaturesDecodeErrorZ() && { LDKCResult_AnnouncementSignaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); return res; }
8070         ~CResult_AnnouncementSignaturesDecodeErrorZ() { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); }
8071         CResult_AnnouncementSignaturesDecodeErrorZ& operator=(CResult_AnnouncementSignaturesDecodeErrorZ&& o) { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); return *this; }
8072         LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() { return &self; }
8073         LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() { return &self; }
8074         const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() const { return &self; }
8075         const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() const { return &self; }
8076 };
8077 class CResult_UpdateFulfillHTLCDecodeErrorZ {
8078 private:
8079         LDKCResult_UpdateFulfillHTLCDecodeErrorZ self;
8080 public:
8081         CResult_UpdateFulfillHTLCDecodeErrorZ(const CResult_UpdateFulfillHTLCDecodeErrorZ&) = delete;
8082         CResult_UpdateFulfillHTLCDecodeErrorZ(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); }
8083         CResult_UpdateFulfillHTLCDecodeErrorZ(LDKCResult_UpdateFulfillHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); }
8084         operator LDKCResult_UpdateFulfillHTLCDecodeErrorZ() && { LDKCResult_UpdateFulfillHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); return res; }
8085         ~CResult_UpdateFulfillHTLCDecodeErrorZ() { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); }
8086         CResult_UpdateFulfillHTLCDecodeErrorZ& operator=(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); return *this; }
8087         LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() { return &self; }
8088         LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() { return &self; }
8089         const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() const { return &self; }
8090         const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() const { return &self; }
8091 };
8092 class CResult_TxCompleteDecodeErrorZ {
8093 private:
8094         LDKCResult_TxCompleteDecodeErrorZ self;
8095 public:
8096         CResult_TxCompleteDecodeErrorZ(const CResult_TxCompleteDecodeErrorZ&) = delete;
8097         CResult_TxCompleteDecodeErrorZ(CResult_TxCompleteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCompleteDecodeErrorZ)); }
8098         CResult_TxCompleteDecodeErrorZ(LDKCResult_TxCompleteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCompleteDecodeErrorZ)); }
8099         operator LDKCResult_TxCompleteDecodeErrorZ() && { LDKCResult_TxCompleteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCompleteDecodeErrorZ)); return res; }
8100         ~CResult_TxCompleteDecodeErrorZ() { CResult_TxCompleteDecodeErrorZ_free(self); }
8101         CResult_TxCompleteDecodeErrorZ& operator=(CResult_TxCompleteDecodeErrorZ&& o) { CResult_TxCompleteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCompleteDecodeErrorZ)); return *this; }
8102         LDKCResult_TxCompleteDecodeErrorZ* operator &() { return &self; }
8103         LDKCResult_TxCompleteDecodeErrorZ* operator ->() { return &self; }
8104         const LDKCResult_TxCompleteDecodeErrorZ* operator &() const { return &self; }
8105         const LDKCResult_TxCompleteDecodeErrorZ* operator ->() const { return &self; }
8106 };
8107 class CResult_StrSecp256k1ErrorZ {
8108 private:
8109         LDKCResult_StrSecp256k1ErrorZ self;
8110 public:
8111         CResult_StrSecp256k1ErrorZ(const CResult_StrSecp256k1ErrorZ&) = delete;
8112         CResult_StrSecp256k1ErrorZ(CResult_StrSecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StrSecp256k1ErrorZ)); }
8113         CResult_StrSecp256k1ErrorZ(LDKCResult_StrSecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StrSecp256k1ErrorZ)); }
8114         operator LDKCResult_StrSecp256k1ErrorZ() && { LDKCResult_StrSecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StrSecp256k1ErrorZ)); return res; }
8115         ~CResult_StrSecp256k1ErrorZ() { CResult_StrSecp256k1ErrorZ_free(self); }
8116         CResult_StrSecp256k1ErrorZ& operator=(CResult_StrSecp256k1ErrorZ&& o) { CResult_StrSecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StrSecp256k1ErrorZ)); return *this; }
8117         LDKCResult_StrSecp256k1ErrorZ* operator &() { return &self; }
8118         LDKCResult_StrSecp256k1ErrorZ* operator ->() { return &self; }
8119         const LDKCResult_StrSecp256k1ErrorZ* operator &() const { return &self; }
8120         const LDKCResult_StrSecp256k1ErrorZ* operator ->() const { return &self; }
8121 };
8122 class CResult_NodeFeaturesDecodeErrorZ {
8123 private:
8124         LDKCResult_NodeFeaturesDecodeErrorZ self;
8125 public:
8126         CResult_NodeFeaturesDecodeErrorZ(const CResult_NodeFeaturesDecodeErrorZ&) = delete;
8127         CResult_NodeFeaturesDecodeErrorZ(CResult_NodeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); }
8128         CResult_NodeFeaturesDecodeErrorZ(LDKCResult_NodeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); }
8129         operator LDKCResult_NodeFeaturesDecodeErrorZ() && { LDKCResult_NodeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); return res; }
8130         ~CResult_NodeFeaturesDecodeErrorZ() { CResult_NodeFeaturesDecodeErrorZ_free(self); }
8131         CResult_NodeFeaturesDecodeErrorZ& operator=(CResult_NodeFeaturesDecodeErrorZ&& o) { CResult_NodeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); return *this; }
8132         LDKCResult_NodeFeaturesDecodeErrorZ* operator &() { return &self; }
8133         LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() { return &self; }
8134         const LDKCResult_NodeFeaturesDecodeErrorZ* operator &() const { return &self; }
8135         const LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() const { return &self; }
8136 };
8137 class CResult_InMemorySignerDecodeErrorZ {
8138 private:
8139         LDKCResult_InMemorySignerDecodeErrorZ self;
8140 public:
8141         CResult_InMemorySignerDecodeErrorZ(const CResult_InMemorySignerDecodeErrorZ&) = delete;
8142         CResult_InMemorySignerDecodeErrorZ(CResult_InMemorySignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); }
8143         CResult_InMemorySignerDecodeErrorZ(LDKCResult_InMemorySignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); }
8144         operator LDKCResult_InMemorySignerDecodeErrorZ() && { LDKCResult_InMemorySignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); return res; }
8145         ~CResult_InMemorySignerDecodeErrorZ() { CResult_InMemorySignerDecodeErrorZ_free(self); }
8146         CResult_InMemorySignerDecodeErrorZ& operator=(CResult_InMemorySignerDecodeErrorZ&& o) { CResult_InMemorySignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); return *this; }
8147         LDKCResult_InMemorySignerDecodeErrorZ* operator &() { return &self; }
8148         LDKCResult_InMemorySignerDecodeErrorZ* operator ->() { return &self; }
8149         const LDKCResult_InMemorySignerDecodeErrorZ* operator &() const { return &self; }
8150         const LDKCResult_InMemorySignerDecodeErrorZ* operator ->() const { return &self; }
8151 };
8152 class CResult_TxSignaturesDecodeErrorZ {
8153 private:
8154         LDKCResult_TxSignaturesDecodeErrorZ self;
8155 public:
8156         CResult_TxSignaturesDecodeErrorZ(const CResult_TxSignaturesDecodeErrorZ&) = delete;
8157         CResult_TxSignaturesDecodeErrorZ(CResult_TxSignaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxSignaturesDecodeErrorZ)); }
8158         CResult_TxSignaturesDecodeErrorZ(LDKCResult_TxSignaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxSignaturesDecodeErrorZ)); }
8159         operator LDKCResult_TxSignaturesDecodeErrorZ() && { LDKCResult_TxSignaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxSignaturesDecodeErrorZ)); return res; }
8160         ~CResult_TxSignaturesDecodeErrorZ() { CResult_TxSignaturesDecodeErrorZ_free(self); }
8161         CResult_TxSignaturesDecodeErrorZ& operator=(CResult_TxSignaturesDecodeErrorZ&& o) { CResult_TxSignaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxSignaturesDecodeErrorZ)); return *this; }
8162         LDKCResult_TxSignaturesDecodeErrorZ* operator &() { return &self; }
8163         LDKCResult_TxSignaturesDecodeErrorZ* operator ->() { return &self; }
8164         const LDKCResult_TxSignaturesDecodeErrorZ* operator &() const { return &self; }
8165         const LDKCResult_TxSignaturesDecodeErrorZ* operator ->() const { return &self; }
8166 };
8167 class CVec_HTLCDescriptorZ {
8168 private:
8169         LDKCVec_HTLCDescriptorZ self;
8170 public:
8171         CVec_HTLCDescriptorZ(const CVec_HTLCDescriptorZ&) = delete;
8172         CVec_HTLCDescriptorZ(CVec_HTLCDescriptorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_HTLCDescriptorZ)); }
8173         CVec_HTLCDescriptorZ(LDKCVec_HTLCDescriptorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_HTLCDescriptorZ)); }
8174         operator LDKCVec_HTLCDescriptorZ() && { LDKCVec_HTLCDescriptorZ res = self; memset(&self, 0, sizeof(LDKCVec_HTLCDescriptorZ)); return res; }
8175         ~CVec_HTLCDescriptorZ() { CVec_HTLCDescriptorZ_free(self); }
8176         CVec_HTLCDescriptorZ& operator=(CVec_HTLCDescriptorZ&& o) { CVec_HTLCDescriptorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_HTLCDescriptorZ)); return *this; }
8177         LDKCVec_HTLCDescriptorZ* operator &() { return &self; }
8178         LDKCVec_HTLCDescriptorZ* operator ->() { return &self; }
8179         const LDKCVec_HTLCDescriptorZ* operator &() const { return &self; }
8180         const LDKCVec_HTLCDescriptorZ* operator ->() const { return &self; }
8181 };
8182 class CResult_ReplyShortChannelIdsEndDecodeErrorZ {
8183 private:
8184         LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ self;
8185 public:
8186         CResult_ReplyShortChannelIdsEndDecodeErrorZ(const CResult_ReplyShortChannelIdsEndDecodeErrorZ&) = delete;
8187         CResult_ReplyShortChannelIdsEndDecodeErrorZ(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
8188         CResult_ReplyShortChannelIdsEndDecodeErrorZ(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
8189         operator LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ() && { LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); return res; }
8190         ~CResult_ReplyShortChannelIdsEndDecodeErrorZ() { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); }
8191         CResult_ReplyShortChannelIdsEndDecodeErrorZ& operator=(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); return *this; }
8192         LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() { return &self; }
8193         LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() { return &self; }
8194         const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() const { return &self; }
8195         const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() const { return &self; }
8196 };
8197 class COption_PathFailureZ {
8198 private:
8199         LDKCOption_PathFailureZ self;
8200 public:
8201         COption_PathFailureZ(const COption_PathFailureZ&) = delete;
8202         COption_PathFailureZ(COption_PathFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_PathFailureZ)); }
8203         COption_PathFailureZ(LDKCOption_PathFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_PathFailureZ)); }
8204         operator LDKCOption_PathFailureZ() && { LDKCOption_PathFailureZ res = self; memset(&self, 0, sizeof(LDKCOption_PathFailureZ)); return res; }
8205         ~COption_PathFailureZ() { COption_PathFailureZ_free(self); }
8206         COption_PathFailureZ& operator=(COption_PathFailureZ&& o) { COption_PathFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_PathFailureZ)); return *this; }
8207         LDKCOption_PathFailureZ* operator &() { return &self; }
8208         LDKCOption_PathFailureZ* operator ->() { return &self; }
8209         const LDKCOption_PathFailureZ* operator &() const { return &self; }
8210         const LDKCOption_PathFailureZ* operator ->() const { return &self; }
8211 };
8212 class CVec_ECDSASignatureZ {
8213 private:
8214         LDKCVec_ECDSASignatureZ self;
8215 public:
8216         CVec_ECDSASignatureZ(const CVec_ECDSASignatureZ&) = delete;
8217         CVec_ECDSASignatureZ(CVec_ECDSASignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ECDSASignatureZ)); }
8218         CVec_ECDSASignatureZ(LDKCVec_ECDSASignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ECDSASignatureZ)); }
8219         operator LDKCVec_ECDSASignatureZ() && { LDKCVec_ECDSASignatureZ res = self; memset(&self, 0, sizeof(LDKCVec_ECDSASignatureZ)); return res; }
8220         ~CVec_ECDSASignatureZ() { CVec_ECDSASignatureZ_free(self); }
8221         CVec_ECDSASignatureZ& operator=(CVec_ECDSASignatureZ&& o) { CVec_ECDSASignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ECDSASignatureZ)); return *this; }
8222         LDKCVec_ECDSASignatureZ* operator &() { return &self; }
8223         LDKCVec_ECDSASignatureZ* operator ->() { return &self; }
8224         const LDKCVec_ECDSASignatureZ* operator &() const { return &self; }
8225         const LDKCVec_ECDSASignatureZ* operator ->() const { return &self; }
8226 };
8227 class CResult_ChannelUpdateInfoDecodeErrorZ {
8228 private:
8229         LDKCResult_ChannelUpdateInfoDecodeErrorZ self;
8230 public:
8231         CResult_ChannelUpdateInfoDecodeErrorZ(const CResult_ChannelUpdateInfoDecodeErrorZ&) = delete;
8232         CResult_ChannelUpdateInfoDecodeErrorZ(CResult_ChannelUpdateInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); }
8233         CResult_ChannelUpdateInfoDecodeErrorZ(LDKCResult_ChannelUpdateInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); }
8234         operator LDKCResult_ChannelUpdateInfoDecodeErrorZ() && { LDKCResult_ChannelUpdateInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); return res; }
8235         ~CResult_ChannelUpdateInfoDecodeErrorZ() { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); }
8236         CResult_ChannelUpdateInfoDecodeErrorZ& operator=(CResult_ChannelUpdateInfoDecodeErrorZ&& o) { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); return *this; }
8237         LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() { return &self; }
8238         LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() { return &self; }
8239         const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() const { return &self; }
8240         const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() const { return &self; }
8241 };
8242 class CVec_UpdateFailHTLCZ {
8243 private:
8244         LDKCVec_UpdateFailHTLCZ self;
8245 public:
8246         CVec_UpdateFailHTLCZ(const CVec_UpdateFailHTLCZ&) = delete;
8247         CVec_UpdateFailHTLCZ(CVec_UpdateFailHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); }
8248         CVec_UpdateFailHTLCZ(LDKCVec_UpdateFailHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); }
8249         operator LDKCVec_UpdateFailHTLCZ() && { LDKCVec_UpdateFailHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); return res; }
8250         ~CVec_UpdateFailHTLCZ() { CVec_UpdateFailHTLCZ_free(self); }
8251         CVec_UpdateFailHTLCZ& operator=(CVec_UpdateFailHTLCZ&& o) { CVec_UpdateFailHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); return *this; }
8252         LDKCVec_UpdateFailHTLCZ* operator &() { return &self; }
8253         LDKCVec_UpdateFailHTLCZ* operator ->() { return &self; }
8254         const LDKCVec_UpdateFailHTLCZ* operator &() const { return &self; }
8255         const LDKCVec_UpdateFailHTLCZ* operator ->() const { return &self; }
8256 };
8257 class CVec_TxOutZ {
8258 private:
8259         LDKCVec_TxOutZ self;
8260 public:
8261         CVec_TxOutZ(const CVec_TxOutZ&) = delete;
8262         CVec_TxOutZ(CVec_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TxOutZ)); }
8263         CVec_TxOutZ(LDKCVec_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TxOutZ)); }
8264         operator LDKCVec_TxOutZ() && { LDKCVec_TxOutZ res = self; memset(&self, 0, sizeof(LDKCVec_TxOutZ)); return res; }
8265         ~CVec_TxOutZ() { CVec_TxOutZ_free(self); }
8266         CVec_TxOutZ& operator=(CVec_TxOutZ&& o) { CVec_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TxOutZ)); return *this; }
8267         LDKCVec_TxOutZ* operator &() { return &self; }
8268         LDKCVec_TxOutZ* operator ->() { return &self; }
8269         const LDKCVec_TxOutZ* operator &() const { return &self; }
8270         const LDKCVec_TxOutZ* operator ->() const { return &self; }
8271 };
8272 class CResult_BuiltCommitmentTransactionDecodeErrorZ {
8273 private:
8274         LDKCResult_BuiltCommitmentTransactionDecodeErrorZ self;
8275 public:
8276         CResult_BuiltCommitmentTransactionDecodeErrorZ(const CResult_BuiltCommitmentTransactionDecodeErrorZ&) = delete;
8277         CResult_BuiltCommitmentTransactionDecodeErrorZ(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); }
8278         CResult_BuiltCommitmentTransactionDecodeErrorZ(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); }
8279         operator LDKCResult_BuiltCommitmentTransactionDecodeErrorZ() && { LDKCResult_BuiltCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); return res; }
8280         ~CResult_BuiltCommitmentTransactionDecodeErrorZ() { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); }
8281         CResult_BuiltCommitmentTransactionDecodeErrorZ& operator=(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); return *this; }
8282         LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
8283         LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
8284         const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
8285         const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
8286 };
8287 class CVec_SpendableOutputDescriptorZ {
8288 private:
8289         LDKCVec_SpendableOutputDescriptorZ self;
8290 public:
8291         CVec_SpendableOutputDescriptorZ(const CVec_SpendableOutputDescriptorZ&) = delete;
8292         CVec_SpendableOutputDescriptorZ(CVec_SpendableOutputDescriptorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SpendableOutputDescriptorZ)); }
8293         CVec_SpendableOutputDescriptorZ(LDKCVec_SpendableOutputDescriptorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SpendableOutputDescriptorZ)); }
8294         operator LDKCVec_SpendableOutputDescriptorZ() && { LDKCVec_SpendableOutputDescriptorZ res = self; memset(&self, 0, sizeof(LDKCVec_SpendableOutputDescriptorZ)); return res; }
8295         ~CVec_SpendableOutputDescriptorZ() { CVec_SpendableOutputDescriptorZ_free(self); }
8296         CVec_SpendableOutputDescriptorZ& operator=(CVec_SpendableOutputDescriptorZ&& o) { CVec_SpendableOutputDescriptorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_SpendableOutputDescriptorZ)); return *this; }
8297         LDKCVec_SpendableOutputDescriptorZ* operator &() { return &self; }
8298         LDKCVec_SpendableOutputDescriptorZ* operator ->() { return &self; }
8299         const LDKCVec_SpendableOutputDescriptorZ* operator &() const { return &self; }
8300         const LDKCVec_SpendableOutputDescriptorZ* operator ->() const { return &self; }
8301 };
8302 class C2Tuple_OutPointCVec_u8ZZ {
8303 private:
8304         LDKC2Tuple_OutPointCVec_u8ZZ self;
8305 public:
8306         C2Tuple_OutPointCVec_u8ZZ(const C2Tuple_OutPointCVec_u8ZZ&) = delete;
8307         C2Tuple_OutPointCVec_u8ZZ(C2Tuple_OutPointCVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointCVec_u8ZZ)); }
8308         C2Tuple_OutPointCVec_u8ZZ(LDKC2Tuple_OutPointCVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointCVec_u8ZZ)); }
8309         operator LDKC2Tuple_OutPointCVec_u8ZZ() && { LDKC2Tuple_OutPointCVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointCVec_u8ZZ)); return res; }
8310         ~C2Tuple_OutPointCVec_u8ZZ() { C2Tuple_OutPointCVec_u8ZZ_free(self); }
8311         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; }
8312         LDKC2Tuple_OutPointCVec_u8ZZ* operator &() { return &self; }
8313         LDKC2Tuple_OutPointCVec_u8ZZ* operator ->() { return &self; }
8314         const LDKC2Tuple_OutPointCVec_u8ZZ* operator &() const { return &self; }
8315         const LDKC2Tuple_OutPointCVec_u8ZZ* operator ->() const { return &self; }
8316 };
8317 class COption_C2Tuple_u64u64ZZ {
8318 private:
8319         LDKCOption_C2Tuple_u64u64ZZ self;
8320 public:
8321         COption_C2Tuple_u64u64ZZ(const COption_C2Tuple_u64u64ZZ&) = delete;
8322         COption_C2Tuple_u64u64ZZ(COption_C2Tuple_u64u64ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_u64u64ZZ)); }
8323         COption_C2Tuple_u64u64ZZ(LDKCOption_C2Tuple_u64u64ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_u64u64ZZ)); }
8324         operator LDKCOption_C2Tuple_u64u64ZZ() && { LDKCOption_C2Tuple_u64u64ZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_u64u64ZZ)); return res; }
8325         ~COption_C2Tuple_u64u64ZZ() { COption_C2Tuple_u64u64ZZ_free(self); }
8326         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; }
8327         LDKCOption_C2Tuple_u64u64ZZ* operator &() { return &self; }
8328         LDKCOption_C2Tuple_u64u64ZZ* operator ->() { return &self; }
8329         const LDKCOption_C2Tuple_u64u64ZZ* operator &() const { return &self; }
8330         const LDKCOption_C2Tuple_u64u64ZZ* operator ->() const { return &self; }
8331 };
8332 class CResult_ChannelAnnouncementDecodeErrorZ {
8333 private:
8334         LDKCResult_ChannelAnnouncementDecodeErrorZ self;
8335 public:
8336         CResult_ChannelAnnouncementDecodeErrorZ(const CResult_ChannelAnnouncementDecodeErrorZ&) = delete;
8337         CResult_ChannelAnnouncementDecodeErrorZ(CResult_ChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); }
8338         CResult_ChannelAnnouncementDecodeErrorZ(LDKCResult_ChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); }
8339         operator LDKCResult_ChannelAnnouncementDecodeErrorZ() && { LDKCResult_ChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); return res; }
8340         ~CResult_ChannelAnnouncementDecodeErrorZ() { CResult_ChannelAnnouncementDecodeErrorZ_free(self); }
8341         CResult_ChannelAnnouncementDecodeErrorZ& operator=(CResult_ChannelAnnouncementDecodeErrorZ&& o) { CResult_ChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); return *this; }
8342         LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
8343         LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
8344         const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
8345         const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
8346 };
8347 class CResult_HTLCUpdateDecodeErrorZ {
8348 private:
8349         LDKCResult_HTLCUpdateDecodeErrorZ self;
8350 public:
8351         CResult_HTLCUpdateDecodeErrorZ(const CResult_HTLCUpdateDecodeErrorZ&) = delete;
8352         CResult_HTLCUpdateDecodeErrorZ(CResult_HTLCUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCUpdateDecodeErrorZ)); }
8353         CResult_HTLCUpdateDecodeErrorZ(LDKCResult_HTLCUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCUpdateDecodeErrorZ)); }
8354         operator LDKCResult_HTLCUpdateDecodeErrorZ() && { LDKCResult_HTLCUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCUpdateDecodeErrorZ)); return res; }
8355         ~CResult_HTLCUpdateDecodeErrorZ() { CResult_HTLCUpdateDecodeErrorZ_free(self); }
8356         CResult_HTLCUpdateDecodeErrorZ& operator=(CResult_HTLCUpdateDecodeErrorZ&& o) { CResult_HTLCUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCUpdateDecodeErrorZ)); return *this; }
8357         LDKCResult_HTLCUpdateDecodeErrorZ* operator &() { return &self; }
8358         LDKCResult_HTLCUpdateDecodeErrorZ* operator ->() { return &self; }
8359         const LDKCResult_HTLCUpdateDecodeErrorZ* operator &() const { return &self; }
8360         const LDKCResult_HTLCUpdateDecodeErrorZ* operator ->() const { return &self; }
8361 };
8362 class CResult_TxAddInputDecodeErrorZ {
8363 private:
8364         LDKCResult_TxAddInputDecodeErrorZ self;
8365 public:
8366         CResult_TxAddInputDecodeErrorZ(const CResult_TxAddInputDecodeErrorZ&) = delete;
8367         CResult_TxAddInputDecodeErrorZ(CResult_TxAddInputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAddInputDecodeErrorZ)); }
8368         CResult_TxAddInputDecodeErrorZ(LDKCResult_TxAddInputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAddInputDecodeErrorZ)); }
8369         operator LDKCResult_TxAddInputDecodeErrorZ() && { LDKCResult_TxAddInputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAddInputDecodeErrorZ)); return res; }
8370         ~CResult_TxAddInputDecodeErrorZ() { CResult_TxAddInputDecodeErrorZ_free(self); }
8371         CResult_TxAddInputDecodeErrorZ& operator=(CResult_TxAddInputDecodeErrorZ&& o) { CResult_TxAddInputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAddInputDecodeErrorZ)); return *this; }
8372         LDKCResult_TxAddInputDecodeErrorZ* operator &() { return &self; }
8373         LDKCResult_TxAddInputDecodeErrorZ* operator ->() { return &self; }
8374         const LDKCResult_TxAddInputDecodeErrorZ* operator &() const { return &self; }
8375         const LDKCResult_TxAddInputDecodeErrorZ* operator ->() const { return &self; }
8376 };
8377 class CVec_OutPointZ {
8378 private:
8379         LDKCVec_OutPointZ self;
8380 public:
8381         CVec_OutPointZ(const CVec_OutPointZ&) = delete;
8382         CVec_OutPointZ(CVec_OutPointZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_OutPointZ)); }
8383         CVec_OutPointZ(LDKCVec_OutPointZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_OutPointZ)); }
8384         operator LDKCVec_OutPointZ() && { LDKCVec_OutPointZ res = self; memset(&self, 0, sizeof(LDKCVec_OutPointZ)); return res; }
8385         ~CVec_OutPointZ() { CVec_OutPointZ_free(self); }
8386         CVec_OutPointZ& operator=(CVec_OutPointZ&& o) { CVec_OutPointZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_OutPointZ)); return *this; }
8387         LDKCVec_OutPointZ* operator &() { return &self; }
8388         LDKCVec_OutPointZ* operator ->() { return &self; }
8389         const LDKCVec_OutPointZ* operator &() const { return &self; }
8390         const LDKCVec_OutPointZ* operator ->() const { return &self; }
8391 };
8392 class CResult_TxInitRbfDecodeErrorZ {
8393 private:
8394         LDKCResult_TxInitRbfDecodeErrorZ self;
8395 public:
8396         CResult_TxInitRbfDecodeErrorZ(const CResult_TxInitRbfDecodeErrorZ&) = delete;
8397         CResult_TxInitRbfDecodeErrorZ(CResult_TxInitRbfDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxInitRbfDecodeErrorZ)); }
8398         CResult_TxInitRbfDecodeErrorZ(LDKCResult_TxInitRbfDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxInitRbfDecodeErrorZ)); }
8399         operator LDKCResult_TxInitRbfDecodeErrorZ() && { LDKCResult_TxInitRbfDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxInitRbfDecodeErrorZ)); return res; }
8400         ~CResult_TxInitRbfDecodeErrorZ() { CResult_TxInitRbfDecodeErrorZ_free(self); }
8401         CResult_TxInitRbfDecodeErrorZ& operator=(CResult_TxInitRbfDecodeErrorZ&& o) { CResult_TxInitRbfDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxInitRbfDecodeErrorZ)); return *this; }
8402         LDKCResult_TxInitRbfDecodeErrorZ* operator &() { return &self; }
8403         LDKCResult_TxInitRbfDecodeErrorZ* operator ->() { return &self; }
8404         const LDKCResult_TxInitRbfDecodeErrorZ* operator &() const { return &self; }
8405         const LDKCResult_TxInitRbfDecodeErrorZ* operator ->() const { return &self; }
8406 };
8407 class COption_WriteableScoreZ {
8408 private:
8409         LDKCOption_WriteableScoreZ self;
8410 public:
8411         COption_WriteableScoreZ(const COption_WriteableScoreZ&) = delete;
8412         COption_WriteableScoreZ(COption_WriteableScoreZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_WriteableScoreZ)); }
8413         COption_WriteableScoreZ(LDKCOption_WriteableScoreZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_WriteableScoreZ)); }
8414         operator LDKCOption_WriteableScoreZ() && { LDKCOption_WriteableScoreZ res = self; memset(&self, 0, sizeof(LDKCOption_WriteableScoreZ)); return res; }
8415         ~COption_WriteableScoreZ() { COption_WriteableScoreZ_free(self); }
8416         COption_WriteableScoreZ& operator=(COption_WriteableScoreZ&& o) { COption_WriteableScoreZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_WriteableScoreZ)); return *this; }
8417         LDKCOption_WriteableScoreZ* operator &() { return &self; }
8418         LDKCOption_WriteableScoreZ* operator ->() { return &self; }
8419         const LDKCOption_WriteableScoreZ* operator &() const { return &self; }
8420         const LDKCOption_WriteableScoreZ* operator ->() const { return &self; }
8421 };
8422 class CVec_StrZ {
8423 private:
8424         LDKCVec_StrZ self;
8425 public:
8426         CVec_StrZ(const CVec_StrZ&) = delete;
8427         CVec_StrZ(CVec_StrZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_StrZ)); }
8428         CVec_StrZ(LDKCVec_StrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_StrZ)); }
8429         operator LDKCVec_StrZ() && { LDKCVec_StrZ res = self; memset(&self, 0, sizeof(LDKCVec_StrZ)); return res; }
8430         ~CVec_StrZ() { CVec_StrZ_free(self); }
8431         CVec_StrZ& operator=(CVec_StrZ&& o) { CVec_StrZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_StrZ)); return *this; }
8432         LDKCVec_StrZ* operator &() { return &self; }
8433         LDKCVec_StrZ* operator ->() { return &self; }
8434         const LDKCVec_StrZ* operator &() const { return &self; }
8435         const LDKCVec_StrZ* operator ->() const { return &self; }
8436 };
8437 class CResult_PositiveTimestampCreationErrorZ {
8438 private:
8439         LDKCResult_PositiveTimestampCreationErrorZ self;
8440 public:
8441         CResult_PositiveTimestampCreationErrorZ(const CResult_PositiveTimestampCreationErrorZ&) = delete;
8442         CResult_PositiveTimestampCreationErrorZ(CResult_PositiveTimestampCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PositiveTimestampCreationErrorZ)); }
8443         CResult_PositiveTimestampCreationErrorZ(LDKCResult_PositiveTimestampCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PositiveTimestampCreationErrorZ)); }
8444         operator LDKCResult_PositiveTimestampCreationErrorZ() && { LDKCResult_PositiveTimestampCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PositiveTimestampCreationErrorZ)); return res; }
8445         ~CResult_PositiveTimestampCreationErrorZ() { CResult_PositiveTimestampCreationErrorZ_free(self); }
8446         CResult_PositiveTimestampCreationErrorZ& operator=(CResult_PositiveTimestampCreationErrorZ&& o) { CResult_PositiveTimestampCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PositiveTimestampCreationErrorZ)); return *this; }
8447         LDKCResult_PositiveTimestampCreationErrorZ* operator &() { return &self; }
8448         LDKCResult_PositiveTimestampCreationErrorZ* operator ->() { return &self; }
8449         const LDKCResult_PositiveTimestampCreationErrorZ* operator &() const { return &self; }
8450         const LDKCResult_PositiveTimestampCreationErrorZ* operator ->() const { return &self; }
8451 };
8452 class CResult_ChannelMonitorUpdateDecodeErrorZ {
8453 private:
8454         LDKCResult_ChannelMonitorUpdateDecodeErrorZ self;
8455 public:
8456         CResult_ChannelMonitorUpdateDecodeErrorZ(const CResult_ChannelMonitorUpdateDecodeErrorZ&) = delete;
8457         CResult_ChannelMonitorUpdateDecodeErrorZ(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); }
8458         CResult_ChannelMonitorUpdateDecodeErrorZ(LDKCResult_ChannelMonitorUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); }
8459         operator LDKCResult_ChannelMonitorUpdateDecodeErrorZ() && { LDKCResult_ChannelMonitorUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); return res; }
8460         ~CResult_ChannelMonitorUpdateDecodeErrorZ() { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); }
8461         CResult_ChannelMonitorUpdateDecodeErrorZ& operator=(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); return *this; }
8462         LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() { return &self; }
8463         LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() { return &self; }
8464         const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() const { return &self; }
8465         const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() const { return &self; }
8466 };
8467 class C2Tuple_BlindedPayInfoBlindedPathZ {
8468 private:
8469         LDKC2Tuple_BlindedPayInfoBlindedPathZ self;
8470 public:
8471         C2Tuple_BlindedPayInfoBlindedPathZ(const C2Tuple_BlindedPayInfoBlindedPathZ&) = delete;
8472         C2Tuple_BlindedPayInfoBlindedPathZ(C2Tuple_BlindedPayInfoBlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BlindedPayInfoBlindedPathZ)); }
8473         C2Tuple_BlindedPayInfoBlindedPathZ(LDKC2Tuple_BlindedPayInfoBlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ)); }
8474         operator LDKC2Tuple_BlindedPayInfoBlindedPathZ() && { LDKC2Tuple_BlindedPayInfoBlindedPathZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ)); return res; }
8475         ~C2Tuple_BlindedPayInfoBlindedPathZ() { C2Tuple_BlindedPayInfoBlindedPathZ_free(self); }
8476         C2Tuple_BlindedPayInfoBlindedPathZ& operator=(C2Tuple_BlindedPayInfoBlindedPathZ&& o) { C2Tuple_BlindedPayInfoBlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BlindedPayInfoBlindedPathZ)); return *this; }
8477         LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator &() { return &self; }
8478         LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator ->() { return &self; }
8479         const LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator &() const { return &self; }
8480         const LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator ->() const { return &self; }
8481 };
8482 class CResult_ReplyChannelRangeDecodeErrorZ {
8483 private:
8484         LDKCResult_ReplyChannelRangeDecodeErrorZ self;
8485 public:
8486         CResult_ReplyChannelRangeDecodeErrorZ(const CResult_ReplyChannelRangeDecodeErrorZ&) = delete;
8487         CResult_ReplyChannelRangeDecodeErrorZ(CResult_ReplyChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); }
8488         CResult_ReplyChannelRangeDecodeErrorZ(LDKCResult_ReplyChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); }
8489         operator LDKCResult_ReplyChannelRangeDecodeErrorZ() && { LDKCResult_ReplyChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); return res; }
8490         ~CResult_ReplyChannelRangeDecodeErrorZ() { CResult_ReplyChannelRangeDecodeErrorZ_free(self); }
8491         CResult_ReplyChannelRangeDecodeErrorZ& operator=(CResult_ReplyChannelRangeDecodeErrorZ&& o) { CResult_ReplyChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); return *this; }
8492         LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() { return &self; }
8493         LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() { return &self; }
8494         const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() const { return &self; }
8495         const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() const { return &self; }
8496 };
8497 class CResult_UnsignedNodeAnnouncementDecodeErrorZ {
8498 private:
8499         LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ self;
8500 public:
8501         CResult_UnsignedNodeAnnouncementDecodeErrorZ(const CResult_UnsignedNodeAnnouncementDecodeErrorZ&) = delete;
8502         CResult_UnsignedNodeAnnouncementDecodeErrorZ(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
8503         CResult_UnsignedNodeAnnouncementDecodeErrorZ(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
8504         operator LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); return res; }
8505         ~CResult_UnsignedNodeAnnouncementDecodeErrorZ() { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); }
8506         CResult_UnsignedNodeAnnouncementDecodeErrorZ& operator=(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); return *this; }
8507         LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() { return &self; }
8508         LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
8509         const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
8510         const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
8511 };
8512 class CResult_TrustedClosingTransactionNoneZ {
8513 private:
8514         LDKCResult_TrustedClosingTransactionNoneZ self;
8515 public:
8516         CResult_TrustedClosingTransactionNoneZ(const CResult_TrustedClosingTransactionNoneZ&) = delete;
8517         CResult_TrustedClosingTransactionNoneZ(CResult_TrustedClosingTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedClosingTransactionNoneZ)); }
8518         CResult_TrustedClosingTransactionNoneZ(LDKCResult_TrustedClosingTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedClosingTransactionNoneZ)); }
8519         operator LDKCResult_TrustedClosingTransactionNoneZ() && { LDKCResult_TrustedClosingTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedClosingTransactionNoneZ)); return res; }
8520         ~CResult_TrustedClosingTransactionNoneZ() { CResult_TrustedClosingTransactionNoneZ_free(self); }
8521         CResult_TrustedClosingTransactionNoneZ& operator=(CResult_TrustedClosingTransactionNoneZ&& o) { CResult_TrustedClosingTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedClosingTransactionNoneZ)); return *this; }
8522         LDKCResult_TrustedClosingTransactionNoneZ* operator &() { return &self; }
8523         LDKCResult_TrustedClosingTransactionNoneZ* operator ->() { return &self; }
8524         const LDKCResult_TrustedClosingTransactionNoneZ* operator &() const { return &self; }
8525         const LDKCResult_TrustedClosingTransactionNoneZ* operator ->() const { return &self; }
8526 };
8527 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ {
8528 private:
8529         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ self;
8530 public:
8531         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(const CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&) = delete;
8532         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); }
8533         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); }
8534         operator LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); return res; }
8535         ~CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ() { CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(self); }
8536         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; }
8537         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator &() { return &self; }
8538         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator ->() { return &self; }
8539         const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator &() const { return &self; }
8540         const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator ->() const { return &self; }
8541 };
8542 class C2Tuple_PublicKeyTypeZ {
8543 private:
8544         LDKC2Tuple_PublicKeyTypeZ self;
8545 public:
8546         C2Tuple_PublicKeyTypeZ(const C2Tuple_PublicKeyTypeZ&) = delete;
8547         C2Tuple_PublicKeyTypeZ(C2Tuple_PublicKeyTypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyTypeZ)); }
8548         C2Tuple_PublicKeyTypeZ(LDKC2Tuple_PublicKeyTypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyTypeZ)); }
8549         operator LDKC2Tuple_PublicKeyTypeZ() && { LDKC2Tuple_PublicKeyTypeZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyTypeZ)); return res; }
8550         ~C2Tuple_PublicKeyTypeZ() { C2Tuple_PublicKeyTypeZ_free(self); }
8551         C2Tuple_PublicKeyTypeZ& operator=(C2Tuple_PublicKeyTypeZ&& o) { C2Tuple_PublicKeyTypeZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyTypeZ)); return *this; }
8552         LDKC2Tuple_PublicKeyTypeZ* operator &() { return &self; }
8553         LDKC2Tuple_PublicKeyTypeZ* operator ->() { return &self; }
8554         const LDKC2Tuple_PublicKeyTypeZ* operator &() const { return &self; }
8555         const LDKC2Tuple_PublicKeyTypeZ* operator ->() const { return &self; }
8556 };
8557 class CResult_TxRemoveOutputDecodeErrorZ {
8558 private:
8559         LDKCResult_TxRemoveOutputDecodeErrorZ self;
8560 public:
8561         CResult_TxRemoveOutputDecodeErrorZ(const CResult_TxRemoveOutputDecodeErrorZ&) = delete;
8562         CResult_TxRemoveOutputDecodeErrorZ(CResult_TxRemoveOutputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxRemoveOutputDecodeErrorZ)); }
8563         CResult_TxRemoveOutputDecodeErrorZ(LDKCResult_TxRemoveOutputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxRemoveOutputDecodeErrorZ)); }
8564         operator LDKCResult_TxRemoveOutputDecodeErrorZ() && { LDKCResult_TxRemoveOutputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxRemoveOutputDecodeErrorZ)); return res; }
8565         ~CResult_TxRemoveOutputDecodeErrorZ() { CResult_TxRemoveOutputDecodeErrorZ_free(self); }
8566         CResult_TxRemoveOutputDecodeErrorZ& operator=(CResult_TxRemoveOutputDecodeErrorZ&& o) { CResult_TxRemoveOutputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxRemoveOutputDecodeErrorZ)); return *this; }
8567         LDKCResult_TxRemoveOutputDecodeErrorZ* operator &() { return &self; }
8568         LDKCResult_TxRemoveOutputDecodeErrorZ* operator ->() { return &self; }
8569         const LDKCResult_TxRemoveOutputDecodeErrorZ* operator &() const { return &self; }
8570         const LDKCResult_TxRemoveOutputDecodeErrorZ* operator ->() const { return &self; }
8571 };
8572 class CResult_ChannelReestablishDecodeErrorZ {
8573 private:
8574         LDKCResult_ChannelReestablishDecodeErrorZ self;
8575 public:
8576         CResult_ChannelReestablishDecodeErrorZ(const CResult_ChannelReestablishDecodeErrorZ&) = delete;
8577         CResult_ChannelReestablishDecodeErrorZ(CResult_ChannelReestablishDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelReestablishDecodeErrorZ)); }
8578         CResult_ChannelReestablishDecodeErrorZ(LDKCResult_ChannelReestablishDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelReestablishDecodeErrorZ)); }
8579         operator LDKCResult_ChannelReestablishDecodeErrorZ() && { LDKCResult_ChannelReestablishDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelReestablishDecodeErrorZ)); return res; }
8580         ~CResult_ChannelReestablishDecodeErrorZ() { CResult_ChannelReestablishDecodeErrorZ_free(self); }
8581         CResult_ChannelReestablishDecodeErrorZ& operator=(CResult_ChannelReestablishDecodeErrorZ&& o) { CResult_ChannelReestablishDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelReestablishDecodeErrorZ)); return *this; }
8582         LDKCResult_ChannelReestablishDecodeErrorZ* operator &() { return &self; }
8583         LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() { return &self; }
8584         const LDKCResult_ChannelReestablishDecodeErrorZ* operator &() const { return &self; }
8585         const LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() const { return &self; }
8586 };
8587 class CResult_OnionMessageDecodeErrorZ {
8588 private:
8589         LDKCResult_OnionMessageDecodeErrorZ self;
8590 public:
8591         CResult_OnionMessageDecodeErrorZ(const CResult_OnionMessageDecodeErrorZ&) = delete;
8592         CResult_OnionMessageDecodeErrorZ(CResult_OnionMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionMessageDecodeErrorZ)); }
8593         CResult_OnionMessageDecodeErrorZ(LDKCResult_OnionMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionMessageDecodeErrorZ)); }
8594         operator LDKCResult_OnionMessageDecodeErrorZ() && { LDKCResult_OnionMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionMessageDecodeErrorZ)); return res; }
8595         ~CResult_OnionMessageDecodeErrorZ() { CResult_OnionMessageDecodeErrorZ_free(self); }
8596         CResult_OnionMessageDecodeErrorZ& operator=(CResult_OnionMessageDecodeErrorZ&& o) { CResult_OnionMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionMessageDecodeErrorZ)); return *this; }
8597         LDKCResult_OnionMessageDecodeErrorZ* operator &() { return &self; }
8598         LDKCResult_OnionMessageDecodeErrorZ* operator ->() { return &self; }
8599         const LDKCResult_OnionMessageDecodeErrorZ* operator &() const { return &self; }
8600         const LDKCResult_OnionMessageDecodeErrorZ* operator ->() const { return &self; }
8601 };
8602 class CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ {
8603 private:
8604         LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ self;
8605 public:
8606         CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ(const CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ&) = delete;
8607         CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ(CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ)); }
8608         CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ(LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ)); }
8609         operator LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ)); return res; }
8610         ~CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ() { CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_free(self); }
8611         CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ& operator=(CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ&& o) { CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ)); return *this; }
8612         LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ* operator &() { return &self; }
8613         LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ* operator ->() { return &self; }
8614         const LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ* operator &() const { return &self; }
8615         const LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ* operator ->() const { return &self; }
8616 };
8617 class CResult_C2Tuple_CVec_u8ZusizeZNoneZ {
8618 private:
8619         LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ self;
8620 public:
8621         CResult_C2Tuple_CVec_u8ZusizeZNoneZ(const CResult_C2Tuple_CVec_u8ZusizeZNoneZ&) = delete;
8622         CResult_C2Tuple_CVec_u8ZusizeZNoneZ(CResult_C2Tuple_CVec_u8ZusizeZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_CVec_u8ZusizeZNoneZ)); }
8623         CResult_C2Tuple_CVec_u8ZusizeZNoneZ(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ)); }
8624         operator LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ() && { LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ)); return res; }
8625         ~CResult_C2Tuple_CVec_u8ZusizeZNoneZ() { CResult_C2Tuple_CVec_u8ZusizeZNoneZ_free(self); }
8626         CResult_C2Tuple_CVec_u8ZusizeZNoneZ& operator=(CResult_C2Tuple_CVec_u8ZusizeZNoneZ&& o) { CResult_C2Tuple_CVec_u8ZusizeZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_CVec_u8ZusizeZNoneZ)); return *this; }
8627         LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* operator &() { return &self; }
8628         LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* operator ->() { return &self; }
8629         const LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* operator &() const { return &self; }
8630         const LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* operator ->() const { return &self; }
8631 };
8632 class CResult_Bolt11InvoiceParseOrSemanticErrorZ {
8633 private:
8634         LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ self;
8635 public:
8636         CResult_Bolt11InvoiceParseOrSemanticErrorZ(const CResult_Bolt11InvoiceParseOrSemanticErrorZ&) = delete;
8637         CResult_Bolt11InvoiceParseOrSemanticErrorZ(CResult_Bolt11InvoiceParseOrSemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceParseOrSemanticErrorZ)); }
8638         CResult_Bolt11InvoiceParseOrSemanticErrorZ(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ)); }
8639         operator LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ() && { LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ)); return res; }
8640         ~CResult_Bolt11InvoiceParseOrSemanticErrorZ() { CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(self); }
8641         CResult_Bolt11InvoiceParseOrSemanticErrorZ& operator=(CResult_Bolt11InvoiceParseOrSemanticErrorZ&& o) { CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceParseOrSemanticErrorZ)); return *this; }
8642         LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator &() { return &self; }
8643         LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator ->() { return &self; }
8644         const LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator &() const { return &self; }
8645         const LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator ->() const { return &self; }
8646 };
8647 class CResult_InitFeaturesDecodeErrorZ {
8648 private:
8649         LDKCResult_InitFeaturesDecodeErrorZ self;
8650 public:
8651         CResult_InitFeaturesDecodeErrorZ(const CResult_InitFeaturesDecodeErrorZ&) = delete;
8652         CResult_InitFeaturesDecodeErrorZ(CResult_InitFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); }
8653         CResult_InitFeaturesDecodeErrorZ(LDKCResult_InitFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); }
8654         operator LDKCResult_InitFeaturesDecodeErrorZ() && { LDKCResult_InitFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); return res; }
8655         ~CResult_InitFeaturesDecodeErrorZ() { CResult_InitFeaturesDecodeErrorZ_free(self); }
8656         CResult_InitFeaturesDecodeErrorZ& operator=(CResult_InitFeaturesDecodeErrorZ&& o) { CResult_InitFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); return *this; }
8657         LDKCResult_InitFeaturesDecodeErrorZ* operator &() { return &self; }
8658         LDKCResult_InitFeaturesDecodeErrorZ* operator ->() { return &self; }
8659         const LDKCResult_InitFeaturesDecodeErrorZ* operator &() const { return &self; }
8660         const LDKCResult_InitFeaturesDecodeErrorZ* operator ->() const { return &self; }
8661 };
8662 class CResult_PublicKeyNoneZ {
8663 private:
8664         LDKCResult_PublicKeyNoneZ self;
8665 public:
8666         CResult_PublicKeyNoneZ(const CResult_PublicKeyNoneZ&) = delete;
8667         CResult_PublicKeyNoneZ(CResult_PublicKeyNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PublicKeyNoneZ)); }
8668         CResult_PublicKeyNoneZ(LDKCResult_PublicKeyNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PublicKeyNoneZ)); }
8669         operator LDKCResult_PublicKeyNoneZ() && { LDKCResult_PublicKeyNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_PublicKeyNoneZ)); return res; }
8670         ~CResult_PublicKeyNoneZ() { CResult_PublicKeyNoneZ_free(self); }
8671         CResult_PublicKeyNoneZ& operator=(CResult_PublicKeyNoneZ&& o) { CResult_PublicKeyNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PublicKeyNoneZ)); return *this; }
8672         LDKCResult_PublicKeyNoneZ* operator &() { return &self; }
8673         LDKCResult_PublicKeyNoneZ* operator ->() { return &self; }
8674         const LDKCResult_PublicKeyNoneZ* operator &() const { return &self; }
8675         const LDKCResult_PublicKeyNoneZ* operator ->() const { return &self; }
8676 };
8677 class CResult_PingDecodeErrorZ {
8678 private:
8679         LDKCResult_PingDecodeErrorZ self;
8680 public:
8681         CResult_PingDecodeErrorZ(const CResult_PingDecodeErrorZ&) = delete;
8682         CResult_PingDecodeErrorZ(CResult_PingDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PingDecodeErrorZ)); }
8683         CResult_PingDecodeErrorZ(LDKCResult_PingDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PingDecodeErrorZ)); }
8684         operator LDKCResult_PingDecodeErrorZ() && { LDKCResult_PingDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PingDecodeErrorZ)); return res; }
8685         ~CResult_PingDecodeErrorZ() { CResult_PingDecodeErrorZ_free(self); }
8686         CResult_PingDecodeErrorZ& operator=(CResult_PingDecodeErrorZ&& o) { CResult_PingDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PingDecodeErrorZ)); return *this; }
8687         LDKCResult_PingDecodeErrorZ* operator &() { return &self; }
8688         LDKCResult_PingDecodeErrorZ* operator ->() { return &self; }
8689         const LDKCResult_PingDecodeErrorZ* operator &() const { return &self; }
8690         const LDKCResult_PingDecodeErrorZ* operator ->() const { return &self; }
8691 };
8692 class CResult_BlindedHopFeaturesDecodeErrorZ {
8693 private:
8694         LDKCResult_BlindedHopFeaturesDecodeErrorZ self;
8695 public:
8696         CResult_BlindedHopFeaturesDecodeErrorZ(const CResult_BlindedHopFeaturesDecodeErrorZ&) = delete;
8697         CResult_BlindedHopFeaturesDecodeErrorZ(CResult_BlindedHopFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedHopFeaturesDecodeErrorZ)); }
8698         CResult_BlindedHopFeaturesDecodeErrorZ(LDKCResult_BlindedHopFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ)); }
8699         operator LDKCResult_BlindedHopFeaturesDecodeErrorZ() && { LDKCResult_BlindedHopFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ)); return res; }
8700         ~CResult_BlindedHopFeaturesDecodeErrorZ() { CResult_BlindedHopFeaturesDecodeErrorZ_free(self); }
8701         CResult_BlindedHopFeaturesDecodeErrorZ& operator=(CResult_BlindedHopFeaturesDecodeErrorZ&& o) { CResult_BlindedHopFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedHopFeaturesDecodeErrorZ)); return *this; }
8702         LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator &() { return &self; }
8703         LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator ->() { return &self; }
8704         const LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator &() const { return &self; }
8705         const LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator ->() const { return &self; }
8706 };
8707 class CVec_TransactionOutputsZ {
8708 private:
8709         LDKCVec_TransactionOutputsZ self;
8710 public:
8711         CVec_TransactionOutputsZ(const CVec_TransactionOutputsZ&) = delete;
8712         CVec_TransactionOutputsZ(CVec_TransactionOutputsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionOutputsZ)); }
8713         CVec_TransactionOutputsZ(LDKCVec_TransactionOutputsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionOutputsZ)); }
8714         operator LDKCVec_TransactionOutputsZ() && { LDKCVec_TransactionOutputsZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionOutputsZ)); return res; }
8715         ~CVec_TransactionOutputsZ() { CVec_TransactionOutputsZ_free(self); }
8716         CVec_TransactionOutputsZ& operator=(CVec_TransactionOutputsZ&& o) { CVec_TransactionOutputsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionOutputsZ)); return *this; }
8717         LDKCVec_TransactionOutputsZ* operator &() { return &self; }
8718         LDKCVec_TransactionOutputsZ* operator ->() { return &self; }
8719         const LDKCVec_TransactionOutputsZ* operator &() const { return &self; }
8720         const LDKCVec_TransactionOutputsZ* operator ->() const { return &self; }
8721 };
8722 class COption_HTLCClaimZ {
8723 private:
8724         LDKCOption_HTLCClaimZ self;
8725 public:
8726         COption_HTLCClaimZ(const COption_HTLCClaimZ&) = delete;
8727         COption_HTLCClaimZ(COption_HTLCClaimZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_HTLCClaimZ)); }
8728         COption_HTLCClaimZ(LDKCOption_HTLCClaimZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_HTLCClaimZ)); }
8729         operator LDKCOption_HTLCClaimZ() && { LDKCOption_HTLCClaimZ res = self; memset(&self, 0, sizeof(LDKCOption_HTLCClaimZ)); return res; }
8730         ~COption_HTLCClaimZ() { COption_HTLCClaimZ_free(self); }
8731         COption_HTLCClaimZ& operator=(COption_HTLCClaimZ&& o) { COption_HTLCClaimZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_HTLCClaimZ)); return *this; }
8732         LDKCOption_HTLCClaimZ* operator &() { return &self; }
8733         LDKCOption_HTLCClaimZ* operator ->() { return &self; }
8734         const LDKCOption_HTLCClaimZ* operator &() const { return &self; }
8735         const LDKCOption_HTLCClaimZ* operator ->() const { return &self; }
8736 };
8737 class COption_boolZ {
8738 private:
8739         LDKCOption_boolZ self;
8740 public:
8741         COption_boolZ(const COption_boolZ&) = delete;
8742         COption_boolZ(COption_boolZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_boolZ)); }
8743         COption_boolZ(LDKCOption_boolZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_boolZ)); }
8744         operator LDKCOption_boolZ() && { LDKCOption_boolZ res = self; memset(&self, 0, sizeof(LDKCOption_boolZ)); return res; }
8745         ~COption_boolZ() { COption_boolZ_free(self); }
8746         COption_boolZ& operator=(COption_boolZ&& o) { COption_boolZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_boolZ)); return *this; }
8747         LDKCOption_boolZ* operator &() { return &self; }
8748         LDKCOption_boolZ* operator ->() { return &self; }
8749         const LDKCOption_boolZ* operator &() const { return &self; }
8750         const LDKCOption_boolZ* operator ->() const { return &self; }
8751 };
8752 class CVec_CVec_u8ZZ {
8753 private:
8754         LDKCVec_CVec_u8ZZ self;
8755 public:
8756         CVec_CVec_u8ZZ(const CVec_CVec_u8ZZ&) = delete;
8757         CVec_CVec_u8ZZ(CVec_CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CVec_u8ZZ)); }
8758         CVec_CVec_u8ZZ(LDKCVec_CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CVec_u8ZZ)); }
8759         operator LDKCVec_CVec_u8ZZ() && { LDKCVec_CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKCVec_CVec_u8ZZ)); return res; }
8760         ~CVec_CVec_u8ZZ() { CVec_CVec_u8ZZ_free(self); }
8761         CVec_CVec_u8ZZ& operator=(CVec_CVec_u8ZZ&& o) { CVec_CVec_u8ZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CVec_u8ZZ)); return *this; }
8762         LDKCVec_CVec_u8ZZ* operator &() { return &self; }
8763         LDKCVec_CVec_u8ZZ* operator ->() { return &self; }
8764         const LDKCVec_CVec_u8ZZ* operator &() const { return &self; }
8765         const LDKCVec_CVec_u8ZZ* operator ->() const { return &self; }
8766 };
8767 class CResult_ProbabilisticScorerDecodeErrorZ {
8768 private:
8769         LDKCResult_ProbabilisticScorerDecodeErrorZ self;
8770 public:
8771         CResult_ProbabilisticScorerDecodeErrorZ(const CResult_ProbabilisticScorerDecodeErrorZ&) = delete;
8772         CResult_ProbabilisticScorerDecodeErrorZ(CResult_ProbabilisticScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ProbabilisticScorerDecodeErrorZ)); }
8773         CResult_ProbabilisticScorerDecodeErrorZ(LDKCResult_ProbabilisticScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ)); }
8774         operator LDKCResult_ProbabilisticScorerDecodeErrorZ() && { LDKCResult_ProbabilisticScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ)); return res; }
8775         ~CResult_ProbabilisticScorerDecodeErrorZ() { CResult_ProbabilisticScorerDecodeErrorZ_free(self); }
8776         CResult_ProbabilisticScorerDecodeErrorZ& operator=(CResult_ProbabilisticScorerDecodeErrorZ&& o) { CResult_ProbabilisticScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ProbabilisticScorerDecodeErrorZ)); return *this; }
8777         LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() { return &self; }
8778         LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() { return &self; }
8779         const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() const { return &self; }
8780         const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() const { return &self; }
8781 };
8782 class CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ {
8783 private:
8784         LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ self;
8785 public:
8786         CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ(const CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&) = delete;
8787         CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ(CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); }
8788         CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ(LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); }
8789         operator LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); return res; }
8790         ~CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ() { CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(self); }
8791         CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ& operator=(CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&& o) { CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); return *this; }
8792         LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator &() { return &self; }
8793         LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator ->() { return &self; }
8794         const LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator &() const { return &self; }
8795         const LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator ->() const { return &self; }
8796 };
8797 class CResult_COption_CustomOnionMessageContentsZDecodeErrorZ {
8798 private:
8799         LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ self;
8800 public:
8801         CResult_COption_CustomOnionMessageContentsZDecodeErrorZ(const CResult_COption_CustomOnionMessageContentsZDecodeErrorZ&) = delete;
8802         CResult_COption_CustomOnionMessageContentsZDecodeErrorZ(CResult_COption_CustomOnionMessageContentsZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_CustomOnionMessageContentsZDecodeErrorZ)); }
8803         CResult_COption_CustomOnionMessageContentsZDecodeErrorZ(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ)); }
8804         operator LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ() && { LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ)); return res; }
8805         ~CResult_COption_CustomOnionMessageContentsZDecodeErrorZ() { CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(self); }
8806         CResult_COption_CustomOnionMessageContentsZDecodeErrorZ& operator=(CResult_COption_CustomOnionMessageContentsZDecodeErrorZ&& o) { CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_CustomOnionMessageContentsZDecodeErrorZ)); return *this; }
8807         LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* operator &() { return &self; }
8808         LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* operator ->() { return &self; }
8809         const LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* operator &() const { return &self; }
8810         const LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* operator ->() const { return &self; }
8811 };
8812 class CResult_ShutdownScriptDecodeErrorZ {
8813 private:
8814         LDKCResult_ShutdownScriptDecodeErrorZ self;
8815 public:
8816         CResult_ShutdownScriptDecodeErrorZ(const CResult_ShutdownScriptDecodeErrorZ&) = delete;
8817         CResult_ShutdownScriptDecodeErrorZ(CResult_ShutdownScriptDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); }
8818         CResult_ShutdownScriptDecodeErrorZ(LDKCResult_ShutdownScriptDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); }
8819         operator LDKCResult_ShutdownScriptDecodeErrorZ() && { LDKCResult_ShutdownScriptDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); return res; }
8820         ~CResult_ShutdownScriptDecodeErrorZ() { CResult_ShutdownScriptDecodeErrorZ_free(self); }
8821         CResult_ShutdownScriptDecodeErrorZ& operator=(CResult_ShutdownScriptDecodeErrorZ&& o) { CResult_ShutdownScriptDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); return *this; }
8822         LDKCResult_ShutdownScriptDecodeErrorZ* operator &() { return &self; }
8823         LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() { return &self; }
8824         const LDKCResult_ShutdownScriptDecodeErrorZ* operator &() const { return &self; }
8825         const LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() const { return &self; }
8826 };
8827 class C2Tuple_usizeTransactionZ {
8828 private:
8829         LDKC2Tuple_usizeTransactionZ self;
8830 public:
8831         C2Tuple_usizeTransactionZ(const C2Tuple_usizeTransactionZ&) = delete;
8832         C2Tuple_usizeTransactionZ(C2Tuple_usizeTransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_usizeTransactionZ)); }
8833         C2Tuple_usizeTransactionZ(LDKC2Tuple_usizeTransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_usizeTransactionZ)); }
8834         operator LDKC2Tuple_usizeTransactionZ() && { LDKC2Tuple_usizeTransactionZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_usizeTransactionZ)); return res; }
8835         ~C2Tuple_usizeTransactionZ() { C2Tuple_usizeTransactionZ_free(self); }
8836         C2Tuple_usizeTransactionZ& operator=(C2Tuple_usizeTransactionZ&& o) { C2Tuple_usizeTransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_usizeTransactionZ)); return *this; }
8837         LDKC2Tuple_usizeTransactionZ* operator &() { return &self; }
8838         LDKC2Tuple_usizeTransactionZ* operator ->() { return &self; }
8839         const LDKC2Tuple_usizeTransactionZ* operator &() const { return &self; }
8840         const LDKC2Tuple_usizeTransactionZ* operator ->() const { return &self; }
8841 };
8842 class CResult_NodeAnnouncementDecodeErrorZ {
8843 private:
8844         LDKCResult_NodeAnnouncementDecodeErrorZ self;
8845 public:
8846         CResult_NodeAnnouncementDecodeErrorZ(const CResult_NodeAnnouncementDecodeErrorZ&) = delete;
8847         CResult_NodeAnnouncementDecodeErrorZ(CResult_NodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); }
8848         CResult_NodeAnnouncementDecodeErrorZ(LDKCResult_NodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); }
8849         operator LDKCResult_NodeAnnouncementDecodeErrorZ() && { LDKCResult_NodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); return res; }
8850         ~CResult_NodeAnnouncementDecodeErrorZ() { CResult_NodeAnnouncementDecodeErrorZ_free(self); }
8851         CResult_NodeAnnouncementDecodeErrorZ& operator=(CResult_NodeAnnouncementDecodeErrorZ&& o) { CResult_NodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); return *this; }
8852         LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() { return &self; }
8853         LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
8854         const LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
8855         const LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
8856 };
8857 class CVec_FutureZ {
8858 private:
8859         LDKCVec_FutureZ self;
8860 public:
8861         CVec_FutureZ(const CVec_FutureZ&) = delete;
8862         CVec_FutureZ(CVec_FutureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_FutureZ)); }
8863         CVec_FutureZ(LDKCVec_FutureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_FutureZ)); }
8864         operator LDKCVec_FutureZ() && { LDKCVec_FutureZ res = self; memset(&self, 0, sizeof(LDKCVec_FutureZ)); return res; }
8865         ~CVec_FutureZ() { CVec_FutureZ_free(self); }
8866         CVec_FutureZ& operator=(CVec_FutureZ&& o) { CVec_FutureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_FutureZ)); return *this; }
8867         LDKCVec_FutureZ* operator &() { return &self; }
8868         LDKCVec_FutureZ* operator ->() { return &self; }
8869         const LDKCVec_FutureZ* operator &() const { return &self; }
8870         const LDKCVec_FutureZ* operator ->() const { return &self; }
8871 };
8872 class CVec_ChannelMonitorZ {
8873 private:
8874         LDKCVec_ChannelMonitorZ self;
8875 public:
8876         CVec_ChannelMonitorZ(const CVec_ChannelMonitorZ&) = delete;
8877         CVec_ChannelMonitorZ(CVec_ChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); }
8878         CVec_ChannelMonitorZ(LDKCVec_ChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelMonitorZ)); }
8879         operator LDKCVec_ChannelMonitorZ() && { LDKCVec_ChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelMonitorZ)); return res; }
8880         ~CVec_ChannelMonitorZ() { CVec_ChannelMonitorZ_free(self); }
8881         CVec_ChannelMonitorZ& operator=(CVec_ChannelMonitorZ&& o) { CVec_ChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); return *this; }
8882         LDKCVec_ChannelMonitorZ* operator &() { return &self; }
8883         LDKCVec_ChannelMonitorZ* operator ->() { return &self; }
8884         const LDKCVec_ChannelMonitorZ* operator &() const { return &self; }
8885         const LDKCVec_ChannelMonitorZ* operator ->() const { return &self; }
8886 };
8887 class CResult_AcceptChannelV2DecodeErrorZ {
8888 private:
8889         LDKCResult_AcceptChannelV2DecodeErrorZ self;
8890 public:
8891         CResult_AcceptChannelV2DecodeErrorZ(const CResult_AcceptChannelV2DecodeErrorZ&) = delete;
8892         CResult_AcceptChannelV2DecodeErrorZ(CResult_AcceptChannelV2DecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AcceptChannelV2DecodeErrorZ)); }
8893         CResult_AcceptChannelV2DecodeErrorZ(LDKCResult_AcceptChannelV2DecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AcceptChannelV2DecodeErrorZ)); }
8894         operator LDKCResult_AcceptChannelV2DecodeErrorZ() && { LDKCResult_AcceptChannelV2DecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AcceptChannelV2DecodeErrorZ)); return res; }
8895         ~CResult_AcceptChannelV2DecodeErrorZ() { CResult_AcceptChannelV2DecodeErrorZ_free(self); }
8896         CResult_AcceptChannelV2DecodeErrorZ& operator=(CResult_AcceptChannelV2DecodeErrorZ&& o) { CResult_AcceptChannelV2DecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AcceptChannelV2DecodeErrorZ)); return *this; }
8897         LDKCResult_AcceptChannelV2DecodeErrorZ* operator &() { return &self; }
8898         LDKCResult_AcceptChannelV2DecodeErrorZ* operator ->() { return &self; }
8899         const LDKCResult_AcceptChannelV2DecodeErrorZ* operator &() const { return &self; }
8900         const LDKCResult_AcceptChannelV2DecodeErrorZ* operator ->() const { return &self; }
8901 };
8902 class CResult_TxCreationKeysDecodeErrorZ {
8903 private:
8904         LDKCResult_TxCreationKeysDecodeErrorZ self;
8905 public:
8906         CResult_TxCreationKeysDecodeErrorZ(const CResult_TxCreationKeysDecodeErrorZ&) = delete;
8907         CResult_TxCreationKeysDecodeErrorZ(CResult_TxCreationKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); }
8908         CResult_TxCreationKeysDecodeErrorZ(LDKCResult_TxCreationKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); }
8909         operator LDKCResult_TxCreationKeysDecodeErrorZ() && { LDKCResult_TxCreationKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); return res; }
8910         ~CResult_TxCreationKeysDecodeErrorZ() { CResult_TxCreationKeysDecodeErrorZ_free(self); }
8911         CResult_TxCreationKeysDecodeErrorZ& operator=(CResult_TxCreationKeysDecodeErrorZ&& o) { CResult_TxCreationKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); return *this; }
8912         LDKCResult_TxCreationKeysDecodeErrorZ* operator &() { return &self; }
8913         LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() { return &self; }
8914         const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
8915         const LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() const { return &self; }
8916 };
8917 class CResult_RouteHopDecodeErrorZ {
8918 private:
8919         LDKCResult_RouteHopDecodeErrorZ self;
8920 public:
8921         CResult_RouteHopDecodeErrorZ(const CResult_RouteHopDecodeErrorZ&) = delete;
8922         CResult_RouteHopDecodeErrorZ(CResult_RouteHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHopDecodeErrorZ)); }
8923         CResult_RouteHopDecodeErrorZ(LDKCResult_RouteHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHopDecodeErrorZ)); }
8924         operator LDKCResult_RouteHopDecodeErrorZ() && { LDKCResult_RouteHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHopDecodeErrorZ)); return res; }
8925         ~CResult_RouteHopDecodeErrorZ() { CResult_RouteHopDecodeErrorZ_free(self); }
8926         CResult_RouteHopDecodeErrorZ& operator=(CResult_RouteHopDecodeErrorZ&& o) { CResult_RouteHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHopDecodeErrorZ)); return *this; }
8927         LDKCResult_RouteHopDecodeErrorZ* operator &() { return &self; }
8928         LDKCResult_RouteHopDecodeErrorZ* operator ->() { return &self; }
8929         const LDKCResult_RouteHopDecodeErrorZ* operator &() const { return &self; }
8930         const LDKCResult_RouteHopDecodeErrorZ* operator ->() const { return &self; }
8931 };
8932 class CVec_HTLCOutputInCommitmentZ {
8933 private:
8934         LDKCVec_HTLCOutputInCommitmentZ self;
8935 public:
8936         CVec_HTLCOutputInCommitmentZ(const CVec_HTLCOutputInCommitmentZ&) = delete;
8937         CVec_HTLCOutputInCommitmentZ(CVec_HTLCOutputInCommitmentZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_HTLCOutputInCommitmentZ)); }
8938         CVec_HTLCOutputInCommitmentZ(LDKCVec_HTLCOutputInCommitmentZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_HTLCOutputInCommitmentZ)); }
8939         operator LDKCVec_HTLCOutputInCommitmentZ() && { LDKCVec_HTLCOutputInCommitmentZ res = self; memset(&self, 0, sizeof(LDKCVec_HTLCOutputInCommitmentZ)); return res; }
8940         ~CVec_HTLCOutputInCommitmentZ() { CVec_HTLCOutputInCommitmentZ_free(self); }
8941         CVec_HTLCOutputInCommitmentZ& operator=(CVec_HTLCOutputInCommitmentZ&& o) { CVec_HTLCOutputInCommitmentZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_HTLCOutputInCommitmentZ)); return *this; }
8942         LDKCVec_HTLCOutputInCommitmentZ* operator &() { return &self; }
8943         LDKCVec_HTLCOutputInCommitmentZ* operator ->() { return &self; }
8944         const LDKCVec_HTLCOutputInCommitmentZ* operator &() const { return &self; }
8945         const LDKCVec_HTLCOutputInCommitmentZ* operator ->() const { return &self; }
8946 };
8947 class CResult_CoinSelectionNoneZ {
8948 private:
8949         LDKCResult_CoinSelectionNoneZ self;
8950 public:
8951         CResult_CoinSelectionNoneZ(const CResult_CoinSelectionNoneZ&) = delete;
8952         CResult_CoinSelectionNoneZ(CResult_CoinSelectionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CoinSelectionNoneZ)); }
8953         CResult_CoinSelectionNoneZ(LDKCResult_CoinSelectionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CoinSelectionNoneZ)); }
8954         operator LDKCResult_CoinSelectionNoneZ() && { LDKCResult_CoinSelectionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CoinSelectionNoneZ)); return res; }
8955         ~CResult_CoinSelectionNoneZ() { CResult_CoinSelectionNoneZ_free(self); }
8956         CResult_CoinSelectionNoneZ& operator=(CResult_CoinSelectionNoneZ&& o) { CResult_CoinSelectionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CoinSelectionNoneZ)); return *this; }
8957         LDKCResult_CoinSelectionNoneZ* operator &() { return &self; }
8958         LDKCResult_CoinSelectionNoneZ* operator ->() { return &self; }
8959         const LDKCResult_CoinSelectionNoneZ* operator &() const { return &self; }
8960         const LDKCResult_CoinSelectionNoneZ* operator ->() const { return &self; }
8961 };
8962 class C2Tuple_ThirtyTwoBytesPublicKeyZ {
8963 private:
8964         LDKC2Tuple_ThirtyTwoBytesPublicKeyZ self;
8965 public:
8966         C2Tuple_ThirtyTwoBytesPublicKeyZ(const C2Tuple_ThirtyTwoBytesPublicKeyZ&) = delete;
8967         C2Tuple_ThirtyTwoBytesPublicKeyZ(C2Tuple_ThirtyTwoBytesPublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesPublicKeyZ)); }
8968         C2Tuple_ThirtyTwoBytesPublicKeyZ(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ)); }
8969         operator LDKC2Tuple_ThirtyTwoBytesPublicKeyZ() && { LDKC2Tuple_ThirtyTwoBytesPublicKeyZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ)); return res; }
8970         ~C2Tuple_ThirtyTwoBytesPublicKeyZ() { C2Tuple_ThirtyTwoBytesPublicKeyZ_free(self); }
8971         C2Tuple_ThirtyTwoBytesPublicKeyZ& operator=(C2Tuple_ThirtyTwoBytesPublicKeyZ&& o) { C2Tuple_ThirtyTwoBytesPublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesPublicKeyZ)); return *this; }
8972         LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator &() { return &self; }
8973         LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator ->() { return &self; }
8974         const LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator &() const { return &self; }
8975         const LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator ->() const { return &self; }
8976 };
8977 class CResult_SiPrefixBolt11ParseErrorZ {
8978 private:
8979         LDKCResult_SiPrefixBolt11ParseErrorZ self;
8980 public:
8981         CResult_SiPrefixBolt11ParseErrorZ(const CResult_SiPrefixBolt11ParseErrorZ&) = delete;
8982         CResult_SiPrefixBolt11ParseErrorZ(CResult_SiPrefixBolt11ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SiPrefixBolt11ParseErrorZ)); }
8983         CResult_SiPrefixBolt11ParseErrorZ(LDKCResult_SiPrefixBolt11ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ)); }
8984         operator LDKCResult_SiPrefixBolt11ParseErrorZ() && { LDKCResult_SiPrefixBolt11ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ)); return res; }
8985         ~CResult_SiPrefixBolt11ParseErrorZ() { CResult_SiPrefixBolt11ParseErrorZ_free(self); }
8986         CResult_SiPrefixBolt11ParseErrorZ& operator=(CResult_SiPrefixBolt11ParseErrorZ&& o) { CResult_SiPrefixBolt11ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SiPrefixBolt11ParseErrorZ)); return *this; }
8987         LDKCResult_SiPrefixBolt11ParseErrorZ* operator &() { return &self; }
8988         LDKCResult_SiPrefixBolt11ParseErrorZ* operator ->() { return &self; }
8989         const LDKCResult_SiPrefixBolt11ParseErrorZ* operator &() const { return &self; }
8990         const LDKCResult_SiPrefixBolt11ParseErrorZ* operator ->() const { return &self; }
8991 };
8992 class CResult_BlindedPathDecodeErrorZ {
8993 private:
8994         LDKCResult_BlindedPathDecodeErrorZ self;
8995 public:
8996         CResult_BlindedPathDecodeErrorZ(const CResult_BlindedPathDecodeErrorZ&) = delete;
8997         CResult_BlindedPathDecodeErrorZ(CResult_BlindedPathDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPathDecodeErrorZ)); }
8998         CResult_BlindedPathDecodeErrorZ(LDKCResult_BlindedPathDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPathDecodeErrorZ)); }
8999         operator LDKCResult_BlindedPathDecodeErrorZ() && { LDKCResult_BlindedPathDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPathDecodeErrorZ)); return res; }
9000         ~CResult_BlindedPathDecodeErrorZ() { CResult_BlindedPathDecodeErrorZ_free(self); }
9001         CResult_BlindedPathDecodeErrorZ& operator=(CResult_BlindedPathDecodeErrorZ&& o) { CResult_BlindedPathDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPathDecodeErrorZ)); return *this; }
9002         LDKCResult_BlindedPathDecodeErrorZ* operator &() { return &self; }
9003         LDKCResult_BlindedPathDecodeErrorZ* operator ->() { return &self; }
9004         const LDKCResult_BlindedPathDecodeErrorZ* operator &() const { return &self; }
9005         const LDKCResult_BlindedPathDecodeErrorZ* operator ->() const { return &self; }
9006 };
9007 class CVec_BalanceZ {
9008 private:
9009         LDKCVec_BalanceZ self;
9010 public:
9011         CVec_BalanceZ(const CVec_BalanceZ&) = delete;
9012         CVec_BalanceZ(CVec_BalanceZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BalanceZ)); }
9013         CVec_BalanceZ(LDKCVec_BalanceZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BalanceZ)); }
9014         operator LDKCVec_BalanceZ() && { LDKCVec_BalanceZ res = self; memset(&self, 0, sizeof(LDKCVec_BalanceZ)); return res; }
9015         ~CVec_BalanceZ() { CVec_BalanceZ_free(self); }
9016         CVec_BalanceZ& operator=(CVec_BalanceZ&& o) { CVec_BalanceZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BalanceZ)); return *this; }
9017         LDKCVec_BalanceZ* operator &() { return &self; }
9018         LDKCVec_BalanceZ* operator ->() { return &self; }
9019         const LDKCVec_BalanceZ* operator &() const { return &self; }
9020         const LDKCVec_BalanceZ* operator ->() const { return &self; }
9021 };
9022 class CResult_NoneIOErrorZ {
9023 private:
9024         LDKCResult_NoneIOErrorZ self;
9025 public:
9026         CResult_NoneIOErrorZ(const CResult_NoneIOErrorZ&) = delete;
9027         CResult_NoneIOErrorZ(CResult_NoneIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneIOErrorZ)); }
9028         CResult_NoneIOErrorZ(LDKCResult_NoneIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneIOErrorZ)); }
9029         operator LDKCResult_NoneIOErrorZ() && { LDKCResult_NoneIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneIOErrorZ)); return res; }
9030         ~CResult_NoneIOErrorZ() { CResult_NoneIOErrorZ_free(self); }
9031         CResult_NoneIOErrorZ& operator=(CResult_NoneIOErrorZ&& o) { CResult_NoneIOErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneIOErrorZ)); return *this; }
9032         LDKCResult_NoneIOErrorZ* operator &() { return &self; }
9033         LDKCResult_NoneIOErrorZ* operator ->() { return &self; }
9034         const LDKCResult_NoneIOErrorZ* operator &() const { return &self; }
9035         const LDKCResult_NoneIOErrorZ* operator ->() const { return &self; }
9036 };
9037 class CResult_MaxDustHTLCExposureDecodeErrorZ {
9038 private:
9039         LDKCResult_MaxDustHTLCExposureDecodeErrorZ self;
9040 public:
9041         CResult_MaxDustHTLCExposureDecodeErrorZ(const CResult_MaxDustHTLCExposureDecodeErrorZ&) = delete;
9042         CResult_MaxDustHTLCExposureDecodeErrorZ(CResult_MaxDustHTLCExposureDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_MaxDustHTLCExposureDecodeErrorZ)); }
9043         CResult_MaxDustHTLCExposureDecodeErrorZ(LDKCResult_MaxDustHTLCExposureDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_MaxDustHTLCExposureDecodeErrorZ)); }
9044         operator LDKCResult_MaxDustHTLCExposureDecodeErrorZ() && { LDKCResult_MaxDustHTLCExposureDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_MaxDustHTLCExposureDecodeErrorZ)); return res; }
9045         ~CResult_MaxDustHTLCExposureDecodeErrorZ() { CResult_MaxDustHTLCExposureDecodeErrorZ_free(self); }
9046         CResult_MaxDustHTLCExposureDecodeErrorZ& operator=(CResult_MaxDustHTLCExposureDecodeErrorZ&& o) { CResult_MaxDustHTLCExposureDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_MaxDustHTLCExposureDecodeErrorZ)); return *this; }
9047         LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator &() { return &self; }
9048         LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator ->() { return &self; }
9049         const LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator &() const { return &self; }
9050         const LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator ->() const { return &self; }
9051 };
9052 class CVec_CommitmentTransactionZ {
9053 private:
9054         LDKCVec_CommitmentTransactionZ self;
9055 public:
9056         CVec_CommitmentTransactionZ(const CVec_CommitmentTransactionZ&) = delete;
9057         CVec_CommitmentTransactionZ(CVec_CommitmentTransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CommitmentTransactionZ)); }
9058         CVec_CommitmentTransactionZ(LDKCVec_CommitmentTransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CommitmentTransactionZ)); }
9059         operator LDKCVec_CommitmentTransactionZ() && { LDKCVec_CommitmentTransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_CommitmentTransactionZ)); return res; }
9060         ~CVec_CommitmentTransactionZ() { CVec_CommitmentTransactionZ_free(self); }
9061         CVec_CommitmentTransactionZ& operator=(CVec_CommitmentTransactionZ&& o) { CVec_CommitmentTransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CommitmentTransactionZ)); return *this; }
9062         LDKCVec_CommitmentTransactionZ* operator &() { return &self; }
9063         LDKCVec_CommitmentTransactionZ* operator ->() { return &self; }
9064         const LDKCVec_CommitmentTransactionZ* operator &() const { return &self; }
9065         const LDKCVec_CommitmentTransactionZ* operator ->() const { return &self; }
9066 };
9067 class CResult_FundingSignedDecodeErrorZ {
9068 private:
9069         LDKCResult_FundingSignedDecodeErrorZ self;
9070 public:
9071         CResult_FundingSignedDecodeErrorZ(const CResult_FundingSignedDecodeErrorZ&) = delete;
9072         CResult_FundingSignedDecodeErrorZ(CResult_FundingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); }
9073         CResult_FundingSignedDecodeErrorZ(LDKCResult_FundingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); }
9074         operator LDKCResult_FundingSignedDecodeErrorZ() && { LDKCResult_FundingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); return res; }
9075         ~CResult_FundingSignedDecodeErrorZ() { CResult_FundingSignedDecodeErrorZ_free(self); }
9076         CResult_FundingSignedDecodeErrorZ& operator=(CResult_FundingSignedDecodeErrorZ&& o) { CResult_FundingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); return *this; }
9077         LDKCResult_FundingSignedDecodeErrorZ* operator &() { return &self; }
9078         LDKCResult_FundingSignedDecodeErrorZ* operator ->() { return &self; }
9079         const LDKCResult_FundingSignedDecodeErrorZ* operator &() const { return &self; }
9080         const LDKCResult_FundingSignedDecodeErrorZ* operator ->() const { return &self; }
9081 };
9082 class CResult_RecoverableSignatureNoneZ {
9083 private:
9084         LDKCResult_RecoverableSignatureNoneZ self;
9085 public:
9086         CResult_RecoverableSignatureNoneZ(const CResult_RecoverableSignatureNoneZ&) = delete;
9087         CResult_RecoverableSignatureNoneZ(CResult_RecoverableSignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecoverableSignatureNoneZ)); }
9088         CResult_RecoverableSignatureNoneZ(LDKCResult_RecoverableSignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecoverableSignatureNoneZ)); }
9089         operator LDKCResult_RecoverableSignatureNoneZ() && { LDKCResult_RecoverableSignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_RecoverableSignatureNoneZ)); return res; }
9090         ~CResult_RecoverableSignatureNoneZ() { CResult_RecoverableSignatureNoneZ_free(self); }
9091         CResult_RecoverableSignatureNoneZ& operator=(CResult_RecoverableSignatureNoneZ&& o) { CResult_RecoverableSignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecoverableSignatureNoneZ)); return *this; }
9092         LDKCResult_RecoverableSignatureNoneZ* operator &() { return &self; }
9093         LDKCResult_RecoverableSignatureNoneZ* operator ->() { return &self; }
9094         const LDKCResult_RecoverableSignatureNoneZ* operator &() const { return &self; }
9095         const LDKCResult_RecoverableSignatureNoneZ* operator ->() const { return &self; }
9096 };
9097 class CResult_SocketAddressDecodeErrorZ {
9098 private:
9099         LDKCResult_SocketAddressDecodeErrorZ self;
9100 public:
9101         CResult_SocketAddressDecodeErrorZ(const CResult_SocketAddressDecodeErrorZ&) = delete;
9102         CResult_SocketAddressDecodeErrorZ(CResult_SocketAddressDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SocketAddressDecodeErrorZ)); }
9103         CResult_SocketAddressDecodeErrorZ(LDKCResult_SocketAddressDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SocketAddressDecodeErrorZ)); }
9104         operator LDKCResult_SocketAddressDecodeErrorZ() && { LDKCResult_SocketAddressDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SocketAddressDecodeErrorZ)); return res; }
9105         ~CResult_SocketAddressDecodeErrorZ() { CResult_SocketAddressDecodeErrorZ_free(self); }
9106         CResult_SocketAddressDecodeErrorZ& operator=(CResult_SocketAddressDecodeErrorZ&& o) { CResult_SocketAddressDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SocketAddressDecodeErrorZ)); return *this; }
9107         LDKCResult_SocketAddressDecodeErrorZ* operator &() { return &self; }
9108         LDKCResult_SocketAddressDecodeErrorZ* operator ->() { return &self; }
9109         const LDKCResult_SocketAddressDecodeErrorZ* operator &() const { return &self; }
9110         const LDKCResult_SocketAddressDecodeErrorZ* operator ->() const { return &self; }
9111 };
9112 class C2Tuple_Z {
9113 private:
9114         LDKC2Tuple_Z self;
9115 public:
9116         C2Tuple_Z(const C2Tuple_Z&) = delete;
9117         C2Tuple_Z(C2Tuple_Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_Z)); }
9118         C2Tuple_Z(LDKC2Tuple_Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_Z)); }
9119         operator LDKC2Tuple_Z() && { LDKC2Tuple_Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_Z)); return res; }
9120         ~C2Tuple_Z() { C2Tuple_Z_free(self); }
9121         C2Tuple_Z& operator=(C2Tuple_Z&& o) { C2Tuple_Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_Z)); return *this; }
9122         LDKC2Tuple_Z* operator &() { return &self; }
9123         LDKC2Tuple_Z* operator ->() { return &self; }
9124         const LDKC2Tuple_Z* operator &() const { return &self; }
9125         const LDKC2Tuple_Z* operator ->() const { return &self; }
9126 };
9127 class C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ {
9128 private:
9129         LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ self;
9130 public:
9131         C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(const C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&) = delete;
9132         C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); }
9133         C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); }
9134         operator LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ() && { LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); return res; }
9135         ~C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ() { C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(self); }
9136         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; }
9137         LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator &() { return &self; }
9138         LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator ->() { return &self; }
9139         const LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator &() const { return &self; }
9140         const LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator ->() const { return &self; }
9141 };
9142 class CVec_PathZ {
9143 private:
9144         LDKCVec_PathZ self;
9145 public:
9146         CVec_PathZ(const CVec_PathZ&) = delete;
9147         CVec_PathZ(CVec_PathZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PathZ)); }
9148         CVec_PathZ(LDKCVec_PathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PathZ)); }
9149         operator LDKCVec_PathZ() && { LDKCVec_PathZ res = self; memset(&self, 0, sizeof(LDKCVec_PathZ)); return res; }
9150         ~CVec_PathZ() { CVec_PathZ_free(self); }
9151         CVec_PathZ& operator=(CVec_PathZ&& o) { CVec_PathZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PathZ)); return *this; }
9152         LDKCVec_PathZ* operator &() { return &self; }
9153         LDKCVec_PathZ* operator ->() { return &self; }
9154         const LDKCVec_PathZ* operator &() const { return &self; }
9155         const LDKCVec_PathZ* operator ->() const { return &self; }
9156 };
9157 class CResult_NetworkGraphDecodeErrorZ {
9158 private:
9159         LDKCResult_NetworkGraphDecodeErrorZ self;
9160 public:
9161         CResult_NetworkGraphDecodeErrorZ(const CResult_NetworkGraphDecodeErrorZ&) = delete;
9162         CResult_NetworkGraphDecodeErrorZ(CResult_NetworkGraphDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NetworkGraphDecodeErrorZ)); }
9163         CResult_NetworkGraphDecodeErrorZ(LDKCResult_NetworkGraphDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NetworkGraphDecodeErrorZ)); }
9164         operator LDKCResult_NetworkGraphDecodeErrorZ() && { LDKCResult_NetworkGraphDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NetworkGraphDecodeErrorZ)); return res; }
9165         ~CResult_NetworkGraphDecodeErrorZ() { CResult_NetworkGraphDecodeErrorZ_free(self); }
9166         CResult_NetworkGraphDecodeErrorZ& operator=(CResult_NetworkGraphDecodeErrorZ&& o) { CResult_NetworkGraphDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NetworkGraphDecodeErrorZ)); return *this; }
9167         LDKCResult_NetworkGraphDecodeErrorZ* operator &() { return &self; }
9168         LDKCResult_NetworkGraphDecodeErrorZ* operator ->() { return &self; }
9169         const LDKCResult_NetworkGraphDecodeErrorZ* operator &() const { return &self; }
9170         const LDKCResult_NetworkGraphDecodeErrorZ* operator ->() const { return &self; }
9171 };
9172 class CResult_NodeInfoDecodeErrorZ {
9173 private:
9174         LDKCResult_NodeInfoDecodeErrorZ self;
9175 public:
9176         CResult_NodeInfoDecodeErrorZ(const CResult_NodeInfoDecodeErrorZ&) = delete;
9177         CResult_NodeInfoDecodeErrorZ(CResult_NodeInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); }
9178         CResult_NodeInfoDecodeErrorZ(LDKCResult_NodeInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); }
9179         operator LDKCResult_NodeInfoDecodeErrorZ() && { LDKCResult_NodeInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); return res; }
9180         ~CResult_NodeInfoDecodeErrorZ() { CResult_NodeInfoDecodeErrorZ_free(self); }
9181         CResult_NodeInfoDecodeErrorZ& operator=(CResult_NodeInfoDecodeErrorZ&& o) { CResult_NodeInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); return *this; }
9182         LDKCResult_NodeInfoDecodeErrorZ* operator &() { return &self; }
9183         LDKCResult_NodeInfoDecodeErrorZ* operator ->() { return &self; }
9184         const LDKCResult_NodeInfoDecodeErrorZ* operator &() const { return &self; }
9185         const LDKCResult_NodeInfoDecodeErrorZ* operator ->() const { return &self; }
9186 };
9187 class CVec_NodeIdZ {
9188 private:
9189         LDKCVec_NodeIdZ self;
9190 public:
9191         CVec_NodeIdZ(const CVec_NodeIdZ&) = delete;
9192         CVec_NodeIdZ(CVec_NodeIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_NodeIdZ)); }
9193         CVec_NodeIdZ(LDKCVec_NodeIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_NodeIdZ)); }
9194         operator LDKCVec_NodeIdZ() && { LDKCVec_NodeIdZ res = self; memset(&self, 0, sizeof(LDKCVec_NodeIdZ)); return res; }
9195         ~CVec_NodeIdZ() { CVec_NodeIdZ_free(self); }
9196         CVec_NodeIdZ& operator=(CVec_NodeIdZ&& o) { CVec_NodeIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_NodeIdZ)); return *this; }
9197         LDKCVec_NodeIdZ* operator &() { return &self; }
9198         LDKCVec_NodeIdZ* operator ->() { return &self; }
9199         const LDKCVec_NodeIdZ* operator &() const { return &self; }
9200         const LDKCVec_NodeIdZ* operator ->() const { return &self; }
9201 };
9202 class CVec_u8Z {
9203 private:
9204         LDKCVec_u8Z self;
9205 public:
9206         CVec_u8Z(const CVec_u8Z&) = delete;
9207         CVec_u8Z(CVec_u8Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u8Z)); }
9208         CVec_u8Z(LDKCVec_u8Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u8Z)); }
9209         operator LDKCVec_u8Z() && { LDKCVec_u8Z res = self; memset(&self, 0, sizeof(LDKCVec_u8Z)); return res; }
9210         ~CVec_u8Z() { CVec_u8Z_free(self); }
9211         CVec_u8Z& operator=(CVec_u8Z&& o) { CVec_u8Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u8Z)); return *this; }
9212         LDKCVec_u8Z* operator &() { return &self; }
9213         LDKCVec_u8Z* operator ->() { return &self; }
9214         const LDKCVec_u8Z* operator &() const { return &self; }
9215         const LDKCVec_u8Z* operator ->() const { return &self; }
9216 };
9217 class CResult_RouteLightningErrorZ {
9218 private:
9219         LDKCResult_RouteLightningErrorZ self;
9220 public:
9221         CResult_RouteLightningErrorZ(const CResult_RouteLightningErrorZ&) = delete;
9222         CResult_RouteLightningErrorZ(CResult_RouteLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); }
9223         CResult_RouteLightningErrorZ(LDKCResult_RouteLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); }
9224         operator LDKCResult_RouteLightningErrorZ() && { LDKCResult_RouteLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); return res; }
9225         ~CResult_RouteLightningErrorZ() { CResult_RouteLightningErrorZ_free(self); }
9226         CResult_RouteLightningErrorZ& operator=(CResult_RouteLightningErrorZ&& o) { CResult_RouteLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); return *this; }
9227         LDKCResult_RouteLightningErrorZ* operator &() { return &self; }
9228         LDKCResult_RouteLightningErrorZ* operator ->() { return &self; }
9229         const LDKCResult_RouteLightningErrorZ* operator &() const { return &self; }
9230         const LDKCResult_RouteLightningErrorZ* operator ->() const { return &self; }
9231 };
9232 class CResult_NonePaymentSendFailureZ {
9233 private:
9234         LDKCResult_NonePaymentSendFailureZ self;
9235 public:
9236         CResult_NonePaymentSendFailureZ(const CResult_NonePaymentSendFailureZ&) = delete;
9237         CResult_NonePaymentSendFailureZ(CResult_NonePaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); }
9238         CResult_NonePaymentSendFailureZ(LDKCResult_NonePaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); }
9239         operator LDKCResult_NonePaymentSendFailureZ() && { LDKCResult_NonePaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); return res; }
9240         ~CResult_NonePaymentSendFailureZ() { CResult_NonePaymentSendFailureZ_free(self); }
9241         CResult_NonePaymentSendFailureZ& operator=(CResult_NonePaymentSendFailureZ&& o) { CResult_NonePaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); return *this; }
9242         LDKCResult_NonePaymentSendFailureZ* operator &() { return &self; }
9243         LDKCResult_NonePaymentSendFailureZ* operator ->() { return &self; }
9244         const LDKCResult_NonePaymentSendFailureZ* operator &() const { return &self; }
9245         const LDKCResult_NonePaymentSendFailureZ* operator ->() const { return &self; }
9246 };
9247 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ {
9248 private:
9249         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ self;
9250 public:
9251         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&) = delete;
9252         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); }
9253         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); }
9254         operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); return res; }
9255         ~CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(self); }
9256         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; }
9257         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator &() { return &self; }
9258         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator ->() { return &self; }
9259         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator &() const { return &self; }
9260         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator ->() const { return &self; }
9261 };
9262 class CResult_ChannelPublicKeysDecodeErrorZ {
9263 private:
9264         LDKCResult_ChannelPublicKeysDecodeErrorZ self;
9265 public:
9266         CResult_ChannelPublicKeysDecodeErrorZ(const CResult_ChannelPublicKeysDecodeErrorZ&) = delete;
9267         CResult_ChannelPublicKeysDecodeErrorZ(CResult_ChannelPublicKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelPublicKeysDecodeErrorZ)); }
9268         CResult_ChannelPublicKeysDecodeErrorZ(LDKCResult_ChannelPublicKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ)); }
9269         operator LDKCResult_ChannelPublicKeysDecodeErrorZ() && { LDKCResult_ChannelPublicKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ)); return res; }
9270         ~CResult_ChannelPublicKeysDecodeErrorZ() { CResult_ChannelPublicKeysDecodeErrorZ_free(self); }
9271         CResult_ChannelPublicKeysDecodeErrorZ& operator=(CResult_ChannelPublicKeysDecodeErrorZ&& o) { CResult_ChannelPublicKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelPublicKeysDecodeErrorZ)); return *this; }
9272         LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() { return &self; }
9273         LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() { return &self; }
9274         const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() const { return &self; }
9275         const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() const { return &self; }
9276 };
9277 class CVec_ClaimedHTLCZ {
9278 private:
9279         LDKCVec_ClaimedHTLCZ self;
9280 public:
9281         CVec_ClaimedHTLCZ(const CVec_ClaimedHTLCZ&) = delete;
9282         CVec_ClaimedHTLCZ(CVec_ClaimedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ClaimedHTLCZ)); }
9283         CVec_ClaimedHTLCZ(LDKCVec_ClaimedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ClaimedHTLCZ)); }
9284         operator LDKCVec_ClaimedHTLCZ() && { LDKCVec_ClaimedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_ClaimedHTLCZ)); return res; }
9285         ~CVec_ClaimedHTLCZ() { CVec_ClaimedHTLCZ_free(self); }
9286         CVec_ClaimedHTLCZ& operator=(CVec_ClaimedHTLCZ&& o) { CVec_ClaimedHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ClaimedHTLCZ)); return *this; }
9287         LDKCVec_ClaimedHTLCZ* operator &() { return &self; }
9288         LDKCVec_ClaimedHTLCZ* operator ->() { return &self; }
9289         const LDKCVec_ClaimedHTLCZ* operator &() const { return &self; }
9290         const LDKCVec_ClaimedHTLCZ* operator ->() const { return &self; }
9291 };
9292 class COption_CVec_ThirtyTwoBytesZZ {
9293 private:
9294         LDKCOption_CVec_ThirtyTwoBytesZZ self;
9295 public:
9296         COption_CVec_ThirtyTwoBytesZZ(const COption_CVec_ThirtyTwoBytesZZ&) = delete;
9297         COption_CVec_ThirtyTwoBytesZZ(COption_CVec_ThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_ThirtyTwoBytesZZ)); }
9298         COption_CVec_ThirtyTwoBytesZZ(LDKCOption_CVec_ThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ)); }
9299         operator LDKCOption_CVec_ThirtyTwoBytesZZ() && { LDKCOption_CVec_ThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ)); return res; }
9300         ~COption_CVec_ThirtyTwoBytesZZ() { COption_CVec_ThirtyTwoBytesZZ_free(self); }
9301         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; }
9302         LDKCOption_CVec_ThirtyTwoBytesZZ* operator &() { return &self; }
9303         LDKCOption_CVec_ThirtyTwoBytesZZ* operator ->() { return &self; }
9304         const LDKCOption_CVec_ThirtyTwoBytesZZ* operator &() const { return &self; }
9305         const LDKCOption_CVec_ThirtyTwoBytesZZ* operator ->() const { return &self; }
9306 };
9307 class CVec_SocketAddressZ {
9308 private:
9309         LDKCVec_SocketAddressZ self;
9310 public:
9311         CVec_SocketAddressZ(const CVec_SocketAddressZ&) = delete;
9312         CVec_SocketAddressZ(CVec_SocketAddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SocketAddressZ)); }
9313         CVec_SocketAddressZ(LDKCVec_SocketAddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SocketAddressZ)); }
9314         operator LDKCVec_SocketAddressZ() && { LDKCVec_SocketAddressZ res = self; memset(&self, 0, sizeof(LDKCVec_SocketAddressZ)); return res; }
9315         ~CVec_SocketAddressZ() { CVec_SocketAddressZ_free(self); }
9316         CVec_SocketAddressZ& operator=(CVec_SocketAddressZ&& o) { CVec_SocketAddressZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_SocketAddressZ)); return *this; }
9317         LDKCVec_SocketAddressZ* operator &() { return &self; }
9318         LDKCVec_SocketAddressZ* operator ->() { return &self; }
9319         const LDKCVec_SocketAddressZ* operator &() const { return &self; }
9320         const LDKCVec_SocketAddressZ* operator ->() const { return &self; }
9321 };
9322 class CResult_ThirtyTwoBytesPaymentSendFailureZ {
9323 private:
9324         LDKCResult_ThirtyTwoBytesPaymentSendFailureZ self;
9325 public:
9326         CResult_ThirtyTwoBytesPaymentSendFailureZ(const CResult_ThirtyTwoBytesPaymentSendFailureZ&) = delete;
9327         CResult_ThirtyTwoBytesPaymentSendFailureZ(CResult_ThirtyTwoBytesPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentSendFailureZ)); }
9328         CResult_ThirtyTwoBytesPaymentSendFailureZ(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ)); }
9329         operator LDKCResult_ThirtyTwoBytesPaymentSendFailureZ() && { LDKCResult_ThirtyTwoBytesPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ)); return res; }
9330         ~CResult_ThirtyTwoBytesPaymentSendFailureZ() { CResult_ThirtyTwoBytesPaymentSendFailureZ_free(self); }
9331         CResult_ThirtyTwoBytesPaymentSendFailureZ& operator=(CResult_ThirtyTwoBytesPaymentSendFailureZ&& o) { CResult_ThirtyTwoBytesPaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentSendFailureZ)); return *this; }
9332         LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator &() { return &self; }
9333         LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator ->() { return &self; }
9334         const LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator &() const { return &self; }
9335         const LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator ->() const { return &self; }
9336 };
9337 class CResult_HolderCommitmentTransactionDecodeErrorZ {
9338 private:
9339         LDKCResult_HolderCommitmentTransactionDecodeErrorZ self;
9340 public:
9341         CResult_HolderCommitmentTransactionDecodeErrorZ(const CResult_HolderCommitmentTransactionDecodeErrorZ&) = delete;
9342         CResult_HolderCommitmentTransactionDecodeErrorZ(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); }
9343         CResult_HolderCommitmentTransactionDecodeErrorZ(LDKCResult_HolderCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); }
9344         operator LDKCResult_HolderCommitmentTransactionDecodeErrorZ() && { LDKCResult_HolderCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); return res; }
9345         ~CResult_HolderCommitmentTransactionDecodeErrorZ() { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); }
9346         CResult_HolderCommitmentTransactionDecodeErrorZ& operator=(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); return *this; }
9347         LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
9348         LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
9349         const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
9350         const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
9351 };
9352 class CResult_WarningMessageDecodeErrorZ {
9353 private:
9354         LDKCResult_WarningMessageDecodeErrorZ self;
9355 public:
9356         CResult_WarningMessageDecodeErrorZ(const CResult_WarningMessageDecodeErrorZ&) = delete;
9357         CResult_WarningMessageDecodeErrorZ(CResult_WarningMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WarningMessageDecodeErrorZ)); }
9358         CResult_WarningMessageDecodeErrorZ(LDKCResult_WarningMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WarningMessageDecodeErrorZ)); }
9359         operator LDKCResult_WarningMessageDecodeErrorZ() && { LDKCResult_WarningMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_WarningMessageDecodeErrorZ)); return res; }
9360         ~CResult_WarningMessageDecodeErrorZ() { CResult_WarningMessageDecodeErrorZ_free(self); }
9361         CResult_WarningMessageDecodeErrorZ& operator=(CResult_WarningMessageDecodeErrorZ&& o) { CResult_WarningMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WarningMessageDecodeErrorZ)); return *this; }
9362         LDKCResult_WarningMessageDecodeErrorZ* operator &() { return &self; }
9363         LDKCResult_WarningMessageDecodeErrorZ* operator ->() { return &self; }
9364         const LDKCResult_WarningMessageDecodeErrorZ* operator &() const { return &self; }
9365         const LDKCResult_WarningMessageDecodeErrorZ* operator ->() const { return &self; }
9366 };
9367 class CResult_ChannelCounterpartyDecodeErrorZ {
9368 private:
9369         LDKCResult_ChannelCounterpartyDecodeErrorZ self;
9370 public:
9371         CResult_ChannelCounterpartyDecodeErrorZ(const CResult_ChannelCounterpartyDecodeErrorZ&) = delete;
9372         CResult_ChannelCounterpartyDecodeErrorZ(CResult_ChannelCounterpartyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); }
9373         CResult_ChannelCounterpartyDecodeErrorZ(LDKCResult_ChannelCounterpartyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); }
9374         operator LDKCResult_ChannelCounterpartyDecodeErrorZ() && { LDKCResult_ChannelCounterpartyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); return res; }
9375         ~CResult_ChannelCounterpartyDecodeErrorZ() { CResult_ChannelCounterpartyDecodeErrorZ_free(self); }
9376         CResult_ChannelCounterpartyDecodeErrorZ& operator=(CResult_ChannelCounterpartyDecodeErrorZ&& o) { CResult_ChannelCounterpartyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); return *this; }
9377         LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() { return &self; }
9378         LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() { return &self; }
9379         const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() const { return &self; }
9380         const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() const { return &self; }
9381 };
9382 class CResult_InitDecodeErrorZ {
9383 private:
9384         LDKCResult_InitDecodeErrorZ self;
9385 public:
9386         CResult_InitDecodeErrorZ(const CResult_InitDecodeErrorZ&) = delete;
9387         CResult_InitDecodeErrorZ(CResult_InitDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); }
9388         CResult_InitDecodeErrorZ(LDKCResult_InitDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); }
9389         operator LDKCResult_InitDecodeErrorZ() && { LDKCResult_InitDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); return res; }
9390         ~CResult_InitDecodeErrorZ() { CResult_InitDecodeErrorZ_free(self); }
9391         CResult_InitDecodeErrorZ& operator=(CResult_InitDecodeErrorZ&& o) { CResult_InitDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); return *this; }
9392         LDKCResult_InitDecodeErrorZ* operator &() { return &self; }
9393         LDKCResult_InitDecodeErrorZ* operator ->() { return &self; }
9394         const LDKCResult_InitDecodeErrorZ* operator &() const { return &self; }
9395         const LDKCResult_InitDecodeErrorZ* operator ->() const { return &self; }
9396 };
9397 class CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ {
9398 private:
9399         LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ self;
9400 public:
9401         CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&) = delete;
9402         CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); }
9403         CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); }
9404         operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); return res; }
9405         ~CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(self); }
9406         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; }
9407         LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator &() { return &self; }
9408         LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator ->() { return &self; }
9409         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator &() const { return &self; }
9410         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator ->() const { return &self; }
9411 };
9412 class CResult_ClaimedHTLCDecodeErrorZ {
9413 private:
9414         LDKCResult_ClaimedHTLCDecodeErrorZ self;
9415 public:
9416         CResult_ClaimedHTLCDecodeErrorZ(const CResult_ClaimedHTLCDecodeErrorZ&) = delete;
9417         CResult_ClaimedHTLCDecodeErrorZ(CResult_ClaimedHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClaimedHTLCDecodeErrorZ)); }
9418         CResult_ClaimedHTLCDecodeErrorZ(LDKCResult_ClaimedHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ)); }
9419         operator LDKCResult_ClaimedHTLCDecodeErrorZ() && { LDKCResult_ClaimedHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ)); return res; }
9420         ~CResult_ClaimedHTLCDecodeErrorZ() { CResult_ClaimedHTLCDecodeErrorZ_free(self); }
9421         CResult_ClaimedHTLCDecodeErrorZ& operator=(CResult_ClaimedHTLCDecodeErrorZ&& o) { CResult_ClaimedHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClaimedHTLCDecodeErrorZ)); return *this; }
9422         LDKCResult_ClaimedHTLCDecodeErrorZ* operator &() { return &self; }
9423         LDKCResult_ClaimedHTLCDecodeErrorZ* operator ->() { return &self; }
9424         const LDKCResult_ClaimedHTLCDecodeErrorZ* operator &() const { return &self; }
9425         const LDKCResult_ClaimedHTLCDecodeErrorZ* operator ->() const { return &self; }
9426 };
9427 class CResult_PaymentPurposeDecodeErrorZ {
9428 private:
9429         LDKCResult_PaymentPurposeDecodeErrorZ self;
9430 public:
9431         CResult_PaymentPurposeDecodeErrorZ(const CResult_PaymentPurposeDecodeErrorZ&) = delete;
9432         CResult_PaymentPurposeDecodeErrorZ(CResult_PaymentPurposeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentPurposeDecodeErrorZ)); }
9433         CResult_PaymentPurposeDecodeErrorZ(LDKCResult_PaymentPurposeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentPurposeDecodeErrorZ)); }
9434         operator LDKCResult_PaymentPurposeDecodeErrorZ() && { LDKCResult_PaymentPurposeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentPurposeDecodeErrorZ)); return res; }
9435         ~CResult_PaymentPurposeDecodeErrorZ() { CResult_PaymentPurposeDecodeErrorZ_free(self); }
9436         CResult_PaymentPurposeDecodeErrorZ& operator=(CResult_PaymentPurposeDecodeErrorZ&& o) { CResult_PaymentPurposeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentPurposeDecodeErrorZ)); return *this; }
9437         LDKCResult_PaymentPurposeDecodeErrorZ* operator &() { return &self; }
9438         LDKCResult_PaymentPurposeDecodeErrorZ* operator ->() { return &self; }
9439         const LDKCResult_PaymentPurposeDecodeErrorZ* operator &() const { return &self; }
9440         const LDKCResult_PaymentPurposeDecodeErrorZ* operator ->() const { return &self; }
9441 };
9442 class CVec_MonitorUpdateIdZ {
9443 private:
9444         LDKCVec_MonitorUpdateIdZ self;
9445 public:
9446         CVec_MonitorUpdateIdZ(const CVec_MonitorUpdateIdZ&) = delete;
9447         CVec_MonitorUpdateIdZ(CVec_MonitorUpdateIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorUpdateIdZ)); }
9448         CVec_MonitorUpdateIdZ(LDKCVec_MonitorUpdateIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorUpdateIdZ)); }
9449         operator LDKCVec_MonitorUpdateIdZ() && { LDKCVec_MonitorUpdateIdZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorUpdateIdZ)); return res; }
9450         ~CVec_MonitorUpdateIdZ() { CVec_MonitorUpdateIdZ_free(self); }
9451         CVec_MonitorUpdateIdZ& operator=(CVec_MonitorUpdateIdZ&& o) { CVec_MonitorUpdateIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MonitorUpdateIdZ)); return *this; }
9452         LDKCVec_MonitorUpdateIdZ* operator &() { return &self; }
9453         LDKCVec_MonitorUpdateIdZ* operator ->() { return &self; }
9454         const LDKCVec_MonitorUpdateIdZ* operator &() const { return &self; }
9455         const LDKCVec_MonitorUpdateIdZ* operator ->() const { return &self; }
9456 };
9457 class CResult_OutPointDecodeErrorZ {
9458 private:
9459         LDKCResult_OutPointDecodeErrorZ self;
9460 public:
9461         CResult_OutPointDecodeErrorZ(const CResult_OutPointDecodeErrorZ&) = delete;
9462         CResult_OutPointDecodeErrorZ(CResult_OutPointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OutPointDecodeErrorZ)); }
9463         CResult_OutPointDecodeErrorZ(LDKCResult_OutPointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OutPointDecodeErrorZ)); }
9464         operator LDKCResult_OutPointDecodeErrorZ() && { LDKCResult_OutPointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OutPointDecodeErrorZ)); return res; }
9465         ~CResult_OutPointDecodeErrorZ() { CResult_OutPointDecodeErrorZ_free(self); }
9466         CResult_OutPointDecodeErrorZ& operator=(CResult_OutPointDecodeErrorZ&& o) { CResult_OutPointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OutPointDecodeErrorZ)); return *this; }
9467         LDKCResult_OutPointDecodeErrorZ* operator &() { return &self; }
9468         LDKCResult_OutPointDecodeErrorZ* operator ->() { return &self; }
9469         const LDKCResult_OutPointDecodeErrorZ* operator &() const { return &self; }
9470         const LDKCResult_OutPointDecodeErrorZ* operator ->() const { return &self; }
9471 };
9472 class CVec_ChannelDetailsZ {
9473 private:
9474         LDKCVec_ChannelDetailsZ self;
9475 public:
9476         CVec_ChannelDetailsZ(const CVec_ChannelDetailsZ&) = delete;
9477         CVec_ChannelDetailsZ(CVec_ChannelDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelDetailsZ)); }
9478         CVec_ChannelDetailsZ(LDKCVec_ChannelDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelDetailsZ)); }
9479         operator LDKCVec_ChannelDetailsZ() && { LDKCVec_ChannelDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelDetailsZ)); return res; }
9480         ~CVec_ChannelDetailsZ() { CVec_ChannelDetailsZ_free(self); }
9481         CVec_ChannelDetailsZ& operator=(CVec_ChannelDetailsZ&& o) { CVec_ChannelDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelDetailsZ)); return *this; }
9482         LDKCVec_ChannelDetailsZ* operator &() { return &self; }
9483         LDKCVec_ChannelDetailsZ* operator ->() { return &self; }
9484         const LDKCVec_ChannelDetailsZ* operator &() const { return &self; }
9485         const LDKCVec_ChannelDetailsZ* operator ->() const { return &self; }
9486 };
9487 class CResult_Bolt11InvoiceFeaturesDecodeErrorZ {
9488 private:
9489         LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ self;
9490 public:
9491         CResult_Bolt11InvoiceFeaturesDecodeErrorZ(const CResult_Bolt11InvoiceFeaturesDecodeErrorZ&) = delete;
9492         CResult_Bolt11InvoiceFeaturesDecodeErrorZ(CResult_Bolt11InvoiceFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceFeaturesDecodeErrorZ)); }
9493         CResult_Bolt11InvoiceFeaturesDecodeErrorZ(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ)); }
9494         operator LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ() && { LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ)); return res; }
9495         ~CResult_Bolt11InvoiceFeaturesDecodeErrorZ() { CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(self); }
9496         CResult_Bolt11InvoiceFeaturesDecodeErrorZ& operator=(CResult_Bolt11InvoiceFeaturesDecodeErrorZ&& o) { CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceFeaturesDecodeErrorZ)); return *this; }
9497         LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator &() { return &self; }
9498         LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator ->() { return &self; }
9499         const LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
9500         const LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
9501 };
9502 class CVec_MessageSendEventZ {
9503 private:
9504         LDKCVec_MessageSendEventZ self;
9505 public:
9506         CVec_MessageSendEventZ(const CVec_MessageSendEventZ&) = delete;
9507         CVec_MessageSendEventZ(CVec_MessageSendEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MessageSendEventZ)); }
9508         CVec_MessageSendEventZ(LDKCVec_MessageSendEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MessageSendEventZ)); }
9509         operator LDKCVec_MessageSendEventZ() && { LDKCVec_MessageSendEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MessageSendEventZ)); return res; }
9510         ~CVec_MessageSendEventZ() { CVec_MessageSendEventZ_free(self); }
9511         CVec_MessageSendEventZ& operator=(CVec_MessageSendEventZ&& o) { CVec_MessageSendEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MessageSendEventZ)); return *this; }
9512         LDKCVec_MessageSendEventZ* operator &() { return &self; }
9513         LDKCVec_MessageSendEventZ* operator ->() { return &self; }
9514         const LDKCVec_MessageSendEventZ* operator &() const { return &self; }
9515         const LDKCVec_MessageSendEventZ* operator ->() const { return &self; }
9516 };
9517 class CResult_RouteHintHopDecodeErrorZ {
9518 private:
9519         LDKCResult_RouteHintHopDecodeErrorZ self;
9520 public:
9521         CResult_RouteHintHopDecodeErrorZ(const CResult_RouteHintHopDecodeErrorZ&) = delete;
9522         CResult_RouteHintHopDecodeErrorZ(CResult_RouteHintHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHintHopDecodeErrorZ)); }
9523         CResult_RouteHintHopDecodeErrorZ(LDKCResult_RouteHintHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHintHopDecodeErrorZ)); }
9524         operator LDKCResult_RouteHintHopDecodeErrorZ() && { LDKCResult_RouteHintHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHintHopDecodeErrorZ)); return res; }
9525         ~CResult_RouteHintHopDecodeErrorZ() { CResult_RouteHintHopDecodeErrorZ_free(self); }
9526         CResult_RouteHintHopDecodeErrorZ& operator=(CResult_RouteHintHopDecodeErrorZ&& o) { CResult_RouteHintHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHintHopDecodeErrorZ)); return *this; }
9527         LDKCResult_RouteHintHopDecodeErrorZ* operator &() { return &self; }
9528         LDKCResult_RouteHintHopDecodeErrorZ* operator ->() { return &self; }
9529         const LDKCResult_RouteHintHopDecodeErrorZ* operator &() const { return &self; }
9530         const LDKCResult_RouteHintHopDecodeErrorZ* operator ->() const { return &self; }
9531 };
9532 class CResult_UpdateFailMalformedHTLCDecodeErrorZ {
9533 private:
9534         LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ self;
9535 public:
9536         CResult_UpdateFailMalformedHTLCDecodeErrorZ(const CResult_UpdateFailMalformedHTLCDecodeErrorZ&) = delete;
9537         CResult_UpdateFailMalformedHTLCDecodeErrorZ(CResult_UpdateFailMalformedHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFailMalformedHTLCDecodeErrorZ)); }
9538         CResult_UpdateFailMalformedHTLCDecodeErrorZ(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ)); }
9539         operator LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ() && { LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ)); return res; }
9540         ~CResult_UpdateFailMalformedHTLCDecodeErrorZ() { CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(self); }
9541         CResult_UpdateFailMalformedHTLCDecodeErrorZ& operator=(CResult_UpdateFailMalformedHTLCDecodeErrorZ&& o) { CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFailMalformedHTLCDecodeErrorZ)); return *this; }
9542         LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() { return &self; }
9543         LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() { return &self; }
9544         const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() const { return &self; }
9545         const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() const { return &self; }
9546 };
9547 class CResult_BlindedPayInfoDecodeErrorZ {
9548 private:
9549         LDKCResult_BlindedPayInfoDecodeErrorZ self;
9550 public:
9551         CResult_BlindedPayInfoDecodeErrorZ(const CResult_BlindedPayInfoDecodeErrorZ&) = delete;
9552         CResult_BlindedPayInfoDecodeErrorZ(CResult_BlindedPayInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPayInfoDecodeErrorZ)); }
9553         CResult_BlindedPayInfoDecodeErrorZ(LDKCResult_BlindedPayInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ)); }
9554         operator LDKCResult_BlindedPayInfoDecodeErrorZ() && { LDKCResult_BlindedPayInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ)); return res; }
9555         ~CResult_BlindedPayInfoDecodeErrorZ() { CResult_BlindedPayInfoDecodeErrorZ_free(self); }
9556         CResult_BlindedPayInfoDecodeErrorZ& operator=(CResult_BlindedPayInfoDecodeErrorZ&& o) { CResult_BlindedPayInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPayInfoDecodeErrorZ)); return *this; }
9557         LDKCResult_BlindedPayInfoDecodeErrorZ* operator &() { return &self; }
9558         LDKCResult_BlindedPayInfoDecodeErrorZ* operator ->() { return &self; }
9559         const LDKCResult_BlindedPayInfoDecodeErrorZ* operator &() const { return &self; }
9560         const LDKCResult_BlindedPayInfoDecodeErrorZ* operator ->() const { return &self; }
9561 };
9562 class CResult_ThirtyTwoBytesAPIErrorZ {
9563 private:
9564         LDKCResult_ThirtyTwoBytesAPIErrorZ self;
9565 public:
9566         CResult_ThirtyTwoBytesAPIErrorZ(const CResult_ThirtyTwoBytesAPIErrorZ&) = delete;
9567         CResult_ThirtyTwoBytesAPIErrorZ(CResult_ThirtyTwoBytesAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesAPIErrorZ)); }
9568         CResult_ThirtyTwoBytesAPIErrorZ(LDKCResult_ThirtyTwoBytesAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesAPIErrorZ)); }
9569         operator LDKCResult_ThirtyTwoBytesAPIErrorZ() && { LDKCResult_ThirtyTwoBytesAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesAPIErrorZ)); return res; }
9570         ~CResult_ThirtyTwoBytesAPIErrorZ() { CResult_ThirtyTwoBytesAPIErrorZ_free(self); }
9571         CResult_ThirtyTwoBytesAPIErrorZ& operator=(CResult_ThirtyTwoBytesAPIErrorZ&& o) { CResult_ThirtyTwoBytesAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesAPIErrorZ)); return *this; }
9572         LDKCResult_ThirtyTwoBytesAPIErrorZ* operator &() { return &self; }
9573         LDKCResult_ThirtyTwoBytesAPIErrorZ* operator ->() { return &self; }
9574         const LDKCResult_ThirtyTwoBytesAPIErrorZ* operator &() const { return &self; }
9575         const LDKCResult_ThirtyTwoBytesAPIErrorZ* operator ->() const { return &self; }
9576 };
9577 class COption_ChannelShutdownStateZ {
9578 private:
9579         LDKCOption_ChannelShutdownStateZ self;
9580 public:
9581         COption_ChannelShutdownStateZ(const COption_ChannelShutdownStateZ&) = delete;
9582         COption_ChannelShutdownStateZ(COption_ChannelShutdownStateZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ChannelShutdownStateZ)); }
9583         COption_ChannelShutdownStateZ(LDKCOption_ChannelShutdownStateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ChannelShutdownStateZ)); }
9584         operator LDKCOption_ChannelShutdownStateZ() && { LDKCOption_ChannelShutdownStateZ res = self; memset(&self, 0, sizeof(LDKCOption_ChannelShutdownStateZ)); return res; }
9585         ~COption_ChannelShutdownStateZ() { COption_ChannelShutdownStateZ_free(self); }
9586         COption_ChannelShutdownStateZ& operator=(COption_ChannelShutdownStateZ&& o) { COption_ChannelShutdownStateZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ChannelShutdownStateZ)); return *this; }
9587         LDKCOption_ChannelShutdownStateZ* operator &() { return &self; }
9588         LDKCOption_ChannelShutdownStateZ* operator ->() { return &self; }
9589         const LDKCOption_ChannelShutdownStateZ* operator &() const { return &self; }
9590         const LDKCOption_ChannelShutdownStateZ* operator ->() const { return &self; }
9591 };
9592 class CResult_CVec_CVec_u8ZZNoneZ {
9593 private:
9594         LDKCResult_CVec_CVec_u8ZZNoneZ self;
9595 public:
9596         CResult_CVec_CVec_u8ZZNoneZ(const CResult_CVec_CVec_u8ZZNoneZ&) = delete;
9597         CResult_CVec_CVec_u8ZZNoneZ(CResult_CVec_CVec_u8ZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_CVec_u8ZZNoneZ)); }
9598         CResult_CVec_CVec_u8ZZNoneZ(LDKCResult_CVec_CVec_u8ZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ)); }
9599         operator LDKCResult_CVec_CVec_u8ZZNoneZ() && { LDKCResult_CVec_CVec_u8ZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ)); return res; }
9600         ~CResult_CVec_CVec_u8ZZNoneZ() { CResult_CVec_CVec_u8ZZNoneZ_free(self); }
9601         CResult_CVec_CVec_u8ZZNoneZ& operator=(CResult_CVec_CVec_u8ZZNoneZ&& o) { CResult_CVec_CVec_u8ZZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_CVec_u8ZZNoneZ)); return *this; }
9602         LDKCResult_CVec_CVec_u8ZZNoneZ* operator &() { return &self; }
9603         LDKCResult_CVec_CVec_u8ZZNoneZ* operator ->() { return &self; }
9604         const LDKCResult_CVec_CVec_u8ZZNoneZ* operator &() const { return &self; }
9605         const LDKCResult_CVec_CVec_u8ZZNoneZ* operator ->() const { return &self; }
9606 };
9607 class CResult_AcceptChannelDecodeErrorZ {
9608 private:
9609         LDKCResult_AcceptChannelDecodeErrorZ self;
9610 public:
9611         CResult_AcceptChannelDecodeErrorZ(const CResult_AcceptChannelDecodeErrorZ&) = delete;
9612         CResult_AcceptChannelDecodeErrorZ(CResult_AcceptChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); }
9613         CResult_AcceptChannelDecodeErrorZ(LDKCResult_AcceptChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); }
9614         operator LDKCResult_AcceptChannelDecodeErrorZ() && { LDKCResult_AcceptChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); return res; }
9615         ~CResult_AcceptChannelDecodeErrorZ() { CResult_AcceptChannelDecodeErrorZ_free(self); }
9616         CResult_AcceptChannelDecodeErrorZ& operator=(CResult_AcceptChannelDecodeErrorZ&& o) { CResult_AcceptChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); return *this; }
9617         LDKCResult_AcceptChannelDecodeErrorZ* operator &() { return &self; }
9618         LDKCResult_AcceptChannelDecodeErrorZ* operator ->() { return &self; }
9619         const LDKCResult_AcceptChannelDecodeErrorZ* operator &() const { return &self; }
9620         const LDKCResult_AcceptChannelDecodeErrorZ* operator ->() const { return &self; }
9621 };
9622 class CResult_HostnameDecodeErrorZ {
9623 private:
9624         LDKCResult_HostnameDecodeErrorZ self;
9625 public:
9626         CResult_HostnameDecodeErrorZ(const CResult_HostnameDecodeErrorZ&) = delete;
9627         CResult_HostnameDecodeErrorZ(CResult_HostnameDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HostnameDecodeErrorZ)); }
9628         CResult_HostnameDecodeErrorZ(LDKCResult_HostnameDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HostnameDecodeErrorZ)); }
9629         operator LDKCResult_HostnameDecodeErrorZ() && { LDKCResult_HostnameDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HostnameDecodeErrorZ)); return res; }
9630         ~CResult_HostnameDecodeErrorZ() { CResult_HostnameDecodeErrorZ_free(self); }
9631         CResult_HostnameDecodeErrorZ& operator=(CResult_HostnameDecodeErrorZ&& o) { CResult_HostnameDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HostnameDecodeErrorZ)); return *this; }
9632         LDKCResult_HostnameDecodeErrorZ* operator &() { return &self; }
9633         LDKCResult_HostnameDecodeErrorZ* operator ->() { return &self; }
9634         const LDKCResult_HostnameDecodeErrorZ* operator &() const { return &self; }
9635         const LDKCResult_HostnameDecodeErrorZ* operator ->() const { return &self; }
9636 };
9637 class C2Tuple_u64u16Z {
9638 private:
9639         LDKC2Tuple_u64u16Z self;
9640 public:
9641         C2Tuple_u64u16Z(const C2Tuple_u64u16Z&) = delete;
9642         C2Tuple_u64u16Z(C2Tuple_u64u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64u16Z)); }
9643         C2Tuple_u64u16Z(LDKC2Tuple_u64u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64u16Z)); }
9644         operator LDKC2Tuple_u64u16Z() && { LDKC2Tuple_u64u16Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64u16Z)); return res; }
9645         ~C2Tuple_u64u16Z() { C2Tuple_u64u16Z_free(self); }
9646         C2Tuple_u64u16Z& operator=(C2Tuple_u64u16Z&& o) { C2Tuple_u64u16Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u64u16Z)); return *this; }
9647         LDKC2Tuple_u64u16Z* operator &() { return &self; }
9648         LDKC2Tuple_u64u16Z* operator ->() { return &self; }
9649         const LDKC2Tuple_u64u16Z* operator &() const { return &self; }
9650         const LDKC2Tuple_u64u16Z* operator ->() const { return &self; }
9651 };
9652 class COption_ThirtyTwoBytesZ {
9653 private:
9654         LDKCOption_ThirtyTwoBytesZ self;
9655 public:
9656         COption_ThirtyTwoBytesZ(const COption_ThirtyTwoBytesZ&) = delete;
9657         COption_ThirtyTwoBytesZ(COption_ThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ThirtyTwoBytesZ)); }
9658         COption_ThirtyTwoBytesZ(LDKCOption_ThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ThirtyTwoBytesZ)); }
9659         operator LDKCOption_ThirtyTwoBytesZ() && { LDKCOption_ThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKCOption_ThirtyTwoBytesZ)); return res; }
9660         ~COption_ThirtyTwoBytesZ() { COption_ThirtyTwoBytesZ_free(self); }
9661         COption_ThirtyTwoBytesZ& operator=(COption_ThirtyTwoBytesZ&& o) { COption_ThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ThirtyTwoBytesZ)); return *this; }
9662         LDKCOption_ThirtyTwoBytesZ* operator &() { return &self; }
9663         LDKCOption_ThirtyTwoBytesZ* operator ->() { return &self; }
9664         const LDKCOption_ThirtyTwoBytesZ* operator &() const { return &self; }
9665         const LDKCOption_ThirtyTwoBytesZ* operator ->() const { return &self; }
9666 };
9667 class CVec_u64Z {
9668 private:
9669         LDKCVec_u64Z self;
9670 public:
9671         CVec_u64Z(const CVec_u64Z&) = delete;
9672         CVec_u64Z(CVec_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u64Z)); }
9673         CVec_u64Z(LDKCVec_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u64Z)); }
9674         operator LDKCVec_u64Z() && { LDKCVec_u64Z res = self; memset(&self, 0, sizeof(LDKCVec_u64Z)); return res; }
9675         ~CVec_u64Z() { CVec_u64Z_free(self); }
9676         CVec_u64Z& operator=(CVec_u64Z&& o) { CVec_u64Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u64Z)); return *this; }
9677         LDKCVec_u64Z* operator &() { return &self; }
9678         LDKCVec_u64Z* operator ->() { return &self; }
9679         const LDKCVec_u64Z* operator &() const { return &self; }
9680         const LDKCVec_u64Z* operator ->() const { return &self; }
9681 };
9682 class COption_SecretKeyZ {
9683 private:
9684         LDKCOption_SecretKeyZ self;
9685 public:
9686         COption_SecretKeyZ(const COption_SecretKeyZ&) = delete;
9687         COption_SecretKeyZ(COption_SecretKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_SecretKeyZ)); }
9688         COption_SecretKeyZ(LDKCOption_SecretKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_SecretKeyZ)); }
9689         operator LDKCOption_SecretKeyZ() && { LDKCOption_SecretKeyZ res = self; memset(&self, 0, sizeof(LDKCOption_SecretKeyZ)); return res; }
9690         ~COption_SecretKeyZ() { COption_SecretKeyZ_free(self); }
9691         COption_SecretKeyZ& operator=(COption_SecretKeyZ&& o) { COption_SecretKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_SecretKeyZ)); return *this; }
9692         LDKCOption_SecretKeyZ* operator &() { return &self; }
9693         LDKCOption_SecretKeyZ* operator ->() { return &self; }
9694         const LDKCOption_SecretKeyZ* operator &() const { return &self; }
9695         const LDKCOption_SecretKeyZ* operator ->() const { return &self; }
9696 };
9697 class CResult_ThirtyTwoBytesPaymentErrorZ {
9698 private:
9699         LDKCResult_ThirtyTwoBytesPaymentErrorZ self;
9700 public:
9701         CResult_ThirtyTwoBytesPaymentErrorZ(const CResult_ThirtyTwoBytesPaymentErrorZ&) = delete;
9702         CResult_ThirtyTwoBytesPaymentErrorZ(CResult_ThirtyTwoBytesPaymentErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentErrorZ)); }
9703         CResult_ThirtyTwoBytesPaymentErrorZ(LDKCResult_ThirtyTwoBytesPaymentErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentErrorZ)); }
9704         operator LDKCResult_ThirtyTwoBytesPaymentErrorZ() && { LDKCResult_ThirtyTwoBytesPaymentErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentErrorZ)); return res; }
9705         ~CResult_ThirtyTwoBytesPaymentErrorZ() { CResult_ThirtyTwoBytesPaymentErrorZ_free(self); }
9706         CResult_ThirtyTwoBytesPaymentErrorZ& operator=(CResult_ThirtyTwoBytesPaymentErrorZ&& o) { CResult_ThirtyTwoBytesPaymentErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentErrorZ)); return *this; }
9707         LDKCResult_ThirtyTwoBytesPaymentErrorZ* operator &() { return &self; }
9708         LDKCResult_ThirtyTwoBytesPaymentErrorZ* operator ->() { return &self; }
9709         const LDKCResult_ThirtyTwoBytesPaymentErrorZ* operator &() const { return &self; }
9710         const LDKCResult_ThirtyTwoBytesPaymentErrorZ* operator ->() const { return &self; }
9711 };
9712 class COption_EventZ {
9713 private:
9714         LDKCOption_EventZ self;
9715 public:
9716         COption_EventZ(const COption_EventZ&) = delete;
9717         COption_EventZ(COption_EventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_EventZ)); }
9718         COption_EventZ(LDKCOption_EventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_EventZ)); }
9719         operator LDKCOption_EventZ() && { LDKCOption_EventZ res = self; memset(&self, 0, sizeof(LDKCOption_EventZ)); return res; }
9720         ~COption_EventZ() { COption_EventZ_free(self); }
9721         COption_EventZ& operator=(COption_EventZ&& o) { COption_EventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_EventZ)); return *this; }
9722         LDKCOption_EventZ* operator &() { return &self; }
9723         LDKCOption_EventZ* operator ->() { return &self; }
9724         const LDKCOption_EventZ* operator &() const { return &self; }
9725         const LDKCOption_EventZ* operator ->() const { return &self; }
9726 };
9727 class CResult_ChannelTypeFeaturesDecodeErrorZ {
9728 private:
9729         LDKCResult_ChannelTypeFeaturesDecodeErrorZ self;
9730 public:
9731         CResult_ChannelTypeFeaturesDecodeErrorZ(const CResult_ChannelTypeFeaturesDecodeErrorZ&) = delete;
9732         CResult_ChannelTypeFeaturesDecodeErrorZ(CResult_ChannelTypeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTypeFeaturesDecodeErrorZ)); }
9733         CResult_ChannelTypeFeaturesDecodeErrorZ(LDKCResult_ChannelTypeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ)); }
9734         operator LDKCResult_ChannelTypeFeaturesDecodeErrorZ() && { LDKCResult_ChannelTypeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ)); return res; }
9735         ~CResult_ChannelTypeFeaturesDecodeErrorZ() { CResult_ChannelTypeFeaturesDecodeErrorZ_free(self); }
9736         CResult_ChannelTypeFeaturesDecodeErrorZ& operator=(CResult_ChannelTypeFeaturesDecodeErrorZ&& o) { CResult_ChannelTypeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTypeFeaturesDecodeErrorZ)); return *this; }
9737         LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() { return &self; }
9738         LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() { return &self; }
9739         const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() const { return &self; }
9740         const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() const { return &self; }
9741 };
9742 class COption_CVec_SocketAddressZZ {
9743 private:
9744         LDKCOption_CVec_SocketAddressZZ self;
9745 public:
9746         COption_CVec_SocketAddressZZ(const COption_CVec_SocketAddressZZ&) = delete;
9747         COption_CVec_SocketAddressZZ(COption_CVec_SocketAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_SocketAddressZZ)); }
9748         COption_CVec_SocketAddressZZ(LDKCOption_CVec_SocketAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_SocketAddressZZ)); }
9749         operator LDKCOption_CVec_SocketAddressZZ() && { LDKCOption_CVec_SocketAddressZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_SocketAddressZZ)); return res; }
9750         ~COption_CVec_SocketAddressZZ() { COption_CVec_SocketAddressZZ_free(self); }
9751         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; }
9752         LDKCOption_CVec_SocketAddressZZ* operator &() { return &self; }
9753         LDKCOption_CVec_SocketAddressZZ* operator ->() { return &self; }
9754         const LDKCOption_CVec_SocketAddressZZ* operator &() const { return &self; }
9755         const LDKCOption_CVec_SocketAddressZZ* operator ->() const { return &self; }
9756 };
9757 class CVec_RouteHintZ {
9758 private:
9759         LDKCVec_RouteHintZ self;
9760 public:
9761         CVec_RouteHintZ(const CVec_RouteHintZ&) = delete;
9762         CVec_RouteHintZ(CVec_RouteHintZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintZ)); }
9763         CVec_RouteHintZ(LDKCVec_RouteHintZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintZ)); }
9764         operator LDKCVec_RouteHintZ() && { LDKCVec_RouteHintZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintZ)); return res; }
9765         ~CVec_RouteHintZ() { CVec_RouteHintZ_free(self); }
9766         CVec_RouteHintZ& operator=(CVec_RouteHintZ&& o) { CVec_RouteHintZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintZ)); return *this; }
9767         LDKCVec_RouteHintZ* operator &() { return &self; }
9768         LDKCVec_RouteHintZ* operator ->() { return &self; }
9769         const LDKCVec_RouteHintZ* operator &() const { return &self; }
9770         const LDKCVec_RouteHintZ* operator ->() const { return &self; }
9771 };
9772 class COption_u16Z {
9773 private:
9774         LDKCOption_u16Z self;
9775 public:
9776         COption_u16Z(const COption_u16Z&) = delete;
9777         COption_u16Z(COption_u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u16Z)); }
9778         COption_u16Z(LDKCOption_u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u16Z)); }
9779         operator LDKCOption_u16Z() && { LDKCOption_u16Z res = self; memset(&self, 0, sizeof(LDKCOption_u16Z)); return res; }
9780         ~COption_u16Z() { COption_u16Z_free(self); }
9781         COption_u16Z& operator=(COption_u16Z&& o) { COption_u16Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u16Z)); return *this; }
9782         LDKCOption_u16Z* operator &() { return &self; }
9783         LDKCOption_u16Z* operator ->() { return &self; }
9784         const LDKCOption_u16Z* operator &() const { return &self; }
9785         const LDKCOption_u16Z* operator ->() const { return &self; }
9786 };
9787 class COption_PaymentFailureReasonZ {
9788 private:
9789         LDKCOption_PaymentFailureReasonZ self;
9790 public:
9791         COption_PaymentFailureReasonZ(const COption_PaymentFailureReasonZ&) = delete;
9792         COption_PaymentFailureReasonZ(COption_PaymentFailureReasonZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_PaymentFailureReasonZ)); }
9793         COption_PaymentFailureReasonZ(LDKCOption_PaymentFailureReasonZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_PaymentFailureReasonZ)); }
9794         operator LDKCOption_PaymentFailureReasonZ() && { LDKCOption_PaymentFailureReasonZ res = self; memset(&self, 0, sizeof(LDKCOption_PaymentFailureReasonZ)); return res; }
9795         ~COption_PaymentFailureReasonZ() { COption_PaymentFailureReasonZ_free(self); }
9796         COption_PaymentFailureReasonZ& operator=(COption_PaymentFailureReasonZ&& o) { COption_PaymentFailureReasonZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_PaymentFailureReasonZ)); return *this; }
9797         LDKCOption_PaymentFailureReasonZ* operator &() { return &self; }
9798         LDKCOption_PaymentFailureReasonZ* operator ->() { return &self; }
9799         const LDKCOption_PaymentFailureReasonZ* operator &() const { return &self; }
9800         const LDKCOption_PaymentFailureReasonZ* operator ->() const { return &self; }
9801 };
9802 class CResult_ECDSASignatureNoneZ {
9803 private:
9804         LDKCResult_ECDSASignatureNoneZ self;
9805 public:
9806         CResult_ECDSASignatureNoneZ(const CResult_ECDSASignatureNoneZ&) = delete;
9807         CResult_ECDSASignatureNoneZ(CResult_ECDSASignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ECDSASignatureNoneZ)); }
9808         CResult_ECDSASignatureNoneZ(LDKCResult_ECDSASignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ECDSASignatureNoneZ)); }
9809         operator LDKCResult_ECDSASignatureNoneZ() && { LDKCResult_ECDSASignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ECDSASignatureNoneZ)); return res; }
9810         ~CResult_ECDSASignatureNoneZ() { CResult_ECDSASignatureNoneZ_free(self); }
9811         CResult_ECDSASignatureNoneZ& operator=(CResult_ECDSASignatureNoneZ&& o) { CResult_ECDSASignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ECDSASignatureNoneZ)); return *this; }
9812         LDKCResult_ECDSASignatureNoneZ* operator &() { return &self; }
9813         LDKCResult_ECDSASignatureNoneZ* operator ->() { return &self; }
9814         const LDKCResult_ECDSASignatureNoneZ* operator &() const { return &self; }
9815         const LDKCResult_ECDSASignatureNoneZ* operator ->() const { return &self; }
9816 };
9817 class CVec_WitnessZ {
9818 private:
9819         LDKCVec_WitnessZ self;
9820 public:
9821         CVec_WitnessZ(const CVec_WitnessZ&) = delete;
9822         CVec_WitnessZ(CVec_WitnessZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_WitnessZ)); }
9823         CVec_WitnessZ(LDKCVec_WitnessZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_WitnessZ)); }
9824         operator LDKCVec_WitnessZ() && { LDKCVec_WitnessZ res = self; memset(&self, 0, sizeof(LDKCVec_WitnessZ)); return res; }
9825         ~CVec_WitnessZ() { CVec_WitnessZ_free(self); }
9826         CVec_WitnessZ& operator=(CVec_WitnessZ&& o) { CVec_WitnessZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_WitnessZ)); return *this; }
9827         LDKCVec_WitnessZ* operator &() { return &self; }
9828         LDKCVec_WitnessZ* operator ->() { return &self; }
9829         const LDKCVec_WitnessZ* operator &() const { return &self; }
9830         const LDKCVec_WitnessZ* operator ->() const { return &self; }
9831 };
9832 class CResult_BlindedTailDecodeErrorZ {
9833 private:
9834         LDKCResult_BlindedTailDecodeErrorZ self;
9835 public:
9836         CResult_BlindedTailDecodeErrorZ(const CResult_BlindedTailDecodeErrorZ&) = delete;
9837         CResult_BlindedTailDecodeErrorZ(CResult_BlindedTailDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedTailDecodeErrorZ)); }
9838         CResult_BlindedTailDecodeErrorZ(LDKCResult_BlindedTailDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedTailDecodeErrorZ)); }
9839         operator LDKCResult_BlindedTailDecodeErrorZ() && { LDKCResult_BlindedTailDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedTailDecodeErrorZ)); return res; }
9840         ~CResult_BlindedTailDecodeErrorZ() { CResult_BlindedTailDecodeErrorZ_free(self); }
9841         CResult_BlindedTailDecodeErrorZ& operator=(CResult_BlindedTailDecodeErrorZ&& o) { CResult_BlindedTailDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedTailDecodeErrorZ)); return *this; }
9842         LDKCResult_BlindedTailDecodeErrorZ* operator &() { return &self; }
9843         LDKCResult_BlindedTailDecodeErrorZ* operator ->() { return &self; }
9844         const LDKCResult_BlindedTailDecodeErrorZ* operator &() const { return &self; }
9845         const LDKCResult_BlindedTailDecodeErrorZ* operator ->() const { return &self; }
9846 };
9847 class CResult_SocketAddressSocketAddressParseErrorZ {
9848 private:
9849         LDKCResult_SocketAddressSocketAddressParseErrorZ self;
9850 public:
9851         CResult_SocketAddressSocketAddressParseErrorZ(const CResult_SocketAddressSocketAddressParseErrorZ&) = delete;
9852         CResult_SocketAddressSocketAddressParseErrorZ(CResult_SocketAddressSocketAddressParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SocketAddressSocketAddressParseErrorZ)); }
9853         CResult_SocketAddressSocketAddressParseErrorZ(LDKCResult_SocketAddressSocketAddressParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ)); }
9854         operator LDKCResult_SocketAddressSocketAddressParseErrorZ() && { LDKCResult_SocketAddressSocketAddressParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ)); return res; }
9855         ~CResult_SocketAddressSocketAddressParseErrorZ() { CResult_SocketAddressSocketAddressParseErrorZ_free(self); }
9856         CResult_SocketAddressSocketAddressParseErrorZ& operator=(CResult_SocketAddressSocketAddressParseErrorZ&& o) { CResult_SocketAddressSocketAddressParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SocketAddressSocketAddressParseErrorZ)); return *this; }
9857         LDKCResult_SocketAddressSocketAddressParseErrorZ* operator &() { return &self; }
9858         LDKCResult_SocketAddressSocketAddressParseErrorZ* operator ->() { return &self; }
9859         const LDKCResult_SocketAddressSocketAddressParseErrorZ* operator &() const { return &self; }
9860         const LDKCResult_SocketAddressSocketAddressParseErrorZ* operator ->() const { return &self; }
9861 };
9862 class COption_C2Tuple_u64u16ZZ {
9863 private:
9864         LDKCOption_C2Tuple_u64u16ZZ self;
9865 public:
9866         COption_C2Tuple_u64u16ZZ(const COption_C2Tuple_u64u16ZZ&) = delete;
9867         COption_C2Tuple_u64u16ZZ(COption_C2Tuple_u64u16ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_u64u16ZZ)); }
9868         COption_C2Tuple_u64u16ZZ(LDKCOption_C2Tuple_u64u16ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_u64u16ZZ)); }
9869         operator LDKCOption_C2Tuple_u64u16ZZ() && { LDKCOption_C2Tuple_u64u16ZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_u64u16ZZ)); return res; }
9870         ~COption_C2Tuple_u64u16ZZ() { COption_C2Tuple_u64u16ZZ_free(self); }
9871         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; }
9872         LDKCOption_C2Tuple_u64u16ZZ* operator &() { return &self; }
9873         LDKCOption_C2Tuple_u64u16ZZ* operator ->() { return &self; }
9874         const LDKCOption_C2Tuple_u64u16ZZ* operator &() const { return &self; }
9875         const LDKCOption_C2Tuple_u64u16ZZ* operator ->() const { return &self; }
9876 };
9877 class CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ {
9878 private:
9879         LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ self;
9880 public:
9881         CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(const CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&) = delete;
9882         CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); }
9883         CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); }
9884         operator LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ() && { LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); return res; }
9885         ~CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ() { CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(self); }
9886         CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ& operator=(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& o) { CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); return *this; }
9887         LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator &() { return &self; }
9888         LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator ->() { return &self; }
9889         const LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator &() const { return &self; }
9890         const LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator ->() const { return &self; }
9891 };
9892 class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ {
9893 private:
9894         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ self;
9895 public:
9896         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(const CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&) = delete;
9897         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); }
9898         CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); }
9899         operator LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ() && { LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); return res; }
9900         ~CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ() { CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(self); }
9901         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; }
9902         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator &() { return &self; }
9903         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator ->() { return &self; }
9904         const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator &() const { return &self; }
9905         const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator ->() const { return &self; }
9906 };
9907 class CResult_ChannelDerivationParametersDecodeErrorZ {
9908 private:
9909         LDKCResult_ChannelDerivationParametersDecodeErrorZ self;
9910 public:
9911         CResult_ChannelDerivationParametersDecodeErrorZ(const CResult_ChannelDerivationParametersDecodeErrorZ&) = delete;
9912         CResult_ChannelDerivationParametersDecodeErrorZ(CResult_ChannelDerivationParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelDerivationParametersDecodeErrorZ)); }
9913         CResult_ChannelDerivationParametersDecodeErrorZ(LDKCResult_ChannelDerivationParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelDerivationParametersDecodeErrorZ)); }
9914         operator LDKCResult_ChannelDerivationParametersDecodeErrorZ() && { LDKCResult_ChannelDerivationParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelDerivationParametersDecodeErrorZ)); return res; }
9915         ~CResult_ChannelDerivationParametersDecodeErrorZ() { CResult_ChannelDerivationParametersDecodeErrorZ_free(self); }
9916         CResult_ChannelDerivationParametersDecodeErrorZ& operator=(CResult_ChannelDerivationParametersDecodeErrorZ&& o) { CResult_ChannelDerivationParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelDerivationParametersDecodeErrorZ)); return *this; }
9917         LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator &() { return &self; }
9918         LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator ->() { return &self; }
9919         const LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator &() const { return &self; }
9920         const LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator ->() const { return &self; }
9921 };
9922 class CResult_PaymentConstraintsDecodeErrorZ {
9923 private:
9924         LDKCResult_PaymentConstraintsDecodeErrorZ self;
9925 public:
9926         CResult_PaymentConstraintsDecodeErrorZ(const CResult_PaymentConstraintsDecodeErrorZ&) = delete;
9927         CResult_PaymentConstraintsDecodeErrorZ(CResult_PaymentConstraintsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentConstraintsDecodeErrorZ)); }
9928         CResult_PaymentConstraintsDecodeErrorZ(LDKCResult_PaymentConstraintsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ)); }
9929         operator LDKCResult_PaymentConstraintsDecodeErrorZ() && { LDKCResult_PaymentConstraintsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ)); return res; }
9930         ~CResult_PaymentConstraintsDecodeErrorZ() { CResult_PaymentConstraintsDecodeErrorZ_free(self); }
9931         CResult_PaymentConstraintsDecodeErrorZ& operator=(CResult_PaymentConstraintsDecodeErrorZ&& o) { CResult_PaymentConstraintsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentConstraintsDecodeErrorZ)); return *this; }
9932         LDKCResult_PaymentConstraintsDecodeErrorZ* operator &() { return &self; }
9933         LDKCResult_PaymentConstraintsDecodeErrorZ* operator ->() { return &self; }
9934         const LDKCResult_PaymentConstraintsDecodeErrorZ* operator &() const { return &self; }
9935         const LDKCResult_PaymentConstraintsDecodeErrorZ* operator ->() const { return &self; }
9936 };
9937 class C2Tuple_u32CVec_u8ZZ {
9938 private:
9939         LDKC2Tuple_u32CVec_u8ZZ self;
9940 public:
9941         C2Tuple_u32CVec_u8ZZ(const C2Tuple_u32CVec_u8ZZ&) = delete;
9942         C2Tuple_u32CVec_u8ZZ(C2Tuple_u32CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u32CVec_u8ZZ)); }
9943         C2Tuple_u32CVec_u8ZZ(LDKC2Tuple_u32CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u32CVec_u8ZZ)); }
9944         operator LDKC2Tuple_u32CVec_u8ZZ() && { LDKC2Tuple_u32CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u32CVec_u8ZZ)); return res; }
9945         ~C2Tuple_u32CVec_u8ZZ() { C2Tuple_u32CVec_u8ZZ_free(self); }
9946         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; }
9947         LDKC2Tuple_u32CVec_u8ZZ* operator &() { return &self; }
9948         LDKC2Tuple_u32CVec_u8ZZ* operator ->() { return &self; }
9949         const LDKC2Tuple_u32CVec_u8ZZ* operator &() const { return &self; }
9950         const LDKC2Tuple_u32CVec_u8ZZ* operator ->() const { return &self; }
9951 };
9952 class CVec_C2Tuple_PublicKeyTypeZZ {
9953 private:
9954         LDKCVec_C2Tuple_PublicKeyTypeZZ self;
9955 public:
9956         CVec_C2Tuple_PublicKeyTypeZZ(const CVec_C2Tuple_PublicKeyTypeZZ&) = delete;
9957         CVec_C2Tuple_PublicKeyTypeZZ(CVec_C2Tuple_PublicKeyTypeZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyTypeZZ)); }
9958         CVec_C2Tuple_PublicKeyTypeZZ(LDKCVec_C2Tuple_PublicKeyTypeZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ)); }
9959         operator LDKCVec_C2Tuple_PublicKeyTypeZZ() && { LDKCVec_C2Tuple_PublicKeyTypeZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ)); return res; }
9960         ~CVec_C2Tuple_PublicKeyTypeZZ() { CVec_C2Tuple_PublicKeyTypeZZ_free(self); }
9961         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; }
9962         LDKCVec_C2Tuple_PublicKeyTypeZZ* operator &() { return &self; }
9963         LDKCVec_C2Tuple_PublicKeyTypeZZ* operator ->() { return &self; }
9964         const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator &() const { return &self; }
9965         const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator ->() const { return &self; }
9966 };
9967 class CResult_OnionMessagePathNoneZ {
9968 private:
9969         LDKCResult_OnionMessagePathNoneZ self;
9970 public:
9971         CResult_OnionMessagePathNoneZ(const CResult_OnionMessagePathNoneZ&) = delete;
9972         CResult_OnionMessagePathNoneZ(CResult_OnionMessagePathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionMessagePathNoneZ)); }
9973         CResult_OnionMessagePathNoneZ(LDKCResult_OnionMessagePathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionMessagePathNoneZ)); }
9974         operator LDKCResult_OnionMessagePathNoneZ() && { LDKCResult_OnionMessagePathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionMessagePathNoneZ)); return res; }
9975         ~CResult_OnionMessagePathNoneZ() { CResult_OnionMessagePathNoneZ_free(self); }
9976         CResult_OnionMessagePathNoneZ& operator=(CResult_OnionMessagePathNoneZ&& o) { CResult_OnionMessagePathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionMessagePathNoneZ)); return *this; }
9977         LDKCResult_OnionMessagePathNoneZ* operator &() { return &self; }
9978         LDKCResult_OnionMessagePathNoneZ* operator ->() { return &self; }
9979         const LDKCResult_OnionMessagePathNoneZ* operator &() const { return &self; }
9980         const LDKCResult_OnionMessagePathNoneZ* operator ->() const { return &self; }
9981 };
9982 class CResult_RefundBolt12ParseErrorZ {
9983 private:
9984         LDKCResult_RefundBolt12ParseErrorZ self;
9985 public:
9986         CResult_RefundBolt12ParseErrorZ(const CResult_RefundBolt12ParseErrorZ&) = delete;
9987         CResult_RefundBolt12ParseErrorZ(CResult_RefundBolt12ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RefundBolt12ParseErrorZ)); }
9988         CResult_RefundBolt12ParseErrorZ(LDKCResult_RefundBolt12ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RefundBolt12ParseErrorZ)); }
9989         operator LDKCResult_RefundBolt12ParseErrorZ() && { LDKCResult_RefundBolt12ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RefundBolt12ParseErrorZ)); return res; }
9990         ~CResult_RefundBolt12ParseErrorZ() { CResult_RefundBolt12ParseErrorZ_free(self); }
9991         CResult_RefundBolt12ParseErrorZ& operator=(CResult_RefundBolt12ParseErrorZ&& o) { CResult_RefundBolt12ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RefundBolt12ParseErrorZ)); return *this; }
9992         LDKCResult_RefundBolt12ParseErrorZ* operator &() { return &self; }
9993         LDKCResult_RefundBolt12ParseErrorZ* operator ->() { return &self; }
9994         const LDKCResult_RefundBolt12ParseErrorZ* operator &() const { return &self; }
9995         const LDKCResult_RefundBolt12ParseErrorZ* operator ->() const { return &self; }
9996 };
9997 class C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ {
9998 private:
9999         LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ self;
10000 public:
10001         C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(const C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&) = delete;
10002         C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); }
10003         C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); }
10004         operator LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ() && { LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); return res; }
10005         ~C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ() { C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(self); }
10006         C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ& operator=(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& o) { C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); return *this; }
10007         LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator &() { return &self; }
10008         LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator ->() { return &self; }
10009         const LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator &() const { return &self; }
10010         const LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator ->() const { return &self; }
10011 };
10012 class CVec_C2Tuple_u64CVec_u8ZZZ {
10013 private:
10014         LDKCVec_C2Tuple_u64CVec_u8ZZZ self;
10015 public:
10016         CVec_C2Tuple_u64CVec_u8ZZZ(const CVec_C2Tuple_u64CVec_u8ZZZ&) = delete;
10017         CVec_C2Tuple_u64CVec_u8ZZZ(CVec_C2Tuple_u64CVec_u8ZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u64CVec_u8ZZZ)); }
10018         CVec_C2Tuple_u64CVec_u8ZZZ(LDKCVec_C2Tuple_u64CVec_u8ZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u64CVec_u8ZZZ)); }
10019         operator LDKCVec_C2Tuple_u64CVec_u8ZZZ() && { LDKCVec_C2Tuple_u64CVec_u8ZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u64CVec_u8ZZZ)); return res; }
10020         ~CVec_C2Tuple_u64CVec_u8ZZZ() { CVec_C2Tuple_u64CVec_u8ZZZ_free(self); }
10021         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; }
10022         LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator &() { return &self; }
10023         LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator ->() { return &self; }
10024         const LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator &() const { return &self; }
10025         const LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator ->() const { return &self; }
10026 };
10027 class CResult_u32GraphSyncErrorZ {
10028 private:
10029         LDKCResult_u32GraphSyncErrorZ self;
10030 public:
10031         CResult_u32GraphSyncErrorZ(const CResult_u32GraphSyncErrorZ&) = delete;
10032         CResult_u32GraphSyncErrorZ(CResult_u32GraphSyncErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); }
10033         CResult_u32GraphSyncErrorZ(LDKCResult_u32GraphSyncErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); }
10034         operator LDKCResult_u32GraphSyncErrorZ() && { LDKCResult_u32GraphSyncErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); return res; }
10035         ~CResult_u32GraphSyncErrorZ() { CResult_u32GraphSyncErrorZ_free(self); }
10036         CResult_u32GraphSyncErrorZ& operator=(CResult_u32GraphSyncErrorZ&& o) { CResult_u32GraphSyncErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); return *this; }
10037         LDKCResult_u32GraphSyncErrorZ* operator &() { return &self; }
10038         LDKCResult_u32GraphSyncErrorZ* operator ->() { return &self; }
10039         const LDKCResult_u32GraphSyncErrorZ* operator &() const { return &self; }
10040         const LDKCResult_u32GraphSyncErrorZ* operator ->() const { return &self; }
10041 };
10042 class CVec_PhantomRouteHintsZ {
10043 private:
10044         LDKCVec_PhantomRouteHintsZ self;
10045 public:
10046         CVec_PhantomRouteHintsZ(const CVec_PhantomRouteHintsZ&) = delete;
10047         CVec_PhantomRouteHintsZ(CVec_PhantomRouteHintsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); }
10048         CVec_PhantomRouteHintsZ(LDKCVec_PhantomRouteHintsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); }
10049         operator LDKCVec_PhantomRouteHintsZ() && { LDKCVec_PhantomRouteHintsZ res = self; memset(&self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); return res; }
10050         ~CVec_PhantomRouteHintsZ() { CVec_PhantomRouteHintsZ_free(self); }
10051         CVec_PhantomRouteHintsZ& operator=(CVec_PhantomRouteHintsZ&& o) { CVec_PhantomRouteHintsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); return *this; }
10052         LDKCVec_PhantomRouteHintsZ* operator &() { return &self; }
10053         LDKCVec_PhantomRouteHintsZ* operator ->() { return &self; }
10054         const LDKCVec_PhantomRouteHintsZ* operator &() const { return &self; }
10055         const LDKCVec_PhantomRouteHintsZ* operator ->() const { return &self; }
10056 };
10057 class CResult_NoneAPIErrorZ {
10058 private:
10059         LDKCResult_NoneAPIErrorZ self;
10060 public:
10061         CResult_NoneAPIErrorZ(const CResult_NoneAPIErrorZ&) = delete;
10062         CResult_NoneAPIErrorZ(CResult_NoneAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); }
10063         CResult_NoneAPIErrorZ(LDKCResult_NoneAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); }
10064         operator LDKCResult_NoneAPIErrorZ() && { LDKCResult_NoneAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); return res; }
10065         ~CResult_NoneAPIErrorZ() { CResult_NoneAPIErrorZ_free(self); }
10066         CResult_NoneAPIErrorZ& operator=(CResult_NoneAPIErrorZ&& o) { CResult_NoneAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); return *this; }
10067         LDKCResult_NoneAPIErrorZ* operator &() { return &self; }
10068         LDKCResult_NoneAPIErrorZ* operator ->() { return &self; }
10069         const LDKCResult_NoneAPIErrorZ* operator &() const { return &self; }
10070         const LDKCResult_NoneAPIErrorZ* operator ->() const { return &self; }
10071 };
10072 class CResult_Bolt12InvoiceFeaturesDecodeErrorZ {
10073 private:
10074         LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ self;
10075 public:
10076         CResult_Bolt12InvoiceFeaturesDecodeErrorZ(const CResult_Bolt12InvoiceFeaturesDecodeErrorZ&) = delete;
10077         CResult_Bolt12InvoiceFeaturesDecodeErrorZ(CResult_Bolt12InvoiceFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt12InvoiceFeaturesDecodeErrorZ)); }
10078         CResult_Bolt12InvoiceFeaturesDecodeErrorZ(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ)); }
10079         operator LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ() && { LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ)); return res; }
10080         ~CResult_Bolt12InvoiceFeaturesDecodeErrorZ() { CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(self); }
10081         CResult_Bolt12InvoiceFeaturesDecodeErrorZ& operator=(CResult_Bolt12InvoiceFeaturesDecodeErrorZ&& o) { CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt12InvoiceFeaturesDecodeErrorZ)); return *this; }
10082         LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator &() { return &self; }
10083         LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator ->() { return &self; }
10084         const LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
10085         const LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
10086 };
10087 class COption_f64Z {
10088 private:
10089         LDKCOption_f64Z self;
10090 public:
10091         COption_f64Z(const COption_f64Z&) = delete;
10092         COption_f64Z(COption_f64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_f64Z)); }
10093         COption_f64Z(LDKCOption_f64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_f64Z)); }
10094         operator LDKCOption_f64Z() && { LDKCOption_f64Z res = self; memset(&self, 0, sizeof(LDKCOption_f64Z)); return res; }
10095         ~COption_f64Z() { COption_f64Z_free(self); }
10096         COption_f64Z& operator=(COption_f64Z&& o) { COption_f64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_f64Z)); return *this; }
10097         LDKCOption_f64Z* operator &() { return &self; }
10098         LDKCOption_f64Z* operator ->() { return &self; }
10099         const LDKCOption_f64Z* operator &() const { return &self; }
10100         const LDKCOption_f64Z* operator ->() const { return &self; }
10101 };
10102 class CResult_ChannelDetailsDecodeErrorZ {
10103 private:
10104         LDKCResult_ChannelDetailsDecodeErrorZ self;
10105 public:
10106         CResult_ChannelDetailsDecodeErrorZ(const CResult_ChannelDetailsDecodeErrorZ&) = delete;
10107         CResult_ChannelDetailsDecodeErrorZ(CResult_ChannelDetailsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelDetailsDecodeErrorZ)); }
10108         CResult_ChannelDetailsDecodeErrorZ(LDKCResult_ChannelDetailsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelDetailsDecodeErrorZ)); }
10109         operator LDKCResult_ChannelDetailsDecodeErrorZ() && { LDKCResult_ChannelDetailsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelDetailsDecodeErrorZ)); return res; }
10110         ~CResult_ChannelDetailsDecodeErrorZ() { CResult_ChannelDetailsDecodeErrorZ_free(self); }
10111         CResult_ChannelDetailsDecodeErrorZ& operator=(CResult_ChannelDetailsDecodeErrorZ&& o) { CResult_ChannelDetailsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelDetailsDecodeErrorZ)); return *this; }
10112         LDKCResult_ChannelDetailsDecodeErrorZ* operator &() { return &self; }
10113         LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() { return &self; }
10114         const LDKCResult_ChannelDetailsDecodeErrorZ* operator &() const { return &self; }
10115         const LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() const { return &self; }
10116 };
10117 class CVec_PublicKeyZ {
10118 private:
10119         LDKCVec_PublicKeyZ self;
10120 public:
10121         CVec_PublicKeyZ(const CVec_PublicKeyZ&) = delete;
10122         CVec_PublicKeyZ(CVec_PublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PublicKeyZ)); }
10123         CVec_PublicKeyZ(LDKCVec_PublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PublicKeyZ)); }
10124         operator LDKCVec_PublicKeyZ() && { LDKCVec_PublicKeyZ res = self; memset(&self, 0, sizeof(LDKCVec_PublicKeyZ)); return res; }
10125         ~CVec_PublicKeyZ() { CVec_PublicKeyZ_free(self); }
10126         CVec_PublicKeyZ& operator=(CVec_PublicKeyZ&& o) { CVec_PublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PublicKeyZ)); return *this; }
10127         LDKCVec_PublicKeyZ* operator &() { return &self; }
10128         LDKCVec_PublicKeyZ* operator ->() { return &self; }
10129         const LDKCVec_PublicKeyZ* operator &() const { return &self; }
10130         const LDKCVec_PublicKeyZ* operator ->() const { return &self; }
10131 };
10132 class CVec_C2Tuple_usizeTransactionZZ {
10133 private:
10134         LDKCVec_C2Tuple_usizeTransactionZZ self;
10135 public:
10136         CVec_C2Tuple_usizeTransactionZZ(const CVec_C2Tuple_usizeTransactionZZ&) = delete;
10137         CVec_C2Tuple_usizeTransactionZZ(CVec_C2Tuple_usizeTransactionZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_usizeTransactionZZ)); }
10138         CVec_C2Tuple_usizeTransactionZZ(LDKCVec_C2Tuple_usizeTransactionZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_usizeTransactionZZ)); }
10139         operator LDKCVec_C2Tuple_usizeTransactionZZ() && { LDKCVec_C2Tuple_usizeTransactionZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_usizeTransactionZZ)); return res; }
10140         ~CVec_C2Tuple_usizeTransactionZZ() { CVec_C2Tuple_usizeTransactionZZ_free(self); }
10141         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; }
10142         LDKCVec_C2Tuple_usizeTransactionZZ* operator &() { return &self; }
10143         LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() { return &self; }
10144         const LDKCVec_C2Tuple_usizeTransactionZZ* operator &() const { return &self; }
10145         const LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() const { return &self; }
10146 };
10147 class CResult_TxRemoveInputDecodeErrorZ {
10148 private:
10149         LDKCResult_TxRemoveInputDecodeErrorZ self;
10150 public:
10151         CResult_TxRemoveInputDecodeErrorZ(const CResult_TxRemoveInputDecodeErrorZ&) = delete;
10152         CResult_TxRemoveInputDecodeErrorZ(CResult_TxRemoveInputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxRemoveInputDecodeErrorZ)); }
10153         CResult_TxRemoveInputDecodeErrorZ(LDKCResult_TxRemoveInputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxRemoveInputDecodeErrorZ)); }
10154         operator LDKCResult_TxRemoveInputDecodeErrorZ() && { LDKCResult_TxRemoveInputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxRemoveInputDecodeErrorZ)); return res; }
10155         ~CResult_TxRemoveInputDecodeErrorZ() { CResult_TxRemoveInputDecodeErrorZ_free(self); }
10156         CResult_TxRemoveInputDecodeErrorZ& operator=(CResult_TxRemoveInputDecodeErrorZ&& o) { CResult_TxRemoveInputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxRemoveInputDecodeErrorZ)); return *this; }
10157         LDKCResult_TxRemoveInputDecodeErrorZ* operator &() { return &self; }
10158         LDKCResult_TxRemoveInputDecodeErrorZ* operator ->() { return &self; }
10159         const LDKCResult_TxRemoveInputDecodeErrorZ* operator &() const { return &self; }
10160         const LDKCResult_TxRemoveInputDecodeErrorZ* operator ->() const { return &self; }
10161 };
10162 class CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ {
10163 private:
10164         LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ self;
10165 public:
10166         CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(const CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&) = delete;
10167         CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); }
10168         CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); }
10169         operator LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); return res; }
10170         ~CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ() { CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(self); }
10171         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; }
10172         LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator &() { return &self; }
10173         LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator ->() { return &self; }
10174         const LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator &() const { return &self; }
10175         const LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator ->() const { return &self; }
10176 };
10177 class CResult_OffersMessageDecodeErrorZ {
10178 private:
10179         LDKCResult_OffersMessageDecodeErrorZ self;
10180 public:
10181         CResult_OffersMessageDecodeErrorZ(const CResult_OffersMessageDecodeErrorZ&) = delete;
10182         CResult_OffersMessageDecodeErrorZ(CResult_OffersMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OffersMessageDecodeErrorZ)); }
10183         CResult_OffersMessageDecodeErrorZ(LDKCResult_OffersMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OffersMessageDecodeErrorZ)); }
10184         operator LDKCResult_OffersMessageDecodeErrorZ() && { LDKCResult_OffersMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OffersMessageDecodeErrorZ)); return res; }
10185         ~CResult_OffersMessageDecodeErrorZ() { CResult_OffersMessageDecodeErrorZ_free(self); }
10186         CResult_OffersMessageDecodeErrorZ& operator=(CResult_OffersMessageDecodeErrorZ&& o) { CResult_OffersMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OffersMessageDecodeErrorZ)); return *this; }
10187         LDKCResult_OffersMessageDecodeErrorZ* operator &() { return &self; }
10188         LDKCResult_OffersMessageDecodeErrorZ* operator ->() { return &self; }
10189         const LDKCResult_OffersMessageDecodeErrorZ* operator &() const { return &self; }
10190         const LDKCResult_OffersMessageDecodeErrorZ* operator ->() const { return &self; }
10191 };
10192 class C2Tuple_u64u64Z {
10193 private:
10194         LDKC2Tuple_u64u64Z self;
10195 public:
10196         C2Tuple_u64u64Z(const C2Tuple_u64u64Z&) = delete;
10197         C2Tuple_u64u64Z(C2Tuple_u64u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64u64Z)); }
10198         C2Tuple_u64u64Z(LDKC2Tuple_u64u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64u64Z)); }
10199         operator LDKC2Tuple_u64u64Z() && { LDKC2Tuple_u64u64Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64u64Z)); return res; }
10200         ~C2Tuple_u64u64Z() { C2Tuple_u64u64Z_free(self); }
10201         C2Tuple_u64u64Z& operator=(C2Tuple_u64u64Z&& o) { C2Tuple_u64u64Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u64u64Z)); return *this; }
10202         LDKC2Tuple_u64u64Z* operator &() { return &self; }
10203         LDKC2Tuple_u64u64Z* operator ->() { return &self; }
10204         const LDKC2Tuple_u64u64Z* operator &() const { return &self; }
10205         const LDKC2Tuple_u64u64Z* operator ->() const { return &self; }
10206 };
10207 class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
10208 private:
10209         LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ self;
10210 public:
10211         CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(const CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&) = delete;
10212         CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
10213         CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
10214         operator LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ() && { LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return res; }
10215         ~CResult_CounterpartyChannelTransactionParametersDecodeErrorZ() { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); }
10216         CResult_CounterpartyChannelTransactionParametersDecodeErrorZ& operator=(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return *this; }
10217         LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
10218         LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
10219         const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
10220         const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
10221 };
10222 class CResult_RecipientOnionFieldsDecodeErrorZ {
10223 private:
10224         LDKCResult_RecipientOnionFieldsDecodeErrorZ self;
10225 public:
10226         CResult_RecipientOnionFieldsDecodeErrorZ(const CResult_RecipientOnionFieldsDecodeErrorZ&) = delete;
10227         CResult_RecipientOnionFieldsDecodeErrorZ(CResult_RecipientOnionFieldsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecipientOnionFieldsDecodeErrorZ)); }
10228         CResult_RecipientOnionFieldsDecodeErrorZ(LDKCResult_RecipientOnionFieldsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ)); }
10229         operator LDKCResult_RecipientOnionFieldsDecodeErrorZ() && { LDKCResult_RecipientOnionFieldsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ)); return res; }
10230         ~CResult_RecipientOnionFieldsDecodeErrorZ() { CResult_RecipientOnionFieldsDecodeErrorZ_free(self); }
10231         CResult_RecipientOnionFieldsDecodeErrorZ& operator=(CResult_RecipientOnionFieldsDecodeErrorZ&& o) { CResult_RecipientOnionFieldsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecipientOnionFieldsDecodeErrorZ)); return *this; }
10232         LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator &() { return &self; }
10233         LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator ->() { return &self; }
10234         const LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator &() const { return &self; }
10235         const LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator ->() const { return &self; }
10236 };
10237 class C2Tuple_u32TxOutZ {
10238 private:
10239         LDKC2Tuple_u32TxOutZ self;
10240 public:
10241         C2Tuple_u32TxOutZ(const C2Tuple_u32TxOutZ&) = delete;
10242         C2Tuple_u32TxOutZ(C2Tuple_u32TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u32TxOutZ)); }
10243         C2Tuple_u32TxOutZ(LDKC2Tuple_u32TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u32TxOutZ)); }
10244         operator LDKC2Tuple_u32TxOutZ() && { LDKC2Tuple_u32TxOutZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u32TxOutZ)); return res; }
10245         ~C2Tuple_u32TxOutZ() { C2Tuple_u32TxOutZ_free(self); }
10246         C2Tuple_u32TxOutZ& operator=(C2Tuple_u32TxOutZ&& o) { C2Tuple_u32TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u32TxOutZ)); return *this; }
10247         LDKC2Tuple_u32TxOutZ* operator &() { return &self; }
10248         LDKC2Tuple_u32TxOutZ* operator ->() { return &self; }
10249         const LDKC2Tuple_u32TxOutZ* operator &() const { return &self; }
10250         const LDKC2Tuple_u32TxOutZ* operator ->() const { return &self; }
10251 };
10252 class CVec_UtxoZ {
10253 private:
10254         LDKCVec_UtxoZ self;
10255 public:
10256         CVec_UtxoZ(const CVec_UtxoZ&) = delete;
10257         CVec_UtxoZ(CVec_UtxoZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UtxoZ)); }
10258         CVec_UtxoZ(LDKCVec_UtxoZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UtxoZ)); }
10259         operator LDKCVec_UtxoZ() && { LDKCVec_UtxoZ res = self; memset(&self, 0, sizeof(LDKCVec_UtxoZ)); return res; }
10260         ~CVec_UtxoZ() { CVec_UtxoZ_free(self); }
10261         CVec_UtxoZ& operator=(CVec_UtxoZ&& o) { CVec_UtxoZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UtxoZ)); return *this; }
10262         LDKCVec_UtxoZ* operator &() { return &self; }
10263         LDKCVec_UtxoZ* operator ->() { return &self; }
10264         const LDKCVec_UtxoZ* operator &() const { return &self; }
10265         const LDKCVec_UtxoZ* operator ->() const { return &self; }
10266 };
10267 class CResult_ChannelConfigDecodeErrorZ {
10268 private:
10269         LDKCResult_ChannelConfigDecodeErrorZ self;
10270 public:
10271         CResult_ChannelConfigDecodeErrorZ(const CResult_ChannelConfigDecodeErrorZ&) = delete;
10272         CResult_ChannelConfigDecodeErrorZ(CResult_ChannelConfigDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelConfigDecodeErrorZ)); }
10273         CResult_ChannelConfigDecodeErrorZ(LDKCResult_ChannelConfigDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelConfigDecodeErrorZ)); }
10274         operator LDKCResult_ChannelConfigDecodeErrorZ() && { LDKCResult_ChannelConfigDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelConfigDecodeErrorZ)); return res; }
10275         ~CResult_ChannelConfigDecodeErrorZ() { CResult_ChannelConfigDecodeErrorZ_free(self); }
10276         CResult_ChannelConfigDecodeErrorZ& operator=(CResult_ChannelConfigDecodeErrorZ&& o) { CResult_ChannelConfigDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelConfigDecodeErrorZ)); return *this; }
10277         LDKCResult_ChannelConfigDecodeErrorZ* operator &() { return &self; }
10278         LDKCResult_ChannelConfigDecodeErrorZ* operator ->() { return &self; }
10279         const LDKCResult_ChannelConfigDecodeErrorZ* operator &() const { return &self; }
10280         const LDKCResult_ChannelConfigDecodeErrorZ* operator ->() const { return &self; }
10281 };
10282 class CVec_PrivateRouteZ {
10283 private:
10284         LDKCVec_PrivateRouteZ self;
10285 public:
10286         CVec_PrivateRouteZ(const CVec_PrivateRouteZ&) = delete;
10287         CVec_PrivateRouteZ(CVec_PrivateRouteZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PrivateRouteZ)); }
10288         CVec_PrivateRouteZ(LDKCVec_PrivateRouteZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PrivateRouteZ)); }
10289         operator LDKCVec_PrivateRouteZ() && { LDKCVec_PrivateRouteZ res = self; memset(&self, 0, sizeof(LDKCVec_PrivateRouteZ)); return res; }
10290         ~CVec_PrivateRouteZ() { CVec_PrivateRouteZ_free(self); }
10291         CVec_PrivateRouteZ& operator=(CVec_PrivateRouteZ&& o) { CVec_PrivateRouteZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PrivateRouteZ)); return *this; }
10292         LDKCVec_PrivateRouteZ* operator &() { return &self; }
10293         LDKCVec_PrivateRouteZ* operator ->() { return &self; }
10294         const LDKCVec_PrivateRouteZ* operator &() const { return &self; }
10295         const LDKCVec_PrivateRouteZ* operator ->() const { return &self; }
10296 };
10297 class COption_i64Z {
10298 private:
10299         LDKCOption_i64Z self;
10300 public:
10301         COption_i64Z(const COption_i64Z&) = delete;
10302         COption_i64Z(COption_i64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_i64Z)); }
10303         COption_i64Z(LDKCOption_i64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_i64Z)); }
10304         operator LDKCOption_i64Z() && { LDKCOption_i64Z res = self; memset(&self, 0, sizeof(LDKCOption_i64Z)); return res; }
10305         ~COption_i64Z() { COption_i64Z_free(self); }
10306         COption_i64Z& operator=(COption_i64Z&& o) { COption_i64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_i64Z)); return *this; }
10307         LDKCOption_i64Z* operator &() { return &self; }
10308         LDKCOption_i64Z* operator ->() { return &self; }
10309         const LDKCOption_i64Z* operator &() const { return &self; }
10310         const LDKCOption_i64Z* operator ->() const { return &self; }
10311 };
10312 class C2Tuple_ThirtyTwoBytesChannelManagerZ {
10313 private:
10314         LDKC2Tuple_ThirtyTwoBytesChannelManagerZ self;
10315 public:
10316         C2Tuple_ThirtyTwoBytesChannelManagerZ(const C2Tuple_ThirtyTwoBytesChannelManagerZ&) = delete;
10317         C2Tuple_ThirtyTwoBytesChannelManagerZ(C2Tuple_ThirtyTwoBytesChannelManagerZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelManagerZ)); }
10318         C2Tuple_ThirtyTwoBytesChannelManagerZ(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ)); }
10319         operator LDKC2Tuple_ThirtyTwoBytesChannelManagerZ() && { LDKC2Tuple_ThirtyTwoBytesChannelManagerZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ)); return res; }
10320         ~C2Tuple_ThirtyTwoBytesChannelManagerZ() { C2Tuple_ThirtyTwoBytesChannelManagerZ_free(self); }
10321         C2Tuple_ThirtyTwoBytesChannelManagerZ& operator=(C2Tuple_ThirtyTwoBytesChannelManagerZ&& o) { C2Tuple_ThirtyTwoBytesChannelManagerZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelManagerZ)); return *this; }
10322         LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator &() { return &self; }
10323         LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator ->() { return &self; }
10324         const LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator &() const { return &self; }
10325         const LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator ->() const { return &self; }
10326 };
10327 class CResult_ShutdownDecodeErrorZ {
10328 private:
10329         LDKCResult_ShutdownDecodeErrorZ self;
10330 public:
10331         CResult_ShutdownDecodeErrorZ(const CResult_ShutdownDecodeErrorZ&) = delete;
10332         CResult_ShutdownDecodeErrorZ(CResult_ShutdownDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownDecodeErrorZ)); }
10333         CResult_ShutdownDecodeErrorZ(LDKCResult_ShutdownDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownDecodeErrorZ)); }
10334         operator LDKCResult_ShutdownDecodeErrorZ() && { LDKCResult_ShutdownDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownDecodeErrorZ)); return res; }
10335         ~CResult_ShutdownDecodeErrorZ() { CResult_ShutdownDecodeErrorZ_free(self); }
10336         CResult_ShutdownDecodeErrorZ& operator=(CResult_ShutdownDecodeErrorZ&& o) { CResult_ShutdownDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownDecodeErrorZ)); return *this; }
10337         LDKCResult_ShutdownDecodeErrorZ* operator &() { return &self; }
10338         LDKCResult_ShutdownDecodeErrorZ* operator ->() { return &self; }
10339         const LDKCResult_ShutdownDecodeErrorZ* operator &() const { return &self; }
10340         const LDKCResult_ShutdownDecodeErrorZ* operator ->() const { return &self; }
10341 };
10342 class C2Tuple_u64CVec_u8ZZ {
10343 private:
10344         LDKC2Tuple_u64CVec_u8ZZ self;
10345 public:
10346         C2Tuple_u64CVec_u8ZZ(const C2Tuple_u64CVec_u8ZZ&) = delete;
10347         C2Tuple_u64CVec_u8ZZ(C2Tuple_u64CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64CVec_u8ZZ)); }
10348         C2Tuple_u64CVec_u8ZZ(LDKC2Tuple_u64CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64CVec_u8ZZ)); }
10349         operator LDKC2Tuple_u64CVec_u8ZZ() && { LDKC2Tuple_u64CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64CVec_u8ZZ)); return res; }
10350         ~C2Tuple_u64CVec_u8ZZ() { C2Tuple_u64CVec_u8ZZ_free(self); }
10351         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; }
10352         LDKC2Tuple_u64CVec_u8ZZ* operator &() { return &self; }
10353         LDKC2Tuple_u64CVec_u8ZZ* operator ->() { return &self; }
10354         const LDKC2Tuple_u64CVec_u8ZZ* operator &() const { return &self; }
10355         const LDKC2Tuple_u64CVec_u8ZZ* operator ->() const { return &self; }
10356 };
10357 class CResult_OfferBolt12ParseErrorZ {
10358 private:
10359         LDKCResult_OfferBolt12ParseErrorZ self;
10360 public:
10361         CResult_OfferBolt12ParseErrorZ(const CResult_OfferBolt12ParseErrorZ&) = delete;
10362         CResult_OfferBolt12ParseErrorZ(CResult_OfferBolt12ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OfferBolt12ParseErrorZ)); }
10363         CResult_OfferBolt12ParseErrorZ(LDKCResult_OfferBolt12ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OfferBolt12ParseErrorZ)); }
10364         operator LDKCResult_OfferBolt12ParseErrorZ() && { LDKCResult_OfferBolt12ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OfferBolt12ParseErrorZ)); return res; }
10365         ~CResult_OfferBolt12ParseErrorZ() { CResult_OfferBolt12ParseErrorZ_free(self); }
10366         CResult_OfferBolt12ParseErrorZ& operator=(CResult_OfferBolt12ParseErrorZ&& o) { CResult_OfferBolt12ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OfferBolt12ParseErrorZ)); return *this; }
10367         LDKCResult_OfferBolt12ParseErrorZ* operator &() { return &self; }
10368         LDKCResult_OfferBolt12ParseErrorZ* operator ->() { return &self; }
10369         const LDKCResult_OfferBolt12ParseErrorZ* operator &() const { return &self; }
10370         const LDKCResult_OfferBolt12ParseErrorZ* operator ->() const { return &self; }
10371 };
10372 class CResult_ThirtyTwoBytesRetryableSendFailureZ {
10373 private:
10374         LDKCResult_ThirtyTwoBytesRetryableSendFailureZ self;
10375 public:
10376         CResult_ThirtyTwoBytesRetryableSendFailureZ(const CResult_ThirtyTwoBytesRetryableSendFailureZ&) = delete;
10377         CResult_ThirtyTwoBytesRetryableSendFailureZ(CResult_ThirtyTwoBytesRetryableSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesRetryableSendFailureZ)); }
10378         CResult_ThirtyTwoBytesRetryableSendFailureZ(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ)); }
10379         operator LDKCResult_ThirtyTwoBytesRetryableSendFailureZ() && { LDKCResult_ThirtyTwoBytesRetryableSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ)); return res; }
10380         ~CResult_ThirtyTwoBytesRetryableSendFailureZ() { CResult_ThirtyTwoBytesRetryableSendFailureZ_free(self); }
10381         CResult_ThirtyTwoBytesRetryableSendFailureZ& operator=(CResult_ThirtyTwoBytesRetryableSendFailureZ&& o) { CResult_ThirtyTwoBytesRetryableSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesRetryableSendFailureZ)); return *this; }
10382         LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator &() { return &self; }
10383         LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator ->() { return &self; }
10384         const LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator &() const { return &self; }
10385         const LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator ->() const { return &self; }
10386 };
10387 class CVec_MonitorEventZ {
10388 private:
10389         LDKCVec_MonitorEventZ self;
10390 public:
10391         CVec_MonitorEventZ(const CVec_MonitorEventZ&) = delete;
10392         CVec_MonitorEventZ(CVec_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorEventZ)); }
10393         CVec_MonitorEventZ(LDKCVec_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorEventZ)); }
10394         operator LDKCVec_MonitorEventZ() && { LDKCVec_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorEventZ)); return res; }
10395         ~CVec_MonitorEventZ() { CVec_MonitorEventZ_free(self); }
10396         CVec_MonitorEventZ& operator=(CVec_MonitorEventZ&& o) { CVec_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MonitorEventZ)); return *this; }
10397         LDKCVec_MonitorEventZ* operator &() { return &self; }
10398         LDKCVec_MonitorEventZ* operator ->() { return &self; }
10399         const LDKCVec_MonitorEventZ* operator &() const { return &self; }
10400         const LDKCVec_MonitorEventZ* operator ->() const { return &self; }
10401 };
10402 class CResult_BigSizeDecodeErrorZ {
10403 private:
10404         LDKCResult_BigSizeDecodeErrorZ self;
10405 public:
10406         CResult_BigSizeDecodeErrorZ(const CResult_BigSizeDecodeErrorZ&) = delete;
10407         CResult_BigSizeDecodeErrorZ(CResult_BigSizeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BigSizeDecodeErrorZ)); }
10408         CResult_BigSizeDecodeErrorZ(LDKCResult_BigSizeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BigSizeDecodeErrorZ)); }
10409         operator LDKCResult_BigSizeDecodeErrorZ() && { LDKCResult_BigSizeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BigSizeDecodeErrorZ)); return res; }
10410         ~CResult_BigSizeDecodeErrorZ() { CResult_BigSizeDecodeErrorZ_free(self); }
10411         CResult_BigSizeDecodeErrorZ& operator=(CResult_BigSizeDecodeErrorZ&& o) { CResult_BigSizeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BigSizeDecodeErrorZ)); return *this; }
10412         LDKCResult_BigSizeDecodeErrorZ* operator &() { return &self; }
10413         LDKCResult_BigSizeDecodeErrorZ* operator ->() { return &self; }
10414         const LDKCResult_BigSizeDecodeErrorZ* operator &() const { return &self; }
10415         const LDKCResult_BigSizeDecodeErrorZ* operator ->() const { return &self; }
10416 };
10417 class CResult_TxOutUtxoLookupErrorZ {
10418 private:
10419         LDKCResult_TxOutUtxoLookupErrorZ self;
10420 public:
10421         CResult_TxOutUtxoLookupErrorZ(const CResult_TxOutUtxoLookupErrorZ&) = delete;
10422         CResult_TxOutUtxoLookupErrorZ(CResult_TxOutUtxoLookupErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxOutUtxoLookupErrorZ)); }
10423         CResult_TxOutUtxoLookupErrorZ(LDKCResult_TxOutUtxoLookupErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxOutUtxoLookupErrorZ)); }
10424         operator LDKCResult_TxOutUtxoLookupErrorZ() && { LDKCResult_TxOutUtxoLookupErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxOutUtxoLookupErrorZ)); return res; }
10425         ~CResult_TxOutUtxoLookupErrorZ() { CResult_TxOutUtxoLookupErrorZ_free(self); }
10426         CResult_TxOutUtxoLookupErrorZ& operator=(CResult_TxOutUtxoLookupErrorZ&& o) { CResult_TxOutUtxoLookupErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxOutUtxoLookupErrorZ)); return *this; }
10427         LDKCResult_TxOutUtxoLookupErrorZ* operator &() { return &self; }
10428         LDKCResult_TxOutUtxoLookupErrorZ* operator ->() { return &self; }
10429         const LDKCResult_TxOutUtxoLookupErrorZ* operator &() const { return &self; }
10430         const LDKCResult_TxOutUtxoLookupErrorZ* operator ->() const { return &self; }
10431 };
10432 class CResult_BlindedPathNoneZ {
10433 private:
10434         LDKCResult_BlindedPathNoneZ self;
10435 public:
10436         CResult_BlindedPathNoneZ(const CResult_BlindedPathNoneZ&) = delete;
10437         CResult_BlindedPathNoneZ(CResult_BlindedPathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPathNoneZ)); }
10438         CResult_BlindedPathNoneZ(LDKCResult_BlindedPathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPathNoneZ)); }
10439         operator LDKCResult_BlindedPathNoneZ() && { LDKCResult_BlindedPathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPathNoneZ)); return res; }
10440         ~CResult_BlindedPathNoneZ() { CResult_BlindedPathNoneZ_free(self); }
10441         CResult_BlindedPathNoneZ& operator=(CResult_BlindedPathNoneZ&& o) { CResult_BlindedPathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPathNoneZ)); return *this; }
10442         LDKCResult_BlindedPathNoneZ* operator &() { return &self; }
10443         LDKCResult_BlindedPathNoneZ* operator ->() { return &self; }
10444         const LDKCResult_BlindedPathNoneZ* operator &() const { return &self; }
10445         const LDKCResult_BlindedPathNoneZ* operator ->() const { return &self; }
10446 };
10447 class COption_usizeZ {
10448 private:
10449         LDKCOption_usizeZ self;
10450 public:
10451         COption_usizeZ(const COption_usizeZ&) = delete;
10452         COption_usizeZ(COption_usizeZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_usizeZ)); }
10453         COption_usizeZ(LDKCOption_usizeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_usizeZ)); }
10454         operator LDKCOption_usizeZ() && { LDKCOption_usizeZ res = self; memset(&self, 0, sizeof(LDKCOption_usizeZ)); return res; }
10455         ~COption_usizeZ() { COption_usizeZ_free(self); }
10456         COption_usizeZ& operator=(COption_usizeZ&& o) { COption_usizeZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_usizeZ)); return *this; }
10457         LDKCOption_usizeZ* operator &() { return &self; }
10458         LDKCOption_usizeZ* operator ->() { return &self; }
10459         const LDKCOption_usizeZ* operator &() const { return &self; }
10460         const LDKCOption_usizeZ* operator ->() const { return &self; }
10461 };
10462 class CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ {
10463 private:
10464         LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ self;
10465 public:
10466         CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(const CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&) = delete;
10467         CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); }
10468         CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); }
10469         operator LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ() && { LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); return res; }
10470         ~CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ() { CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(self); }
10471         CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ& operator=(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& o) { CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); return *this; }
10472         LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator &() { return &self; }
10473         LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator ->() { return &self; }
10474         const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator &() const { return &self; }
10475         const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator ->() const { return &self; }
10476 };
10477 class CResult_NoneNoneZ {
10478 private:
10479         LDKCResult_NoneNoneZ self;
10480 public:
10481         CResult_NoneNoneZ(const CResult_NoneNoneZ&) = delete;
10482         CResult_NoneNoneZ(CResult_NoneNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneNoneZ)); }
10483         CResult_NoneNoneZ(LDKCResult_NoneNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneNoneZ)); }
10484         operator LDKCResult_NoneNoneZ() && { LDKCResult_NoneNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneNoneZ)); return res; }
10485         ~CResult_NoneNoneZ() { CResult_NoneNoneZ_free(self); }
10486         CResult_NoneNoneZ& operator=(CResult_NoneNoneZ&& o) { CResult_NoneNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneNoneZ)); return *this; }
10487         LDKCResult_NoneNoneZ* operator &() { return &self; }
10488         LDKCResult_NoneNoneZ* operator ->() { return &self; }
10489         const LDKCResult_NoneNoneZ* operator &() const { return &self; }
10490         const LDKCResult_NoneNoneZ* operator ->() const { return &self; }
10491 };
10492 class CResult_boolPeerHandleErrorZ {
10493 private:
10494         LDKCResult_boolPeerHandleErrorZ self;
10495 public:
10496         CResult_boolPeerHandleErrorZ(const CResult_boolPeerHandleErrorZ&) = delete;
10497         CResult_boolPeerHandleErrorZ(CResult_boolPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); }
10498         CResult_boolPeerHandleErrorZ(LDKCResult_boolPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); }
10499         operator LDKCResult_boolPeerHandleErrorZ() && { LDKCResult_boolPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); return res; }
10500         ~CResult_boolPeerHandleErrorZ() { CResult_boolPeerHandleErrorZ_free(self); }
10501         CResult_boolPeerHandleErrorZ& operator=(CResult_boolPeerHandleErrorZ&& o) { CResult_boolPeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); return *this; }
10502         LDKCResult_boolPeerHandleErrorZ* operator &() { return &self; }
10503         LDKCResult_boolPeerHandleErrorZ* operator ->() { return &self; }
10504         const LDKCResult_boolPeerHandleErrorZ* operator &() const { return &self; }
10505         const LDKCResult_boolPeerHandleErrorZ* operator ->() const { return &self; }
10506 };
10507 class CResult_ChannelUpdateDecodeErrorZ {
10508 private:
10509         LDKCResult_ChannelUpdateDecodeErrorZ self;
10510 public:
10511         CResult_ChannelUpdateDecodeErrorZ(const CResult_ChannelUpdateDecodeErrorZ&) = delete;
10512         CResult_ChannelUpdateDecodeErrorZ(CResult_ChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); }
10513         CResult_ChannelUpdateDecodeErrorZ(LDKCResult_ChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); }
10514         operator LDKCResult_ChannelUpdateDecodeErrorZ() && { LDKCResult_ChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); return res; }
10515         ~CResult_ChannelUpdateDecodeErrorZ() { CResult_ChannelUpdateDecodeErrorZ_free(self); }
10516         CResult_ChannelUpdateDecodeErrorZ& operator=(CResult_ChannelUpdateDecodeErrorZ&& o) { CResult_ChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); return *this; }
10517         LDKCResult_ChannelUpdateDecodeErrorZ* operator &() { return &self; }
10518         LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() { return &self; }
10519         const LDKCResult_ChannelUpdateDecodeErrorZ* operator &() const { return &self; }
10520         const LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
10521 };
10522 class CVec_APIErrorZ {
10523 private:
10524         LDKCVec_APIErrorZ self;
10525 public:
10526         CVec_APIErrorZ(const CVec_APIErrorZ&) = delete;
10527         CVec_APIErrorZ(CVec_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_APIErrorZ)); }
10528         CVec_APIErrorZ(LDKCVec_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_APIErrorZ)); }
10529         operator LDKCVec_APIErrorZ() && { LDKCVec_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCVec_APIErrorZ)); return res; }
10530         ~CVec_APIErrorZ() { CVec_APIErrorZ_free(self); }
10531         CVec_APIErrorZ& operator=(CVec_APIErrorZ&& o) { CVec_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_APIErrorZ)); return *this; }
10532         LDKCVec_APIErrorZ* operator &() { return &self; }
10533         LDKCVec_APIErrorZ* operator ->() { return &self; }
10534         const LDKCVec_APIErrorZ* operator &() const { return &self; }
10535         const LDKCVec_APIErrorZ* operator ->() const { return &self; }
10536 };
10537 class COption_TxOutZ {
10538 private:
10539         LDKCOption_TxOutZ self;
10540 public:
10541         COption_TxOutZ(const COption_TxOutZ&) = delete;
10542         COption_TxOutZ(COption_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_TxOutZ)); }
10543         COption_TxOutZ(LDKCOption_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_TxOutZ)); }
10544         operator LDKCOption_TxOutZ() && { LDKCOption_TxOutZ res = self; memset(&self, 0, sizeof(LDKCOption_TxOutZ)); return res; }
10545         ~COption_TxOutZ() { COption_TxOutZ_free(self); }
10546         COption_TxOutZ& operator=(COption_TxOutZ&& o) { COption_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_TxOutZ)); return *this; }
10547         LDKCOption_TxOutZ* operator &() { return &self; }
10548         LDKCOption_TxOutZ* operator ->() { return &self; }
10549         const LDKCOption_TxOutZ* operator &() const { return &self; }
10550         const LDKCOption_TxOutZ* operator ->() const { return &self; }
10551 };
10552 class COption_ClosureReasonZ {
10553 private:
10554         LDKCOption_ClosureReasonZ self;
10555 public:
10556         COption_ClosureReasonZ(const COption_ClosureReasonZ&) = delete;
10557         COption_ClosureReasonZ(COption_ClosureReasonZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ClosureReasonZ)); }
10558         COption_ClosureReasonZ(LDKCOption_ClosureReasonZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ClosureReasonZ)); }
10559         operator LDKCOption_ClosureReasonZ() && { LDKCOption_ClosureReasonZ res = self; memset(&self, 0, sizeof(LDKCOption_ClosureReasonZ)); return res; }
10560         ~COption_ClosureReasonZ() { COption_ClosureReasonZ_free(self); }
10561         COption_ClosureReasonZ& operator=(COption_ClosureReasonZ&& o) { COption_ClosureReasonZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ClosureReasonZ)); return *this; }
10562         LDKCOption_ClosureReasonZ* operator &() { return &self; }
10563         LDKCOption_ClosureReasonZ* operator ->() { return &self; }
10564         const LDKCOption_ClosureReasonZ* operator &() const { return &self; }
10565         const LDKCOption_ClosureReasonZ* operator ->() const { return &self; }
10566 };
10567 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ {
10568 private:
10569         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ self;
10570 public:
10571         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&) = delete;
10572         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); }
10573         CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); }
10574         operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); return res; }
10575         ~CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(self); }
10576         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; }
10577         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator &() { return &self; }
10578         LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator ->() { return &self; }
10579         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator &() const { return &self; }
10580         const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator ->() const { return &self; }
10581 };
10582 class CResult_TransactionU16LenLimitedDecodeErrorZ {
10583 private:
10584         LDKCResult_TransactionU16LenLimitedDecodeErrorZ self;
10585 public:
10586         CResult_TransactionU16LenLimitedDecodeErrorZ(const CResult_TransactionU16LenLimitedDecodeErrorZ&) = delete;
10587         CResult_TransactionU16LenLimitedDecodeErrorZ(CResult_TransactionU16LenLimitedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedDecodeErrorZ)); }
10588         CResult_TransactionU16LenLimitedDecodeErrorZ(LDKCResult_TransactionU16LenLimitedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionU16LenLimitedDecodeErrorZ)); }
10589         operator LDKCResult_TransactionU16LenLimitedDecodeErrorZ() && { LDKCResult_TransactionU16LenLimitedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionU16LenLimitedDecodeErrorZ)); return res; }
10590         ~CResult_TransactionU16LenLimitedDecodeErrorZ() { CResult_TransactionU16LenLimitedDecodeErrorZ_free(self); }
10591         CResult_TransactionU16LenLimitedDecodeErrorZ& operator=(CResult_TransactionU16LenLimitedDecodeErrorZ&& o) { CResult_TransactionU16LenLimitedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedDecodeErrorZ)); return *this; }
10592         LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator &() { return &self; }
10593         LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator ->() { return &self; }
10594         const LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator &() const { return &self; }
10595         const LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator ->() const { return &self; }
10596 };
10597 class CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ {
10598 private:
10599         LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ self;
10600 public:
10601         CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(const CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&) = delete;
10602         CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); }
10603         CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); }
10604         operator LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ() && { LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); return res; }
10605         ~CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ() { CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(self); }
10606         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; }
10607         LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator &() { return &self; }
10608         LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator ->() { return &self; }
10609         const LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator &() const { return &self; }
10610         const LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator ->() const { return &self; }
10611 };
10612 class CResult_CounterpartyForwardingInfoDecodeErrorZ {
10613 private:
10614         LDKCResult_CounterpartyForwardingInfoDecodeErrorZ self;
10615 public:
10616         CResult_CounterpartyForwardingInfoDecodeErrorZ(const CResult_CounterpartyForwardingInfoDecodeErrorZ&) = delete;
10617         CResult_CounterpartyForwardingInfoDecodeErrorZ(CResult_CounterpartyForwardingInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyForwardingInfoDecodeErrorZ)); }
10618         CResult_CounterpartyForwardingInfoDecodeErrorZ(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ)); }
10619         operator LDKCResult_CounterpartyForwardingInfoDecodeErrorZ() && { LDKCResult_CounterpartyForwardingInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ)); return res; }
10620         ~CResult_CounterpartyForwardingInfoDecodeErrorZ() { CResult_CounterpartyForwardingInfoDecodeErrorZ_free(self); }
10621         CResult_CounterpartyForwardingInfoDecodeErrorZ& operator=(CResult_CounterpartyForwardingInfoDecodeErrorZ&& o) { CResult_CounterpartyForwardingInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyForwardingInfoDecodeErrorZ)); return *this; }
10622         LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator &() { return &self; }
10623         LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator ->() { return &self; }
10624         const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator &() const { return &self; }
10625         const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator ->() const { return &self; }
10626 };
10627 class CResult_OpenChannelV2DecodeErrorZ {
10628 private:
10629         LDKCResult_OpenChannelV2DecodeErrorZ self;
10630 public:
10631         CResult_OpenChannelV2DecodeErrorZ(const CResult_OpenChannelV2DecodeErrorZ&) = delete;
10632         CResult_OpenChannelV2DecodeErrorZ(CResult_OpenChannelV2DecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OpenChannelV2DecodeErrorZ)); }
10633         CResult_OpenChannelV2DecodeErrorZ(LDKCResult_OpenChannelV2DecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OpenChannelV2DecodeErrorZ)); }
10634         operator LDKCResult_OpenChannelV2DecodeErrorZ() && { LDKCResult_OpenChannelV2DecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OpenChannelV2DecodeErrorZ)); return res; }
10635         ~CResult_OpenChannelV2DecodeErrorZ() { CResult_OpenChannelV2DecodeErrorZ_free(self); }
10636         CResult_OpenChannelV2DecodeErrorZ& operator=(CResult_OpenChannelV2DecodeErrorZ&& o) { CResult_OpenChannelV2DecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OpenChannelV2DecodeErrorZ)); return *this; }
10637         LDKCResult_OpenChannelV2DecodeErrorZ* operator &() { return &self; }
10638         LDKCResult_OpenChannelV2DecodeErrorZ* operator ->() { return &self; }
10639         const LDKCResult_OpenChannelV2DecodeErrorZ* operator &() const { return &self; }
10640         const LDKCResult_OpenChannelV2DecodeErrorZ* operator ->() const { return &self; }
10641 };
10642 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ {
10643 private:
10644         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ self;
10645 public:
10646         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(const CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&) = delete;
10647         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); }
10648         CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); }
10649         operator LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); return res; }
10650         ~CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ() { CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(self); }
10651         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; }
10652         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator &() { return &self; }
10653         LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator ->() { return &self; }
10654         const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator &() const { return &self; }
10655         const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator ->() const { return &self; }
10656 };
10657 class C2Tuple_PublicKeyOnionMessageZ {
10658 private:
10659         LDKC2Tuple_PublicKeyOnionMessageZ self;
10660 public:
10661         C2Tuple_PublicKeyOnionMessageZ(const C2Tuple_PublicKeyOnionMessageZ&) = delete;
10662         C2Tuple_PublicKeyOnionMessageZ(C2Tuple_PublicKeyOnionMessageZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyOnionMessageZ)); }
10663         C2Tuple_PublicKeyOnionMessageZ(LDKC2Tuple_PublicKeyOnionMessageZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyOnionMessageZ)); }
10664         operator LDKC2Tuple_PublicKeyOnionMessageZ() && { LDKC2Tuple_PublicKeyOnionMessageZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyOnionMessageZ)); return res; }
10665         ~C2Tuple_PublicKeyOnionMessageZ() { C2Tuple_PublicKeyOnionMessageZ_free(self); }
10666         C2Tuple_PublicKeyOnionMessageZ& operator=(C2Tuple_PublicKeyOnionMessageZ&& o) { C2Tuple_PublicKeyOnionMessageZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyOnionMessageZ)); return *this; }
10667         LDKC2Tuple_PublicKeyOnionMessageZ* operator &() { return &self; }
10668         LDKC2Tuple_PublicKeyOnionMessageZ* operator ->() { return &self; }
10669         const LDKC2Tuple_PublicKeyOnionMessageZ* operator &() const { return &self; }
10670         const LDKC2Tuple_PublicKeyOnionMessageZ* operator ->() const { return &self; }
10671 };
10672 class CResult_RouteDecodeErrorZ {
10673 private:
10674         LDKCResult_RouteDecodeErrorZ self;
10675 public:
10676         CResult_RouteDecodeErrorZ(const CResult_RouteDecodeErrorZ&) = delete;
10677         CResult_RouteDecodeErrorZ(CResult_RouteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); }
10678         CResult_RouteDecodeErrorZ(LDKCResult_RouteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); }
10679         operator LDKCResult_RouteDecodeErrorZ() && { LDKCResult_RouteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); return res; }
10680         ~CResult_RouteDecodeErrorZ() { CResult_RouteDecodeErrorZ_free(self); }
10681         CResult_RouteDecodeErrorZ& operator=(CResult_RouteDecodeErrorZ&& o) { CResult_RouteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); return *this; }
10682         LDKCResult_RouteDecodeErrorZ* operator &() { return &self; }
10683         LDKCResult_RouteDecodeErrorZ* operator ->() { return &self; }
10684         const LDKCResult_RouteDecodeErrorZ* operator &() const { return &self; }
10685         const LDKCResult_RouteDecodeErrorZ* operator ->() const { return &self; }
10686 };
10687 class CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ {
10688 private:
10689         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ self;
10690 public:
10691         CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(const CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&) = delete;
10692         CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); }
10693         CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); }
10694         operator LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ() && { LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); return res; }
10695         ~CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ() { CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(self); }
10696         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; }
10697         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator &() { return &self; }
10698         LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator ->() { return &self; }
10699         const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator &() const { return &self; }
10700         const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator ->() const { return &self; }
10701 };
10702 class COption_NoneZ {
10703 private:
10704         LDKCOption_NoneZ self;
10705 public:
10706         COption_NoneZ(const COption_NoneZ&) = delete;
10707         COption_NoneZ(COption_NoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NoneZ)); }
10708         COption_NoneZ(LDKCOption_NoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NoneZ)); }
10709         operator LDKCOption_NoneZ() && { LDKCOption_NoneZ res = self; memset(&self, 0, sizeof(LDKCOption_NoneZ)); return res; }
10710         ~COption_NoneZ() { COption_NoneZ_free(self); }
10711         COption_NoneZ& operator=(COption_NoneZ&& o) { COption_NoneZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NoneZ)); return *this; }
10712         LDKCOption_NoneZ* operator &() { return &self; }
10713         LDKCOption_NoneZ* operator ->() { return &self; }
10714         const LDKCOption_NoneZ* operator &() const { return &self; }
10715         const LDKCOption_NoneZ* operator ->() const { return &self; }
10716 };
10717 class CResult_TxAddOutputDecodeErrorZ {
10718 private:
10719         LDKCResult_TxAddOutputDecodeErrorZ self;
10720 public:
10721         CResult_TxAddOutputDecodeErrorZ(const CResult_TxAddOutputDecodeErrorZ&) = delete;
10722         CResult_TxAddOutputDecodeErrorZ(CResult_TxAddOutputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAddOutputDecodeErrorZ)); }
10723         CResult_TxAddOutputDecodeErrorZ(LDKCResult_TxAddOutputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAddOutputDecodeErrorZ)); }
10724         operator LDKCResult_TxAddOutputDecodeErrorZ() && { LDKCResult_TxAddOutputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAddOutputDecodeErrorZ)); return res; }
10725         ~CResult_TxAddOutputDecodeErrorZ() { CResult_TxAddOutputDecodeErrorZ_free(self); }
10726         CResult_TxAddOutputDecodeErrorZ& operator=(CResult_TxAddOutputDecodeErrorZ&& o) { CResult_TxAddOutputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAddOutputDecodeErrorZ)); return *this; }
10727         LDKCResult_TxAddOutputDecodeErrorZ* operator &() { return &self; }
10728         LDKCResult_TxAddOutputDecodeErrorZ* operator ->() { return &self; }
10729         const LDKCResult_TxAddOutputDecodeErrorZ* operator &() const { return &self; }
10730         const LDKCResult_TxAddOutputDecodeErrorZ* operator ->() const { return &self; }
10731 };
10732 class COption_CVec_u8ZZ {
10733 private:
10734         LDKCOption_CVec_u8ZZ self;
10735 public:
10736         COption_CVec_u8ZZ(const COption_CVec_u8ZZ&) = delete;
10737         COption_CVec_u8ZZ(COption_CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_u8ZZ)); }
10738         COption_CVec_u8ZZ(LDKCOption_CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_u8ZZ)); }
10739         operator LDKCOption_CVec_u8ZZ() && { LDKCOption_CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_u8ZZ)); return res; }
10740         ~COption_CVec_u8ZZ() { COption_CVec_u8ZZ_free(self); }
10741         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; }
10742         LDKCOption_CVec_u8ZZ* operator &() { return &self; }
10743         LDKCOption_CVec_u8ZZ* operator ->() { return &self; }
10744         const LDKCOption_CVec_u8ZZ* operator &() const { return &self; }
10745         const LDKCOption_CVec_u8ZZ* operator ->() const { return &self; }
10746 };
10747
10748 inline LDKPublicKey ChannelSigner::get_per_commitment_point(uint64_t idx) {
10749         LDKPublicKey ret = (self.get_per_commitment_point)(self.this_arg, idx);
10750         return ret;
10751 }
10752 inline LDKThirtyTwoBytes ChannelSigner::release_commitment_secret(uint64_t idx) {
10753         LDKThirtyTwoBytes ret = (self.release_commitment_secret)(self.this_arg, idx);
10754         return ret;
10755 }
10756 inline LDK::CResult_NoneNoneZ ChannelSigner::validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ preimages) {
10757         LDK::CResult_NoneNoneZ ret = (self.validate_holder_commitment)(self.this_arg, holder_tx, preimages);
10758         return ret;
10759 }
10760 inline LDKThirtyTwoBytes ChannelSigner::channel_keys_id() {
10761         LDKThirtyTwoBytes ret = (self.channel_keys_id)(self.this_arg);
10762         return ret;
10763 }
10764 inline void ChannelSigner::provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters) {
10765         (self.provide_channel_parameters)(self.this_arg, channel_parameters);
10766 }
10767 inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ EcdsaChannelSigner::sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ preimages) {
10768         LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ ret = (self.sign_counterparty_commitment)(self.this_arg, commitment_tx, preimages);
10769         return ret;
10770 }
10771 inline LDK::CResult_NoneNoneZ EcdsaChannelSigner::validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]) {
10772         LDK::CResult_NoneNoneZ ret = (self.validate_counterparty_revocation)(self.this_arg, idx, secret);
10773         return ret;
10774 }
10775 inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ EcdsaChannelSigner::sign_holder_commitment_and_htlcs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx) {
10776         LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ ret = (self.sign_holder_commitment_and_htlcs)(self.this_arg, commitment_tx);
10777         return ret;
10778 }
10779 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]) {
10780         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_justice_revoked_output)(self.this_arg, justice_tx, input, amount, per_commitment_key);
10781         return ret;
10782 }
10783 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) {
10784         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_justice_revoked_htlc)(self.this_arg, justice_tx, input, amount, per_commitment_key, htlc);
10785         return ret;
10786 }
10787 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor) {
10788         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_htlc_transaction)(self.this_arg, htlc_tx, input, htlc_descriptor);
10789         return ret;
10790 }
10791 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) {
10792         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_counterparty_htlc_transaction)(self.this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
10793         return ret;
10794 }
10795 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx) {
10796         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_closing_transaction)(self.this_arg, closing_tx);
10797         return ret;
10798 }
10799 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input) {
10800         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_anchor_input)(self.this_arg, anchor_tx, input);
10801         return ret;
10802 }
10803 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg) {
10804         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_channel_announcement_with_funding_key)(self.this_arg, msg);
10805         return ret;
10806 }
10807 inline LDKThirtyTwoBytes EntropySource::get_secure_random_bytes() {
10808         LDKThirtyTwoBytes ret = (self.get_secure_random_bytes)(self.this_arg);
10809         return ret;
10810 }
10811 inline LDKThirtyTwoBytes NodeSigner::get_inbound_payment_key_material() {
10812         LDKThirtyTwoBytes ret = (self.get_inbound_payment_key_material)(self.this_arg);
10813         return ret;
10814 }
10815 inline LDK::CResult_PublicKeyNoneZ NodeSigner::get_node_id(enum LDKRecipient recipient) {
10816         LDK::CResult_PublicKeyNoneZ ret = (self.get_node_id)(self.this_arg, recipient);
10817         return ret;
10818 }
10819 inline LDK::CResult_ThirtyTwoBytesNoneZ NodeSigner::ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak) {
10820         LDK::CResult_ThirtyTwoBytesNoneZ ret = (self.ecdh)(self.this_arg, recipient, other_key, tweak);
10821         return ret;
10822 }
10823 inline LDK::CResult_RecoverableSignatureNoneZ NodeSigner::sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient) {
10824         LDK::CResult_RecoverableSignatureNoneZ ret = (self.sign_invoice)(self.this_arg, hrp_bytes, invoice_data, recipient);
10825         return ret;
10826 }
10827 inline LDK::CResult_SchnorrSignatureNoneZ NodeSigner::sign_bolt12_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR invoice_request) {
10828         LDK::CResult_SchnorrSignatureNoneZ ret = (self.sign_bolt12_invoice_request)(self.this_arg, invoice_request);
10829         return ret;
10830 }
10831 inline LDK::CResult_SchnorrSignatureNoneZ NodeSigner::sign_bolt12_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR invoice) {
10832         LDK::CResult_SchnorrSignatureNoneZ ret = (self.sign_bolt12_invoice)(self.this_arg, invoice);
10833         return ret;
10834 }
10835 inline LDK::CResult_ECDSASignatureNoneZ NodeSigner::sign_gossip_message(struct LDKUnsignedGossipMessage msg) {
10836         LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_gossip_message)(self.this_arg, msg);
10837         return ret;
10838 }
10839 inline LDKThirtyTwoBytes SignerProvider::generate_channel_keys_id(bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id) {
10840         LDKThirtyTwoBytes ret = (self.generate_channel_keys_id)(self.this_arg, inbound, channel_value_satoshis, user_channel_id);
10841         return ret;
10842 }
10843 inline LDK::WriteableEcdsaChannelSigner SignerProvider::derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id) {
10844         LDK::WriteableEcdsaChannelSigner ret = (self.derive_channel_signer)(self.this_arg, channel_value_satoshis, channel_keys_id);
10845         return ret;
10846 }
10847 inline LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ SignerProvider::read_chan_signer(struct LDKu8slice reader) {
10848         LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ ret = (self.read_chan_signer)(self.this_arg, reader);
10849         return ret;
10850 }
10851 inline LDK::CResult_CVec_u8ZNoneZ SignerProvider::get_destination_script() {
10852         LDK::CResult_CVec_u8ZNoneZ ret = (self.get_destination_script)(self.this_arg);
10853         return ret;
10854 }
10855 inline LDK::CResult_ShutdownScriptNoneZ SignerProvider::get_shutdown_scriptpubkey() {
10856         LDK::CResult_ShutdownScriptNoneZ ret = (self.get_shutdown_scriptpubkey)(self.this_arg);
10857         return ret;
10858 }
10859 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) {
10860         LDK::CResult_RouteLightningErrorZ ret = (self.find_route)(self.this_arg, payer, route_params, first_hops, inflight_htlcs);
10861         return ret;
10862 }
10863 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) {
10864         LDK::CResult_RouteLightningErrorZ ret = (self.find_route_with_id)(self.this_arg, payer, route_params, first_hops, inflight_htlcs, _payment_hash, _payment_id);
10865         return ret;
10866 }
10867 inline uint64_t ScoreLookUp::channel_penalty_msat(uint64_t short_channel_id, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params) {
10868         uint64_t ret = (self.channel_penalty_msat)(self.this_arg, short_channel_id, source, target, usage, score_params);
10869         return ret;
10870 }
10871 inline void ScoreUpdate::payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id) {
10872         (self.payment_path_failed)(self.this_arg, path, short_channel_id);
10873 }
10874 inline void ScoreUpdate::payment_path_successful(const struct LDKPath *NONNULL_PTR path) {
10875         (self.payment_path_successful)(self.this_arg, path);
10876 }
10877 inline void ScoreUpdate::probe_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id) {
10878         (self.probe_failed)(self.this_arg, path, short_channel_id);
10879 }
10880 inline void ScoreUpdate::probe_successful(const struct LDKPath *NONNULL_PTR path) {
10881         (self.probe_successful)(self.this_arg, path);
10882 }
10883 inline LDK::ScoreLookUp LockableScore::read_lock() {
10884         LDK::ScoreLookUp ret = (self.read_lock)(self.this_arg);
10885         return ret;
10886 }
10887 inline LDK::ScoreUpdate LockableScore::write_lock() {
10888         LDK::ScoreUpdate ret = (self.write_lock)(self.this_arg);
10889         return ret;
10890 }
10891 inline void Listen::filtered_block_connected(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
10892         (self.filtered_block_connected)(self.this_arg, header, txdata, height);
10893 }
10894 inline void Listen::block_connected(struct LDKu8slice block, uint32_t height) {
10895         (self.block_connected)(self.this_arg, block, height);
10896 }
10897 inline void Listen::block_disconnected(const uint8_t (*header)[80], uint32_t height) {
10898         (self.block_disconnected)(self.this_arg, header, height);
10899 }
10900 inline void Confirm::transactions_confirmed(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
10901         (self.transactions_confirmed)(self.this_arg, header, txdata, height);
10902 }
10903 inline void Confirm::transaction_unconfirmed(const uint8_t (*txid)[32]) {
10904         (self.transaction_unconfirmed)(self.this_arg, txid);
10905 }
10906 inline void Confirm::best_block_updated(const uint8_t (*header)[80], uint32_t height) {
10907         (self.best_block_updated)(self.this_arg, header, height);
10908 }
10909 inline LDK::CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ Confirm::get_relevant_txids() {
10910         LDK::CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ ret = (self.get_relevant_txids)(self.this_arg);
10911         return ret;
10912 }
10913 inline LDK::CResult_ChannelMonitorUpdateStatusNoneZ Watch::watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor) {
10914         LDK::CResult_ChannelMonitorUpdateStatusNoneZ ret = (self.watch_channel)(self.this_arg, funding_txo, monitor);
10915         return ret;
10916 }
10917 inline LDK::ChannelMonitorUpdateStatus Watch::update_channel(struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update) {
10918         LDK::ChannelMonitorUpdateStatus ret = (self.update_channel)(self.this_arg, funding_txo, update);
10919         return ret;
10920 }
10921 inline LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Watch::release_pending_monitor_events() {
10922         LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret = (self.release_pending_monitor_events)(self.this_arg);
10923         return ret;
10924 }
10925 inline void Filter::register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey) {
10926         (self.register_tx)(self.this_arg, txid, script_pubkey);
10927 }
10928 inline void Filter::register_output(struct LDKWatchedOutput output) {
10929         (self.register_output)(self.this_arg, output);
10930 }
10931 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) {
10932         LDK::CResult_CoinSelectionNoneZ ret = (self.select_confirmed_utxos)(self.this_arg, claim_id, must_spend, must_pay_to, target_feerate_sat_per_1000_weight);
10933         return ret;
10934 }
10935 inline LDK::CResult_TransactionNoneZ CoinSelectionSource::sign_tx(struct LDKTransaction tx) {
10936         LDK::CResult_TransactionNoneZ ret = (self.sign_tx)(self.this_arg, tx);
10937         return ret;
10938 }
10939 inline LDK::CResult_CVec_UtxoZNoneZ WalletSource::list_confirmed_utxos() {
10940         LDK::CResult_CVec_UtxoZNoneZ ret = (self.list_confirmed_utxos)(self.this_arg);
10941         return ret;
10942 }
10943 inline LDK::CResult_CVec_u8ZNoneZ WalletSource::get_change_script() {
10944         LDK::CResult_CVec_u8ZNoneZ ret = (self.get_change_script)(self.this_arg);
10945         return ret;
10946 }
10947 inline LDK::CResult_TransactionNoneZ WalletSource::sign_tx(struct LDKTransaction tx) {
10948         LDK::CResult_TransactionNoneZ ret = (self.sign_tx)(self.this_arg, tx);
10949         return ret;
10950 }
10951 inline LDK::CResult_NoneLightningErrorZ CustomMessageHandler::handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id) {
10952         LDK::CResult_NoneLightningErrorZ ret = (self.handle_custom_message)(self.this_arg, msg, sender_node_id);
10953         return ret;
10954 }
10955 inline LDK::CVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler::get_and_clear_pending_msg() {
10956         LDK::CVec_C2Tuple_PublicKeyTypeZZ ret = (self.get_and_clear_pending_msg)(self.this_arg);
10957         return ret;
10958 }
10959 inline LDK::NodeFeatures CustomMessageHandler::provided_node_features() {
10960         LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
10961         return ret;
10962 }
10963 inline LDK::InitFeatures CustomMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
10964         LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
10965         return ret;
10966 }
10967 inline uintptr_t SocketDescriptor::send_data(struct LDKu8slice data, bool resume_read) {
10968         uintptr_t ret = (self.send_data)(self.this_arg, data, resume_read);
10969         return ret;
10970 }
10971 inline void SocketDescriptor::disconnect_socket() {
10972         (self.disconnect_socket)(self.this_arg);
10973 }
10974 inline bool SocketDescriptor::eq(const struct LDKSocketDescriptor *NONNULL_PTR other_arg) {
10975         bool ret = (self.eq)(self.this_arg, other_arg);
10976         return ret;
10977 }
10978 inline uint64_t SocketDescriptor::hash() {
10979         uint64_t ret = (self.hash)(self.this_arg);
10980         return ret;
10981 }
10982 inline LDK::CResult_CVec_u8ZIOErrorZ KVStore::read(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key) {
10983         LDK::CResult_CVec_u8ZIOErrorZ ret = (self.read)(self.this_arg, primary_namespace, secondary_namespace, key);
10984         return ret;
10985 }
10986 inline LDK::CResult_NoneIOErrorZ KVStore::write(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, struct LDKu8slice buf) {
10987         LDK::CResult_NoneIOErrorZ ret = (self.write)(self.this_arg, primary_namespace, secondary_namespace, key, buf);
10988         return ret;
10989 }
10990 inline LDK::CResult_NoneIOErrorZ KVStore::remove(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, bool lazy) {
10991         LDK::CResult_NoneIOErrorZ ret = (self.remove)(self.this_arg, primary_namespace, secondary_namespace, key, lazy);
10992         return ret;
10993 }
10994 inline LDK::CResult_CVec_StrZIOErrorZ KVStore::list(struct LDKStr primary_namespace, struct LDKStr secondary_namespace) {
10995         LDK::CResult_CVec_StrZIOErrorZ ret = (self.list)(self.this_arg, primary_namespace, secondary_namespace);
10996         return ret;
10997 }
10998 inline LDK::CResult_NoneIOErrorZ Persister::persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager) {
10999         LDK::CResult_NoneIOErrorZ ret = (self.persist_manager)(self.this_arg, channel_manager);
11000         return ret;
11001 }
11002 inline LDK::CResult_NoneIOErrorZ Persister::persist_graph(const struct LDKNetworkGraph *NONNULL_PTR network_graph) {
11003         LDK::CResult_NoneIOErrorZ ret = (self.persist_graph)(self.this_arg, network_graph);
11004         return ret;
11005 }
11006 inline LDK::CResult_NoneIOErrorZ Persister::persist_scorer(const struct LDKWriteableScore *NONNULL_PTR scorer) {
11007         LDK::CResult_NoneIOErrorZ ret = (self.persist_scorer)(self.this_arg, scorer);
11008         return ret;
11009 }
11010 inline void ChannelMessageHandler::handle_open_channel(struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg) {
11011         (self.handle_open_channel)(self.this_arg, their_node_id, msg);
11012 }
11013 inline void ChannelMessageHandler::handle_open_channel_v2(struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg) {
11014         (self.handle_open_channel_v2)(self.this_arg, their_node_id, msg);
11015 }
11016 inline void ChannelMessageHandler::handle_accept_channel(struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg) {
11017         (self.handle_accept_channel)(self.this_arg, their_node_id, msg);
11018 }
11019 inline void ChannelMessageHandler::handle_accept_channel_v2(struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg) {
11020         (self.handle_accept_channel_v2)(self.this_arg, their_node_id, msg);
11021 }
11022 inline void ChannelMessageHandler::handle_funding_created(struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg) {
11023         (self.handle_funding_created)(self.this_arg, their_node_id, msg);
11024 }
11025 inline void ChannelMessageHandler::handle_funding_signed(struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg) {
11026         (self.handle_funding_signed)(self.this_arg, their_node_id, msg);
11027 }
11028 inline void ChannelMessageHandler::handle_channel_ready(struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg) {
11029         (self.handle_channel_ready)(self.this_arg, their_node_id, msg);
11030 }
11031 inline void ChannelMessageHandler::handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg) {
11032         (self.handle_shutdown)(self.this_arg, their_node_id, msg);
11033 }
11034 inline void ChannelMessageHandler::handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg) {
11035         (self.handle_closing_signed)(self.this_arg, their_node_id, msg);
11036 }
11037 inline void ChannelMessageHandler::handle_tx_add_input(struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg) {
11038         (self.handle_tx_add_input)(self.this_arg, their_node_id, msg);
11039 }
11040 inline void ChannelMessageHandler::handle_tx_add_output(struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg) {
11041         (self.handle_tx_add_output)(self.this_arg, their_node_id, msg);
11042 }
11043 inline void ChannelMessageHandler::handle_tx_remove_input(struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg) {
11044         (self.handle_tx_remove_input)(self.this_arg, their_node_id, msg);
11045 }
11046 inline void ChannelMessageHandler::handle_tx_remove_output(struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg) {
11047         (self.handle_tx_remove_output)(self.this_arg, their_node_id, msg);
11048 }
11049 inline void ChannelMessageHandler::handle_tx_complete(struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg) {
11050         (self.handle_tx_complete)(self.this_arg, their_node_id, msg);
11051 }
11052 inline void ChannelMessageHandler::handle_tx_signatures(struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg) {
11053         (self.handle_tx_signatures)(self.this_arg, their_node_id, msg);
11054 }
11055 inline void ChannelMessageHandler::handle_tx_init_rbf(struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg) {
11056         (self.handle_tx_init_rbf)(self.this_arg, their_node_id, msg);
11057 }
11058 inline void ChannelMessageHandler::handle_tx_ack_rbf(struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg) {
11059         (self.handle_tx_ack_rbf)(self.this_arg, their_node_id, msg);
11060 }
11061 inline void ChannelMessageHandler::handle_tx_abort(struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg) {
11062         (self.handle_tx_abort)(self.this_arg, their_node_id, msg);
11063 }
11064 inline void ChannelMessageHandler::handle_update_add_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg) {
11065         (self.handle_update_add_htlc)(self.this_arg, their_node_id, msg);
11066 }
11067 inline void ChannelMessageHandler::handle_update_fulfill_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg) {
11068         (self.handle_update_fulfill_htlc)(self.this_arg, their_node_id, msg);
11069 }
11070 inline void ChannelMessageHandler::handle_update_fail_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg) {
11071         (self.handle_update_fail_htlc)(self.this_arg, their_node_id, msg);
11072 }
11073 inline void ChannelMessageHandler::handle_update_fail_malformed_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg) {
11074         (self.handle_update_fail_malformed_htlc)(self.this_arg, their_node_id, msg);
11075 }
11076 inline void ChannelMessageHandler::handle_commitment_signed(struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg) {
11077         (self.handle_commitment_signed)(self.this_arg, their_node_id, msg);
11078 }
11079 inline void ChannelMessageHandler::handle_revoke_and_ack(struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg) {
11080         (self.handle_revoke_and_ack)(self.this_arg, their_node_id, msg);
11081 }
11082 inline void ChannelMessageHandler::handle_update_fee(struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg) {
11083         (self.handle_update_fee)(self.this_arg, their_node_id, msg);
11084 }
11085 inline void ChannelMessageHandler::handle_announcement_signatures(struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg) {
11086         (self.handle_announcement_signatures)(self.this_arg, their_node_id, msg);
11087 }
11088 inline void ChannelMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id) {
11089         (self.peer_disconnected)(self.this_arg, their_node_id);
11090 }
11091 inline LDK::CResult_NoneNoneZ ChannelMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound) {
11092         LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, msg, inbound);
11093         return ret;
11094 }
11095 inline void ChannelMessageHandler::handle_channel_reestablish(struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg) {
11096         (self.handle_channel_reestablish)(self.this_arg, their_node_id, msg);
11097 }
11098 inline void ChannelMessageHandler::handle_channel_update(struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg) {
11099         (self.handle_channel_update)(self.this_arg, their_node_id, msg);
11100 }
11101 inline void ChannelMessageHandler::handle_error(struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg) {
11102         (self.handle_error)(self.this_arg, their_node_id, msg);
11103 }
11104 inline LDK::NodeFeatures ChannelMessageHandler::provided_node_features() {
11105         LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
11106         return ret;
11107 }
11108 inline LDK::InitFeatures ChannelMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
11109         LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
11110         return ret;
11111 }
11112 inline LDK::COption_CVec_ThirtyTwoBytesZZ ChannelMessageHandler::get_genesis_hashes() {
11113         LDK::COption_CVec_ThirtyTwoBytesZZ ret = (self.get_genesis_hashes)(self.this_arg);
11114         return ret;
11115 }
11116 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg) {
11117         LDK::CResult_boolLightningErrorZ ret = (self.handle_node_announcement)(self.this_arg, msg);
11118         return ret;
11119 }
11120 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg) {
11121         LDK::CResult_boolLightningErrorZ ret = (self.handle_channel_announcement)(self.this_arg, msg);
11122         return ret;
11123 }
11124 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_channel_update(const struct LDKChannelUpdate *NONNULL_PTR msg) {
11125         LDK::CResult_boolLightningErrorZ ret = (self.handle_channel_update)(self.this_arg, msg);
11126         return ret;
11127 }
11128 inline LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler::get_next_channel_announcement(uint64_t starting_point) {
11129         LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = (self.get_next_channel_announcement)(self.this_arg, starting_point);
11130         return ret;
11131 }
11132 inline LDK::NodeAnnouncement RoutingMessageHandler::get_next_node_announcement(struct LDKNodeId starting_point) {
11133         LDK::NodeAnnouncement ret = (self.get_next_node_announcement)(self.this_arg, starting_point);
11134         return ret;
11135 }
11136 inline LDK::CResult_NoneNoneZ RoutingMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound) {
11137         LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, init, inbound);
11138         return ret;
11139 }
11140 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_reply_channel_range(struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg) {
11141         LDK::CResult_NoneLightningErrorZ ret = (self.handle_reply_channel_range)(self.this_arg, their_node_id, msg);
11142         return ret;
11143 }
11144 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_reply_short_channel_ids_end(struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg) {
11145         LDK::CResult_NoneLightningErrorZ ret = (self.handle_reply_short_channel_ids_end)(self.this_arg, their_node_id, msg);
11146         return ret;
11147 }
11148 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_query_channel_range(struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg) {
11149         LDK::CResult_NoneLightningErrorZ ret = (self.handle_query_channel_range)(self.this_arg, their_node_id, msg);
11150         return ret;
11151 }
11152 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg) {
11153         LDK::CResult_NoneLightningErrorZ ret = (self.handle_query_short_channel_ids)(self.this_arg, their_node_id, msg);
11154         return ret;
11155 }
11156 inline bool RoutingMessageHandler::processing_queue_high() {
11157         bool ret = (self.processing_queue_high)(self.this_arg);
11158         return ret;
11159 }
11160 inline LDK::NodeFeatures RoutingMessageHandler::provided_node_features() {
11161         LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
11162         return ret;
11163 }
11164 inline LDK::InitFeatures RoutingMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
11165         LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
11166         return ret;
11167 }
11168 inline void OnionMessageHandler::handle_onion_message(struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg) {
11169         (self.handle_onion_message)(self.this_arg, peer_node_id, msg);
11170 }
11171 inline LDK::CResult_NoneNoneZ OnionMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound) {
11172         LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, init, inbound);
11173         return ret;
11174 }
11175 inline void OnionMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id) {
11176         (self.peer_disconnected)(self.this_arg, their_node_id);
11177 }
11178 inline LDK::NodeFeatures OnionMessageHandler::provided_node_features() {
11179         LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
11180         return ret;
11181 }
11182 inline LDK::InitFeatures OnionMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
11183         LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
11184         return ret;
11185 }
11186 inline void Logger::log(const struct LDKRecord *NONNULL_PTR record) {
11187         (self.log)(self.this_arg, record);
11188 }
11189 inline void FutureCallback::call() {
11190         (self.call)(self.this_arg);
11191 }
11192 inline LDK::COption_OffersMessageZ OffersMessageHandler::handle_message(struct LDKOffersMessage message) {
11193         LDK::COption_OffersMessageZ ret = (self.handle_message)(self.this_arg, message);
11194         return ret;
11195 }
11196 inline void BroadcasterInterface::broadcast_transactions(struct LDKCVec_TransactionZ txs) {
11197         (self.broadcast_transactions)(self.this_arg, txs);
11198 }
11199 inline uint32_t FeeEstimator::get_est_sat_per_1000_weight(enum LDKConfirmationTarget confirmation_target) {
11200         uint32_t ret = (self.get_est_sat_per_1000_weight)(self.this_arg, confirmation_target);
11201         return ret;
11202 }
11203 inline uint64_t CustomOnionMessageContents::tlv_type() {
11204         uint64_t ret = (self.tlv_type)(self.this_arg);
11205         return ret;
11206 }
11207 inline LDK::CVec_MessageSendEventZ MessageSendEventsProvider::get_and_clear_pending_msg_events() {
11208         LDK::CVec_MessageSendEventZ ret = (self.get_and_clear_pending_msg_events)(self.this_arg);
11209         return ret;
11210 }
11211 inline LDK::OnionMessage OnionMessageProvider::next_onion_message_for_peer(struct LDKPublicKey peer_node_id) {
11212         LDK::OnionMessage ret = (self.next_onion_message_for_peer)(self.this_arg, peer_node_id);
11213         return ret;
11214 }
11215 inline void EventsProvider::process_pending_events(struct LDKEventHandler handler) {
11216         (self.process_pending_events)(self.this_arg, handler);
11217 }
11218 inline void EventHandler::handle_event(struct LDKEvent event) {
11219         (self.handle_event)(self.this_arg, event);
11220 }
11221 inline LDK::CResult_COption_TypeZDecodeErrorZ CustomMessageReader::read(uint16_t message_type, struct LDKu8slice buffer) {
11222         LDK::CResult_COption_TypeZDecodeErrorZ ret = (self.read)(self.this_arg, message_type, buffer);
11223         return ret;
11224 }
11225 inline uint16_t Type::type_id() {
11226         uint16_t ret = (self.type_id)(self.this_arg);
11227         return ret;
11228 }
11229 inline LDK::Str Type::debug_str() {
11230         LDK::Str ret = (self.debug_str)(self.this_arg);
11231         return ret;
11232 }
11233 inline LDK::UtxoResult UtxoLookup::get_utxo(const uint8_t (*genesis_hash)[32], uint64_t short_channel_id) {
11234         LDK::UtxoResult ret = (self.get_utxo)(self.this_arg, genesis_hash, short_channel_id);
11235         return ret;
11236 }
11237 inline LDK::CResult_OnionMessagePathNoneZ MessageRouter::find_path(struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination) {
11238         LDK::CResult_OnionMessagePathNoneZ ret = (self.find_path)(self.this_arg, sender, peers, destination);
11239         return ret;
11240 }
11241 inline LDK::COption_CustomOnionMessageContentsZ CustomOnionMessageHandler::handle_custom_message(struct LDKCustomOnionMessageContents msg) {
11242         LDK::COption_CustomOnionMessageContentsZ ret = (self.handle_custom_message)(self.this_arg, msg);
11243         return ret;
11244 }
11245 inline LDK::CResult_COption_CustomOnionMessageContentsZDecodeErrorZ CustomOnionMessageHandler::read_custom_message(uint64_t message_type, struct LDKu8slice buffer) {
11246         LDK::CResult_COption_CustomOnionMessageContentsZDecodeErrorZ ret = (self.read_custom_message)(self.this_arg, message_type, buffer);
11247         return ret;
11248 }
11249 inline LDK::ChannelMonitorUpdateStatus Persist::persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
11250         LDK::ChannelMonitorUpdateStatus ret = (self.persist_new_channel)(self.this_arg, channel_id, data, update_id);
11251         return ret;
11252 }
11253 inline LDK::ChannelMonitorUpdateStatus Persist::update_persisted_channel(struct LDKOutPoint channel_id, struct LDKChannelMonitorUpdate update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
11254         LDK::ChannelMonitorUpdateStatus ret = (self.update_persisted_channel)(self.this_arg, channel_id, update, data, update_id);
11255         return ret;
11256 }
11257 }