Auto-generated bindings updates

[rust-lightning] / lightning-c-bindings / include / lightningpp.hpp

diff --git a/lightning-c-bindings/include/lightningpp.hpp b/lightning-c-bindings/include/lightningpp.hpp
index 81370fd12034e8a86a74719d5cd298dcc2bfba3b..3151b9c0cb6c013cd960d6ec6b459037b735668c 100644 (file)
--- a/lightning-c-bindings/include/lightningpp.hpp
+++ b/lightning-c-bindings/include/lightningpp.hpp
@@ -165,6 +165,36 @@ public:
        const LDKTrustedCommitmentTransaction* operator &() const { return &self; }
        const LDKTrustedCommitmentTransaction* operator ->() const { return &self; }
 };
+class IgnoringMessageHandler {
+private:
+       LDKIgnoringMessageHandler self;
+public:
+       IgnoringMessageHandler(const IgnoringMessageHandler&) = delete;
+       IgnoringMessageHandler(IgnoringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(IgnoringMessageHandler)); }
+       IgnoringMessageHandler(LDKIgnoringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKIgnoringMessageHandler)); }
+       operator LDKIgnoringMessageHandler() && { LDKIgnoringMessageHandler res = self; memset(&self, 0, sizeof(LDKIgnoringMessageHandler)); return res; }
+       ~IgnoringMessageHandler() { IgnoringMessageHandler_free(self); }
+       IgnoringMessageHandler& operator=(IgnoringMessageHandler&& o) { IgnoringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(IgnoringMessageHandler)); return *this; }
+       LDKIgnoringMessageHandler* operator &() { return &self; }
+       LDKIgnoringMessageHandler* operator ->() { return &self; }
+       const LDKIgnoringMessageHandler* operator &() const { return &self; }
+       const LDKIgnoringMessageHandler* operator ->() const { return &self; }
+};
+class ErroringMessageHandler {
+private:
+       LDKErroringMessageHandler self;
+public:
+       ErroringMessageHandler(const ErroringMessageHandler&) = delete;
+       ErroringMessageHandler(ErroringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ErroringMessageHandler)); }
+       ErroringMessageHandler(LDKErroringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroringMessageHandler)); }
+       operator LDKErroringMessageHandler() && { LDKErroringMessageHandler res = self; memset(&self, 0, sizeof(LDKErroringMessageHandler)); return res; }
+       ~ErroringMessageHandler() { ErroringMessageHandler_free(self); }
+       ErroringMessageHandler& operator=(ErroringMessageHandler&& o) { ErroringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ErroringMessageHandler)); return *this; }
+       LDKErroringMessageHandler* operator &() { return &self; }
+       LDKErroringMessageHandler* operator ->() { return &self; }
+       const LDKErroringMessageHandler* operator &() const { return &self; }
+       const LDKErroringMessageHandler* operator ->() const { return &self; }
+};
 class MessageHandler {
 private:
        LDKMessageHandler self;
@@ -702,6 +732,21 @@ public:
        const LDKAccess* operator &() const { return &self; }
        const LDKAccess* operator ->() const { return &self; }
 };
+class Listen {
+private:
+       LDKListen self;
+public:
+       Listen(const Listen&) = delete;
+       Listen(Listen&& o) : self(o.self) { memset(&o, 0, sizeof(Listen)); }
+       Listen(LDKListen&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKListen)); }
+       operator LDKListen() && { LDKListen res = self; memset(&self, 0, sizeof(LDKListen)); return res; }
+       ~Listen() { Listen_free(self); }
+       Listen& operator=(Listen&& o) { Listen_free(self); self = o.self; memset(&o, 0, sizeof(Listen)); return *this; }
+       LDKListen* operator &() { return &self; }
+       LDKListen* operator ->() { return &self; }
+       const LDKListen* operator &() const { return &self; }
+       const LDKListen* operator ->() const { return &self; }
+};
 class Watch {
 private:
        LDKWatch self;
@@ -791,6 +836,21 @@ public:
        const LDKChannelManager* operator &() const { return &self; }
        const LDKChannelManager* operator ->() const { return &self; }
 };
+class ChainParameters {
+private:
+       LDKChainParameters self;
+public:
+       ChainParameters(const ChainParameters&) = delete;
+       ChainParameters(ChainParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChainParameters)); }
+       ChainParameters(LDKChainParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainParameters)); }
+       operator LDKChainParameters() && { LDKChainParameters res = self; memset(&self, 0, sizeof(LDKChainParameters)); return res; }
+       ~ChainParameters() { ChainParameters_free(self); }
+       ChainParameters& operator=(ChainParameters&& o) { ChainParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChainParameters)); return *this; }
+       LDKChainParameters* operator &() { return &self; }
+       LDKChainParameters* operator ->() { return &self; }
+       const LDKChainParameters* operator &() const { return &self; }
+       const LDKChainParameters* operator ->() const { return &self; }
+};
 class ChannelDetails {
 private:
        LDKChannelDetails self;
@@ -881,20 +941,20 @@ public:
        const LDKSpendableOutputDescriptor* operator &() const { return &self; }
        const LDKSpendableOutputDescriptor* operator ->() const { return &self; }
 };
-class ChannelKeys {
+class Sign {
 private:
-       LDKChannelKeys self;
+       LDKSign self;
 public:
-       ChannelKeys(const ChannelKeys&) = delete;
-       ChannelKeys(ChannelKeys&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelKeys)); }
-       ChannelKeys(LDKChannelKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelKeys)); }
-       operator LDKChannelKeys() && { LDKChannelKeys res = self; memset(&self, 0, sizeof(LDKChannelKeys)); return res; }
-       ~ChannelKeys() { ChannelKeys_free(self); }
-       ChannelKeys& operator=(ChannelKeys&& o) { ChannelKeys_free(self); self = o.self; memset(&o, 0, sizeof(ChannelKeys)); return *this; }
-       LDKChannelKeys* operator &() { return &self; }
-       LDKChannelKeys* operator ->() { return &self; }
-       const LDKChannelKeys* operator &() const { return &self; }
-       const LDKChannelKeys* operator ->() const { return &self; }
+       Sign(const Sign&) = delete;
+       Sign(Sign&& o) : self(o.self) { memset(&o, 0, sizeof(Sign)); }
+       Sign(LDKSign&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSign)); }
+       operator LDKSign() && { LDKSign res = self; memset(&self, 0, sizeof(LDKSign)); return res; }
+       ~Sign() { Sign_free(self); }
+       Sign& operator=(Sign&& o) { Sign_free(self); self = o.self; memset(&o, 0, sizeof(Sign)); return *this; }
+       LDKSign* operator &() { return &self; }
+       LDKSign* operator ->() { return &self; }
+       const LDKSign* operator &() const { return &self; }
+       const LDKSign* operator ->() const { return &self; }
 };
 class KeysInterface {
 private:
@@ -911,20 +971,20 @@ public:
        const LDKKeysInterface* operator &() const { return &self; }
        const LDKKeysInterface* operator ->() const { return &self; }
 };
-class InMemoryChannelKeys {
+class InMemorySigner {
 private:
-       LDKInMemoryChannelKeys self;
+       LDKInMemorySigner self;
 public:
-       InMemoryChannelKeys(const InMemoryChannelKeys&) = delete;
-       InMemoryChannelKeys(InMemoryChannelKeys&& o) : self(o.self) { memset(&o, 0, sizeof(InMemoryChannelKeys)); }
-       InMemoryChannelKeys(LDKInMemoryChannelKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInMemoryChannelKeys)); }
-       operator LDKInMemoryChannelKeys() && { LDKInMemoryChannelKeys res = self; memset(&self, 0, sizeof(LDKInMemoryChannelKeys)); return res; }
-       ~InMemoryChannelKeys() { InMemoryChannelKeys_free(self); }
-       InMemoryChannelKeys& operator=(InMemoryChannelKeys&& o) { InMemoryChannelKeys_free(self); self = o.self; memset(&o, 0, sizeof(InMemoryChannelKeys)); return *this; }
-       LDKInMemoryChannelKeys* operator &() { return &self; }
-       LDKInMemoryChannelKeys* operator ->() { return &self; }
-       const LDKInMemoryChannelKeys* operator &() const { return &self; }
-       const LDKInMemoryChannelKeys* operator ->() const { return &self; }
+       InMemorySigner(const InMemorySigner&) = delete;
+       InMemorySigner(InMemorySigner&& o) : self(o.self) { memset(&o, 0, sizeof(InMemorySigner)); }
+       InMemorySigner(LDKInMemorySigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInMemorySigner)); }
+       operator LDKInMemorySigner() && { LDKInMemorySigner res = self; memset(&self, 0, sizeof(LDKInMemorySigner)); return res; }
+       ~InMemorySigner() { InMemorySigner_free(self); }
+       InMemorySigner& operator=(InMemorySigner&& o) { InMemorySigner_free(self); self = o.self; memset(&o, 0, sizeof(InMemorySigner)); return *this; }
+       LDKInMemorySigner* operator &() { return &self; }
+       LDKInMemorySigner* operator ->() { return &self; }
+       const LDKInMemorySigner* operator &() const { return &self; }
+       const LDKInMemorySigner* operator ->() const { return &self; }
 };
 class KeysManager {
 private:
@@ -2411,6 +2471,21 @@ public:
        const LDKCVec_ChannelDetailsZ* operator &() const { return &self; }
        const LDKCVec_ChannelDetailsZ* operator ->() const { return &self; }
 };
+class CResult_SignDecodeErrorZ {
+private:
+       LDKCResult_SignDecodeErrorZ self;
+public:
+       CResult_SignDecodeErrorZ(const CResult_SignDecodeErrorZ&) = delete;
+       CResult_SignDecodeErrorZ(CResult_SignDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignDecodeErrorZ)); }
+       CResult_SignDecodeErrorZ(LDKCResult_SignDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignDecodeErrorZ)); }
+       operator LDKCResult_SignDecodeErrorZ() && { LDKCResult_SignDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SignDecodeErrorZ)); return res; }
+       ~CResult_SignDecodeErrorZ() { CResult_SignDecodeErrorZ_free(self); }
+       CResult_SignDecodeErrorZ& operator=(CResult_SignDecodeErrorZ&& o) { CResult_SignDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SignDecodeErrorZ)); return *this; }
+       LDKCResult_SignDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_SignDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_SignDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_SignDecodeErrorZ* operator ->() const { return &self; }
+};
 class CVec_MessageSendEventZ {
 private:
        LDKCVec_MessageSendEventZ self;
@@ -2456,21 +2531,6 @@ public:
        const LDKC2Tuple_OutPointScriptZ* operator &() const { return &self; }
        const LDKC2Tuple_OutPointScriptZ* operator ->() const { return &self; }
 };
-class CResult_InMemoryChannelKeysDecodeErrorZ {
-private:
-       LDKCResult_InMemoryChannelKeysDecodeErrorZ self;
-public:
-       CResult_InMemoryChannelKeysDecodeErrorZ(const CResult_InMemoryChannelKeysDecodeErrorZ&) = delete;
-       CResult_InMemoryChannelKeysDecodeErrorZ(CResult_InMemoryChannelKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InMemoryChannelKeysDecodeErrorZ)); }
-       CResult_InMemoryChannelKeysDecodeErrorZ(LDKCResult_InMemoryChannelKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InMemoryChannelKeysDecodeErrorZ)); }
-       operator LDKCResult_InMemoryChannelKeysDecodeErrorZ() && { LDKCResult_InMemoryChannelKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InMemoryChannelKeysDecodeErrorZ)); return res; }
-       ~CResult_InMemoryChannelKeysDecodeErrorZ() { CResult_InMemoryChannelKeysDecodeErrorZ_free(self); }
-       CResult_InMemoryChannelKeysDecodeErrorZ& operator=(CResult_InMemoryChannelKeysDecodeErrorZ&& o) { CResult_InMemoryChannelKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InMemoryChannelKeysDecodeErrorZ)); return *this; }
-       LDKCResult_InMemoryChannelKeysDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_InMemoryChannelKeysDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_InMemoryChannelKeysDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_InMemoryChannelKeysDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_UpdateFailMalformedHTLCDecodeErrorZ {
 private:
        LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ self;
@@ -2726,21 +2786,6 @@ public:
        const LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() const { return &self; }
        const LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() const { return &self; }
 };
-class CResult_NonePeerHandleErrorZ {
-private:
-       LDKCResult_NonePeerHandleErrorZ self;
-public:
-       CResult_NonePeerHandleErrorZ(const CResult_NonePeerHandleErrorZ&) = delete;
-       CResult_NonePeerHandleErrorZ(CResult_NonePeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); }
-       CResult_NonePeerHandleErrorZ(LDKCResult_NonePeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); }
-       operator LDKCResult_NonePeerHandleErrorZ() && { LDKCResult_NonePeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); return res; }
-       ~CResult_NonePeerHandleErrorZ() { CResult_NonePeerHandleErrorZ_free(self); }
-       CResult_NonePeerHandleErrorZ& operator=(CResult_NonePeerHandleErrorZ&& o) { CResult_NonePeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); return *this; }
-       LDKCResult_NonePeerHandleErrorZ* operator &() { return &self; }
-       LDKCResult_NonePeerHandleErrorZ* operator ->() { return &self; }
-       const LDKCResult_NonePeerHandleErrorZ* operator &() const { return &self; }
-       const LDKCResult_NonePeerHandleErrorZ* operator ->() const { return &self; }
-};
 class CResult_NoneLightningErrorZ {
 private:
        LDKCResult_NoneLightningErrorZ self;
@@ -2756,6 +2801,21 @@ public:
        const LDKCResult_NoneLightningErrorZ* operator &() const { return &self; }
        const LDKCResult_NoneLightningErrorZ* operator ->() const { return &self; }
 };
+class CResult_NonePeerHandleErrorZ {
+private:
+       LDKCResult_NonePeerHandleErrorZ self;
+public:
+       CResult_NonePeerHandleErrorZ(const CResult_NonePeerHandleErrorZ&) = delete;
+       CResult_NonePeerHandleErrorZ(CResult_NonePeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); }
+       CResult_NonePeerHandleErrorZ(LDKCResult_NonePeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); }
+       operator LDKCResult_NonePeerHandleErrorZ() && { LDKCResult_NonePeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); return res; }
+       ~CResult_NonePeerHandleErrorZ() { CResult_NonePeerHandleErrorZ_free(self); }
+       CResult_NonePeerHandleErrorZ& operator=(CResult_NonePeerHandleErrorZ&& o) { CResult_NonePeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); return *this; }
+       LDKCResult_NonePeerHandleErrorZ* operator &() { return &self; }
+       LDKCResult_NonePeerHandleErrorZ* operator ->() { return &self; }
+       const LDKCResult_NonePeerHandleErrorZ* operator &() const { return &self; }
+       const LDKCResult_NonePeerHandleErrorZ* operator ->() const { return &self; }
+};
 class CResult_CVec_SignatureZNoneZ {
 private:
        LDKCResult_CVec_SignatureZNoneZ self;
@@ -3176,21 +3236,6 @@ public:
        const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_ChannelKeysDecodeErrorZ {
-private:
-       LDKCResult_ChannelKeysDecodeErrorZ self;
-public:
-       CResult_ChannelKeysDecodeErrorZ(const CResult_ChannelKeysDecodeErrorZ&) = delete;
-       CResult_ChannelKeysDecodeErrorZ(CResult_ChannelKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelKeysDecodeErrorZ)); }
-       CResult_ChannelKeysDecodeErrorZ(LDKCResult_ChannelKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelKeysDecodeErrorZ)); }
-       operator LDKCResult_ChannelKeysDecodeErrorZ() && { LDKCResult_ChannelKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelKeysDecodeErrorZ)); return res; }
-       ~CResult_ChannelKeysDecodeErrorZ() { CResult_ChannelKeysDecodeErrorZ_free(self); }
-       CResult_ChannelKeysDecodeErrorZ& operator=(CResult_ChannelKeysDecodeErrorZ&& o) { CResult_ChannelKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelKeysDecodeErrorZ)); return *this; }
-       LDKCResult_ChannelKeysDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_ChannelKeysDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_ChannelKeysDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_ChannelKeysDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_NodeFeaturesDecodeErrorZ {
 private:
        LDKCResult_NodeFeaturesDecodeErrorZ self;
@@ -3206,6 +3251,21 @@ public:
        const LDKCResult_NodeFeaturesDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_InMemorySignerDecodeErrorZ {
+private:
+       LDKCResult_InMemorySignerDecodeErrorZ self;
+public:
+       CResult_InMemorySignerDecodeErrorZ(const CResult_InMemorySignerDecodeErrorZ&) = delete;
+       CResult_InMemorySignerDecodeErrorZ(CResult_InMemorySignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); }
+       CResult_InMemorySignerDecodeErrorZ(LDKCResult_InMemorySignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); }
+       operator LDKCResult_InMemorySignerDecodeErrorZ() && { LDKCResult_InMemorySignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); return res; }
+       ~CResult_InMemorySignerDecodeErrorZ() { CResult_InMemorySignerDecodeErrorZ_free(self); }
+       CResult_InMemorySignerDecodeErrorZ& operator=(CResult_InMemorySignerDecodeErrorZ&& o) { CResult_InMemorySignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); return *this; }
+       LDKCResult_InMemorySignerDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_InMemorySignerDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_InMemorySignerDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_InMemorySignerDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_ReplyShortChannelIdsEndDecodeErrorZ {
 private:
        LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ self;