@chilkat/react-native 11.6.1

package/nitrogen/generated/android/ChilkatRNOnLoad.cpp

@@ -0,0 +1,1029 @@
+///
+/// ChilkatRNOnLoad.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#ifndef BUILDING_CHILKATRN_WITH_GENERATED_CMAKE_PROJECT
+#error ChilkatRNOnLoad.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
+#endif
+
+#include "ChilkatRNOnLoad.hpp"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+#include "HybridAi.hpp"
+#include "HybridAsn.hpp"
+#include "HybridAuthAws.hpp"
+#include "HybridAuthAzureSAS.hpp"
+#include "HybridAuthAzureStorage.hpp"
+#include "HybridAuthGoogle.hpp"
+#include "HybridBinData.hpp"
+#include "HybridBz2.hpp"
+#include "HybridCache.hpp"
+#include "HybridCert.hpp"
+#include "HybridCertChain.hpp"
+#include "HybridCertStore.hpp"
+#include "HybridCharset.hpp"
+#include "HybridCkDateTime.hpp"
+#include "HybridCodeSign.hpp"
+#include "HybridCompression.hpp"
+#include "HybridCrypt2.hpp"
+#include "HybridCsr.hpp"
+#include "HybridCsv.hpp"
+#include "HybridDh.hpp"
+#include "HybridDirTree.hpp"
+#include "HybridDkim.hpp"
+#include "HybridDns.hpp"
+#include "HybridDsa.hpp"
+#include "HybridDtObj.hpp"
+#include "HybridEcc.hpp"
+#include "HybridEdDSA.hpp"
+#include "HybridEmail.hpp"
+#include "HybridEmailBundle.hpp"
+#include "HybridFileAccess.hpp"
+#include "HybridFtp2.hpp"
+#include "HybridGlobal.hpp"
+#include "HybridGzip.hpp"
+#include "HybridHashtable.hpp"
+#include "HybridHtmlToText.hpp"
+#include "HybridHtmlToXml.hpp"
+#include "HybridHttp.hpp"
+#include "HybridHttpCurl.hpp"
+#include "HybridHttpRequest.hpp"
+#include "HybridHttpResponse.hpp"
+#include "HybridImap.hpp"
+#include "HybridJavaKeyStore.hpp"
+#include "HybridJs.hpp"
+#include "HybridJsonArray.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridJwe.hpp"
+#include "HybridJws.hpp"
+#include "HybridJwt.hpp"
+#include "HybridLog.hpp"
+#include "HybridMailMan.hpp"
+#include "HybridMailboxes.hpp"
+#include "HybridMcp.hpp"
+#include "HybridMessageSet.hpp"
+#include "HybridMht.hpp"
+#include "HybridMime.hpp"
+#include "HybridNtlm.hpp"
+#include "HybridOAuth1.hpp"
+#include "HybridOAuth2.hpp"
+#include "HybridPdf.hpp"
+#include "HybridPem.hpp"
+#include "HybridPfx.hpp"
+#include "HybridPkcs11.hpp"
+#include "HybridPrivateKey.hpp"
+#include "HybridPrng.hpp"
+#include "HybridPublicKey.hpp"
+#include "HybridRest.hpp"
+#include "HybridRsa.hpp"
+#include "HybridSCard.hpp"
+#include "HybridSFtp.hpp"
+#include "HybridSFtpDir.hpp"
+#include "HybridSFtpFile.hpp"
+#include "HybridScMinidriver.hpp"
+#include "HybridScp.hpp"
+#include "HybridSecrets.hpp"
+#include "HybridSecureString.hpp"
+#include "HybridServerSentEvent.hpp"
+#include "HybridSocket.hpp"
+#include "HybridSpider.hpp"
+#include "HybridSsh.hpp"
+#include "HybridSshKey.hpp"
+#include "HybridSshTunnel.hpp"
+#include "HybridStream.hpp"
+#include "HybridStringArray.hpp"
+#include "HybridStringBuilder.hpp"
+#include "HybridStringTable.hpp"
+#include "HybridTar.hpp"
+#include "HybridTrustedRoots.hpp"
+#include "HybridUnixCompress.hpp"
+#include "HybridUpload.hpp"
+#include "HybridUrl.hpp"
+#include "HybridWebSocket.hpp"
+#include "HybridXml.hpp"
+#include "HybridXmlCertVault.hpp"
+#include "HybridXmlDSig.hpp"
+#include "HybridXmlDSigGen.hpp"
+#include "HybridXmp.hpp"
+#include "HybridZip.hpp"
+#include "HybridZipCrc.hpp"
+#include "HybridZipEntry.hpp"
+
+namespace margelo::nitro::chilkat {
+
+int initialize(JavaVM* vm) {
+  return facebook::jni::initialize(vm, []() {
+    ::margelo::nitro::chilkat::registerAllNatives();
+  });
+}
+
+
+
+void registerAllNatives() {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::chilkat;
+
+  // Register native JNI methods
+  
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Ai",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridAi>,
+                    "The HybridObject \"HybridAi\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridAi>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Asn",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridAsn>,
+                    "The HybridObject \"HybridAsn\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridAsn>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "AuthAws",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridAuthAws>,
+                    "The HybridObject \"HybridAuthAws\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridAuthAws>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "AuthAzureSAS",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridAuthAzureSAS>,
+                    "The HybridObject \"HybridAuthAzureSAS\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridAuthAzureSAS>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "AuthAzureStorage",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridAuthAzureStorage>,
+                    "The HybridObject \"HybridAuthAzureStorage\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridAuthAzureStorage>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "AuthGoogle",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridAuthGoogle>,
+                    "The HybridObject \"HybridAuthGoogle\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridAuthGoogle>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "BinData",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridBinData>,
+                    "The HybridObject \"HybridBinData\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridBinData>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Bz2",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridBz2>,
+                    "The HybridObject \"HybridBz2\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridBz2>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Cache",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridCache>,
+                    "The HybridObject \"HybridCache\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridCache>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Cert",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridCert>,
+                    "The HybridObject \"HybridCert\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridCert>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "CertChain",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridCertChain>,
+                    "The HybridObject \"HybridCertChain\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridCertChain>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "CertStore",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridCertStore>,
+                    "The HybridObject \"HybridCertStore\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridCertStore>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Charset",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridCharset>,
+                    "The HybridObject \"HybridCharset\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridCharset>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "CkDateTime",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridCkDateTime>,
+                    "The HybridObject \"HybridCkDateTime\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridCkDateTime>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "CodeSign",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridCodeSign>,
+                    "The HybridObject \"HybridCodeSign\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridCodeSign>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Compression",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridCompression>,
+                    "The HybridObject \"HybridCompression\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridCompression>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Crypt2",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridCrypt2>,
+                    "The HybridObject \"HybridCrypt2\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridCrypt2>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Csr",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridCsr>,
+                    "The HybridObject \"HybridCsr\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridCsr>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Csv",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridCsv>,
+                    "The HybridObject \"HybridCsv\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridCsv>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Dh",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridDh>,
+                    "The HybridObject \"HybridDh\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridDh>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "DirTree",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridDirTree>,
+                    "The HybridObject \"HybridDirTree\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridDirTree>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Dkim",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridDkim>,
+                    "The HybridObject \"HybridDkim\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridDkim>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Dns",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridDns>,
+                    "The HybridObject \"HybridDns\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridDns>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Dsa",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridDsa>,
+                    "The HybridObject \"HybridDsa\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridDsa>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "DtObj",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridDtObj>,
+                    "The HybridObject \"HybridDtObj\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridDtObj>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Ecc",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridEcc>,
+                    "The HybridObject \"HybridEcc\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridEcc>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "EdDSA",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridEdDSA>,
+                    "The HybridObject \"HybridEdDSA\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridEdDSA>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Email",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridEmail>,
+                    "The HybridObject \"HybridEmail\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridEmail>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "EmailBundle",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridEmailBundle>,
+                    "The HybridObject \"HybridEmailBundle\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridEmailBundle>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "FileAccess",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridFileAccess>,
+                    "The HybridObject \"HybridFileAccess\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridFileAccess>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Ftp2",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridFtp2>,
+                    "The HybridObject \"HybridFtp2\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridFtp2>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Global",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridGlobal>,
+                    "The HybridObject \"HybridGlobal\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridGlobal>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Gzip",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridGzip>,
+                    "The HybridObject \"HybridGzip\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridGzip>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Hashtable",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridHashtable>,
+                    "The HybridObject \"HybridHashtable\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridHashtable>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "HtmlToText",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridHtmlToText>,
+                    "The HybridObject \"HybridHtmlToText\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridHtmlToText>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "HtmlToXml",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridHtmlToXml>,
+                    "The HybridObject \"HybridHtmlToXml\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridHtmlToXml>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Http",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridHttp>,
+                    "The HybridObject \"HybridHttp\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridHttp>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "HttpCurl",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridHttpCurl>,
+                    "The HybridObject \"HybridHttpCurl\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridHttpCurl>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "HttpRequest",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridHttpRequest>,
+                    "The HybridObject \"HybridHttpRequest\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridHttpRequest>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "HttpResponse",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridHttpResponse>,
+                    "The HybridObject \"HybridHttpResponse\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridHttpResponse>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Imap",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridImap>,
+                    "The HybridObject \"HybridImap\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridImap>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "JavaKeyStore",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridJavaKeyStore>,
+                    "The HybridObject \"HybridJavaKeyStore\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridJavaKeyStore>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Js",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridJs>,
+                    "The HybridObject \"HybridJs\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridJs>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "JsonArray",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridJsonArray>,
+                    "The HybridObject \"HybridJsonArray\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridJsonArray>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "JsonObject",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridJsonObject>,
+                    "The HybridObject \"HybridJsonObject\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridJsonObject>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Jwe",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridJwe>,
+                    "The HybridObject \"HybridJwe\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridJwe>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Jws",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridJws>,
+                    "The HybridObject \"HybridJws\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridJws>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Jwt",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridJwt>,
+                    "The HybridObject \"HybridJwt\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridJwt>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Log",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridLog>,
+                    "The HybridObject \"HybridLog\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridLog>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MailMan",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridMailMan>,
+                    "The HybridObject \"HybridMailMan\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridMailMan>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Mailboxes",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridMailboxes>,
+                    "The HybridObject \"HybridMailboxes\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridMailboxes>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Mcp",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridMcp>,
+                    "The HybridObject \"HybridMcp\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridMcp>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MessageSet",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridMessageSet>,
+                    "The HybridObject \"HybridMessageSet\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridMessageSet>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Mht",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridMht>,
+                    "The HybridObject \"HybridMht\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridMht>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Mime",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridMime>,
+                    "The HybridObject \"HybridMime\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridMime>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Ntlm",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridNtlm>,
+                    "The HybridObject \"HybridNtlm\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridNtlm>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "OAuth1",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridOAuth1>,
+                    "The HybridObject \"HybridOAuth1\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridOAuth1>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "OAuth2",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridOAuth2>,
+                    "The HybridObject \"HybridOAuth2\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridOAuth2>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Pdf",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridPdf>,
+                    "The HybridObject \"HybridPdf\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridPdf>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Pem",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridPem>,
+                    "The HybridObject \"HybridPem\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridPem>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Pfx",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridPfx>,
+                    "The HybridObject \"HybridPfx\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridPfx>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Pkcs11",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridPkcs11>,
+                    "The HybridObject \"HybridPkcs11\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridPkcs11>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "PrivateKey",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridPrivateKey>,
+                    "The HybridObject \"HybridPrivateKey\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridPrivateKey>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Prng",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridPrng>,
+                    "The HybridObject \"HybridPrng\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridPrng>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "PublicKey",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridPublicKey>,
+                    "The HybridObject \"HybridPublicKey\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridPublicKey>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Rest",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridRest>,
+                    "The HybridObject \"HybridRest\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridRest>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Rsa",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridRsa>,
+                    "The HybridObject \"HybridRsa\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridRsa>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "SCard",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridSCard>,
+                    "The HybridObject \"HybridSCard\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridSCard>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "SFtp",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridSFtp>,
+                    "The HybridObject \"HybridSFtp\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridSFtp>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "SFtpDir",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridSFtpDir>,
+                    "The HybridObject \"HybridSFtpDir\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridSFtpDir>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "SFtpFile",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridSFtpFile>,
+                    "The HybridObject \"HybridSFtpFile\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridSFtpFile>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ScMinidriver",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridScMinidriver>,
+                    "The HybridObject \"HybridScMinidriver\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridScMinidriver>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Scp",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridScp>,
+                    "The HybridObject \"HybridScp\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridScp>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Secrets",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridSecrets>,
+                    "The HybridObject \"HybridSecrets\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridSecrets>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "SecureString",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridSecureString>,
+                    "The HybridObject \"HybridSecureString\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridSecureString>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ServerSentEvent",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridServerSentEvent>,
+                    "The HybridObject \"HybridServerSentEvent\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridServerSentEvent>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Socket",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridSocket>,
+                    "The HybridObject \"HybridSocket\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridSocket>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Spider",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridSpider>,
+                    "The HybridObject \"HybridSpider\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridSpider>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Ssh",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridSsh>,
+                    "The HybridObject \"HybridSsh\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridSsh>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "SshKey",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridSshKey>,
+                    "The HybridObject \"HybridSshKey\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridSshKey>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "SshTunnel",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridSshTunnel>,
+                    "The HybridObject \"HybridSshTunnel\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridSshTunnel>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Stream",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridStream>,
+                    "The HybridObject \"HybridStream\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridStream>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "StringArray",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridStringArray>,
+                    "The HybridObject \"HybridStringArray\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridStringArray>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "StringBuilder",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridStringBuilder>,
+                    "The HybridObject \"HybridStringBuilder\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridStringBuilder>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "StringTable",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridStringTable>,
+                    "The HybridObject \"HybridStringTable\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridStringTable>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Tar",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridTar>,
+                    "The HybridObject \"HybridTar\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridTar>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "TrustedRoots",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridTrustedRoots>,
+                    "The HybridObject \"HybridTrustedRoots\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridTrustedRoots>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "UnixCompress",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridUnixCompress>,
+                    "The HybridObject \"HybridUnixCompress\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridUnixCompress>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Upload",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridUpload>,
+                    "The HybridObject \"HybridUpload\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridUpload>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Url",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridUrl>,
+                    "The HybridObject \"HybridUrl\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridUrl>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "WebSocket",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridWebSocket>,
+                    "The HybridObject \"HybridWebSocket\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridWebSocket>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Xml",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridXml>,
+                    "The HybridObject \"HybridXml\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridXml>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "XmlCertVault",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridXmlCertVault>,
+                    "The HybridObject \"HybridXmlCertVault\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridXmlCertVault>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "XmlDSig",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridXmlDSig>,
+                    "The HybridObject \"HybridXmlDSig\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridXmlDSig>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "XmlDSigGen",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridXmlDSigGen>,
+                    "The HybridObject \"HybridXmlDSigGen\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridXmlDSigGen>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Xmp",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridXmp>,
+                    "The HybridObject \"HybridXmp\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridXmp>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Zip",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridZip>,
+                    "The HybridObject \"HybridZip\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridZip>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ZipCrc",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridZipCrc>,
+                    "The HybridObject \"HybridZipCrc\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridZipCrc>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ZipEntry",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridZipEntry>,
+                    "The HybridObject \"HybridZipEntry\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridZipEntry>();
+    }
+  );
+}
+
+} // namespace margelo::nitro::chilkat