@chilkat/react-native 11.6.1

package/cpp/HybridHttp.cpp

@@ -0,0 +1,2067 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridHttp.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCert.hpp"
+#include "HybridHashtable.hpp"
+#include "HybridHttpRequest.hpp"
+#include "HybridHttpResponse.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridPrivateKey.hpp"
+#include "HybridSecureString.hpp"
+#include "HybridStringBuilder.hpp"
+#include "HybridStringTable.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+#include <CkHttpProgress.h>
+
+namespace margelo::nitro::chilkat {
+
+HybridHttp::HybridHttp()
+    : HybridObject(HybridHttpSpec::TAG), ChilkatObject<CkHttp>("Http", CkHttp::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridHttp::HybridHttp(CkHttp* owned)
+    : HybridObject(HybridHttpSpec::TAG), ChilkatObject<CkHttp>("Http", owned) {
+  init();
+}
+
+void HybridHttp::init() {
+  this->installProgress<ProgressAdapter<CkHttpProgress>>();
+}
+
+void HybridHttp::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridHttp::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttp::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttp::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttp::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttp::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridHttp::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridHttp::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridHttp::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridHttp::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+bool HybridHttp::getAbortCurrent() {
+  this->beginCall();
+  return this->ck().get_AbortCurrent();
+}
+void HybridHttp::setAbortCurrent(bool value) {
+  this->beginCall();
+  this->ck().put_AbortCurrent(value);
+}
+std::string HybridHttp::getAccept() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Accept(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setAccept(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "accept");
+  this->ck().put_Accept(value.c_str());
+}
+bool HybridHttp::getAllowGzip() {
+  this->beginCall();
+  return this->ck().get_AllowGzip();
+}
+void HybridHttp::setAllowGzip(bool value) {
+  this->beginCall();
+  this->ck().put_AllowGzip(value);
+}
+bool HybridHttp::getAutoAddHostHeader() {
+  this->beginCall();
+  return this->ck().get_AutoAddHostHeader();
+}
+void HybridHttp::setAutoAddHostHeader(bool value) {
+  this->beginCall();
+  this->ck().put_AutoAddHostHeader(value);
+}
+std::string HybridHttp::getAwsAccessKey() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AwsAccessKey(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setAwsAccessKey(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "awsAccessKey");
+  this->ck().put_AwsAccessKey(value.c_str());
+}
+std::string HybridHttp::getAwsEndpoint() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AwsEndpoint(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setAwsEndpoint(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "awsEndpoint");
+  this->ck().put_AwsEndpoint(value.c_str());
+}
+std::string HybridHttp::getAwsRegion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AwsRegion(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setAwsRegion(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "awsRegion");
+  this->ck().put_AwsRegion(value.c_str());
+}
+std::string HybridHttp::getAwsSecretKey() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AwsSecretKey(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setAwsSecretKey(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "awsSecretKey");
+  this->ck().put_AwsSecretKey(value.c_str());
+}
+std::string HybridHttp::getAwsSubResources() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AwsSubResources(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setAwsSubResources(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "awsSubResources");
+  this->ck().put_AwsSubResources(value.c_str());
+}
+double HybridHttp::getBandwidthThrottleDown() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_BandwidthThrottleDown());
+}
+void HybridHttp::setBandwidthThrottleDown(double value) {
+  this->beginCall();
+  this->ck().put_BandwidthThrottleDown(rt::toInt(value, "bandwidthThrottleDown"));
+}
+double HybridHttp::getBandwidthThrottleUp() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_BandwidthThrottleUp());
+}
+void HybridHttp::setBandwidthThrottleUp(double value) {
+  this->beginCall();
+  this->ck().put_BandwidthThrottleUp(rt::toInt(value, "bandwidthThrottleUp"));
+}
+bool HybridHttp::getBasicAuth() {
+  this->beginCall();
+  return this->ck().get_BasicAuth();
+}
+void HybridHttp::setBasicAuth(bool value) {
+  this->beginCall();
+  this->ck().put_BasicAuth(value);
+}
+std::string HybridHttp::getClientIpAddress() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ClientIpAddress(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setClientIpAddress(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "clientIpAddress");
+  this->ck().put_ClientIpAddress(value.c_str());
+}
+double HybridHttp::getConnectFailReason() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ConnectFailReason());
+}
+double HybridHttp::getConnectTimeout() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ConnectTimeout());
+}
+void HybridHttp::setConnectTimeout(double value) {
+  this->beginCall();
+  this->ck().put_ConnectTimeout(rt::toInt(value, "connectTimeout"));
+}
+std::string HybridHttp::getCookieDir() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_CookieDir(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setCookieDir(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "cookieDir");
+  this->ck().put_CookieDir(value.c_str());
+}
+double HybridHttp::getDefaultFreshPeriod() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_DefaultFreshPeriod());
+}
+void HybridHttp::setDefaultFreshPeriod(double value) {
+  this->beginCall();
+  this->ck().put_DefaultFreshPeriod(rt::toInt(value, "defaultFreshPeriod"));
+}
+bool HybridHttp::getDigestAuth() {
+  this->beginCall();
+  return this->ck().get_DigestAuth();
+}
+void HybridHttp::setDigestAuth(bool value) {
+  this->beginCall();
+  this->ck().put_DigestAuth(value);
+}
+bool HybridHttp::getFetchFromCache() {
+  this->beginCall();
+  return this->ck().get_FetchFromCache();
+}
+void HybridHttp::setFetchFromCache(bool value) {
+  this->beginCall();
+  this->ck().put_FetchFromCache(value);
+}
+std::string HybridHttp::getFinalRedirectUrl() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_FinalRedirectUrl(_s);
+  return rt::stdString(_s);
+}
+bool HybridHttp::getFollowRedirects() {
+  this->beginCall();
+  return this->ck().get_FollowRedirects();
+}
+void HybridHttp::setFollowRedirects(bool value) {
+  this->beginCall();
+  this->ck().put_FollowRedirects(value);
+}
+double HybridHttp::getFreshnessAlgorithm() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_FreshnessAlgorithm());
+}
+void HybridHttp::setFreshnessAlgorithm(double value) {
+  this->beginCall();
+  this->ck().put_FreshnessAlgorithm(rt::toInt(value, "freshnessAlgorithm"));
+}
+double HybridHttp::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridHttp::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+bool HybridHttp::getIgnoreMustRevalidate() {
+  this->beginCall();
+  return this->ck().get_IgnoreMustRevalidate();
+}
+void HybridHttp::setIgnoreMustRevalidate(bool value) {
+  this->beginCall();
+  this->ck().put_IgnoreMustRevalidate(value);
+}
+bool HybridHttp::getIgnoreNoCache() {
+  this->beginCall();
+  return this->ck().get_IgnoreNoCache();
+}
+void HybridHttp::setIgnoreNoCache(bool value) {
+  this->beginCall();
+  this->ck().put_IgnoreNoCache(value);
+}
+bool HybridHttp::getKeepResponseBody() {
+  this->beginCall();
+  return this->ck().get_KeepResponseBody();
+}
+void HybridHttp::setKeepResponseBody(bool value) {
+  this->beginCall();
+  this->ck().put_KeepResponseBody(value);
+}
+double HybridHttp::getLmFactor() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_LMFactor());
+}
+void HybridHttp::setLmFactor(double value) {
+  this->beginCall();
+  this->ck().put_LMFactor(rt::toInt(value, "lmFactor"));
+}
+std::string HybridHttp::getLastContentType() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastContentType(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttp::getLastHeader() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastHeader(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttp::getLastModDate() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastModDate(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttp::getLastResponseBody() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastResponseBody(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttp::getLastResponseHeader() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastResponseHeader(_s);
+  return rt::stdString(_s);
+}
+double HybridHttp::getLastStatus() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_LastStatus());
+}
+std::string HybridHttp::getLogin() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Login(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setLogin(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "login");
+  this->ck().put_Login(value.c_str());
+}
+std::string HybridHttp::getLoginDomain() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LoginDomain(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setLoginDomain(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "loginDomain");
+  this->ck().put_LoginDomain(value.c_str());
+}
+double HybridHttp::getMaxConnections() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_MaxConnections());
+}
+void HybridHttp::setMaxConnections(double value) {
+  this->beginCall();
+  this->ck().put_MaxConnections(rt::toInt(value, "maxConnections"));
+}
+double HybridHttp::getMaxFreshPeriod() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_MaxFreshPeriod());
+}
+void HybridHttp::setMaxFreshPeriod(double value) {
+  this->beginCall();
+  this->ck().put_MaxFreshPeriod(rt::toInt(value, "maxFreshPeriod"));
+}
+double HybridHttp::getMaxResponseSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_MaxResponseSize());
+}
+void HybridHttp::setMaxResponseSize(double value) {
+  this->beginCall();
+  this->ck().put_MaxResponseSize(rt::toULong(value, "maxResponseSize"));
+}
+double HybridHttp::getMaxUrlLen() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_MaxUrlLen());
+}
+void HybridHttp::setMaxUrlLen(double value) {
+  this->beginCall();
+  this->ck().put_MaxUrlLen(rt::toInt(value, "maxUrlLen"));
+}
+double HybridHttp::getMinFreshPeriod() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_MinFreshPeriod());
+}
+void HybridHttp::setMinFreshPeriod(double value) {
+  this->beginCall();
+  this->ck().put_MinFreshPeriod(rt::toInt(value, "minFreshPeriod"));
+}
+bool HybridHttp::getNegotiateAuth() {
+  this->beginCall();
+  return this->ck().get_NegotiateAuth();
+}
+void HybridHttp::setNegotiateAuth(bool value) {
+  this->beginCall();
+  this->ck().put_NegotiateAuth(value);
+}
+bool HybridHttp::getNtlmAuth() {
+  this->beginCall();
+  return this->ck().get_NtlmAuth();
+}
+void HybridHttp::setNtlmAuth(bool value) {
+  this->beginCall();
+  this->ck().put_NtlmAuth(value);
+}
+double HybridHttp::getNumCacheLevels() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumCacheLevels());
+}
+void HybridHttp::setNumCacheLevels(double value) {
+  this->beginCall();
+  this->ck().put_NumCacheLevels(rt::toInt(value, "numCacheLevels"));
+}
+double HybridHttp::getNumCacheRoots() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumCacheRoots());
+}
+bool HybridHttp::getOAuth1() {
+  this->beginCall();
+  return this->ck().get_OAuth1();
+}
+void HybridHttp::setOAuth1(bool value) {
+  this->beginCall();
+  this->ck().put_OAuth1(value);
+}
+std::string HybridHttp::getOAuthCallback() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OAuthCallback(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setOAuthCallback(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oAuthCallback");
+  this->ck().put_OAuthCallback(value.c_str());
+}
+std::string HybridHttp::getOAuthConsumerKey() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OAuthConsumerKey(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setOAuthConsumerKey(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oAuthConsumerKey");
+  this->ck().put_OAuthConsumerKey(value.c_str());
+}
+std::string HybridHttp::getOAuthConsumerSecret() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OAuthConsumerSecret(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setOAuthConsumerSecret(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oAuthConsumerSecret");
+  this->ck().put_OAuthConsumerSecret(value.c_str());
+}
+std::string HybridHttp::getOAuthRealm() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OAuthRealm(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setOAuthRealm(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oAuthRealm");
+  this->ck().put_OAuthRealm(value.c_str());
+}
+std::string HybridHttp::getOAuthSigMethod() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OAuthSigMethod(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setOAuthSigMethod(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oAuthSigMethod");
+  this->ck().put_OAuthSigMethod(value.c_str());
+}
+std::string HybridHttp::getOAuthToken() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OAuthToken(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setOAuthToken(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oAuthToken");
+  this->ck().put_OAuthToken(value.c_str());
+}
+std::string HybridHttp::getOAuthTokenSecret() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OAuthTokenSecret(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setOAuthTokenSecret(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oAuthTokenSecret");
+  this->ck().put_OAuthTokenSecret(value.c_str());
+}
+std::string HybridHttp::getOAuthVerifier() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OAuthVerifier(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setOAuthVerifier(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oAuthVerifier");
+  this->ck().put_OAuthVerifier(value.c_str());
+}
+std::string HybridHttp::getPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Password(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "password");
+  this->ck().put_Password(value.c_str());
+}
+double HybridHttp::getPercentDoneScale() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_PercentDoneScale());
+}
+void HybridHttp::setPercentDoneScale(double value) {
+  this->beginCall();
+  this->ck().put_PercentDoneScale(rt::toInt(value, "percentDoneScale"));
+}
+bool HybridHttp::getPreferIpv6() {
+  this->beginCall();
+  return this->ck().get_PreferIpv6();
+}
+void HybridHttp::setPreferIpv6(bool value) {
+  this->beginCall();
+  this->ck().put_PreferIpv6(value);
+}
+std::string HybridHttp::getProxyAuthMethod() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ProxyAuthMethod(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setProxyAuthMethod(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "proxyAuthMethod");
+  this->ck().put_ProxyAuthMethod(value.c_str());
+}
+std::string HybridHttp::getProxyDomain() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ProxyDomain(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setProxyDomain(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "proxyDomain");
+  this->ck().put_ProxyDomain(value.c_str());
+}
+std::string HybridHttp::getProxyLogin() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ProxyLogin(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setProxyLogin(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "proxyLogin");
+  this->ck().put_ProxyLogin(value.c_str());
+}
+std::string HybridHttp::getProxyLoginDomain() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ProxyLoginDomain(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setProxyLoginDomain(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "proxyLoginDomain");
+  this->ck().put_ProxyLoginDomain(value.c_str());
+}
+std::string HybridHttp::getProxyPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ProxyPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setProxyPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "proxyPassword");
+  this->ck().put_ProxyPassword(value.c_str());
+}
+double HybridHttp::getProxyPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ProxyPort());
+}
+void HybridHttp::setProxyPort(double value) {
+  this->beginCall();
+  this->ck().put_ProxyPort(rt::toInt(value, "proxyPort"));
+}
+double HybridHttp::getReadTimeout() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ReadTimeout());
+}
+void HybridHttp::setReadTimeout(double value) {
+  this->beginCall();
+  this->ck().put_ReadTimeout(rt::toInt(value, "readTimeout"));
+}
+std::string HybridHttp::getRedirectVerb() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_RedirectVerb(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setRedirectVerb(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "redirectVerb");
+  this->ck().put_RedirectVerb(value.c_str());
+}
+bool HybridHttp::getRequireSslCertVerify() {
+  this->beginCall();
+  return this->ck().get_RequireSslCertVerify();
+}
+void HybridHttp::setRequireSslCertVerify(bool value) {
+  this->beginCall();
+  this->ck().put_RequireSslCertVerify(value);
+}
+std::string HybridHttp::getRequiredContentType() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_RequiredContentType(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setRequiredContentType(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "requiredContentType");
+  this->ck().put_RequiredContentType(value.c_str());
+}
+bool HybridHttp::getSaveCookies() {
+  this->beginCall();
+  return this->ck().get_SaveCookies();
+}
+void HybridHttp::setSaveCookies(bool value) {
+  this->beginCall();
+  this->ck().put_SaveCookies(value);
+}
+double HybridHttp::getSendBufferSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SendBufferSize());
+}
+void HybridHttp::setSendBufferSize(double value) {
+  this->beginCall();
+  this->ck().put_SendBufferSize(rt::toInt(value, "sendBufferSize"));
+}
+bool HybridHttp::getSendCookies() {
+  this->beginCall();
+  return this->ck().get_SendCookies();
+}
+void HybridHttp::setSendCookies(bool value) {
+  this->beginCall();
+  this->ck().put_SendCookies(value);
+}
+std::string HybridHttp::getSessionLogFilename() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SessionLogFilename(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setSessionLogFilename(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sessionLogFilename");
+  this->ck().put_SessionLogFilename(value.c_str());
+}
+double HybridHttp::getSoRcvBuf() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SoRcvBuf());
+}
+void HybridHttp::setSoRcvBuf(double value) {
+  this->beginCall();
+  this->ck().put_SoRcvBuf(rt::toInt(value, "soRcvBuf"));
+}
+double HybridHttp::getSoSndBuf() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SoSndBuf());
+}
+void HybridHttp::setSoSndBuf(double value) {
+  this->beginCall();
+  this->ck().put_SoSndBuf(rt::toInt(value, "soSndBuf"));
+}
+std::string HybridHttp::getSocksHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setSocksHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksHostname");
+  this->ck().put_SocksHostname(value.c_str());
+}
+std::string HybridHttp::getSocksPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setSocksPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksPassword");
+  this->ck().put_SocksPassword(value.c_str());
+}
+double HybridHttp::getSocksPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SocksPort());
+}
+void HybridHttp::setSocksPort(double value) {
+  this->beginCall();
+  this->ck().put_SocksPort(rt::toInt(value, "socksPort"));
+}
+std::string HybridHttp::getSocksUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksUsername(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setSocksUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksUsername");
+  this->ck().put_SocksUsername(value.c_str());
+}
+double HybridHttp::getSocksVersion() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SocksVersion());
+}
+void HybridHttp::setSocksVersion(double value) {
+  this->beginCall();
+  this->ck().put_SocksVersion(rt::toInt(value, "socksVersion"));
+}
+std::string HybridHttp::getSslAllowedCiphers() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SslAllowedCiphers(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setSslAllowedCiphers(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sslAllowedCiphers");
+  this->ck().put_SslAllowedCiphers(value.c_str());
+}
+std::string HybridHttp::getSslProtocol() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SslProtocol(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setSslProtocol(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sslProtocol");
+  this->ck().put_SslProtocol(value.c_str());
+}
+std::string HybridHttp::getStreamResponseBodyPath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_StreamResponseBodyPath(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setStreamResponseBodyPath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "streamResponseBodyPath");
+  this->ck().put_StreamResponseBodyPath(value.c_str());
+}
+std::string HybridHttp::getTlsCipherSuite() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TlsCipherSuite(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttp::getTlsPinSet() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TlsPinSet(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setTlsPinSet(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "tlsPinSet");
+  this->ck().put_TlsPinSet(value.c_str());
+}
+std::string HybridHttp::getTlsVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TlsVersion(_s);
+  return rt::stdString(_s);
+}
+bool HybridHttp::getUpdateCache() {
+  this->beginCall();
+  return this->ck().get_UpdateCache();
+}
+void HybridHttp::setUpdateCache(bool value) {
+  this->beginCall();
+  this->ck().put_UpdateCache(value);
+}
+bool HybridHttp::getUseIEProxy() {
+  this->beginCall();
+  return this->ck().get_UseIEProxy();
+}
+void HybridHttp::setUseIEProxy(bool value) {
+  this->beginCall();
+  this->ck().put_UseIEProxy(value);
+}
+std::string HybridHttp::getUserAgent() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UserAgent(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setUserAgent(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "userAgent");
+  this->ck().put_UserAgent(value.c_str());
+}
+bool HybridHttp::getWasRedirected() {
+  this->beginCall();
+  return this->ck().get_WasRedirected();
+}
+bool HybridHttp::getAllowHeaderFolding() {
+  this->beginCall();
+  return this->ck().get_AllowHeaderFolding();
+}
+void HybridHttp::setAllowHeaderFolding(bool value) {
+  this->beginCall();
+  this->ck().put_AllowHeaderFolding(value);
+}
+std::string HybridHttp::getAuthToken() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AuthToken(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setAuthToken(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "authToken");
+  this->ck().put_AuthToken(value.c_str());
+}
+std::string HybridHttp::getLastStatusText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastStatusText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttp::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+std::string HybridHttp::getSniHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SniHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setSniHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sniHostname");
+  this->ck().put_SniHostname(value.c_str());
+}
+bool HybridHttp::getProxyDirectTls() {
+  this->beginCall();
+  return this->ck().get_ProxyDirectTls();
+}
+void HybridHttp::setProxyDirectTls(bool value) {
+  this->beginCall();
+  this->ck().put_ProxyDirectTls(value);
+}
+std::string HybridHttp::getAuthSignature() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AuthSignature(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setAuthSignature(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "authSignature");
+  this->ck().put_AuthSignature(value.c_str());
+}
+bool HybridHttp::getOAuthBodyHash() {
+  this->beginCall();
+  return this->ck().get_OAuthBodyHash();
+}
+void HybridHttp::setOAuthBodyHash(bool value) {
+  this->beginCall();
+  this->ck().put_OAuthBodyHash(value);
+}
+bool HybridHttp::getLastFromCache() {
+  this->beginCall();
+  return this->ck().get_LastFromCache();
+}
+bool HybridHttp::getReceivedCertReq() {
+  this->beginCall();
+  return this->ck().get_ReceivedCertReq();
+}
+std::string HybridHttp::getAwsSessionToken() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AwsSessionToken(_s);
+  return rt::stdString(_s);
+}
+void HybridHttp::setAwsSessionToken(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "awsSessionToken");
+  this->ck().put_AwsSessionToken(value.c_str());
+}
+bool HybridHttp::getRequireHostnameMatch() {
+  this->beginCall();
+  return this->ck().get_RequireHostnameMatch();
+}
+void HybridHttp::setRequireHostnameMatch(bool value) {
+  this->beginCall();
+  this->ck().put_RequireHostnameMatch(value);
+}
+bool HybridHttp::getEnableSecrets() {
+  this->beginCall();
+  return this->ck().get_EnableSecrets();
+}
+void HybridHttp::setEnableSecrets(bool value) {
+  this->beginCall();
+  this->ck().put_EnableSecrets(value);
+}
+
+// ---- Methods ----
+
+void HybridHttp::addCacheRoot(const std::string& dir) {
+  this->beginCall();
+  addCacheRoot_impl(dir);
+}
+void HybridHttp::addCacheRoot_impl(const std::string& dir) {
+  rt::checkNoNul(dir, "dir");
+  this->ck().AddCacheRoot(dir.c_str());
+}
+
+void HybridHttp::closeAllConnections() {
+  this->beginCall();
+  closeAllConnections_impl();
+}
+void HybridHttp::closeAllConnections_impl() {
+  if (!this->ck().CloseAllConnections()) throw this->fail("closeAllConnections");
+}
+std::shared_ptr<Promise<void>> HybridHttp::closeAllConnectionsAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Http.closeAllConnectionsAsync", std::move(_parts), [_self]() {
+    _self->closeAllConnections_impl();
+  });
+}
+
+void HybridHttp::dnsCacheClear() {
+  this->beginCall();
+  dnsCacheClear_impl();
+}
+void HybridHttp::dnsCacheClear_impl() {
+  this->ck().DnsCacheClear();
+}
+
+void HybridHttp::download(const std::string& url, const std::string& localFilePath) {
+  this->beginCall();
+  download_impl(url, localFilePath);
+}
+void HybridHttp::download_impl(const std::string& url, const std::string& localFilePath) {
+  rt::checkNoNul(url, "url");
+  rt::checkNoNul(localFilePath, "localFilePath");
+  if (!this->ck().Download(url.c_str(), localFilePath.c_str())) throw this->fail("download");
+}
+std::shared_ptr<Promise<void>> HybridHttp::downloadAsync(const std::string& url, const std::string& localFilePath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Http.downloadAsync", std::move(_parts), [_self, url, localFilePath]() {
+    _self->download_impl(url, localFilePath);
+  });
+}
+
+void HybridHttp::downloadAppend(const std::string& url, const std::string& appendToPath) {
+  this->beginCall();
+  downloadAppend_impl(url, appendToPath);
+}
+void HybridHttp::downloadAppend_impl(const std::string& url, const std::string& appendToPath) {
+  rt::checkNoNul(url, "url");
+  rt::checkNoNul(appendToPath, "appendToPath");
+  if (!this->ck().DownloadAppend(url.c_str(), appendToPath.c_str())) throw this->fail("downloadAppend");
+}
+std::shared_ptr<Promise<void>> HybridHttp::downloadAppendAsync(const std::string& url, const std::string& appendToPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Http.downloadAppendAsync", std::move(_parts), [_self, url, appendToPath]() {
+    _self->downloadAppend_impl(url, appendToPath);
+  });
+}
+
+std::string HybridHttp::downloadHash(const std::string& url, const std::string& hashAlgorithm, const std::string& encoding) {
+  this->beginCall();
+  return downloadHash_impl(url, hashAlgorithm, encoding);
+}
+std::string HybridHttp::downloadHash_impl(const std::string& url, const std::string& hashAlgorithm, const std::string& encoding) {
+  rt::checkNoNul(url, "url");
+  rt::checkNoNul(hashAlgorithm, "hashAlgorithm");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().DownloadHash(url.c_str(), hashAlgorithm.c_str(), encoding.c_str(), _out)) throw this->fail("downloadHash");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridHttp::downloadHashAsync(const std::string& url, const std::string& hashAlgorithm, const std::string& encoding) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Http.downloadHashAsync", std::move(_parts), [_self, url, hashAlgorithm, encoding]() {
+    return _self->downloadHash_impl(url, hashAlgorithm, encoding);
+  });
+}
+
+std::string HybridHttp::extractMetaRefreshUrl(const std::string& htmlContent) {
+  this->beginCall();
+  return extractMetaRefreshUrl_impl(htmlContent);
+}
+std::string HybridHttp::extractMetaRefreshUrl_impl(const std::string& htmlContent) {
+  rt::checkNoNul(htmlContent, "htmlContent");
+  CkString _out;
+  if (!this->ck().ExtractMetaRefreshUrl(htmlContent.c_str(), _out)) throw this->fail("extractMetaRefreshUrl");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttp::gSvcOauthAccessToken(const std::string& iss, const std::string& scope, const std::string& subEmail, double numSec, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  return gSvcOauthAccessToken_impl(iss, scope, subEmail, numSec, cert);
+}
+std::string HybridHttp::gSvcOauthAccessToken_impl(const std::string& iss, const std::string& scope, const std::string& subEmail, double numSec, const std::shared_ptr<HybridCertSpec>& cert) {
+  rt::checkNoNul(iss, "iss");
+  rt::checkNoNul(scope, "scope");
+  rt::checkNoNul(subEmail, "subEmail");
+  CkString _out;
+  if (!this->ck().G_SvcOauthAccessToken(iss.c_str(), scope.c_str(), subEmail.c_str(), rt::toInt(numSec, "numSec"), rt::implOf<HybridCert>(cert, "cert").ck(), _out)) throw this->fail("gSvcOauthAccessToken");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridHttp::gSvcOauthAccessTokenAsync(const std::string& iss, const std::string& scope, const std::string& subEmail, double numSec, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(cert);
+  return rt::runAsync<std::string>("Http.gSvcOauthAccessTokenAsync", std::move(_parts), [_self, iss, scope, subEmail, numSec, cert]() {
+    return _self->gSvcOauthAccessToken_impl(iss, scope, subEmail, numSec, cert);
+  });
+}
+
+std::string HybridHttp::gSvcOauthAccessToken2(const std::shared_ptr<HybridHashtableSpec>& claimParams, double numSec, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  return gSvcOauthAccessToken2_impl(claimParams, numSec, cert);
+}
+std::string HybridHttp::gSvcOauthAccessToken2_impl(const std::shared_ptr<HybridHashtableSpec>& claimParams, double numSec, const std::shared_ptr<HybridCertSpec>& cert) {
+  CkString _out;
+  if (!this->ck().G_SvcOauthAccessToken2(rt::implOf<HybridHashtable>(claimParams, "claimParams").ck(), rt::toInt(numSec, "numSec"), rt::implOf<HybridCert>(cert, "cert").ck(), _out)) throw this->fail("gSvcOauthAccessToken2");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridHttp::gSvcOauthAccessToken2Async(const std::shared_ptr<HybridHashtableSpec>& claimParams, double numSec, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(claimParams);
+  _parts.push_back(cert);
+  return rt::runAsync<std::string>("Http.gSvcOauthAccessToken2Async", std::move(_parts), [_self, claimParams, numSec, cert]() {
+    return _self->gSvcOauthAccessToken2_impl(claimParams, numSec, cert);
+  });
+}
+
+std::string HybridHttp::genTimeStamp() {
+  this->beginCall();
+  return genTimeStamp_impl();
+}
+std::string HybridHttp::genTimeStamp_impl() {
+  CkString _out;
+  if (!this->ck().GenTimeStamp(_out)) throw this->fail("genTimeStamp");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttp::getCacheRoot(double index) {
+  this->beginCall();
+  return getCacheRoot_impl(index);
+}
+std::string HybridHttp::getCacheRoot_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetCacheRoot(rt::toInt(index, "index"), _out)) throw this->fail("getCacheRoot");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttp::getCookieXml(const std::string& domain) {
+  this->beginCall();
+  return getCookieXml_impl(domain);
+}
+std::string HybridHttp::getCookieXml_impl(const std::string& domain) {
+  rt::checkNoNul(domain, "domain");
+  CkString _out;
+  if (!this->ck().GetCookieXml(domain.c_str(), _out)) throw this->fail("getCookieXml");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttp::getDomain(const std::string& url) {
+  this->beginCall();
+  return getDomain_impl(url);
+}
+std::string HybridHttp::getDomain_impl(const std::string& url) {
+  rt::checkNoNul(url, "url");
+  CkString _out;
+  if (!this->ck().GetDomain(url.c_str(), _out)) throw this->fail("getDomain");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttp::getRequestHeader(const std::string& name) {
+  this->beginCall();
+  return getRequestHeader_impl(name);
+}
+std::string HybridHttp::getRequestHeader_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  CkString _out;
+  if (!this->ck().GetRequestHeader(name.c_str(), _out)) throw this->fail("getRequestHeader");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttp::getUrlPath(const std::string& url) {
+  this->beginCall();
+  return getUrlPath_impl(url);
+}
+std::string HybridHttp::getUrlPath_impl(const std::string& url) {
+  rt::checkNoNul(url, "url");
+  CkString _out;
+  if (!this->ck().GetUrlPath(url.c_str(), _out)) throw this->fail("getUrlPath");
+  return rt::stdString(_out);
+}
+
+bool HybridHttp::hasRequestHeader(const std::string& name) {
+  this->beginCall();
+  return hasRequestHeader_impl(name);
+}
+bool HybridHttp::hasRequestHeader_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  return this->ck().HasRequestHeader(name.c_str());
+}
+
+std::string HybridHttp::quickDeleteStr(const std::string& url) {
+  this->beginCall();
+  return quickDeleteStr_impl(url);
+}
+std::string HybridHttp::quickDeleteStr_impl(const std::string& url) {
+  rt::checkNoNul(url, "url");
+  CkString _out;
+  if (!this->ck().QuickDeleteStr(url.c_str(), _out)) throw this->fail("quickDeleteStr");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridHttp::quickDeleteStrAsync(const std::string& url) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Http.quickDeleteStrAsync", std::move(_parts), [_self, url]() {
+    return _self->quickDeleteStr_impl(url);
+  });
+}
+
+std::string HybridHttp::quickGetStr(const std::string& url) {
+  this->beginCall();
+  return quickGetStr_impl(url);
+}
+std::string HybridHttp::quickGetStr_impl(const std::string& url) {
+  rt::checkNoNul(url, "url");
+  CkString _out;
+  if (!this->ck().QuickGetStr(url.c_str(), _out)) throw this->fail("quickGetStr");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridHttp::quickGetStrAsync(const std::string& url) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Http.quickGetStrAsync", std::move(_parts), [_self, url]() {
+    return _self->quickGetStr_impl(url);
+  });
+}
+
+void HybridHttp::removeRequestHeader(const std::string& name) {
+  this->beginCall();
+  removeRequestHeader_impl(name);
+}
+void HybridHttp::removeRequestHeader_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  this->ck().RemoveRequestHeader(name.c_str());
+}
+
+std::string HybridHttp::renderGet(const std::string& url) {
+  this->beginCall();
+  return renderGet_impl(url);
+}
+std::string HybridHttp::renderGet_impl(const std::string& url) {
+  rt::checkNoNul(url, "url");
+  CkString _out;
+  if (!this->ck().RenderGet(url.c_str(), _out)) throw this->fail("renderGet");
+  return rt::stdString(_out);
+}
+
+void HybridHttp::resumeDownload(const std::string& url, const std::string& targetFilename) {
+  this->beginCall();
+  resumeDownload_impl(url, targetFilename);
+}
+void HybridHttp::resumeDownload_impl(const std::string& url, const std::string& targetFilename) {
+  rt::checkNoNul(url, "url");
+  rt::checkNoNul(targetFilename, "targetFilename");
+  if (!this->ck().ResumeDownload(url.c_str(), targetFilename.c_str())) throw this->fail("resumeDownload");
+}
+std::shared_ptr<Promise<void>> HybridHttp::resumeDownloadAsync(const std::string& url, const std::string& targetFilename) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Http.resumeDownloadAsync", std::move(_parts), [_self, url, targetFilename]() {
+    _self->resumeDownload_impl(url, targetFilename);
+  });
+}
+
+void HybridHttp::s3CreateBucket(const std::string& bucketPath) {
+  this->beginCall();
+  s3CreateBucket_impl(bucketPath);
+}
+void HybridHttp::s3CreateBucket_impl(const std::string& bucketPath) {
+  rt::checkNoNul(bucketPath, "bucketPath");
+  if (!this->ck().S3_CreateBucket(bucketPath.c_str())) throw this->fail("s3CreateBucket");
+}
+std::shared_ptr<Promise<void>> HybridHttp::s3CreateBucketAsync(const std::string& bucketPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Http.s3CreateBucketAsync", std::move(_parts), [_self, bucketPath]() {
+    _self->s3CreateBucket_impl(bucketPath);
+  });
+}
+
+void HybridHttp::s3DeleteBucket(const std::string& bucketPath) {
+  this->beginCall();
+  s3DeleteBucket_impl(bucketPath);
+}
+void HybridHttp::s3DeleteBucket_impl(const std::string& bucketPath) {
+  rt::checkNoNul(bucketPath, "bucketPath");
+  if (!this->ck().S3_DeleteBucket(bucketPath.c_str())) throw this->fail("s3DeleteBucket");
+}
+std::shared_ptr<Promise<void>> HybridHttp::s3DeleteBucketAsync(const std::string& bucketPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Http.s3DeleteBucketAsync", std::move(_parts), [_self, bucketPath]() {
+    _self->s3DeleteBucket_impl(bucketPath);
+  });
+}
+
+void HybridHttp::s3DeleteObject(const std::string& bucketPath, const std::string& objectName) {
+  this->beginCall();
+  s3DeleteObject_impl(bucketPath, objectName);
+}
+void HybridHttp::s3DeleteObject_impl(const std::string& bucketPath, const std::string& objectName) {
+  rt::checkNoNul(bucketPath, "bucketPath");
+  rt::checkNoNul(objectName, "objectName");
+  if (!this->ck().S3_DeleteObject(bucketPath.c_str(), objectName.c_str())) throw this->fail("s3DeleteObject");
+}
+std::shared_ptr<Promise<void>> HybridHttp::s3DeleteObjectAsync(const std::string& bucketPath, const std::string& objectName) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Http.s3DeleteObjectAsync", std::move(_parts), [_self, bucketPath, objectName]() {
+    _self->s3DeleteObject_impl(bucketPath, objectName);
+  });
+}
+
+void HybridHttp::s3DownloadFile(const std::string& bucketPath, const std::string& objectName, const std::string& localFilePath) {
+  this->beginCall();
+  s3DownloadFile_impl(bucketPath, objectName, localFilePath);
+}
+void HybridHttp::s3DownloadFile_impl(const std::string& bucketPath, const std::string& objectName, const std::string& localFilePath) {
+  rt::checkNoNul(bucketPath, "bucketPath");
+  rt::checkNoNul(objectName, "objectName");
+  rt::checkNoNul(localFilePath, "localFilePath");
+  if (!this->ck().S3_DownloadFile(bucketPath.c_str(), objectName.c_str(), localFilePath.c_str())) throw this->fail("s3DownloadFile");
+}
+std::shared_ptr<Promise<void>> HybridHttp::s3DownloadFileAsync(const std::string& bucketPath, const std::string& objectName, const std::string& localFilePath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Http.s3DownloadFileAsync", std::move(_parts), [_self, bucketPath, objectName, localFilePath]() {
+    _self->s3DownloadFile_impl(bucketPath, objectName, localFilePath);
+  });
+}
+
+std::string HybridHttp::s3DownloadString(const std::string& bucketPath, const std::string& objectName, const std::string& charset) {
+  this->beginCall();
+  return s3DownloadString_impl(bucketPath, objectName, charset);
+}
+std::string HybridHttp::s3DownloadString_impl(const std::string& bucketPath, const std::string& objectName, const std::string& charset) {
+  rt::checkNoNul(bucketPath, "bucketPath");
+  rt::checkNoNul(objectName, "objectName");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().S3_DownloadString(bucketPath.c_str(), objectName.c_str(), charset.c_str(), _out)) throw this->fail("s3DownloadString");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridHttp::s3DownloadStringAsync(const std::string& bucketPath, const std::string& objectName, const std::string& charset) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Http.s3DownloadStringAsync", std::move(_parts), [_self, bucketPath, objectName, charset]() {
+    return _self->s3DownloadString_impl(bucketPath, objectName, charset);
+  });
+}
+
+double HybridHttp::s3FileExists(const std::string& bucketPath, const std::string& objectName) {
+  this->beginCall();
+  return s3FileExists_impl(bucketPath, objectName);
+}
+double HybridHttp::s3FileExists_impl(const std::string& bucketPath, const std::string& objectName) {
+  rt::checkNoNul(bucketPath, "bucketPath");
+  rt::checkNoNul(objectName, "objectName");
+  return static_cast<double>(this->ck().S3_FileExists(bucketPath.c_str(), objectName.c_str()));
+}
+std::shared_ptr<Promise<double>> HybridHttp::s3FileExistsAsync(const std::string& bucketPath, const std::string& objectName) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Http.s3FileExistsAsync", std::move(_parts), [_self, bucketPath, objectName]() {
+    return _self->s3FileExists_impl(bucketPath, objectName);
+  });
+}
+
+std::string HybridHttp::s3ListBucketObjects(const std::string& bucketPath) {
+  this->beginCall();
+  return s3ListBucketObjects_impl(bucketPath);
+}
+std::string HybridHttp::s3ListBucketObjects_impl(const std::string& bucketPath) {
+  rt::checkNoNul(bucketPath, "bucketPath");
+  CkString _out;
+  if (!this->ck().S3_ListBucketObjects(bucketPath.c_str(), _out)) throw this->fail("s3ListBucketObjects");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridHttp::s3ListBucketObjectsAsync(const std::string& bucketPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Http.s3ListBucketObjectsAsync", std::move(_parts), [_self, bucketPath]() {
+    return _self->s3ListBucketObjects_impl(bucketPath);
+  });
+}
+
+std::string HybridHttp::s3ListBuckets() {
+  this->beginCall();
+  return s3ListBuckets_impl();
+}
+std::string HybridHttp::s3ListBuckets_impl() {
+  CkString _out;
+  if (!this->ck().S3_ListBuckets(_out)) throw this->fail("s3ListBuckets");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridHttp::s3ListBucketsAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Http.s3ListBucketsAsync", std::move(_parts), [_self]() {
+    return _self->s3ListBuckets_impl();
+  });
+}
+
+void HybridHttp::s3UploadFile(const std::string& localFilePath, const std::string& contentType, const std::string& bucketPath, const std::string& objectName) {
+  this->beginCall();
+  s3UploadFile_impl(localFilePath, contentType, bucketPath, objectName);
+}
+void HybridHttp::s3UploadFile_impl(const std::string& localFilePath, const std::string& contentType, const std::string& bucketPath, const std::string& objectName) {
+  rt::checkNoNul(localFilePath, "localFilePath");
+  rt::checkNoNul(contentType, "contentType");
+  rt::checkNoNul(bucketPath, "bucketPath");
+  rt::checkNoNul(objectName, "objectName");
+  if (!this->ck().S3_UploadFile(localFilePath.c_str(), contentType.c_str(), bucketPath.c_str(), objectName.c_str())) throw this->fail("s3UploadFile");
+}
+std::shared_ptr<Promise<void>> HybridHttp::s3UploadFileAsync(const std::string& localFilePath, const std::string& contentType, const std::string& bucketPath, const std::string& objectName) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Http.s3UploadFileAsync", std::move(_parts), [_self, localFilePath, contentType, bucketPath, objectName]() {
+    _self->s3UploadFile_impl(localFilePath, contentType, bucketPath, objectName);
+  });
+}
+
+void HybridHttp::s3UploadString(const std::string& objectContent, const std::string& charset, const std::string& contentType, const std::string& bucketPath, const std::string& objectName) {
+  this->beginCall();
+  s3UploadString_impl(objectContent, charset, contentType, bucketPath, objectName);
+}
+void HybridHttp::s3UploadString_impl(const std::string& objectContent, const std::string& charset, const std::string& contentType, const std::string& bucketPath, const std::string& objectName) {
+  rt::checkNoNul(objectContent, "objectContent");
+  rt::checkNoNul(charset, "charset");
+  rt::checkNoNul(contentType, "contentType");
+  rt::checkNoNul(bucketPath, "bucketPath");
+  rt::checkNoNul(objectName, "objectName");
+  if (!this->ck().S3_UploadString(objectContent.c_str(), charset.c_str(), contentType.c_str(), bucketPath.c_str(), objectName.c_str())) throw this->fail("s3UploadString");
+}
+std::shared_ptr<Promise<void>> HybridHttp::s3UploadStringAsync(const std::string& objectContent, const std::string& charset, const std::string& contentType, const std::string& bucketPath, const std::string& objectName) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Http.s3UploadStringAsync", std::move(_parts), [_self, objectContent, charset, contentType, bucketPath, objectName]() {
+    _self->s3UploadString_impl(objectContent, charset, contentType, bucketPath, objectName);
+  });
+}
+
+void HybridHttp::setCookieXml(const std::string& domain, const std::string& cookieXml) {
+  this->beginCall();
+  setCookieXml_impl(domain, cookieXml);
+}
+void HybridHttp::setCookieXml_impl(const std::string& domain, const std::string& cookieXml) {
+  rt::checkNoNul(domain, "domain");
+  rt::checkNoNul(cookieXml, "cookieXml");
+  if (!this->ck().SetCookieXml(domain.c_str(), cookieXml.c_str())) throw this->fail("setCookieXml");
+}
+
+void HybridHttp::setOAuthRsaKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  this->beginCall();
+  setOAuthRsaKey_impl(privKey);
+}
+void HybridHttp::setOAuthRsaKey_impl(const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  if (!this->ck().SetOAuthRsaKey(rt::implOf<HybridPrivateKey>(privKey, "privKey").ck())) throw this->fail("setOAuthRsaKey");
+}
+
+void HybridHttp::setRequestHeader(const std::string& headerFieldName, const std::string& headerFieldValue) {
+  this->beginCall();
+  setRequestHeader_impl(headerFieldName, headerFieldValue);
+}
+void HybridHttp::setRequestHeader_impl(const std::string& headerFieldName, const std::string& headerFieldValue) {
+  rt::checkNoNul(headerFieldName, "headerFieldName");
+  rt::checkNoNul(headerFieldValue, "headerFieldValue");
+  this->ck().SetRequestHeader(headerFieldName.c_str(), headerFieldValue.c_str());
+}
+
+void HybridHttp::setSslClientCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  setSslClientCert_impl(cert);
+}
+void HybridHttp::setSslClientCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().SetSslClientCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("setSslClientCert");
+}
+
+void HybridHttp::setSslClientCertPem(const std::string& pemDataOrPath, const std::string& pemPassword) {
+  this->beginCall();
+  setSslClientCertPem_impl(pemDataOrPath, pemPassword);
+}
+void HybridHttp::setSslClientCertPem_impl(const std::string& pemDataOrPath, const std::string& pemPassword) {
+  rt::checkNoNul(pemDataOrPath, "pemDataOrPath");
+  rt::checkNoNul(pemPassword, "pemPassword");
+  if (!this->ck().SetSslClientCertPem(pemDataOrPath.c_str(), pemPassword.c_str())) throw this->fail("setSslClientCertPem");
+}
+
+void HybridHttp::setSslClientCertPfx(const std::string& pfxPath, const std::string& pfxPassword) {
+  this->beginCall();
+  setSslClientCertPfx_impl(pfxPath, pfxPassword);
+}
+void HybridHttp::setSslClientCertPfx_impl(const std::string& pfxPath, const std::string& pfxPassword) {
+  rt::checkNoNul(pfxPath, "pfxPath");
+  rt::checkNoNul(pfxPassword, "pfxPassword");
+  if (!this->ck().SetSslClientCertPfx(pfxPath.c_str(), pfxPassword.c_str())) throw this->fail("setSslClientCertPfx");
+}
+
+void HybridHttp::sleepMs(double millisec) {
+  this->beginCall();
+  sleepMs_impl(millisec);
+}
+void HybridHttp::sleepMs_impl(double millisec) {
+  this->ck().SleepMs(rt::toInt(millisec, "millisec"));
+}
+
+std::string HybridHttp::urlDecode(const std::string& str) {
+  this->beginCall();
+  return urlDecode_impl(str);
+}
+std::string HybridHttp::urlDecode_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  CkString _out;
+  if (!this->ck().UrlDecode(str.c_str(), _out)) throw this->fail("urlDecode");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttp::urlEncode(const std::string& str) {
+  this->beginCall();
+  return urlEncode_impl(str);
+}
+std::string HybridHttp::urlEncode_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  CkString _out;
+  if (!this->ck().UrlEncode(str.c_str(), _out)) throw this->fail("urlEncode");
+  return rt::stdString(_out);
+}
+
+void HybridHttp::downloadBd(const std::string& url, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  downloadBd_impl(url, binData);
+}
+void HybridHttp::downloadBd_impl(const std::string& url, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  rt::checkNoNul(url, "url");
+  if (!this->ck().DownloadBd(url.c_str(), rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("downloadBd");
+}
+std::shared_ptr<Promise<void>> HybridHttp::downloadBdAsync(const std::string& url, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(binData);
+  return rt::runAsync<void>("Http.downloadBdAsync", std::move(_parts), [_self, url, binData]() {
+    _self->downloadBd_impl(url, binData);
+  });
+}
+
+void HybridHttp::downloadSb(const std::string& url, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  downloadSb_impl(url, charset, sb);
+}
+void HybridHttp::downloadSb_impl(const std::string& url, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  rt::checkNoNul(url, "url");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().DownloadSb(url.c_str(), charset.c_str(), rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("downloadSb");
+}
+std::shared_ptr<Promise<void>> HybridHttp::downloadSbAsync(const std::string& url, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sb);
+  return rt::runAsync<void>("Http.downloadSbAsync", std::move(_parts), [_self, url, charset, sb]() {
+    _self->downloadSb_impl(url, charset, sb);
+  });
+}
+
+void HybridHttp::quickGetSb(const std::string& url, const std::shared_ptr<HybridStringBuilderSpec>& sbContent) {
+  this->beginCall();
+  quickGetSb_impl(url, sbContent);
+}
+void HybridHttp::quickGetSb_impl(const std::string& url, const std::shared_ptr<HybridStringBuilderSpec>& sbContent) {
+  rt::checkNoNul(url, "url");
+  if (!this->ck().QuickGetSb(url.c_str(), rt::implOf<HybridStringBuilder>(sbContent, "sbContent").ck())) throw this->fail("quickGetSb");
+}
+std::shared_ptr<Promise<void>> HybridHttp::quickGetSbAsync(const std::string& url, const std::shared_ptr<HybridStringBuilderSpec>& sbContent) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sbContent);
+  return rt::runAsync<void>("Http.quickGetSbAsync", std::move(_parts), [_self, url, sbContent]() {
+    _self->quickGetSb_impl(url, sbContent);
+  });
+}
+
+void HybridHttp::quickGetBd(const std::string& url, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  quickGetBd_impl(url, binData);
+}
+void HybridHttp::quickGetBd_impl(const std::string& url, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  rt::checkNoNul(url, "url");
+  if (!this->ck().QuickGetBd(url.c_str(), rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("quickGetBd");
+}
+std::shared_ptr<Promise<void>> HybridHttp::quickGetBdAsync(const std::string& url, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(binData);
+  return rt::runAsync<void>("Http.quickGetBdAsync", std::move(_parts), [_self, url, binData]() {
+    _self->quickGetBd_impl(url, binData);
+  });
+}
+
+void HybridHttp::setUrlVar(const std::string& name, const std::string& value) {
+  this->beginCall();
+  setUrlVar_impl(name, value);
+}
+void HybridHttp::setUrlVar_impl(const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().SetUrlVar(name.c_str(), value.c_str())) throw this->fail("setUrlVar");
+}
+
+void HybridHttp::clearUrlVars() {
+  this->beginCall();
+  clearUrlVars_impl();
+}
+void HybridHttp::clearUrlVars_impl() {
+  this->ck().ClearUrlVars();
+}
+
+void HybridHttp::sharePointOnlineAuth(const std::string& siteUrl, const std::string& username, const std::shared_ptr<HybridSecureStringSpec>& password, const std::shared_ptr<HybridJsonObjectSpec>& extraInfo) {
+  this->beginCall();
+  sharePointOnlineAuth_impl(siteUrl, username, password, extraInfo);
+}
+void HybridHttp::sharePointOnlineAuth_impl(const std::string& siteUrl, const std::string& username, const std::shared_ptr<HybridSecureStringSpec>& password, const std::shared_ptr<HybridJsonObjectSpec>& extraInfo) {
+  rt::checkNoNul(siteUrl, "siteUrl");
+  rt::checkNoNul(username, "username");
+  if (!this->ck().SharePointOnlineAuth(siteUrl.c_str(), username.c_str(), rt::implOf<HybridSecureString>(password, "password").ck(), rt::implOf<HybridJsonObject>(extraInfo, "extraInfo").ck())) throw this->fail("sharePointOnlineAuth");
+}
+std::shared_ptr<Promise<void>> HybridHttp::sharePointOnlineAuthAsync(const std::string& siteUrl, const std::string& username, const std::shared_ptr<HybridSecureStringSpec>& password, const std::shared_ptr<HybridJsonObjectSpec>& extraInfo) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(password);
+  _parts.push_back(extraInfo);
+  return rt::runAsync<void>("Http.sharePointOnlineAuthAsync", std::move(_parts), [_self, siteUrl, username, password, extraInfo]() {
+    _self->sharePointOnlineAuth_impl(siteUrl, username, password, extraInfo);
+  });
+}
+
+void HybridHttp::resumeDownloadBd(const std::string& url, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  resumeDownloadBd_impl(url, binData);
+}
+void HybridHttp::resumeDownloadBd_impl(const std::string& url, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  rt::checkNoNul(url, "url");
+  if (!this->ck().ResumeDownloadBd(url.c_str(), rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("resumeDownloadBd");
+}
+std::shared_ptr<Promise<void>> HybridHttp::resumeDownloadBdAsync(const std::string& url, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(binData);
+  return rt::runAsync<void>("Http.resumeDownloadBdAsync", std::move(_parts), [_self, url, binData]() {
+    _self->resumeDownloadBd_impl(url, binData);
+  });
+}
+
+void HybridHttp::createTimestampRequest(const std::string& hashAlg, const std::string& hashVal, const std::string& reqPolicyOid, bool addNonce, bool reqTsaCert, const std::shared_ptr<HybridBinDataSpec>& timestampToken) {
+  this->beginCall();
+  createTimestampRequest_impl(hashAlg, hashVal, reqPolicyOid, addNonce, reqTsaCert, timestampToken);
+}
+void HybridHttp::createTimestampRequest_impl(const std::string& hashAlg, const std::string& hashVal, const std::string& reqPolicyOid, bool addNonce, bool reqTsaCert, const std::shared_ptr<HybridBinDataSpec>& timestampToken) {
+  rt::checkNoNul(hashAlg, "hashAlg");
+  rt::checkNoNul(hashVal, "hashVal");
+  rt::checkNoNul(reqPolicyOid, "reqPolicyOid");
+  if (!this->ck().CreateTimestampRequest(hashAlg.c_str(), hashVal.c_str(), reqPolicyOid.c_str(), addNonce, reqTsaCert, rt::implOf<HybridBinData>(timestampToken, "timestampToken").ck())) throw this->fail("createTimestampRequest");
+}
+
+double HybridHttp::verifyTimestampReply(const std::shared_ptr<HybridBinDataSpec>& timestampReply, const std::shared_ptr<HybridCertSpec>& tsaCert) {
+  this->beginCall();
+  return verifyTimestampReply_impl(timestampReply, tsaCert);
+}
+double HybridHttp::verifyTimestampReply_impl(const std::shared_ptr<HybridBinDataSpec>& timestampReply, const std::shared_ptr<HybridCertSpec>& tsaCert) {
+  return static_cast<double>(this->ck().VerifyTimestampReply(rt::implOf<HybridBinData>(timestampReply, "timestampReply").ck(), rt::implOf<HybridCert>(tsaCert, "tsaCert").ck()));
+}
+
+void HybridHttp::createOcspRequest(const std::shared_ptr<HybridJsonObjectSpec>& requestDetails, const std::shared_ptr<HybridBinDataSpec>& ocspRequest) {
+  this->beginCall();
+  createOcspRequest_impl(requestDetails, ocspRequest);
+}
+void HybridHttp::createOcspRequest_impl(const std::shared_ptr<HybridJsonObjectSpec>& requestDetails, const std::shared_ptr<HybridBinDataSpec>& ocspRequest) {
+  if (!this->ck().CreateOcspRequest(rt::implOf<HybridJsonObject>(requestDetails, "requestDetails").ck(), rt::implOf<HybridBinData>(ocspRequest, "ocspRequest").ck())) throw this->fail("createOcspRequest");
+}
+
+double HybridHttp::parseOcspReply(const std::shared_ptr<HybridBinDataSpec>& ocspReply, const std::shared_ptr<HybridJsonObjectSpec>& replyData) {
+  this->beginCall();
+  return parseOcspReply_impl(ocspReply, replyData);
+}
+double HybridHttp::parseOcspReply_impl(const std::shared_ptr<HybridBinDataSpec>& ocspReply, const std::shared_ptr<HybridJsonObjectSpec>& replyData) {
+  return static_cast<double>(this->ck().ParseOcspReply(rt::implOf<HybridBinData>(ocspReply, "ocspReply").ck(), rt::implOf<HybridJsonObject>(replyData, "replyData").ck()));
+}
+
+void HybridHttp::setSecurePassword(const std::shared_ptr<HybridSecureStringSpec>& password) {
+  this->beginCall();
+  setSecurePassword_impl(password);
+}
+void HybridHttp::setSecurePassword_impl(const std::shared_ptr<HybridSecureStringSpec>& password) {
+  if (!this->ck().SetSecurePassword(rt::implOf<HybridSecureString>(password, "password").ck())) throw this->fail("setSecurePassword");
+}
+
+void HybridHttp::s3UploadBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& contentType, const std::string& bucketPath, const std::string& objectName) {
+  this->beginCall();
+  s3UploadBd_impl(bd, contentType, bucketPath, objectName);
+}
+void HybridHttp::s3UploadBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& contentType, const std::string& bucketPath, const std::string& objectName) {
+  rt::checkNoNul(contentType, "contentType");
+  rt::checkNoNul(bucketPath, "bucketPath");
+  rt::checkNoNul(objectName, "objectName");
+  if (!this->ck().S3_UploadBd(rt::implOf<HybridBinData>(bd, "bd").ck(), contentType.c_str(), bucketPath.c_str(), objectName.c_str())) throw this->fail("s3UploadBd");
+}
+std::shared_ptr<Promise<void>> HybridHttp::s3UploadBdAsync(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& contentType, const std::string& bucketPath, const std::string& objectName) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bd);
+  return rt::runAsync<void>("Http.s3UploadBdAsync", std::move(_parts), [_self, bd, contentType, bucketPath, objectName]() {
+    _self->s3UploadBd_impl(bd, contentType, bucketPath, objectName);
+  });
+}
+
+void HybridHttp::s3DownloadBd(const std::string& bucketPath, const std::string& objectName, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  s3DownloadBd_impl(bucketPath, objectName, bd);
+}
+void HybridHttp::s3DownloadBd_impl(const std::string& bucketPath, const std::string& objectName, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(bucketPath, "bucketPath");
+  rt::checkNoNul(objectName, "objectName");
+  if (!this->ck().S3_DownloadBd(bucketPath.c_str(), objectName.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("s3DownloadBd");
+}
+std::shared_ptr<Promise<void>> HybridHttp::s3DownloadBdAsync(const std::string& bucketPath, const std::string& objectName, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bd);
+  return rt::runAsync<void>("Http.s3DownloadBdAsync", std::move(_parts), [_self, bucketPath, objectName, bd]() {
+    _self->s3DownloadBd_impl(bucketPath, objectName, bd);
+  });
+}
+
+void HybridHttp::clearHeaders() {
+  this->beginCall();
+  clearHeaders_impl();
+}
+void HybridHttp::clearHeaders_impl() {
+  this->ck().ClearHeaders();
+}
+
+std::string HybridHttp::s3GenPresignedUrl(const std::string& httpVerb, bool useHttps, const std::string& bucketName, const std::string& path, double numSecondsValid, const std::string& awsService) {
+  this->beginCall();
+  return s3GenPresignedUrl_impl(httpVerb, useHttps, bucketName, path, numSecondsValid, awsService);
+}
+std::string HybridHttp::s3GenPresignedUrl_impl(const std::string& httpVerb, bool useHttps, const std::string& bucketName, const std::string& path, double numSecondsValid, const std::string& awsService) {
+  rt::checkNoNul(httpVerb, "httpVerb");
+  rt::checkNoNul(bucketName, "bucketName");
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(awsService, "awsService");
+  CkString _out;
+  if (!this->ck().S3_GenPresignedUrl(httpVerb.c_str(), useHttps, bucketName.c_str(), path.c_str(), rt::toInt(numSecondsValid, "numSecondsValid"), awsService.c_str(), _out)) throw this->fail("s3GenPresignedUrl");
+  return rt::stdString(_out);
+}
+
+void HybridHttp::setSslCertRequirement(const std::string& reqName, const std::string& reqValue) {
+  this->beginCall();
+  setSslCertRequirement_impl(reqName, reqValue);
+}
+void HybridHttp::setSslCertRequirement_impl(const std::string& reqName, const std::string& reqValue) {
+  rt::checkNoNul(reqName, "reqName");
+  rt::checkNoNul(reqValue, "reqValue");
+  this->ck().SetSslCertRequirement(reqName.c_str(), reqValue.c_str());
+}
+
+double HybridHttp::ocspCheck(const std::string& domain, double port) {
+  this->beginCall();
+  return ocspCheck_impl(domain, port);
+}
+double HybridHttp::ocspCheck_impl(const std::string& domain, double port) {
+  rt::checkNoNul(domain, "domain");
+  return static_cast<double>(this->ck().OcspCheck(domain.c_str(), rt::toInt(port, "port")));
+}
+std::shared_ptr<Promise<double>> HybridHttp::ocspCheckAsync(const std::string& domain, double port) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Http.ocspCheckAsync", std::move(_parts), [_self, domain, port]() {
+    return _self->ocspCheck_impl(domain, port);
+  });
+}
+
+void HybridHttp::setAuthPrivateKey(const std::string& publicKeyId, const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  this->beginCall();
+  setAuthPrivateKey_impl(publicKeyId, privKey);
+}
+void HybridHttp::setAuthPrivateKey_impl(const std::string& publicKeyId, const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  rt::checkNoNul(publicKeyId, "publicKeyId");
+  if (!this->ck().SetAuthPrivateKey(publicKeyId.c_str(), rt::implOf<HybridPrivateKey>(privKey, "privKey").ck())) throw this->fail("setAuthPrivateKey");
+}
+
+void HybridHttp::setAuthTokenSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  setAuthTokenSb_impl(sb);
+}
+void HybridHttp::setAuthTokenSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().SetAuthTokenSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("setAuthTokenSb");
+}
+
+void HybridHttp::getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getLastJsonData_impl(json);
+}
+void HybridHttp::getLastJsonData_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->ck().GetLastJsonData(rt::implOf<HybridJsonObject>(json, "json").ck());
+}
+
+void HybridHttp::getServerCert(const std::string& domain, double port, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  getServerCert_impl(domain, port, cert);
+}
+void HybridHttp::getServerCert_impl(const std::string& domain, double port, const std::shared_ptr<HybridCertSpec>& cert) {
+  rt::checkNoNul(domain, "domain");
+  if (!this->ck().GetServerCert(domain.c_str(), rt::toInt(port, "port"), rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("getServerCert");
+}
+std::shared_ptr<Promise<void>> HybridHttp::getServerCertAsync(const std::string& domain, double port, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(cert);
+  return rt::runAsync<void>("Http.getServerCertAsync", std::move(_parts), [_self, domain, port, cert]() {
+    _self->getServerCert_impl(domain, port, cert);
+  });
+}
+
+void HybridHttp::httpBd(const std::string& verb, const std::string& url, const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& contentType, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  this->beginCall();
+  httpBd_impl(verb, url, bd, contentType, response);
+}
+void HybridHttp::httpBd_impl(const std::string& verb, const std::string& url, const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& contentType, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  rt::checkNoNul(verb, "verb");
+  rt::checkNoNul(url, "url");
+  rt::checkNoNul(contentType, "contentType");
+  if (!this->ck().HttpBd(verb.c_str(), url.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck(), contentType.c_str(), rt::implOf<HybridHttpResponse>(response, "response").ck())) throw this->fail("httpBd");
+}
+std::shared_ptr<Promise<void>> HybridHttp::httpBdAsync(const std::string& verb, const std::string& url, const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& contentType, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bd);
+  _parts.push_back(response);
+  return rt::runAsync<void>("Http.httpBdAsync", std::move(_parts), [_self, verb, url, bd, contentType, response]() {
+    _self->httpBd_impl(verb, url, bd, contentType, response);
+  });
+}
+
+void HybridHttp::httpNoBody(const std::string& verb, const std::string& url, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  this->beginCall();
+  httpNoBody_impl(verb, url, response);
+}
+void HybridHttp::httpNoBody_impl(const std::string& verb, const std::string& url, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  rt::checkNoNul(verb, "verb");
+  rt::checkNoNul(url, "url");
+  if (!this->ck().HttpNoBody(verb.c_str(), url.c_str(), rt::implOf<HybridHttpResponse>(response, "response").ck())) throw this->fail("httpNoBody");
+}
+std::shared_ptr<Promise<void>> HybridHttp::httpNoBodyAsync(const std::string& verb, const std::string& url, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(response);
+  return rt::runAsync<void>("Http.httpNoBodyAsync", std::move(_parts), [_self, verb, url, response]() {
+    _self->httpNoBody_impl(verb, url, response);
+  });
+}
+
+void HybridHttp::httpStr(const std::string& verb, const std::string& url, const std::string& bodyStr, const std::string& charset, const std::string& contentType, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  this->beginCall();
+  httpStr_impl(verb, url, bodyStr, charset, contentType, response);
+}
+void HybridHttp::httpStr_impl(const std::string& verb, const std::string& url, const std::string& bodyStr, const std::string& charset, const std::string& contentType, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  rt::checkNoNul(verb, "verb");
+  rt::checkNoNul(url, "url");
+  rt::checkNoNul(bodyStr, "bodyStr");
+  rt::checkNoNul(charset, "charset");
+  rt::checkNoNul(contentType, "contentType");
+  if (!this->ck().HttpStr(verb.c_str(), url.c_str(), bodyStr.c_str(), charset.c_str(), contentType.c_str(), rt::implOf<HybridHttpResponse>(response, "response").ck())) throw this->fail("httpStr");
+}
+std::shared_ptr<Promise<void>> HybridHttp::httpStrAsync(const std::string& verb, const std::string& url, const std::string& bodyStr, const std::string& charset, const std::string& contentType, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(response);
+  return rt::runAsync<void>("Http.httpStrAsync", std::move(_parts), [_self, verb, url, bodyStr, charset, contentType, response]() {
+    _self->httpStr_impl(verb, url, bodyStr, charset, contentType, response);
+  });
+}
+
+void HybridHttp::httpSb(const std::string& verb, const std::string& url, const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset, const std::string& contentType, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  this->beginCall();
+  httpSb_impl(verb, url, sb, charset, contentType, response);
+}
+void HybridHttp::httpSb_impl(const std::string& verb, const std::string& url, const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset, const std::string& contentType, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  rt::checkNoNul(verb, "verb");
+  rt::checkNoNul(url, "url");
+  rt::checkNoNul(charset, "charset");
+  rt::checkNoNul(contentType, "contentType");
+  if (!this->ck().HttpSb(verb.c_str(), url.c_str(), rt::implOf<HybridStringBuilder>(sb, "sb").ck(), charset.c_str(), contentType.c_str(), rt::implOf<HybridHttpResponse>(response, "response").ck())) throw this->fail("httpSb");
+}
+std::shared_ptr<Promise<void>> HybridHttp::httpSbAsync(const std::string& verb, const std::string& url, const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset, const std::string& contentType, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sb);
+  _parts.push_back(response);
+  return rt::runAsync<void>("Http.httpSbAsync", std::move(_parts), [_self, verb, url, sb, charset, contentType, response]() {
+    _self->httpSb_impl(verb, url, sb, charset, contentType, response);
+  });
+}
+
+void HybridHttp::httpJson(const std::string& verb, const std::string& url, const std::shared_ptr<HybridJsonObjectSpec>& json, const std::string& contentType, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  this->beginCall();
+  httpJson_impl(verb, url, json, contentType, response);
+}
+void HybridHttp::httpJson_impl(const std::string& verb, const std::string& url, const std::shared_ptr<HybridJsonObjectSpec>& json, const std::string& contentType, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  rt::checkNoNul(verb, "verb");
+  rt::checkNoNul(url, "url");
+  rt::checkNoNul(contentType, "contentType");
+  if (!this->ck().HttpJson(verb.c_str(), url.c_str(), rt::implOf<HybridJsonObject>(json, "json").ck(), contentType.c_str(), rt::implOf<HybridHttpResponse>(response, "response").ck())) throw this->fail("httpJson");
+}
+std::shared_ptr<Promise<void>> HybridHttp::httpJsonAsync(const std::string& verb, const std::string& url, const std::shared_ptr<HybridJsonObjectSpec>& json, const std::string& contentType, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(json);
+  _parts.push_back(response);
+  return rt::runAsync<void>("Http.httpJsonAsync", std::move(_parts), [_self, verb, url, json, contentType, response]() {
+    _self->httpJson_impl(verb, url, json, contentType, response);
+  });
+}
+
+void HybridHttp::httpReq(const std::string& url, const std::shared_ptr<HybridHttpRequestSpec>& request, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  this->beginCall();
+  httpReq_impl(url, request, response);
+}
+void HybridHttp::httpReq_impl(const std::string& url, const std::shared_ptr<HybridHttpRequestSpec>& request, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  rt::checkNoNul(url, "url");
+  if (!this->ck().HttpReq(url.c_str(), rt::implOf<HybridHttpRequest>(request, "request").ck(), rt::implOf<HybridHttpResponse>(response, "response").ck())) throw this->fail("httpReq");
+}
+std::shared_ptr<Promise<void>> HybridHttp::httpReqAsync(const std::string& url, const std::shared_ptr<HybridHttpRequestSpec>& request, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(request);
+  _parts.push_back(response);
+  return rt::runAsync<void>("Http.httpReqAsync", std::move(_parts), [_self, url, request, response]() {
+    _self->httpReq_impl(url, request, response);
+  });
+}
+
+void HybridHttp::httpFile(const std::string& verb, const std::string& url, const std::string& localFilePath, const std::string& contentType, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  this->beginCall();
+  httpFile_impl(verb, url, localFilePath, contentType, response);
+}
+void HybridHttp::httpFile_impl(const std::string& verb, const std::string& url, const std::string& localFilePath, const std::string& contentType, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  rt::checkNoNul(verb, "verb");
+  rt::checkNoNul(url, "url");
+  rt::checkNoNul(localFilePath, "localFilePath");
+  rt::checkNoNul(contentType, "contentType");
+  if (!this->ck().HttpFile(verb.c_str(), url.c_str(), localFilePath.c_str(), contentType.c_str(), rt::implOf<HybridHttpResponse>(response, "response").ck())) throw this->fail("httpFile");
+}
+std::shared_ptr<Promise<void>> HybridHttp::httpFileAsync(const std::string& verb, const std::string& url, const std::string& localFilePath, const std::string& contentType, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(response);
+  return rt::runAsync<void>("Http.httpFileAsync", std::move(_parts), [_self, verb, url, localFilePath, contentType, response]() {
+    _self->httpFile_impl(verb, url, localFilePath, contentType, response);
+  });
+}
+
+void HybridHttp::httpParams(const std::string& verb, const std::string& url, const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  this->beginCall();
+  httpParams_impl(verb, url, json, response);
+}
+void HybridHttp::httpParams_impl(const std::string& verb, const std::string& url, const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  rt::checkNoNul(verb, "verb");
+  rt::checkNoNul(url, "url");
+  if (!this->ck().HttpParams(verb.c_str(), url.c_str(), rt::implOf<HybridJsonObject>(json, "json").ck(), rt::implOf<HybridHttpResponse>(response, "response").ck())) throw this->fail("httpParams");
+}
+std::shared_ptr<Promise<void>> HybridHttp::httpParamsAsync(const std::string& verb, const std::string& url, const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(json);
+  _parts.push_back(response);
+  return rt::runAsync<void>("Http.httpParamsAsync", std::move(_parts), [_self, verb, url, json, response]() {
+    _self->httpParams_impl(verb, url, json, response);
+  });
+}
+
+void HybridHttp::httpSReq(const std::string& domain, double port, bool ssl, const std::shared_ptr<HybridHttpRequestSpec>& request, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  this->beginCall();
+  httpSReq_impl(domain, port, ssl, request, response);
+}
+void HybridHttp::httpSReq_impl(const std::string& domain, double port, bool ssl, const std::shared_ptr<HybridHttpRequestSpec>& request, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  rt::checkNoNul(domain, "domain");
+  if (!this->ck().HttpSReq(domain.c_str(), rt::toInt(port, "port"), ssl, rt::implOf<HybridHttpRequest>(request, "request").ck(), rt::implOf<HybridHttpResponse>(response, "response").ck())) throw this->fail("httpSReq");
+}
+std::shared_ptr<Promise<void>> HybridHttp::httpSReqAsync(const std::string& domain, double port, bool ssl, const std::shared_ptr<HybridHttpRequestSpec>& request, const std::shared_ptr<HybridHttpResponseSpec>& response) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(request);
+  _parts.push_back(response);
+  return rt::runAsync<void>("Http.httpSReqAsync", std::move(_parts), [_self, domain, port, ssl, request, response]() {
+    _self->httpSReq_impl(domain, port, ssl, request, response);
+  });
+}
+
+void HybridHttp::s3DeleteObjects(const std::string& bucketName, const std::shared_ptr<HybridStringTableSpec>& objectNames, const std::shared_ptr<HybridJsonObjectSpec>& jsonResponse) {
+  this->beginCall();
+  s3DeleteObjects_impl(bucketName, objectNames, jsonResponse);
+}
+void HybridHttp::s3DeleteObjects_impl(const std::string& bucketName, const std::shared_ptr<HybridStringTableSpec>& objectNames, const std::shared_ptr<HybridJsonObjectSpec>& jsonResponse) {
+  rt::checkNoNul(bucketName, "bucketName");
+  if (!this->ck().S3_DeleteObjects(bucketName.c_str(), rt::implOf<HybridStringTable>(objectNames, "objectNames").ck(), rt::implOf<HybridJsonObject>(jsonResponse, "jsonResponse").ck())) throw this->fail("s3DeleteObjects");
+}
+std::shared_ptr<Promise<void>> HybridHttp::s3DeleteObjectsAsync(const std::string& bucketName, const std::shared_ptr<HybridStringTableSpec>& objectNames, const std::shared_ptr<HybridJsonObjectSpec>& jsonResponse) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridHttp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(objectNames);
+  _parts.push_back(jsonResponse);
+  return rt::runAsync<void>("Http.s3DeleteObjectsAsync", std::move(_parts), [_self, bucketName, objectNames, jsonResponse]() {
+    _self->s3DeleteObjects_impl(bucketName, objectNames, jsonResponse);
+  });
+}
+
+void HybridHttp::clearInMemoryCookies() {
+  this->beginCall();
+  clearInMemoryCookies_impl();
+}
+void HybridHttp::clearInMemoryCookies_impl() {
+  this->ck().ClearInMemoryCookies();
+}
+
+void HybridHttp::setDPoPKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  this->beginCall();
+  setDPoPKey_impl(privKey);
+}
+void HybridHttp::setDPoPKey_impl(const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  if (!this->ck().SetDPoPKey(rt::implOf<HybridPrivateKey>(privKey, "privKey").ck())) throw this->fail("setDPoPKey");
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridHttp::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridHttp::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridHttp::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridHttp::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridHttp::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat