react-native-nitro-background-geolocation 0.1.0

package/nitrogen/generated/ios/NitroBackgroundGeolocation-Swift-Cxx-Bridge.hpp

@@ -0,0 +1,911 @@
+///
+/// NitroBackgroundGeolocation-Swift-Cxx-Bridge.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `Activity` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { struct Activity; }
+// Forward declaration of `AuthorizationStatus` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { enum class AuthorizationStatus; }
+// Forward declaration of `BackgroundGeolocationError` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { struct BackgroundGeolocationError; }
+// Forward declaration of `ConfigureOptions` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { struct ConfigureOptions; }
+// Forward declaration of `HybridNitroBackgroundGeolocationSpec` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { class HybridNitroBackgroundGeolocationSpec; }
+// Forward declaration of `LocationAccuracy` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { enum class LocationAccuracy; }
+// Forward declaration of `LocationProvider` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { enum class LocationProvider; }
+// Forward declaration of `Location` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { struct Location; }
+// Forward declaration of `LogEntry` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { struct LogEntry; }
+// Forward declaration of `ServiceStatus` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { struct ServiceStatus; }
+// Forward declaration of `StationaryLocation` to properly resolve imports.
+namespace margelo::nitro::nitrobackgroundgeolocation { struct StationaryLocation; }
+
+// Forward declarations of Swift defined types
+// Forward declaration of `HybridNitroBackgroundGeolocationSpec_cxx` to properly resolve imports.
+namespace NitroBackgroundGeolocation { class HybridNitroBackgroundGeolocationSpec_cxx; }
+
+// Include C++ defined types
+#include "Activity.hpp"
+#include "AuthorizationStatus.hpp"
+#include "BackgroundGeolocationError.hpp"
+#include "ConfigureOptions.hpp"
+#include "HybridNitroBackgroundGeolocationSpec.hpp"
+#include "Location.hpp"
+#include "LocationAccuracy.hpp"
+#include "LocationProvider.hpp"
+#include "LogEntry.hpp"
+#include "ServiceStatus.hpp"
+#include "StationaryLocation.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/Null.hpp>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/PromiseHolder.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+/**
+ * Contains specialized versions of C++ templated types so they can be accessed from Swift,
+ * as well as helper functions to interact with those C++ types from Swift.
+ */
+namespace margelo::nitro::nitrobackgroundgeolocation::bridge::swift {
+
+  // pragma MARK: std::shared_ptr<Promise<void>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<void>>`.
+   */
+  using std__shared_ptr_Promise_void__ = std::shared_ptr<Promise<void>>;
+  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() noexcept {
+    return Promise<void>::create();
+  }
+  inline PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) noexcept {
+    return PromiseHolder<void>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void()>
+  /**
+   * Specialized version of `std::function<void()>`.
+   */
+  using Func_void = std::function<void()>;
+  /**
+   * Wrapper class for a `std::function<void()>`, this can be used from Swift.
+   */
+  class Func_void_Wrapper final {
+  public:
+    explicit Func_void_Wrapper(std::function<void()>&& func): _function(std::make_unique<std::function<void()>>(std::move(func))) {}
+    inline void call() const noexcept {
+      _function->operator()();
+    }
+  private:
+    std::unique_ptr<std::function<void()>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_Wrapper wrap_Func_void(Func_void value) noexcept {
+    return Func_void_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
+  /**
+   * Specialized version of `std::function<void(const std::exception_ptr&)>`.
+   */
+  using Func_void_std__exception_ptr = std::function<void(const std::exception_ptr& /* error */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::exception_ptr& / * error * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__exception_ptr_Wrapper final {
+  public:
+    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::make_unique<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
+    inline void call(std::exception_ptr error) const noexcept {
+      _function->operator()(error);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::exception_ptr& /* error */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) noexcept {
+    return Func_void_std__exception_ptr_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, LocationProvider>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, LocationProvider>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_nitro__NullType__LocationProvider_ final {
+    std::variant<nitro::NullType, LocationProvider> variant;
+    std__variant_nitro__NullType__LocationProvider_(std::variant<nitro::NullType, LocationProvider> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, LocationProvider>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline LocationProvider get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__LocationProvider_ create_std__variant_nitro__NullType__LocationProvider_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__LocationProvider_(value);
+  }
+  inline std__variant_nitro__NullType__LocationProvider_ create_std__variant_nitro__NullType__LocationProvider_(LocationProvider value) noexcept {
+    return std__variant_nitro__NullType__LocationProvider_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, LocationProvider>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, LocationProvider>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__LocationProvider__ = std::optional<std::variant<nitro::NullType, LocationProvider>>;
+  inline std::optional<std::variant<nitro::NullType, LocationProvider>> create_std__optional_std__variant_nitro__NullType__LocationProvider__(const std::variant<nitro::NullType, LocationProvider>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, LocationProvider>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__LocationProvider__(const std::optional<std::variant<nitro::NullType, LocationProvider>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, LocationProvider> get_std__optional_std__variant_nitro__NullType__LocationProvider__(const std::optional<std::variant<nitro::NullType, LocationProvider>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, LocationAccuracy>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, LocationAccuracy>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_nitro__NullType__LocationAccuracy_ final {
+    std::variant<nitro::NullType, LocationAccuracy> variant;
+    std__variant_nitro__NullType__LocationAccuracy_(std::variant<nitro::NullType, LocationAccuracy> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, LocationAccuracy>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline LocationAccuracy get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__LocationAccuracy_ create_std__variant_nitro__NullType__LocationAccuracy_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__LocationAccuracy_(value);
+  }
+  inline std__variant_nitro__NullType__LocationAccuracy_ create_std__variant_nitro__NullType__LocationAccuracy_(LocationAccuracy value) noexcept {
+    return std__variant_nitro__NullType__LocationAccuracy_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, LocationAccuracy>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, LocationAccuracy>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__LocationAccuracy__ = std::optional<std::variant<nitro::NullType, LocationAccuracy>>;
+  inline std::optional<std::variant<nitro::NullType, LocationAccuracy>> create_std__optional_std__variant_nitro__NullType__LocationAccuracy__(const std::variant<nitro::NullType, LocationAccuracy>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, LocationAccuracy>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__LocationAccuracy__(const std::optional<std::variant<nitro::NullType, LocationAccuracy>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, LocationAccuracy> get_std__optional_std__variant_nitro__NullType__LocationAccuracy__(const std::optional<std::variant<nitro::NullType, LocationAccuracy>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, double>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, double>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_nitro__NullType__double_ final {
+    std::variant<nitro::NullType, double> variant;
+    std__variant_nitro__NullType__double_(std::variant<nitro::NullType, double> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, double>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline double get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__double_ create_std__variant_nitro__NullType__double_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__double_(value);
+  }
+  inline std__variant_nitro__NullType__double_ create_std__variant_nitro__NullType__double_(double value) noexcept {
+    return std__variant_nitro__NullType__double_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, double>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, double>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__double__ = std::optional<std::variant<nitro::NullType, double>>;
+  inline std::optional<std::variant<nitro::NullType, double>> create_std__optional_std__variant_nitro__NullType__double__(const std::variant<nitro::NullType, double>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, double>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__double__(const std::optional<std::variant<nitro::NullType, double>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, double> get_std__optional_std__variant_nitro__NullType__double__(const std::optional<std::variant<nitro::NullType, double>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, bool>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, bool>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_nitro__NullType__bool_ final {
+    std::variant<nitro::NullType, bool> variant;
+    std__variant_nitro__NullType__bool_(std::variant<nitro::NullType, bool> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, bool>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline bool get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__bool_ create_std__variant_nitro__NullType__bool_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__bool_(value);
+  }
+  inline std__variant_nitro__NullType__bool_ create_std__variant_nitro__NullType__bool_(bool value) noexcept {
+    return std__variant_nitro__NullType__bool_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, bool>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, bool>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__bool__ = std::optional<std::variant<nitro::NullType, bool>>;
+  inline std::optional<std::variant<nitro::NullType, bool>> create_std__optional_std__variant_nitro__NullType__bool__(const std::variant<nitro::NullType, bool>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, bool>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__bool__(const std::optional<std::variant<nitro::NullType, bool>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, bool> get_std__optional_std__variant_nitro__NullType__bool__(const std::optional<std::variant<nitro::NullType, bool>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, std::string>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, std::string>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_nitro__NullType__std__string_ final {
+    std::variant<nitro::NullType, std::string> variant;
+    std__variant_nitro__NullType__std__string_(std::variant<nitro::NullType, std::string> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, std::string>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline std::string get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__std__string_ create_std__variant_nitro__NullType__std__string_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__std__string_(value);
+  }
+  inline std__variant_nitro__NullType__std__string_ create_std__variant_nitro__NullType__std__string_(const std::string& value) noexcept {
+    return std__variant_nitro__NullType__std__string_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, std::string>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, std::string>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__std__string__ = std::optional<std::variant<nitro::NullType, std::string>>;
+  inline std::optional<std::variant<nitro::NullType, std::string>> create_std__optional_std__variant_nitro__NullType__std__string__(const std::variant<nitro::NullType, std::string>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, std::string>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__std__string__(const std::optional<std::variant<nitro::NullType, std::string>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, std::string> get_std__optional_std__variant_nitro__NullType__std__string__(const std::optional<std::variant<nitro::NullType, std::string>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::unordered_map<std::string, std::string>
+  /**
+   * Specialized version of `std::unordered_map<std::string, std::string>`.
+   */
+  using std__unordered_map_std__string__std__string_ = std::unordered_map<std::string, std::string>;
+  inline std::unordered_map<std::string, std::string> create_std__unordered_map_std__string__std__string_(size_t size) noexcept {
+    std::unordered_map<std::string, std::string> map;
+    map.reserve(size);
+    return map;
+  }
+  inline std::vector<std::string> get_std__unordered_map_std__string__std__string__keys(const std__unordered_map_std__string__std__string_& map) noexcept {
+    std::vector<std::string> keys;
+    keys.reserve(map.size());
+    for (const auto& entry : map) {
+      keys.push_back(entry.first);
+    }
+    return keys;
+  }
+  inline std::string get_std__unordered_map_std__string__std__string__value(const std__unordered_map_std__string__std__string_& map, const std::string& key) noexcept {
+    return map.find(key)->second;
+  }
+  inline void emplace_std__unordered_map_std__string__std__string_(std__unordered_map_std__string__std__string_& map, const std::string& key, const std::string& value) noexcept {
+    map.emplace(key, value);
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_nitro__NullType__std__unordered_map_std__string__std__string__ final {
+    std::variant<nitro::NullType, std::unordered_map<std::string, std::string>> variant;
+    std__variant_nitro__NullType__std__unordered_map_std__string__std__string__(std::variant<nitro::NullType, std::unordered_map<std::string, std::string>> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline std::unordered_map<std::string, std::string> get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__std__unordered_map_std__string__std__string__ create_std__variant_nitro__NullType__std__unordered_map_std__string__std__string__(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__std__unordered_map_std__string__std__string__(value);
+  }
+  inline std__variant_nitro__NullType__std__unordered_map_std__string__std__string__ create_std__variant_nitro__NullType__std__unordered_map_std__string__std__string__(const std::unordered_map<std::string, std::string>& value) noexcept {
+    return std__variant_nitro__NullType__std__unordered_map_std__string__std__string__(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__std__unordered_map_std__string__std__string___ = std::optional<std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>>;
+  inline std::optional<std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>> create_std__optional_std__variant_nitro__NullType__std__unordered_map_std__string__std__string___(const std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__std__unordered_map_std__string__std__string___(const std::optional<std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, std::unordered_map<std::string, std::string>> get_std__optional_std__variant_nitro__NullType__std__unordered_map_std__string__std__string___(const std::optional<std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, std::shared_ptr<AnyMap>>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, std::shared_ptr<AnyMap>>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_nitro__NullType__std__shared_ptr_AnyMap__ final {
+    std::variant<nitro::NullType, std::shared_ptr<AnyMap>> variant;
+    std__variant_nitro__NullType__std__shared_ptr_AnyMap__(std::variant<nitro::NullType, std::shared_ptr<AnyMap>> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, std::shared_ptr<AnyMap>>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline std::shared_ptr<AnyMap> get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__std__shared_ptr_AnyMap__ create_std__variant_nitro__NullType__std__shared_ptr_AnyMap__(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__std__shared_ptr_AnyMap__(value);
+  }
+  inline std__variant_nitro__NullType__std__shared_ptr_AnyMap__ create_std__variant_nitro__NullType__std__shared_ptr_AnyMap__(const std::shared_ptr<AnyMap>& value) noexcept {
+    return std__variant_nitro__NullType__std__shared_ptr_AnyMap__(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, std::shared_ptr<AnyMap>>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, std::shared_ptr<AnyMap>>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__std__shared_ptr_AnyMap___ = std::optional<std::variant<nitro::NullType, std::shared_ptr<AnyMap>>>;
+  inline std::optional<std::variant<nitro::NullType, std::shared_ptr<AnyMap>>> create_std__optional_std__variant_nitro__NullType__std__shared_ptr_AnyMap___(const std::variant<nitro::NullType, std::shared_ptr<AnyMap>>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, std::shared_ptr<AnyMap>>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__std__shared_ptr_AnyMap___(const std::optional<std::variant<nitro::NullType, std::shared_ptr<AnyMap>>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, std::shared_ptr<AnyMap>> get_std__optional_std__variant_nitro__NullType__std__shared_ptr_AnyMap___(const std::optional<std::variant<nitro::NullType, std::shared_ptr<AnyMap>>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<Location>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<Location>>`.
+   */
+  using std__shared_ptr_Promise_Location__ = std::shared_ptr<Promise<Location>>;
+  inline std::shared_ptr<Promise<Location>> create_std__shared_ptr_Promise_Location__() noexcept {
+    return Promise<Location>::create();
+  }
+  inline PromiseHolder<Location> wrap_std__shared_ptr_Promise_Location__(std::shared_ptr<Promise<Location>> promise) noexcept {
+    return PromiseHolder<Location>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const Location& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const Location&)>`.
+   */
+  using Func_void_Location = std::function<void(const Location& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const Location& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_Location_Wrapper final {
+  public:
+    explicit Func_void_Location_Wrapper(std::function<void(const Location& /* result */)>&& func): _function(std::make_unique<std::function<void(const Location& /* result */)>>(std::move(func))) {}
+    inline void call(Location result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const Location& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_Location create_Func_void_Location(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_Location_Wrapper wrap_Func_void_Location(Func_void_Location value) noexcept {
+    return Func_void_Location_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<double>
+  /**
+   * Specialized version of `std::optional<double>`.
+   */
+  using std__optional_double_ = std::optional<double>;
+  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
+    return std::optional<double>(value);
+  }
+  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<bool>
+  /**
+   * Specialized version of `std::optional<bool>`.
+   */
+  using std__optional_bool_ = std::optional<bool>;
+  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
+    return std::optional<bool>(value);
+  }
+  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<StationaryLocation>
+  /**
+   * Specialized version of `std::optional<StationaryLocation>`.
+   */
+  using std__optional_StationaryLocation_ = std::optional<StationaryLocation>;
+  inline std::optional<StationaryLocation> create_std__optional_StationaryLocation_(const StationaryLocation& value) noexcept {
+    return std::optional<StationaryLocation>(value);
+  }
+  inline bool has_value_std__optional_StationaryLocation_(const std::optional<StationaryLocation>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline StationaryLocation get_std__optional_StationaryLocation_(const std::optional<StationaryLocation>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::optional<StationaryLocation>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::optional<StationaryLocation>>>`.
+   */
+  using std__shared_ptr_Promise_std__optional_StationaryLocation___ = std::shared_ptr<Promise<std::optional<StationaryLocation>>>;
+  inline std::shared_ptr<Promise<std::optional<StationaryLocation>>> create_std__shared_ptr_Promise_std__optional_StationaryLocation___() noexcept {
+    return Promise<std::optional<StationaryLocation>>::create();
+  }
+  inline PromiseHolder<std::optional<StationaryLocation>> wrap_std__shared_ptr_Promise_std__optional_StationaryLocation___(std::shared_ptr<Promise<std::optional<StationaryLocation>>> promise) noexcept {
+    return PromiseHolder<std::optional<StationaryLocation>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::optional<StationaryLocation>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::optional<StationaryLocation>&)>`.
+   */
+  using Func_void_std__optional_StationaryLocation_ = std::function<void(const std::optional<StationaryLocation>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::optional<StationaryLocation>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__optional_StationaryLocation__Wrapper final {
+  public:
+    explicit Func_void_std__optional_StationaryLocation__Wrapper(std::function<void(const std::optional<StationaryLocation>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<StationaryLocation>& /* result */)>>(std::move(func))) {}
+    inline void call(std::optional<StationaryLocation> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::optional<StationaryLocation>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__optional_StationaryLocation_ create_Func_void_std__optional_StationaryLocation_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__optional_StationaryLocation__Wrapper wrap_Func_void_std__optional_StationaryLocation_(Func_void_std__optional_StationaryLocation_ value) noexcept {
+    return Func_void_std__optional_StationaryLocation__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<ServiceStatus>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<ServiceStatus>>`.
+   */
+  using std__shared_ptr_Promise_ServiceStatus__ = std::shared_ptr<Promise<ServiceStatus>>;
+  inline std::shared_ptr<Promise<ServiceStatus>> create_std__shared_ptr_Promise_ServiceStatus__() noexcept {
+    return Promise<ServiceStatus>::create();
+  }
+  inline PromiseHolder<ServiceStatus> wrap_std__shared_ptr_Promise_ServiceStatus__(std::shared_ptr<Promise<ServiceStatus>> promise) noexcept {
+    return PromiseHolder<ServiceStatus>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const ServiceStatus& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const ServiceStatus&)>`.
+   */
+  using Func_void_ServiceStatus = std::function<void(const ServiceStatus& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const ServiceStatus& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_ServiceStatus_Wrapper final {
+  public:
+    explicit Func_void_ServiceStatus_Wrapper(std::function<void(const ServiceStatus& /* result */)>&& func): _function(std::make_unique<std::function<void(const ServiceStatus& /* result */)>>(std::move(func))) {}
+    inline void call(ServiceStatus result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const ServiceStatus& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_ServiceStatus create_Func_void_ServiceStatus(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_ServiceStatus_Wrapper wrap_Func_void_ServiceStatus(Func_void_ServiceStatus value) noexcept {
+    return Func_void_ServiceStatus_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<ConfigureOptions>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<ConfigureOptions>>`.
+   */
+  using std__shared_ptr_Promise_ConfigureOptions__ = std::shared_ptr<Promise<ConfigureOptions>>;
+  inline std::shared_ptr<Promise<ConfigureOptions>> create_std__shared_ptr_Promise_ConfigureOptions__() noexcept {
+    return Promise<ConfigureOptions>::create();
+  }
+  inline PromiseHolder<ConfigureOptions> wrap_std__shared_ptr_Promise_ConfigureOptions__(std::shared_ptr<Promise<ConfigureOptions>> promise) noexcept {
+    return PromiseHolder<ConfigureOptions>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const ConfigureOptions& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const ConfigureOptions&)>`.
+   */
+  using Func_void_ConfigureOptions = std::function<void(const ConfigureOptions& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const ConfigureOptions& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_ConfigureOptions_Wrapper final {
+  public:
+    explicit Func_void_ConfigureOptions_Wrapper(std::function<void(const ConfigureOptions& /* result */)>&& func): _function(std::make_unique<std::function<void(const ConfigureOptions& /* result */)>>(std::move(func))) {}
+    inline void call(ConfigureOptions result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const ConfigureOptions& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_ConfigureOptions create_Func_void_ConfigureOptions(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_ConfigureOptions_Wrapper wrap_Func_void_ConfigureOptions(Func_void_ConfigureOptions value) noexcept {
+    return Func_void_ConfigureOptions_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::vector<Location>
+  /**
+   * Specialized version of `std::vector<Location>`.
+   */
+  using std__vector_Location_ = std::vector<Location>;
+  inline std::vector<Location> create_std__vector_Location_(size_t size) noexcept {
+    std::vector<Location> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<Location>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<Location>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_Location___ = std::shared_ptr<Promise<std::vector<Location>>>;
+  inline std::shared_ptr<Promise<std::vector<Location>>> create_std__shared_ptr_Promise_std__vector_Location___() noexcept {
+    return Promise<std::vector<Location>>::create();
+  }
+  inline PromiseHolder<std::vector<Location>> wrap_std__shared_ptr_Promise_std__vector_Location___(std::shared_ptr<Promise<std::vector<Location>>> promise) noexcept {
+    return PromiseHolder<std::vector<Location>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<Location>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<Location>&)>`.
+   */
+  using Func_void_std__vector_Location_ = std::function<void(const std::vector<Location>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<Location>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_Location__Wrapper final {
+  public:
+    explicit Func_void_std__vector_Location__Wrapper(std::function<void(const std::vector<Location>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<Location>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<Location> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<Location>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_Location_ create_Func_void_std__vector_Location_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_Location__Wrapper wrap_Func_void_std__vector_Location_(Func_void_std__vector_Location_ value) noexcept {
+    return Func_void_std__vector_Location__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::vector<LogEntry>
+  /**
+   * Specialized version of `std::vector<LogEntry>`.
+   */
+  using std__vector_LogEntry_ = std::vector<LogEntry>;
+  inline std::vector<LogEntry> create_std__vector_LogEntry_(size_t size) noexcept {
+    std::vector<LogEntry> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<LogEntry>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<LogEntry>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_LogEntry___ = std::shared_ptr<Promise<std::vector<LogEntry>>>;
+  inline std::shared_ptr<Promise<std::vector<LogEntry>>> create_std__shared_ptr_Promise_std__vector_LogEntry___() noexcept {
+    return Promise<std::vector<LogEntry>>::create();
+  }
+  inline PromiseHolder<std::vector<LogEntry>> wrap_std__shared_ptr_Promise_std__vector_LogEntry___(std::shared_ptr<Promise<std::vector<LogEntry>>> promise) noexcept {
+    return PromiseHolder<std::vector<LogEntry>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<LogEntry>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<LogEntry>&)>`.
+   */
+  using Func_void_std__vector_LogEntry_ = std::function<void(const std::vector<LogEntry>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<LogEntry>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_LogEntry__Wrapper final {
+  public:
+    explicit Func_void_std__vector_LogEntry__Wrapper(std::function<void(const std::vector<LogEntry>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<LogEntry>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<LogEntry> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<LogEntry>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_LogEntry_ create_Func_void_std__vector_LogEntry_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_LogEntry__Wrapper wrap_Func_void_std__vector_LogEntry_(Func_void_std__vector_LogEntry_ value) noexcept {
+    return Func_void_std__vector_LogEntry__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const StationaryLocation& /* location */)>
+  /**
+   * Specialized version of `std::function<void(const StationaryLocation&)>`.
+   */
+  using Func_void_StationaryLocation = std::function<void(const StationaryLocation& /* location */)>;
+  /**
+   * Wrapper class for a `std::function<void(const StationaryLocation& / * location * /)>`, this can be used from Swift.
+   */
+  class Func_void_StationaryLocation_Wrapper final {
+  public:
+    explicit Func_void_StationaryLocation_Wrapper(std::function<void(const StationaryLocation& /* location */)>&& func): _function(std::make_unique<std::function<void(const StationaryLocation& /* location */)>>(std::move(func))) {}
+    inline void call(StationaryLocation location) const noexcept {
+      _function->operator()(location);
+    }
+  private:
+    std::unique_ptr<std::function<void(const StationaryLocation& /* location */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_StationaryLocation create_Func_void_StationaryLocation(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_StationaryLocation_Wrapper wrap_Func_void_StationaryLocation(Func_void_StationaryLocation value) noexcept {
+    return Func_void_StationaryLocation_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const Activity& /* activity */)>
+  /**
+   * Specialized version of `std::function<void(const Activity&)>`.
+   */
+  using Func_void_Activity = std::function<void(const Activity& /* activity */)>;
+  /**
+   * Wrapper class for a `std::function<void(const Activity& / * activity * /)>`, this can be used from Swift.
+   */
+  class Func_void_Activity_Wrapper final {
+  public:
+    explicit Func_void_Activity_Wrapper(std::function<void(const Activity& /* activity */)>&& func): _function(std::make_unique<std::function<void(const Activity& /* activity */)>>(std::move(func))) {}
+    inline void call(Activity activity) const noexcept {
+      _function->operator()(activity);
+    }
+  private:
+    std::unique_ptr<std::function<void(const Activity& /* activity */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_Activity create_Func_void_Activity(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_Activity_Wrapper wrap_Func_void_Activity(Func_void_Activity value) noexcept {
+    return Func_void_Activity_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const BackgroundGeolocationError& /* error */)>
+  /**
+   * Specialized version of `std::function<void(const BackgroundGeolocationError&)>`.
+   */
+  using Func_void_BackgroundGeolocationError = std::function<void(const BackgroundGeolocationError& /* error */)>;
+  /**
+   * Wrapper class for a `std::function<void(const BackgroundGeolocationError& / * error * /)>`, this can be used from Swift.
+   */
+  class Func_void_BackgroundGeolocationError_Wrapper final {
+  public:
+    explicit Func_void_BackgroundGeolocationError_Wrapper(std::function<void(const BackgroundGeolocationError& /* error */)>&& func): _function(std::make_unique<std::function<void(const BackgroundGeolocationError& /* error */)>>(std::move(func))) {}
+    inline void call(BackgroundGeolocationError error) const noexcept {
+      _function->operator()(error);
+    }
+  private:
+    std::unique_ptr<std::function<void(const BackgroundGeolocationError& /* error */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_BackgroundGeolocationError create_Func_void_BackgroundGeolocationError(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_BackgroundGeolocationError_Wrapper wrap_Func_void_BackgroundGeolocationError(Func_void_BackgroundGeolocationError value) noexcept {
+    return Func_void_BackgroundGeolocationError_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(AuthorizationStatus /* status */)>
+  /**
+   * Specialized version of `std::function<void(AuthorizationStatus)>`.
+   */
+  using Func_void_AuthorizationStatus = std::function<void(AuthorizationStatus /* status */)>;
+  /**
+   * Wrapper class for a `std::function<void(AuthorizationStatus / * status * /)>`, this can be used from Swift.
+   */
+  class Func_void_AuthorizationStatus_Wrapper final {
+  public:
+    explicit Func_void_AuthorizationStatus_Wrapper(std::function<void(AuthorizationStatus /* status */)>&& func): _function(std::make_unique<std::function<void(AuthorizationStatus /* status */)>>(std::move(func))) {}
+    inline void call(int status) const noexcept {
+      _function->operator()(static_cast<AuthorizationStatus>(status));
+    }
+  private:
+    std::unique_ptr<std::function<void(AuthorizationStatus /* status */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_AuthorizationStatus create_Func_void_AuthorizationStatus(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_AuthorizationStatus_Wrapper wrap_Func_void_AuthorizationStatus(Func_void_AuthorizationStatus value) noexcept {
+    return Func_void_AuthorizationStatus_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridNitroBackgroundGeolocationSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridNitroBackgroundGeolocationSpec>`.
+   */
+  using std__shared_ptr_HybridNitroBackgroundGeolocationSpec_ = std::shared_ptr<HybridNitroBackgroundGeolocationSpec>;
+  std::shared_ptr<HybridNitroBackgroundGeolocationSpec> create_std__shared_ptr_HybridNitroBackgroundGeolocationSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridNitroBackgroundGeolocationSpec_(std__shared_ptr_HybridNitroBackgroundGeolocationSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridNitroBackgroundGeolocationSpec>
+  using std__weak_ptr_HybridNitroBackgroundGeolocationSpec_ = std::weak_ptr<HybridNitroBackgroundGeolocationSpec>;
+  inline std__weak_ptr_HybridNitroBackgroundGeolocationSpec_ weakify_std__shared_ptr_HybridNitroBackgroundGeolocationSpec_(const std::shared_ptr<HybridNitroBackgroundGeolocationSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<void>>>
+  using Result_std__shared_ptr_Promise_void___ = Result<std::shared_ptr<Promise<void>>>;
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::shared_ptr<Promise<void>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<void>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<void>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<Location>>>
+  using Result_std__shared_ptr_Promise_Location___ = Result<std::shared_ptr<Promise<Location>>>;
+  inline Result_std__shared_ptr_Promise_Location___ create_Result_std__shared_ptr_Promise_Location___(const std::shared_ptr<Promise<Location>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<Location>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_Location___ create_Result_std__shared_ptr_Promise_Location___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<Location>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<StationaryLocation>>>>
+  using Result_std__shared_ptr_Promise_std__optional_StationaryLocation____ = Result<std::shared_ptr<Promise<std::optional<StationaryLocation>>>>;
+  inline Result_std__shared_ptr_Promise_std__optional_StationaryLocation____ create_Result_std__shared_ptr_Promise_std__optional_StationaryLocation____(const std::shared_ptr<Promise<std::optional<StationaryLocation>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::optional<StationaryLocation>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__optional_StationaryLocation____ create_Result_std__shared_ptr_Promise_std__optional_StationaryLocation____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::optional<StationaryLocation>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<ServiceStatus>>>
+  using Result_std__shared_ptr_Promise_ServiceStatus___ = Result<std::shared_ptr<Promise<ServiceStatus>>>;
+  inline Result_std__shared_ptr_Promise_ServiceStatus___ create_Result_std__shared_ptr_Promise_ServiceStatus___(const std::shared_ptr<Promise<ServiceStatus>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<ServiceStatus>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_ServiceStatus___ create_Result_std__shared_ptr_Promise_ServiceStatus___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<ServiceStatus>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<ConfigureOptions>>>
+  using Result_std__shared_ptr_Promise_ConfigureOptions___ = Result<std::shared_ptr<Promise<ConfigureOptions>>>;
+  inline Result_std__shared_ptr_Promise_ConfigureOptions___ create_Result_std__shared_ptr_Promise_ConfigureOptions___(const std::shared_ptr<Promise<ConfigureOptions>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<ConfigureOptions>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_ConfigureOptions___ create_Result_std__shared_ptr_Promise_ConfigureOptions___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<ConfigureOptions>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<void>
+  using Result_void_ = Result<void>;
+  inline Result_void_ create_Result_void_() noexcept {
+    return Result<void>::withValue();
+  }
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
+    return Result<void>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<Location>>>>
+  using Result_std__shared_ptr_Promise_std__vector_Location____ = Result<std::shared_ptr<Promise<std::vector<Location>>>>;
+  inline Result_std__shared_ptr_Promise_std__vector_Location____ create_Result_std__shared_ptr_Promise_std__vector_Location____(const std::shared_ptr<Promise<std::vector<Location>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::vector<Location>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__vector_Location____ create_Result_std__shared_ptr_Promise_std__vector_Location____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::vector<Location>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<LogEntry>>>>
+  using Result_std__shared_ptr_Promise_std__vector_LogEntry____ = Result<std::shared_ptr<Promise<std::vector<LogEntry>>>>;
+  inline Result_std__shared_ptr_Promise_std__vector_LogEntry____ create_Result_std__shared_ptr_Promise_std__vector_LogEntry____(const std::shared_ptr<Promise<std::vector<LogEntry>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::vector<LogEntry>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__vector_LogEntry____ create_Result_std__shared_ptr_Promise_std__vector_LogEntry____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::vector<LogEntry>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::function<void()>>
+  using Result_std__function_void____ = Result<std::function<void()>>;
+  inline Result_std__function_void____ create_Result_std__function_void____(const std::function<void()>& value) noexcept {
+    return Result<std::function<void()>>::withValue(value);
+  }
+  inline Result_std__function_void____ create_Result_std__function_void____(const std::exception_ptr& error) noexcept {
+    return Result<std::function<void()>>::withError(error);
+  }
+
+} // namespace margelo::nitro::nitrobackgroundgeolocation::bridge::swift