onnxruntime_cxx_api.h

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
 
// Summary: The Ort C++ API is a header only wrapper around the Ort C API.
//
// The C++ API simplifies usage by returning values directly instead of error codes, throwing exceptions on errors
// and automatically releasing resources in the destructors. The primary purpose of C++ API is exception safety so
// all the resources follow RAII and do not leak memory.
//
// Each of the C++ wrapper classes holds only a pointer to the C internal object. Treat them like smart pointers.
// To create an empty object, pass 'nullptr' to the constructor (for example, Env e{nullptr};). However, you can't use them
// until you assign an instance that actually holds an underlying object.
//
// For Ort objects only move assignment between objects is allowed, there are no copy constructors.
// Some objects have explicit 'Clone' methods for this purpose.
//
// ConstXXXX types are copyable since they do not own the underlying C object, so you can pass them to functions as arguments
// by value or by reference. ConstXXXX types are restricted to const only interfaces.
//
// UnownedXXXX are similar to ConstXXXX but also allow non-const interfaces.
//
// The lifetime of the corresponding owning object must eclipse the lifetimes of the ConstXXXX/UnownedXXXX types. They exists so you do not
// have to fallback to C types and the API with the usual pitfalls. In general, do not use C API from your C++ code.
 
#pragma once
#include "onnxruntime_c_api.h"
#include "onnxruntime_float16.h"
 
#include <array>
#include <cstddef>
#include <cstdio>
#include <memory>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <variant>
#include <vector>
 
#ifdef ORT_NO_EXCEPTIONS
#include <iostream>
#endif
 
namespace Ort {
 
struct Exception : std::exception {
  Exception(std::string&& string, OrtErrorCode code) : message_{std::move(string)}, code_{code} {}
 
  OrtErrorCode GetOrtErrorCode() const { return code_; }
  const char* what() const noexcept override { return message_.c_str(); }
 
 private:
  std::string message_;
  OrtErrorCode code_;
};
 
#ifdef ORT_NO_EXCEPTIONS
// The #ifndef is for the very special case where the user of this library wants to define their own way of handling errors.
// NOTE: This header expects control flow to not continue after calling ORT_CXX_API_THROW
#ifndef ORT_CXX_API_THROW
#define ORT_CXX_API_THROW(string, code)       \
  do {                                        \
    std::cerr << Ort::Exception(string, code) \
                     .what()                  \
              << std::endl;                   \
    abort();                                  \
  } while (false)
#endif
#else
#define ORT_CXX_API_THROW(string, code) \
  throw Ort::Exception(string, code)
#endif
 
// This is used internally by the C++ API. This class holds the global variable that points to the OrtApi,
//  it's in a template so that we can define a global variable in a header and make
// it transparent to the users of the API.
template <typename T>
struct Global {
  static const OrtApi* api_;
};
 
// If macro ORT_API_MANUAL_INIT is defined, no static initialization will be performed. Instead, user must call InitApi() before using it.
template <typename T>
#ifdef ORT_API_MANUAL_INIT
const OrtApi* Global<T>::api_{};
inline void InitApi() noexcept { Global<void>::api_ = OrtGetApiBase()->GetApi(ORT_API_VERSION); }
 
// Used by custom operator libraries that are not linked to onnxruntime. Sets the global API object, which is
// required by C++ APIs.
//
// Example mycustomop.cc:
//
// #define ORT_API_MANUAL_INIT
// #include <onnxruntime_cxx_api.h>
// #undef ORT_API_MANUAL_INIT
//
// OrtStatus* ORT_API_CALL RegisterCustomOps(OrtSessionOptions* options, const OrtApiBase* api_base) {
//   Ort::InitApi(api_base->GetApi(ORT_API_VERSION));
//   // ...
// }
//
inline void InitApi(const OrtApi* api) noexcept { Global<void>::api_ = api; }
#else
#if defined(_MSC_VER) && !defined(__clang__)
#pragma warning(push)
// "Global initializer calls a non-constexpr function." Therefore you can't use ORT APIs in the other global initializers.
// Please define ORT_API_MANUAL_INIT if it conerns you.
#pragma warning(disable : 26426)
#endif
const OrtApi* Global<T>::api_ = OrtGetApiBase()->GetApi(ORT_API_VERSION);
#if defined(_MSC_VER) && !defined(__clang__)
#pragma warning(pop)
#endif
#endif
 
inline const OrtApi& GetApi() noexcept { return *Global<void>::api_; }
 
std::string GetVersionString();
 
std::string GetBuildInfoString();
 
std::vector<std::string> GetAvailableProviders();
 
inline const OrtModelEditorApi& GetModelEditorApi() {
  auto* api = GetApi().GetModelEditorApi();
  if (api == nullptr) {
    // minimal build
    ORT_CXX_API_THROW("Model Editor API is not available in this build", ORT_FAIL);
  }
 
  return *api;
}
 
inline const OrtCompileApi& GetCompileApi() {
  auto* api = GetApi().GetCompileApi();
  if (api == nullptr) {
    // minimal build
    ORT_CXX_API_THROW("Compile API is not available in this build", ORT_FAIL);
  }
 
  return *api;
}
 
inline const OrtEpApi& GetEpApi() {
  auto* api = GetApi().GetEpApi();
  if (api == nullptr) {
    // minimal build
    ORT_CXX_API_THROW("EP API is not available in this build", ORT_FAIL);
  }
 
  return *api;
}
 
struct Float16_t : onnxruntime_float16::Float16Impl<Float16_t> {
 private:
  constexpr explicit Float16_t(uint16_t v) noexcept { val = v; }
 
 public:
  using Base = onnxruntime_float16::Float16Impl<Float16_t>;
 
  Float16_t() = default;
 
  constexpr static Float16_t FromBits(uint16_t v) noexcept { return Float16_t(v); }
 
  explicit Float16_t(float v) noexcept { val = Base::ToUint16Impl(v); }
 
  float ToFloat() const noexcept { return Base::ToFloatImpl(); }
 
  using Base::IsNegative;
 
  using Base::IsNaN;
 
  using Base::IsFinite;
 
  using Base::IsPositiveInfinity;
 
  using Base::IsNegativeInfinity;
 
  using Base::IsInfinity;
 
  using Base::IsNaNOrZero;
 
  using Base::IsNormal;
 
  using Base::IsSubnormal;
 
  using Base::Abs;
 
  using Base::Negate;
 
  using Base::AreZero;
 
  explicit operator float() const noexcept { return ToFloat(); }
 
  using Base::operator==;
  using Base::operator!=;
  using Base::operator<;
};
 
static_assert(sizeof(Float16_t) == sizeof(uint16_t), "Sizes must match");
 
struct BFloat16_t : onnxruntime_float16::BFloat16Impl<BFloat16_t> {
 private:
  constexpr explicit BFloat16_t(uint16_t v) noexcept { val = v; }
 
 public:
  using Base = onnxruntime_float16::BFloat16Impl<BFloat16_t>;
 
  BFloat16_t() = default;
 
  static constexpr BFloat16_t FromBits(uint16_t v) noexcept { return BFloat16_t(v); }
 
  explicit BFloat16_t(float v) noexcept { val = Base::ToUint16Impl(v); }
 
  float ToFloat() const noexcept { return Base::ToFloatImpl(); }
 
  using Base::IsNegative;
 
  using Base::IsNaN;
 
  using Base::IsFinite;
 
  using Base::IsPositiveInfinity;
 
  using Base::IsNegativeInfinity;
 
  using Base::IsInfinity;
 
  using Base::IsNaNOrZero;
 
  using Base::IsNormal;
 
  using Base::IsSubnormal;
 
  using Base::Abs;
 
  using Base::Negate;
 
  using Base::AreZero;
 
  explicit operator float() const noexcept { return ToFloat(); }
 
  // We do not have an inherited impl for the below operators
  // as the internal class implements them a little differently
  bool operator==(const BFloat16_t& rhs) const noexcept;
  bool operator!=(const BFloat16_t& rhs) const noexcept { return !(*this == rhs); }
  bool operator<(const BFloat16_t& rhs) const noexcept;
};
 
static_assert(sizeof(BFloat16_t) == sizeof(uint16_t), "Sizes must match");
 
struct Float8E4M3FN_t {
  uint8_t value;
  constexpr Float8E4M3FN_t() noexcept : value(0) {}
  constexpr Float8E4M3FN_t(uint8_t v) noexcept : value(v) {}
  constexpr operator uint8_t() const noexcept { return value; }
  // nan values are treated like any other value for operator ==, !=
  constexpr bool operator==(const Float8E4M3FN_t& rhs) const noexcept { return value == rhs.value; };
  constexpr bool operator!=(const Float8E4M3FN_t& rhs) const noexcept { return value != rhs.value; };
};
 
static_assert(sizeof(Float8E4M3FN_t) == sizeof(uint8_t), "Sizes must match");
 
struct Float8E4M3FNUZ_t {
  uint8_t value;
  constexpr Float8E4M3FNUZ_t() noexcept : value(0) {}
  constexpr Float8E4M3FNUZ_t(uint8_t v) noexcept : value(v) {}
  constexpr operator uint8_t() const noexcept { return value; }
  // nan values are treated like any other value for operator ==, !=
  constexpr bool operator==(const Float8E4M3FNUZ_t& rhs) const noexcept { return value == rhs.value; };
  constexpr bool operator!=(const Float8E4M3FNUZ_t& rhs) const noexcept { return value != rhs.value; };
};
 
static_assert(sizeof(Float8E4M3FNUZ_t) == sizeof(uint8_t), "Sizes must match");
 
struct Float8E5M2_t {
  uint8_t value;
  constexpr Float8E5M2_t() noexcept : value(0) {}
  constexpr Float8E5M2_t(uint8_t v) noexcept : value(v) {}
  constexpr operator uint8_t() const noexcept { return value; }
  // nan values are treated like any other value for operator ==, !=
  constexpr bool operator==(const Float8E5M2_t& rhs) const noexcept { return value == rhs.value; };
  constexpr bool operator!=(const Float8E5M2_t& rhs) const noexcept { return value != rhs.value; };
};
 
static_assert(sizeof(Float8E5M2_t) == sizeof(uint8_t), "Sizes must match");
 
struct Float8E5M2FNUZ_t {
  uint8_t value;
  constexpr Float8E5M2FNUZ_t() noexcept : value(0) {}
  constexpr Float8E5M2FNUZ_t(uint8_t v) noexcept : value(v) {}
  constexpr operator uint8_t() const noexcept { return value; }
  // nan values are treated like any other value for operator ==, !=
  constexpr bool operator==(const Float8E5M2FNUZ_t& rhs) const noexcept { return value == rhs.value; };
  constexpr bool operator!=(const Float8E5M2FNUZ_t& rhs) const noexcept { return value != rhs.value; };
};
 
static_assert(sizeof(Float8E5M2FNUZ_t) == sizeof(uint8_t), "Sizes must match");
 
namespace detail {
// This is used internally by the C++ API. This macro is to make it easy to generate overloaded methods for all of the various OrtRelease* functions for every Ort* type
// This can't be done in the C API since C doesn't have function overloading.
#define ORT_DEFINE_RELEASE(NAME) \
  inline void OrtRelease(Ort##NAME* ptr) { GetApi().Release##NAME(ptr); }
 
#define ORT_DEFINE_RELEASE_FROM_API_STRUCT(NAME, API_GETTER) \
  inline void OrtRelease(Ort##NAME* ptr) { API_GETTER().Release##NAME(ptr); }
 
ORT_DEFINE_RELEASE(Allocator);
ORT_DEFINE_RELEASE(MemoryInfo);
ORT_DEFINE_RELEASE(CustomOpDomain);
ORT_DEFINE_RELEASE(ThreadingOptions);
ORT_DEFINE_RELEASE(Env);
ORT_DEFINE_RELEASE(RunOptions);
ORT_DEFINE_RELEASE(LoraAdapter);
ORT_DEFINE_RELEASE(Session);
ORT_DEFINE_RELEASE(SessionOptions);
ORT_DEFINE_RELEASE(TensorTypeAndShapeInfo);
ORT_DEFINE_RELEASE(SequenceTypeInfo);
ORT_DEFINE_RELEASE(MapTypeInfo);
ORT_DEFINE_RELEASE(TypeInfo);
ORT_DEFINE_RELEASE(Value);
ORT_DEFINE_RELEASE(ModelMetadata);
ORT_DEFINE_RELEASE(IoBinding);
ORT_DEFINE_RELEASE(ArenaCfg);
ORT_DEFINE_RELEASE(Status);
ORT_DEFINE_RELEASE(OpAttr);
ORT_DEFINE_RELEASE(Op);
ORT_DEFINE_RELEASE(KernelInfo);
ORT_DEFINE_RELEASE(ValueInfo);
ORT_DEFINE_RELEASE(Node);
ORT_DEFINE_RELEASE(Graph);
ORT_DEFINE_RELEASE(Model);
ORT_DEFINE_RELEASE(KeyValuePairs)
ORT_DEFINE_RELEASE_FROM_API_STRUCT(ModelCompilationOptions, GetCompileApi);
ORT_DEFINE_RELEASE_FROM_API_STRUCT(EpDevice, GetEpApi);
 
#undef ORT_DEFINE_RELEASE
#undef ORT_DEFINE_RELEASE_FROM_API_STRUCT
 
template <typename T>
struct Unowned {
  using Type = T;
};
 
template <typename T>
struct Base {
  using contained_type = T;
 
  constexpr Base() = default;
  constexpr explicit Base(contained_type* p) noexcept : p_{p} {}
  ~Base() {
    OrtRelease(p_);
  }
 
  Base(const Base&) = delete;
  Base& operator=(const Base&) = delete;
 
  Base(Base&& v) noexcept : p_{v.p_} { v.p_ = nullptr; }
  Base& operator=(Base&& v) noexcept {
    OrtRelease(p_);
    p_ = v.release();
    return *this;
  }
 
  constexpr operator contained_type*() const noexcept { return p_; }
 
  contained_type* release() {
    T* p = p_;
    p_ = nullptr;
    return p;
  }
 
 protected:
  contained_type* p_{};
};
 
// Undefined. For const types use Base<Unowned<const T>>
template <typename T>
struct Base<const T>;
 
template <typename T>
struct Base<Unowned<T>> {
  using contained_type = typename Unowned<T>::Type;
 
  constexpr Base() = default;
  constexpr explicit Base(contained_type* p) noexcept : p_{p} {}
 
  ~Base() = default;
 
  Base(const Base&) = default;
  Base& operator=(const Base&) = default;
 
  Base(Base&& v) noexcept : p_{v.p_} { v.p_ = nullptr; }
  Base& operator=(Base&& v) noexcept {
    p_ = nullptr;
    std::swap(p_, v.p_);
    return *this;
  }
 
  constexpr operator contained_type*() const noexcept { return p_; }
 
 protected:
  contained_type* p_{};
};
 
// Light functor to release memory with OrtAllocator
struct AllocatedFree {
  OrtAllocator* allocator_;
  explicit AllocatedFree(OrtAllocator* allocator)
      : allocator_(allocator) {}
  void operator()(void* ptr) const {
    if (ptr) allocator_->Free(allocator_, ptr);
  }
};
 
}  // namespace detail
 
struct AllocatorWithDefaultOptions;
struct Env;
struct EpDevice;
struct Graph;
struct Model;
struct Node;
struct ModelMetadata;
struct TypeInfo;
struct Value;
struct ValueInfo;
 
using AllocatedStringPtr = std::unique_ptr<char, detail::AllocatedFree>;
 
struct Status : detail::Base<OrtStatus> {
  using Base = detail::Base<OrtStatus>;
  using Base::Base;
 
  explicit Status(std::nullptr_t) noexcept {}               
  explicit Status(OrtStatus* status) noexcept;              
  explicit Status(const Exception&) noexcept;               
  explicit Status(const std::exception&) noexcept;          
  Status(const char* message, OrtErrorCode code) noexcept;  
  std::string GetErrorMessage() const;
  OrtErrorCode GetErrorCode() const;
  bool IsOK() const noexcept;  
};
 
struct ThreadingOptions : detail::Base<OrtThreadingOptions> {
  ThreadingOptions();
 
  ThreadingOptions& SetGlobalIntraOpNumThreads(int intra_op_num_threads);
 
  ThreadingOptions& SetGlobalInterOpNumThreads(int inter_op_num_threads);
 
  ThreadingOptions& SetGlobalSpinControl(int allow_spinning);
 
  ThreadingOptions& SetGlobalDenormalAsZero();
 
  ThreadingOptions& SetGlobalCustomCreateThreadFn(OrtCustomCreateThreadFn ort_custom_create_thread_fn);
 
  ThreadingOptions& SetGlobalCustomThreadCreationOptions(void* ort_custom_thread_creation_options);
 
  ThreadingOptions& SetGlobalCustomJoinThreadFn(OrtCustomJoinThreadFn ort_custom_join_thread_fn);
};
 
namespace detail {
template <typename T>
struct KeyValuePairsImpl : Ort::detail::Base<T> {
  using B = Ort::detail::Base<T>;
  using B::B;
 
  const char* GetValue(const char* key) const;
 
  // get the pairs in unordered_map. needs to copy to std::string so the hash works as expected
  std::unordered_map<std::string, std::string> GetKeyValuePairs() const;
  // get the pairs in two vectors. entries will be 1:1 between keys and values. avoids copying to std::string
  void GetKeyValuePairs(std::vector<const char*>& keys, std::vector<const char*>& values) const;
};
}  // namespace detail
 
// Const object holder that does not own the underlying object
using ConstKeyValuePairs = detail::KeyValuePairsImpl<Ort::detail::Unowned<const OrtKeyValuePairs>>;
 
struct KeyValuePairs : detail::KeyValuePairsImpl<OrtKeyValuePairs> {
  explicit KeyValuePairs(std::nullptr_t) {}  
  explicit KeyValuePairs(OrtKeyValuePairs* p) : KeyValuePairsImpl<OrtKeyValuePairs>{p} {}
 
  explicit KeyValuePairs();
 
  explicit KeyValuePairs(const std::unordered_map<std::string, std::string>& kv_pairs);
 
  void Add(const char* key, const char* value);
 
  void Remove(const char* key);
 
  ConstKeyValuePairs GetConst() const { return ConstKeyValuePairs{this->p_}; }
};
 
namespace detail {
template <typename T>
struct HardwareDeviceImpl : Ort::detail::Base<T> {
  using B = Ort::detail::Base<T>;
  using B::B;
 
  OrtHardwareDeviceType Type() const;
  uint32_t VendorId() const;
  uint32_t DeviceId() const;
  const char* Vendor() const;
  ConstKeyValuePairs Metadata() const;
};
}  // namespace detail
 
using ConstHardwareDevice = detail::HardwareDeviceImpl<Ort::detail::Unowned<const OrtHardwareDevice>>;
 
namespace detail {
template <typename T>
struct EpDeviceImpl : Ort::detail::Base<T> {
  using B = Ort::detail::Base<T>;
  using B::B;
 
  const char* EpName() const;
  const char* EpVendor() const;
  ConstKeyValuePairs EpMetadata() const;
  ConstKeyValuePairs EpOptions() const;
  ConstHardwareDevice Device() const;
};
}  // namespace detail
 
using ConstEpDevice = detail::EpDeviceImpl<Ort::detail::Unowned<const OrtEpDevice>>;
 
struct EpDevice : detail::EpDeviceImpl<OrtEpDevice> {
  explicit EpDevice(std::nullptr_t) {}                                 
  explicit EpDevice(OrtEpDevice* p) : EpDeviceImpl<OrtEpDevice>{p} {}  
 
  EpDevice(OrtEpFactory& ep_factory, ConstHardwareDevice& hardware_device,
           ConstKeyValuePairs ep_metadata = {}, ConstKeyValuePairs ep_options = {});
};
 
struct Env : detail::Base<OrtEnv> {
  explicit Env(std::nullptr_t) {}  
 
  Env(OrtLoggingLevel logging_level = ORT_LOGGING_LEVEL_WARNING, _In_ const char* logid = "");
 
  Env(OrtLoggingLevel logging_level, const char* logid, OrtLoggingFunction logging_function, void* logger_param);
 
  Env(const OrtThreadingOptions* tp_options, OrtLoggingLevel logging_level = ORT_LOGGING_LEVEL_WARNING, _In_ const char* logid = "");
 
  Env(const OrtThreadingOptions* tp_options, OrtLoggingFunction logging_function, void* logger_param,
      OrtLoggingLevel logging_level = ORT_LOGGING_LEVEL_WARNING, _In_ const char* logid = "");
 
  explicit Env(OrtEnv* p) : Base<OrtEnv>{p} {}
 
  Env& EnableTelemetryEvents();   
  Env& DisableTelemetryEvents();  
 
  Env& UpdateEnvWithCustomLogLevel(OrtLoggingLevel log_severity_level);  
 
  Env& CreateAndRegisterAllocator(const OrtMemoryInfo* mem_info, const OrtArenaCfg* arena_cfg);  
 
  Env& CreateAndRegisterAllocatorV2(const std::string& provider_type, const OrtMemoryInfo* mem_info,
                                    const std::unordered_map<std::string, std::string>& options,
                                    const OrtArenaCfg* arena_cfg);  
 
  Env& RegisterExecutionProviderLibrary(const char* registration_name, const std::basic_string<ORTCHAR_T>& path);  
  Env& UnregisterExecutionProviderLibrary(const char* registration_name);                                          
 
  std::vector<ConstEpDevice> GetEpDevices() const;
};
 
struct CustomOpDomain : detail::Base<OrtCustomOpDomain> {
  using Base = detail::Base<OrtCustomOpDomain>;
  using Base::Base;
 
  explicit CustomOpDomain(std::nullptr_t) {}  
 
  explicit CustomOpDomain(const char* domain);
 
  // This does not take ownership of the op, simply registers it.
  void Add(const OrtCustomOp* op);  
};
 
struct LoraAdapter : detail::Base<OrtLoraAdapter> {
  using Base = detail::Base<OrtLoraAdapter>;
  using Base::Base;
 
  explicit LoraAdapter(std::nullptr_t) {}  
  static LoraAdapter CreateLoraAdapter(const std::basic_string<ORTCHAR_T>& adapter_path,
                                       OrtAllocator* allocator);
 
  static LoraAdapter CreateLoraAdapterFromArray(const void* bytes, size_t num_bytes,
                                                OrtAllocator* allocator);
};
 
struct RunOptions : detail::Base<OrtRunOptions> {
  explicit RunOptions(std::nullptr_t) {}  
  RunOptions();                           
 
  RunOptions& SetRunLogVerbosityLevel(int);  
  int GetRunLogVerbosityLevel() const;       
 
  RunOptions& SetRunLogSeverityLevel(int);  
  int GetRunLogSeverityLevel() const;       
 
  RunOptions& SetRunTag(const char* run_tag);  
  const char* GetRunTag() const;               
 
  RunOptions& AddConfigEntry(const char* config_key, const char* config_value);  
 
  RunOptions& SetTerminate();
 
  RunOptions& UnsetTerminate();
 
  RunOptions& AddActiveLoraAdapter(const LoraAdapter& adapter);
};
 
namespace detail {
// Utility function that returns a SessionOption config entry key for a specific custom operator.
// Ex: custom_op.[custom_op_name].[config]
std::string MakeCustomOpConfigEntryKey(const char* custom_op_name, const char* config);
}  // namespace detail
 
struct CustomOpConfigs {
  CustomOpConfigs() = default;
  ~CustomOpConfigs() = default;
  CustomOpConfigs(const CustomOpConfigs&) = default;
  CustomOpConfigs& operator=(const CustomOpConfigs&) = default;
  CustomOpConfigs(CustomOpConfigs&& o) = default;
  CustomOpConfigs& operator=(CustomOpConfigs&& o) = default;
 
  CustomOpConfigs& AddConfig(const char* custom_op_name, const char* config_key, const char* config_value);
 
  const std::unordered_map<std::string, std::string>& GetFlattenedConfigs() const;
 
 private:
  std::unordered_map<std::string, std::string> flat_configs_;
};
 
struct SessionOptions;
 
namespace detail {
// we separate const-only methods because passing const ptr to non-const methods
// is only discovered when inline methods are compiled which is counter-intuitive
template <typename T>
struct ConstSessionOptionsImpl : Base<T> {
  using B = Base<T>;
  using B::B;
 
  SessionOptions Clone() const;  
 
  std::string GetConfigEntry(const char* config_key) const;  
  bool HasConfigEntry(const char* config_key) const;         
  std::string GetConfigEntryOrDefault(const char* config_key, const std::string& def) const;
};
 
template <typename T>
struct SessionOptionsImpl : ConstSessionOptionsImpl<T> {
  using B = ConstSessionOptionsImpl<T>;
  using B::B;
 
  SessionOptionsImpl& SetIntraOpNumThreads(int intra_op_num_threads);                              
  SessionOptionsImpl& SetInterOpNumThreads(int inter_op_num_threads);                              
  SessionOptionsImpl& SetGraphOptimizationLevel(GraphOptimizationLevel graph_optimization_level);  
  SessionOptionsImpl& SetDeterministicCompute(bool value);                                         
 
  SessionOptionsImpl& EnableCpuMemArena();   
  SessionOptionsImpl& DisableCpuMemArena();  
 
  SessionOptionsImpl& SetOptimizedModelFilePath(const ORTCHAR_T* optimized_model_file);  
 
  SessionOptionsImpl& EnableProfiling(const ORTCHAR_T* profile_file_prefix);  
  SessionOptionsImpl& DisableProfiling();                                     
 
  SessionOptionsImpl& EnableOrtCustomOps();  
 
  SessionOptionsImpl& EnableMemPattern();   
  SessionOptionsImpl& DisableMemPattern();  
 
  SessionOptionsImpl& SetExecutionMode(ExecutionMode execution_mode);  
 
  SessionOptionsImpl& SetLoadCancellationFlag(bool value);  
 
  SessionOptionsImpl& SetLogId(const char* logid);     
  SessionOptionsImpl& SetLogSeverityLevel(int level);  
 
  SessionOptionsImpl& Add(OrtCustomOpDomain* custom_op_domain);  
 
  SessionOptionsImpl& DisablePerSessionThreads();  
 
  SessionOptionsImpl& AddConfigEntry(const char* config_key, const char* config_value);  
 
  SessionOptionsImpl& AddInitializer(const char* name, const OrtValue* ort_val);                                             
  SessionOptionsImpl& AddExternalInitializers(const std::vector<std::string>& names, const std::vector<Value>& ort_values);  
  SessionOptionsImpl& AddExternalInitializersFromFilesInMemory(const std::vector<std::basic_string<ORTCHAR_T>>& external_initializer_file_names,
                                                               const std::vector<char*>& external_initializer_file_buffer_array,
                                                               const std::vector<size_t>& external_initializer_file_lengths);  
 
  SessionOptionsImpl& AppendExecutionProvider_CUDA(const OrtCUDAProviderOptions& provider_options);          
  SessionOptionsImpl& AppendExecutionProvider_CUDA_V2(const OrtCUDAProviderOptionsV2& provider_options);     
  SessionOptionsImpl& AppendExecutionProvider_ROCM(const OrtROCMProviderOptions& provider_options);          
  SessionOptionsImpl& AppendExecutionProvider_OpenVINO(const OrtOpenVINOProviderOptions& provider_options);  
  SessionOptionsImpl& AppendExecutionProvider_OpenVINO_V2(const std::unordered_map<std::string, std::string>& provider_options = {});
  SessionOptionsImpl& AppendExecutionProvider_TensorRT(const OrtTensorRTProviderOptions& provider_options);       
  SessionOptionsImpl& AppendExecutionProvider_TensorRT_V2(const OrtTensorRTProviderOptionsV2& provider_options);  
  SessionOptionsImpl& AppendExecutionProvider_MIGraphX(const OrtMIGraphXProviderOptions& provider_options);       
  SessionOptionsImpl& AppendExecutionProvider_CANN(const OrtCANNProviderOptions& provider_options);
  SessionOptionsImpl& AppendExecutionProvider_Dnnl(const OrtDnnlProviderOptions& provider_options);
  SessionOptionsImpl& AppendExecutionProvider(const std::string& provider_name,
                                              const std::unordered_map<std::string, std::string>& provider_options = {});
 
  SessionOptionsImpl& AppendExecutionProvider_V2(Env& env, const std::vector<ConstEpDevice>& ep_devices,
                                                 const KeyValuePairs& ep_options);
  SessionOptionsImpl& AppendExecutionProvider_V2(Env& env, const std::vector<ConstEpDevice>& ep_devices,
                                                 const std::unordered_map<std::string, std::string>& ep_options);
 
  SessionOptionsImpl& SetEpSelectionPolicy(OrtExecutionProviderDevicePolicy policy);
 
  SessionOptionsImpl& SetEpSelectionPolicy(EpSelectionDelegate delegate, void* state = nullptr);
 
  SessionOptionsImpl& SetCustomCreateThreadFn(OrtCustomCreateThreadFn ort_custom_create_thread_fn);  
  SessionOptionsImpl& SetCustomThreadCreationOptions(void* ort_custom_thread_creation_options);      
  SessionOptionsImpl& SetCustomJoinThreadFn(OrtCustomJoinThreadFn ort_custom_join_thread_fn);        
 
  SessionOptionsImpl& RegisterCustomOpsLibrary(const ORTCHAR_T* library_name, const CustomOpConfigs& custom_op_configs = {});
 
  SessionOptionsImpl& RegisterCustomOpsUsingFunction(const char* function_name);  
 
  SessionOptionsImpl& AppendExecutionProvider_VitisAI(const std::unordered_map<std::string, std::string>& provider_options = {});
};
}  // namespace detail
 
using UnownedSessionOptions = detail::SessionOptionsImpl<detail::Unowned<OrtSessionOptions>>;
using ConstSessionOptions = detail::ConstSessionOptionsImpl<detail::Unowned<const OrtSessionOptions>>;
 
struct SessionOptions : detail::SessionOptionsImpl<OrtSessionOptions> {
  explicit SessionOptions(std::nullptr_t) {}                                                   
  SessionOptions();                                                                            
  explicit SessionOptions(OrtSessionOptions* p) : SessionOptionsImpl<OrtSessionOptions>{p} {}  
  UnownedSessionOptions GetUnowned() const { return UnownedSessionOptions{this->p_}; }
  ConstSessionOptions GetConst() const { return ConstSessionOptions{this->p_}; }
};
 
struct ModelCompilationOptions : detail::Base<OrtModelCompilationOptions> {
  using Base = detail::Base<OrtModelCompilationOptions>;
  using Base::Base;
 
  explicit ModelCompilationOptions(std::nullptr_t) {}  
 
  ModelCompilationOptions(const Env& env, const SessionOptions& session_options);  
  ModelCompilationOptions(const Env& env, ConstSessionOptions session_options);    
 
  ModelCompilationOptions& SetInputModelPath(const ORTCHAR_T* input_model_path);  
  ModelCompilationOptions& SetInputModelFromBuffer(const void* input_model_data,
                                                   size_t input_model_data_size);   
  ModelCompilationOptions& SetEpContextEmbedMode(bool embed_ep_context_in_model);   
  ModelCompilationOptions& SetOutputModelPath(const ORTCHAR_T* output_model_path);  
  ModelCompilationOptions& SetOutputModelExternalInitializersFile(const ORTCHAR_T* file_path,
                                                                  size_t initializer_size_threshold);  
  ModelCompilationOptions& SetOutputModelBuffer(OrtAllocator* allocator, void** output_model_buffer_ptr,
                                                size_t* output_model_buffer_size_ptr);  
};
 
Status CompileModel(const Env& env, const ModelCompilationOptions& model_compilation_options);
 
struct ModelMetadata : detail::Base<OrtModelMetadata> {
  using Base = detail::Base<OrtModelMetadata>;
  using Base::Base;
 
  explicit ModelMetadata(std::nullptr_t) {}  
 
  AllocatedStringPtr GetProducerNameAllocated(OrtAllocator* allocator) const;  
 
  AllocatedStringPtr GetGraphNameAllocated(OrtAllocator* allocator) const;  
 
  AllocatedStringPtr GetDomainAllocated(OrtAllocator* allocator) const;  
 
  AllocatedStringPtr GetDescriptionAllocated(OrtAllocator* allocator) const;  
 
  AllocatedStringPtr GetGraphDescriptionAllocated(OrtAllocator* allocator) const;  
 
  std::vector<AllocatedStringPtr> GetCustomMetadataMapKeysAllocated(OrtAllocator* allocator) const;  
 
  AllocatedStringPtr LookupCustomMetadataMapAllocated(const char* key, OrtAllocator* allocator) const;  
 
  int64_t GetVersion() const;  
};
 
struct IoBinding;
 
namespace detail {
 
// we separate const-only methods because passing const ptr to non-const methods
// is only discovered when inline methods are compiled which is counter-intuitive
template <typename T>
struct ConstSessionImpl : Base<T> {
  using B = Base<T>;
  using B::B;
 
  size_t GetInputCount() const;                   
  size_t GetOutputCount() const;                  
  size_t GetOverridableInitializerCount() const;  
 
  std::vector<std::string> GetInputNames() const;
  std::vector<std::string> GetOutputNames() const;
  std::vector<std::string> GetOverridableInitializerNames() const;
 
  AllocatedStringPtr GetInputNameAllocated(size_t index, OrtAllocator* allocator) const;
 
  AllocatedStringPtr GetOutputNameAllocated(size_t index, OrtAllocator* allocator) const;
 
  AllocatedStringPtr GetOverridableInitializerNameAllocated(size_t index, OrtAllocator* allocator) const;  
 
  uint64_t GetProfilingStartTimeNs() const;  
  ModelMetadata GetModelMetadata() const;    
 
  TypeInfo GetInputTypeInfo(size_t index) const;                   
  TypeInfo GetOutputTypeInfo(size_t index) const;                  
  TypeInfo GetOverridableInitializerTypeInfo(size_t index) const;  
 
  int GetOpset(const std::string& domain) const;  
 
  // Will move before checkin if that's the case.
  std::vector<ValueInfo> GetInputs() const;
  std::vector<ValueInfo> GetOutputs() const;
};
 
template <typename T>
struct SessionImpl : ConstSessionImpl<T> {
  using B = ConstSessionImpl<T>;
  using B::B;
 
  std::vector<Value> Run(const RunOptions& run_options, const char* const* input_names, const Value* input_values, size_t input_count,
                         const char* const* output_names, size_t output_count);
 
  void Run(const RunOptions& run_options, const char* const* input_names, const Value* input_values, size_t input_count,
           const char* const* output_names, Value* output_values, size_t output_count);
 
  void Run(const RunOptions& run_options, const IoBinding&);  
 
  void RunAsync(const RunOptions& run_options, const char* const* input_names, const Value* input_values, size_t input_count,
                const char* const* output_names, Value* output_values, size_t output_count, RunAsyncCallbackFn callback, void* user_data);
 
  AllocatedStringPtr EndProfilingAllocated(OrtAllocator* allocator);  
 
  void SetEpDynamicOptions(const char* const* keys, const char* const* values, size_t kv_len);
 
  void FinalizeModelEditorSession(const Model& model, const SessionOptions& options,
                                  OrtPrepackedWeightsContainer* prepacked_weights_container = nullptr);
};
 
}  // namespace detail
 
using ConstSession = detail::ConstSessionImpl<detail::Unowned<const OrtSession>>;
using UnownedSession = detail::SessionImpl<detail::Unowned<OrtSession>>;
 
struct Session : detail::SessionImpl<OrtSession> {
  explicit Session(std::nullptr_t) {}
  explicit Session(OrtSession* p) : SessionImpl{p} {}  
 
  Session(const Env& env, const ORTCHAR_T* model_path, const SessionOptions& options);
 
  Session(const Env& env, const ORTCHAR_T* model_path, const SessionOptions& options,
          OrtPrepackedWeightsContainer* prepacked_weights_container);
 
  Session(const Env& env, const void* model_data, size_t model_data_length, const SessionOptions& options);
 
  Session(const Env& env, const void* model_data, size_t model_data_length, const SessionOptions& options,
          OrtPrepackedWeightsContainer* prepacked_weights_container);
 
#if !defined(ORT_MINIMAL_BUILD)
  Session(const Env& env, const Model& model, const SessionOptions& options);
 
  static Session CreateModelEditorSession(const Env& env, const ORTCHAR_T* model_path, const SessionOptions& options);
 
  static Session CreateModelEditorSession(const Env& env, const void* model_data, size_t model_data_length,
                                          const SessionOptions& options);
#endif  // !defined(ORT_MINIMAL_BUILD)
 
  ConstSession GetConst() const { return ConstSession{this->p_}; }
  UnownedSession GetUnowned() const { return UnownedSession{this->p_}; }
};
 
namespace detail {
template <typename T>
struct MemoryInfoImpl : Base<T> {
  using B = Base<T>;
  using B::B;
 
  std::string GetAllocatorName() const;
  OrtAllocatorType GetAllocatorType() const;
  int GetDeviceId() const;
  OrtMemoryInfoDeviceType GetDeviceType() const;
  OrtMemType GetMemoryType() const;
 
  template <typename U>
  bool operator==(const MemoryInfoImpl<U>& o) const;
};
}  // namespace detail
 
// Const object holder that does not own the underlying object
using ConstMemoryInfo = detail::MemoryInfoImpl<detail::Unowned<const OrtMemoryInfo>>;
 
struct MemoryInfo : detail::MemoryInfoImpl<OrtMemoryInfo> {
  static MemoryInfo CreateCpu(OrtAllocatorType type, OrtMemType mem_type1);
  explicit MemoryInfo(std::nullptr_t) {}                                       
  explicit MemoryInfo(OrtMemoryInfo* p) : MemoryInfoImpl<OrtMemoryInfo>{p} {}  
  MemoryInfo(const char* name, OrtAllocatorType type, int id, OrtMemType mem_type);
  ConstMemoryInfo GetConst() const { return ConstMemoryInfo{this->p_}; }
};
 
namespace detail {
template <typename T>
struct TensorTypeAndShapeInfoImpl : Base<T> {
  using B = Base<T>;
  using B::B;
 
  ONNXTensorElementDataType GetElementType() const;  
  size_t GetElementCount() const;                    
 
  size_t GetDimensionsCount() const;  
 
  [[deprecated("use GetShape()")]] void GetDimensions(int64_t* values, size_t values_count) const;  
 
  void GetSymbolicDimensions(const char** values, size_t values_count) const;  
  std::vector<const char*> GetSymbolicDimensions() const;
 
  std::vector<int64_t> GetShape() const;  
};
 
}  // namespace detail
 
using ConstTensorTypeAndShapeInfo = detail::TensorTypeAndShapeInfoImpl<detail::Unowned<const OrtTensorTypeAndShapeInfo>>;
 
struct TensorTypeAndShapeInfo : detail::TensorTypeAndShapeInfoImpl<OrtTensorTypeAndShapeInfo> {
  using Base = detail::TensorTypeAndShapeInfoImpl<OrtTensorTypeAndShapeInfo>;
  using Base::Base;
 
  explicit TensorTypeAndShapeInfo(std::nullptr_t) {}
  explicit TensorTypeAndShapeInfo(OrtTensorTypeAndShapeInfo* p) : TensorTypeAndShapeInfoImpl{p} {}
 
  // Create a TensorTypeAndShapeInfo object with the specified element type and dimensions
  // symbolic_dims are optional, but should be 1:1 with dims.
  // The value in symbolic_dims will be used for all entries in dims that are -1.
  explicit TensorTypeAndShapeInfo(ONNXTensorElementDataType element_type,
                                  const std::vector<int64_t>& dims,
                                  const std::vector<std::string>* symbolic_dims = nullptr);
 
  ConstTensorTypeAndShapeInfo GetConst() const { return ConstTensorTypeAndShapeInfo{this->p_}; }
};
 
namespace detail {
template <typename T>
struct SequenceTypeInfoImpl : Base<T> {
  using B = Base<T>;
  using B::B;
  TypeInfo GetSequenceElementType() const;  
};
 
}  // namespace detail
 
using ConstSequenceTypeInfo = detail::SequenceTypeInfoImpl<detail::Unowned<const OrtSequenceTypeInfo>>;
 
struct SequenceTypeInfo : detail::SequenceTypeInfoImpl<OrtSequenceTypeInfo> {
  using Base = detail::SequenceTypeInfoImpl<OrtSequenceTypeInfo>;
  using Base::Base;
 
  explicit SequenceTypeInfo(std::nullptr_t) {}                                                         
  explicit SequenceTypeInfo(OrtSequenceTypeInfo* p) : SequenceTypeInfoImpl<OrtSequenceTypeInfo>{p} {}  
  ConstSequenceTypeInfo GetConst() const { return ConstSequenceTypeInfo{this->p_}; }
};
 
namespace detail {
template <typename T>
struct OptionalTypeInfoImpl : Base<T> {
  using B = Base<T>;
  using B::B;
  TypeInfo GetOptionalElementType() const;  
};
 
}  // namespace detail
 
// This is always owned by the TypeInfo and can only be obtained from it.
using ConstOptionalTypeInfo = detail::OptionalTypeInfoImpl<detail::Unowned<const OrtOptionalTypeInfo>>;
 
namespace detail {
template <typename T>
struct MapTypeInfoImpl : detail::Base<T> {
  using B = Base<T>;
  using B::B;
  ONNXTensorElementDataType GetMapKeyType() const;  
  TypeInfo GetMapValueType() const;                 
};
 
}  // namespace detail
 
using ConstMapTypeInfo = detail::MapTypeInfoImpl<detail::Unowned<const OrtMapTypeInfo>>;
 
struct MapTypeInfo : detail::MapTypeInfoImpl<OrtMapTypeInfo> {
  using Base = detail::MapTypeInfoImpl<OrtMapTypeInfo>;
  using Base::Base;
 
  explicit MapTypeInfo(std::nullptr_t) {}                                          
  explicit MapTypeInfo(OrtMapTypeInfo* p) : MapTypeInfoImpl<OrtMapTypeInfo>{p} {}  
  ConstMapTypeInfo GetConst() const { return ConstMapTypeInfo{this->p_}; }
};
 
namespace detail {
template <typename T>
struct TypeInfoImpl : detail::Base<T> {
  using B = Base<T>;
  using B::B;
 
  ConstTensorTypeAndShapeInfo GetTensorTypeAndShapeInfo() const;  
  ConstSequenceTypeInfo GetSequenceTypeInfo() const;              
  ConstMapTypeInfo GetMapTypeInfo() const;                        
  ConstOptionalTypeInfo GetOptionalTypeInfo() const;              
 
  ONNXType GetONNXType() const;
};
}  // namespace detail
 
using ConstTypeInfo = detail::TypeInfoImpl<detail::Unowned<const OrtTypeInfo>>;
 
struct TypeInfo : detail::TypeInfoImpl<OrtTypeInfo> {
  using Base = detail::TypeInfoImpl<OrtTypeInfo>;
  using Base::Base;
 
  explicit TypeInfo(std::nullptr_t) {}
  explicit TypeInfo(OrtTypeInfo* p) : TypeInfoImpl<OrtTypeInfo>{p} {}  
 
#if !defined(ORT_MINIMAL_BUILD)
  static TypeInfo CreateTensorInfo(ConstTensorTypeAndShapeInfo tensor_info);
  static TypeInfo CreateSparseTensorInfo(ConstTensorTypeAndShapeInfo sparse_tensor_info);
  static TypeInfo CreateSequenceTypeInfo(ConstTypeInfo sequence_type);
  static TypeInfo CreateMapTypeInfo(ONNXTensorElementDataType key_type, ConstTypeInfo value_type);
  static TypeInfo CreateOptionalTypeInfo(ConstTypeInfo contained_type);
#endif  // !defined(ORT_MINIMAL_BUILD)
 
  ConstTypeInfo GetConst() const { return ConstTypeInfo{this->p_}; }
};
 
namespace detail {
// This structure is used to feed  sparse tensor values
// information for use with FillSparseTensor<Format>() API
// if the data type for the sparse tensor values is numeric
// use data.p_data, otherwise, use data.str pointer to feed
// values. data.str is an array of const char* that are zero terminated.
// number of strings in the array must match shape size.
// For fully sparse tensors use shape {0} and set p_data/str
// to nullptr.
struct OrtSparseValuesParam {
  const int64_t* values_shape;
  size_t values_shape_len;
  union {
    const void* p_data;
    const char** str;
  } data;
};
 
// Provides a way to pass shape in a single
// argument
struct Shape {
  const int64_t* shape;
  size_t shape_len;
};
 
template <typename T>
struct ConstValueImpl : Base<T> {
  using B = Base<T>;
  using B::B;
 
  template <typename R>
  void GetOpaqueData(const char* domain, const char* type_name, R&) const;  
 
  bool IsTensor() const;  
  bool HasValue() const;  
 
  size_t GetCount() const;  // If a non tensor, returns 2 for map and N for sequence, where N is the number of elements
  Value GetValue(int index, OrtAllocator* allocator) const;
 
  size_t GetStringTensorDataLength() const;
 
  void GetStringTensorContent(void* buffer, size_t buffer_length, size_t* offsets, size_t offsets_count) const;
 
  template <typename R>
  const R* GetTensorData() const;  
 
  const void* GetTensorRawData() const;
 
  TypeInfo GetTypeInfo() const;
 
  TensorTypeAndShapeInfo GetTensorTypeAndShapeInfo() const;
 
  ConstMemoryInfo GetTensorMemoryInfo() const;
 
  void GetStringTensorElement(size_t buffer_length, size_t element_index, void* buffer) const;
 
  std::string GetStringTensorElement(size_t element_index) const;
 
  size_t GetStringTensorElementLength(size_t element_index) const;
 
#if !defined(DISABLE_SPARSE_TENSORS)
  OrtSparseFormat GetSparseFormat() const;
 
  TensorTypeAndShapeInfo GetSparseTensorValuesTypeAndShapeInfo() const;
 
  TensorTypeAndShapeInfo GetSparseTensorIndicesTypeShapeInfo(OrtSparseIndicesFormat format) const;
 
  template <typename R>
  const R* GetSparseTensorIndicesData(OrtSparseIndicesFormat indices_format, size_t& num_indices) const;
 
  bool IsSparseTensor() const;
 
  template <typename R>
  const R* GetSparseTensorValues() const;
 
#endif
};
 
template <typename T>
struct ValueImpl : ConstValueImpl<T> {
  using B = ConstValueImpl<T>;
  using B::B;
 
  template <typename R>
  R* GetTensorMutableData();
 
  void* GetTensorMutableRawData();
 
  //  Obtain a reference to an element of data at the location specified
  template <typename R>
  R& At(const std::vector<int64_t>& location);
 
  void FillStringTensor(const char* const* s, size_t s_len);
 
  void FillStringTensorElement(const char* s, size_t index);
 
  char* GetResizedStringTensorElementBuffer(size_t index, size_t buffer_length);
 
#if !defined(DISABLE_SPARSE_TENSORS)
  void UseCooIndices(int64_t* indices_data, size_t indices_num);
 
  void UseCsrIndices(int64_t* inner_data, size_t inner_num, int64_t* outer_data, size_t outer_num);
 
  void UseBlockSparseIndices(const Shape& indices_shape, int32_t* indices_data);
 
  void FillSparseTensorCoo(const OrtMemoryInfo* data_mem_info, const OrtSparseValuesParam& values_param,
                           const int64_t* indices_data, size_t indices_num);
 
  void FillSparseTensorCsr(const OrtMemoryInfo* data_mem_info,
                           const OrtSparseValuesParam& values,
                           const int64_t* inner_indices_data, size_t inner_indices_num,
                           const int64_t* outer_indices_data, size_t outer_indices_num);
 
  void FillSparseTensorBlockSparse(const OrtMemoryInfo* data_mem_info,
                                   const OrtSparseValuesParam& values,
                                   const Shape& indices_shape,
                                   const int32_t* indices_data);
 
#endif
};
 
}  // namespace detail
 
using ConstValue = detail::ConstValueImpl<detail::Unowned<const OrtValue>>;
using UnownedValue = detail::ValueImpl<detail::Unowned<OrtValue>>;
 
struct Value : detail::ValueImpl<OrtValue> {
  using Base = detail::ValueImpl<OrtValue>;
  using Base::Base;
  using OrtSparseValuesParam = detail::OrtSparseValuesParam;
  using Shape = detail::Shape;
 
  explicit Value(std::nullptr_t) {}  
  Value(Value&&) = default;
  Value& operator=(Value&&) = default;
 
  ConstValue GetConst() const { return ConstValue{this->p_}; }
  UnownedValue GetUnowned() const { return UnownedValue{this->p_}; }
 
  template <typename T>
  static Value CreateTensor(const OrtMemoryInfo* info, T* p_data, size_t p_data_element_count,
                            const int64_t* shape, size_t shape_len);
 
  static Value CreateTensor(const OrtMemoryInfo* info, void* p_data, size_t p_data_byte_count,
                            const int64_t* shape, size_t shape_len,
                            ONNXTensorElementDataType type);
 
  static Value CreateTensor(OrtAllocator* deleter, void* p_data, size_t p_data_byte_count,
                            const int64_t* shape, size_t shape_len,
                            ONNXTensorElementDataType type);
 
  template <typename T>
  static Value CreateTensor(OrtAllocator* allocator, const int64_t* shape, size_t shape_len);
 
  static Value CreateTensor(OrtAllocator* allocator, const int64_t* shape, size_t shape_len,
                            ONNXTensorElementDataType type);
 
  static Value CreateMap(const Value& keys, const Value& values);  
 
  static Value CreateSequence(const std::vector<Value>& values);  
 
  template <typename T>
  static Value CreateOpaque(const char* domain, const char* type_name, const T& value);  
 
#if !defined(DISABLE_SPARSE_TENSORS)
  template <typename T>
  static Value CreateSparseTensor(const OrtMemoryInfo* info, T* p_data, const Shape& dense_shape,
                                  const Shape& values_shape);
 
  static Value CreateSparseTensor(const OrtMemoryInfo* info, void* p_data, const Shape& dense_shape,
                                  const Shape& values_shape, ONNXTensorElementDataType type);
 
  template <typename T>
  static Value CreateSparseTensor(OrtAllocator* allocator, const Shape& dense_shape);
 
  static Value CreateSparseTensor(OrtAllocator* allocator, const Shape& dense_shape, ONNXTensorElementDataType type);
 
#endif  // !defined(DISABLE_SPARSE_TENSORS)
};
 
struct MemoryAllocation {
  MemoryAllocation(OrtAllocator* allocator, void* p, size_t size);
  ~MemoryAllocation();
  MemoryAllocation(const MemoryAllocation&) = delete;
  MemoryAllocation& operator=(const MemoryAllocation&) = delete;
  MemoryAllocation(MemoryAllocation&&) noexcept;
  MemoryAllocation& operator=(MemoryAllocation&&) noexcept;
 
  void* get() { return p_; }
  size_t size() const { return size_; }
 
 private:
  OrtAllocator* allocator_;
  void* p_;
  size_t size_;
};
 
namespace detail {
template <typename T>
struct AllocatorImpl : Base<T> {
  using B = Base<T>;
  using B::B;
 
  void* Alloc(size_t size);
  MemoryAllocation GetAllocation(size_t size);
  void Free(void* p);
  ConstMemoryInfo GetInfo() const;
};
 
}  // namespace detail
 
struct AllocatorWithDefaultOptions : detail::AllocatorImpl<detail::Unowned<OrtAllocator>> {
  explicit AllocatorWithDefaultOptions(std::nullptr_t) {}  
  AllocatorWithDefaultOptions();
};
 
struct Allocator : detail::AllocatorImpl<OrtAllocator> {
  explicit Allocator(std::nullptr_t) {}  
  Allocator(const Session& session, const OrtMemoryInfo*);
};
 
using UnownedAllocator = detail::AllocatorImpl<detail::Unowned<OrtAllocator>>;
 
namespace detail {
namespace binding_utils {
// Bring these out of template
std::vector<std::string> GetOutputNamesHelper(const OrtIoBinding* binding, OrtAllocator*);
std::vector<Value> GetOutputValuesHelper(const OrtIoBinding* binding, OrtAllocator*);
}  // namespace binding_utils
 
template <typename T>
struct ConstIoBindingImpl : Base<T> {
  using B = Base<T>;
  using B::B;
 
  std::vector<std::string> GetOutputNames() const;
  std::vector<std::string> GetOutputNames(OrtAllocator*) const;
  std::vector<Value> GetOutputValues() const;
  std::vector<Value> GetOutputValues(OrtAllocator*) const;
};
 
template <typename T>
struct IoBindingImpl : ConstIoBindingImpl<T> {
  using B = ConstIoBindingImpl<T>;
  using B::B;
 
  void BindInput(const char* name, const Value&);
  void BindOutput(const char* name, const Value&);
  void BindOutput(const char* name, const OrtMemoryInfo*);
  void ClearBoundInputs();
  void ClearBoundOutputs();
  void SynchronizeInputs();
  void SynchronizeOutputs();
};
 
}  // namespace detail
 
using ConstIoBinding = detail::ConstIoBindingImpl<detail::Unowned<const OrtIoBinding>>;
using UnownedIoBinding = detail::IoBindingImpl<detail::Unowned<OrtIoBinding>>;
 
struct IoBinding : detail::IoBindingImpl<OrtIoBinding> {
  explicit IoBinding(std::nullptr_t) {}  
  explicit IoBinding(Session& session);
  ConstIoBinding GetConst() const { return ConstIoBinding{this->p_}; }
  UnownedIoBinding GetUnowned() const { return UnownedIoBinding{this->p_}; }
};
 
struct ArenaCfg : detail::Base<OrtArenaCfg> {
  explicit ArenaCfg(std::nullptr_t) {}  
  ArenaCfg(size_t max_mem, int arena_extend_strategy, int initial_chunk_size_bytes, int max_dead_bytes_per_chunk);
};
 
//
// Custom OPs (only needed to implement custom OPs)
//
 
struct OpAttr : detail::Base<OrtOpAttr> {
  using Base = detail::Base<OrtOpAttr>;
  using Base::Base;
 
  explicit OpAttr(std::nullptr_t) {}
  OpAttr(const char* name, const void* data, int len, OrtOpAttrType type);
};
 
#define ORT_CXX_LOG(logger, message_severity, message)                                       \
  do {                                                                                       \
    if (message_severity >= logger.GetLoggingSeverityLevel()) {                              \
      Ort::ThrowOnError(logger.LogMessage(message_severity, ORT_FILE, __LINE__,              \
                                          static_cast<const char*>(__FUNCTION__), message)); \
    }                                                                                        \
  } while (false)
 
#define ORT_CXX_LOG_NOEXCEPT(logger, message_severity, message)                              \
  do {                                                                                       \
    if (message_severity >= logger.GetLoggingSeverityLevel()) {                              \
      static_cast<void>(logger.LogMessage(message_severity, ORT_FILE, __LINE__,              \
                                          static_cast<const char*>(__FUNCTION__), message)); \
    }                                                                                        \
  } while (false)
 
#define ORT_CXX_LOGF(logger, message_severity, /*format,*/...)                                            \
  do {                                                                                                    \
    if (message_severity >= logger.GetLoggingSeverityLevel()) {                                           \
      Ort::ThrowOnError(logger.LogFormattedMessage(message_severity, ORT_FILE, __LINE__,                  \
                                                   static_cast<const char*>(__FUNCTION__), __VA_ARGS__)); \
    }                                                                                                     \
  } while (false)
 
#define ORT_CXX_LOGF_NOEXCEPT(logger, message_severity, /*format,*/...)                                   \
  do {                                                                                                    \
    if (message_severity >= logger.GetLoggingSeverityLevel()) {                                           \
      static_cast<void>(logger.LogFormattedMessage(message_severity, ORT_FILE, __LINE__,                  \
                                                   static_cast<const char*>(__FUNCTION__), __VA_ARGS__)); \
    }                                                                                                     \
  } while (false)
 
struct Logger {
  Logger() = default;
 
  explicit Logger(std::nullptr_t) {}
 
  explicit Logger(const OrtLogger* logger);
 
  ~Logger() = default;
 
  Logger(const Logger&) = default;
  Logger& operator=(const Logger&) = default;
 
  Logger(Logger&& v) noexcept = default;
  Logger& operator=(Logger&& v) noexcept = default;
 
  OrtLoggingLevel GetLoggingSeverityLevel() const noexcept;
 
  Status LogMessage(OrtLoggingLevel log_severity_level, const ORTCHAR_T* file_path, int line_number,
                    const char* func_name, const char* message) const noexcept;
 
  template <typename... Args>
  Status LogFormattedMessage(OrtLoggingLevel log_severity_level, const ORTCHAR_T* file_path, int line_number,
                             const char* func_name, const char* format, Args&&... args) const noexcept;
 
 private:
  const OrtLogger* logger_{};
  OrtLoggingLevel cached_severity_level_{};
};
 
struct KernelContext {
  explicit KernelContext(OrtKernelContext* context);
  size_t GetInputCount() const;
  size_t GetOutputCount() const;
  // If input is optional and is not present, the method returns an empty ConstValue
  // which can be compared to nullptr.
  ConstValue GetInput(size_t index) const;
  // If output is optional and is not present, the method returns an empty UnownedValue
  // which can be compared to nullptr.
  UnownedValue GetOutput(size_t index, const int64_t* dim_values, size_t dim_count) const;
  UnownedValue GetOutput(size_t index, const std::vector<int64_t>& dims) const;
  void* GetGPUComputeStream() const;
  Logger GetLogger() const;
  OrtAllocator* GetAllocator(const OrtMemoryInfo& memory_info) const;
  OrtKernelContext* GetOrtKernelContext() const { return ctx_; }
  void ParallelFor(void (*fn)(void*, size_t), size_t total, size_t num_batch, void* usr_data) const;
 
 private:
  OrtKernelContext* ctx_;
};
 
struct KernelInfo;
 
namespace detail {
namespace attr_utils {
void GetAttr(const OrtKernelInfo* p, const char* name, float&);
void GetAttr(const OrtKernelInfo* p, const char* name, int64_t&);
void GetAttr(const OrtKernelInfo* p, const char* name, std::string&);
void GetAttrs(const OrtKernelInfo* p, const char* name, std::vector<float>&);
void GetAttrs(const OrtKernelInfo* p, const char* name, std::vector<int64_t>&);
}  // namespace attr_utils
 
template <typename T>
struct KernelInfoImpl : Base<T> {
  using B = Base<T>;
  using B::B;
 
  KernelInfo Copy() const;
 
  template <typename R>  // R is only implemented for float, int64_t, and string
  R GetAttribute(const char* name) const {
    R val;
    attr_utils::GetAttr(this->p_, name, val);
    return val;
  }
 
  template <typename R>  // R is only implemented for std::vector<float>, std::vector<int64_t>
  std::vector<R> GetAttributes(const char* name) const {
    std::vector<R> result;
    attr_utils::GetAttrs(this->p_, name, result);
    return result;
  }
 
  Value GetTensorAttribute(const char* name, OrtAllocator* allocator) const;
 
  size_t GetInputCount() const;
  size_t GetOutputCount() const;
 
  std::string GetInputName(size_t index) const;
  std::string GetOutputName(size_t index) const;
 
  TypeInfo GetInputTypeInfo(size_t index) const;
  TypeInfo GetOutputTypeInfo(size_t index) const;
 
  ConstValue GetTensorConstantInput(size_t index, int* is_constant) const;
 
  std::string GetNodeName() const;
  Logger GetLogger() const;
};
 
}  // namespace detail
 
using ConstKernelInfo = detail::KernelInfoImpl<detail::Unowned<const OrtKernelInfo>>;
 
struct KernelInfo : detail::KernelInfoImpl<OrtKernelInfo> {
  using Base = detail::KernelInfoImpl<OrtKernelInfo>;
  using Base::Base;
  explicit KernelInfo(std::nullptr_t) {}     
  explicit KernelInfo(OrtKernelInfo* info);  
  ConstKernelInfo GetConst() const { return ConstKernelInfo{this->p_}; }
};
 
struct Op : detail::Base<OrtOp> {
  using Base = detail::Base<OrtOp>;
  using Base::Base;
 
  explicit Op(std::nullptr_t) {}  
 
  explicit Op(OrtOp*);  
 
  static Op Create(const OrtKernelInfo* info, const char* op_name, const char* domain,
                   int version, const char** type_constraint_names,
                   const ONNXTensorElementDataType* type_constraint_values,
                   size_t type_constraint_count,
                   const OpAttr* attr_values,
                   size_t attr_count,
                   size_t input_count, size_t output_count);
 
  void Invoke(const OrtKernelContext* context,
              const Value* input_values,
              size_t input_count,
              Value* output_values,
              size_t output_count);
 
  // For easier refactoring
  void Invoke(const OrtKernelContext* context,
              const OrtValue* const* input_values,
              size_t input_count,
              OrtValue* const* output_values,
              size_t output_count);
};
 
struct ShapeInferContext {
  struct SymbolicInteger {
    SymbolicInteger(int64_t i) : i_(i), is_int_(true) {};
    SymbolicInteger(const char* s) : s_(s), is_int_(false) {};
    SymbolicInteger(const SymbolicInteger&) = default;
    SymbolicInteger(SymbolicInteger&&) = default;
 
    SymbolicInteger& operator=(const SymbolicInteger&) = default;
    SymbolicInteger& operator=(SymbolicInteger&&) = default;
 
    bool operator==(const SymbolicInteger& dim) const {
      if (is_int_ == dim.is_int_) {
        if (is_int_) {
          return i_ == dim.i_;
        } else {
          return std::string{s_} == std::string{dim.s_};
        }
      }
      return false;
    }
 
    bool IsInt() const { return is_int_; }
    int64_t AsInt() const { return i_; }
    const char* AsSym() const { return s_; }
 
    static constexpr int INVALID_INT_DIM = -2;
 
   private:
    union {
      int64_t i_;
      const char* s_;
    };
    bool is_int_;
  };
 
  using Shape = std::vector<SymbolicInteger>;
 
  ShapeInferContext(const OrtApi* ort_api, OrtShapeInferContext* ctx);
 
  const Shape& GetInputShape(size_t indice) const { return input_shapes_.at(indice); }
 
  size_t GetInputCount() const { return input_shapes_.size(); }
 
  Status SetOutputShape(size_t indice, const Shape& shape, ONNXTensorElementDataType type = ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT);
 
  int64_t GetAttrInt(const char* attr_name);
 
  using Ints = std::vector<int64_t>;
  Ints GetAttrInts(const char* attr_name);
 
  float GetAttrFloat(const char* attr_name);
 
  using Floats = std::vector<float>;
  Floats GetAttrFloats(const char* attr_name);
 
  std::string GetAttrString(const char* attr_name);
 
  using Strings = std::vector<std::string>;
  Strings GetAttrStrings(const char* attr_name);
 
 private:
  const OrtOpAttr* GetAttrHdl(const char* attr_name) const;
  const OrtApi* ort_api_;
  OrtShapeInferContext* ctx_;
  std::vector<Shape> input_shapes_;
};
 
using ShapeInferFn = Ort::Status (*)(Ort::ShapeInferContext&);
 
#define MAX_CUSTOM_OP_END_VER (1UL << 31) - 1
 
template <typename TOp, typename TKernel, bool WithStatus = false>
struct CustomOpBase : OrtCustomOp {
  CustomOpBase() {
    OrtCustomOp::version = ORT_API_VERSION;
    OrtCustomOp::GetName = [](const OrtCustomOp* this_) { return static_cast<const TOp*>(this_)->GetName(); };
 
    OrtCustomOp::GetExecutionProviderType = [](const OrtCustomOp* this_) { return static_cast<const TOp*>(this_)->GetExecutionProviderType(); };
 
    OrtCustomOp::GetInputTypeCount = [](const OrtCustomOp* this_) { return static_cast<const TOp*>(this_)->GetInputTypeCount(); };
    OrtCustomOp::GetInputType = [](const OrtCustomOp* this_, size_t index) { return static_cast<const TOp*>(this_)->GetInputType(index); };
    OrtCustomOp::GetInputMemoryType = [](const OrtCustomOp* this_, size_t index) { return static_cast<const TOp*>(this_)->GetInputMemoryType(index); };
 
    OrtCustomOp::GetOutputTypeCount = [](const OrtCustomOp* this_) { return static_cast<const TOp*>(this_)->GetOutputTypeCount(); };
    OrtCustomOp::GetOutputType = [](const OrtCustomOp* this_, size_t index) { return static_cast<const TOp*>(this_)->GetOutputType(index); };
 
#if defined(_MSC_VER) && !defined(__clang__)
#pragma warning(push)
#pragma warning(disable : 26409)
#endif
    OrtCustomOp::KernelDestroy = [](void* op_kernel) { delete static_cast<TKernel*>(op_kernel); };
#if defined(_MSC_VER) && !defined(__clang__)
#pragma warning(pop)
#endif
    OrtCustomOp::GetInputCharacteristic = [](const OrtCustomOp* this_, size_t index) { return static_cast<const TOp*>(this_)->GetInputCharacteristic(index); };
    OrtCustomOp::GetOutputCharacteristic = [](const OrtCustomOp* this_, size_t index) { return static_cast<const TOp*>(this_)->GetOutputCharacteristic(index); };
 
    OrtCustomOp::GetVariadicInputMinArity = [](const OrtCustomOp* this_) { return static_cast<const TOp*>(this_)->GetVariadicInputMinArity(); };
    OrtCustomOp::GetVariadicInputHomogeneity = [](const OrtCustomOp* this_) { return static_cast<int>(static_cast<const TOp*>(this_)->GetVariadicInputHomogeneity()); };
    OrtCustomOp::GetVariadicOutputMinArity = [](const OrtCustomOp* this_) { return static_cast<const TOp*>(this_)->GetVariadicOutputMinArity(); };
    OrtCustomOp::GetVariadicOutputHomogeneity = [](const OrtCustomOp* this_) { return static_cast<int>(static_cast<const TOp*>(this_)->GetVariadicOutputHomogeneity()); };
#ifdef __cpp_if_constexpr
    if constexpr (WithStatus) {
#else
    if (WithStatus) {
#endif
      OrtCustomOp::CreateKernelV2 = [](const OrtCustomOp* this_, const OrtApi* api, const OrtKernelInfo* info, void** op_kernel) -> OrtStatusPtr {
        return static_cast<const TOp*>(this_)->CreateKernelV2(*api, info, op_kernel);
      };
      OrtCustomOp::KernelComputeV2 = [](void* op_kernel, OrtKernelContext* context) -> OrtStatusPtr {
        return static_cast<TKernel*>(op_kernel)->ComputeV2(context);
      };
    } else {
      OrtCustomOp::CreateKernelV2 = nullptr;
      OrtCustomOp::KernelComputeV2 = nullptr;
 
      OrtCustomOp::CreateKernel = [](const OrtCustomOp* this_, const OrtApi* api, const OrtKernelInfo* info) { return static_cast<const TOp*>(this_)->CreateKernel(*api, info); };
      OrtCustomOp::KernelCompute = [](void* op_kernel, OrtKernelContext* context) {
        static_cast<TKernel*>(op_kernel)->Compute(context);
      };
    }
 
    SetShapeInferFn<TOp>(0);
 
    OrtCustomOp::GetStartVersion = [](const OrtCustomOp* this_) {
      return static_cast<const TOp*>(this_)->start_ver_;
    };
 
    OrtCustomOp::GetEndVersion = [](const OrtCustomOp* this_) {
      return static_cast<const TOp*>(this_)->end_ver_;
    };
 
    OrtCustomOp::GetMayInplace = nullptr;
    OrtCustomOp::ReleaseMayInplace = nullptr;
    OrtCustomOp::GetAliasMap = nullptr;
    OrtCustomOp::ReleaseAliasMap = nullptr;
  }
 
  // Default implementation of GetExecutionProviderType that returns nullptr to default to the CPU provider
  const char* GetExecutionProviderType() const { return nullptr; }
 
  // Default implementations of GetInputCharacteristic() and GetOutputCharacteristic() below
  // (inputs and outputs are required by default)
  OrtCustomOpInputOutputCharacteristic GetInputCharacteristic(size_t /*index*/) const {
    return OrtCustomOpInputOutputCharacteristic::INPUT_OUTPUT_REQUIRED;
  }
 
  OrtCustomOpInputOutputCharacteristic GetOutputCharacteristic(size_t /*index*/) const {
    return OrtCustomOpInputOutputCharacteristic::INPUT_OUTPUT_REQUIRED;
  }
 
  // Default implemention of GetInputMemoryType() that returns OrtMemTypeDefault
  OrtMemType GetInputMemoryType(size_t /*index*/) const {
    return OrtMemTypeDefault;
  }
 
  // Default implementation of GetVariadicInputMinArity() returns 1 to specify that a variadic input
  // should expect at least 1 argument.
  int GetVariadicInputMinArity() const {
    return 1;
  }
 
  // Default implementation of GetVariadicInputHomegeneity() returns true to specify that all arguments
  // to a variadic input should be of the same type.
  bool GetVariadicInputHomogeneity() const {
    return true;
  }
 
  // Default implementation of GetVariadicOutputMinArity() returns 1 to specify that a variadic output
  // should produce at least 1 output value.
  int GetVariadicOutputMinArity() const {
    return 1;
  }
 
  // Default implementation of GetVariadicOutputHomegeneity() returns true to specify that all output values
  // produced by a variadic output should be of the same type.
  bool GetVariadicOutputHomogeneity() const {
    return true;
  }
 
  // Declare list of session config entries used by this Custom Op.
  // Implement this function in order to get configs from CustomOpBase::GetSessionConfigs().
  // This default implementation returns an empty vector of config entries.
  std::vector<std::string> GetSessionConfigKeys() const {
    return std::vector<std::string>{};
  }
 
  // Ort::CustomOpBase derived class should provide the following static method with the type/shape inferencing
  // implementation if needed:
  //   static OrtStatusPtr InferOutputShape(Ort::ShapeInferContext& context)
  template <typename C>
  decltype(&C::InferOutputShape) SetShapeInferFn(decltype(&C::InferOutputShape)) {
    OrtCustomOp::InferOutputShapeFn = [](const OrtCustomOp*, OrtShapeInferContext* ort_ctx) -> OrtStatusPtr {
      ShapeInferContext ctx(&GetApi(), ort_ctx);
      return C::InferOutputShape(ctx);
    };
    return {};
  }
 
  template <typename C>
  void SetShapeInferFn(...) {
    OrtCustomOp::InferOutputShapeFn = {};
  }
 
 protected:
  // Helper function that returns a map of session config entries specified by CustomOpBase::GetSessionConfigKeys.
  void GetSessionConfigs(std::unordered_map<std::string, std::string>& out, ConstSessionOptions options) const;
 
  int start_ver_ = 1;
  int end_ver_ = MAX_CUSTOM_OP_END_VER;
};
 
namespace detail {
template <typename T>
struct ValueInfoImpl : Ort::detail::Base<T> {
  using B = Ort::detail::Base<T>;
  using B::B;
 
  std::string Name() const;
  ConstTypeInfo TypeInfo() const;
};
}  // namespace detail
 
// Const object holder that does not own the underlying object
using ConstValueInfo = detail::ValueInfoImpl<Ort::detail::Unowned<const OrtValueInfo>>;
 
struct ValueInfo : detail::ValueInfoImpl<OrtValueInfo> {
  explicit ValueInfo(std::nullptr_t) {}  
  explicit ValueInfo(OrtValueInfo* p) : ValueInfoImpl<OrtValueInfo>{p} {}
 
  // Create ValueInfo for a tensor
  explicit ValueInfo(const std::string& name, const ConstTypeInfo& type_info);
 
  ConstValueInfo GetConst() const { return ConstValueInfo{this->p_}; }
};
 
namespace detail {
template <typename T>
struct NodeImpl : Ort::detail::Base<T> {
  using B = Ort::detail::Base<T>;
  using B::B;
};
}  // namespace detail
 
struct Node : detail::NodeImpl<OrtNode> {
  explicit Node(std::nullptr_t) {}                     
  explicit Node(OrtNode* p) : NodeImpl<OrtNode>{p} {}  
 
#if !defined(ORT_MINIMAL_BUILD)
  Node(const std::string& operator_name, const std::string& operator_domain,
       const std::string& node_name,
       const std::vector<std::string>& input_names,
       const std::vector<std::string>& output_names);
 
  Node(const std::string& operator_name, const std::string& operator_domain,
       const std::string& node_name,
       const std::vector<std::string>& input_names,
       const std::vector<std::string>& output_names,
       std::vector<OpAttr>& attributes);
 
 private:
  static void Init(const std::string& operator_name, const std::string& operator_domain,
                   const std::string& node_name,
                   const std::vector<std::string>& input_names,
                   const std::vector<std::string>& output_names,
                   std::vector<OpAttr>& attributes,
                   OrtNode*& node);
#endif  // !defined(ORT_MINIMAL_BUILD)
};
 
namespace detail {
template <typename T>
struct GraphImpl : Ort::detail::Base<T> {
  using B = Ort::detail::Base<T>;
  using B::B;
 
#if !defined(ORT_MINIMAL_BUILD)
  void SetInputs(std::vector<ValueInfo>& inputs);
  void SetOutputs(std::vector<ValueInfo>& outputs);
  void AddInitializer(const std::string& name, Value& initializer, bool data_is_external);  // Graph takes ownership of Value
  void AddNode(Node& node);                                                                 // Graph takes ownership of Node
#endif                                                                                      // !defined(ORT_MINIMAL_BUILD)
};
}  // namespace detail
 
struct Graph : detail::GraphImpl<OrtGraph> {
  explicit Graph(std::nullptr_t) {}                        
  explicit Graph(OrtGraph* p) : GraphImpl<OrtGraph>{p} {}  
#if !defined(ORT_MINIMAL_BUILD)
  Graph();
#endif
};
 
namespace detail {
template <typename T>
struct ModelImpl : Ort::detail::Base<T> {
  using B = Ort::detail::Base<T>;
  using B::B;
 
#if !defined(ORT_MINIMAL_BUILD)
  void AddGraph(Graph& graph);
#endif
};
}  // namespace detail
 
// Const object holder that does not own the underlying object
using ConstModel = detail::ModelImpl<Ort::detail::Unowned<const OrtModel>>;
 
struct Model : detail::ModelImpl<OrtModel> {
  using DomainOpsetPair = std::pair<std::string, int>;
 
  explicit Model(std::nullptr_t) {}                        
  explicit Model(OrtModel* p) : ModelImpl<OrtModel>{p} {}  
 
#if !defined(ORT_MINIMAL_BUILD)
  explicit Model(const std::vector<DomainOpsetPair>& opsets);
#endif
 
  ConstModel GetConst() const { return ConstModel{this->p_}; }
};
}  // namespace Ort
#include "onnxruntime_cxx_inline.h"