@chilkat/react-native 11.6.1

package/cpp/HybridOAuth2.cpp

@@ -0,0 +1,515 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridOAuth2.hpp"
+#include "HybridSocket.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridOAuth2::HybridOAuth2()
+    : HybridObject(HybridOAuth2Spec::TAG), ChilkatObject<CkOAuth2>("OAuth2", CkOAuth2::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridOAuth2::HybridOAuth2(CkOAuth2* owned)
+    : HybridObject(HybridOAuth2Spec::TAG), ChilkatObject<CkOAuth2>("OAuth2", owned) {
+  init();
+}
+
+void HybridOAuth2::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridOAuth2::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridOAuth2::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridOAuth2::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridOAuth2::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridOAuth2::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridOAuth2::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth2::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridOAuth2::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridOAuth2::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridOAuth2::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridOAuth2::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridOAuth2::getAuthorizationEndpoint() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AuthorizationEndpoint(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth2::setAuthorizationEndpoint(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "authorizationEndpoint");
+  this->ck().put_AuthorizationEndpoint(value.c_str());
+}
+std::string HybridOAuth2::getTokenEndpoint() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TokenEndpoint(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth2::setTokenEndpoint(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "tokenEndpoint");
+  this->ck().put_TokenEndpoint(value.c_str());
+}
+std::string HybridOAuth2::getClientId() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ClientId(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth2::setClientId(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "clientId");
+  this->ck().put_ClientId(value.c_str());
+}
+std::string HybridOAuth2::getClientSecret() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ClientSecret(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth2::setClientSecret(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "clientSecret");
+  this->ck().put_ClientSecret(value.c_str());
+}
+std::string HybridOAuth2::getScope() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Scope(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth2::setScope(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "scope");
+  this->ck().put_Scope(value.c_str());
+}
+bool HybridOAuth2::getCodeChallenge() {
+  this->beginCall();
+  return this->ck().get_CodeChallenge();
+}
+void HybridOAuth2::setCodeChallenge(bool value) {
+  this->beginCall();
+  this->ck().put_CodeChallenge(value);
+}
+std::string HybridOAuth2::getCodeChallengeMethod() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_CodeChallengeMethod(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth2::setCodeChallengeMethod(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "codeChallengeMethod");
+  this->ck().put_CodeChallengeMethod(value.c_str());
+}
+std::string HybridOAuth2::getAccessTokenResponse() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AccessTokenResponse(_s);
+  return rt::stdString(_s);
+}
+double HybridOAuth2::getAuthFlowState() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_AuthFlowState());
+}
+std::string HybridOAuth2::getFailureInfo() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_FailureInfo(_s);
+  return rt::stdString(_s);
+}
+std::string HybridOAuth2::getRedirectAllowHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_RedirectAllowHtml(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth2::setRedirectAllowHtml(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "redirectAllowHtml");
+  this->ck().put_RedirectAllowHtml(value.c_str());
+}
+std::string HybridOAuth2::getRedirectDenyHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_RedirectDenyHtml(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth2::setRedirectDenyHtml(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "redirectDenyHtml");
+  this->ck().put_RedirectDenyHtml(value.c_str());
+}
+std::string HybridOAuth2::getAccessToken() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AccessToken(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth2::setAccessToken(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "accessToken");
+  this->ck().put_AccessToken(value.c_str());
+}
+std::string HybridOAuth2::getTokenType() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TokenType(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth2::setTokenType(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "tokenType");
+  this->ck().put_TokenType(value.c_str());
+}
+std::string HybridOAuth2::getRefreshToken() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_RefreshToken(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth2::setRefreshToken(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "refreshToken");
+  this->ck().put_RefreshToken(value.c_str());
+}
+double HybridOAuth2::getListenPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ListenPort());
+}
+void HybridOAuth2::setListenPort(double value) {
+  this->beginCall();
+  this->ck().put_ListenPort(rt::toInt(value, "listenPort"));
+}
+std::string HybridOAuth2::getLocalHost() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LocalHost(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth2::setLocalHost(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "localHost");
+  this->ck().put_LocalHost(value.c_str());
+}
+std::string HybridOAuth2::getResource() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Resource(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth2::setResource(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "resource");
+  this->ck().put_Resource(value.c_str());
+}
+double HybridOAuth2::getListenPortRangeEnd() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ListenPortRangeEnd());
+}
+void HybridOAuth2::setListenPortRangeEnd(double value) {
+  this->beginCall();
+  this->ck().put_ListenPortRangeEnd(rt::toInt(value, "listenPortRangeEnd"));
+}
+std::string HybridOAuth2::getAppCallbackUrl() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AppCallbackUrl(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth2::setAppCallbackUrl(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "appCallbackUrl");
+  this->ck().put_AppCallbackUrl(value.c_str());
+}
+bool HybridOAuth2::getUseBasicAuth() {
+  this->beginCall();
+  return this->ck().get_UseBasicAuth();
+}
+void HybridOAuth2::setUseBasicAuth(bool value) {
+  this->beginCall();
+  this->ck().put_UseBasicAuth(value);
+}
+bool HybridOAuth2::getIncludeNonce() {
+  this->beginCall();
+  return this->ck().get_IncludeNonce();
+}
+void HybridOAuth2::setIncludeNonce(bool value) {
+  this->beginCall();
+  this->ck().put_IncludeNonce(value);
+}
+std::string HybridOAuth2::getResponseMode() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ResponseMode(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth2::setResponseMode(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "responseMode");
+  this->ck().put_ResponseMode(value.c_str());
+}
+std::string HybridOAuth2::getResponseType() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ResponseType(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth2::setResponseType(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "responseType");
+  this->ck().put_ResponseType(value.c_str());
+}
+double HybridOAuth2::getNonceLength() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NonceLength());
+}
+void HybridOAuth2::setNonceLength(double value) {
+  this->beginCall();
+  this->ck().put_NonceLength(rt::toInt(value, "nonceLength"));
+}
+std::string HybridOAuth2::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth2::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+std::string HybridOAuth2::getRedirectReqReceived() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_RedirectReqReceived(_s);
+  return rt::stdString(_s);
+}
+std::string HybridOAuth2::getStateParam() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_StateParam(_s);
+  return rt::stdString(_s);
+}
+void HybridOAuth2::setStateParam(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "stateParam");
+  this->ck().put_StateParam(value.c_str());
+}
+double HybridOAuth2::getListenPortSelected() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ListenPortSelected());
+}
+bool HybridOAuth2::getOob() {
+  this->beginCall();
+  return this->ck().get_Oob();
+}
+void HybridOAuth2::setOob(bool value) {
+  this->beginCall();
+  this->ck().put_Oob(value);
+}
+bool HybridOAuth2::getEnableSecrets() {
+  this->beginCall();
+  return this->ck().get_EnableSecrets();
+}
+void HybridOAuth2::setEnableSecrets(bool value) {
+  this->beginCall();
+  this->ck().put_EnableSecrets(value);
+}
+
+// ---- Methods ----
+
+std::string HybridOAuth2::startAuth() {
+  this->beginCall();
+  return startAuth_impl();
+}
+std::string HybridOAuth2::startAuth_impl() {
+  CkString _out;
+  if (!this->ck().StartAuth(_out)) throw this->fail("startAuth");
+  return rt::stdString(_out);
+}
+
+void HybridOAuth2::cancel() {
+  this->beginCall();
+  cancel_impl();
+}
+void HybridOAuth2::cancel_impl() {
+  if (!this->ck().Cancel()) throw this->fail("cancel");
+}
+
+void HybridOAuth2::sleepMs(double millisec) {
+  this->beginCall();
+  sleepMs_impl(millisec);
+}
+void HybridOAuth2::sleepMs_impl(double millisec) {
+  this->ck().SleepMs(rt::toInt(millisec, "millisec"));
+}
+
+void HybridOAuth2::refreshAccessToken() {
+  this->beginCall();
+  refreshAccessToken_impl();
+}
+void HybridOAuth2::refreshAccessToken_impl() {
+  if (!this->ck().RefreshAccessToken()) throw this->fail("refreshAccessToken");
+}
+std::shared_ptr<Promise<void>> HybridOAuth2::refreshAccessTokenAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridOAuth2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("OAuth2.refreshAccessTokenAsync", std::move(_parts), [_self]() {
+    _self->refreshAccessToken_impl();
+  });
+}
+
+void HybridOAuth2::useConnection(const std::shared_ptr<HybridSocketSpec>& sock) {
+  this->beginCall();
+  useConnection_impl(sock);
+}
+void HybridOAuth2::useConnection_impl(const std::shared_ptr<HybridSocketSpec>& sock) {
+  if (!this->ck().UseConnection(rt::implOf<HybridSocket>(sock, "sock").ck())) throw this->fail("useConnection");
+}
+
+std::string HybridOAuth2::getRedirectRequestParam(const std::string& paramName) {
+  this->beginCall();
+  return getRedirectRequestParam_impl(paramName);
+}
+std::string HybridOAuth2::getRedirectRequestParam_impl(const std::string& paramName) {
+  rt::checkNoNul(paramName, "paramName");
+  CkString _out;
+  if (!this->ck().GetRedirectRequestParam(paramName.c_str(), _out)) throw this->fail("getRedirectRequestParam");
+  return rt::stdString(_out);
+}
+
+void HybridOAuth2::setRefreshHeader(const std::string& name, const std::string& value) {
+  this->beginCall();
+  setRefreshHeader_impl(name, value);
+}
+void HybridOAuth2::setRefreshHeader_impl(const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().SetRefreshHeader(name.c_str(), value.c_str())) throw this->fail("setRefreshHeader");
+}
+
+void HybridOAuth2::addTokenQueryParam(const std::string& name, const std::string& value) {
+  this->beginCall();
+  addTokenQueryParam_impl(name, value);
+}
+void HybridOAuth2::addTokenQueryParam_impl(const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().AddTokenQueryParam(name.c_str(), value.c_str())) throw this->fail("addTokenQueryParam");
+}
+
+void HybridOAuth2::addAuthQueryParam(const std::string& name, const std::string& value) {
+  this->beginCall();
+  addAuthQueryParam_impl(name, value);
+}
+void HybridOAuth2::addAuthQueryParam_impl(const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().AddAuthQueryParam(name.c_str(), value.c_str())) throw this->fail("addAuthQueryParam");
+}
+
+void HybridOAuth2::addRefreshQueryParam(const std::string& name, const std::string& value) {
+  this->beginCall();
+  addRefreshQueryParam_impl(name, value);
+}
+void HybridOAuth2::addRefreshQueryParam_impl(const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().AddRefreshQueryParam(name.c_str(), value.c_str())) throw this->fail("addRefreshQueryParam");
+}
+
+void HybridOAuth2::launchBrowser(const std::string& url) {
+  this->beginCall();
+  launchBrowser_impl(url);
+}
+void HybridOAuth2::launchBrowser_impl(const std::string& url) {
+  rt::checkNoNul(url, "url");
+  if (!this->ck().LaunchBrowser(url.c_str())) throw this->fail("launchBrowser");
+}
+
+void HybridOAuth2::exchangeCodeForToken(const std::string& code) {
+  this->beginCall();
+  exchangeCodeForToken_impl(code);
+}
+void HybridOAuth2::exchangeCodeForToken_impl(const std::string& code) {
+  rt::checkNoNul(code, "code");
+  if (!this->ck().ExchangeCodeForToken(code.c_str())) throw this->fail("exchangeCodeForToken");
+}
+std::shared_ptr<Promise<void>> HybridOAuth2::exchangeCodeForTokenAsync(const std::string& code) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridOAuth2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("OAuth2.exchangeCodeForTokenAsync", std::move(_parts), [_self, code]() {
+    _self->exchangeCodeForToken_impl(code);
+  });
+}
+
+void HybridOAuth2::getAccessTokenResponseSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  getAccessTokenResponseSb_impl(sb);
+}
+void HybridOAuth2::getAccessTokenResponseSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().GetAccessTokenResponseSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("getAccessTokenResponseSb");
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridOAuth2::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridOAuth2::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridOAuth2::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridOAuth2::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridOAuth2::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridOAuth2.hpp

@@ -0,0 +1,127 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// OAuth2: the Nitro HybridObject over Chilkat's CkOAuth2 (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridOAuth2Spec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkOAuth2.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridOAuth2 final : public HybridOAuth2Spec, public ChilkatObject<CkOAuth2> {
+public:
+  HybridOAuth2();                                  // `new OAuth2()` from JS
+  explicit HybridOAuth2(CkOAuth2* owned);  // wraps an object a Chilkat method returned
+  void dispose() override;
+
+  // ---- Properties ----
+  std::string getLastErrorHtml() override;
+  std::string getLastErrorText() override;
+  std::string getLastErrorXml() override;
+  std::string getVersion() override;
+  std::string getDebugLogFilePath() override;
+  void setDebugLogFilePath(const std::string& value) override;
+  bool getVerboseLogging() override;
+  void setVerboseLogging(bool value) override;
+  bool getLastMethodSuccess() override;
+  void setLastMethodSuccess(bool value) override;
+  std::string getAuthorizationEndpoint() override;
+  void setAuthorizationEndpoint(const std::string& value) override;
+  std::string getTokenEndpoint() override;
+  void setTokenEndpoint(const std::string& value) override;
+  std::string getClientId() override;
+  void setClientId(const std::string& value) override;
+  std::string getClientSecret() override;
+  void setClientSecret(const std::string& value) override;
+  std::string getScope() override;
+  void setScope(const std::string& value) override;
+  bool getCodeChallenge() override;
+  void setCodeChallenge(bool value) override;
+  std::string getCodeChallengeMethod() override;
+  void setCodeChallengeMethod(const std::string& value) override;
+  std::string getAccessTokenResponse() override;
+  double getAuthFlowState() override;
+  std::string getFailureInfo() override;
+  std::string getRedirectAllowHtml() override;
+  void setRedirectAllowHtml(const std::string& value) override;
+  std::string getRedirectDenyHtml() override;
+  void setRedirectDenyHtml(const std::string& value) override;
+  std::string getAccessToken() override;
+  void setAccessToken(const std::string& value) override;
+  std::string getTokenType() override;
+  void setTokenType(const std::string& value) override;
+  std::string getRefreshToken() override;
+  void setRefreshToken(const std::string& value) override;
+  double getListenPort() override;
+  void setListenPort(double value) override;
+  std::string getLocalHost() override;
+  void setLocalHost(const std::string& value) override;
+  std::string getResource() override;
+  void setResource(const std::string& value) override;
+  double getListenPortRangeEnd() override;
+  void setListenPortRangeEnd(double value) override;
+  std::string getAppCallbackUrl() override;
+  void setAppCallbackUrl(const std::string& value) override;
+  bool getUseBasicAuth() override;
+  void setUseBasicAuth(bool value) override;
+  bool getIncludeNonce() override;
+  void setIncludeNonce(bool value) override;
+  std::string getResponseMode() override;
+  void setResponseMode(const std::string& value) override;
+  std::string getResponseType() override;
+  void setResponseType(const std::string& value) override;
+  double getNonceLength() override;
+  void setNonceLength(double value) override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+  std::string getRedirectReqReceived() override;
+  std::string getStateParam() override;
+  void setStateParam(const std::string& value) override;
+  double getListenPortSelected() override;
+  bool getOob() override;
+  void setOob(bool value) override;
+  bool getEnableSecrets() override;
+  void setEnableSecrets(bool value) override;
+
+  // ---- Methods ----
+  std::string startAuth() override;
+  void cancel() override;
+  void sleepMs(double millisec) override;
+  void refreshAccessToken() override;
+  std::shared_ptr<Promise<void>> refreshAccessTokenAsync() override;
+  void useConnection(const std::shared_ptr<HybridSocketSpec>& sock) override;
+  std::string getRedirectRequestParam(const std::string& paramName) override;
+  void setRefreshHeader(const std::string& name, const std::string& value) override;
+  void addTokenQueryParam(const std::string& name, const std::string& value) override;
+  void addAuthQueryParam(const std::string& name, const std::string& value) override;
+  void addRefreshQueryParam(const std::string& name, const std::string& value) override;
+  void launchBrowser(const std::string& url) override;
+  void exchangeCodeForToken(const std::string& code) override;
+  std::shared_ptr<Promise<void>> exchangeCodeForTokenAsync(const std::string& code) override;
+  void getAccessTokenResponseSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+
+  // ---- Events (ReactNativeGen_DESIGN.md §6) ----
+  std::optional<std::function<void(double)>> getOnPercentDone() override;
+  void setOnPercentDone(const std::optional<std::function<void(double)>>& cb) override;
+  std::optional<std::function<void(const std::string&, const std::string&)>> getOnProgressInfo() override;
+  void setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) override;
+  void abort() override;
+
+private:
+  void init();
+  std::string startAuth_impl();
+  void cancel_impl();
+  void sleepMs_impl(double millisec);
+  void refreshAccessToken_impl();
+  void useConnection_impl(const std::shared_ptr<HybridSocketSpec>& sock);
+  std::string getRedirectRequestParam_impl(const std::string& paramName);
+  void setRefreshHeader_impl(const std::string& name, const std::string& value);
+  void addTokenQueryParam_impl(const std::string& name, const std::string& value);
+  void addAuthQueryParam_impl(const std::string& name, const std::string& value);
+  void addRefreshQueryParam_impl(const std::string& name, const std::string& value);
+  void launchBrowser_impl(const std::string& url);
+  void exchangeCodeForToken_impl(const std::string& code);
+  void getAccessTokenResponseSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+};
+
+} // namespace margelo::nitro::chilkat