// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: substrait/function.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2ffunction_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_substrait_2ffunction_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3019003 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_bases.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "substrait/type.pb.h"
#include "substrait/parameterized_types.pb.h"
#include "substrait/type_expressions.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_substrait_2ffunction_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_substrait_2ffunction_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[12]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ffunction_2eproto;
namespace substrait {
class FunctionSignature;
struct FunctionSignatureDefaultTypeInternal;
extern FunctionSignatureDefaultTypeInternal _FunctionSignature_default_instance_;
class FunctionSignature_Aggregate;
struct FunctionSignature_AggregateDefaultTypeInternal;
extern FunctionSignature_AggregateDefaultTypeInternal _FunctionSignature_Aggregate_default_instance_;
class FunctionSignature_Argument;
struct FunctionSignature_ArgumentDefaultTypeInternal;
extern FunctionSignature_ArgumentDefaultTypeInternal _FunctionSignature_Argument_default_instance_;
class FunctionSignature_Argument_EnumArgument;
struct FunctionSignature_Argument_EnumArgumentDefaultTypeInternal;
extern FunctionSignature_Argument_EnumArgumentDefaultTypeInternal _FunctionSignature_Argument_EnumArgument_default_instance_;
class FunctionSignature_Argument_TypeArgument;
struct FunctionSignature_Argument_TypeArgumentDefaultTypeInternal;
extern FunctionSignature_Argument_TypeArgumentDefaultTypeInternal _FunctionSignature_Argument_TypeArgument_default_instance_;
class FunctionSignature_Argument_ValueArgument;
struct FunctionSignature_Argument_ValueArgumentDefaultTypeInternal;
extern FunctionSignature_Argument_ValueArgumentDefaultTypeInternal _FunctionSignature_Argument_ValueArgument_default_instance_;
class FunctionSignature_Description;
struct FunctionSignature_DescriptionDefaultTypeInternal;
extern FunctionSignature_DescriptionDefaultTypeInternal _FunctionSignature_Description_default_instance_;
class FunctionSignature_FinalArgNormal;
struct FunctionSignature_FinalArgNormalDefaultTypeInternal;
extern FunctionSignature_FinalArgNormalDefaultTypeInternal _FunctionSignature_FinalArgNormal_default_instance_;
class FunctionSignature_FinalArgVariadic;
struct FunctionSignature_FinalArgVariadicDefaultTypeInternal;
extern FunctionSignature_FinalArgVariadicDefaultTypeInternal _FunctionSignature_FinalArgVariadic_default_instance_;
class FunctionSignature_Implementation;
struct FunctionSignature_ImplementationDefaultTypeInternal;
extern FunctionSignature_ImplementationDefaultTypeInternal _FunctionSignature_Implementation_default_instance_;
class FunctionSignature_Scalar;
struct FunctionSignature_ScalarDefaultTypeInternal;
extern FunctionSignature_ScalarDefaultTypeInternal _FunctionSignature_Scalar_default_instance_;
class FunctionSignature_Window;
struct FunctionSignature_WindowDefaultTypeInternal;
extern FunctionSignature_WindowDefaultTypeInternal _FunctionSignature_Window_default_instance_;
}  // namespace substrait
PROTOBUF_NAMESPACE_OPEN
template<> ::substrait::FunctionSignature* Arena::CreateMaybeMessage<::substrait::FunctionSignature>(Arena*);
template<> ::substrait::FunctionSignature_Aggregate* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Aggregate>(Arena*);
template<> ::substrait::FunctionSignature_Argument* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Argument>(Arena*);
template<> ::substrait::FunctionSignature_Argument_EnumArgument* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Argument_EnumArgument>(Arena*);
template<> ::substrait::FunctionSignature_Argument_TypeArgument* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Argument_TypeArgument>(Arena*);
template<> ::substrait::FunctionSignature_Argument_ValueArgument* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Argument_ValueArgument>(Arena*);
template<> ::substrait::FunctionSignature_Description* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Description>(Arena*);
template<> ::substrait::FunctionSignature_FinalArgNormal* Arena::CreateMaybeMessage<::substrait::FunctionSignature_FinalArgNormal>(Arena*);
template<> ::substrait::FunctionSignature_FinalArgVariadic* Arena::CreateMaybeMessage<::substrait::FunctionSignature_FinalArgVariadic>(Arena*);
template<> ::substrait::FunctionSignature_Implementation* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Implementation>(Arena*);
template<> ::substrait::FunctionSignature_Scalar* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Scalar>(Arena*);
template<> ::substrait::FunctionSignature_Window* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Window>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace substrait {

enum FunctionSignature_FinalArgVariadic_ParameterConsistency : int {
  FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_UNSPECIFIED = 0,
  FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_CONSISTENT = 1,
  FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_INCONSISTENT = 2,
  FunctionSignature_FinalArgVariadic_ParameterConsistency_FunctionSignature_FinalArgVariadic_ParameterConsistency_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  FunctionSignature_FinalArgVariadic_ParameterConsistency_FunctionSignature_FinalArgVariadic_ParameterConsistency_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool FunctionSignature_FinalArgVariadic_ParameterConsistency_IsValid(int value);
constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MIN = FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_UNSPECIFIED;
constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MAX = FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_INCONSISTENT;
constexpr int FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_ARRAYSIZE = FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor();
template<typename T>
inline const std::string& FunctionSignature_FinalArgVariadic_ParameterConsistency_Name(T enum_t_value) {
  static_assert(::std::is_same<T, FunctionSignature_FinalArgVariadic_ParameterConsistency>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function FunctionSignature_FinalArgVariadic_ParameterConsistency_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor(), enum_t_value);
}
inline bool FunctionSignature_FinalArgVariadic_ParameterConsistency_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FunctionSignature_FinalArgVariadic_ParameterConsistency* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FunctionSignature_FinalArgVariadic_ParameterConsistency>(
    FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor(), name, value);
}
enum FunctionSignature_Window_WindowType : int {
  FunctionSignature_Window_WindowType_WINDOW_TYPE_UNSPECIFIED = 0,
  FunctionSignature_Window_WindowType_WINDOW_TYPE_STREAMING = 1,
  FunctionSignature_Window_WindowType_WINDOW_TYPE_PARTITION = 2,
  FunctionSignature_Window_WindowType_FunctionSignature_Window_WindowType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  FunctionSignature_Window_WindowType_FunctionSignature_Window_WindowType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool FunctionSignature_Window_WindowType_IsValid(int value);
constexpr FunctionSignature_Window_WindowType FunctionSignature_Window_WindowType_WindowType_MIN = FunctionSignature_Window_WindowType_WINDOW_TYPE_UNSPECIFIED;
constexpr FunctionSignature_Window_WindowType FunctionSignature_Window_WindowType_WindowType_MAX = FunctionSignature_Window_WindowType_WINDOW_TYPE_PARTITION;
constexpr int FunctionSignature_Window_WindowType_WindowType_ARRAYSIZE = FunctionSignature_Window_WindowType_WindowType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Window_WindowType_descriptor();
template<typename T>
inline const std::string& FunctionSignature_Window_WindowType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, FunctionSignature_Window_WindowType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function FunctionSignature_Window_WindowType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    FunctionSignature_Window_WindowType_descriptor(), enum_t_value);
}
inline bool FunctionSignature_Window_WindowType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FunctionSignature_Window_WindowType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FunctionSignature_Window_WindowType>(
    FunctionSignature_Window_WindowType_descriptor(), name, value);
}
enum FunctionSignature_Implementation_Type : int {
  FunctionSignature_Implementation_Type_TYPE_UNSPECIFIED = 0,
  FunctionSignature_Implementation_Type_TYPE_WEB_ASSEMBLY = 1,
  FunctionSignature_Implementation_Type_TYPE_TRINO_JAR = 2,
  FunctionSignature_Implementation_Type_FunctionSignature_Implementation_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  FunctionSignature_Implementation_Type_FunctionSignature_Implementation_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool FunctionSignature_Implementation_Type_IsValid(int value);
constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation_Type_Type_MIN = FunctionSignature_Implementation_Type_TYPE_UNSPECIFIED;
constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation_Type_Type_MAX = FunctionSignature_Implementation_Type_TYPE_TRINO_JAR;
constexpr int FunctionSignature_Implementation_Type_Type_ARRAYSIZE = FunctionSignature_Implementation_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Implementation_Type_descriptor();
template<typename T>
inline const std::string& FunctionSignature_Implementation_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, FunctionSignature_Implementation_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function FunctionSignature_Implementation_Type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    FunctionSignature_Implementation_Type_descriptor(), enum_t_value);
}
inline bool FunctionSignature_Implementation_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FunctionSignature_Implementation_Type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FunctionSignature_Implementation_Type>(
    FunctionSignature_Implementation_Type_descriptor(), name, value);
}
// ===================================================================

class FunctionSignature_FinalArgVariadic final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.FinalArgVariadic) */ {
 public:
  inline FunctionSignature_FinalArgVariadic() : FunctionSignature_FinalArgVariadic(nullptr) {}
  ~FunctionSignature_FinalArgVariadic() override;
  explicit constexpr FunctionSignature_FinalArgVariadic(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  FunctionSignature_FinalArgVariadic(const FunctionSignature_FinalArgVariadic& from);
  FunctionSignature_FinalArgVariadic(FunctionSignature_FinalArgVariadic&& from) noexcept
    : FunctionSignature_FinalArgVariadic() {
    *this = ::std::move(from);
  }

  inline FunctionSignature_FinalArgVariadic& operator=(const FunctionSignature_FinalArgVariadic& from) {
    CopyFrom(from);
    return *this;
  }
  inline FunctionSignature_FinalArgVariadic& operator=(FunctionSignature_FinalArgVariadic&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FunctionSignature_FinalArgVariadic& default_instance() {
    return *internal_default_instance();
  }
  static inline const FunctionSignature_FinalArgVariadic* internal_default_instance() {
    return reinterpret_cast<const FunctionSignature_FinalArgVariadic*>(
               &_FunctionSignature_FinalArgVariadic_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(FunctionSignature_FinalArgVariadic& a, FunctionSignature_FinalArgVariadic& b) {
    a.Swap(&b);
  }
  inline void Swap(FunctionSignature_FinalArgVariadic* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FunctionSignature_FinalArgVariadic* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  FunctionSignature_FinalArgVariadic* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FunctionSignature_FinalArgVariadic>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const FunctionSignature_FinalArgVariadic& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const FunctionSignature_FinalArgVariadic& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FunctionSignature_FinalArgVariadic* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.FunctionSignature.FinalArgVariadic";
  }
  protected:
  explicit FunctionSignature_FinalArgVariadic(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef FunctionSignature_FinalArgVariadic_ParameterConsistency ParameterConsistency;
  static constexpr ParameterConsistency PARAMETER_CONSISTENCY_UNSPECIFIED =
    FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_UNSPECIFIED;
  static constexpr ParameterConsistency PARAMETER_CONSISTENCY_CONSISTENT =
    FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_CONSISTENT;
  static constexpr ParameterConsistency PARAMETER_CONSISTENCY_INCONSISTENT =
    FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_INCONSISTENT;
  static inline bool ParameterConsistency_IsValid(int value) {
    return FunctionSignature_FinalArgVariadic_ParameterConsistency_IsValid(value);
  }
  static constexpr ParameterConsistency ParameterConsistency_MIN =
    FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MIN;
  static constexpr ParameterConsistency ParameterConsistency_MAX =
    FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MAX;
  static constexpr int ParameterConsistency_ARRAYSIZE =
    FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ParameterConsistency_descriptor() {
    return FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor();
  }
  template<typename T>
  static inline const std::string& ParameterConsistency_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ParameterConsistency>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ParameterConsistency_Name.");
    return FunctionSignature_FinalArgVariadic_ParameterConsistency_Name(enum_t_value);
  }
  static inline bool ParameterConsistency_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ParameterConsistency* value) {
    return FunctionSignature_FinalArgVariadic_ParameterConsistency_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kMinArgsFieldNumber = 1,
    kMaxArgsFieldNumber = 2,
    kConsistencyFieldNumber = 3,
  };
  // int64 min_args = 1 [json_name = "minArgs"];
  void clear_min_args();
  int64_t min_args() const;
  void set_min_args(int64_t value);
  private:
  int64_t _internal_min_args() const;
  void _internal_set_min_args(int64_t value);
  public:

  // int64 max_args = 2 [json_name = "maxArgs"];
  void clear_max_args();
  int64_t max_args() const;
  void set_max_args(int64_t value);
  private:
  int64_t _internal_max_args() const;
  void _internal_set_max_args(int64_t value);
  public:

  // .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3 [json_name = "consistency"];
  void clear_consistency();
  ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency consistency() const;
  void set_consistency(::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value);
  private:
  ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency _internal_consistency() const;
  void _internal_set_consistency(::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value);
  public:

  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.FinalArgVariadic)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  int64_t min_args_;
  int64_t max_args_;
  int consistency_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ffunction_2eproto;
};
// -------------------------------------------------------------------

class FunctionSignature_FinalArgNormal final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.FinalArgNormal) */ {
 public:
  inline FunctionSignature_FinalArgNormal() : FunctionSignature_FinalArgNormal(nullptr) {}
  explicit constexpr FunctionSignature_FinalArgNormal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  FunctionSignature_FinalArgNormal(const FunctionSignature_FinalArgNormal& from);
  FunctionSignature_FinalArgNormal(FunctionSignature_FinalArgNormal&& from) noexcept
    : FunctionSignature_FinalArgNormal() {
    *this = ::std::move(from);
  }

  inline FunctionSignature_FinalArgNormal& operator=(const FunctionSignature_FinalArgNormal& from) {
    CopyFrom(from);
    return *this;
  }
  inline FunctionSignature_FinalArgNormal& operator=(FunctionSignature_FinalArgNormal&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FunctionSignature_FinalArgNormal& default_instance() {
    return *internal_default_instance();
  }
  static inline const FunctionSignature_FinalArgNormal* internal_default_instance() {
    return reinterpret_cast<const FunctionSignature_FinalArgNormal*>(
               &_FunctionSignature_FinalArgNormal_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(FunctionSignature_FinalArgNormal& a, FunctionSignature_FinalArgNormal& b) {
    a.Swap(&b);
  }
  inline void Swap(FunctionSignature_FinalArgNormal* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FunctionSignature_FinalArgNormal* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  FunctionSignature_FinalArgNormal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FunctionSignature_FinalArgNormal>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const FunctionSignature_FinalArgNormal& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const FunctionSignature_FinalArgNormal& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.FunctionSignature.FinalArgNormal";
  }
  protected:
  explicit FunctionSignature_FinalArgNormal(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.FinalArgNormal)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ffunction_2eproto;
};
// -------------------------------------------------------------------

class FunctionSignature_Scalar final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Scalar) */ {
 public:
  inline FunctionSignature_Scalar() : FunctionSignature_Scalar(nullptr) {}
  ~FunctionSignature_Scalar() override;
  explicit constexpr FunctionSignature_Scalar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  FunctionSignature_Scalar(const FunctionSignature_Scalar& from);
  FunctionSignature_Scalar(FunctionSignature_Scalar&& from) noexcept
    : FunctionSignature_Scalar() {
    *this = ::std::move(from);
  }

  inline FunctionSignature_Scalar& operator=(const FunctionSignature_Scalar& from) {
    CopyFrom(from);
    return *this;
  }
  inline FunctionSignature_Scalar& operator=(FunctionSignature_Scalar&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FunctionSignature_Scalar& default_instance() {
    return *internal_default_instance();
  }
  enum FinalVariableBehaviorCase {
    kVariadic = 10,
    kNormal = 11,
    FINAL_VARIABLE_BEHAVIOR_NOT_SET = 0,
  };

  static inline const FunctionSignature_Scalar* internal_default_instance() {
    return reinterpret_cast<const FunctionSignature_Scalar*>(
               &_FunctionSignature_Scalar_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(FunctionSignature_Scalar& a, FunctionSignature_Scalar& b) {
    a.Swap(&b);
  }
  inline void Swap(FunctionSignature_Scalar* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FunctionSignature_Scalar* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  FunctionSignature_Scalar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FunctionSignature_Scalar>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const FunctionSignature_Scalar& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const FunctionSignature_Scalar& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FunctionSignature_Scalar* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.FunctionSignature.Scalar";
  }
  protected:
  explicit FunctionSignature_Scalar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kArgumentsFieldNumber = 2,
    kNameFieldNumber = 3,
    kImplementationsFieldNumber = 12,
    kDescriptionFieldNumber = 4,
    kOutputTypeFieldNumber = 9,
    kDeterministicFieldNumber = 7,
    kSessionDependentFieldNumber = 8,
    kVariadicFieldNumber = 10,
    kNormalFieldNumber = 11,
  };
  // repeated .substrait.FunctionSignature.Argument arguments = 2 [json_name = "arguments"];
  int arguments_size() const;
  private:
  int _internal_arguments_size() const;
  public:
  void clear_arguments();
  ::substrait::FunctionSignature_Argument* mutable_arguments(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >*
      mutable_arguments();
  private:
  const ::substrait::FunctionSignature_Argument& _internal_arguments(int index) const;
  ::substrait::FunctionSignature_Argument* _internal_add_arguments();
  public:
  const ::substrait::FunctionSignature_Argument& arguments(int index) const;
  ::substrait::FunctionSignature_Argument* add_arguments();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >&
      arguments() const;

  // repeated string name = 3 [json_name = "name"];
  int name_size() const;
  private:
  int _internal_name_size() const;
  public:
  void clear_name();
  const std::string& name(int index) const;
  std::string* mutable_name(int index);
  void set_name(int index, const std::string& value);
  void set_name(int index, std::string&& value);
  void set_name(int index, const char* value);
  void set_name(int index, const char* value, size_t size);
  std::string* add_name();
  void add_name(const std::string& value);
  void add_name(std::string&& value);
  void add_name(const char* value);
  void add_name(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& name() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_name();
  private:
  const std::string& _internal_name(int index) const;
  std::string* _internal_add_name();
  public:

  // repeated .substrait.FunctionSignature.Implementation implementations = 12 [json_name = "implementations"];
  int implementations_size() const;
  private:
  int _internal_implementations_size() const;
  public:
  void clear_implementations();
  ::substrait::FunctionSignature_Implementation* mutable_implementations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >*
      mutable_implementations();
  private:
  const ::substrait::FunctionSignature_Implementation& _internal_implementations(int index) const;
  ::substrait::FunctionSignature_Implementation* _internal_add_implementations();
  public:
  const ::substrait::FunctionSignature_Implementation& implementations(int index) const;
  ::substrait::FunctionSignature_Implementation* add_implementations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >&
      implementations() const;

  // .substrait.FunctionSignature.Description description = 4 [json_name = "description"];
  bool has_description() const;
  private:
  bool _internal_has_description() const;
  public:
  void clear_description();
  const ::substrait::FunctionSignature_Description& description() const;
  PROTOBUF_NODISCARD ::substrait::FunctionSignature_Description* release_description();
  ::substrait::FunctionSignature_Description* mutable_description();
  void set_allocated_description(::substrait::FunctionSignature_Description* description);
  private:
  const ::substrait::FunctionSignature_Description& _internal_description() const;
  ::substrait::FunctionSignature_Description* _internal_mutable_description();
  public:
  void unsafe_arena_set_allocated_description(
      ::substrait::FunctionSignature_Description* description);
  ::substrait::FunctionSignature_Description* unsafe_arena_release_description();

  // .substrait.DerivationExpression output_type = 9 [json_name = "outputType"];
  bool has_output_type() const;
  private:
  bool _internal_has_output_type() const;
  public:
  void clear_output_type();
  const ::substrait::DerivationExpression& output_type() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_output_type();
  ::substrait::DerivationExpression* mutable_output_type();
  void set_allocated_output_type(::substrait::DerivationExpression* output_type);
  private:
  const ::substrait::DerivationExpression& _internal_output_type() const;
  ::substrait::DerivationExpression* _internal_mutable_output_type();
  public:
  void unsafe_arena_set_allocated_output_type(
      ::substrait::DerivationExpression* output_type);
  ::substrait::DerivationExpression* unsafe_arena_release_output_type();

  // bool deterministic = 7 [json_name = "deterministic"];
  void clear_deterministic();
  bool deterministic() const;
  void set_deterministic(bool value);
  private:
  bool _internal_deterministic() const;
  void _internal_set_deterministic(bool value);
  public:

  // bool session_dependent = 8 [json_name = "sessionDependent"];
  void clear_session_dependent();
  bool session_dependent() const;
  void set_session_dependent(bool value);
  private:
  bool _internal_session_dependent() const;
  void _internal_set_session_dependent(bool value);
  public:

  // .substrait.FunctionSignature.FinalArgVariadic variadic = 10 [json_name = "variadic"];
  bool has_variadic() const;
  private:
  bool _internal_has_variadic() const;
  public:
  void clear_variadic();
  const ::substrait::FunctionSignature_FinalArgVariadic& variadic() const;
  PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgVariadic* release_variadic();
  ::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic();
  void set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic);
  private:
  const ::substrait::FunctionSignature_FinalArgVariadic& _internal_variadic() const;
  ::substrait::FunctionSignature_FinalArgVariadic* _internal_mutable_variadic();
  public:
  void unsafe_arena_set_allocated_variadic(
      ::substrait::FunctionSignature_FinalArgVariadic* variadic);
  ::substrait::FunctionSignature_FinalArgVariadic* unsafe_arena_release_variadic();

  // .substrait.FunctionSignature.FinalArgNormal normal = 11 [json_name = "normal"];
  bool has_normal() const;
  private:
  bool _internal_has_normal() const;
  public:
  void clear_normal();
  const ::substrait::FunctionSignature_FinalArgNormal& normal() const;
  PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgNormal* release_normal();
  ::substrait::FunctionSignature_FinalArgNormal* mutable_normal();
  void set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal);
  private:
  const ::substrait::FunctionSignature_FinalArgNormal& _internal_normal() const;
  ::substrait::FunctionSignature_FinalArgNormal* _internal_mutable_normal();
  public:
  void unsafe_arena_set_allocated_normal(
      ::substrait::FunctionSignature_FinalArgNormal* normal);
  ::substrait::FunctionSignature_FinalArgNormal* unsafe_arena_release_normal();

  void clear_final_variable_behavior();
  FinalVariableBehaviorCase final_variable_behavior_case() const;
  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Scalar)
 private:
  class _Internal;
  void set_has_variadic();
  void set_has_normal();

  inline bool has_final_variable_behavior() const;
  inline void clear_has_final_variable_behavior();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument > arguments_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> name_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation > implementations_;
  ::substrait::FunctionSignature_Description* description_;
  ::substrait::DerivationExpression* output_type_;
  bool deterministic_;
  bool session_dependent_;
  union FinalVariableBehaviorUnion {
    constexpr FinalVariableBehaviorUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::substrait::FunctionSignature_FinalArgVariadic* variadic_;
    ::substrait::FunctionSignature_FinalArgNormal* normal_;
  } final_variable_behavior_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  uint32_t _oneof_case_[1];

  friend struct ::TableStruct_substrait_2ffunction_2eproto;
};
// -------------------------------------------------------------------

class FunctionSignature_Aggregate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Aggregate) */ {
 public:
  inline FunctionSignature_Aggregate() : FunctionSignature_Aggregate(nullptr) {}
  ~FunctionSignature_Aggregate() override;
  explicit constexpr FunctionSignature_Aggregate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  FunctionSignature_Aggregate(const FunctionSignature_Aggregate& from);
  FunctionSignature_Aggregate(FunctionSignature_Aggregate&& from) noexcept
    : FunctionSignature_Aggregate() {
    *this = ::std::move(from);
  }

  inline FunctionSignature_Aggregate& operator=(const FunctionSignature_Aggregate& from) {
    CopyFrom(from);
    return *this;
  }
  inline FunctionSignature_Aggregate& operator=(FunctionSignature_Aggregate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FunctionSignature_Aggregate& default_instance() {
    return *internal_default_instance();
  }
  enum FinalVariableBehaviorCase {
    kVariadic = 10,
    kNormal = 11,
    FINAL_VARIABLE_BEHAVIOR_NOT_SET = 0,
  };

  static inline const FunctionSignature_Aggregate* internal_default_instance() {
    return reinterpret_cast<const FunctionSignature_Aggregate*>(
               &_FunctionSignature_Aggregate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(FunctionSignature_Aggregate& a, FunctionSignature_Aggregate& b) {
    a.Swap(&b);
  }
  inline void Swap(FunctionSignature_Aggregate* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FunctionSignature_Aggregate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  FunctionSignature_Aggregate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FunctionSignature_Aggregate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const FunctionSignature_Aggregate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const FunctionSignature_Aggregate& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FunctionSignature_Aggregate* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.FunctionSignature.Aggregate";
  }
  protected:
  explicit FunctionSignature_Aggregate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kArgumentsFieldNumber = 2,
    kImplementationsFieldNumber = 15,
    kNameFieldNumber = 3,
    kDescriptionFieldNumber = 4,
    kOutputTypeFieldNumber = 9,
    kIntermediateTypeFieldNumber = 13,
    kDeterministicFieldNumber = 7,
    kSessionDependentFieldNumber = 8,
    kOrderedFieldNumber = 14,
    kMaxSetFieldNumber = 12,
    kVariadicFieldNumber = 10,
    kNormalFieldNumber = 11,
  };
  // repeated .substrait.FunctionSignature.Argument arguments = 2 [json_name = "arguments"];
  int arguments_size() const;
  private:
  int _internal_arguments_size() const;
  public:
  void clear_arguments();
  ::substrait::FunctionSignature_Argument* mutable_arguments(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >*
      mutable_arguments();
  private:
  const ::substrait::FunctionSignature_Argument& _internal_arguments(int index) const;
  ::substrait::FunctionSignature_Argument* _internal_add_arguments();
  public:
  const ::substrait::FunctionSignature_Argument& arguments(int index) const;
  ::substrait::FunctionSignature_Argument* add_arguments();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >&
      arguments() const;

  // repeated .substrait.FunctionSignature.Implementation implementations = 15 [json_name = "implementations"];
  int implementations_size() const;
  private:
  int _internal_implementations_size() const;
  public:
  void clear_implementations();
  ::substrait::FunctionSignature_Implementation* mutable_implementations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >*
      mutable_implementations();
  private:
  const ::substrait::FunctionSignature_Implementation& _internal_implementations(int index) const;
  ::substrait::FunctionSignature_Implementation* _internal_add_implementations();
  public:
  const ::substrait::FunctionSignature_Implementation& implementations(int index) const;
  ::substrait::FunctionSignature_Implementation* add_implementations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >&
      implementations() const;

  // string name = 3 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .substrait.FunctionSignature.Description description = 4 [json_name = "description"];
  bool has_description() const;
  private:
  bool _internal_has_description() const;
  public:
  void clear_description();
  const ::substrait::FunctionSignature_Description& description() const;
  PROTOBUF_NODISCARD ::substrait::FunctionSignature_Description* release_description();
  ::substrait::FunctionSignature_Description* mutable_description();
  void set_allocated_description(::substrait::FunctionSignature_Description* description);
  private:
  const ::substrait::FunctionSignature_Description& _internal_description() const;
  ::substrait::FunctionSignature_Description* _internal_mutable_description();
  public:
  void unsafe_arena_set_allocated_description(
      ::substrait::FunctionSignature_Description* description);
  ::substrait::FunctionSignature_Description* unsafe_arena_release_description();

  // .substrait.DerivationExpression output_type = 9 [json_name = "outputType"];
  bool has_output_type() const;
  private:
  bool _internal_has_output_type() const;
  public:
  void clear_output_type();
  const ::substrait::DerivationExpression& output_type() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_output_type();
  ::substrait::DerivationExpression* mutable_output_type();
  void set_allocated_output_type(::substrait::DerivationExpression* output_type);
  private:
  const ::substrait::DerivationExpression& _internal_output_type() const;
  ::substrait::DerivationExpression* _internal_mutable_output_type();
  public:
  void unsafe_arena_set_allocated_output_type(
      ::substrait::DerivationExpression* output_type);
  ::substrait::DerivationExpression* unsafe_arena_release_output_type();

  // .substrait.Type intermediate_type = 13 [json_name = "intermediateType"];
  bool has_intermediate_type() const;
  private:
  bool _internal_has_intermediate_type() const;
  public:
  void clear_intermediate_type();
  const ::substrait::Type& intermediate_type() const;
  PROTOBUF_NODISCARD ::substrait::Type* release_intermediate_type();
  ::substrait::Type* mutable_intermediate_type();
  void set_allocated_intermediate_type(::substrait::Type* intermediate_type);
  private:
  const ::substrait::Type& _internal_intermediate_type() const;
  ::substrait::Type* _internal_mutable_intermediate_type();
  public:
  void unsafe_arena_set_allocated_intermediate_type(
      ::substrait::Type* intermediate_type);
  ::substrait::Type* unsafe_arena_release_intermediate_type();

  // bool deterministic = 7 [json_name = "deterministic"];
  void clear_deterministic();
  bool deterministic() const;
  void set_deterministic(bool value);
  private:
  bool _internal_deterministic() const;
  void _internal_set_deterministic(bool value);
  public:

  // bool session_dependent = 8 [json_name = "sessionDependent"];
  void clear_session_dependent();
  bool session_dependent() const;
  void set_session_dependent(bool value);
  private:
  bool _internal_session_dependent() const;
  void _internal_set_session_dependent(bool value);
  public:

  // bool ordered = 14 [json_name = "ordered"];
  void clear_ordered();
  bool ordered() const;
  void set_ordered(bool value);
  private:
  bool _internal_ordered() const;
  void _internal_set_ordered(bool value);
  public:

  // uint64 max_set = 12 [json_name = "maxSet"];
  void clear_max_set();
  uint64_t max_set() const;
  void set_max_set(uint64_t value);
  private:
  uint64_t _internal_max_set() const;
  void _internal_set_max_set(uint64_t value);
  public:

  // .substrait.FunctionSignature.FinalArgVariadic variadic = 10 [json_name = "variadic"];
  bool has_variadic() const;
  private:
  bool _internal_has_variadic() const;
  public:
  void clear_variadic();
  const ::substrait::FunctionSignature_FinalArgVariadic& variadic() const;
  PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgVariadic* release_variadic();
  ::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic();
  void set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic);
  private:
  const ::substrait::FunctionSignature_FinalArgVariadic& _internal_variadic() const;
  ::substrait::FunctionSignature_FinalArgVariadic* _internal_mutable_variadic();
  public:
  void unsafe_arena_set_allocated_variadic(
      ::substrait::FunctionSignature_FinalArgVariadic* variadic);
  ::substrait::FunctionSignature_FinalArgVariadic* unsafe_arena_release_variadic();

  // .substrait.FunctionSignature.FinalArgNormal normal = 11 [json_name = "normal"];
  bool has_normal() const;
  private:
  bool _internal_has_normal() const;
  public:
  void clear_normal();
  const ::substrait::FunctionSignature_FinalArgNormal& normal() const;
  PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgNormal* release_normal();
  ::substrait::FunctionSignature_FinalArgNormal* mutable_normal();
  void set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal);
  private:
  const ::substrait::FunctionSignature_FinalArgNormal& _internal_normal() const;
  ::substrait::FunctionSignature_FinalArgNormal* _internal_mutable_normal();
  public:
  void unsafe_arena_set_allocated_normal(
      ::substrait::FunctionSignature_FinalArgNormal* normal);
  ::substrait::FunctionSignature_FinalArgNormal* unsafe_arena_release_normal();

  void clear_final_variable_behavior();
  FinalVariableBehaviorCase final_variable_behavior_case() const;
  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Aggregate)
 private:
  class _Internal;
  void set_has_variadic();
  void set_has_normal();

  inline bool has_final_variable_behavior() const;
  inline void clear_has_final_variable_behavior();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument > arguments_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation > implementations_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::substrait::FunctionSignature_Description* description_;
  ::substrait::DerivationExpression* output_type_;
  ::substrait::Type* intermediate_type_;
  bool deterministic_;
  bool session_dependent_;
  bool ordered_;
  uint64_t max_set_;
  union FinalVariableBehaviorUnion {
    constexpr FinalVariableBehaviorUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::substrait::FunctionSignature_FinalArgVariadic* variadic_;
    ::substrait::FunctionSignature_FinalArgNormal* normal_;
  } final_variable_behavior_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  uint32_t _oneof_case_[1];

  friend struct ::TableStruct_substrait_2ffunction_2eproto;
};
// -------------------------------------------------------------------

class FunctionSignature_Window final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Window) */ {
 public:
  inline FunctionSignature_Window() : FunctionSignature_Window(nullptr) {}
  ~FunctionSignature_Window() override;
  explicit constexpr FunctionSignature_Window(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  FunctionSignature_Window(const FunctionSignature_Window& from);
  FunctionSignature_Window(FunctionSignature_Window&& from) noexcept
    : FunctionSignature_Window() {
    *this = ::std::move(from);
  }

  inline FunctionSignature_Window& operator=(const FunctionSignature_Window& from) {
    CopyFrom(from);
    return *this;
  }
  inline FunctionSignature_Window& operator=(FunctionSignature_Window&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FunctionSignature_Window& default_instance() {
    return *internal_default_instance();
  }
  enum FinalVariableBehaviorCase {
    kVariadic = 16,
    kNormal = 17,
    FINAL_VARIABLE_BEHAVIOR_NOT_SET = 0,
  };

  static inline const FunctionSignature_Window* internal_default_instance() {
    return reinterpret_cast<const FunctionSignature_Window*>(
               &_FunctionSignature_Window_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(FunctionSignature_Window& a, FunctionSignature_Window& b) {
    a.Swap(&b);
  }
  inline void Swap(FunctionSignature_Window* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FunctionSignature_Window* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  FunctionSignature_Window* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FunctionSignature_Window>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const FunctionSignature_Window& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const FunctionSignature_Window& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FunctionSignature_Window* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.FunctionSignature.Window";
  }
  protected:
  explicit FunctionSignature_Window(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef FunctionSignature_Window_WindowType WindowType;
  static constexpr WindowType WINDOW_TYPE_UNSPECIFIED =
    FunctionSignature_Window_WindowType_WINDOW_TYPE_UNSPECIFIED;
  static constexpr WindowType WINDOW_TYPE_STREAMING =
    FunctionSignature_Window_WindowType_WINDOW_TYPE_STREAMING;
  static constexpr WindowType WINDOW_TYPE_PARTITION =
    FunctionSignature_Window_WindowType_WINDOW_TYPE_PARTITION;
  static inline bool WindowType_IsValid(int value) {
    return FunctionSignature_Window_WindowType_IsValid(value);
  }
  static constexpr WindowType WindowType_MIN =
    FunctionSignature_Window_WindowType_WindowType_MIN;
  static constexpr WindowType WindowType_MAX =
    FunctionSignature_Window_WindowType_WindowType_MAX;
  static constexpr int WindowType_ARRAYSIZE =
    FunctionSignature_Window_WindowType_WindowType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  WindowType_descriptor() {
    return FunctionSignature_Window_WindowType_descriptor();
  }
  template<typename T>
  static inline const std::string& WindowType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, WindowType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function WindowType_Name.");
    return FunctionSignature_Window_WindowType_Name(enum_t_value);
  }
  static inline bool WindowType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      WindowType* value) {
    return FunctionSignature_Window_WindowType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kArgumentsFieldNumber = 2,
    kNameFieldNumber = 3,
    kImplementationsFieldNumber = 15,
    kDescriptionFieldNumber = 4,
    kIntermediateTypeFieldNumber = 9,
    kOutputTypeFieldNumber = 10,
    kDeterministicFieldNumber = 7,
    kSessionDependentFieldNumber = 8,
    kOrderedFieldNumber = 11,
    kWindowTypeFieldNumber = 14,
    kMaxSetFieldNumber = 12,
    kVariadicFieldNumber = 16,
    kNormalFieldNumber = 17,
  };
  // repeated .substrait.FunctionSignature.Argument arguments = 2 [json_name = "arguments"];
  int arguments_size() const;
  private:
  int _internal_arguments_size() const;
  public:
  void clear_arguments();
  ::substrait::FunctionSignature_Argument* mutable_arguments(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >*
      mutable_arguments();
  private:
  const ::substrait::FunctionSignature_Argument& _internal_arguments(int index) const;
  ::substrait::FunctionSignature_Argument* _internal_add_arguments();
  public:
  const ::substrait::FunctionSignature_Argument& arguments(int index) const;
  ::substrait::FunctionSignature_Argument* add_arguments();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >&
      arguments() const;

  // repeated string name = 3 [json_name = "name"];
  int name_size() const;
  private:
  int _internal_name_size() const;
  public:
  void clear_name();
  const std::string& name(int index) const;
  std::string* mutable_name(int index);
  void set_name(int index, const std::string& value);
  void set_name(int index, std::string&& value);
  void set_name(int index, const char* value);
  void set_name(int index, const char* value, size_t size);
  std::string* add_name();
  void add_name(const std::string& value);
  void add_name(std::string&& value);
  void add_name(const char* value);
  void add_name(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& name() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_name();
  private:
  const std::string& _internal_name(int index) const;
  std::string* _internal_add_name();
  public:

  // repeated .substrait.FunctionSignature.Implementation implementations = 15 [json_name = "implementations"];
  int implementations_size() const;
  private:
  int _internal_implementations_size() const;
  public:
  void clear_implementations();
  ::substrait::FunctionSignature_Implementation* mutable_implementations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >*
      mutable_implementations();
  private:
  const ::substrait::FunctionSignature_Implementation& _internal_implementations(int index) const;
  ::substrait::FunctionSignature_Implementation* _internal_add_implementations();
  public:
  const ::substrait::FunctionSignature_Implementation& implementations(int index) const;
  ::substrait::FunctionSignature_Implementation* add_implementations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >&
      implementations() const;

  // .substrait.FunctionSignature.Description description = 4 [json_name = "description"];
  bool has_description() const;
  private:
  bool _internal_has_description() const;
  public:
  void clear_description();
  const ::substrait::FunctionSignature_Description& description() const;
  PROTOBUF_NODISCARD ::substrait::FunctionSignature_Description* release_description();
  ::substrait::FunctionSignature_Description* mutable_description();
  void set_allocated_description(::substrait::FunctionSignature_Description* description);
  private:
  const ::substrait::FunctionSignature_Description& _internal_description() const;
  ::substrait::FunctionSignature_Description* _internal_mutable_description();
  public:
  void unsafe_arena_set_allocated_description(
      ::substrait::FunctionSignature_Description* description);
  ::substrait::FunctionSignature_Description* unsafe_arena_release_description();

  // .substrait.DerivationExpression intermediate_type = 9 [json_name = "intermediateType"];
  bool has_intermediate_type() const;
  private:
  bool _internal_has_intermediate_type() const;
  public:
  void clear_intermediate_type();
  const ::substrait::DerivationExpression& intermediate_type() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_intermediate_type();
  ::substrait::DerivationExpression* mutable_intermediate_type();
  void set_allocated_intermediate_type(::substrait::DerivationExpression* intermediate_type);
  private:
  const ::substrait::DerivationExpression& _internal_intermediate_type() const;
  ::substrait::DerivationExpression* _internal_mutable_intermediate_type();
  public:
  void unsafe_arena_set_allocated_intermediate_type(
      ::substrait::DerivationExpression* intermediate_type);
  ::substrait::DerivationExpression* unsafe_arena_release_intermediate_type();

  // .substrait.DerivationExpression output_type = 10 [json_name = "outputType"];
  bool has_output_type() const;
  private:
  bool _internal_has_output_type() const;
  public:
  void clear_output_type();
  const ::substrait::DerivationExpression& output_type() const;
  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_output_type();
  ::substrait::DerivationExpression* mutable_output_type();
  void set_allocated_output_type(::substrait::DerivationExpression* output_type);
  private:
  const ::substrait::DerivationExpression& _internal_output_type() const;
  ::substrait::DerivationExpression* _internal_mutable_output_type();
  public:
  void unsafe_arena_set_allocated_output_type(
      ::substrait::DerivationExpression* output_type);
  ::substrait::DerivationExpression* unsafe_arena_release_output_type();

  // bool deterministic = 7 [json_name = "deterministic"];
  void clear_deterministic();
  bool deterministic() const;
  void set_deterministic(bool value);
  private:
  bool _internal_deterministic() const;
  void _internal_set_deterministic(bool value);
  public:

  // bool session_dependent = 8 [json_name = "sessionDependent"];
  void clear_session_dependent();
  bool session_dependent() const;
  void set_session_dependent(bool value);
  private:
  bool _internal_session_dependent() const;
  void _internal_set_session_dependent(bool value);
  public:

  // bool ordered = 11 [json_name = "ordered"];
  void clear_ordered();
  bool ordered() const;
  void set_ordered(bool value);
  private:
  bool _internal_ordered() const;
  void _internal_set_ordered(bool value);
  public:

  // .substrait.FunctionSignature.Window.WindowType window_type = 14 [json_name = "windowType"];
  void clear_window_type();
  ::substrait::FunctionSignature_Window_WindowType window_type() const;
  void set_window_type(::substrait::FunctionSignature_Window_WindowType value);
  private:
  ::substrait::FunctionSignature_Window_WindowType _internal_window_type() const;
  void _internal_set_window_type(::substrait::FunctionSignature_Window_WindowType value);
  public:

  // uint64 max_set = 12 [json_name = "maxSet"];
  void clear_max_set();
  uint64_t max_set() const;
  void set_max_set(uint64_t value);
  private:
  uint64_t _internal_max_set() const;
  void _internal_set_max_set(uint64_t value);
  public:

  // .substrait.FunctionSignature.FinalArgVariadic variadic = 16 [json_name = "variadic"];
  bool has_variadic() const;
  private:
  bool _internal_has_variadic() const;
  public:
  void clear_variadic();
  const ::substrait::FunctionSignature_FinalArgVariadic& variadic() const;
  PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgVariadic* release_variadic();
  ::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic();
  void set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic);
  private:
  const ::substrait::FunctionSignature_FinalArgVariadic& _internal_variadic() const;
  ::substrait::FunctionSignature_FinalArgVariadic* _internal_mutable_variadic();
  public:
  void unsafe_arena_set_allocated_variadic(
      ::substrait::FunctionSignature_FinalArgVariadic* variadic);
  ::substrait::FunctionSignature_FinalArgVariadic* unsafe_arena_release_variadic();

  // .substrait.FunctionSignature.FinalArgNormal normal = 17 [json_name = "normal"];
  bool has_normal() const;
  private:
  bool _internal_has_normal() const;
  public:
  void clear_normal();
  const ::substrait::FunctionSignature_FinalArgNormal& normal() const;
  PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgNormal* release_normal();
  ::substrait::FunctionSignature_FinalArgNormal* mutable_normal();
  void set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal);
  private:
  const ::substrait::FunctionSignature_FinalArgNormal& _internal_normal() const;
  ::substrait::FunctionSignature_FinalArgNormal* _internal_mutable_normal();
  public:
  void unsafe_arena_set_allocated_normal(
      ::substrait::FunctionSignature_FinalArgNormal* normal);
  ::substrait::FunctionSignature_FinalArgNormal* unsafe_arena_release_normal();

  void clear_final_variable_behavior();
  FinalVariableBehaviorCase final_variable_behavior_case() const;
  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Window)
 private:
  class _Internal;
  void set_has_variadic();
  void set_has_normal();

  inline bool has_final_variable_behavior() const;
  inline void clear_has_final_variable_behavior();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument > arguments_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> name_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation > implementations_;
  ::substrait::FunctionSignature_Description* description_;
  ::substrait::DerivationExpression* intermediate_type_;
  ::substrait::DerivationExpression* output_type_;
  bool deterministic_;
  bool session_dependent_;
  bool ordered_;
  int window_type_;
  uint64_t max_set_;
  union FinalVariableBehaviorUnion {
    constexpr FinalVariableBehaviorUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::substrait::FunctionSignature_FinalArgVariadic* variadic_;
    ::substrait::FunctionSignature_FinalArgNormal* normal_;
  } final_variable_behavior_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  uint32_t _oneof_case_[1];

  friend struct ::TableStruct_substrait_2ffunction_2eproto;
};
// -------------------------------------------------------------------

class FunctionSignature_Description final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Description) */ {
 public:
  inline FunctionSignature_Description() : FunctionSignature_Description(nullptr) {}
  ~FunctionSignature_Description() override;
  explicit constexpr FunctionSignature_Description(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  FunctionSignature_Description(const FunctionSignature_Description& from);
  FunctionSignature_Description(FunctionSignature_Description&& from) noexcept
    : FunctionSignature_Description() {
    *this = ::std::move(from);
  }

  inline FunctionSignature_Description& operator=(const FunctionSignature_Description& from) {
    CopyFrom(from);
    return *this;
  }
  inline FunctionSignature_Description& operator=(FunctionSignature_Description&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FunctionSignature_Description& default_instance() {
    return *internal_default_instance();
  }
  static inline const FunctionSignature_Description* internal_default_instance() {
    return reinterpret_cast<const FunctionSignature_Description*>(
               &_FunctionSignature_Description_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(FunctionSignature_Description& a, FunctionSignature_Description& b) {
    a.Swap(&b);
  }
  inline void Swap(FunctionSignature_Description* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FunctionSignature_Description* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  FunctionSignature_Description* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FunctionSignature_Description>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const FunctionSignature_Description& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const FunctionSignature_Description& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FunctionSignature_Description* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.FunctionSignature.Description";
  }
  protected:
  explicit FunctionSignature_Description(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLanguageFieldNumber = 1,
    kBodyFieldNumber = 2,
  };
  // string language = 1 [json_name = "language"];
  void clear_language();
  const std::string& language() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_language(ArgT0&& arg0, ArgT... args);
  std::string* mutable_language();
  PROTOBUF_NODISCARD std::string* release_language();
  void set_allocated_language(std::string* language);
  private:
  const std::string& _internal_language() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_language(const std::string& value);
  std::string* _internal_mutable_language();
  public:

  // string body = 2 [json_name = "body"];
  void clear_body();
  const std::string& body() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_body(ArgT0&& arg0, ArgT... args);
  std::string* mutable_body();
  PROTOBUF_NODISCARD std::string* release_body();
  void set_allocated_body(std::string* body);
  private:
  const std::string& _internal_body() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_body(const std::string& value);
  std::string* _internal_mutable_body();
  public:

  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Description)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr language_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ffunction_2eproto;
};
// -------------------------------------------------------------------

class FunctionSignature_Implementation final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Implementation) */ {
 public:
  inline FunctionSignature_Implementation() : FunctionSignature_Implementation(nullptr) {}
  ~FunctionSignature_Implementation() override;
  explicit constexpr FunctionSignature_Implementation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  FunctionSignature_Implementation(const FunctionSignature_Implementation& from);
  FunctionSignature_Implementation(FunctionSignature_Implementation&& from) noexcept
    : FunctionSignature_Implementation() {
    *this = ::std::move(from);
  }

  inline FunctionSignature_Implementation& operator=(const FunctionSignature_Implementation& from) {
    CopyFrom(from);
    return *this;
  }
  inline FunctionSignature_Implementation& operator=(FunctionSignature_Implementation&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FunctionSignature_Implementation& default_instance() {
    return *internal_default_instance();
  }
  static inline const FunctionSignature_Implementation* internal_default_instance() {
    return reinterpret_cast<const FunctionSignature_Implementation*>(
               &_FunctionSignature_Implementation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(FunctionSignature_Implementation& a, FunctionSignature_Implementation& b) {
    a.Swap(&b);
  }
  inline void Swap(FunctionSignature_Implementation* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FunctionSignature_Implementation* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  FunctionSignature_Implementation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FunctionSignature_Implementation>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const FunctionSignature_Implementation& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const FunctionSignature_Implementation& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FunctionSignature_Implementation* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.FunctionSignature.Implementation";
  }
  protected:
  explicit FunctionSignature_Implementation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef FunctionSignature_Implementation_Type Type;
  static constexpr Type TYPE_UNSPECIFIED =
    FunctionSignature_Implementation_Type_TYPE_UNSPECIFIED;
  static constexpr Type TYPE_WEB_ASSEMBLY =
    FunctionSignature_Implementation_Type_TYPE_WEB_ASSEMBLY;
  static constexpr Type TYPE_TRINO_JAR =
    FunctionSignature_Implementation_Type_TYPE_TRINO_JAR;
  static inline bool Type_IsValid(int value) {
    return FunctionSignature_Implementation_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    FunctionSignature_Implementation_Type_Type_MIN;
  static constexpr Type Type_MAX =
    FunctionSignature_Implementation_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    FunctionSignature_Implementation_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return FunctionSignature_Implementation_Type_descriptor();
  }
  template<typename T>
  static inline const std::string& Type_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Type>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Type_Name.");
    return FunctionSignature_Implementation_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return FunctionSignature_Implementation_Type_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kUriFieldNumber = 2,
    kTypeFieldNumber = 1,
  };
  // string uri = 2 [json_name = "uri"];
  void clear_uri();
  const std::string& uri() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_uri(ArgT0&& arg0, ArgT... args);
  std::string* mutable_uri();
  PROTOBUF_NODISCARD std::string* release_uri();
  void set_allocated_uri(std::string* uri);
  private:
  const std::string& _internal_uri() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri(const std::string& value);
  std::string* _internal_mutable_uri();
  public:

  // .substrait.FunctionSignature.Implementation.Type type = 1 [json_name = "type"];
  void clear_type();
  ::substrait::FunctionSignature_Implementation_Type type() const;
  void set_type(::substrait::FunctionSignature_Implementation_Type value);
  private:
  ::substrait::FunctionSignature_Implementation_Type _internal_type() const;
  void _internal_set_type(::substrait::FunctionSignature_Implementation_Type value);
  public:

  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Implementation)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_;
  int type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ffunction_2eproto;
};
// -------------------------------------------------------------------

class FunctionSignature_Argument_ValueArgument final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Argument.ValueArgument) */ {
 public:
  inline FunctionSignature_Argument_ValueArgument() : FunctionSignature_Argument_ValueArgument(nullptr) {}
  ~FunctionSignature_Argument_ValueArgument() override;
  explicit constexpr FunctionSignature_Argument_ValueArgument(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  FunctionSignature_Argument_ValueArgument(const FunctionSignature_Argument_ValueArgument& from);
  FunctionSignature_Argument_ValueArgument(FunctionSignature_Argument_ValueArgument&& from) noexcept
    : FunctionSignature_Argument_ValueArgument() {
    *this = ::std::move(from);
  }

  inline FunctionSignature_Argument_ValueArgument& operator=(const FunctionSignature_Argument_ValueArgument& from) {
    CopyFrom(from);
    return *this;
  }
  inline FunctionSignature_Argument_ValueArgument& operator=(FunctionSignature_Argument_ValueArgument&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FunctionSignature_Argument_ValueArgument& default_instance() {
    return *internal_default_instance();
  }
  static inline const FunctionSignature_Argument_ValueArgument* internal_default_instance() {
    return reinterpret_cast<const FunctionSignature_Argument_ValueArgument*>(
               &_FunctionSignature_Argument_ValueArgument_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(FunctionSignature_Argument_ValueArgument& a, FunctionSignature_Argument_ValueArgument& b) {
    a.Swap(&b);
  }
  inline void Swap(FunctionSignature_Argument_ValueArgument* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FunctionSignature_Argument_ValueArgument* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  FunctionSignature_Argument_ValueArgument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FunctionSignature_Argument_ValueArgument>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const FunctionSignature_Argument_ValueArgument& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const FunctionSignature_Argument_ValueArgument& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FunctionSignature_Argument_ValueArgument* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.FunctionSignature.Argument.ValueArgument";
  }
  protected:
  explicit FunctionSignature_Argument_ValueArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTypeFieldNumber = 1,
    kConstantFieldNumber = 2,
  };
  // .substrait.ParameterizedType type = 1 [json_name = "type"];
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  const ::substrait::ParameterizedType& type() const;
  PROTOBUF_NODISCARD ::substrait::ParameterizedType* release_type();
  ::substrait::ParameterizedType* mutable_type();
  void set_allocated_type(::substrait::ParameterizedType* type);
  private:
  const ::substrait::ParameterizedType& _internal_type() const;
  ::substrait::ParameterizedType* _internal_mutable_type();
  public:
  void unsafe_arena_set_allocated_type(
      ::substrait::ParameterizedType* type);
  ::substrait::ParameterizedType* unsafe_arena_release_type();

  // bool constant = 2 [json_name = "constant"];
  void clear_constant();
  bool constant() const;
  void set_constant(bool value);
  private:
  bool _internal_constant() const;
  void _internal_set_constant(bool value);
  public:

  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Argument.ValueArgument)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::substrait::ParameterizedType* type_;
  bool constant_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ffunction_2eproto;
};
// -------------------------------------------------------------------

class FunctionSignature_Argument_TypeArgument final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Argument.TypeArgument) */ {
 public:
  inline FunctionSignature_Argument_TypeArgument() : FunctionSignature_Argument_TypeArgument(nullptr) {}
  ~FunctionSignature_Argument_TypeArgument() override;
  explicit constexpr FunctionSignature_Argument_TypeArgument(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  FunctionSignature_Argument_TypeArgument(const FunctionSignature_Argument_TypeArgument& from);
  FunctionSignature_Argument_TypeArgument(FunctionSignature_Argument_TypeArgument&& from) noexcept
    : FunctionSignature_Argument_TypeArgument() {
    *this = ::std::move(from);
  }

  inline FunctionSignature_Argument_TypeArgument& operator=(const FunctionSignature_Argument_TypeArgument& from) {
    CopyFrom(from);
    return *this;
  }
  inline FunctionSignature_Argument_TypeArgument& operator=(FunctionSignature_Argument_TypeArgument&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FunctionSignature_Argument_TypeArgument& default_instance() {
    return *internal_default_instance();
  }
  static inline const FunctionSignature_Argument_TypeArgument* internal_default_instance() {
    return reinterpret_cast<const FunctionSignature_Argument_TypeArgument*>(
               &_FunctionSignature_Argument_TypeArgument_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(FunctionSignature_Argument_TypeArgument& a, FunctionSignature_Argument_TypeArgument& b) {
    a.Swap(&b);
  }
  inline void Swap(FunctionSignature_Argument_TypeArgument* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FunctionSignature_Argument_TypeArgument* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  FunctionSignature_Argument_TypeArgument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FunctionSignature_Argument_TypeArgument>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const FunctionSignature_Argument_TypeArgument& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const FunctionSignature_Argument_TypeArgument& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FunctionSignature_Argument_TypeArgument* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.FunctionSignature.Argument.TypeArgument";
  }
  protected:
  explicit FunctionSignature_Argument_TypeArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTypeFieldNumber = 1,
  };
  // .substrait.ParameterizedType type = 1 [json_name = "type"];
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  const ::substrait::ParameterizedType& type() const;
  PROTOBUF_NODISCARD ::substrait::ParameterizedType* release_type();
  ::substrait::ParameterizedType* mutable_type();
  void set_allocated_type(::substrait::ParameterizedType* type);
  private:
  const ::substrait::ParameterizedType& _internal_type() const;
  ::substrait::ParameterizedType* _internal_mutable_type();
  public:
  void unsafe_arena_set_allocated_type(
      ::substrait::ParameterizedType* type);
  ::substrait::ParameterizedType* unsafe_arena_release_type();

  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Argument.TypeArgument)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::substrait::ParameterizedType* type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ffunction_2eproto;
};
// -------------------------------------------------------------------

class FunctionSignature_Argument_EnumArgument final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Argument.EnumArgument) */ {
 public:
  inline FunctionSignature_Argument_EnumArgument() : FunctionSignature_Argument_EnumArgument(nullptr) {}
  ~FunctionSignature_Argument_EnumArgument() override;
  explicit constexpr FunctionSignature_Argument_EnumArgument(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  FunctionSignature_Argument_EnumArgument(const FunctionSignature_Argument_EnumArgument& from);
  FunctionSignature_Argument_EnumArgument(FunctionSignature_Argument_EnumArgument&& from) noexcept
    : FunctionSignature_Argument_EnumArgument() {
    *this = ::std::move(from);
  }

  inline FunctionSignature_Argument_EnumArgument& operator=(const FunctionSignature_Argument_EnumArgument& from) {
    CopyFrom(from);
    return *this;
  }
  inline FunctionSignature_Argument_EnumArgument& operator=(FunctionSignature_Argument_EnumArgument&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FunctionSignature_Argument_EnumArgument& default_instance() {
    return *internal_default_instance();
  }
  static inline const FunctionSignature_Argument_EnumArgument* internal_default_instance() {
    return reinterpret_cast<const FunctionSignature_Argument_EnumArgument*>(
               &_FunctionSignature_Argument_EnumArgument_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(FunctionSignature_Argument_EnumArgument& a, FunctionSignature_Argument_EnumArgument& b) {
    a.Swap(&b);
  }
  inline void Swap(FunctionSignature_Argument_EnumArgument* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FunctionSignature_Argument_EnumArgument* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  FunctionSignature_Argument_EnumArgument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FunctionSignature_Argument_EnumArgument>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const FunctionSignature_Argument_EnumArgument& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const FunctionSignature_Argument_EnumArgument& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FunctionSignature_Argument_EnumArgument* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.FunctionSignature.Argument.EnumArgument";
  }
  protected:
  explicit FunctionSignature_Argument_EnumArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kOptionsFieldNumber = 1,
    kOptionalFieldNumber = 2,
  };
  // repeated string options = 1 [json_name = "options"];
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  const std::string& options(int index) const;
  std::string* mutable_options(int index);
  void set_options(int index, const std::string& value);
  void set_options(int index, std::string&& value);
  void set_options(int index, const char* value);
  void set_options(int index, const char* value, size_t size);
  std::string* add_options();
  void add_options(const std::string& value);
  void add_options(std::string&& value);
  void add_options(const char* value);
  void add_options(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& options() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_options();
  private:
  const std::string& _internal_options(int index) const;
  std::string* _internal_add_options();
  public:

  // bool optional = 2 [json_name = "optional"];
  void clear_optional();
  bool optional() const;
  void set_optional(bool value);
  private:
  bool _internal_optional() const;
  void _internal_set_optional(bool value);
  public:

  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Argument.EnumArgument)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> options_;
  bool optional_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ffunction_2eproto;
};
// -------------------------------------------------------------------

class FunctionSignature_Argument final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Argument) */ {
 public:
  inline FunctionSignature_Argument() : FunctionSignature_Argument(nullptr) {}
  ~FunctionSignature_Argument() override;
  explicit constexpr FunctionSignature_Argument(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  FunctionSignature_Argument(const FunctionSignature_Argument& from);
  FunctionSignature_Argument(FunctionSignature_Argument&& from) noexcept
    : FunctionSignature_Argument() {
    *this = ::std::move(from);
  }

  inline FunctionSignature_Argument& operator=(const FunctionSignature_Argument& from) {
    CopyFrom(from);
    return *this;
  }
  inline FunctionSignature_Argument& operator=(FunctionSignature_Argument&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FunctionSignature_Argument& default_instance() {
    return *internal_default_instance();
  }
  enum ArgumentKindCase {
    kValue = 2,
    kType = 3,
    kEnum = 4,
    ARGUMENT_KIND_NOT_SET = 0,
  };

  static inline const FunctionSignature_Argument* internal_default_instance() {
    return reinterpret_cast<const FunctionSignature_Argument*>(
               &_FunctionSignature_Argument_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(FunctionSignature_Argument& a, FunctionSignature_Argument& b) {
    a.Swap(&b);
  }
  inline void Swap(FunctionSignature_Argument* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FunctionSignature_Argument* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  FunctionSignature_Argument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FunctionSignature_Argument>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const FunctionSignature_Argument& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const FunctionSignature_Argument& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FunctionSignature_Argument* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.FunctionSignature.Argument";
  }
  protected:
  explicit FunctionSignature_Argument(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef FunctionSignature_Argument_ValueArgument ValueArgument;
  typedef FunctionSignature_Argument_TypeArgument TypeArgument;
  typedef FunctionSignature_Argument_EnumArgument EnumArgument;

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
    kValueFieldNumber = 2,
    kTypeFieldNumber = 3,
    kEnumFieldNumber = 4,
  };
  // string name = 1 [json_name = "name"];
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .substrait.FunctionSignature.Argument.ValueArgument value = 2 [json_name = "value"];
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  const ::substrait::FunctionSignature_Argument_ValueArgument& value() const;
  PROTOBUF_NODISCARD ::substrait::FunctionSignature_Argument_ValueArgument* release_value();
  ::substrait::FunctionSignature_Argument_ValueArgument* mutable_value();
  void set_allocated_value(::substrait::FunctionSignature_Argument_ValueArgument* value);
  private:
  const ::substrait::FunctionSignature_Argument_ValueArgument& _internal_value() const;
  ::substrait::FunctionSignature_Argument_ValueArgument* _internal_mutable_value();
  public:
  void unsafe_arena_set_allocated_value(
      ::substrait::FunctionSignature_Argument_ValueArgument* value);
  ::substrait::FunctionSignature_Argument_ValueArgument* unsafe_arena_release_value();

  // .substrait.FunctionSignature.Argument.TypeArgument type = 3 [json_name = "type"];
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  const ::substrait::FunctionSignature_Argument_TypeArgument& type() const;
  PROTOBUF_NODISCARD ::substrait::FunctionSignature_Argument_TypeArgument* release_type();
  ::substrait::FunctionSignature_Argument_TypeArgument* mutable_type();
  void set_allocated_type(::substrait::FunctionSignature_Argument_TypeArgument* type);
  private:
  const ::substrait::FunctionSignature_Argument_TypeArgument& _internal_type() const;
  ::substrait::FunctionSignature_Argument_TypeArgument* _internal_mutable_type();
  public:
  void unsafe_arena_set_allocated_type(
      ::substrait::FunctionSignature_Argument_TypeArgument* type);
  ::substrait::FunctionSignature_Argument_TypeArgument* unsafe_arena_release_type();

  // .substrait.FunctionSignature.Argument.EnumArgument enum = 4 [json_name = "enum"];
  bool has_enum_() const;
  private:
  bool _internal_has_enum_() const;
  public:
  void clear_enum_();
  const ::substrait::FunctionSignature_Argument_EnumArgument& enum_() const;
  PROTOBUF_NODISCARD ::substrait::FunctionSignature_Argument_EnumArgument* release_enum_();
  ::substrait::FunctionSignature_Argument_EnumArgument* mutable_enum_();
  void set_allocated_enum_(::substrait::FunctionSignature_Argument_EnumArgument* enum_);
  private:
  const ::substrait::FunctionSignature_Argument_EnumArgument& _internal_enum_() const;
  ::substrait::FunctionSignature_Argument_EnumArgument* _internal_mutable_enum_();
  public:
  void unsafe_arena_set_allocated_enum_(
      ::substrait::FunctionSignature_Argument_EnumArgument* enum_);
  ::substrait::FunctionSignature_Argument_EnumArgument* unsafe_arena_release_enum_();

  void clear_argument_kind();
  ArgumentKindCase argument_kind_case() const;
  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Argument)
 private:
  class _Internal;
  void set_has_value();
  void set_has_type();
  void set_has_enum_();

  inline bool has_argument_kind() const;
  inline void clear_has_argument_kind();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  union ArgumentKindUnion {
    constexpr ArgumentKindUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::substrait::FunctionSignature_Argument_ValueArgument* value_;
    ::substrait::FunctionSignature_Argument_TypeArgument* type_;
    ::substrait::FunctionSignature_Argument_EnumArgument* enum__;
  } argument_kind_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  uint32_t _oneof_case_[1];

  friend struct ::TableStruct_substrait_2ffunction_2eproto;
};
// -------------------------------------------------------------------

class FunctionSignature final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature) */ {
 public:
  inline FunctionSignature() : FunctionSignature(nullptr) {}
  explicit constexpr FunctionSignature(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  FunctionSignature(const FunctionSignature& from);
  FunctionSignature(FunctionSignature&& from) noexcept
    : FunctionSignature() {
    *this = ::std::move(from);
  }

  inline FunctionSignature& operator=(const FunctionSignature& from) {
    CopyFrom(from);
    return *this;
  }
  inline FunctionSignature& operator=(FunctionSignature&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FunctionSignature& default_instance() {
    return *internal_default_instance();
  }
  static inline const FunctionSignature* internal_default_instance() {
    return reinterpret_cast<const FunctionSignature*>(
               &_FunctionSignature_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(FunctionSignature& a, FunctionSignature& b) {
    a.Swap(&b);
  }
  inline void Swap(FunctionSignature* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FunctionSignature* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  FunctionSignature* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FunctionSignature>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const FunctionSignature& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const FunctionSignature& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "substrait.FunctionSignature";
  }
  protected:
  explicit FunctionSignature(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef FunctionSignature_FinalArgVariadic FinalArgVariadic;
  typedef FunctionSignature_FinalArgNormal FinalArgNormal;
  typedef FunctionSignature_Scalar Scalar;
  typedef FunctionSignature_Aggregate Aggregate;
  typedef FunctionSignature_Window Window;
  typedef FunctionSignature_Description Description;
  typedef FunctionSignature_Implementation Implementation;
  typedef FunctionSignature_Argument Argument;

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_substrait_2ffunction_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// FunctionSignature_FinalArgVariadic

// int64 min_args = 1 [json_name = "minArgs"];
inline void FunctionSignature_FinalArgVariadic::clear_min_args() {
  min_args_ = int64_t{0};
}
inline int64_t FunctionSignature_FinalArgVariadic::_internal_min_args() const {
  return min_args_;
}
inline int64_t FunctionSignature_FinalArgVariadic::min_args() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.FinalArgVariadic.min_args)
  return _internal_min_args();
}
inline void FunctionSignature_FinalArgVariadic::_internal_set_min_args(int64_t value) {
  
  min_args_ = value;
}
inline void FunctionSignature_FinalArgVariadic::set_min_args(int64_t value) {
  _internal_set_min_args(value);
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.FinalArgVariadic.min_args)
}

// int64 max_args = 2 [json_name = "maxArgs"];
inline void FunctionSignature_FinalArgVariadic::clear_max_args() {
  max_args_ = int64_t{0};
}
inline int64_t FunctionSignature_FinalArgVariadic::_internal_max_args() const {
  return max_args_;
}
inline int64_t FunctionSignature_FinalArgVariadic::max_args() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.FinalArgVariadic.max_args)
  return _internal_max_args();
}
inline void FunctionSignature_FinalArgVariadic::_internal_set_max_args(int64_t value) {
  
  max_args_ = value;
}
inline void FunctionSignature_FinalArgVariadic::set_max_args(int64_t value) {
  _internal_set_max_args(value);
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.FinalArgVariadic.max_args)
}

// .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3 [json_name = "consistency"];
inline void FunctionSignature_FinalArgVariadic::clear_consistency() {
  consistency_ = 0;
}
inline ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::_internal_consistency() const {
  return static_cast< ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency >(consistency_);
}
inline ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::consistency() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.FinalArgVariadic.consistency)
  return _internal_consistency();
}
inline void FunctionSignature_FinalArgVariadic::_internal_set_consistency(::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value) {
  
  consistency_ = value;
}
inline void FunctionSignature_FinalArgVariadic::set_consistency(::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value) {
  _internal_set_consistency(value);
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.FinalArgVariadic.consistency)
}

// -------------------------------------------------------------------

// FunctionSignature_FinalArgNormal

// -------------------------------------------------------------------

// FunctionSignature_Scalar

// repeated .substrait.FunctionSignature.Argument arguments = 2 [json_name = "arguments"];
inline int FunctionSignature_Scalar::_internal_arguments_size() const {
  return arguments_.size();
}
inline int FunctionSignature_Scalar::arguments_size() const {
  return _internal_arguments_size();
}
inline void FunctionSignature_Scalar::clear_arguments() {
  arguments_.Clear();
}
inline ::substrait::FunctionSignature_Argument* FunctionSignature_Scalar::mutable_arguments(int index) {
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.arguments)
  return arguments_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >*
FunctionSignature_Scalar::mutable_arguments() {
  // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Scalar.arguments)
  return &arguments_;
}
inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Scalar::_internal_arguments(int index) const {
  return arguments_.Get(index);
}
inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Scalar::arguments(int index) const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.arguments)
  return _internal_arguments(index);
}
inline ::substrait::FunctionSignature_Argument* FunctionSignature_Scalar::_internal_add_arguments() {
  return arguments_.Add();
}
inline ::substrait::FunctionSignature_Argument* FunctionSignature_Scalar::add_arguments() {
  ::substrait::FunctionSignature_Argument* _add = _internal_add_arguments();
  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Scalar.arguments)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >&
FunctionSignature_Scalar::arguments() const {
  // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Scalar.arguments)
  return arguments_;
}

// repeated string name = 3 [json_name = "name"];
inline int FunctionSignature_Scalar::_internal_name_size() const {
  return name_.size();
}
inline int FunctionSignature_Scalar::name_size() const {
  return _internal_name_size();
}
inline void FunctionSignature_Scalar::clear_name() {
  name_.Clear();
}
inline std::string* FunctionSignature_Scalar::add_name() {
  std::string* _s = _internal_add_name();
  // @@protoc_insertion_point(field_add_mutable:substrait.FunctionSignature.Scalar.name)
  return _s;
}
inline const std::string& FunctionSignature_Scalar::_internal_name(int index) const {
  return name_.Get(index);
}
inline const std::string& FunctionSignature_Scalar::name(int index) const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.name)
  return _internal_name(index);
}
inline std::string* FunctionSignature_Scalar::mutable_name(int index) {
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.name)
  return name_.Mutable(index);
}
inline void FunctionSignature_Scalar::set_name(int index, const std::string& value) {
  name_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Scalar.name)
}
inline void FunctionSignature_Scalar::set_name(int index, std::string&& value) {
  name_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Scalar.name)
}
inline void FunctionSignature_Scalar::set_name(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  name_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:substrait.FunctionSignature.Scalar.name)
}
inline void FunctionSignature_Scalar::set_name(int index, const char* value, size_t size) {
  name_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:substrait.FunctionSignature.Scalar.name)
}
inline std::string* FunctionSignature_Scalar::_internal_add_name() {
  return name_.Add();
}
inline void FunctionSignature_Scalar::add_name(const std::string& value) {
  name_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Scalar.name)
}
inline void FunctionSignature_Scalar::add_name(std::string&& value) {
  name_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Scalar.name)
}
inline void FunctionSignature_Scalar::add_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  name_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:substrait.FunctionSignature.Scalar.name)
}
inline void FunctionSignature_Scalar::add_name(const char* value, size_t size) {
  name_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:substrait.FunctionSignature.Scalar.name)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
FunctionSignature_Scalar::name() const {
  // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Scalar.name)
  return name_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
FunctionSignature_Scalar::mutable_name() {
  // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Scalar.name)
  return &name_;
}

// .substrait.FunctionSignature.Description description = 4 [json_name = "description"];
inline bool FunctionSignature_Scalar::_internal_has_description() const {
  return this != internal_default_instance() && description_ != nullptr;
}
inline bool FunctionSignature_Scalar::has_description() const {
  return _internal_has_description();
}
inline void FunctionSignature_Scalar::clear_description() {
  if (GetArenaForAllocation() == nullptr && description_ != nullptr) {
    delete description_;
  }
  description_ = nullptr;
}
inline const ::substrait::FunctionSignature_Description& FunctionSignature_Scalar::_internal_description() const {
  const ::substrait::FunctionSignature_Description* p = description_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::FunctionSignature_Description&>(
      ::substrait::_FunctionSignature_Description_default_instance_);
}
inline const ::substrait::FunctionSignature_Description& FunctionSignature_Scalar::description() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.description)
  return _internal_description();
}
inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_description(
    ::substrait::FunctionSignature_Description* description) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(description_);
  }
  description_ = description;
  if (description) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Scalar.description)
}
inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::release_description() {
  
  ::substrait::FunctionSignature_Description* temp = description_;
  description_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::unsafe_arena_release_description() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Scalar.description)
  
  ::substrait::FunctionSignature_Description* temp = description_;
  description_ = nullptr;
  return temp;
}
inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::_internal_mutable_description() {
  
  if (description_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::FunctionSignature_Description>(GetArenaForAllocation());
    description_ = p;
  }
  return description_;
}
inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::mutable_description() {
  ::substrait::FunctionSignature_Description* _msg = _internal_mutable_description();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.description)
  return _msg;
}
inline void FunctionSignature_Scalar::set_allocated_description(::substrait::FunctionSignature_Description* description) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete description_;
  }
  if (description) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Description>::GetOwningArena(description);
    if (message_arena != submessage_arena) {
      description = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, description, submessage_arena);
    }
    
  } else {
    
  }
  description_ = description;
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Scalar.description)
}

// bool deterministic = 7 [json_name = "deterministic"];
inline void FunctionSignature_Scalar::clear_deterministic() {
  deterministic_ = false;
}
inline bool FunctionSignature_Scalar::_internal_deterministic() const {
  return deterministic_;
}
inline bool FunctionSignature_Scalar::deterministic() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.deterministic)
  return _internal_deterministic();
}
inline void FunctionSignature_Scalar::_internal_set_deterministic(bool value) {
  
  deterministic_ = value;
}
inline void FunctionSignature_Scalar::set_deterministic(bool value) {
  _internal_set_deterministic(value);
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Scalar.deterministic)
}

// bool session_dependent = 8 [json_name = "sessionDependent"];
inline void FunctionSignature_Scalar::clear_session_dependent() {
  session_dependent_ = false;
}
inline bool FunctionSignature_Scalar::_internal_session_dependent() const {
  return session_dependent_;
}
inline bool FunctionSignature_Scalar::session_dependent() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.session_dependent)
  return _internal_session_dependent();
}
inline void FunctionSignature_Scalar::_internal_set_session_dependent(bool value) {
  
  session_dependent_ = value;
}
inline void FunctionSignature_Scalar::set_session_dependent(bool value) {
  _internal_set_session_dependent(value);
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Scalar.session_dependent)
}

// .substrait.DerivationExpression output_type = 9 [json_name = "outputType"];
inline bool FunctionSignature_Scalar::_internal_has_output_type() const {
  return this != internal_default_instance() && output_type_ != nullptr;
}
inline bool FunctionSignature_Scalar::has_output_type() const {
  return _internal_has_output_type();
}
inline const ::substrait::DerivationExpression& FunctionSignature_Scalar::_internal_output_type() const {
  const ::substrait::DerivationExpression* p = output_type_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
      ::substrait::_DerivationExpression_default_instance_);
}
inline const ::substrait::DerivationExpression& FunctionSignature_Scalar::output_type() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.output_type)
  return _internal_output_type();
}
inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_output_type(
    ::substrait::DerivationExpression* output_type) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_);
  }
  output_type_ = output_type;
  if (output_type) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Scalar.output_type)
}
inline ::substrait::DerivationExpression* FunctionSignature_Scalar::release_output_type() {
  
  ::substrait::DerivationExpression* temp = output_type_;
  output_type_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression* FunctionSignature_Scalar::unsafe_arena_release_output_type() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Scalar.output_type)
  
  ::substrait::DerivationExpression* temp = output_type_;
  output_type_ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression* FunctionSignature_Scalar::_internal_mutable_output_type() {
  
  if (output_type_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
    output_type_ = p;
  }
  return output_type_;
}
inline ::substrait::DerivationExpression* FunctionSignature_Scalar::mutable_output_type() {
  ::substrait::DerivationExpression* _msg = _internal_mutable_output_type();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.output_type)
  return _msg;
}
inline void FunctionSignature_Scalar::set_allocated_output_type(::substrait::DerivationExpression* output_type) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_);
  }
  if (output_type) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type));
    if (message_arena != submessage_arena) {
      output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, output_type, submessage_arena);
    }
    
  } else {
    
  }
  output_type_ = output_type;
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Scalar.output_type)
}

// .substrait.FunctionSignature.FinalArgVariadic variadic = 10 [json_name = "variadic"];
inline bool FunctionSignature_Scalar::_internal_has_variadic() const {
  return final_variable_behavior_case() == kVariadic;
}
inline bool FunctionSignature_Scalar::has_variadic() const {
  return _internal_has_variadic();
}
inline void FunctionSignature_Scalar::set_has_variadic() {
  _oneof_case_[0] = kVariadic;
}
inline void FunctionSignature_Scalar::clear_variadic() {
  if (_internal_has_variadic()) {
    if (GetArenaForAllocation() == nullptr) {
      delete final_variable_behavior_.variadic_;
    }
    clear_has_final_variable_behavior();
  }
}
inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::release_variadic() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Scalar.variadic)
  if (_internal_has_variadic()) {
    clear_has_final_variable_behavior();
      ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    final_variable_behavior_.variadic_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Scalar::_internal_variadic() const {
  return _internal_has_variadic()
      ? *final_variable_behavior_.variadic_
      : reinterpret_cast< ::substrait::FunctionSignature_FinalArgVariadic&>(::substrait::_FunctionSignature_FinalArgVariadic_default_instance_);
}
inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Scalar::variadic() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.variadic)
  return _internal_variadic();
}
inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::unsafe_arena_release_variadic() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Scalar.variadic)
  if (_internal_has_variadic()) {
    clear_has_final_variable_behavior();
    ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_;
    final_variable_behavior_.variadic_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) {
  clear_final_variable_behavior();
  if (variadic) {
    set_has_variadic();
    final_variable_behavior_.variadic_ = variadic;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Scalar.variadic)
}
inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::_internal_mutable_variadic() {
  if (!_internal_has_variadic()) {
    clear_final_variable_behavior();
    set_has_variadic();
    final_variable_behavior_.variadic_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(GetArenaForAllocation());
  }
  return final_variable_behavior_.variadic_;
}
inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::mutable_variadic() {
  ::substrait::FunctionSignature_FinalArgVariadic* _msg = _internal_mutable_variadic();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.variadic)
  return _msg;
}

// .substrait.FunctionSignature.FinalArgNormal normal = 11 [json_name = "normal"];
inline bool FunctionSignature_Scalar::_internal_has_normal() const {
  return final_variable_behavior_case() == kNormal;
}
inline bool FunctionSignature_Scalar::has_normal() const {
  return _internal_has_normal();
}
inline void FunctionSignature_Scalar::set_has_normal() {
  _oneof_case_[0] = kNormal;
}
inline void FunctionSignature_Scalar::clear_normal() {
  if (_internal_has_normal()) {
    if (GetArenaForAllocation() == nullptr) {
      delete final_variable_behavior_.normal_;
    }
    clear_has_final_variable_behavior();
  }
}
inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::release_normal() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Scalar.normal)
  if (_internal_has_normal()) {
    clear_has_final_variable_behavior();
      ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    final_variable_behavior_.normal_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Scalar::_internal_normal() const {
  return _internal_has_normal()
      ? *final_variable_behavior_.normal_
      : reinterpret_cast< ::substrait::FunctionSignature_FinalArgNormal&>(::substrait::_FunctionSignature_FinalArgNormal_default_instance_);
}
inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Scalar::normal() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.normal)
  return _internal_normal();
}
inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::unsafe_arena_release_normal() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Scalar.normal)
  if (_internal_has_normal()) {
    clear_has_final_variable_behavior();
    ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_;
    final_variable_behavior_.normal_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) {
  clear_final_variable_behavior();
  if (normal) {
    set_has_normal();
    final_variable_behavior_.normal_ = normal;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Scalar.normal)
}
inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::_internal_mutable_normal() {
  if (!_internal_has_normal()) {
    clear_final_variable_behavior();
    set_has_normal();
    final_variable_behavior_.normal_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(GetArenaForAllocation());
  }
  return final_variable_behavior_.normal_;
}
inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::mutable_normal() {
  ::substrait::FunctionSignature_FinalArgNormal* _msg = _internal_mutable_normal();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.normal)
  return _msg;
}

// repeated .substrait.FunctionSignature.Implementation implementations = 12 [json_name = "implementations"];
inline int FunctionSignature_Scalar::_internal_implementations_size() const {
  return implementations_.size();
}
inline int FunctionSignature_Scalar::implementations_size() const {
  return _internal_implementations_size();
}
inline void FunctionSignature_Scalar::clear_implementations() {
  implementations_.Clear();
}
inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Scalar::mutable_implementations(int index) {
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.implementations)
  return implementations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >*
FunctionSignature_Scalar::mutable_implementations() {
  // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Scalar.implementations)
  return &implementations_;
}
inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Scalar::_internal_implementations(int index) const {
  return implementations_.Get(index);
}
inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Scalar::implementations(int index) const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.implementations)
  return _internal_implementations(index);
}
inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Scalar::_internal_add_implementations() {
  return implementations_.Add();
}
inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Scalar::add_implementations() {
  ::substrait::FunctionSignature_Implementation* _add = _internal_add_implementations();
  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Scalar.implementations)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >&
FunctionSignature_Scalar::implementations() const {
  // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Scalar.implementations)
  return implementations_;
}

inline bool FunctionSignature_Scalar::has_final_variable_behavior() const {
  return final_variable_behavior_case() != FINAL_VARIABLE_BEHAVIOR_NOT_SET;
}
inline void FunctionSignature_Scalar::clear_has_final_variable_behavior() {
  _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET;
}
inline FunctionSignature_Scalar::FinalVariableBehaviorCase FunctionSignature_Scalar::final_variable_behavior_case() const {
  return FunctionSignature_Scalar::FinalVariableBehaviorCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// FunctionSignature_Aggregate

// repeated .substrait.FunctionSignature.Argument arguments = 2 [json_name = "arguments"];
inline int FunctionSignature_Aggregate::_internal_arguments_size() const {
  return arguments_.size();
}
inline int FunctionSignature_Aggregate::arguments_size() const {
  return _internal_arguments_size();
}
inline void FunctionSignature_Aggregate::clear_arguments() {
  arguments_.Clear();
}
inline ::substrait::FunctionSignature_Argument* FunctionSignature_Aggregate::mutable_arguments(int index) {
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.arguments)
  return arguments_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >*
FunctionSignature_Aggregate::mutable_arguments() {
  // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Aggregate.arguments)
  return &arguments_;
}
inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Aggregate::_internal_arguments(int index) const {
  return arguments_.Get(index);
}
inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Aggregate::arguments(int index) const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.arguments)
  return _internal_arguments(index);
}
inline ::substrait::FunctionSignature_Argument* FunctionSignature_Aggregate::_internal_add_arguments() {
  return arguments_.Add();
}
inline ::substrait::FunctionSignature_Argument* FunctionSignature_Aggregate::add_arguments() {
  ::substrait::FunctionSignature_Argument* _add = _internal_add_arguments();
  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Aggregate.arguments)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >&
FunctionSignature_Aggregate::arguments() const {
  // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Aggregate.arguments)
  return arguments_;
}

// string name = 3 [json_name = "name"];
inline void FunctionSignature_Aggregate::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& FunctionSignature_Aggregate::name() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FunctionSignature_Aggregate::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.name)
}
inline std::string* FunctionSignature_Aggregate::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.name)
  return _s;
}
inline const std::string& FunctionSignature_Aggregate::_internal_name() const {
  return name_.Get();
}
inline void FunctionSignature_Aggregate::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* FunctionSignature_Aggregate::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* FunctionSignature_Aggregate::release_name() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void FunctionSignature_Aggregate::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.name)
}

// .substrait.FunctionSignature.Description description = 4 [json_name = "description"];
inline bool FunctionSignature_Aggregate::_internal_has_description() const {
  return this != internal_default_instance() && description_ != nullptr;
}
inline bool FunctionSignature_Aggregate::has_description() const {
  return _internal_has_description();
}
inline void FunctionSignature_Aggregate::clear_description() {
  if (GetArenaForAllocation() == nullptr && description_ != nullptr) {
    delete description_;
  }
  description_ = nullptr;
}
inline const ::substrait::FunctionSignature_Description& FunctionSignature_Aggregate::_internal_description() const {
  const ::substrait::FunctionSignature_Description* p = description_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::FunctionSignature_Description&>(
      ::substrait::_FunctionSignature_Description_default_instance_);
}
inline const ::substrait::FunctionSignature_Description& FunctionSignature_Aggregate::description() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.description)
  return _internal_description();
}
inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_description(
    ::substrait::FunctionSignature_Description* description) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(description_);
  }
  description_ = description;
  if (description) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Aggregate.description)
}
inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::release_description() {
  
  ::substrait::FunctionSignature_Description* temp = description_;
  description_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::unsafe_arena_release_description() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.description)
  
  ::substrait::FunctionSignature_Description* temp = description_;
  description_ = nullptr;
  return temp;
}
inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::_internal_mutable_description() {
  
  if (description_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::FunctionSignature_Description>(GetArenaForAllocation());
    description_ = p;
  }
  return description_;
}
inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::mutable_description() {
  ::substrait::FunctionSignature_Description* _msg = _internal_mutable_description();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.description)
  return _msg;
}
inline void FunctionSignature_Aggregate::set_allocated_description(::substrait::FunctionSignature_Description* description) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete description_;
  }
  if (description) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Description>::GetOwningArena(description);
    if (message_arena != submessage_arena) {
      description = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, description, submessage_arena);
    }
    
  } else {
    
  }
  description_ = description;
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.description)
}

// bool deterministic = 7 [json_name = "deterministic"];
inline void FunctionSignature_Aggregate::clear_deterministic() {
  deterministic_ = false;
}
inline bool FunctionSignature_Aggregate::_internal_deterministic() const {
  return deterministic_;
}
inline bool FunctionSignature_Aggregate::deterministic() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.deterministic)
  return _internal_deterministic();
}
inline void FunctionSignature_Aggregate::_internal_set_deterministic(bool value) {
  
  deterministic_ = value;
}
inline void FunctionSignature_Aggregate::set_deterministic(bool value) {
  _internal_set_deterministic(value);
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.deterministic)
}

// bool session_dependent = 8 [json_name = "sessionDependent"];
inline void FunctionSignature_Aggregate::clear_session_dependent() {
  session_dependent_ = false;
}
inline bool FunctionSignature_Aggregate::_internal_session_dependent() const {
  return session_dependent_;
}
inline bool FunctionSignature_Aggregate::session_dependent() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.session_dependent)
  return _internal_session_dependent();
}
inline void FunctionSignature_Aggregate::_internal_set_session_dependent(bool value) {
  
  session_dependent_ = value;
}
inline void FunctionSignature_Aggregate::set_session_dependent(bool value) {
  _internal_set_session_dependent(value);
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.session_dependent)
}

// .substrait.DerivationExpression output_type = 9 [json_name = "outputType"];
inline bool FunctionSignature_Aggregate::_internal_has_output_type() const {
  return this != internal_default_instance() && output_type_ != nullptr;
}
inline bool FunctionSignature_Aggregate::has_output_type() const {
  return _internal_has_output_type();
}
inline const ::substrait::DerivationExpression& FunctionSignature_Aggregate::_internal_output_type() const {
  const ::substrait::DerivationExpression* p = output_type_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
      ::substrait::_DerivationExpression_default_instance_);
}
inline const ::substrait::DerivationExpression& FunctionSignature_Aggregate::output_type() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.output_type)
  return _internal_output_type();
}
inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_output_type(
    ::substrait::DerivationExpression* output_type) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_);
  }
  output_type_ = output_type;
  if (output_type) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Aggregate.output_type)
}
inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::release_output_type() {
  
  ::substrait::DerivationExpression* temp = output_type_;
  output_type_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::unsafe_arena_release_output_type() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.output_type)
  
  ::substrait::DerivationExpression* temp = output_type_;
  output_type_ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::_internal_mutable_output_type() {
  
  if (output_type_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
    output_type_ = p;
  }
  return output_type_;
}
inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::mutable_output_type() {
  ::substrait::DerivationExpression* _msg = _internal_mutable_output_type();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.output_type)
  return _msg;
}
inline void FunctionSignature_Aggregate::set_allocated_output_type(::substrait::DerivationExpression* output_type) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_);
  }
  if (output_type) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type));
    if (message_arena != submessage_arena) {
      output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, output_type, submessage_arena);
    }
    
  } else {
    
  }
  output_type_ = output_type;
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.output_type)
}

// .substrait.FunctionSignature.FinalArgVariadic variadic = 10 [json_name = "variadic"];
inline bool FunctionSignature_Aggregate::_internal_has_variadic() const {
  return final_variable_behavior_case() == kVariadic;
}
inline bool FunctionSignature_Aggregate::has_variadic() const {
  return _internal_has_variadic();
}
inline void FunctionSignature_Aggregate::set_has_variadic() {
  _oneof_case_[0] = kVariadic;
}
inline void FunctionSignature_Aggregate::clear_variadic() {
  if (_internal_has_variadic()) {
    if (GetArenaForAllocation() == nullptr) {
      delete final_variable_behavior_.variadic_;
    }
    clear_has_final_variable_behavior();
  }
}
inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::release_variadic() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.variadic)
  if (_internal_has_variadic()) {
    clear_has_final_variable_behavior();
      ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    final_variable_behavior_.variadic_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Aggregate::_internal_variadic() const {
  return _internal_has_variadic()
      ? *final_variable_behavior_.variadic_
      : reinterpret_cast< ::substrait::FunctionSignature_FinalArgVariadic&>(::substrait::_FunctionSignature_FinalArgVariadic_default_instance_);
}
inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Aggregate::variadic() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.variadic)
  return _internal_variadic();
}
inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::unsafe_arena_release_variadic() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Aggregate.variadic)
  if (_internal_has_variadic()) {
    clear_has_final_variable_behavior();
    ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_;
    final_variable_behavior_.variadic_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) {
  clear_final_variable_behavior();
  if (variadic) {
    set_has_variadic();
    final_variable_behavior_.variadic_ = variadic;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Aggregate.variadic)
}
inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::_internal_mutable_variadic() {
  if (!_internal_has_variadic()) {
    clear_final_variable_behavior();
    set_has_variadic();
    final_variable_behavior_.variadic_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(GetArenaForAllocation());
  }
  return final_variable_behavior_.variadic_;
}
inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::mutable_variadic() {
  ::substrait::FunctionSignature_FinalArgVariadic* _msg = _internal_mutable_variadic();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.variadic)
  return _msg;
}

// .substrait.FunctionSignature.FinalArgNormal normal = 11 [json_name = "normal"];
inline bool FunctionSignature_Aggregate::_internal_has_normal() const {
  return final_variable_behavior_case() == kNormal;
}
inline bool FunctionSignature_Aggregate::has_normal() const {
  return _internal_has_normal();
}
inline void FunctionSignature_Aggregate::set_has_normal() {
  _oneof_case_[0] = kNormal;
}
inline void FunctionSignature_Aggregate::clear_normal() {
  if (_internal_has_normal()) {
    if (GetArenaForAllocation() == nullptr) {
      delete final_variable_behavior_.normal_;
    }
    clear_has_final_variable_behavior();
  }
}
inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::release_normal() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.normal)
  if (_internal_has_normal()) {
    clear_has_final_variable_behavior();
      ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    final_variable_behavior_.normal_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Aggregate::_internal_normal() const {
  return _internal_has_normal()
      ? *final_variable_behavior_.normal_
      : reinterpret_cast< ::substrait::FunctionSignature_FinalArgNormal&>(::substrait::_FunctionSignature_FinalArgNormal_default_instance_);
}
inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Aggregate::normal() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.normal)
  return _internal_normal();
}
inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::unsafe_arena_release_normal() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Aggregate.normal)
  if (_internal_has_normal()) {
    clear_has_final_variable_behavior();
    ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_;
    final_variable_behavior_.normal_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) {
  clear_final_variable_behavior();
  if (normal) {
    set_has_normal();
    final_variable_behavior_.normal_ = normal;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Aggregate.normal)
}
inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::_internal_mutable_normal() {
  if (!_internal_has_normal()) {
    clear_final_variable_behavior();
    set_has_normal();
    final_variable_behavior_.normal_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(GetArenaForAllocation());
  }
  return final_variable_behavior_.normal_;
}
inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::mutable_normal() {
  ::substrait::FunctionSignature_FinalArgNormal* _msg = _internal_mutable_normal();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.normal)
  return _msg;
}

// bool ordered = 14 [json_name = "ordered"];
inline void FunctionSignature_Aggregate::clear_ordered() {
  ordered_ = false;
}
inline bool FunctionSignature_Aggregate::_internal_ordered() const {
  return ordered_;
}
inline bool FunctionSignature_Aggregate::ordered() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.ordered)
  return _internal_ordered();
}
inline void FunctionSignature_Aggregate::_internal_set_ordered(bool value) {
  
  ordered_ = value;
}
inline void FunctionSignature_Aggregate::set_ordered(bool value) {
  _internal_set_ordered(value);
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.ordered)
}

// uint64 max_set = 12 [json_name = "maxSet"];
inline void FunctionSignature_Aggregate::clear_max_set() {
  max_set_ = uint64_t{0u};
}
inline uint64_t FunctionSignature_Aggregate::_internal_max_set() const {
  return max_set_;
}
inline uint64_t FunctionSignature_Aggregate::max_set() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.max_set)
  return _internal_max_set();
}
inline void FunctionSignature_Aggregate::_internal_set_max_set(uint64_t value) {
  
  max_set_ = value;
}
inline void FunctionSignature_Aggregate::set_max_set(uint64_t value) {
  _internal_set_max_set(value);
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.max_set)
}

// .substrait.Type intermediate_type = 13 [json_name = "intermediateType"];
inline bool FunctionSignature_Aggregate::_internal_has_intermediate_type() const {
  return this != internal_default_instance() && intermediate_type_ != nullptr;
}
inline bool FunctionSignature_Aggregate::has_intermediate_type() const {
  return _internal_has_intermediate_type();
}
inline const ::substrait::Type& FunctionSignature_Aggregate::_internal_intermediate_type() const {
  const ::substrait::Type* p = intermediate_type_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Type&>(
      ::substrait::_Type_default_instance_);
}
inline const ::substrait::Type& FunctionSignature_Aggregate::intermediate_type() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.intermediate_type)
  return _internal_intermediate_type();
}
inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_intermediate_type(
    ::substrait::Type* intermediate_type) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_);
  }
  intermediate_type_ = intermediate_type;
  if (intermediate_type) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Aggregate.intermediate_type)
}
inline ::substrait::Type* FunctionSignature_Aggregate::release_intermediate_type() {
  
  ::substrait::Type* temp = intermediate_type_;
  intermediate_type_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::Type* FunctionSignature_Aggregate::unsafe_arena_release_intermediate_type() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.intermediate_type)
  
  ::substrait::Type* temp = intermediate_type_;
  intermediate_type_ = nullptr;
  return temp;
}
inline ::substrait::Type* FunctionSignature_Aggregate::_internal_mutable_intermediate_type() {
  
  if (intermediate_type_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation());
    intermediate_type_ = p;
  }
  return intermediate_type_;
}
inline ::substrait::Type* FunctionSignature_Aggregate::mutable_intermediate_type() {
  ::substrait::Type* _msg = _internal_mutable_intermediate_type();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.intermediate_type)
  return _msg;
}
inline void FunctionSignature_Aggregate::set_allocated_intermediate_type(::substrait::Type* intermediate_type) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_);
  }
  if (intermediate_type) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type));
    if (message_arena != submessage_arena) {
      intermediate_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, intermediate_type, submessage_arena);
    }
    
  } else {
    
  }
  intermediate_type_ = intermediate_type;
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.intermediate_type)
}

// repeated .substrait.FunctionSignature.Implementation implementations = 15 [json_name = "implementations"];
inline int FunctionSignature_Aggregate::_internal_implementations_size() const {
  return implementations_.size();
}
inline int FunctionSignature_Aggregate::implementations_size() const {
  return _internal_implementations_size();
}
inline void FunctionSignature_Aggregate::clear_implementations() {
  implementations_.Clear();
}
inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Aggregate::mutable_implementations(int index) {
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.implementations)
  return implementations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >*
FunctionSignature_Aggregate::mutable_implementations() {
  // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Aggregate.implementations)
  return &implementations_;
}
inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Aggregate::_internal_implementations(int index) const {
  return implementations_.Get(index);
}
inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Aggregate::implementations(int index) const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.implementations)
  return _internal_implementations(index);
}
inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Aggregate::_internal_add_implementations() {
  return implementations_.Add();
}
inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Aggregate::add_implementations() {
  ::substrait::FunctionSignature_Implementation* _add = _internal_add_implementations();
  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Aggregate.implementations)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >&
FunctionSignature_Aggregate::implementations() const {
  // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Aggregate.implementations)
  return implementations_;
}

inline bool FunctionSignature_Aggregate::has_final_variable_behavior() const {
  return final_variable_behavior_case() != FINAL_VARIABLE_BEHAVIOR_NOT_SET;
}
inline void FunctionSignature_Aggregate::clear_has_final_variable_behavior() {
  _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET;
}
inline FunctionSignature_Aggregate::FinalVariableBehaviorCase FunctionSignature_Aggregate::final_variable_behavior_case() const {
  return FunctionSignature_Aggregate::FinalVariableBehaviorCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// FunctionSignature_Window

// repeated .substrait.FunctionSignature.Argument arguments = 2 [json_name = "arguments"];
inline int FunctionSignature_Window::_internal_arguments_size() const {
  return arguments_.size();
}
inline int FunctionSignature_Window::arguments_size() const {
  return _internal_arguments_size();
}
inline void FunctionSignature_Window::clear_arguments() {
  arguments_.Clear();
}
inline ::substrait::FunctionSignature_Argument* FunctionSignature_Window::mutable_arguments(int index) {
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.arguments)
  return arguments_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >*
FunctionSignature_Window::mutable_arguments() {
  // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Window.arguments)
  return &arguments_;
}
inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Window::_internal_arguments(int index) const {
  return arguments_.Get(index);
}
inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Window::arguments(int index) const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.arguments)
  return _internal_arguments(index);
}
inline ::substrait::FunctionSignature_Argument* FunctionSignature_Window::_internal_add_arguments() {
  return arguments_.Add();
}
inline ::substrait::FunctionSignature_Argument* FunctionSignature_Window::add_arguments() {
  ::substrait::FunctionSignature_Argument* _add = _internal_add_arguments();
  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Window.arguments)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >&
FunctionSignature_Window::arguments() const {
  // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Window.arguments)
  return arguments_;
}

// repeated string name = 3 [json_name = "name"];
inline int FunctionSignature_Window::_internal_name_size() const {
  return name_.size();
}
inline int FunctionSignature_Window::name_size() const {
  return _internal_name_size();
}
inline void FunctionSignature_Window::clear_name() {
  name_.Clear();
}
inline std::string* FunctionSignature_Window::add_name() {
  std::string* _s = _internal_add_name();
  // @@protoc_insertion_point(field_add_mutable:substrait.FunctionSignature.Window.name)
  return _s;
}
inline const std::string& FunctionSignature_Window::_internal_name(int index) const {
  return name_.Get(index);
}
inline const std::string& FunctionSignature_Window::name(int index) const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.name)
  return _internal_name(index);
}
inline std::string* FunctionSignature_Window::mutable_name(int index) {
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.name)
  return name_.Mutable(index);
}
inline void FunctionSignature_Window::set_name(int index, const std::string& value) {
  name_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.name)
}
inline void FunctionSignature_Window::set_name(int index, std::string&& value) {
  name_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.name)
}
inline void FunctionSignature_Window::set_name(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  name_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:substrait.FunctionSignature.Window.name)
}
inline void FunctionSignature_Window::set_name(int index, const char* value, size_t size) {
  name_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:substrait.FunctionSignature.Window.name)
}
inline std::string* FunctionSignature_Window::_internal_add_name() {
  return name_.Add();
}
inline void FunctionSignature_Window::add_name(const std::string& value) {
  name_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Window.name)
}
inline void FunctionSignature_Window::add_name(std::string&& value) {
  name_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Window.name)
}
inline void FunctionSignature_Window::add_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  name_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:substrait.FunctionSignature.Window.name)
}
inline void FunctionSignature_Window::add_name(const char* value, size_t size) {
  name_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:substrait.FunctionSignature.Window.name)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
FunctionSignature_Window::name() const {
  // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Window.name)
  return name_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
FunctionSignature_Window::mutable_name() {
  // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Window.name)
  return &name_;
}

// .substrait.FunctionSignature.Description description = 4 [json_name = "description"];
inline bool FunctionSignature_Window::_internal_has_description() const {
  return this != internal_default_instance() && description_ != nullptr;
}
inline bool FunctionSignature_Window::has_description() const {
  return _internal_has_description();
}
inline void FunctionSignature_Window::clear_description() {
  if (GetArenaForAllocation() == nullptr && description_ != nullptr) {
    delete description_;
  }
  description_ = nullptr;
}
inline const ::substrait::FunctionSignature_Description& FunctionSignature_Window::_internal_description() const {
  const ::substrait::FunctionSignature_Description* p = description_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::FunctionSignature_Description&>(
      ::substrait::_FunctionSignature_Description_default_instance_);
}
inline const ::substrait::FunctionSignature_Description& FunctionSignature_Window::description() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.description)
  return _internal_description();
}
inline void FunctionSignature_Window::unsafe_arena_set_allocated_description(
    ::substrait::FunctionSignature_Description* description) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(description_);
  }
  description_ = description;
  if (description) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Window.description)
}
inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::release_description() {
  
  ::substrait::FunctionSignature_Description* temp = description_;
  description_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::unsafe_arena_release_description() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Window.description)
  
  ::substrait::FunctionSignature_Description* temp = description_;
  description_ = nullptr;
  return temp;
}
inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::_internal_mutable_description() {
  
  if (description_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::FunctionSignature_Description>(GetArenaForAllocation());
    description_ = p;
  }
  return description_;
}
inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::mutable_description() {
  ::substrait::FunctionSignature_Description* _msg = _internal_mutable_description();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.description)
  return _msg;
}
inline void FunctionSignature_Window::set_allocated_description(::substrait::FunctionSignature_Description* description) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete description_;
  }
  if (description) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Description>::GetOwningArena(description);
    if (message_arena != submessage_arena) {
      description = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, description, submessage_arena);
    }
    
  } else {
    
  }
  description_ = description;
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.description)
}

// bool deterministic = 7 [json_name = "deterministic"];
inline void FunctionSignature_Window::clear_deterministic() {
  deterministic_ = false;
}
inline bool FunctionSignature_Window::_internal_deterministic() const {
  return deterministic_;
}
inline bool FunctionSignature_Window::deterministic() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.deterministic)
  return _internal_deterministic();
}
inline void FunctionSignature_Window::_internal_set_deterministic(bool value) {
  
  deterministic_ = value;
}
inline void FunctionSignature_Window::set_deterministic(bool value) {
  _internal_set_deterministic(value);
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.deterministic)
}

// bool session_dependent = 8 [json_name = "sessionDependent"];
inline void FunctionSignature_Window::clear_session_dependent() {
  session_dependent_ = false;
}
inline bool FunctionSignature_Window::_internal_session_dependent() const {
  return session_dependent_;
}
inline bool FunctionSignature_Window::session_dependent() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.session_dependent)
  return _internal_session_dependent();
}
inline void FunctionSignature_Window::_internal_set_session_dependent(bool value) {
  
  session_dependent_ = value;
}
inline void FunctionSignature_Window::set_session_dependent(bool value) {
  _internal_set_session_dependent(value);
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.session_dependent)
}

// .substrait.DerivationExpression intermediate_type = 9 [json_name = "intermediateType"];
inline bool FunctionSignature_Window::_internal_has_intermediate_type() const {
  return this != internal_default_instance() && intermediate_type_ != nullptr;
}
inline bool FunctionSignature_Window::has_intermediate_type() const {
  return _internal_has_intermediate_type();
}
inline const ::substrait::DerivationExpression& FunctionSignature_Window::_internal_intermediate_type() const {
  const ::substrait::DerivationExpression* p = intermediate_type_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
      ::substrait::_DerivationExpression_default_instance_);
}
inline const ::substrait::DerivationExpression& FunctionSignature_Window::intermediate_type() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.intermediate_type)
  return _internal_intermediate_type();
}
inline void FunctionSignature_Window::unsafe_arena_set_allocated_intermediate_type(
    ::substrait::DerivationExpression* intermediate_type) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_);
  }
  intermediate_type_ = intermediate_type;
  if (intermediate_type) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Window.intermediate_type)
}
inline ::substrait::DerivationExpression* FunctionSignature_Window::release_intermediate_type() {
  
  ::substrait::DerivationExpression* temp = intermediate_type_;
  intermediate_type_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression* FunctionSignature_Window::unsafe_arena_release_intermediate_type() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Window.intermediate_type)
  
  ::substrait::DerivationExpression* temp = intermediate_type_;
  intermediate_type_ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression* FunctionSignature_Window::_internal_mutable_intermediate_type() {
  
  if (intermediate_type_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
    intermediate_type_ = p;
  }
  return intermediate_type_;
}
inline ::substrait::DerivationExpression* FunctionSignature_Window::mutable_intermediate_type() {
  ::substrait::DerivationExpression* _msg = _internal_mutable_intermediate_type();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.intermediate_type)
  return _msg;
}
inline void FunctionSignature_Window::set_allocated_intermediate_type(::substrait::DerivationExpression* intermediate_type) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_);
  }
  if (intermediate_type) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type));
    if (message_arena != submessage_arena) {
      intermediate_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, intermediate_type, submessage_arena);
    }
    
  } else {
    
  }
  intermediate_type_ = intermediate_type;
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.intermediate_type)
}

// .substrait.DerivationExpression output_type = 10 [json_name = "outputType"];
inline bool FunctionSignature_Window::_internal_has_output_type() const {
  return this != internal_default_instance() && output_type_ != nullptr;
}
inline bool FunctionSignature_Window::has_output_type() const {
  return _internal_has_output_type();
}
inline const ::substrait::DerivationExpression& FunctionSignature_Window::_internal_output_type() const {
  const ::substrait::DerivationExpression* p = output_type_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
      ::substrait::_DerivationExpression_default_instance_);
}
inline const ::substrait::DerivationExpression& FunctionSignature_Window::output_type() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.output_type)
  return _internal_output_type();
}
inline void FunctionSignature_Window::unsafe_arena_set_allocated_output_type(
    ::substrait::DerivationExpression* output_type) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_);
  }
  output_type_ = output_type;
  if (output_type) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Window.output_type)
}
inline ::substrait::DerivationExpression* FunctionSignature_Window::release_output_type() {
  
  ::substrait::DerivationExpression* temp = output_type_;
  output_type_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::DerivationExpression* FunctionSignature_Window::unsafe_arena_release_output_type() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Window.output_type)
  
  ::substrait::DerivationExpression* temp = output_type_;
  output_type_ = nullptr;
  return temp;
}
inline ::substrait::DerivationExpression* FunctionSignature_Window::_internal_mutable_output_type() {
  
  if (output_type_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
    output_type_ = p;
  }
  return output_type_;
}
inline ::substrait::DerivationExpression* FunctionSignature_Window::mutable_output_type() {
  ::substrait::DerivationExpression* _msg = _internal_mutable_output_type();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.output_type)
  return _msg;
}
inline void FunctionSignature_Window::set_allocated_output_type(::substrait::DerivationExpression* output_type) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_);
  }
  if (output_type) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type));
    if (message_arena != submessage_arena) {
      output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, output_type, submessage_arena);
    }
    
  } else {
    
  }
  output_type_ = output_type;
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.output_type)
}

// .substrait.FunctionSignature.FinalArgVariadic variadic = 16 [json_name = "variadic"];
inline bool FunctionSignature_Window::_internal_has_variadic() const {
  return final_variable_behavior_case() == kVariadic;
}
inline bool FunctionSignature_Window::has_variadic() const {
  return _internal_has_variadic();
}
inline void FunctionSignature_Window::set_has_variadic() {
  _oneof_case_[0] = kVariadic;
}
inline void FunctionSignature_Window::clear_variadic() {
  if (_internal_has_variadic()) {
    if (GetArenaForAllocation() == nullptr) {
      delete final_variable_behavior_.variadic_;
    }
    clear_has_final_variable_behavior();
  }
}
inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::release_variadic() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Window.variadic)
  if (_internal_has_variadic()) {
    clear_has_final_variable_behavior();
      ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    final_variable_behavior_.variadic_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Window::_internal_variadic() const {
  return _internal_has_variadic()
      ? *final_variable_behavior_.variadic_
      : reinterpret_cast< ::substrait::FunctionSignature_FinalArgVariadic&>(::substrait::_FunctionSignature_FinalArgVariadic_default_instance_);
}
inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Window::variadic() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.variadic)
  return _internal_variadic();
}
inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::unsafe_arena_release_variadic() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Window.variadic)
  if (_internal_has_variadic()) {
    clear_has_final_variable_behavior();
    ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_;
    final_variable_behavior_.variadic_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void FunctionSignature_Window::unsafe_arena_set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) {
  clear_final_variable_behavior();
  if (variadic) {
    set_has_variadic();
    final_variable_behavior_.variadic_ = variadic;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Window.variadic)
}
inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::_internal_mutable_variadic() {
  if (!_internal_has_variadic()) {
    clear_final_variable_behavior();
    set_has_variadic();
    final_variable_behavior_.variadic_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(GetArenaForAllocation());
  }
  return final_variable_behavior_.variadic_;
}
inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::mutable_variadic() {
  ::substrait::FunctionSignature_FinalArgVariadic* _msg = _internal_mutable_variadic();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.variadic)
  return _msg;
}

// .substrait.FunctionSignature.FinalArgNormal normal = 17 [json_name = "normal"];
inline bool FunctionSignature_Window::_internal_has_normal() const {
  return final_variable_behavior_case() == kNormal;
}
inline bool FunctionSignature_Window::has_normal() const {
  return _internal_has_normal();
}
inline void FunctionSignature_Window::set_has_normal() {
  _oneof_case_[0] = kNormal;
}
inline void FunctionSignature_Window::clear_normal() {
  if (_internal_has_normal()) {
    if (GetArenaForAllocation() == nullptr) {
      delete final_variable_behavior_.normal_;
    }
    clear_has_final_variable_behavior();
  }
}
inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::release_normal() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Window.normal)
  if (_internal_has_normal()) {
    clear_has_final_variable_behavior();
      ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    final_variable_behavior_.normal_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Window::_internal_normal() const {
  return _internal_has_normal()
      ? *final_variable_behavior_.normal_
      : reinterpret_cast< ::substrait::FunctionSignature_FinalArgNormal&>(::substrait::_FunctionSignature_FinalArgNormal_default_instance_);
}
inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Window::normal() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.normal)
  return _internal_normal();
}
inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::unsafe_arena_release_normal() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Window.normal)
  if (_internal_has_normal()) {
    clear_has_final_variable_behavior();
    ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_;
    final_variable_behavior_.normal_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void FunctionSignature_Window::unsafe_arena_set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) {
  clear_final_variable_behavior();
  if (normal) {
    set_has_normal();
    final_variable_behavior_.normal_ = normal;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Window.normal)
}
inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::_internal_mutable_normal() {
  if (!_internal_has_normal()) {
    clear_final_variable_behavior();
    set_has_normal();
    final_variable_behavior_.normal_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(GetArenaForAllocation());
  }
  return final_variable_behavior_.normal_;
}
inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::mutable_normal() {
  ::substrait::FunctionSignature_FinalArgNormal* _msg = _internal_mutable_normal();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.normal)
  return _msg;
}

// bool ordered = 11 [json_name = "ordered"];
inline void FunctionSignature_Window::clear_ordered() {
  ordered_ = false;
}
inline bool FunctionSignature_Window::_internal_ordered() const {
  return ordered_;
}
inline bool FunctionSignature_Window::ordered() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.ordered)
  return _internal_ordered();
}
inline void FunctionSignature_Window::_internal_set_ordered(bool value) {
  
  ordered_ = value;
}
inline void FunctionSignature_Window::set_ordered(bool value) {
  _internal_set_ordered(value);
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.ordered)
}

// uint64 max_set = 12 [json_name = "maxSet"];
inline void FunctionSignature_Window::clear_max_set() {
  max_set_ = uint64_t{0u};
}
inline uint64_t FunctionSignature_Window::_internal_max_set() const {
  return max_set_;
}
inline uint64_t FunctionSignature_Window::max_set() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.max_set)
  return _internal_max_set();
}
inline void FunctionSignature_Window::_internal_set_max_set(uint64_t value) {
  
  max_set_ = value;
}
inline void FunctionSignature_Window::set_max_set(uint64_t value) {
  _internal_set_max_set(value);
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.max_set)
}

// .substrait.FunctionSignature.Window.WindowType window_type = 14 [json_name = "windowType"];
inline void FunctionSignature_Window::clear_window_type() {
  window_type_ = 0;
}
inline ::substrait::FunctionSignature_Window_WindowType FunctionSignature_Window::_internal_window_type() const {
  return static_cast< ::substrait::FunctionSignature_Window_WindowType >(window_type_);
}
inline ::substrait::FunctionSignature_Window_WindowType FunctionSignature_Window::window_type() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.window_type)
  return _internal_window_type();
}
inline void FunctionSignature_Window::_internal_set_window_type(::substrait::FunctionSignature_Window_WindowType value) {
  
  window_type_ = value;
}
inline void FunctionSignature_Window::set_window_type(::substrait::FunctionSignature_Window_WindowType value) {
  _internal_set_window_type(value);
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.window_type)
}

// repeated .substrait.FunctionSignature.Implementation implementations = 15 [json_name = "implementations"];
inline int FunctionSignature_Window::_internal_implementations_size() const {
  return implementations_.size();
}
inline int FunctionSignature_Window::implementations_size() const {
  return _internal_implementations_size();
}
inline void FunctionSignature_Window::clear_implementations() {
  implementations_.Clear();
}
inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Window::mutable_implementations(int index) {
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.implementations)
  return implementations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >*
FunctionSignature_Window::mutable_implementations() {
  // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Window.implementations)
  return &implementations_;
}
inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Window::_internal_implementations(int index) const {
  return implementations_.Get(index);
}
inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Window::implementations(int index) const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.implementations)
  return _internal_implementations(index);
}
inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Window::_internal_add_implementations() {
  return implementations_.Add();
}
inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Window::add_implementations() {
  ::substrait::FunctionSignature_Implementation* _add = _internal_add_implementations();
  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Window.implementations)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >&
FunctionSignature_Window::implementations() const {
  // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Window.implementations)
  return implementations_;
}

inline bool FunctionSignature_Window::has_final_variable_behavior() const {
  return final_variable_behavior_case() != FINAL_VARIABLE_BEHAVIOR_NOT_SET;
}
inline void FunctionSignature_Window::clear_has_final_variable_behavior() {
  _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET;
}
inline FunctionSignature_Window::FinalVariableBehaviorCase FunctionSignature_Window::final_variable_behavior_case() const {
  return FunctionSignature_Window::FinalVariableBehaviorCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// FunctionSignature_Description

// string language = 1 [json_name = "language"];
inline void FunctionSignature_Description::clear_language() {
  language_.ClearToEmpty();
}
inline const std::string& FunctionSignature_Description::language() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Description.language)
  return _internal_language();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FunctionSignature_Description::set_language(ArgT0&& arg0, ArgT... args) {
 
 language_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Description.language)
}
inline std::string* FunctionSignature_Description::mutable_language() {
  std::string* _s = _internal_mutable_language();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Description.language)
  return _s;
}
inline const std::string& FunctionSignature_Description::_internal_language() const {
  return language_.Get();
}
inline void FunctionSignature_Description::_internal_set_language(const std::string& value) {
  
  language_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* FunctionSignature_Description::_internal_mutable_language() {
  
  return language_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* FunctionSignature_Description::release_language() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Description.language)
  return language_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void FunctionSignature_Description::set_allocated_language(std::string* language) {
  if (language != nullptr) {
    
  } else {
    
  }
  language_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), language,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (language_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    language_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Description.language)
}

// string body = 2 [json_name = "body"];
inline void FunctionSignature_Description::clear_body() {
  body_.ClearToEmpty();
}
inline const std::string& FunctionSignature_Description::body() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Description.body)
  return _internal_body();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FunctionSignature_Description::set_body(ArgT0&& arg0, ArgT... args) {
 
 body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Description.body)
}
inline std::string* FunctionSignature_Description::mutable_body() {
  std::string* _s = _internal_mutable_body();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Description.body)
  return _s;
}
inline const std::string& FunctionSignature_Description::_internal_body() const {
  return body_.Get();
}
inline void FunctionSignature_Description::_internal_set_body(const std::string& value) {
  
  body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* FunctionSignature_Description::_internal_mutable_body() {
  
  return body_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* FunctionSignature_Description::release_body() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Description.body)
  return body_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void FunctionSignature_Description::set_allocated_body(std::string* body) {
  if (body != nullptr) {
    
  } else {
    
  }
  body_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), body,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (body_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    body_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Description.body)
}

// -------------------------------------------------------------------

// FunctionSignature_Implementation

// .substrait.FunctionSignature.Implementation.Type type = 1 [json_name = "type"];
inline void FunctionSignature_Implementation::clear_type() {
  type_ = 0;
}
inline ::substrait::FunctionSignature_Implementation_Type FunctionSignature_Implementation::_internal_type() const {
  return static_cast< ::substrait::FunctionSignature_Implementation_Type >(type_);
}
inline ::substrait::FunctionSignature_Implementation_Type FunctionSignature_Implementation::type() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Implementation.type)
  return _internal_type();
}
inline void FunctionSignature_Implementation::_internal_set_type(::substrait::FunctionSignature_Implementation_Type value) {
  
  type_ = value;
}
inline void FunctionSignature_Implementation::set_type(::substrait::FunctionSignature_Implementation_Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Implementation.type)
}

// string uri = 2 [json_name = "uri"];
inline void FunctionSignature_Implementation::clear_uri() {
  uri_.ClearToEmpty();
}
inline const std::string& FunctionSignature_Implementation::uri() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Implementation.uri)
  return _internal_uri();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FunctionSignature_Implementation::set_uri(ArgT0&& arg0, ArgT... args) {
 
 uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Implementation.uri)
}
inline std::string* FunctionSignature_Implementation::mutable_uri() {
  std::string* _s = _internal_mutable_uri();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Implementation.uri)
  return _s;
}
inline const std::string& FunctionSignature_Implementation::_internal_uri() const {
  return uri_.Get();
}
inline void FunctionSignature_Implementation::_internal_set_uri(const std::string& value) {
  
  uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* FunctionSignature_Implementation::_internal_mutable_uri() {
  
  return uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* FunctionSignature_Implementation::release_uri() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Implementation.uri)
  return uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void FunctionSignature_Implementation::set_allocated_uri(std::string* uri) {
  if (uri != nullptr) {
    
  } else {
    
  }
  uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uri,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (uri_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Implementation.uri)
}

// -------------------------------------------------------------------

// FunctionSignature_Argument_ValueArgument

// .substrait.ParameterizedType type = 1 [json_name = "type"];
inline bool FunctionSignature_Argument_ValueArgument::_internal_has_type() const {
  return this != internal_default_instance() && type_ != nullptr;
}
inline bool FunctionSignature_Argument_ValueArgument::has_type() const {
  return _internal_has_type();
}
inline const ::substrait::ParameterizedType& FunctionSignature_Argument_ValueArgument::_internal_type() const {
  const ::substrait::ParameterizedType* p = type_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::ParameterizedType&>(
      ::substrait::_ParameterizedType_default_instance_);
}
inline const ::substrait::ParameterizedType& FunctionSignature_Argument_ValueArgument::type() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.ValueArgument.type)
  return _internal_type();
}
inline void FunctionSignature_Argument_ValueArgument::unsafe_arena_set_allocated_type(
    ::substrait::ParameterizedType* type) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_);
  }
  type_ = type;
  if (type) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Argument.ValueArgument.type)
}
inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::release_type() {
  
  ::substrait::ParameterizedType* temp = type_;
  type_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::unsafe_arena_release_type() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.ValueArgument.type)
  
  ::substrait::ParameterizedType* temp = type_;
  type_ = nullptr;
  return temp;
}
inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::_internal_mutable_type() {
  
  if (type_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArenaForAllocation());
    type_ = p;
  }
  return type_;
}
inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::mutable_type() {
  ::substrait::ParameterizedType* _msg = _internal_mutable_type();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.ValueArgument.type)
  return _msg;
}
inline void FunctionSignature_Argument_ValueArgument::set_allocated_type(::substrait::ParameterizedType* type) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_);
  }
  if (type) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type));
    if (message_arena != submessage_arena) {
      type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, type, submessage_arena);
    }
    
  } else {
    
  }
  type_ = type;
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.ValueArgument.type)
}

// bool constant = 2 [json_name = "constant"];
inline void FunctionSignature_Argument_ValueArgument::clear_constant() {
  constant_ = false;
}
inline bool FunctionSignature_Argument_ValueArgument::_internal_constant() const {
  return constant_;
}
inline bool FunctionSignature_Argument_ValueArgument::constant() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.ValueArgument.constant)
  return _internal_constant();
}
inline void FunctionSignature_Argument_ValueArgument::_internal_set_constant(bool value) {
  
  constant_ = value;
}
inline void FunctionSignature_Argument_ValueArgument::set_constant(bool value) {
  _internal_set_constant(value);
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.ValueArgument.constant)
}

// -------------------------------------------------------------------

// FunctionSignature_Argument_TypeArgument

// .substrait.ParameterizedType type = 1 [json_name = "type"];
inline bool FunctionSignature_Argument_TypeArgument::_internal_has_type() const {
  return this != internal_default_instance() && type_ != nullptr;
}
inline bool FunctionSignature_Argument_TypeArgument::has_type() const {
  return _internal_has_type();
}
inline const ::substrait::ParameterizedType& FunctionSignature_Argument_TypeArgument::_internal_type() const {
  const ::substrait::ParameterizedType* p = type_;
  return p != nullptr ? *p : reinterpret_cast<const ::substrait::ParameterizedType&>(
      ::substrait::_ParameterizedType_default_instance_);
}
inline const ::substrait::ParameterizedType& FunctionSignature_Argument_TypeArgument::type() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.TypeArgument.type)
  return _internal_type();
}
inline void FunctionSignature_Argument_TypeArgument::unsafe_arena_set_allocated_type(
    ::substrait::ParameterizedType* type) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_);
  }
  type_ = type;
  if (type) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Argument.TypeArgument.type)
}
inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::release_type() {
  
  ::substrait::ParameterizedType* temp = type_;
  type_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::unsafe_arena_release_type() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.TypeArgument.type)
  
  ::substrait::ParameterizedType* temp = type_;
  type_ = nullptr;
  return temp;
}
inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::_internal_mutable_type() {
  
  if (type_ == nullptr) {
    auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArenaForAllocation());
    type_ = p;
  }
  return type_;
}
inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::mutable_type() {
  ::substrait::ParameterizedType* _msg = _internal_mutable_type();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.TypeArgument.type)
  return _msg;
}
inline void FunctionSignature_Argument_TypeArgument::set_allocated_type(::substrait::ParameterizedType* type) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_);
  }
  if (type) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type));
    if (message_arena != submessage_arena) {
      type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, type, submessage_arena);
    }
    
  } else {
    
  }
  type_ = type;
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.TypeArgument.type)
}

// -------------------------------------------------------------------

// FunctionSignature_Argument_EnumArgument

// repeated string options = 1 [json_name = "options"];
inline int FunctionSignature_Argument_EnumArgument::_internal_options_size() const {
  return options_.size();
}
inline int FunctionSignature_Argument_EnumArgument::options_size() const {
  return _internal_options_size();
}
inline void FunctionSignature_Argument_EnumArgument::clear_options() {
  options_.Clear();
}
inline std::string* FunctionSignature_Argument_EnumArgument::add_options() {
  std::string* _s = _internal_add_options();
  // @@protoc_insertion_point(field_add_mutable:substrait.FunctionSignature.Argument.EnumArgument.options)
  return _s;
}
inline const std::string& FunctionSignature_Argument_EnumArgument::_internal_options(int index) const {
  return options_.Get(index);
}
inline const std::string& FunctionSignature_Argument_EnumArgument::options(int index) const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.EnumArgument.options)
  return _internal_options(index);
}
inline std::string* FunctionSignature_Argument_EnumArgument::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.EnumArgument.options)
  return options_.Mutable(index);
}
inline void FunctionSignature_Argument_EnumArgument::set_options(int index, const std::string& value) {
  options_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.EnumArgument.options)
}
inline void FunctionSignature_Argument_EnumArgument::set_options(int index, std::string&& value) {
  options_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.EnumArgument.options)
}
inline void FunctionSignature_Argument_EnumArgument::set_options(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  options_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:substrait.FunctionSignature.Argument.EnumArgument.options)
}
inline void FunctionSignature_Argument_EnumArgument::set_options(int index, const char* value, size_t size) {
  options_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:substrait.FunctionSignature.Argument.EnumArgument.options)
}
inline std::string* FunctionSignature_Argument_EnumArgument::_internal_add_options() {
  return options_.Add();
}
inline void FunctionSignature_Argument_EnumArgument::add_options(const std::string& value) {
  options_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Argument.EnumArgument.options)
}
inline void FunctionSignature_Argument_EnumArgument::add_options(std::string&& value) {
  options_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Argument.EnumArgument.options)
}
inline void FunctionSignature_Argument_EnumArgument::add_options(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  options_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:substrait.FunctionSignature.Argument.EnumArgument.options)
}
inline void FunctionSignature_Argument_EnumArgument::add_options(const char* value, size_t size) {
  options_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:substrait.FunctionSignature.Argument.EnumArgument.options)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
FunctionSignature_Argument_EnumArgument::options() const {
  // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Argument.EnumArgument.options)
  return options_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
FunctionSignature_Argument_EnumArgument::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Argument.EnumArgument.options)
  return &options_;
}

// bool optional = 2 [json_name = "optional"];
inline void FunctionSignature_Argument_EnumArgument::clear_optional() {
  optional_ = false;
}
inline bool FunctionSignature_Argument_EnumArgument::_internal_optional() const {
  return optional_;
}
inline bool FunctionSignature_Argument_EnumArgument::optional() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.EnumArgument.optional)
  return _internal_optional();
}
inline void FunctionSignature_Argument_EnumArgument::_internal_set_optional(bool value) {
  
  optional_ = value;
}
inline void FunctionSignature_Argument_EnumArgument::set_optional(bool value) {
  _internal_set_optional(value);
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.EnumArgument.optional)
}

// -------------------------------------------------------------------

// FunctionSignature_Argument

// string name = 1 [json_name = "name"];
inline void FunctionSignature_Argument::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& FunctionSignature_Argument::name() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FunctionSignature_Argument::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.name)
}
inline std::string* FunctionSignature_Argument::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.name)
  return _s;
}
inline const std::string& FunctionSignature_Argument::_internal_name() const {
  return name_.Get();
}
inline void FunctionSignature_Argument::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* FunctionSignature_Argument::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* FunctionSignature_Argument::release_name() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void FunctionSignature_Argument::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.name)
}

// .substrait.FunctionSignature.Argument.ValueArgument value = 2 [json_name = "value"];
inline bool FunctionSignature_Argument::_internal_has_value() const {
  return argument_kind_case() == kValue;
}
inline bool FunctionSignature_Argument::has_value() const {
  return _internal_has_value();
}
inline void FunctionSignature_Argument::set_has_value() {
  _oneof_case_[0] = kValue;
}
inline void FunctionSignature_Argument::clear_value() {
  if (_internal_has_value()) {
    if (GetArenaForAllocation() == nullptr) {
      delete argument_kind_.value_;
    }
    clear_has_argument_kind();
  }
}
inline ::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::release_value() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.value)
  if (_internal_has_value()) {
    clear_has_argument_kind();
      ::substrait::FunctionSignature_Argument_ValueArgument* temp = argument_kind_.value_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    argument_kind_.value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::FunctionSignature_Argument_ValueArgument& FunctionSignature_Argument::_internal_value() const {
  return _internal_has_value()
      ? *argument_kind_.value_
      : reinterpret_cast< ::substrait::FunctionSignature_Argument_ValueArgument&>(::substrait::_FunctionSignature_Argument_ValueArgument_default_instance_);
}
inline const ::substrait::FunctionSignature_Argument_ValueArgument& FunctionSignature_Argument::value() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.value)
  return _internal_value();
}
inline ::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::unsafe_arena_release_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Argument.value)
  if (_internal_has_value()) {
    clear_has_argument_kind();
    ::substrait::FunctionSignature_Argument_ValueArgument* temp = argument_kind_.value_;
    argument_kind_.value_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void FunctionSignature_Argument::unsafe_arena_set_allocated_value(::substrait::FunctionSignature_Argument_ValueArgument* value) {
  clear_argument_kind();
  if (value) {
    set_has_value();
    argument_kind_.value_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Argument.value)
}
inline ::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::_internal_mutable_value() {
  if (!_internal_has_value()) {
    clear_argument_kind();
    set_has_value();
    argument_kind_.value_ = CreateMaybeMessage< ::substrait::FunctionSignature_Argument_ValueArgument >(GetArenaForAllocation());
  }
  return argument_kind_.value_;
}
inline ::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::mutable_value() {
  ::substrait::FunctionSignature_Argument_ValueArgument* _msg = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.value)
  return _msg;
}

// .substrait.FunctionSignature.Argument.TypeArgument type = 3 [json_name = "type"];
inline bool FunctionSignature_Argument::_internal_has_type() const {
  return argument_kind_case() == kType;
}
inline bool FunctionSignature_Argument::has_type() const {
  return _internal_has_type();
}
inline void FunctionSignature_Argument::set_has_type() {
  _oneof_case_[0] = kType;
}
inline void FunctionSignature_Argument::clear_type() {
  if (_internal_has_type()) {
    if (GetArenaForAllocation() == nullptr) {
      delete argument_kind_.type_;
    }
    clear_has_argument_kind();
  }
}
inline ::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::release_type() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.type)
  if (_internal_has_type()) {
    clear_has_argument_kind();
      ::substrait::FunctionSignature_Argument_TypeArgument* temp = argument_kind_.type_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    argument_kind_.type_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::FunctionSignature_Argument_TypeArgument& FunctionSignature_Argument::_internal_type() const {
  return _internal_has_type()
      ? *argument_kind_.type_
      : reinterpret_cast< ::substrait::FunctionSignature_Argument_TypeArgument&>(::substrait::_FunctionSignature_Argument_TypeArgument_default_instance_);
}
inline const ::substrait::FunctionSignature_Argument_TypeArgument& FunctionSignature_Argument::type() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.type)
  return _internal_type();
}
inline ::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::unsafe_arena_release_type() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Argument.type)
  if (_internal_has_type()) {
    clear_has_argument_kind();
    ::substrait::FunctionSignature_Argument_TypeArgument* temp = argument_kind_.type_;
    argument_kind_.type_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void FunctionSignature_Argument::unsafe_arena_set_allocated_type(::substrait::FunctionSignature_Argument_TypeArgument* type) {
  clear_argument_kind();
  if (type) {
    set_has_type();
    argument_kind_.type_ = type;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Argument.type)
}
inline ::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::_internal_mutable_type() {
  if (!_internal_has_type()) {
    clear_argument_kind();
    set_has_type();
    argument_kind_.type_ = CreateMaybeMessage< ::substrait::FunctionSignature_Argument_TypeArgument >(GetArenaForAllocation());
  }
  return argument_kind_.type_;
}
inline ::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::mutable_type() {
  ::substrait::FunctionSignature_Argument_TypeArgument* _msg = _internal_mutable_type();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.type)
  return _msg;
}

// .substrait.FunctionSignature.Argument.EnumArgument enum = 4 [json_name = "enum"];
inline bool FunctionSignature_Argument::_internal_has_enum_() const {
  return argument_kind_case() == kEnum;
}
inline bool FunctionSignature_Argument::has_enum_() const {
  return _internal_has_enum_();
}
inline void FunctionSignature_Argument::set_has_enum_() {
  _oneof_case_[0] = kEnum;
}
inline void FunctionSignature_Argument::clear_enum_() {
  if (_internal_has_enum_()) {
    if (GetArenaForAllocation() == nullptr) {
      delete argument_kind_.enum__;
    }
    clear_has_argument_kind();
  }
}
inline ::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::release_enum_() {
  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.enum)
  if (_internal_has_enum_()) {
    clear_has_argument_kind();
      ::substrait::FunctionSignature_Argument_EnumArgument* temp = argument_kind_.enum__;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    argument_kind_.enum__ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::substrait::FunctionSignature_Argument_EnumArgument& FunctionSignature_Argument::_internal_enum_() const {
  return _internal_has_enum_()
      ? *argument_kind_.enum__
      : reinterpret_cast< ::substrait::FunctionSignature_Argument_EnumArgument&>(::substrait::_FunctionSignature_Argument_EnumArgument_default_instance_);
}
inline const ::substrait::FunctionSignature_Argument_EnumArgument& FunctionSignature_Argument::enum_() const {
  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.enum)
  return _internal_enum_();
}
inline ::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::unsafe_arena_release_enum_() {
  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Argument.enum)
  if (_internal_has_enum_()) {
    clear_has_argument_kind();
    ::substrait::FunctionSignature_Argument_EnumArgument* temp = argument_kind_.enum__;
    argument_kind_.enum__ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void FunctionSignature_Argument::unsafe_arena_set_allocated_enum_(::substrait::FunctionSignature_Argument_EnumArgument* enum_) {
  clear_argument_kind();
  if (enum_) {
    set_has_enum_();
    argument_kind_.enum__ = enum_;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Argument.enum)
}
inline ::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::_internal_mutable_enum_() {
  if (!_internal_has_enum_()) {
    clear_argument_kind();
    set_has_enum_();
    argument_kind_.enum__ = CreateMaybeMessage< ::substrait::FunctionSignature_Argument_EnumArgument >(GetArenaForAllocation());
  }
  return argument_kind_.enum__;
}
inline ::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::mutable_enum_() {
  ::substrait::FunctionSignature_Argument_EnumArgument* _msg = _internal_mutable_enum_();
  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.enum)
  return _msg;
}

inline bool FunctionSignature_Argument::has_argument_kind() const {
  return argument_kind_case() != ARGUMENT_KIND_NOT_SET;
}
inline void FunctionSignature_Argument::clear_has_argument_kind() {
  _oneof_case_[0] = ARGUMENT_KIND_NOT_SET;
}
inline FunctionSignature_Argument::ArgumentKindCase FunctionSignature_Argument::argument_kind_case() const {
  return FunctionSignature_Argument::ArgumentKindCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// FunctionSignature

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace substrait

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency>() {
  return ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor();
}
template <> struct is_proto_enum< ::substrait::FunctionSignature_Window_WindowType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::substrait::FunctionSignature_Window_WindowType>() {
  return ::substrait::FunctionSignature_Window_WindowType_descriptor();
}
template <> struct is_proto_enum< ::substrait::FunctionSignature_Implementation_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::substrait::FunctionSignature_Implementation_Type>() {
  return ::substrait::FunctionSignature_Implementation_Type_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2ffunction_2eproto
