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