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

   1 #include <string.h>
   2 namespace LDK {
   3 class Event {
   4 private:
   5         LDKEvent self;
   6 public:
   7         Event(const Event&) = delete;
   8         ~Event() { Event_free(self); }
   9         Event(Event&& o) : self(o.self) { memset(&o, 0, sizeof(Event)); }
  10         Event(LDKEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEvent)); }
  11         operator LDKEvent() { LDKEvent res = self; memset(&self, 0, sizeof(LDKEvent)); return res; }
  12         LDKEvent* operator &() { return &self; }
  13         LDKEvent* operator ->() { return &self; }
  14         const LDKEvent* operator &() const { return &self; }
  15         const LDKEvent* operator ->() const { return &self; }
  16 };
  17 class MessageSendEvent {
  18 private:
  19         LDKMessageSendEvent self;
  20 public:
  21         MessageSendEvent(const MessageSendEvent&) = delete;
  22         ~MessageSendEvent() { MessageSendEvent_free(self); }
  23         MessageSendEvent(MessageSendEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEvent)); }
  24         MessageSendEvent(LDKMessageSendEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEvent)); }
  25         operator LDKMessageSendEvent() { LDKMessageSendEvent res = self; memset(&self, 0, sizeof(LDKMessageSendEvent)); return res; }
  26         LDKMessageSendEvent* operator &() { return &self; }
  27         LDKMessageSendEvent* operator ->() { return &self; }
  28         const LDKMessageSendEvent* operator &() const { return &self; }
  29         const LDKMessageSendEvent* operator ->() const { return &self; }
  30 };
  31 class MessageSendEventsProvider {
  32 private:
  33         LDKMessageSendEventsProvider self;
  34 public:
  35         MessageSendEventsProvider(const MessageSendEventsProvider&) = delete;
  36         ~MessageSendEventsProvider() { MessageSendEventsProvider_free(self); }
  37         MessageSendEventsProvider(MessageSendEventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEventsProvider)); }
  38         MessageSendEventsProvider(LDKMessageSendEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEventsProvider)); }
  39         operator LDKMessageSendEventsProvider() { LDKMessageSendEventsProvider res = self; memset(&self, 0, sizeof(LDKMessageSendEventsProvider)); return res; }
  40         LDKMessageSendEventsProvider* operator &() { return &self; }
  41         LDKMessageSendEventsProvider* operator ->() { return &self; }
  42         const LDKMessageSendEventsProvider* operator &() const { return &self; }
  43         const LDKMessageSendEventsProvider* operator ->() const { return &self; }
  44 };
  45 class EventsProvider {
  46 private:
  47         LDKEventsProvider self;
  48 public:
  49         EventsProvider(const EventsProvider&) = delete;
  50         ~EventsProvider() { EventsProvider_free(self); }
  51         EventsProvider(EventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(EventsProvider)); }
  52         EventsProvider(LDKEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventsProvider)); }
  53         operator LDKEventsProvider() { LDKEventsProvider res = self; memset(&self, 0, sizeof(LDKEventsProvider)); return res; }
  54         LDKEventsProvider* operator &() { return &self; }
  55         LDKEventsProvider* operator ->() { return &self; }
  56         const LDKEventsProvider* operator &() const { return &self; }
  57         const LDKEventsProvider* operator ->() const { return &self; }
  58 };
  59 class APIError {
  60 private:
  61         LDKAPIError self;
  62 public:
  63         APIError(const APIError&) = delete;
  64         ~APIError() { APIError_free(self); }
  65         APIError(APIError&& o) : self(o.self) { memset(&o, 0, sizeof(APIError)); }
  66         APIError(LDKAPIError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAPIError)); }
  67         operator LDKAPIError() { LDKAPIError res = self; memset(&self, 0, sizeof(LDKAPIError)); return res; }
  68         LDKAPIError* operator &() { return &self; }
  69         LDKAPIError* operator ->() { return &self; }
  70         const LDKAPIError* operator &() const { return &self; }
  71         const LDKAPIError* operator ->() const { return &self; }
  72 };
  73 class Level {
  74 private:
  75         LDKLevel self;
  76 public:
  77         Level(const Level&) = delete;
  78         Level(Level&& o) : self(o.self) { memset(&o, 0, sizeof(Level)); }
  79         Level(LDKLevel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLevel)); }
  80         operator LDKLevel() { LDKLevel res = self; memset(&self, 0, sizeof(LDKLevel)); return res; }
  81         LDKLevel* operator &() { return &self; }
  82         LDKLevel* operator ->() { return &self; }
  83         const LDKLevel* operator &() const { return &self; }
  84         const LDKLevel* operator ->() const { return &self; }
  85 };
  86 class Logger {
  87 private:
  88         LDKLogger self;
  89 public:
  90         Logger(const Logger&) = delete;
  91         ~Logger() { Logger_free(self); }
  92         Logger(Logger&& o) : self(o.self) { memset(&o, 0, sizeof(Logger)); }
  93         Logger(LDKLogger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLogger)); }
  94         operator LDKLogger() { LDKLogger res = self; memset(&self, 0, sizeof(LDKLogger)); return res; }
  95         LDKLogger* operator &() { return &self; }
  96         LDKLogger* operator ->() { return &self; }
  97         const LDKLogger* operator &() const { return &self; }
  98         const LDKLogger* operator ->() const { return &self; }
  99 };
 100 class ChannelHandshakeConfig {
 101 private:
 102         LDKChannelHandshakeConfig self;
 103 public:
 104         ChannelHandshakeConfig(const ChannelHandshakeConfig&) = delete;
 105         ~ChannelHandshakeConfig() { ChannelHandshakeConfig_free(self); }
 106         ChannelHandshakeConfig(ChannelHandshakeConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeConfig)); }
 107         ChannelHandshakeConfig(LDKChannelHandshakeConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeConfig)); }
 108         operator LDKChannelHandshakeConfig() { LDKChannelHandshakeConfig res = self; memset(&self, 0, sizeof(LDKChannelHandshakeConfig)); return res; }
 109         LDKChannelHandshakeConfig* operator &() { return &self; }
 110         LDKChannelHandshakeConfig* operator ->() { return &self; }
 111         const LDKChannelHandshakeConfig* operator &() const { return &self; }
 112         const LDKChannelHandshakeConfig* operator ->() const { return &self; }
 113 };
 114 class ChannelHandshakeLimits {
 115 private:
 116         LDKChannelHandshakeLimits self;
 117 public:
 118         ChannelHandshakeLimits(const ChannelHandshakeLimits&) = delete;
 119         ~ChannelHandshakeLimits() { ChannelHandshakeLimits_free(self); }
 120         ChannelHandshakeLimits(ChannelHandshakeLimits&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeLimits)); }
 121         ChannelHandshakeLimits(LDKChannelHandshakeLimits&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeLimits)); }
 122         operator LDKChannelHandshakeLimits() { LDKChannelHandshakeLimits res = self; memset(&self, 0, sizeof(LDKChannelHandshakeLimits)); return res; }
 123         LDKChannelHandshakeLimits* operator &() { return &self; }
 124         LDKChannelHandshakeLimits* operator ->() { return &self; }
 125         const LDKChannelHandshakeLimits* operator &() const { return &self; }
 126         const LDKChannelHandshakeLimits* operator ->() const { return &self; }
 127 };
 128 class ChannelConfig {
 129 private:
 130         LDKChannelConfig self;
 131 public:
 132         ChannelConfig(const ChannelConfig&) = delete;
 133         ~ChannelConfig() { ChannelConfig_free(self); }
 134         ChannelConfig(ChannelConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfig)); }
 135         ChannelConfig(LDKChannelConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfig)); }
 136         operator LDKChannelConfig() { LDKChannelConfig res = self; memset(&self, 0, sizeof(LDKChannelConfig)); return res; }
 137         LDKChannelConfig* operator &() { return &self; }
 138         LDKChannelConfig* operator ->() { return &self; }
 139         const LDKChannelConfig* operator &() const { return &self; }
 140         const LDKChannelConfig* operator ->() const { return &self; }
 141 };
 142 class UserConfig {
 143 private:
 144         LDKUserConfig self;
 145 public:
 146         UserConfig(const UserConfig&) = delete;
 147         ~UserConfig() { UserConfig_free(self); }
 148         UserConfig(UserConfig&& o) : self(o.self) { memset(&o, 0, sizeof(UserConfig)); }
 149         UserConfig(LDKUserConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUserConfig)); }
 150         operator LDKUserConfig() { LDKUserConfig res = self; memset(&self, 0, sizeof(LDKUserConfig)); return res; }
 151         LDKUserConfig* operator &() { return &self; }
 152         LDKUserConfig* operator ->() { return &self; }
 153         const LDKUserConfig* operator &() const { return &self; }
 154         const LDKUserConfig* operator ->() const { return &self; }
 155 };
 156 class ChainError {
 157 private:
 158         LDKChainError self;
 159 public:
 160         ChainError(const ChainError&) = delete;
 161         ChainError(ChainError&& o) : self(o.self) { memset(&o, 0, sizeof(ChainError)); }
 162         ChainError(LDKChainError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainError)); }
 163         operator LDKChainError() { LDKChainError res = self; memset(&self, 0, sizeof(LDKChainError)); return res; }
 164         LDKChainError* operator &() { return &self; }
 165         LDKChainError* operator ->() { return &self; }
 166         const LDKChainError* operator &() const { return &self; }
 167         const LDKChainError* operator ->() const { return &self; }
 168 };
 169 class ChainWatchInterface {
 170 private:
 171         LDKChainWatchInterface self;
 172 public:
 173         ChainWatchInterface(const ChainWatchInterface&) = delete;
 174         ~ChainWatchInterface() { ChainWatchInterface_free(self); }
 175         ChainWatchInterface(ChainWatchInterface&& o) : self(o.self) { memset(&o, 0, sizeof(ChainWatchInterface)); }
 176         ChainWatchInterface(LDKChainWatchInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainWatchInterface)); }
 177         operator LDKChainWatchInterface() { LDKChainWatchInterface res = self; memset(&self, 0, sizeof(LDKChainWatchInterface)); return res; }
 178         LDKChainWatchInterface* operator &() { return &self; }
 179         LDKChainWatchInterface* operator ->() { return &self; }
 180         const LDKChainWatchInterface* operator &() const { return &self; }
 181         const LDKChainWatchInterface* operator ->() const { return &self; }
 182 };
 183 class BroadcasterInterface {
 184 private:
 185         LDKBroadcasterInterface self;
 186 public:
 187         BroadcasterInterface(const BroadcasterInterface&) = delete;
 188         ~BroadcasterInterface() { BroadcasterInterface_free(self); }
 189         BroadcasterInterface(BroadcasterInterface&& o) : self(o.self) { memset(&o, 0, sizeof(BroadcasterInterface)); }
 190         BroadcasterInterface(LDKBroadcasterInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBroadcasterInterface)); }
 191         operator LDKBroadcasterInterface() { LDKBroadcasterInterface res = self; memset(&self, 0, sizeof(LDKBroadcasterInterface)); return res; }
 192         LDKBroadcasterInterface* operator &() { return &self; }
 193         LDKBroadcasterInterface* operator ->() { return &self; }
 194         const LDKBroadcasterInterface* operator &() const { return &self; }
 195         const LDKBroadcasterInterface* operator ->() const { return &self; }
 196 };
 197 class ChainListener {
 198 private:
 199         LDKChainListener self;
 200 public:
 201         ChainListener(const ChainListener&) = delete;
 202         ~ChainListener() { ChainListener_free(self); }
 203         ChainListener(ChainListener&& o) : self(o.self) { memset(&o, 0, sizeof(ChainListener)); }
 204         ChainListener(LDKChainListener&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainListener)); }
 205         operator LDKChainListener() { LDKChainListener res = self; memset(&self, 0, sizeof(LDKChainListener)); return res; }
 206         LDKChainListener* operator &() { return &self; }
 207         LDKChainListener* operator ->() { return &self; }
 208         const LDKChainListener* operator &() const { return &self; }
 209         const LDKChainListener* operator ->() const { return &self; }
 210 };
 211 class ConfirmationTarget {
 212 private:
 213         LDKConfirmationTarget self;
 214 public:
 215         ConfirmationTarget(const ConfirmationTarget&) = delete;
 216         ConfirmationTarget(ConfirmationTarget&& o) : self(o.self) { memset(&o, 0, sizeof(ConfirmationTarget)); }
 217         ConfirmationTarget(LDKConfirmationTarget&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirmationTarget)); }
 218         operator LDKConfirmationTarget() { LDKConfirmationTarget res = self; memset(&self, 0, sizeof(LDKConfirmationTarget)); return res; }
 219         LDKConfirmationTarget* operator &() { return &self; }
 220         LDKConfirmationTarget* operator ->() { return &self; }
 221         const LDKConfirmationTarget* operator &() const { return &self; }
 222         const LDKConfirmationTarget* operator ->() const { return &self; }
 223 };
 224 class FeeEstimator {
 225 private:
 226         LDKFeeEstimator self;
 227 public:
 228         FeeEstimator(const FeeEstimator&) = delete;
 229         ~FeeEstimator() { FeeEstimator_free(self); }
 230         FeeEstimator(FeeEstimator&& o) : self(o.self) { memset(&o, 0, sizeof(FeeEstimator)); }
 231         FeeEstimator(LDKFeeEstimator&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFeeEstimator)); }
 232         operator LDKFeeEstimator() { LDKFeeEstimator res = self; memset(&self, 0, sizeof(LDKFeeEstimator)); return res; }
 233         LDKFeeEstimator* operator &() { return &self; }
 234         LDKFeeEstimator* operator ->() { return &self; }
 235         const LDKFeeEstimator* operator &() const { return &self; }
 236         const LDKFeeEstimator* operator ->() const { return &self; }
 237 };
 238 class ChainWatchedUtil {
 239 private:
 240         LDKChainWatchedUtil self;
 241 public:
 242         ChainWatchedUtil(const ChainWatchedUtil&) = delete;
 243         ~ChainWatchedUtil() { ChainWatchedUtil_free(self); }
 244         ChainWatchedUtil(ChainWatchedUtil&& o) : self(o.self) { memset(&o, 0, sizeof(ChainWatchedUtil)); }
 245         ChainWatchedUtil(LDKChainWatchedUtil&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainWatchedUtil)); }
 246         operator LDKChainWatchedUtil() { LDKChainWatchedUtil res = self; memset(&self, 0, sizeof(LDKChainWatchedUtil)); return res; }
 247         LDKChainWatchedUtil* operator &() { return &self; }
 248         LDKChainWatchedUtil* operator ->() { return &self; }
 249         const LDKChainWatchedUtil* operator &() const { return &self; }
 250         const LDKChainWatchedUtil* operator ->() const { return &self; }
 251 };
 252 class BlockNotifier {
 253 private:
 254         LDKBlockNotifier self;
 255 public:
 256         BlockNotifier(const BlockNotifier&) = delete;
 257         ~BlockNotifier() { BlockNotifier_free(self); }
 258         BlockNotifier(BlockNotifier&& o) : self(o.self) { memset(&o, 0, sizeof(BlockNotifier)); }
 259         BlockNotifier(LDKBlockNotifier&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlockNotifier)); }
 260         operator LDKBlockNotifier() { LDKBlockNotifier res = self; memset(&self, 0, sizeof(LDKBlockNotifier)); return res; }
 261         LDKBlockNotifier* operator &() { return &self; }
 262         LDKBlockNotifier* operator ->() { return &self; }
 263         const LDKBlockNotifier* operator &() const { return &self; }
 264         const LDKBlockNotifier* operator ->() const { return &self; }
 265 };
 266 class ChainWatchInterfaceUtil {
 267 private:
 268         LDKChainWatchInterfaceUtil self;
 269 public:
 270         ChainWatchInterfaceUtil(const ChainWatchInterfaceUtil&) = delete;
 271         ~ChainWatchInterfaceUtil() { ChainWatchInterfaceUtil_free(self); }
 272         ChainWatchInterfaceUtil(ChainWatchInterfaceUtil&& o) : self(o.self) { memset(&o, 0, sizeof(ChainWatchInterfaceUtil)); }
 273         ChainWatchInterfaceUtil(LDKChainWatchInterfaceUtil&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainWatchInterfaceUtil)); }
 274         operator LDKChainWatchInterfaceUtil() { LDKChainWatchInterfaceUtil res = self; memset(&self, 0, sizeof(LDKChainWatchInterfaceUtil)); return res; }
 275         LDKChainWatchInterfaceUtil* operator &() { return &self; }
 276         LDKChainWatchInterfaceUtil* operator ->() { return &self; }
 277         const LDKChainWatchInterfaceUtil* operator &() const { return &self; }
 278         const LDKChainWatchInterfaceUtil* operator ->() const { return &self; }
 279 };
 280 class OutPoint {
 281 private:
 282         LDKOutPoint self;
 283 public:
 284         OutPoint(const OutPoint&) = delete;
 285         ~OutPoint() { OutPoint_free(self); }
 286         OutPoint(OutPoint&& o) : self(o.self) { memset(&o, 0, sizeof(OutPoint)); }
 287         OutPoint(LDKOutPoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutPoint)); }
 288         operator LDKOutPoint() { LDKOutPoint res = self; memset(&self, 0, sizeof(LDKOutPoint)); return res; }
 289         LDKOutPoint* operator &() { return &self; }
 290         LDKOutPoint* operator ->() { return &self; }
 291         const LDKOutPoint* operator &() const { return &self; }
 292         const LDKOutPoint* operator ->() const { return &self; }
 293 };
 294 class SpendableOutputDescriptor {
 295 private:
 296         LDKSpendableOutputDescriptor self;
 297 public:
 298         SpendableOutputDescriptor(const SpendableOutputDescriptor&) = delete;
 299         ~SpendableOutputDescriptor() { SpendableOutputDescriptor_free(self); }
 300         SpendableOutputDescriptor(SpendableOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SpendableOutputDescriptor)); }
 301         SpendableOutputDescriptor(LDKSpendableOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendableOutputDescriptor)); }
 302         operator LDKSpendableOutputDescriptor() { LDKSpendableOutputDescriptor res = self; memset(&self, 0, sizeof(LDKSpendableOutputDescriptor)); return res; }
 303         LDKSpendableOutputDescriptor* operator &() { return &self; }
 304         LDKSpendableOutputDescriptor* operator ->() { return &self; }
 305         const LDKSpendableOutputDescriptor* operator &() const { return &self; }
 306         const LDKSpendableOutputDescriptor* operator ->() const { return &self; }
 307 };
 308 class ChannelKeys {
 309 private:
 310         LDKChannelKeys self;
 311 public:
 312         ChannelKeys(const ChannelKeys&) = delete;
 313         ~ChannelKeys() { ChannelKeys_free(self); }
 314         ChannelKeys(ChannelKeys&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelKeys)); }
 315         ChannelKeys(LDKChannelKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelKeys)); }
 316         operator LDKChannelKeys() { LDKChannelKeys res = self; memset(&self, 0, sizeof(LDKChannelKeys)); return res; }
 317         LDKChannelKeys* operator &() { return &self; }
 318         LDKChannelKeys* operator ->() { return &self; }
 319         const LDKChannelKeys* operator &() const { return &self; }
 320         const LDKChannelKeys* operator ->() const { return &self; }
 321 };
 322 class KeysInterface {
 323 private:
 324         LDKKeysInterface self;
 325 public:
 326         KeysInterface(const KeysInterface&) = delete;
 327         ~KeysInterface() { KeysInterface_free(self); }
 328         KeysInterface(KeysInterface&& o) : self(o.self) { memset(&o, 0, sizeof(KeysInterface)); }
 329         KeysInterface(LDKKeysInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysInterface)); }
 330         operator LDKKeysInterface() { LDKKeysInterface res = self; memset(&self, 0, sizeof(LDKKeysInterface)); return res; }
 331         LDKKeysInterface* operator &() { return &self; }
 332         LDKKeysInterface* operator ->() { return &self; }
 333         const LDKKeysInterface* operator &() const { return &self; }
 334         const LDKKeysInterface* operator ->() const { return &self; }
 335 };
 336 class InMemoryChannelKeys {
 337 private:
 338         LDKInMemoryChannelKeys self;
 339 public:
 340         InMemoryChannelKeys(const InMemoryChannelKeys&) = delete;
 341         ~InMemoryChannelKeys() { InMemoryChannelKeys_free(self); }
 342         InMemoryChannelKeys(InMemoryChannelKeys&& o) : self(o.self) { memset(&o, 0, sizeof(InMemoryChannelKeys)); }
 343         InMemoryChannelKeys(LDKInMemoryChannelKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInMemoryChannelKeys)); }
 344         operator LDKInMemoryChannelKeys() { LDKInMemoryChannelKeys res = self; memset(&self, 0, sizeof(LDKInMemoryChannelKeys)); return res; }
 345         LDKInMemoryChannelKeys* operator &() { return &self; }
 346         LDKInMemoryChannelKeys* operator ->() { return &self; }
 347         const LDKInMemoryChannelKeys* operator &() const { return &self; }
 348         const LDKInMemoryChannelKeys* operator ->() const { return &self; }
 349 };
 350 class KeysManager {
 351 private:
 352         LDKKeysManager self;
 353 public:
 354         KeysManager(const KeysManager&) = delete;
 355         ~KeysManager() { KeysManager_free(self); }
 356         KeysManager(KeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(KeysManager)); }
 357         KeysManager(LDKKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysManager)); }
 358         operator LDKKeysManager() { LDKKeysManager res = self; memset(&self, 0, sizeof(LDKKeysManager)); return res; }
 359         LDKKeysManager* operator &() { return &self; }
 360         LDKKeysManager* operator ->() { return &self; }
 361         const LDKKeysManager* operator &() const { return &self; }
 362         const LDKKeysManager* operator ->() const { return &self; }
 363 };
 364 class ChannelManager {
 365 private:
 366         LDKChannelManager self;
 367 public:
 368         ChannelManager(const ChannelManager&) = delete;
 369         ~ChannelManager() { ChannelManager_free(self); }
 370         ChannelManager(ChannelManager&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManager)); }
 371         ChannelManager(LDKChannelManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManager)); }
 372         operator LDKChannelManager() { LDKChannelManager res = self; memset(&self, 0, sizeof(LDKChannelManager)); return res; }
 373         LDKChannelManager* operator &() { return &self; }
 374         LDKChannelManager* operator ->() { return &self; }
 375         const LDKChannelManager* operator &() const { return &self; }
 376         const LDKChannelManager* operator ->() const { return &self; }
 377 };
 378 class ChannelDetails {
 379 private:
 380         LDKChannelDetails self;
 381 public:
 382         ChannelDetails(const ChannelDetails&) = delete;
 383         ~ChannelDetails() { ChannelDetails_free(self); }
 384         ChannelDetails(ChannelDetails&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDetails)); }
 385         ChannelDetails(LDKChannelDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDetails)); }
 386         operator LDKChannelDetails() { LDKChannelDetails res = self; memset(&self, 0, sizeof(LDKChannelDetails)); return res; }
 387         LDKChannelDetails* operator &() { return &self; }
 388         LDKChannelDetails* operator ->() { return &self; }
 389         const LDKChannelDetails* operator &() const { return &self; }
 390         const LDKChannelDetails* operator ->() const { return &self; }
 391 };
 392 class PaymentSendFailure {
 393 private:
 394         LDKPaymentSendFailure self;
 395 public:
 396         PaymentSendFailure(const PaymentSendFailure&) = delete;
 397         ~PaymentSendFailure() { PaymentSendFailure_free(self); }
 398         PaymentSendFailure(PaymentSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentSendFailure)); }
 399         PaymentSendFailure(LDKPaymentSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentSendFailure)); }
 400         operator LDKPaymentSendFailure() { LDKPaymentSendFailure res = self; memset(&self, 0, sizeof(LDKPaymentSendFailure)); return res; }
 401         LDKPaymentSendFailure* operator &() { return &self; }
 402         LDKPaymentSendFailure* operator ->() { return &self; }
 403         const LDKPaymentSendFailure* operator &() const { return &self; }
 404         const LDKPaymentSendFailure* operator ->() const { return &self; }
 405 };
 406 class ChannelManagerReadArgs {
 407 private:
 408         LDKChannelManagerReadArgs self;
 409 public:
 410         ChannelManagerReadArgs(const ChannelManagerReadArgs&) = delete;
 411         ~ChannelManagerReadArgs() { ChannelManagerReadArgs_free(self); }
 412         ChannelManagerReadArgs(ChannelManagerReadArgs&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerReadArgs)); }
 413         ChannelManagerReadArgs(LDKChannelManagerReadArgs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerReadArgs)); }
 414         operator LDKChannelManagerReadArgs() { LDKChannelManagerReadArgs res = self; memset(&self, 0, sizeof(LDKChannelManagerReadArgs)); return res; }
 415         LDKChannelManagerReadArgs* operator &() { return &self; }
 416         LDKChannelManagerReadArgs* operator ->() { return &self; }
 417         const LDKChannelManagerReadArgs* operator &() const { return &self; }
 418         const LDKChannelManagerReadArgs* operator ->() const { return &self; }
 419 };
 420 class ChannelMonitorUpdate {
 421 private:
 422         LDKChannelMonitorUpdate self;
 423 public:
 424         ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete;
 425         ~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); }
 426         ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); }
 427         ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); }
 428         operator LDKChannelMonitorUpdate() { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; }
 429         LDKChannelMonitorUpdate* operator &() { return &self; }
 430         LDKChannelMonitorUpdate* operator ->() { return &self; }
 431         const LDKChannelMonitorUpdate* operator &() const { return &self; }
 432         const LDKChannelMonitorUpdate* operator ->() const { return &self; }
 433 };
 434 class ChannelMonitorUpdateErr {
 435 private:
 436         LDKChannelMonitorUpdateErr self;
 437 public:
 438         ChannelMonitorUpdateErr(const ChannelMonitorUpdateErr&) = delete;
 439         ChannelMonitorUpdateErr(ChannelMonitorUpdateErr&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); }
 440         ChannelMonitorUpdateErr(LDKChannelMonitorUpdateErr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateErr)); }
 441         operator LDKChannelMonitorUpdateErr() { LDKChannelMonitorUpdateErr res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateErr)); return res; }
 442         LDKChannelMonitorUpdateErr* operator &() { return &self; }
 443         LDKChannelMonitorUpdateErr* operator ->() { return &self; }
 444         const LDKChannelMonitorUpdateErr* operator &() const { return &self; }
 445         const LDKChannelMonitorUpdateErr* operator ->() const { return &self; }
 446 };
 447 class MonitorUpdateError {
 448 private:
 449         LDKMonitorUpdateError self;
 450 public:
 451         MonitorUpdateError(const MonitorUpdateError&) = delete;
 452         ~MonitorUpdateError() { MonitorUpdateError_free(self); }
 453         MonitorUpdateError(MonitorUpdateError&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdateError)); }
 454         MonitorUpdateError(LDKMonitorUpdateError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdateError)); }
 455         operator LDKMonitorUpdateError() { LDKMonitorUpdateError res = self; memset(&self, 0, sizeof(LDKMonitorUpdateError)); return res; }
 456         LDKMonitorUpdateError* operator &() { return &self; }
 457         LDKMonitorUpdateError* operator ->() { return &self; }
 458         const LDKMonitorUpdateError* operator &() const { return &self; }
 459         const LDKMonitorUpdateError* operator ->() const { return &self; }
 460 };
 461 class MonitorEvent {
 462 private:
 463         LDKMonitorEvent self;
 464 public:
 465         MonitorEvent(const MonitorEvent&) = delete;
 466         ~MonitorEvent() { MonitorEvent_free(self); }
 467         MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); }
 468         MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); }
 469         operator LDKMonitorEvent() { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; }
 470         LDKMonitorEvent* operator &() { return &self; }
 471         LDKMonitorEvent* operator ->() { return &self; }
 472         const LDKMonitorEvent* operator &() const { return &self; }
 473         const LDKMonitorEvent* operator ->() const { return &self; }
 474 };
 475 class HTLCUpdate {
 476 private:
 477         LDKHTLCUpdate self;
 478 public:
 479         HTLCUpdate(const HTLCUpdate&) = delete;
 480         ~HTLCUpdate() { HTLCUpdate_free(self); }
 481         HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); }
 482         HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); }
 483         operator LDKHTLCUpdate() { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; }
 484         LDKHTLCUpdate* operator &() { return &self; }
 485         LDKHTLCUpdate* operator ->() { return &self; }
 486         const LDKHTLCUpdate* operator &() const { return &self; }
 487         const LDKHTLCUpdate* operator ->() const { return &self; }
 488 };
 489 class ChannelMonitor {
 490 private:
 491         LDKChannelMonitor self;
 492 public:
 493         ChannelMonitor(const ChannelMonitor&) = delete;
 494         ~ChannelMonitor() { ChannelMonitor_free(self); }
 495         ChannelMonitor(ChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitor)); }
 496         ChannelMonitor(LDKChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitor)); }
 497         operator LDKChannelMonitor() { LDKChannelMonitor res = self; memset(&self, 0, sizeof(LDKChannelMonitor)); return res; }
 498         LDKChannelMonitor* operator &() { return &self; }
 499         LDKChannelMonitor* operator ->() { return &self; }
 500         const LDKChannelMonitor* operator &() const { return &self; }
 501         const LDKChannelMonitor* operator ->() const { return &self; }
 502 };
 503 class ManyChannelMonitor {
 504 private:
 505         LDKManyChannelMonitor self;
 506 public:
 507         ManyChannelMonitor(const ManyChannelMonitor&) = delete;
 508         ~ManyChannelMonitor() { ManyChannelMonitor_free(self); }
 509         ManyChannelMonitor(ManyChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ManyChannelMonitor)); }
 510         ManyChannelMonitor(LDKManyChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKManyChannelMonitor)); }
 511         operator LDKManyChannelMonitor() { LDKManyChannelMonitor res = self; memset(&self, 0, sizeof(LDKManyChannelMonitor)); return res; }
 512         LDKManyChannelMonitor* operator &() { return &self; }
 513         LDKManyChannelMonitor* operator ->() { return &self; }
 514         const LDKManyChannelMonitor* operator &() const { return &self; }
 515         const LDKManyChannelMonitor* operator ->() const { return &self; }
 516 };
 517 class DecodeError {
 518 private:
 519         LDKDecodeError self;
 520 public:
 521         DecodeError(const DecodeError&) = delete;
 522         ~DecodeError() { DecodeError_free(self); }
 523         DecodeError(DecodeError&& o) : self(o.self) { memset(&o, 0, sizeof(DecodeError)); }
 524         DecodeError(LDKDecodeError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDecodeError)); }
 525         operator LDKDecodeError() { LDKDecodeError res = self; memset(&self, 0, sizeof(LDKDecodeError)); return res; }
 526         LDKDecodeError* operator &() { return &self; }
 527         LDKDecodeError* operator ->() { return &self; }
 528         const LDKDecodeError* operator &() const { return &self; }
 529         const LDKDecodeError* operator ->() const { return &self; }
 530 };
 531 class Init {
 532 private:
 533         LDKInit self;
 534 public:
 535         Init(const Init&) = delete;
 536         ~Init() { Init_free(self); }
 537         Init(Init&& o) : self(o.self) { memset(&o, 0, sizeof(Init)); }
 538         Init(LDKInit&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInit)); }
 539         operator LDKInit() { LDKInit res = self; memset(&self, 0, sizeof(LDKInit)); return res; }
 540         LDKInit* operator &() { return &self; }
 541         LDKInit* operator ->() { return &self; }
 542         const LDKInit* operator &() const { return &self; }
 543         const LDKInit* operator ->() const { return &self; }
 544 };
 545 class ErrorMessage {
 546 private:
 547         LDKErrorMessage self;
 548 public:
 549         ErrorMessage(const ErrorMessage&) = delete;
 550         ~ErrorMessage() { ErrorMessage_free(self); }
 551         ErrorMessage(ErrorMessage&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorMessage)); }
 552         ErrorMessage(LDKErrorMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorMessage)); }
 553         operator LDKErrorMessage() { LDKErrorMessage res = self; memset(&self, 0, sizeof(LDKErrorMessage)); return res; }
 554         LDKErrorMessage* operator &() { return &self; }
 555         LDKErrorMessage* operator ->() { return &self; }
 556         const LDKErrorMessage* operator &() const { return &self; }
 557         const LDKErrorMessage* operator ->() const { return &self; }
 558 };
 559 class Ping {
 560 private:
 561         LDKPing self;
 562 public:
 563         Ping(const Ping&) = delete;
 564         ~Ping() { Ping_free(self); }
 565         Ping(Ping&& o) : self(o.self) { memset(&o, 0, sizeof(Ping)); }
 566         Ping(LDKPing&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPing)); }
 567         operator LDKPing() { LDKPing res = self; memset(&self, 0, sizeof(LDKPing)); return res; }
 568         LDKPing* operator &() { return &self; }
 569         LDKPing* operator ->() { return &self; }
 570         const LDKPing* operator &() const { return &self; }
 571         const LDKPing* operator ->() const { return &self; }
 572 };
 573 class Pong {
 574 private:
 575         LDKPong self;
 576 public:
 577         Pong(const Pong&) = delete;
 578         ~Pong() { Pong_free(self); }
 579         Pong(Pong&& o) : self(o.self) { memset(&o, 0, sizeof(Pong)); }
 580         Pong(LDKPong&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPong)); }
 581         operator LDKPong() { LDKPong res = self; memset(&self, 0, sizeof(LDKPong)); return res; }
 582         LDKPong* operator &() { return &self; }
 583         LDKPong* operator ->() { return &self; }
 584         const LDKPong* operator &() const { return &self; }
 585         const LDKPong* operator ->() const { return &self; }
 586 };
 587 class OpenChannel {
 588 private:
 589         LDKOpenChannel self;
 590 public:
 591         OpenChannel(const OpenChannel&) = delete;
 592         ~OpenChannel() { OpenChannel_free(self); }
 593         OpenChannel(OpenChannel&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannel)); }
 594         OpenChannel(LDKOpenChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannel)); }
 595         operator LDKOpenChannel() { LDKOpenChannel res = self; memset(&self, 0, sizeof(LDKOpenChannel)); return res; }
 596         LDKOpenChannel* operator &() { return &self; }
 597         LDKOpenChannel* operator ->() { return &self; }
 598         const LDKOpenChannel* operator &() const { return &self; }
 599         const LDKOpenChannel* operator ->() const { return &self; }
 600 };
 601 class AcceptChannel {
 602 private:
 603         LDKAcceptChannel self;
 604 public:
 605         AcceptChannel(const AcceptChannel&) = delete;
 606         ~AcceptChannel() { AcceptChannel_free(self); }
 607         AcceptChannel(AcceptChannel&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannel)); }
 608         AcceptChannel(LDKAcceptChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannel)); }
 609         operator LDKAcceptChannel() { LDKAcceptChannel res = self; memset(&self, 0, sizeof(LDKAcceptChannel)); return res; }
 610         LDKAcceptChannel* operator &() { return &self; }
 611         LDKAcceptChannel* operator ->() { return &self; }
 612         const LDKAcceptChannel* operator &() const { return &self; }
 613         const LDKAcceptChannel* operator ->() const { return &self; }
 614 };
 615 class FundingCreated {
 616 private:
 617         LDKFundingCreated self;
 618 public:
 619         FundingCreated(const FundingCreated&) = delete;
 620         ~FundingCreated() { FundingCreated_free(self); }
 621         FundingCreated(FundingCreated&& o) : self(o.self) { memset(&o, 0, sizeof(FundingCreated)); }
 622         FundingCreated(LDKFundingCreated&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingCreated)); }
 623         operator LDKFundingCreated() { LDKFundingCreated res = self; memset(&self, 0, sizeof(LDKFundingCreated)); return res; }
 624         LDKFundingCreated* operator &() { return &self; }
 625         LDKFundingCreated* operator ->() { return &self; }
 626         const LDKFundingCreated* operator &() const { return &self; }
 627         const LDKFundingCreated* operator ->() const { return &self; }
 628 };
 629 class FundingSigned {
 630 private:
 631         LDKFundingSigned self;
 632 public:
 633         FundingSigned(const FundingSigned&) = delete;
 634         ~FundingSigned() { FundingSigned_free(self); }
 635         FundingSigned(FundingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(FundingSigned)); }
 636         FundingSigned(LDKFundingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingSigned)); }
 637         operator LDKFundingSigned() { LDKFundingSigned res = self; memset(&self, 0, sizeof(LDKFundingSigned)); return res; }
 638         LDKFundingSigned* operator &() { return &self; }
 639         LDKFundingSigned* operator ->() { return &self; }
 640         const LDKFundingSigned* operator &() const { return &self; }
 641         const LDKFundingSigned* operator ->() const { return &self; }
 642 };
 643 class FundingLocked {
 644 private:
 645         LDKFundingLocked self;
 646 public:
 647         FundingLocked(const FundingLocked&) = delete;
 648         ~FundingLocked() { FundingLocked_free(self); }
 649         FundingLocked(FundingLocked&& o) : self(o.self) { memset(&o, 0, sizeof(FundingLocked)); }
 650         FundingLocked(LDKFundingLocked&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingLocked)); }
 651         operator LDKFundingLocked() { LDKFundingLocked res = self; memset(&self, 0, sizeof(LDKFundingLocked)); return res; }
 652         LDKFundingLocked* operator &() { return &self; }
 653         LDKFundingLocked* operator ->() { return &self; }
 654         const LDKFundingLocked* operator &() const { return &self; }
 655         const LDKFundingLocked* operator ->() const { return &self; }
 656 };
 657 class Shutdown {
 658 private:
 659         LDKShutdown self;
 660 public:
 661         Shutdown(const Shutdown&) = delete;
 662         ~Shutdown() { Shutdown_free(self); }
 663         Shutdown(Shutdown&& o) : self(o.self) { memset(&o, 0, sizeof(Shutdown)); }
 664         Shutdown(LDKShutdown&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdown)); }
 665         operator LDKShutdown() { LDKShutdown res = self; memset(&self, 0, sizeof(LDKShutdown)); return res; }
 666         LDKShutdown* operator &() { return &self; }
 667         LDKShutdown* operator ->() { return &self; }
 668         const LDKShutdown* operator &() const { return &self; }
 669         const LDKShutdown* operator ->() const { return &self; }
 670 };
 671 class ClosingSigned {
 672 private:
 673         LDKClosingSigned self;
 674 public:
 675         ClosingSigned(const ClosingSigned&) = delete;
 676         ~ClosingSigned() { ClosingSigned_free(self); }
 677         ClosingSigned(ClosingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSigned)); }
 678         ClosingSigned(LDKClosingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSigned)); }
 679         operator LDKClosingSigned() { LDKClosingSigned res = self; memset(&self, 0, sizeof(LDKClosingSigned)); return res; }
 680         LDKClosingSigned* operator &() { return &self; }
 681         LDKClosingSigned* operator ->() { return &self; }
 682         const LDKClosingSigned* operator &() const { return &self; }
 683         const LDKClosingSigned* operator ->() const { return &self; }
 684 };
 685 class UpdateAddHTLC {
 686 private:
 687         LDKUpdateAddHTLC self;
 688 public:
 689         UpdateAddHTLC(const UpdateAddHTLC&) = delete;
 690         ~UpdateAddHTLC() { UpdateAddHTLC_free(self); }
 691         UpdateAddHTLC(UpdateAddHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateAddHTLC)); }
 692         UpdateAddHTLC(LDKUpdateAddHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateAddHTLC)); }
 693         operator LDKUpdateAddHTLC() { LDKUpdateAddHTLC res = self; memset(&self, 0, sizeof(LDKUpdateAddHTLC)); return res; }
 694         LDKUpdateAddHTLC* operator &() { return &self; }
 695         LDKUpdateAddHTLC* operator ->() { return &self; }
 696         const LDKUpdateAddHTLC* operator &() const { return &self; }
 697         const LDKUpdateAddHTLC* operator ->() const { return &self; }
 698 };
 699 class UpdateFulfillHTLC {
 700 private:
 701         LDKUpdateFulfillHTLC self;
 702 public:
 703         UpdateFulfillHTLC(const UpdateFulfillHTLC&) = delete;
 704         ~UpdateFulfillHTLC() { UpdateFulfillHTLC_free(self); }
 705         UpdateFulfillHTLC(UpdateFulfillHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFulfillHTLC)); }
 706         UpdateFulfillHTLC(LDKUpdateFulfillHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFulfillHTLC)); }
 707         operator LDKUpdateFulfillHTLC() { LDKUpdateFulfillHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFulfillHTLC)); return res; }
 708         LDKUpdateFulfillHTLC* operator &() { return &self; }
 709         LDKUpdateFulfillHTLC* operator ->() { return &self; }
 710         const LDKUpdateFulfillHTLC* operator &() const { return &self; }
 711         const LDKUpdateFulfillHTLC* operator ->() const { return &self; }
 712 };
 713 class UpdateFailHTLC {
 714 private:
 715         LDKUpdateFailHTLC self;
 716 public:
 717         UpdateFailHTLC(const UpdateFailHTLC&) = delete;
 718         ~UpdateFailHTLC() { UpdateFailHTLC_free(self); }
 719         UpdateFailHTLC(UpdateFailHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailHTLC)); }
 720         UpdateFailHTLC(LDKUpdateFailHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailHTLC)); }
 721         operator LDKUpdateFailHTLC() { LDKUpdateFailHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailHTLC)); return res; }
 722         LDKUpdateFailHTLC* operator &() { return &self; }
 723         LDKUpdateFailHTLC* operator ->() { return &self; }
 724         const LDKUpdateFailHTLC* operator &() const { return &self; }
 725         const LDKUpdateFailHTLC* operator ->() const { return &self; }
 726 };
 727 class UpdateFailMalformedHTLC {
 728 private:
 729         LDKUpdateFailMalformedHTLC self;
 730 public:
 731         UpdateFailMalformedHTLC(const UpdateFailMalformedHTLC&) = delete;
 732         ~UpdateFailMalformedHTLC() { UpdateFailMalformedHTLC_free(self); }
 733         UpdateFailMalformedHTLC(UpdateFailMalformedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); }
 734         UpdateFailMalformedHTLC(LDKUpdateFailMalformedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailMalformedHTLC)); }
 735         operator LDKUpdateFailMalformedHTLC() { LDKUpdateFailMalformedHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailMalformedHTLC)); return res; }
 736         LDKUpdateFailMalformedHTLC* operator &() { return &self; }
 737         LDKUpdateFailMalformedHTLC* operator ->() { return &self; }
 738         const LDKUpdateFailMalformedHTLC* operator &() const { return &self; }
 739         const LDKUpdateFailMalformedHTLC* operator ->() const { return &self; }
 740 };
 741 class CommitmentSigned {
 742 private:
 743         LDKCommitmentSigned self;
 744 public:
 745         CommitmentSigned(const CommitmentSigned&) = delete;
 746         ~CommitmentSigned() { CommitmentSigned_free(self); }
 747         CommitmentSigned(CommitmentSigned&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentSigned)); }
 748         CommitmentSigned(LDKCommitmentSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentSigned)); }
 749         operator LDKCommitmentSigned() { LDKCommitmentSigned res = self; memset(&self, 0, sizeof(LDKCommitmentSigned)); return res; }
 750         LDKCommitmentSigned* operator &() { return &self; }
 751         LDKCommitmentSigned* operator ->() { return &self; }
 752         const LDKCommitmentSigned* operator &() const { return &self; }
 753         const LDKCommitmentSigned* operator ->() const { return &self; }
 754 };
 755 class RevokeAndACK {
 756 private:
 757         LDKRevokeAndACK self;
 758 public:
 759         RevokeAndACK(const RevokeAndACK&) = delete;
 760         ~RevokeAndACK() { RevokeAndACK_free(self); }
 761         RevokeAndACK(RevokeAndACK&& o) : self(o.self) { memset(&o, 0, sizeof(RevokeAndACK)); }
 762         RevokeAndACK(LDKRevokeAndACK&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevokeAndACK)); }
 763         operator LDKRevokeAndACK() { LDKRevokeAndACK res = self; memset(&self, 0, sizeof(LDKRevokeAndACK)); return res; }
 764         LDKRevokeAndACK* operator &() { return &self; }
 765         LDKRevokeAndACK* operator ->() { return &self; }
 766         const LDKRevokeAndACK* operator &() const { return &self; }
 767         const LDKRevokeAndACK* operator ->() const { return &self; }
 768 };
 769 class UpdateFee {
 770 private:
 771         LDKUpdateFee self;
 772 public:
 773         UpdateFee(const UpdateFee&) = delete;
 774         ~UpdateFee() { UpdateFee_free(self); }
 775         UpdateFee(UpdateFee&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFee)); }
 776         UpdateFee(LDKUpdateFee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFee)); }
 777         operator LDKUpdateFee() { LDKUpdateFee res = self; memset(&self, 0, sizeof(LDKUpdateFee)); return res; }
 778         LDKUpdateFee* operator &() { return &self; }
 779         LDKUpdateFee* operator ->() { return &self; }
 780         const LDKUpdateFee* operator &() const { return &self; }
 781         const LDKUpdateFee* operator ->() const { return &self; }
 782 };
 783 class DataLossProtect {
 784 private:
 785         LDKDataLossProtect self;
 786 public:
 787         DataLossProtect(const DataLossProtect&) = delete;
 788         ~DataLossProtect() { DataLossProtect_free(self); }
 789         DataLossProtect(DataLossProtect&& o) : self(o.self) { memset(&o, 0, sizeof(DataLossProtect)); }
 790         DataLossProtect(LDKDataLossProtect&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDataLossProtect)); }
 791         operator LDKDataLossProtect() { LDKDataLossProtect res = self; memset(&self, 0, sizeof(LDKDataLossProtect)); return res; }
 792         LDKDataLossProtect* operator &() { return &self; }
 793         LDKDataLossProtect* operator ->() { return &self; }
 794         const LDKDataLossProtect* operator &() const { return &self; }
 795         const LDKDataLossProtect* operator ->() const { return &self; }
 796 };
 797 class ChannelReestablish {
 798 private:
 799         LDKChannelReestablish self;
 800 public:
 801         ChannelReestablish(const ChannelReestablish&) = delete;
 802         ~ChannelReestablish() { ChannelReestablish_free(self); }
 803         ChannelReestablish(ChannelReestablish&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReestablish)); }
 804         ChannelReestablish(LDKChannelReestablish&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReestablish)); }
 805         operator LDKChannelReestablish() { LDKChannelReestablish res = self; memset(&self, 0, sizeof(LDKChannelReestablish)); return res; }
 806         LDKChannelReestablish* operator &() { return &self; }
 807         LDKChannelReestablish* operator ->() { return &self; }
 808         const LDKChannelReestablish* operator &() const { return &self; }
 809         const LDKChannelReestablish* operator ->() const { return &self; }
 810 };
 811 class AnnouncementSignatures {
 812 private:
 813         LDKAnnouncementSignatures self;
 814 public:
 815         AnnouncementSignatures(const AnnouncementSignatures&) = delete;
 816         ~AnnouncementSignatures() { AnnouncementSignatures_free(self); }
 817         AnnouncementSignatures(AnnouncementSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(AnnouncementSignatures)); }
 818         AnnouncementSignatures(LDKAnnouncementSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnnouncementSignatures)); }
 819         operator LDKAnnouncementSignatures() { LDKAnnouncementSignatures res = self; memset(&self, 0, sizeof(LDKAnnouncementSignatures)); return res; }
 820         LDKAnnouncementSignatures* operator &() { return &self; }
 821         LDKAnnouncementSignatures* operator ->() { return &self; }
 822         const LDKAnnouncementSignatures* operator &() const { return &self; }
 823         const LDKAnnouncementSignatures* operator ->() const { return &self; }
 824 };
 825 class NetAddress {
 826 private:
 827         LDKNetAddress self;
 828 public:
 829         NetAddress(const NetAddress&) = delete;
 830         ~NetAddress() { NetAddress_free(self); }
 831         NetAddress(NetAddress&& o) : self(o.self) { memset(&o, 0, sizeof(NetAddress)); }
 832         NetAddress(LDKNetAddress&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetAddress)); }
 833         operator LDKNetAddress() { LDKNetAddress res = self; memset(&self, 0, sizeof(LDKNetAddress)); return res; }
 834         LDKNetAddress* operator &() { return &self; }
 835         LDKNetAddress* operator ->() { return &self; }
 836         const LDKNetAddress* operator &() const { return &self; }
 837         const LDKNetAddress* operator ->() const { return &self; }
 838 };
 839 class UnsignedNodeAnnouncement {
 840 private:
 841         LDKUnsignedNodeAnnouncement self;
 842 public:
 843         UnsignedNodeAnnouncement(const UnsignedNodeAnnouncement&) = delete;
 844         ~UnsignedNodeAnnouncement() { UnsignedNodeAnnouncement_free(self); }
 845         UnsignedNodeAnnouncement(UnsignedNodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); }
 846         UnsignedNodeAnnouncement(LDKUnsignedNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedNodeAnnouncement)); }
 847         operator LDKUnsignedNodeAnnouncement() { LDKUnsignedNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedNodeAnnouncement)); return res; }
 848         LDKUnsignedNodeAnnouncement* operator &() { return &self; }
 849         LDKUnsignedNodeAnnouncement* operator ->() { return &self; }
 850         const LDKUnsignedNodeAnnouncement* operator &() const { return &self; }
 851         const LDKUnsignedNodeAnnouncement* operator ->() const { return &self; }
 852 };
 853 class NodeAnnouncement {
 854 private:
 855         LDKNodeAnnouncement self;
 856 public:
 857         NodeAnnouncement(const NodeAnnouncement&) = delete;
 858         ~NodeAnnouncement() { NodeAnnouncement_free(self); }
 859         NodeAnnouncement(NodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncement)); }
 860         NodeAnnouncement(LDKNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncement)); }
 861         operator LDKNodeAnnouncement() { LDKNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKNodeAnnouncement)); return res; }
 862         LDKNodeAnnouncement* operator &() { return &self; }
 863         LDKNodeAnnouncement* operator ->() { return &self; }
 864         const LDKNodeAnnouncement* operator &() const { return &self; }
 865         const LDKNodeAnnouncement* operator ->() const { return &self; }
 866 };
 867 class UnsignedChannelAnnouncement {
 868 private:
 869         LDKUnsignedChannelAnnouncement self;
 870 public:
 871         UnsignedChannelAnnouncement(const UnsignedChannelAnnouncement&) = delete;
 872         ~UnsignedChannelAnnouncement() { UnsignedChannelAnnouncement_free(self); }
 873         UnsignedChannelAnnouncement(UnsignedChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); }
 874         UnsignedChannelAnnouncement(LDKUnsignedChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelAnnouncement)); }
 875         operator LDKUnsignedChannelAnnouncement() { LDKUnsignedChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedChannelAnnouncement)); return res; }
 876         LDKUnsignedChannelAnnouncement* operator &() { return &self; }
 877         LDKUnsignedChannelAnnouncement* operator ->() { return &self; }
 878         const LDKUnsignedChannelAnnouncement* operator &() const { return &self; }
 879         const LDKUnsignedChannelAnnouncement* operator ->() const { return &self; }
 880 };
 881 class ChannelAnnouncement {
 882 private:
 883         LDKChannelAnnouncement self;
 884 public:
 885         ChannelAnnouncement(const ChannelAnnouncement&) = delete;
 886         ~ChannelAnnouncement() { ChannelAnnouncement_free(self); }
 887         ChannelAnnouncement(ChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelAnnouncement)); }
 888         ChannelAnnouncement(LDKChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelAnnouncement)); }
 889         operator LDKChannelAnnouncement() { LDKChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKChannelAnnouncement)); return res; }
 890         LDKChannelAnnouncement* operator &() { return &self; }
 891         LDKChannelAnnouncement* operator ->() { return &self; }
 892         const LDKChannelAnnouncement* operator &() const { return &self; }
 893         const LDKChannelAnnouncement* operator ->() const { return &self; }
 894 };
 895 class UnsignedChannelUpdate {
 896 private:
 897         LDKUnsignedChannelUpdate self;
 898 public:
 899         UnsignedChannelUpdate(const UnsignedChannelUpdate&) = delete;
 900         ~UnsignedChannelUpdate() { UnsignedChannelUpdate_free(self); }
 901         UnsignedChannelUpdate(UnsignedChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelUpdate)); }
 902         UnsignedChannelUpdate(LDKUnsignedChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelUpdate)); }
 903         operator LDKUnsignedChannelUpdate() { LDKUnsignedChannelUpdate res = self; memset(&self, 0, sizeof(LDKUnsignedChannelUpdate)); return res; }
 904         LDKUnsignedChannelUpdate* operator &() { return &self; }
 905         LDKUnsignedChannelUpdate* operator ->() { return &self; }
 906         const LDKUnsignedChannelUpdate* operator &() const { return &self; }
 907         const LDKUnsignedChannelUpdate* operator ->() const { return &self; }
 908 };
 909 class ChannelUpdate {
 910 private:
 911         LDKChannelUpdate self;
 912 public:
 913         ChannelUpdate(const ChannelUpdate&) = delete;
 914         ~ChannelUpdate() { ChannelUpdate_free(self); }
 915         ChannelUpdate(ChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdate)); }
 916         ChannelUpdate(LDKChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdate)); }
 917         operator LDKChannelUpdate() { LDKChannelUpdate res = self; memset(&self, 0, sizeof(LDKChannelUpdate)); return res; }
 918         LDKChannelUpdate* operator &() { return &self; }
 919         LDKChannelUpdate* operator ->() { return &self; }
 920         const LDKChannelUpdate* operator &() const { return &self; }
 921         const LDKChannelUpdate* operator ->() const { return &self; }
 922 };
 923 class QueryChannelRange {
 924 private:
 925         LDKQueryChannelRange self;
 926 public:
 927         QueryChannelRange(const QueryChannelRange&) = delete;
 928         ~QueryChannelRange() { QueryChannelRange_free(self); }
 929         QueryChannelRange(QueryChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(QueryChannelRange)); }
 930         QueryChannelRange(LDKQueryChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryChannelRange)); }
 931         operator LDKQueryChannelRange() { LDKQueryChannelRange res = self; memset(&self, 0, sizeof(LDKQueryChannelRange)); return res; }
 932         LDKQueryChannelRange* operator &() { return &self; }
 933         LDKQueryChannelRange* operator ->() { return &self; }
 934         const LDKQueryChannelRange* operator &() const { return &self; }
 935         const LDKQueryChannelRange* operator ->() const { return &self; }
 936 };
 937 class ReplyChannelRange {
 938 private:
 939         LDKReplyChannelRange self;
 940 public:
 941         ReplyChannelRange(const ReplyChannelRange&) = delete;
 942         ~ReplyChannelRange() { ReplyChannelRange_free(self); }
 943         ReplyChannelRange(ReplyChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyChannelRange)); }
 944         ReplyChannelRange(LDKReplyChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyChannelRange)); }
 945         operator LDKReplyChannelRange() { LDKReplyChannelRange res = self; memset(&self, 0, sizeof(LDKReplyChannelRange)); return res; }
 946         LDKReplyChannelRange* operator &() { return &self; }
 947         LDKReplyChannelRange* operator ->() { return &self; }
 948         const LDKReplyChannelRange* operator &() const { return &self; }
 949         const LDKReplyChannelRange* operator ->() const { return &self; }
 950 };
 951 class QueryShortChannelIds {
 952 private:
 953         LDKQueryShortChannelIds self;
 954 public:
 955         QueryShortChannelIds(const QueryShortChannelIds&) = delete;
 956         ~QueryShortChannelIds() { QueryShortChannelIds_free(self); }
 957         QueryShortChannelIds(QueryShortChannelIds&& o) : self(o.self) { memset(&o, 0, sizeof(QueryShortChannelIds)); }
 958         QueryShortChannelIds(LDKQueryShortChannelIds&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryShortChannelIds)); }
 959         operator LDKQueryShortChannelIds() { LDKQueryShortChannelIds res = self; memset(&self, 0, sizeof(LDKQueryShortChannelIds)); return res; }
 960         LDKQueryShortChannelIds* operator &() { return &self; }
 961         LDKQueryShortChannelIds* operator ->() { return &self; }
 962         const LDKQueryShortChannelIds* operator &() const { return &self; }
 963         const LDKQueryShortChannelIds* operator ->() const { return &self; }
 964 };
 965 class ReplyShortChannelIdsEnd {
 966 private:
 967         LDKReplyShortChannelIdsEnd self;
 968 public:
 969         ReplyShortChannelIdsEnd(const ReplyShortChannelIdsEnd&) = delete;
 970         ~ReplyShortChannelIdsEnd() { ReplyShortChannelIdsEnd_free(self); }
 971         ReplyShortChannelIdsEnd(ReplyShortChannelIdsEnd&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); }
 972         ReplyShortChannelIdsEnd(LDKReplyShortChannelIdsEnd&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyShortChannelIdsEnd)); }
 973         operator LDKReplyShortChannelIdsEnd() { LDKReplyShortChannelIdsEnd res = self; memset(&self, 0, sizeof(LDKReplyShortChannelIdsEnd)); return res; }
 974         LDKReplyShortChannelIdsEnd* operator &() { return &self; }
 975         LDKReplyShortChannelIdsEnd* operator ->() { return &self; }
 976         const LDKReplyShortChannelIdsEnd* operator &() const { return &self; }
 977         const LDKReplyShortChannelIdsEnd* operator ->() const { return &self; }
 978 };
 979 class GossipTimestampFilter {
 980 private:
 981         LDKGossipTimestampFilter self;
 982 public:
 983         GossipTimestampFilter(const GossipTimestampFilter&) = delete;
 984         ~GossipTimestampFilter() { GossipTimestampFilter_free(self); }
 985         GossipTimestampFilter(GossipTimestampFilter&& o) : self(o.self) { memset(&o, 0, sizeof(GossipTimestampFilter)); }
 986         GossipTimestampFilter(LDKGossipTimestampFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipTimestampFilter)); }
 987         operator LDKGossipTimestampFilter() { LDKGossipTimestampFilter res = self; memset(&self, 0, sizeof(LDKGossipTimestampFilter)); return res; }
 988         LDKGossipTimestampFilter* operator &() { return &self; }
 989         LDKGossipTimestampFilter* operator ->() { return &self; }
 990         const LDKGossipTimestampFilter* operator &() const { return &self; }
 991         const LDKGossipTimestampFilter* operator ->() const { return &self; }
 992 };
 993 class ErrorAction {
 994 private:
 995         LDKErrorAction self;
 996 public:
 997         ErrorAction(const ErrorAction&) = delete;
 998         ~ErrorAction() { ErrorAction_free(self); }
 999         ErrorAction(ErrorAction&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorAction)); }
1000         ErrorAction(LDKErrorAction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorAction)); }
1001         operator LDKErrorAction() { LDKErrorAction res = self; memset(&self, 0, sizeof(LDKErrorAction)); return res; }
1002         LDKErrorAction* operator &() { return &self; }
1003         LDKErrorAction* operator ->() { return &self; }
1004         const LDKErrorAction* operator &() const { return &self; }
1005         const LDKErrorAction* operator ->() const { return &self; }
1006 };
1007 class LightningError {
1008 private:
1009         LDKLightningError self;
1010 public:
1011         LightningError(const LightningError&) = delete;
1012         ~LightningError() { LightningError_free(self); }
1013         LightningError(LightningError&& o) : self(o.self) { memset(&o, 0, sizeof(LightningError)); }
1014         LightningError(LDKLightningError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLightningError)); }
1015         operator LDKLightningError() { LDKLightningError res = self; memset(&self, 0, sizeof(LDKLightningError)); return res; }
1016         LDKLightningError* operator &() { return &self; }
1017         LDKLightningError* operator ->() { return &self; }
1018         const LDKLightningError* operator &() const { return &self; }
1019         const LDKLightningError* operator ->() const { return &self; }
1020 };
1021 class CommitmentUpdate {
1022 private:
1023         LDKCommitmentUpdate self;
1024 public:
1025         CommitmentUpdate(const CommitmentUpdate&) = delete;
1026         ~CommitmentUpdate() { CommitmentUpdate_free(self); }
1027         CommitmentUpdate(CommitmentUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentUpdate)); }
1028         CommitmentUpdate(LDKCommitmentUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentUpdate)); }
1029         operator LDKCommitmentUpdate() { LDKCommitmentUpdate res = self; memset(&self, 0, sizeof(LDKCommitmentUpdate)); return res; }
1030         LDKCommitmentUpdate* operator &() { return &self; }
1031         LDKCommitmentUpdate* operator ->() { return &self; }
1032         const LDKCommitmentUpdate* operator &() const { return &self; }
1033         const LDKCommitmentUpdate* operator ->() const { return &self; }
1034 };
1035 class HTLCFailChannelUpdate {
1036 private:
1037         LDKHTLCFailChannelUpdate self;
1038 public:
1039         HTLCFailChannelUpdate(const HTLCFailChannelUpdate&) = delete;
1040         ~HTLCFailChannelUpdate() { HTLCFailChannelUpdate_free(self); }
1041         HTLCFailChannelUpdate(HTLCFailChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCFailChannelUpdate)); }
1042         HTLCFailChannelUpdate(LDKHTLCFailChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCFailChannelUpdate)); }
1043         operator LDKHTLCFailChannelUpdate() { LDKHTLCFailChannelUpdate res = self; memset(&self, 0, sizeof(LDKHTLCFailChannelUpdate)); return res; }
1044         LDKHTLCFailChannelUpdate* operator &() { return &self; }
1045         LDKHTLCFailChannelUpdate* operator ->() { return &self; }
1046         const LDKHTLCFailChannelUpdate* operator &() const { return &self; }
1047         const LDKHTLCFailChannelUpdate* operator ->() const { return &self; }
1048 };
1049 class ChannelMessageHandler {
1050 private:
1051         LDKChannelMessageHandler self;
1052 public:
1053         ChannelMessageHandler(const ChannelMessageHandler&) = delete;
1054         ~ChannelMessageHandler() { ChannelMessageHandler_free(self); }
1055         ChannelMessageHandler(ChannelMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMessageHandler)); }
1056         ChannelMessageHandler(LDKChannelMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMessageHandler)); }
1057         operator LDKChannelMessageHandler() { LDKChannelMessageHandler res = self; memset(&self, 0, sizeof(LDKChannelMessageHandler)); return res; }
1058         LDKChannelMessageHandler* operator &() { return &self; }
1059         LDKChannelMessageHandler* operator ->() { return &self; }
1060         const LDKChannelMessageHandler* operator &() const { return &self; }
1061         const LDKChannelMessageHandler* operator ->() const { return &self; }
1062 };
1063 class RoutingMessageHandler {
1064 private:
1065         LDKRoutingMessageHandler self;
1066 public:
1067         RoutingMessageHandler(const RoutingMessageHandler&) = delete;
1068         ~RoutingMessageHandler() { RoutingMessageHandler_free(self); }
1069         RoutingMessageHandler(RoutingMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingMessageHandler)); }
1070         RoutingMessageHandler(LDKRoutingMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingMessageHandler)); }
1071         operator LDKRoutingMessageHandler() { LDKRoutingMessageHandler res = self; memset(&self, 0, sizeof(LDKRoutingMessageHandler)); return res; }
1072         LDKRoutingMessageHandler* operator &() { return &self; }
1073         LDKRoutingMessageHandler* operator ->() { return &self; }
1074         const LDKRoutingMessageHandler* operator &() const { return &self; }
1075         const LDKRoutingMessageHandler* operator ->() const { return &self; }
1076 };
1077 class MessageHandler {
1078 private:
1079         LDKMessageHandler self;
1080 public:
1081         MessageHandler(const MessageHandler&) = delete;
1082         ~MessageHandler() { MessageHandler_free(self); }
1083         MessageHandler(MessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(MessageHandler)); }
1084         MessageHandler(LDKMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageHandler)); }
1085         operator LDKMessageHandler() { LDKMessageHandler res = self; memset(&self, 0, sizeof(LDKMessageHandler)); return res; }
1086         LDKMessageHandler* operator &() { return &self; }
1087         LDKMessageHandler* operator ->() { return &self; }
1088         const LDKMessageHandler* operator &() const { return &self; }
1089         const LDKMessageHandler* operator ->() const { return &self; }
1090 };
1091 class SocketDescriptor {
1092 private:
1093         LDKSocketDescriptor self;
1094 public:
1095         SocketDescriptor(const SocketDescriptor&) = delete;
1096         ~SocketDescriptor() { SocketDescriptor_free(self); }
1097         SocketDescriptor(SocketDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SocketDescriptor)); }
1098         SocketDescriptor(LDKSocketDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketDescriptor)); }
1099         operator LDKSocketDescriptor() { LDKSocketDescriptor res = self; memset(&self, 0, sizeof(LDKSocketDescriptor)); return res; }
1100         LDKSocketDescriptor* operator &() { return &self; }
1101         LDKSocketDescriptor* operator ->() { return &self; }
1102         const LDKSocketDescriptor* operator &() const { return &self; }
1103         const LDKSocketDescriptor* operator ->() const { return &self; }
1104 };
1105 class PeerHandleError {
1106 private:
1107         LDKPeerHandleError self;
1108 public:
1109         PeerHandleError(const PeerHandleError&) = delete;
1110         ~PeerHandleError() { PeerHandleError_free(self); }
1111         PeerHandleError(PeerHandleError&& o) : self(o.self) { memset(&o, 0, sizeof(PeerHandleError)); }
1112         PeerHandleError(LDKPeerHandleError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerHandleError)); }
1113         operator LDKPeerHandleError() { LDKPeerHandleError res = self; memset(&self, 0, sizeof(LDKPeerHandleError)); return res; }
1114         LDKPeerHandleError* operator &() { return &self; }
1115         LDKPeerHandleError* operator ->() { return &self; }
1116         const LDKPeerHandleError* operator &() const { return &self; }
1117         const LDKPeerHandleError* operator ->() const { return &self; }
1118 };
1119 class PeerManager {
1120 private:
1121         LDKPeerManager self;
1122 public:
1123         PeerManager(const PeerManager&) = delete;
1124         ~PeerManager() { PeerManager_free(self); }
1125         PeerManager(PeerManager&& o) : self(o.self) { memset(&o, 0, sizeof(PeerManager)); }
1126         PeerManager(LDKPeerManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerManager)); }
1127         operator LDKPeerManager() { LDKPeerManager res = self; memset(&self, 0, sizeof(LDKPeerManager)); return res; }
1128         LDKPeerManager* operator &() { return &self; }
1129         LDKPeerManager* operator ->() { return &self; }
1130         const LDKPeerManager* operator &() const { return &self; }
1131         const LDKPeerManager* operator ->() const { return &self; }
1132 };
1133 class TxCreationKeys {
1134 private:
1135         LDKTxCreationKeys self;
1136 public:
1137         TxCreationKeys(const TxCreationKeys&) = delete;
1138         ~TxCreationKeys() { TxCreationKeys_free(self); }
1139         TxCreationKeys(TxCreationKeys&& o) : self(o.self) { memset(&o, 0, sizeof(TxCreationKeys)); }
1140         TxCreationKeys(LDKTxCreationKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxCreationKeys)); }
1141         operator LDKTxCreationKeys() { LDKTxCreationKeys res = self; memset(&self, 0, sizeof(LDKTxCreationKeys)); return res; }
1142         LDKTxCreationKeys* operator &() { return &self; }
1143         LDKTxCreationKeys* operator ->() { return &self; }
1144         const LDKTxCreationKeys* operator &() const { return &self; }
1145         const LDKTxCreationKeys* operator ->() const { return &self; }
1146 };
1147 class PreCalculatedTxCreationKeys {
1148 private:
1149         LDKPreCalculatedTxCreationKeys self;
1150 public:
1151         PreCalculatedTxCreationKeys(const PreCalculatedTxCreationKeys&) = delete;
1152         ~PreCalculatedTxCreationKeys() { PreCalculatedTxCreationKeys_free(self); }
1153         PreCalculatedTxCreationKeys(PreCalculatedTxCreationKeys&& o) : self(o.self) { memset(&o, 0, sizeof(PreCalculatedTxCreationKeys)); }
1154         PreCalculatedTxCreationKeys(LDKPreCalculatedTxCreationKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPreCalculatedTxCreationKeys)); }
1155         operator LDKPreCalculatedTxCreationKeys() { LDKPreCalculatedTxCreationKeys res = self; memset(&self, 0, sizeof(LDKPreCalculatedTxCreationKeys)); return res; }
1156         LDKPreCalculatedTxCreationKeys* operator &() { return &self; }
1157         LDKPreCalculatedTxCreationKeys* operator ->() { return &self; }
1158         const LDKPreCalculatedTxCreationKeys* operator &() const { return &self; }
1159         const LDKPreCalculatedTxCreationKeys* operator ->() const { return &self; }
1160 };
1161 class ChannelPublicKeys {
1162 private:
1163         LDKChannelPublicKeys self;
1164 public:
1165         ChannelPublicKeys(const ChannelPublicKeys&) = delete;
1166         ~ChannelPublicKeys() { ChannelPublicKeys_free(self); }
1167         ChannelPublicKeys(ChannelPublicKeys&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelPublicKeys)); }
1168         ChannelPublicKeys(LDKChannelPublicKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelPublicKeys)); }
1169         operator LDKChannelPublicKeys() { LDKChannelPublicKeys res = self; memset(&self, 0, sizeof(LDKChannelPublicKeys)); return res; }
1170         LDKChannelPublicKeys* operator &() { return &self; }
1171         LDKChannelPublicKeys* operator ->() { return &self; }
1172         const LDKChannelPublicKeys* operator &() const { return &self; }
1173         const LDKChannelPublicKeys* operator ->() const { return &self; }
1174 };
1175 class HTLCOutputInCommitment {
1176 private:
1177         LDKHTLCOutputInCommitment self;
1178 public:
1179         HTLCOutputInCommitment(const HTLCOutputInCommitment&) = delete;
1180         ~HTLCOutputInCommitment() { HTLCOutputInCommitment_free(self); }
1181         HTLCOutputInCommitment(HTLCOutputInCommitment&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCOutputInCommitment)); }
1182         HTLCOutputInCommitment(LDKHTLCOutputInCommitment&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCOutputInCommitment)); }
1183         operator LDKHTLCOutputInCommitment() { LDKHTLCOutputInCommitment res = self; memset(&self, 0, sizeof(LDKHTLCOutputInCommitment)); return res; }
1184         LDKHTLCOutputInCommitment* operator &() { return &self; }
1185         LDKHTLCOutputInCommitment* operator ->() { return &self; }
1186         const LDKHTLCOutputInCommitment* operator &() const { return &self; }
1187         const LDKHTLCOutputInCommitment* operator ->() const { return &self; }
1188 };
1189 class HolderCommitmentTransaction {
1190 private:
1191         LDKHolderCommitmentTransaction self;
1192 public:
1193         HolderCommitmentTransaction(const HolderCommitmentTransaction&) = delete;
1194         ~HolderCommitmentTransaction() { HolderCommitmentTransaction_free(self); }
1195         HolderCommitmentTransaction(HolderCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(HolderCommitmentTransaction)); }
1196         HolderCommitmentTransaction(LDKHolderCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHolderCommitmentTransaction)); }
1197         operator LDKHolderCommitmentTransaction() { LDKHolderCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKHolderCommitmentTransaction)); return res; }
1198         LDKHolderCommitmentTransaction* operator &() { return &self; }
1199         LDKHolderCommitmentTransaction* operator ->() { return &self; }
1200         const LDKHolderCommitmentTransaction* operator &() const { return &self; }
1201         const LDKHolderCommitmentTransaction* operator ->() const { return &self; }
1202 };
1203 class InitFeatures {
1204 private:
1205         LDKInitFeatures self;
1206 public:
1207         InitFeatures(const InitFeatures&) = delete;
1208         ~InitFeatures() { InitFeatures_free(self); }
1209         InitFeatures(InitFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InitFeatures)); }
1210         InitFeatures(LDKInitFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInitFeatures)); }
1211         operator LDKInitFeatures() { LDKInitFeatures res = self; memset(&self, 0, sizeof(LDKInitFeatures)); return res; }
1212         LDKInitFeatures* operator &() { return &self; }
1213         LDKInitFeatures* operator ->() { return &self; }
1214         const LDKInitFeatures* operator &() const { return &self; }
1215         const LDKInitFeatures* operator ->() const { return &self; }
1216 };
1217 class NodeFeatures {
1218 private:
1219         LDKNodeFeatures self;
1220 public:
1221         NodeFeatures(const NodeFeatures&) = delete;
1222         ~NodeFeatures() { NodeFeatures_free(self); }
1223         NodeFeatures(NodeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(NodeFeatures)); }
1224         NodeFeatures(LDKNodeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeFeatures)); }
1225         operator LDKNodeFeatures() { LDKNodeFeatures res = self; memset(&self, 0, sizeof(LDKNodeFeatures)); return res; }
1226         LDKNodeFeatures* operator &() { return &self; }
1227         LDKNodeFeatures* operator ->() { return &self; }
1228         const LDKNodeFeatures* operator &() const { return &self; }
1229         const LDKNodeFeatures* operator ->() const { return &self; }
1230 };
1231 class ChannelFeatures {
1232 private:
1233         LDKChannelFeatures self;
1234 public:
1235         ChannelFeatures(const ChannelFeatures&) = delete;
1236         ~ChannelFeatures() { ChannelFeatures_free(self); }
1237         ChannelFeatures(ChannelFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelFeatures)); }
1238         ChannelFeatures(LDKChannelFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelFeatures)); }
1239         operator LDKChannelFeatures() { LDKChannelFeatures res = self; memset(&self, 0, sizeof(LDKChannelFeatures)); return res; }
1240         LDKChannelFeatures* operator &() { return &self; }
1241         LDKChannelFeatures* operator ->() { return &self; }
1242         const LDKChannelFeatures* operator &() const { return &self; }
1243         const LDKChannelFeatures* operator ->() const { return &self; }
1244 };
1245 class RouteHop {
1246 private:
1247         LDKRouteHop self;
1248 public:
1249         RouteHop(const RouteHop&) = delete;
1250         ~RouteHop() { RouteHop_free(self); }
1251         RouteHop(RouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHop)); }
1252         RouteHop(LDKRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHop)); }
1253         operator LDKRouteHop() { LDKRouteHop res = self; memset(&self, 0, sizeof(LDKRouteHop)); return res; }
1254         LDKRouteHop* operator &() { return &self; }
1255         LDKRouteHop* operator ->() { return &self; }
1256         const LDKRouteHop* operator &() const { return &self; }
1257         const LDKRouteHop* operator ->() const { return &self; }
1258 };
1259 class Route {
1260 private:
1261         LDKRoute self;
1262 public:
1263         Route(const Route&) = delete;
1264         ~Route() { Route_free(self); }
1265         Route(Route&& o) : self(o.self) { memset(&o, 0, sizeof(Route)); }
1266         Route(LDKRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoute)); }
1267         operator LDKRoute() { LDKRoute res = self; memset(&self, 0, sizeof(LDKRoute)); return res; }
1268         LDKRoute* operator &() { return &self; }
1269         LDKRoute* operator ->() { return &self; }
1270         const LDKRoute* operator &() const { return &self; }
1271         const LDKRoute* operator ->() const { return &self; }
1272 };
1273 class RouteHint {
1274 private:
1275         LDKRouteHint self;
1276 public:
1277         RouteHint(const RouteHint&) = delete;
1278         ~RouteHint() { RouteHint_free(self); }
1279         RouteHint(RouteHint&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHint)); }
1280         RouteHint(LDKRouteHint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHint)); }
1281         operator LDKRouteHint() { LDKRouteHint res = self; memset(&self, 0, sizeof(LDKRouteHint)); return res; }
1282         LDKRouteHint* operator &() { return &self; }
1283         LDKRouteHint* operator ->() { return &self; }
1284         const LDKRouteHint* operator &() const { return &self; }
1285         const LDKRouteHint* operator ->() const { return &self; }
1286 };
1287 class NetworkGraph {
1288 private:
1289         LDKNetworkGraph self;
1290 public:
1291         NetworkGraph(const NetworkGraph&) = delete;
1292         ~NetworkGraph() { NetworkGraph_free(self); }
1293         NetworkGraph(NetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkGraph)); }
1294         NetworkGraph(LDKNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkGraph)); }
1295         operator LDKNetworkGraph() { LDKNetworkGraph res = self; memset(&self, 0, sizeof(LDKNetworkGraph)); return res; }
1296         LDKNetworkGraph* operator &() { return &self; }
1297         LDKNetworkGraph* operator ->() { return &self; }
1298         const LDKNetworkGraph* operator &() const { return &self; }
1299         const LDKNetworkGraph* operator ->() const { return &self; }
1300 };
1301 class LockedNetworkGraph {
1302 private:
1303         LDKLockedNetworkGraph self;
1304 public:
1305         LockedNetworkGraph(const LockedNetworkGraph&) = delete;
1306         ~LockedNetworkGraph() { LockedNetworkGraph_free(self); }
1307         LockedNetworkGraph(LockedNetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(LockedNetworkGraph)); }
1308         LockedNetworkGraph(LDKLockedNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockedNetworkGraph)); }
1309         operator LDKLockedNetworkGraph() { LDKLockedNetworkGraph res = self; memset(&self, 0, sizeof(LDKLockedNetworkGraph)); return res; }
1310         LDKLockedNetworkGraph* operator &() { return &self; }
1311         LDKLockedNetworkGraph* operator ->() { return &self; }
1312         const LDKLockedNetworkGraph* operator &() const { return &self; }
1313         const LDKLockedNetworkGraph* operator ->() const { return &self; }
1314 };
1315 class NetGraphMsgHandler {
1316 private:
1317         LDKNetGraphMsgHandler self;
1318 public:
1319         NetGraphMsgHandler(const NetGraphMsgHandler&) = delete;
1320         ~NetGraphMsgHandler() { NetGraphMsgHandler_free(self); }
1321         NetGraphMsgHandler(NetGraphMsgHandler&& o) : self(o.self) { memset(&o, 0, sizeof(NetGraphMsgHandler)); }
1322         NetGraphMsgHandler(LDKNetGraphMsgHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetGraphMsgHandler)); }
1323         operator LDKNetGraphMsgHandler() { LDKNetGraphMsgHandler res = self; memset(&self, 0, sizeof(LDKNetGraphMsgHandler)); return res; }
1324         LDKNetGraphMsgHandler* operator &() { return &self; }
1325         LDKNetGraphMsgHandler* operator ->() { return &self; }
1326         const LDKNetGraphMsgHandler* operator &() const { return &self; }
1327         const LDKNetGraphMsgHandler* operator ->() const { return &self; }
1328 };
1329 class DirectionalChannelInfo {
1330 private:
1331         LDKDirectionalChannelInfo self;
1332 public:
1333         DirectionalChannelInfo(const DirectionalChannelInfo&) = delete;
1334         ~DirectionalChannelInfo() { DirectionalChannelInfo_free(self); }
1335         DirectionalChannelInfo(DirectionalChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(DirectionalChannelInfo)); }
1336         DirectionalChannelInfo(LDKDirectionalChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectionalChannelInfo)); }
1337         operator LDKDirectionalChannelInfo() { LDKDirectionalChannelInfo res = self; memset(&self, 0, sizeof(LDKDirectionalChannelInfo)); return res; }
1338         LDKDirectionalChannelInfo* operator &() { return &self; }
1339         LDKDirectionalChannelInfo* operator ->() { return &self; }
1340         const LDKDirectionalChannelInfo* operator &() const { return &self; }
1341         const LDKDirectionalChannelInfo* operator ->() const { return &self; }
1342 };
1343 class ChannelInfo {
1344 private:
1345         LDKChannelInfo self;
1346 public:
1347         ChannelInfo(const ChannelInfo&) = delete;
1348         ~ChannelInfo() { ChannelInfo_free(self); }
1349         ChannelInfo(ChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelInfo)); }
1350         ChannelInfo(LDKChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelInfo)); }
1351         operator LDKChannelInfo() { LDKChannelInfo res = self; memset(&self, 0, sizeof(LDKChannelInfo)); return res; }
1352         LDKChannelInfo* operator &() { return &self; }
1353         LDKChannelInfo* operator ->() { return &self; }
1354         const LDKChannelInfo* operator &() const { return &self; }
1355         const LDKChannelInfo* operator ->() const { return &self; }
1356 };
1357 class RoutingFees {
1358 private:
1359         LDKRoutingFees self;
1360 public:
1361         RoutingFees(const RoutingFees&) = delete;
1362         ~RoutingFees() { RoutingFees_free(self); }
1363         RoutingFees(RoutingFees&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingFees)); }
1364         RoutingFees(LDKRoutingFees&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingFees)); }
1365         operator LDKRoutingFees() { LDKRoutingFees res = self; memset(&self, 0, sizeof(LDKRoutingFees)); return res; }
1366         LDKRoutingFees* operator &() { return &self; }
1367         LDKRoutingFees* operator ->() { return &self; }
1368         const LDKRoutingFees* operator &() const { return &self; }
1369         const LDKRoutingFees* operator ->() const { return &self; }
1370 };
1371 class NodeAnnouncementInfo {
1372 private:
1373         LDKNodeAnnouncementInfo self;
1374 public:
1375         NodeAnnouncementInfo(const NodeAnnouncementInfo&) = delete;
1376         ~NodeAnnouncementInfo() { NodeAnnouncementInfo_free(self); }
1377         NodeAnnouncementInfo(NodeAnnouncementInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncementInfo)); }
1378         NodeAnnouncementInfo(LDKNodeAnnouncementInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncementInfo)); }
1379         operator LDKNodeAnnouncementInfo() { LDKNodeAnnouncementInfo res = self; memset(&self, 0, sizeof(LDKNodeAnnouncementInfo)); return res; }
1380         LDKNodeAnnouncementInfo* operator &() { return &self; }
1381         LDKNodeAnnouncementInfo* operator ->() { return &self; }
1382         const LDKNodeAnnouncementInfo* operator &() const { return &self; }
1383         const LDKNodeAnnouncementInfo* operator ->() const { return &self; }
1384 };
1385 class NodeInfo {
1386 private:
1387         LDKNodeInfo self;
1388 public:
1389         NodeInfo(const NodeInfo&) = delete;
1390         ~NodeInfo() { NodeInfo_free(self); }
1391         NodeInfo(NodeInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeInfo)); }
1392         NodeInfo(LDKNodeInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeInfo)); }
1393         operator LDKNodeInfo() { LDKNodeInfo res = self; memset(&self, 0, sizeof(LDKNodeInfo)); return res; }
1394         LDKNodeInfo* operator &() { return &self; }
1395         LDKNodeInfo* operator ->() { return &self; }
1396         const LDKNodeInfo* operator &() const { return &self; }
1397         const LDKNodeInfo* operator ->() const { return &self; }
1398 };
1399 class CResult_PublicKeySecpErrorZ {
1400 private:
1401         LDKCResult_PublicKeySecpErrorZ self;
1402 public:
1403         CResult_PublicKeySecpErrorZ(const CResult_PublicKeySecpErrorZ&) = delete;
1404         ~CResult_PublicKeySecpErrorZ() { CResult_PublicKeySecpErrorZ_free(self); }
1405         CResult_PublicKeySecpErrorZ(CResult_PublicKeySecpErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PublicKeySecpErrorZ)); }
1406         CResult_PublicKeySecpErrorZ(LDKCResult_PublicKeySecpErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PublicKeySecpErrorZ)); }
1407         operator LDKCResult_PublicKeySecpErrorZ() { LDKCResult_PublicKeySecpErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PublicKeySecpErrorZ)); return res; }
1408         LDKCResult_PublicKeySecpErrorZ* operator &() { return &self; }
1409         LDKCResult_PublicKeySecpErrorZ* operator ->() { return &self; }
1410         const LDKCResult_PublicKeySecpErrorZ* operator &() const { return &self; }
1411         const LDKCResult_PublicKeySecpErrorZ* operator ->() const { return &self; }
1412 };
1413 class CVec_u8Z {
1414 private:
1415         LDKCVec_u8Z self;
1416 public:
1417         CVec_u8Z(const CVec_u8Z&) = delete;
1418         ~CVec_u8Z() { CVec_u8Z_free(self); }
1419         CVec_u8Z(CVec_u8Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u8Z)); }
1420         CVec_u8Z(LDKCVec_u8Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u8Z)); }
1421         operator LDKCVec_u8Z() { LDKCVec_u8Z res = self; memset(&self, 0, sizeof(LDKCVec_u8Z)); return res; }
1422         LDKCVec_u8Z* operator &() { return &self; }
1423         LDKCVec_u8Z* operator ->() { return &self; }
1424         const LDKCVec_u8Z* operator &() const { return &self; }
1425         const LDKCVec_u8Z* operator ->() const { return &self; }
1426 };
1427 class CResult_NoneMonitorUpdateErrorZ {
1428 private:
1429         LDKCResult_NoneMonitorUpdateErrorZ self;
1430 public:
1431         CResult_NoneMonitorUpdateErrorZ(const CResult_NoneMonitorUpdateErrorZ&) = delete;
1432         ~CResult_NoneMonitorUpdateErrorZ() { CResult_NoneMonitorUpdateErrorZ_free(self); }
1433         CResult_NoneMonitorUpdateErrorZ(CResult_NoneMonitorUpdateErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneMonitorUpdateErrorZ)); }
1434         CResult_NoneMonitorUpdateErrorZ(LDKCResult_NoneMonitorUpdateErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneMonitorUpdateErrorZ)); }
1435         operator LDKCResult_NoneMonitorUpdateErrorZ() { LDKCResult_NoneMonitorUpdateErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneMonitorUpdateErrorZ)); return res; }
1436         LDKCResult_NoneMonitorUpdateErrorZ* operator &() { return &self; }
1437         LDKCResult_NoneMonitorUpdateErrorZ* operator ->() { return &self; }
1438         const LDKCResult_NoneMonitorUpdateErrorZ* operator &() const { return &self; }
1439         const LDKCResult_NoneMonitorUpdateErrorZ* operator ->() const { return &self; }
1440 };
1441 class C2Tuple_OutPointScriptZ {
1442 private:
1443         LDKC2Tuple_OutPointScriptZ self;
1444 public:
1445         C2Tuple_OutPointScriptZ(const C2Tuple_OutPointScriptZ&) = delete;
1446         ~C2Tuple_OutPointScriptZ() { C2Tuple_OutPointScriptZ_free(self); }
1447         C2Tuple_OutPointScriptZ(C2Tuple_OutPointScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointScriptZ)); }
1448         C2Tuple_OutPointScriptZ(LDKC2Tuple_OutPointScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointScriptZ)); }
1449         operator LDKC2Tuple_OutPointScriptZ() { LDKC2Tuple_OutPointScriptZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointScriptZ)); return res; }
1450         LDKC2Tuple_OutPointScriptZ* operator &() { return &self; }
1451         LDKC2Tuple_OutPointScriptZ* operator ->() { return &self; }
1452         const LDKC2Tuple_OutPointScriptZ* operator &() const { return &self; }
1453         const LDKC2Tuple_OutPointScriptZ* operator ->() const { return &self; }
1454 };
1455 class CVec_u64Z {
1456 private:
1457         LDKCVec_u64Z self;
1458 public:
1459         CVec_u64Z(const CVec_u64Z&) = delete;
1460         ~CVec_u64Z() { CVec_u64Z_free(self); }
1461         CVec_u64Z(CVec_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u64Z)); }
1462         CVec_u64Z(LDKCVec_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u64Z)); }
1463         operator LDKCVec_u64Z() { LDKCVec_u64Z res = self; memset(&self, 0, sizeof(LDKCVec_u64Z)); return res; }
1464         LDKCVec_u64Z* operator &() { return &self; }
1465         LDKCVec_u64Z* operator ->() { return &self; }
1466         const LDKCVec_u64Z* operator &() const { return &self; }
1467         const LDKCVec_u64Z* operator ->() const { return &self; }
1468 };
1469 class CVec_CVec_RouteHopZZ {
1470 private:
1471         LDKCVec_CVec_RouteHopZZ self;
1472 public:
1473         CVec_CVec_RouteHopZZ(const CVec_CVec_RouteHopZZ&) = delete;
1474         ~CVec_CVec_RouteHopZZ() { CVec_CVec_RouteHopZZ_free(self); }
1475         CVec_CVec_RouteHopZZ(CVec_CVec_RouteHopZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CVec_RouteHopZZ)); }
1476         CVec_CVec_RouteHopZZ(LDKCVec_CVec_RouteHopZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CVec_RouteHopZZ)); }
1477         operator LDKCVec_CVec_RouteHopZZ() { LDKCVec_CVec_RouteHopZZ res = self; memset(&self, 0, sizeof(LDKCVec_CVec_RouteHopZZ)); return res; }
1478         LDKCVec_CVec_RouteHopZZ* operator &() { return &self; }
1479         LDKCVec_CVec_RouteHopZZ* operator ->() { return &self; }
1480         const LDKCVec_CVec_RouteHopZZ* operator &() const { return &self; }
1481         const LDKCVec_CVec_RouteHopZZ* operator ->() const { return &self; }
1482 };
1483 class CVec_TransactionZ {
1484 private:
1485         LDKCVec_TransactionZ self;
1486 public:
1487         CVec_TransactionZ(const CVec_TransactionZ&) = delete;
1488         ~CVec_TransactionZ() { CVec_TransactionZ_free(self); }
1489         CVec_TransactionZ(CVec_TransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionZ)); }
1490         CVec_TransactionZ(LDKCVec_TransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionZ)); }
1491         operator LDKCVec_TransactionZ() { LDKCVec_TransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionZ)); return res; }
1492         LDKCVec_TransactionZ* operator &() { return &self; }
1493         LDKCVec_TransactionZ* operator ->() { return &self; }
1494         const LDKCVec_TransactionZ* operator &() const { return &self; }
1495         const LDKCVec_TransactionZ* operator ->() const { return &self; }
1496 };
1497 class CResult_C2Tuple_Scriptu64ZChainErrorZ {
1498 private:
1499         LDKCResult_C2Tuple_Scriptu64ZChainErrorZ self;
1500 public:
1501         CResult_C2Tuple_Scriptu64ZChainErrorZ(const CResult_C2Tuple_Scriptu64ZChainErrorZ&) = delete;
1502         ~CResult_C2Tuple_Scriptu64ZChainErrorZ() { CResult_C2Tuple_Scriptu64ZChainErrorZ_free(self); }
1503         CResult_C2Tuple_Scriptu64ZChainErrorZ(CResult_C2Tuple_Scriptu64ZChainErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_Scriptu64ZChainErrorZ)); }
1504         CResult_C2Tuple_Scriptu64ZChainErrorZ(LDKCResult_C2Tuple_Scriptu64ZChainErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_Scriptu64ZChainErrorZ)); }
1505         operator LDKCResult_C2Tuple_Scriptu64ZChainErrorZ() { LDKCResult_C2Tuple_Scriptu64ZChainErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_Scriptu64ZChainErrorZ)); return res; }
1506         LDKCResult_C2Tuple_Scriptu64ZChainErrorZ* operator &() { return &self; }
1507         LDKCResult_C2Tuple_Scriptu64ZChainErrorZ* operator ->() { return &self; }
1508         const LDKCResult_C2Tuple_Scriptu64ZChainErrorZ* operator &() const { return &self; }
1509         const LDKCResult_C2Tuple_Scriptu64ZChainErrorZ* operator ->() const { return &self; }
1510 };
1511 class CResult_CVec_SignatureZNoneZ {
1512 private:
1513         LDKCResult_CVec_SignatureZNoneZ self;
1514 public:
1515         CResult_CVec_SignatureZNoneZ(const CResult_CVec_SignatureZNoneZ&) = delete;
1516         ~CResult_CVec_SignatureZNoneZ() { CResult_CVec_SignatureZNoneZ_free(self); }
1517         CResult_CVec_SignatureZNoneZ(CResult_CVec_SignatureZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_SignatureZNoneZ)); }
1518         CResult_CVec_SignatureZNoneZ(LDKCResult_CVec_SignatureZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_SignatureZNoneZ)); }
1519         operator LDKCResult_CVec_SignatureZNoneZ() { LDKCResult_CVec_SignatureZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_SignatureZNoneZ)); return res; }
1520         LDKCResult_CVec_SignatureZNoneZ* operator &() { return &self; }
1521         LDKCResult_CVec_SignatureZNoneZ* operator ->() { return &self; }
1522         const LDKCResult_CVec_SignatureZNoneZ* operator &() const { return &self; }
1523         const LDKCResult_CVec_SignatureZNoneZ* operator ->() const { return &self; }
1524 };
1525 class CVec_NodeAnnouncementZ {
1526 private:
1527         LDKCVec_NodeAnnouncementZ self;
1528 public:
1529         CVec_NodeAnnouncementZ(const CVec_NodeAnnouncementZ&) = delete;
1530         ~CVec_NodeAnnouncementZ() { CVec_NodeAnnouncementZ_free(self); }
1531         CVec_NodeAnnouncementZ(CVec_NodeAnnouncementZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_NodeAnnouncementZ)); }
1532         CVec_NodeAnnouncementZ(LDKCVec_NodeAnnouncementZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_NodeAnnouncementZ)); }
1533         operator LDKCVec_NodeAnnouncementZ() { LDKCVec_NodeAnnouncementZ res = self; memset(&self, 0, sizeof(LDKCVec_NodeAnnouncementZ)); return res; }
1534         LDKCVec_NodeAnnouncementZ* operator &() { return &self; }
1535         LDKCVec_NodeAnnouncementZ* operator ->() { return &self; }
1536         const LDKCVec_NodeAnnouncementZ* operator &() const { return &self; }
1537         const LDKCVec_NodeAnnouncementZ* operator ->() const { return &self; }
1538 };
1539 class CResult_RouteLightningErrorZ {
1540 private:
1541         LDKCResult_RouteLightningErrorZ self;
1542 public:
1543         CResult_RouteLightningErrorZ(const CResult_RouteLightningErrorZ&) = delete;
1544         ~CResult_RouteLightningErrorZ() { CResult_RouteLightningErrorZ_free(self); }
1545         CResult_RouteLightningErrorZ(CResult_RouteLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); }
1546         CResult_RouteLightningErrorZ(LDKCResult_RouteLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); }
1547         operator LDKCResult_RouteLightningErrorZ() { LDKCResult_RouteLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); return res; }
1548         LDKCResult_RouteLightningErrorZ* operator &() { return &self; }
1549         LDKCResult_RouteLightningErrorZ* operator ->() { return &self; }
1550         const LDKCResult_RouteLightningErrorZ* operator &() const { return &self; }
1551         const LDKCResult_RouteLightningErrorZ* operator ->() const { return &self; }
1552 };
1553 class CResult_boolPeerHandleErrorZ {
1554 private:
1555         LDKCResult_boolPeerHandleErrorZ self;
1556 public:
1557         CResult_boolPeerHandleErrorZ(const CResult_boolPeerHandleErrorZ&) = delete;
1558         ~CResult_boolPeerHandleErrorZ() { CResult_boolPeerHandleErrorZ_free(self); }
1559         CResult_boolPeerHandleErrorZ(CResult_boolPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); }
1560         CResult_boolPeerHandleErrorZ(LDKCResult_boolPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); }
1561         operator LDKCResult_boolPeerHandleErrorZ() { LDKCResult_boolPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); return res; }
1562         LDKCResult_boolPeerHandleErrorZ* operator &() { return &self; }
1563         LDKCResult_boolPeerHandleErrorZ* operator ->() { return &self; }
1564         const LDKCResult_boolPeerHandleErrorZ* operator &() const { return &self; }
1565         const LDKCResult_boolPeerHandleErrorZ* operator ->() const { return &self; }
1566 };
1567 class C2Tuple_SignatureCVec_SignatureZZ {
1568 private:
1569         LDKC2Tuple_SignatureCVec_SignatureZZ self;
1570 public:
1571         C2Tuple_SignatureCVec_SignatureZZ(const C2Tuple_SignatureCVec_SignatureZZ&) = delete;
1572         ~C2Tuple_SignatureCVec_SignatureZZ() { C2Tuple_SignatureCVec_SignatureZZ_free(self); }
1573         C2Tuple_SignatureCVec_SignatureZZ(C2Tuple_SignatureCVec_SignatureZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_SignatureCVec_SignatureZZ)); }
1574         C2Tuple_SignatureCVec_SignatureZZ(LDKC2Tuple_SignatureCVec_SignatureZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ)); }
1575         operator LDKC2Tuple_SignatureCVec_SignatureZZ() { LDKC2Tuple_SignatureCVec_SignatureZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ)); return res; }
1576         LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() { return &self; }
1577         LDKC2Tuple_SignatureCVec_SignatureZZ* operator ->() { return &self; }
1578         const LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() const { return &self; }
1579         const LDKC2Tuple_SignatureCVec_SignatureZZ* operator ->() const { return &self; }
1580 };
1581 class CVec_HTLCOutputInCommitmentZ {
1582 private:
1583         LDKCVec_HTLCOutputInCommitmentZ self;
1584 public:
1585         CVec_HTLCOutputInCommitmentZ(const CVec_HTLCOutputInCommitmentZ&) = delete;
1586         ~CVec_HTLCOutputInCommitmentZ() { CVec_HTLCOutputInCommitmentZ_free(self); }
1587         CVec_HTLCOutputInCommitmentZ(CVec_HTLCOutputInCommitmentZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_HTLCOutputInCommitmentZ)); }
1588         CVec_HTLCOutputInCommitmentZ(LDKCVec_HTLCOutputInCommitmentZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_HTLCOutputInCommitmentZ)); }
1589         operator LDKCVec_HTLCOutputInCommitmentZ() { LDKCVec_HTLCOutputInCommitmentZ res = self; memset(&self, 0, sizeof(LDKCVec_HTLCOutputInCommitmentZ)); return res; }
1590         LDKCVec_HTLCOutputInCommitmentZ* operator &() { return &self; }
1591         LDKCVec_HTLCOutputInCommitmentZ* operator ->() { return &self; }
1592         const LDKCVec_HTLCOutputInCommitmentZ* operator &() const { return &self; }
1593         const LDKCVec_HTLCOutputInCommitmentZ* operator ->() const { return &self; }
1594 };
1595 class C2Tuple_Scriptu64Z {
1596 private:
1597         LDKC2Tuple_Scriptu64Z self;
1598 public:
1599         C2Tuple_Scriptu64Z(const C2Tuple_Scriptu64Z&) = delete;
1600         ~C2Tuple_Scriptu64Z() { C2Tuple_Scriptu64Z_free(self); }
1601         C2Tuple_Scriptu64Z(C2Tuple_Scriptu64Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_Scriptu64Z)); }
1602         C2Tuple_Scriptu64Z(LDKC2Tuple_Scriptu64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_Scriptu64Z)); }
1603         operator LDKC2Tuple_Scriptu64Z() { LDKC2Tuple_Scriptu64Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_Scriptu64Z)); return res; }
1604         LDKC2Tuple_Scriptu64Z* operator &() { return &self; }
1605         LDKC2Tuple_Scriptu64Z* operator ->() { return &self; }
1606         const LDKC2Tuple_Scriptu64Z* operator &() const { return &self; }
1607         const LDKC2Tuple_Scriptu64Z* operator ->() const { return &self; }
1608 };
1609 class CVec_ChannelMonitorZ {
1610 private:
1611         LDKCVec_ChannelMonitorZ self;
1612 public:
1613         CVec_ChannelMonitorZ(const CVec_ChannelMonitorZ&) = delete;
1614         ~CVec_ChannelMonitorZ() { CVec_ChannelMonitorZ_free(self); }
1615         CVec_ChannelMonitorZ(CVec_ChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); }
1616         CVec_ChannelMonitorZ(LDKCVec_ChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelMonitorZ)); }
1617         operator LDKCVec_ChannelMonitorZ() { LDKCVec_ChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelMonitorZ)); return res; }
1618         LDKCVec_ChannelMonitorZ* operator &() { return &self; }
1619         LDKCVec_ChannelMonitorZ* operator ->() { return &self; }
1620         const LDKCVec_ChannelMonitorZ* operator &() const { return &self; }
1621         const LDKCVec_ChannelMonitorZ* operator ->() const { return &self; }
1622 };
1623 class C2Tuple_Txidu32Z {
1624 private:
1625         LDKC2Tuple_Txidu32Z self;
1626 public:
1627         C2Tuple_Txidu32Z(const C2Tuple_Txidu32Z&) = delete;
1628         ~C2Tuple_Txidu32Z() { C2Tuple_Txidu32Z_free(self); }
1629         C2Tuple_Txidu32Z(C2Tuple_Txidu32Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_Txidu32Z)); }
1630         C2Tuple_Txidu32Z(LDKC2Tuple_Txidu32Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_Txidu32Z)); }
1631         operator LDKC2Tuple_Txidu32Z() { LDKC2Tuple_Txidu32Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_Txidu32Z)); return res; }
1632         LDKC2Tuple_Txidu32Z* operator &() { return &self; }
1633         LDKC2Tuple_Txidu32Z* operator ->() { return &self; }
1634         const LDKC2Tuple_Txidu32Z* operator &() const { return &self; }
1635         const LDKC2Tuple_Txidu32Z* operator ->() const { return &self; }
1636 };
1637 class CVec_ChannelDetailsZ {
1638 private:
1639         LDKCVec_ChannelDetailsZ self;
1640 public:
1641         CVec_ChannelDetailsZ(const CVec_ChannelDetailsZ&) = delete;
1642         ~CVec_ChannelDetailsZ() { CVec_ChannelDetailsZ_free(self); }
1643         CVec_ChannelDetailsZ(CVec_ChannelDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelDetailsZ)); }
1644         CVec_ChannelDetailsZ(LDKCVec_ChannelDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelDetailsZ)); }
1645         operator LDKCVec_ChannelDetailsZ() { LDKCVec_ChannelDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelDetailsZ)); return res; }
1646         LDKCVec_ChannelDetailsZ* operator &() { return &self; }
1647         LDKCVec_ChannelDetailsZ* operator ->() { return &self; }
1648         const LDKCVec_ChannelDetailsZ* operator &() const { return &self; }
1649         const LDKCVec_ChannelDetailsZ* operator ->() const { return &self; }
1650 };
1651 class C2Tuple_u64u64Z {
1652 private:
1653         LDKC2Tuple_u64u64Z self;
1654 public:
1655         C2Tuple_u64u64Z(const C2Tuple_u64u64Z&) = delete;
1656         ~C2Tuple_u64u64Z() { C2Tuple_u64u64Z_free(self); }
1657         C2Tuple_u64u64Z(C2Tuple_u64u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64u64Z)); }
1658         C2Tuple_u64u64Z(LDKC2Tuple_u64u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64u64Z)); }
1659         operator LDKC2Tuple_u64u64Z() { LDKC2Tuple_u64u64Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64u64Z)); return res; }
1660         LDKC2Tuple_u64u64Z* operator &() { return &self; }
1661         LDKC2Tuple_u64u64Z* operator ->() { return &self; }
1662         const LDKC2Tuple_u64u64Z* operator &() const { return &self; }
1663         const LDKC2Tuple_u64u64Z* operator ->() const { return &self; }
1664 };
1665 class CResult_NonePaymentSendFailureZ {
1666 private:
1667         LDKCResult_NonePaymentSendFailureZ self;
1668 public:
1669         CResult_NonePaymentSendFailureZ(const CResult_NonePaymentSendFailureZ&) = delete;
1670         ~CResult_NonePaymentSendFailureZ() { CResult_NonePaymentSendFailureZ_free(self); }
1671         CResult_NonePaymentSendFailureZ(CResult_NonePaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); }
1672         CResult_NonePaymentSendFailureZ(LDKCResult_NonePaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); }
1673         operator LDKCResult_NonePaymentSendFailureZ() { LDKCResult_NonePaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); return res; }
1674         LDKCResult_NonePaymentSendFailureZ* operator &() { return &self; }
1675         LDKCResult_NonePaymentSendFailureZ* operator ->() { return &self; }
1676         const LDKCResult_NonePaymentSendFailureZ* operator &() const { return &self; }
1677         const LDKCResult_NonePaymentSendFailureZ* operator ->() const { return &self; }
1678 };
1679 class CResult_NoneChannelMonitorUpdateErrZ {
1680 private:
1681         LDKCResult_NoneChannelMonitorUpdateErrZ self;
1682 public:
1683         CResult_NoneChannelMonitorUpdateErrZ(const CResult_NoneChannelMonitorUpdateErrZ&) = delete;
1684         ~CResult_NoneChannelMonitorUpdateErrZ() { CResult_NoneChannelMonitorUpdateErrZ_free(self); }
1685         CResult_NoneChannelMonitorUpdateErrZ(CResult_NoneChannelMonitorUpdateErrZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneChannelMonitorUpdateErrZ)); }
1686         CResult_NoneChannelMonitorUpdateErrZ(LDKCResult_NoneChannelMonitorUpdateErrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ)); }
1687         operator LDKCResult_NoneChannelMonitorUpdateErrZ() { LDKCResult_NoneChannelMonitorUpdateErrZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ)); return res; }
1688         LDKCResult_NoneChannelMonitorUpdateErrZ* operator &() { return &self; }
1689         LDKCResult_NoneChannelMonitorUpdateErrZ* operator ->() { return &self; }
1690         const LDKCResult_NoneChannelMonitorUpdateErrZ* operator &() const { return &self; }
1691         const LDKCResult_NoneChannelMonitorUpdateErrZ* operator ->() const { return &self; }
1692 };
1693 class CVec_MonitorEventZ {
1694 private:
1695         LDKCVec_MonitorEventZ self;
1696 public:
1697         CVec_MonitorEventZ(const CVec_MonitorEventZ&) = delete;
1698         ~CVec_MonitorEventZ() { CVec_MonitorEventZ_free(self); }
1699         CVec_MonitorEventZ(CVec_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorEventZ)); }
1700         CVec_MonitorEventZ(LDKCVec_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorEventZ)); }
1701         operator LDKCVec_MonitorEventZ() { LDKCVec_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorEventZ)); return res; }
1702         LDKCVec_MonitorEventZ* operator &() { return &self; }
1703         LDKCVec_MonitorEventZ* operator ->() { return &self; }
1704         const LDKCVec_MonitorEventZ* operator &() const { return &self; }
1705         const LDKCVec_MonitorEventZ* operator ->() const { return &self; }
1706 };
1707 class CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
1708 private:
1709         LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ self;
1710 public:
1711         CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(const CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&) = delete;
1712         ~CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() { CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); }
1713         CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
1714         CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
1715         operator LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() { LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return res; }
1716         LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() { return &self; }
1717         LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() { return &self; }
1718         const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() const { return &self; }
1719         const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() const { return &self; }
1720 };
1721 class C2Tuple_HTLCOutputInCommitmentSignatureZ {
1722 private:
1723         LDKC2Tuple_HTLCOutputInCommitmentSignatureZ self;
1724 public:
1725         C2Tuple_HTLCOutputInCommitmentSignatureZ(const C2Tuple_HTLCOutputInCommitmentSignatureZ&) = delete;
1726         ~C2Tuple_HTLCOutputInCommitmentSignatureZ() { C2Tuple_HTLCOutputInCommitmentSignatureZ_free(self); }
1727         C2Tuple_HTLCOutputInCommitmentSignatureZ(C2Tuple_HTLCOutputInCommitmentSignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_HTLCOutputInCommitmentSignatureZ)); }
1728         C2Tuple_HTLCOutputInCommitmentSignatureZ(LDKC2Tuple_HTLCOutputInCommitmentSignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_HTLCOutputInCommitmentSignatureZ)); }
1729         operator LDKC2Tuple_HTLCOutputInCommitmentSignatureZ() { LDKC2Tuple_HTLCOutputInCommitmentSignatureZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_HTLCOutputInCommitmentSignatureZ)); return res; }
1730         LDKC2Tuple_HTLCOutputInCommitmentSignatureZ* operator &() { return &self; }
1731         LDKC2Tuple_HTLCOutputInCommitmentSignatureZ* operator ->() { return &self; }
1732         const LDKC2Tuple_HTLCOutputInCommitmentSignatureZ* operator &() const { return &self; }
1733         const LDKC2Tuple_HTLCOutputInCommitmentSignatureZ* operator ->() const { return &self; }
1734 };
1735 class CResult_SecretKeySecpErrorZ {
1736 private:
1737         LDKCResult_SecretKeySecpErrorZ self;
1738 public:
1739         CResult_SecretKeySecpErrorZ(const CResult_SecretKeySecpErrorZ&) = delete;
1740         ~CResult_SecretKeySecpErrorZ() { CResult_SecretKeySecpErrorZ_free(self); }
1741         CResult_SecretKeySecpErrorZ(CResult_SecretKeySecpErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SecretKeySecpErrorZ)); }
1742         CResult_SecretKeySecpErrorZ(LDKCResult_SecretKeySecpErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SecretKeySecpErrorZ)); }
1743         operator LDKCResult_SecretKeySecpErrorZ() { LDKCResult_SecretKeySecpErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SecretKeySecpErrorZ)); return res; }
1744         LDKCResult_SecretKeySecpErrorZ* operator &() { return &self; }
1745         LDKCResult_SecretKeySecpErrorZ* operator ->() { return &self; }
1746         const LDKCResult_SecretKeySecpErrorZ* operator &() const { return &self; }
1747         const LDKCResult_SecretKeySecpErrorZ* operator ->() const { return &self; }
1748 };
1749 class CVec_RouteHintZ {
1750 private:
1751         LDKCVec_RouteHintZ self;
1752 public:
1753         CVec_RouteHintZ(const CVec_RouteHintZ&) = delete;
1754         ~CVec_RouteHintZ() { CVec_RouteHintZ_free(self); }
1755         CVec_RouteHintZ(CVec_RouteHintZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintZ)); }
1756         CVec_RouteHintZ(LDKCVec_RouteHintZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintZ)); }
1757         operator LDKCVec_RouteHintZ() { LDKCVec_RouteHintZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintZ)); return res; }
1758         LDKCVec_RouteHintZ* operator &() { return &self; }
1759         LDKCVec_RouteHintZ* operator ->() { return &self; }
1760         const LDKCVec_RouteHintZ* operator &() const { return &self; }
1761         const LDKCVec_RouteHintZ* operator ->() const { return &self; }
1762 };
1763 class CVec_UpdateFailMalformedHTLCZ {
1764 private:
1765         LDKCVec_UpdateFailMalformedHTLCZ self;
1766 public:
1767         CVec_UpdateFailMalformedHTLCZ(const CVec_UpdateFailMalformedHTLCZ&) = delete;
1768         ~CVec_UpdateFailMalformedHTLCZ() { CVec_UpdateFailMalformedHTLCZ_free(self); }
1769         CVec_UpdateFailMalformedHTLCZ(CVec_UpdateFailMalformedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); }
1770         CVec_UpdateFailMalformedHTLCZ(LDKCVec_UpdateFailMalformedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); }
1771         operator LDKCVec_UpdateFailMalformedHTLCZ() { LDKCVec_UpdateFailMalformedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); return res; }
1772         LDKCVec_UpdateFailMalformedHTLCZ* operator &() { return &self; }
1773         LDKCVec_UpdateFailMalformedHTLCZ* operator ->() { return &self; }
1774         const LDKCVec_UpdateFailMalformedHTLCZ* operator &() const { return &self; }
1775         const LDKCVec_UpdateFailMalformedHTLCZ* operator ->() const { return &self; }
1776 };
1777 class CVec_RouteHopZ {
1778 private:
1779         LDKCVec_RouteHopZ self;
1780 public:
1781         CVec_RouteHopZ(const CVec_RouteHopZ&) = delete;
1782         ~CVec_RouteHopZ() { CVec_RouteHopZ_free(self); }
1783         CVec_RouteHopZ(CVec_RouteHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHopZ)); }
1784         CVec_RouteHopZ(LDKCVec_RouteHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHopZ)); }
1785         operator LDKCVec_RouteHopZ() { LDKCVec_RouteHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHopZ)); return res; }
1786         LDKCVec_RouteHopZ* operator &() { return &self; }
1787         LDKCVec_RouteHopZ* operator ->() { return &self; }
1788         const LDKCVec_RouteHopZ* operator &() const { return &self; }
1789         const LDKCVec_RouteHopZ* operator ->() const { return &self; }
1790 };
1791 class CVec_SpendableOutputDescriptorZ {
1792 private:
1793         LDKCVec_SpendableOutputDescriptorZ self;
1794 public:
1795         CVec_SpendableOutputDescriptorZ(const CVec_SpendableOutputDescriptorZ&) = delete;
1796         ~CVec_SpendableOutputDescriptorZ() { CVec_SpendableOutputDescriptorZ_free(self); }
1797         CVec_SpendableOutputDescriptorZ(CVec_SpendableOutputDescriptorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SpendableOutputDescriptorZ)); }
1798         CVec_SpendableOutputDescriptorZ(LDKCVec_SpendableOutputDescriptorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SpendableOutputDescriptorZ)); }
1799         operator LDKCVec_SpendableOutputDescriptorZ() { LDKCVec_SpendableOutputDescriptorZ res = self; memset(&self, 0, sizeof(LDKCVec_SpendableOutputDescriptorZ)); return res; }
1800         LDKCVec_SpendableOutputDescriptorZ* operator &() { return &self; }
1801         LDKCVec_SpendableOutputDescriptorZ* operator ->() { return &self; }
1802         const LDKCVec_SpendableOutputDescriptorZ* operator &() const { return &self; }
1803         const LDKCVec_SpendableOutputDescriptorZ* operator ->() const { return &self; }
1804 };
1805 class CResult_boolLightningErrorZ {
1806 private:
1807         LDKCResult_boolLightningErrorZ self;
1808 public:
1809         CResult_boolLightningErrorZ(const CResult_boolLightningErrorZ&) = delete;
1810         ~CResult_boolLightningErrorZ() { CResult_boolLightningErrorZ_free(self); }
1811         CResult_boolLightningErrorZ(CResult_boolLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); }
1812         CResult_boolLightningErrorZ(LDKCResult_boolLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolLightningErrorZ)); }
1813         operator LDKCResult_boolLightningErrorZ() { LDKCResult_boolLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolLightningErrorZ)); return res; }
1814         LDKCResult_boolLightningErrorZ* operator &() { return &self; }
1815         LDKCResult_boolLightningErrorZ* operator ->() { return &self; }
1816         const LDKCResult_boolLightningErrorZ* operator &() const { return &self; }
1817         const LDKCResult_boolLightningErrorZ* operator ->() const { return &self; }
1818 };
1819 class CResult_NoneAPIErrorZ {
1820 private:
1821         LDKCResult_NoneAPIErrorZ self;
1822 public:
1823         CResult_NoneAPIErrorZ(const CResult_NoneAPIErrorZ&) = delete;
1824         ~CResult_NoneAPIErrorZ() { CResult_NoneAPIErrorZ_free(self); }
1825         CResult_NoneAPIErrorZ(CResult_NoneAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); }
1826         CResult_NoneAPIErrorZ(LDKCResult_NoneAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); }
1827         operator LDKCResult_NoneAPIErrorZ() { LDKCResult_NoneAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); return res; }
1828         LDKCResult_NoneAPIErrorZ* operator &() { return &self; }
1829         LDKCResult_NoneAPIErrorZ* operator ->() { return &self; }
1830         const LDKCResult_NoneAPIErrorZ* operator &() const { return &self; }
1831         const LDKCResult_NoneAPIErrorZ* operator ->() const { return &self; }
1832 };
1833 class CVec_NetAddressZ {
1834 private:
1835         LDKCVec_NetAddressZ self;
1836 public:
1837         CVec_NetAddressZ(const CVec_NetAddressZ&) = delete;
1838         ~CVec_NetAddressZ() { CVec_NetAddressZ_free(self); }
1839         CVec_NetAddressZ(CVec_NetAddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_NetAddressZ)); }
1840         CVec_NetAddressZ(LDKCVec_NetAddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_NetAddressZ)); }
1841         operator LDKCVec_NetAddressZ() { LDKCVec_NetAddressZ res = self; memset(&self, 0, sizeof(LDKCVec_NetAddressZ)); return res; }
1842         LDKCVec_NetAddressZ* operator &() { return &self; }
1843         LDKCVec_NetAddressZ* operator ->() { return &self; }
1844         const LDKCVec_NetAddressZ* operator &() const { return &self; }
1845         const LDKCVec_NetAddressZ* operator ->() const { return &self; }
1846 };
1847 class CResult_CVec_u8ZPeerHandleErrorZ {
1848 private:
1849         LDKCResult_CVec_u8ZPeerHandleErrorZ self;
1850 public:
1851         CResult_CVec_u8ZPeerHandleErrorZ(const CResult_CVec_u8ZPeerHandleErrorZ&) = delete;
1852         ~CResult_CVec_u8ZPeerHandleErrorZ() { CResult_CVec_u8ZPeerHandleErrorZ_free(self); }
1853         CResult_CVec_u8ZPeerHandleErrorZ(CResult_CVec_u8ZPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); }
1854         CResult_CVec_u8ZPeerHandleErrorZ(LDKCResult_CVec_u8ZPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); }
1855         operator LDKCResult_CVec_u8ZPeerHandleErrorZ() { LDKCResult_CVec_u8ZPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); return res; }
1856         LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() { return &self; }
1857         LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() { return &self; }
1858         const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() const { return &self; }
1859         const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() const { return &self; }
1860 };
1861 class CVec_usizeZ {
1862 private:
1863         LDKCVec_usizeZ self;
1864 public:
1865         CVec_usizeZ(const CVec_usizeZ&) = delete;
1866         ~CVec_usizeZ() { CVec_usizeZ_free(self); }
1867         CVec_usizeZ(CVec_usizeZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_usizeZ)); }
1868         CVec_usizeZ(LDKCVec_usizeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_usizeZ)); }
1869         operator LDKCVec_usizeZ() { LDKCVec_usizeZ res = self; memset(&self, 0, sizeof(LDKCVec_usizeZ)); return res; }
1870         LDKCVec_usizeZ* operator &() { return &self; }
1871         LDKCVec_usizeZ* operator ->() { return &self; }
1872         const LDKCVec_usizeZ* operator &() const { return &self; }
1873         const LDKCVec_usizeZ* operator ->() const { return &self; }
1874 };
1875 class CResult_NonePeerHandleErrorZ {
1876 private:
1877         LDKCResult_NonePeerHandleErrorZ self;
1878 public:
1879         CResult_NonePeerHandleErrorZ(const CResult_NonePeerHandleErrorZ&) = delete;
1880         ~CResult_NonePeerHandleErrorZ() { CResult_NonePeerHandleErrorZ_free(self); }
1881         CResult_NonePeerHandleErrorZ(CResult_NonePeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); }
1882         CResult_NonePeerHandleErrorZ(LDKCResult_NonePeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); }
1883         operator LDKCResult_NonePeerHandleErrorZ() { LDKCResult_NonePeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); return res; }
1884         LDKCResult_NonePeerHandleErrorZ* operator &() { return &self; }
1885         LDKCResult_NonePeerHandleErrorZ* operator ->() { return &self; }
1886         const LDKCResult_NonePeerHandleErrorZ* operator &() const { return &self; }
1887         const LDKCResult_NonePeerHandleErrorZ* operator ->() const { return &self; }
1888 };
1889 class CResult_TxCreationKeysSecpErrorZ {
1890 private:
1891         LDKCResult_TxCreationKeysSecpErrorZ self;
1892 public:
1893         CResult_TxCreationKeysSecpErrorZ(const CResult_TxCreationKeysSecpErrorZ&) = delete;
1894         ~CResult_TxCreationKeysSecpErrorZ() { CResult_TxCreationKeysSecpErrorZ_free(self); }
1895         CResult_TxCreationKeysSecpErrorZ(CResult_TxCreationKeysSecpErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysSecpErrorZ)); }
1896         CResult_TxCreationKeysSecpErrorZ(LDKCResult_TxCreationKeysSecpErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysSecpErrorZ)); }
1897         operator LDKCResult_TxCreationKeysSecpErrorZ() { LDKCResult_TxCreationKeysSecpErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysSecpErrorZ)); return res; }
1898         LDKCResult_TxCreationKeysSecpErrorZ* operator &() { return &self; }
1899         LDKCResult_TxCreationKeysSecpErrorZ* operator ->() { return &self; }
1900         const LDKCResult_TxCreationKeysSecpErrorZ* operator &() const { return &self; }
1901         const LDKCResult_TxCreationKeysSecpErrorZ* operator ->() const { return &self; }
1902 };
1903 class CVec_PublicKeyZ {
1904 private:
1905         LDKCVec_PublicKeyZ self;
1906 public:
1907         CVec_PublicKeyZ(const CVec_PublicKeyZ&) = delete;
1908         ~CVec_PublicKeyZ() { CVec_PublicKeyZ_free(self); }
1909         CVec_PublicKeyZ(CVec_PublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PublicKeyZ)); }
1910         CVec_PublicKeyZ(LDKCVec_PublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PublicKeyZ)); }
1911         operator LDKCVec_PublicKeyZ() { LDKCVec_PublicKeyZ res = self; memset(&self, 0, sizeof(LDKCVec_PublicKeyZ)); return res; }
1912         LDKCVec_PublicKeyZ* operator &() { return &self; }
1913         LDKCVec_PublicKeyZ* operator ->() { return &self; }
1914         const LDKCVec_PublicKeyZ* operator &() const { return &self; }
1915         const LDKCVec_PublicKeyZ* operator ->() const { return &self; }
1916 };
1917 class CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
1918 private:
1919         LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ self;
1920 public:
1921         CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(const CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&) = delete;
1922         ~CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ() { CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(self); }
1923         CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); }
1924         CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); }
1925         operator LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ() { LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); return res; }
1926         LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator &() { return &self; }
1927         LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator ->() { return &self; }
1928         const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator &() const { return &self; }
1929         const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator ->() const { return &self; }
1930 };
1931 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
1932 private:
1933         LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ self;
1934 public:
1935         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(const C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&) = delete;
1936         ~C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); }
1937         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
1938         C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
1939         operator LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() { LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return res; }
1940         LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() { return &self; }
1941         LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() { return &self; }
1942         const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() const { return &self; }
1943         const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() const { return &self; }
1944 };
1945 class CVec_MessageSendEventZ {
1946 private:
1947         LDKCVec_MessageSendEventZ self;
1948 public:
1949         CVec_MessageSendEventZ(const CVec_MessageSendEventZ&) = delete;
1950         ~CVec_MessageSendEventZ() { CVec_MessageSendEventZ_free(self); }
1951         CVec_MessageSendEventZ(CVec_MessageSendEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MessageSendEventZ)); }
1952         CVec_MessageSendEventZ(LDKCVec_MessageSendEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MessageSendEventZ)); }
1953         operator LDKCVec_MessageSendEventZ() { LDKCVec_MessageSendEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MessageSendEventZ)); return res; }
1954         LDKCVec_MessageSendEventZ* operator &() { return &self; }
1955         LDKCVec_MessageSendEventZ* operator ->() { return &self; }
1956         const LDKCVec_MessageSendEventZ* operator &() const { return &self; }
1957         const LDKCVec_MessageSendEventZ* operator ->() const { return &self; }
1958 };
1959 class CVec_UpdateFailHTLCZ {
1960 private:
1961         LDKCVec_UpdateFailHTLCZ self;
1962 public:
1963         CVec_UpdateFailHTLCZ(const CVec_UpdateFailHTLCZ&) = delete;
1964         ~CVec_UpdateFailHTLCZ() { CVec_UpdateFailHTLCZ_free(self); }
1965         CVec_UpdateFailHTLCZ(CVec_UpdateFailHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); }
1966         CVec_UpdateFailHTLCZ(LDKCVec_UpdateFailHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); }
1967         operator LDKCVec_UpdateFailHTLCZ() { LDKCVec_UpdateFailHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); return res; }
1968         LDKCVec_UpdateFailHTLCZ* operator &() { return &self; }
1969         LDKCVec_UpdateFailHTLCZ* operator ->() { return &self; }
1970         const LDKCVec_UpdateFailHTLCZ* operator &() const { return &self; }
1971         const LDKCVec_UpdateFailHTLCZ* operator ->() const { return &self; }
1972 };
1973 class CVec_UpdateFulfillHTLCZ {
1974 private:
1975         LDKCVec_UpdateFulfillHTLCZ self;
1976 public:
1977         CVec_UpdateFulfillHTLCZ(const CVec_UpdateFulfillHTLCZ&) = delete;
1978         ~CVec_UpdateFulfillHTLCZ() { CVec_UpdateFulfillHTLCZ_free(self); }
1979         CVec_UpdateFulfillHTLCZ(CVec_UpdateFulfillHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); }
1980         CVec_UpdateFulfillHTLCZ(LDKCVec_UpdateFulfillHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); }
1981         operator LDKCVec_UpdateFulfillHTLCZ() { LDKCVec_UpdateFulfillHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); return res; }
1982         LDKCVec_UpdateFulfillHTLCZ* operator &() { return &self; }
1983         LDKCVec_UpdateFulfillHTLCZ* operator ->() { return &self; }
1984         const LDKCVec_UpdateFulfillHTLCZ* operator &() const { return &self; }
1985         const LDKCVec_UpdateFulfillHTLCZ* operator ->() const { return &self; }
1986 };
1987 class CVec_UpdateAddHTLCZ {
1988 private:
1989         LDKCVec_UpdateAddHTLCZ self;
1990 public:
1991         CVec_UpdateAddHTLCZ(const CVec_UpdateAddHTLCZ&) = delete;
1992         ~CVec_UpdateAddHTLCZ() { CVec_UpdateAddHTLCZ_free(self); }
1993         CVec_UpdateAddHTLCZ(CVec_UpdateAddHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); }
1994         CVec_UpdateAddHTLCZ(LDKCVec_UpdateAddHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); }
1995         operator LDKCVec_UpdateAddHTLCZ() { LDKCVec_UpdateAddHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); return res; }
1996         LDKCVec_UpdateAddHTLCZ* operator &() { return &self; }
1997         LDKCVec_UpdateAddHTLCZ* operator ->() { return &self; }
1998         const LDKCVec_UpdateAddHTLCZ* operator &() const { return &self; }
1999         const LDKCVec_UpdateAddHTLCZ* operator ->() const { return &self; }
2000 };
2001 class CVec_EventZ {
2002 private:
2003         LDKCVec_EventZ self;
2004 public:
2005         CVec_EventZ(const CVec_EventZ&) = delete;
2006         ~CVec_EventZ() { CVec_EventZ_free(self); }
2007         CVec_EventZ(CVec_EventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_EventZ)); }
2008         CVec_EventZ(LDKCVec_EventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_EventZ)); }
2009         operator LDKCVec_EventZ() { LDKCVec_EventZ res = self; memset(&self, 0, sizeof(LDKCVec_EventZ)); return res; }
2010         LDKCVec_EventZ* operator &() { return &self; }
2011         LDKCVec_EventZ* operator ->() { return &self; }
2012         const LDKCVec_EventZ* operator &() const { return &self; }
2013         const LDKCVec_EventZ* operator ->() const { return &self; }
2014 };
2015 class CVec_SignatureZ {
2016 private:
2017         LDKCVec_SignatureZ self;
2018 public:
2019         CVec_SignatureZ(const CVec_SignatureZ&) = delete;
2020         ~CVec_SignatureZ() { CVec_SignatureZ_free(self); }
2021         CVec_SignatureZ(CVec_SignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SignatureZ)); }
2022         CVec_SignatureZ(LDKCVec_SignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SignatureZ)); }
2023         operator LDKCVec_SignatureZ() { LDKCVec_SignatureZ res = self; memset(&self, 0, sizeof(LDKCVec_SignatureZ)); return res; }
2024         LDKCVec_SignatureZ* operator &() { return &self; }
2025         LDKCVec_SignatureZ* operator ->() { return &self; }
2026         const LDKCVec_SignatureZ* operator &() const { return &self; }
2027         const LDKCVec_SignatureZ* operator ->() const { return &self; }
2028 };
2029 class CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ {
2030 private:
2031         LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ self;
2032 public:
2033         CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ(const CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ&) = delete;
2034         ~CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ() { CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ_free(self); }
2035         CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ(CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ)); }
2036         CVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ(LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ)); }
2037         operator LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ() { LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ)); return res; }
2038         LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ* operator &() { return &self; }
2039         LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ* operator ->() { return &self; }
2040         const LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ* operator &() const { return &self; }
2041         const LDKCVec_C2Tuple_HTLCOutputInCommitmentSignatureZZ* operator ->() const { return &self; }
2042 };
2043 class CResult_SignatureNoneZ {
2044 private:
2045         LDKCResult_SignatureNoneZ self;
2046 public:
2047         CResult_SignatureNoneZ(const CResult_SignatureNoneZ&) = delete;
2048         ~CResult_SignatureNoneZ() { CResult_SignatureNoneZ_free(self); }
2049         CResult_SignatureNoneZ(CResult_SignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignatureNoneZ)); }
2050         CResult_SignatureNoneZ(LDKCResult_SignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignatureNoneZ)); }
2051         operator LDKCResult_SignatureNoneZ() { LDKCResult_SignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SignatureNoneZ)); return res; }
2052         LDKCResult_SignatureNoneZ* operator &() { return &self; }
2053         LDKCResult_SignatureNoneZ* operator ->() { return &self; }
2054         const LDKCResult_SignatureNoneZ* operator &() const { return &self; }
2055         const LDKCResult_SignatureNoneZ* operator ->() const { return &self; }
2056 };
2057 }