@chilkat/react-native 11.6.1

package/nitrogen/generated/ios/ChilkatRNAutolinking.swift

@@ -0,0 +1,16 @@
+///
+/// ChilkatRNAutolinking.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+// TODO: Use empty enums once Swift supports exporting them as namespaces
+//       See: https://github.com/swiftlang/swift/pull/83616
+public final class ChilkatRNAutolinking {
+  public typealias bridge = margelo.nitro.chilkat.bridge.swift
+
+  
+}

package/nitrogen/generated/shared/c++/HybridAiSpec.cpp

@@ -0,0 +1,114 @@
+///
+/// HybridAiSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridAiSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridAiSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridAiSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridAiSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridAiSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridAiSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridAiSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridAiSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridAiSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridAiSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridAiSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridAiSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("provider", &HybridAiSpec::getProvider);
+      prototype.registerHybridSetter("provider", &HybridAiSpec::setProvider);
+      prototype.registerHybridGetter("selectedConvo", &HybridAiSpec::getSelectedConvo);
+      prototype.registerHybridSetter("selectedConvo", &HybridAiSpec::setSelectedConvo);
+      prototype.registerHybridGetter("apiKey", &HybridAiSpec::getApiKey);
+      prototype.registerHybridSetter("apiKey", &HybridAiSpec::setApiKey);
+      prototype.registerHybridGetter("model", &HybridAiSpec::getModel);
+      prototype.registerHybridSetter("model", &HybridAiSpec::setModel);
+      prototype.registerHybridGetter("fullTranscript", &HybridAiSpec::getFullTranscript);
+      prototype.registerHybridSetter("fullTranscript", &HybridAiSpec::setFullTranscript);
+      prototype.registerHybridGetter("streaming", &HybridAiSpec::getStreaming);
+      prototype.registerHybridSetter("streaming", &HybridAiSpec::setStreaming);
+      prototype.registerHybridGetter("heartbeatMs", &HybridAiSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridAiSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("hostedConvo", &HybridAiSpec::getHostedConvo);
+      prototype.registerHybridSetter("hostedConvo", &HybridAiSpec::setHostedConvo);
+      prototype.registerHybridGetter("uncommonOptions", &HybridAiSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridAiSpec::setUncommonOptions);
+      prototype.registerHybridGetter("idleTimeoutMs", &HybridAiSpec::getIdleTimeoutMs);
+      prototype.registerHybridSetter("idleTimeoutMs", &HybridAiSpec::setIdleTimeoutMs);
+      prototype.registerHybridGetter("responseStatusCode", &HybridAiSpec::getResponseStatusCode);
+      prototype.registerHybridGetter("apiSpec", &HybridAiSpec::getApiSpec);
+      prototype.registerHybridSetter("apiSpec", &HybridAiSpec::setApiSpec);
+      prototype.registerHybridGetter("baseUrl", &HybridAiSpec::getBaseUrl);
+      prototype.registerHybridSetter("baseUrl", &HybridAiSpec::setBaseUrl);
+      prototype.registerHybridGetter("apiKeyHeader", &HybridAiSpec::getApiKeyHeader);
+      prototype.registerHybridSetter("apiKeyHeader", &HybridAiSpec::setApiKeyHeader);
+      prototype.registerHybridGetter("hasFunctionCalls", &HybridAiSpec::getHasFunctionCalls);
+      prototype.registerHybridGetter("jsToolTimeout", &HybridAiSpec::getJsToolTimeout);
+      prototype.registerHybridSetter("jsToolTimeout", &HybridAiSpec::setJsToolTimeout);
+      prototype.registerHybridGetter("enableSecrets", &HybridAiSpec::getEnableSecrets);
+      prototype.registerHybridSetter("enableSecrets", &HybridAiSpec::setEnableSecrets);
+      prototype.registerHybridGetter("lastResponseRefused", &HybridAiSpec::getLastResponseRefused);
+      prototype.registerHybridGetter("refusalText", &HybridAiSpec::getRefusalText);
+      prototype.registerHybridGetter("onPercentDone", &HybridAiSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridAiSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridAiSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridAiSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("newConvo", &HybridAiSpec::newConvo);
+      prototype.registerHybridMethod("exportConvo", &HybridAiSpec::exportConvo);
+      prototype.registerHybridMethod("importConvo", &HybridAiSpec::importConvo);
+      prototype.registerHybridMethod("listConvos", &HybridAiSpec::listConvos);
+      prototype.registerHybridMethod("deleteConvo", &HybridAiSpec::deleteConvo);
+      prototype.registerHybridMethod("setConnectionSettings", &HybridAiSpec::setConnectionSettings);
+      prototype.registerHybridMethod("ask", &HybridAiSpec::ask);
+      prototype.registerHybridMethod("askAsync", &HybridAiSpec::askAsync);
+      prototype.registerHybridMethod("getLastJsonData", &HybridAiSpec::getLastJsonData);
+      prototype.registerHybridMethod("getModels", &HybridAiSpec::getModels);
+      prototype.registerHybridMethod("getModelsAsync", &HybridAiSpec::getModelsAsync);
+      prototype.registerHybridMethod("inputAddText", &HybridAiSpec::inputAddText);
+      prototype.registerHybridMethod("getOutputText", &HybridAiSpec::getOutputText);
+      prototype.registerHybridMethod("getOutputTextSb", &HybridAiSpec::getOutputTextSb);
+      prototype.registerHybridMethod("inputClear", &HybridAiSpec::inputClear);
+      prototype.registerHybridMethod("inputAddTextSb", &HybridAiSpec::inputAddTextSb);
+      prototype.registerHybridMethod("inputAddImageData", &HybridAiSpec::inputAddImageData);
+      prototype.registerHybridMethod("inputAddImageUrl", &HybridAiSpec::inputAddImageUrl);
+      prototype.registerHybridMethod("inputAddFileData", &HybridAiSpec::inputAddFileData);
+      prototype.registerHybridMethod("inputAddFileUrl", &HybridAiSpec::inputAddFileUrl);
+      prototype.registerHybridMethod("pollAi", &HybridAiSpec::pollAi);
+      prototype.registerHybridMethod("nextAiEvent", &HybridAiSpec::nextAiEvent);
+      prototype.registerHybridMethod("sleepMs", &HybridAiSpec::sleepMs);
+      prototype.registerHybridMethod("setProviderParams", &HybridAiSpec::setProviderParams);
+      prototype.registerHybridMethod("setAskParams", &HybridAiSpec::setAskParams);
+      prototype.registerHybridMethod("registerManualTools", &HybridAiSpec::registerManualTools);
+      prototype.registerHybridMethod("getFunctionCalls", &HybridAiSpec::getFunctionCalls);
+      prototype.registerHybridMethod("getSearchResults", &HybridAiSpec::getSearchResults);
+      prototype.registerHybridMethod("useMcp", &HybridAiSpec::useMcp);
+      prototype.registerHybridMethod("useMcpAsync", &HybridAiSpec::useMcpAsync);
+      prototype.registerHybridMethod("setOutputSchema", &HybridAiSpec::setOutputSchema);
+      prototype.registerHybridMethod("getOutputJson", &HybridAiSpec::getOutputJson);
+      prototype.registerHybridMethod("inputAddFnResult", &HybridAiSpec::inputAddFnResult);
+      prototype.registerHybridMethod("registerJsTools", &HybridAiSpec::registerJsTools);
+      prototype.registerHybridMethod("streamingJsToolCall", &HybridAiSpec::streamingJsToolCall);
+      prototype.registerHybridMethod("streamingJsToolCallAsync", &HybridAiSpec::streamingJsToolCallAsync);
+      prototype.registerHybridMethod("inputAddFileId", &HybridAiSpec::inputAddFileId);
+      prototype.registerHybridMethod("getOutputBd", &HybridAiSpec::getOutputBd);
+      prototype.registerHybridMethod("uploadFile", &HybridAiSpec::uploadFile);
+      prototype.registerHybridMethod("uploadFileAsync", &HybridAiSpec::uploadFileAsync);
+      prototype.registerHybridMethod("uploadFileBd", &HybridAiSpec::uploadFileBd);
+      prototype.registerHybridMethod("uploadFileBdAsync", &HybridAiSpec::uploadFileBdAsync);
+      prototype.registerHybridMethod("uploadFileSb", &HybridAiSpec::uploadFileSb);
+      prototype.registerHybridMethod("uploadFileSbAsync", &HybridAiSpec::uploadFileSbAsync);
+      prototype.registerHybridMethod("inputAddImageFileId", &HybridAiSpec::inputAddImageFileId);
+      prototype.registerHybridMethod("abort", &HybridAiSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridAiSpec.hpp

@@ -0,0 +1,175 @@
+///
+/// HybridAiSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+// Forward declaration of `HybridStringTableSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringTableSpec; }
+// Forward declaration of `HybridSocketSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridSocketSpec; }
+// Forward declaration of `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridMcpSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridMcpSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <memory>
+#include "HybridJsonObjectSpec.hpp"
+#include "HybridStringTableSpec.hpp"
+#include "HybridSocketSpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include "HybridStringBuilderSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include "HybridMcpSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Ai`
+   * Inherit this class to create instances of `HybridAiSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridAi: public HybridAiSpec {
+   * public:
+   *   HybridAi(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridAiSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridAiSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridAiSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getLastErrorHtml() = 0;
+      virtual std::string getLastErrorText() = 0;
+      virtual std::string getLastErrorXml() = 0;
+      virtual std::string getVersion() = 0;
+      virtual std::string getDebugLogFilePath() = 0;
+      virtual void setDebugLogFilePath(const std::string& debugLogFilePath) = 0;
+      virtual bool getVerboseLogging() = 0;
+      virtual void setVerboseLogging(bool verboseLogging) = 0;
+      virtual bool getLastMethodSuccess() = 0;
+      virtual void setLastMethodSuccess(bool lastMethodSuccess) = 0;
+      virtual std::string getProvider() = 0;
+      virtual void setProvider(const std::string& provider) = 0;
+      virtual std::string getSelectedConvo() = 0;
+      virtual void setSelectedConvo(const std::string& selectedConvo) = 0;
+      virtual std::string getApiKey() = 0;
+      virtual void setApiKey(const std::string& apiKey) = 0;
+      virtual std::string getModel() = 0;
+      virtual void setModel(const std::string& model) = 0;
+      virtual bool getFullTranscript() = 0;
+      virtual void setFullTranscript(bool fullTranscript) = 0;
+      virtual bool getStreaming() = 0;
+      virtual void setStreaming(bool streaming) = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual bool getHostedConvo() = 0;
+      virtual void setHostedConvo(bool hostedConvo) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+      virtual double getIdleTimeoutMs() = 0;
+      virtual void setIdleTimeoutMs(double idleTimeoutMs) = 0;
+      virtual double getResponseStatusCode() = 0;
+      virtual std::string getApiSpec() = 0;
+      virtual void setApiSpec(const std::string& apiSpec) = 0;
+      virtual std::string getBaseUrl() = 0;
+      virtual void setBaseUrl(const std::string& baseUrl) = 0;
+      virtual std::string getApiKeyHeader() = 0;
+      virtual void setApiKeyHeader(const std::string& apiKeyHeader) = 0;
+      virtual bool getHasFunctionCalls() = 0;
+      virtual double getJsToolTimeout() = 0;
+      virtual void setJsToolTimeout(double jsToolTimeout) = 0;
+      virtual bool getEnableSecrets() = 0;
+      virtual void setEnableSecrets(bool enableSecrets) = 0;
+      virtual bool getLastResponseRefused() = 0;
+      virtual std::string getRefusalText() = 0;
+      virtual std::optional<std::function<void(double /* pctDone */)>> getOnPercentDone() = 0;
+      virtual void setOnPercentDone(const std::optional<std::function<void(double /* pctDone */)>>& onPercentDone) = 0;
+      virtual std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>> getOnProgressInfo() = 0;
+      virtual void setOnProgressInfo(const std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>>& onProgressInfo) = 0;
+
+    public:
+      // Methods
+      virtual void newConvo(const std::string& name, const std::string& sysMsg, const std::string& devMsg) = 0;
+      virtual void exportConvo(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void importConvo(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void listConvos(const std::shared_ptr<HybridStringTableSpec>& st) = 0;
+      virtual void deleteConvo(const std::string& name) = 0;
+      virtual void setConnectionSettings(const std::shared_ptr<HybridSocketSpec>& sock) = 0;
+      virtual void ask(const std::string& outputType) = 0;
+      virtual std::shared_ptr<Promise<void>> askAsync(const std::string& outputType) = 0;
+      virtual void getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void getModels(const std::shared_ptr<HybridStringTableSpec>& st) = 0;
+      virtual std::shared_ptr<Promise<void>> getModelsAsync(const std::shared_ptr<HybridStringTableSpec>& st) = 0;
+      virtual void inputAddText(const std::string& text) = 0;
+      virtual std::string getOutputText() = 0;
+      virtual void getOutputTextSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void inputClear() = 0;
+      virtual void inputAddTextSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void inputAddImageData(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& summary) = 0;
+      virtual void inputAddImageUrl(const std::string& url, const std::string& summary) = 0;
+      virtual void inputAddFileData(const std::string& filename, const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& summary) = 0;
+      virtual void inputAddFileUrl(const std::string& url, const std::string& summary) = 0;
+      virtual double pollAi(bool abort) = 0;
+      virtual void nextAiEvent(double maxWaitMs, const std::shared_ptr<HybridStringBuilderSpec>& sbName, const std::shared_ptr<HybridStringBuilderSpec>& sbDelta) = 0;
+      virtual void sleepMs(double millisec) = 0;
+      virtual void setProviderParams(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void setAskParams(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void registerManualTools(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void getFunctionCalls(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void getSearchResults(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void useMcp(const std::shared_ptr<HybridMcpSpec>& cMcp, const std::string& namePrefix) = 0;
+      virtual std::shared_ptr<Promise<void>> useMcpAsync(const std::shared_ptr<HybridMcpSpec>& cMcp, const std::string& namePrefix) = 0;
+      virtual void setOutputSchema(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& schema, bool strict) = 0;
+      virtual void getOutputJson(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void inputAddFnResult(const std::string& callId, const std::string& fnResult) = 0;
+      virtual void registerJsTools(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool evalOnly, bool allowAllKeyword) = 0;
+      virtual void streamingJsToolCall(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual std::shared_ptr<Promise<void>> streamingJsToolCallAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void inputAddFileId(const std::string& fileId, const std::string& mimeType) = 0;
+      virtual void getOutputBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual std::string uploadFile(const std::string& path, const std::string& mimeType) = 0;
+      virtual std::shared_ptr<Promise<std::string>> uploadFileAsync(const std::string& path, const std::string& mimeType) = 0;
+      virtual std::string uploadFileBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& filename, const std::string& mimeType) = 0;
+      virtual std::shared_ptr<Promise<std::string>> uploadFileBdAsync(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& filename, const std::string& mimeType) = 0;
+      virtual std::string uploadFileSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& filename, const std::string& mimeType) = 0;
+      virtual std::shared_ptr<Promise<std::string>> uploadFileSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& filename, const std::string& mimeType) = 0;
+      virtual void inputAddImageFileId(const std::string& fileId, const std::string& mimeType) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Ai";
+  };
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridAsnSpec.cpp

@@ -0,0 +1,70 @@
+///
+/// HybridAsnSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridAsnSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridAsnSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridAsnSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridAsnSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridAsnSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridAsnSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridAsnSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridAsnSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridAsnSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridAsnSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridAsnSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridAsnSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("boolValue", &HybridAsnSpec::getBoolValue);
+      prototype.registerHybridSetter("boolValue", &HybridAsnSpec::setBoolValue);
+      prototype.registerHybridGetter("constructed", &HybridAsnSpec::getConstructed);
+      prototype.registerHybridGetter("contentStr", &HybridAsnSpec::getContentStr);
+      prototype.registerHybridSetter("contentStr", &HybridAsnSpec::setContentStr);
+      prototype.registerHybridGetter("intValue", &HybridAsnSpec::getIntValue);
+      prototype.registerHybridSetter("intValue", &HybridAsnSpec::setIntValue);
+      prototype.registerHybridGetter("numSubItems", &HybridAsnSpec::getNumSubItems);
+      prototype.registerHybridGetter("tag", &HybridAsnSpec::getTag);
+      prototype.registerHybridGetter("tagValue", &HybridAsnSpec::getTagValue);
+      prototype.registerHybridMethod("appendBigInt", &HybridAsnSpec::appendBigInt);
+      prototype.registerHybridMethod("appendBits", &HybridAsnSpec::appendBits);
+      prototype.registerHybridMethod("appendBool", &HybridAsnSpec::appendBool);
+      prototype.registerHybridMethod("appendContextConstructed", &HybridAsnSpec::appendContextConstructed);
+      prototype.registerHybridMethod("appendContextPrimitive", &HybridAsnSpec::appendContextPrimitive);
+      prototype.registerHybridMethod("appendInt", &HybridAsnSpec::appendInt);
+      prototype.registerHybridMethod("appendNull", &HybridAsnSpec::appendNull);
+      prototype.registerHybridMethod("appendOctets", &HybridAsnSpec::appendOctets);
+      prototype.registerHybridMethod("appendOid", &HybridAsnSpec::appendOid);
+      prototype.registerHybridMethod("appendSequence", &HybridAsnSpec::appendSequence);
+      prototype.registerHybridMethod("appendSequence2", &HybridAsnSpec::appendSequence2);
+      prototype.registerHybridMethod("appendSequenceR", &HybridAsnSpec::appendSequenceR);
+      prototype.registerHybridMethod("appendSet", &HybridAsnSpec::appendSet);
+      prototype.registerHybridMethod("appendSet2", &HybridAsnSpec::appendSet2);
+      prototype.registerHybridMethod("appendSetR", &HybridAsnSpec::appendSetR);
+      prototype.registerHybridMethod("appendString", &HybridAsnSpec::appendString);
+      prototype.registerHybridMethod("appendTime", &HybridAsnSpec::appendTime);
+      prototype.registerHybridMethod("asnToXml", &HybridAsnSpec::asnToXml);
+      prototype.registerHybridMethod("deleteSubItem", &HybridAsnSpec::deleteSubItem);
+      prototype.registerHybridMethod("getEncodedContent", &HybridAsnSpec::getEncodedContent);
+      prototype.registerHybridMethod("getEncodedDer", &HybridAsnSpec::getEncodedDer);
+      prototype.registerHybridMethod("getLastSubItem", &HybridAsnSpec::getLastSubItem);
+      prototype.registerHybridMethod("getSubItem", &HybridAsnSpec::getSubItem);
+      prototype.registerHybridMethod("loadAsnXml", &HybridAsnSpec::loadAsnXml);
+      prototype.registerHybridMethod("loadBinaryFile", &HybridAsnSpec::loadBinaryFile);
+      prototype.registerHybridMethod("loadEncoded", &HybridAsnSpec::loadEncoded);
+      prototype.registerHybridMethod("setEncodedContent", &HybridAsnSpec::setEncodedContent);
+      prototype.registerHybridMethod("writeBinaryDer", &HybridAsnSpec::writeBinaryDer);
+      prototype.registerHybridMethod("loadBd", &HybridAsnSpec::loadBd);
+      prototype.registerHybridMethod("writeBd", &HybridAsnSpec::writeBd);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridAsnSpec.hpp

@@ -0,0 +1,116 @@
+///
+/// HybridAsnSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridAsnSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridAsnSpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridAsnSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Asn`
+   * Inherit this class to create instances of `HybridAsnSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridAsn: public HybridAsnSpec {
+   * public:
+   *   HybridAsn(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridAsnSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridAsnSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridAsnSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getLastErrorHtml() = 0;
+      virtual std::string getLastErrorText() = 0;
+      virtual std::string getLastErrorXml() = 0;
+      virtual std::string getVersion() = 0;
+      virtual std::string getDebugLogFilePath() = 0;
+      virtual void setDebugLogFilePath(const std::string& debugLogFilePath) = 0;
+      virtual bool getVerboseLogging() = 0;
+      virtual void setVerboseLogging(bool verboseLogging) = 0;
+      virtual bool getLastMethodSuccess() = 0;
+      virtual void setLastMethodSuccess(bool lastMethodSuccess) = 0;
+      virtual bool getBoolValue() = 0;
+      virtual void setBoolValue(bool boolValue) = 0;
+      virtual bool getConstructed() = 0;
+      virtual std::string getContentStr() = 0;
+      virtual void setContentStr(const std::string& contentStr) = 0;
+      virtual double getIntValue() = 0;
+      virtual void setIntValue(double intValue) = 0;
+      virtual double getNumSubItems() = 0;
+      virtual std::string getTag() = 0;
+      virtual double getTagValue() = 0;
+
+    public:
+      // Methods
+      virtual void appendBigInt(const std::string& encodedBytes, const std::string& encoding) = 0;
+      virtual void appendBits(const std::string& encodedBytes, const std::string& encoding) = 0;
+      virtual void appendBool(bool value) = 0;
+      virtual void appendContextConstructed(double tag) = 0;
+      virtual void appendContextPrimitive(double tag, const std::string& encodedBytes, const std::string& encoding) = 0;
+      virtual void appendInt(double value) = 0;
+      virtual void appendNull() = 0;
+      virtual void appendOctets(const std::string& encodedBytes, const std::string& encoding) = 0;
+      virtual void appendOid(const std::string& oid) = 0;
+      virtual void appendSequence() = 0;
+      virtual void appendSequence2() = 0;
+      virtual std::shared_ptr<HybridAsnSpec> appendSequenceR() = 0;
+      virtual void appendSet() = 0;
+      virtual void appendSet2() = 0;
+      virtual std::shared_ptr<HybridAsnSpec> appendSetR() = 0;
+      virtual void appendString(const std::string& strType, const std::string& value) = 0;
+      virtual void appendTime(const std::string& timeFormat, const std::string& dateTimeStr) = 0;
+      virtual std::string asnToXml() = 0;
+      virtual void deleteSubItem(double index) = 0;
+      virtual std::string getEncodedContent(const std::string& encoding) = 0;
+      virtual std::string getEncodedDer(const std::string& encoding) = 0;
+      virtual std::shared_ptr<HybridAsnSpec> getLastSubItem() = 0;
+      virtual std::shared_ptr<HybridAsnSpec> getSubItem(double index) = 0;
+      virtual void loadAsnXml(const std::string& xmlStr) = 0;
+      virtual void loadBinaryFile(const std::string& path) = 0;
+      virtual void loadEncoded(const std::string& asnContent, const std::string& encoding) = 0;
+      virtual void setEncodedContent(const std::string& encodedBytes, const std::string& encoding) = 0;
+      virtual void writeBinaryDer(const std::string& path) = 0;
+      virtual void loadBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void writeBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Asn";
+  };
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridAuthAwsSpec.cpp

@@ -0,0 +1,49 @@
+///
+/// HybridAuthAwsSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridAuthAwsSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridAuthAwsSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridAuthAwsSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridAuthAwsSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridAuthAwsSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridAuthAwsSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridAuthAwsSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridAuthAwsSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridAuthAwsSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridAuthAwsSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridAuthAwsSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridAuthAwsSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("accessKey", &HybridAuthAwsSpec::getAccessKey);
+      prototype.registerHybridSetter("accessKey", &HybridAuthAwsSpec::setAccessKey);
+      prototype.registerHybridGetter("canonicalizedResourceV2", &HybridAuthAwsSpec::getCanonicalizedResourceV2);
+      prototype.registerHybridSetter("canonicalizedResourceV2", &HybridAuthAwsSpec::setCanonicalizedResourceV2);
+      prototype.registerHybridGetter("precomputedMd5", &HybridAuthAwsSpec::getPrecomputedMd5);
+      prototype.registerHybridSetter("precomputedMd5", &HybridAuthAwsSpec::setPrecomputedMd5);
+      prototype.registerHybridGetter("precomputedSha256", &HybridAuthAwsSpec::getPrecomputedSha256);
+      prototype.registerHybridSetter("precomputedSha256", &HybridAuthAwsSpec::setPrecomputedSha256);
+      prototype.registerHybridGetter("region", &HybridAuthAwsSpec::getRegion);
+      prototype.registerHybridSetter("region", &HybridAuthAwsSpec::setRegion);
+      prototype.registerHybridGetter("secretKey", &HybridAuthAwsSpec::getSecretKey);
+      prototype.registerHybridSetter("secretKey", &HybridAuthAwsSpec::setSecretKey);
+      prototype.registerHybridGetter("serviceName", &HybridAuthAwsSpec::getServiceName);
+      prototype.registerHybridSetter("serviceName", &HybridAuthAwsSpec::setServiceName);
+      prototype.registerHybridGetter("signatureVersion", &HybridAuthAwsSpec::getSignatureVersion);
+      prototype.registerHybridSetter("signatureVersion", &HybridAuthAwsSpec::setSignatureVersion);
+      prototype.registerHybridGetter("enableSecrets", &HybridAuthAwsSpec::getEnableSecrets);
+      prototype.registerHybridSetter("enableSecrets", &HybridAuthAwsSpec::setEnableSecrets);
+      prototype.registerHybridMethod("genPresignedUrl", &HybridAuthAwsSpec::genPresignedUrl);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridAuthAwsSpec.hpp

@@ -0,0 +1,89 @@
+///
+/// HybridAuthAwsSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `AuthAws`
+   * Inherit this class to create instances of `HybridAuthAwsSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridAuthAws: public HybridAuthAwsSpec {
+   * public:
+   *   HybridAuthAws(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridAuthAwsSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridAuthAwsSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridAuthAwsSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getLastErrorHtml() = 0;
+      virtual std::string getLastErrorText() = 0;
+      virtual std::string getLastErrorXml() = 0;
+      virtual std::string getVersion() = 0;
+      virtual std::string getDebugLogFilePath() = 0;
+      virtual void setDebugLogFilePath(const std::string& debugLogFilePath) = 0;
+      virtual bool getVerboseLogging() = 0;
+      virtual void setVerboseLogging(bool verboseLogging) = 0;
+      virtual bool getLastMethodSuccess() = 0;
+      virtual void setLastMethodSuccess(bool lastMethodSuccess) = 0;
+      virtual std::string getAccessKey() = 0;
+      virtual void setAccessKey(const std::string& accessKey) = 0;
+      virtual std::string getCanonicalizedResourceV2() = 0;
+      virtual void setCanonicalizedResourceV2(const std::string& canonicalizedResourceV2) = 0;
+      virtual std::string getPrecomputedMd5() = 0;
+      virtual void setPrecomputedMd5(const std::string& precomputedMd5) = 0;
+      virtual std::string getPrecomputedSha256() = 0;
+      virtual void setPrecomputedSha256(const std::string& precomputedSha256) = 0;
+      virtual std::string getRegion() = 0;
+      virtual void setRegion(const std::string& region) = 0;
+      virtual std::string getSecretKey() = 0;
+      virtual void setSecretKey(const std::string& secretKey) = 0;
+      virtual std::string getServiceName() = 0;
+      virtual void setServiceName(const std::string& serviceName) = 0;
+      virtual double getSignatureVersion() = 0;
+      virtual void setSignatureVersion(double signatureVersion) = 0;
+      virtual bool getEnableSecrets() = 0;
+      virtual void setEnableSecrets(bool enableSecrets) = 0;
+
+    public:
+      // Methods
+      virtual std::string genPresignedUrl(const std::string& httpVerb, bool useHttps, const std::string& domain, const std::string& path, double numSecondsValid, const std::string& awsService) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "AuthAws";
+  };
+
+} // namespace margelo::nitro::chilkat