text: // Generated by the protocol buffer compiler.  DO NOT EDIT!
  // source: flyteidl-flink/flink.proto
  
  #ifndef PROTOBUF_INCLUDED_flyteidl_2dflink_2fflink_2eproto
  #define PROTOBUF_INCLUDED_flyteidl_2dflink_2fflink_2eproto
  
  #include <limits>
  #include <string>
  
  #include <google/protobuf/port_def.inc>
  #if PROTOBUF_VERSION < 3007000
  #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 3007000 < 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_table_driven.h>
  #include <google/protobuf/generated_message_util.h>
  #include <google/protobuf/inlined_string_field.h>
  #include <google/protobuf/metadata.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/map.h>  // IWYU pragma: export
  #include <google/protobuf/map_entry.h>
  #include <google/protobuf/map_field_inl.h>
  #include <google/protobuf/generated_enum_reflection.h>
  #include <google/protobuf/unknown_field_set.h>
  #include "k8s.io/apimachinery/pkg/api/resource/generated.pb.h"
  // @@protoc_insertion_point(includes)
  #include <google/protobuf/port_def.inc>
  #define PROTOBUF_INTERNAL_EXPORT_flyteidl_2dflink_2fflink_2eproto
  
  // Internal implementation detail -- do not use these members.
  struct TableStruct_flyteidl_2dflink_2fflink_2eproto {
    static const ::google::protobuf::internal::ParseTableField entries[]
      PROTOBUF_SECTION_VARIABLE(protodesc_cold);
    static const ::google::protobuf::internal::AuxillaryParseTableField aux[]
      PROTOBUF_SECTION_VARIABLE(protodesc_cold);
    static const ::google::protobuf::internal::ParseTable schema[9]
      PROTOBUF_SECTION_VARIABLE(protodesc_cold);
    static const ::google::protobuf::internal::FieldMetadata field_metadata[];
    static const ::google::protobuf::internal::SerializationTable serialization_table[];
    static const ::google::protobuf::uint32 offsets[];
  };
  void AddDescriptors_flyteidl_2dflink_2fflink_2eproto();
  namespace flyteidl_flink {
  class FlinkExecutionInfo;
  class FlinkExecutionInfoDefaultTypeInternal;
  extern FlinkExecutionInfoDefaultTypeInternal _FlinkExecutionInfo_default_instance_;
  class FlinkJob;
  class FlinkJobDefaultTypeInternal;
  extern FlinkJobDefaultTypeInternal _FlinkJob_default_instance_;
  class FlinkJob_FlinkPropertiesEntry_DoNotUse;
  class FlinkJob_FlinkPropertiesEntry_DoNotUseDefaultTypeInternal;
  extern FlinkJob_FlinkPropertiesEntry_DoNotUseDefaultTypeInternal _FlinkJob_FlinkPropertiesEntry_DoNotUse_default_instance_;
  class JobExecutionInfo;
  class JobExecutionInfoDefaultTypeInternal;
  extern JobExecutionInfoDefaultTypeInternal _JobExecutionInfo_default_instance_;
  class JobManager;
  class JobManagerDefaultTypeInternal;
  extern JobManagerDefaultTypeInternal _JobManager_default_instance_;
  class JobManagerExecutionInfo;
  class JobManagerExecutionInfoDefaultTypeInternal;
  extern JobManagerExecutionInfoDefaultTypeInternal _JobManagerExecutionInfo_default_instance_;
  class Resource;
  class ResourceDefaultTypeInternal;
  extern ResourceDefaultTypeInternal _Resource_default_instance_;
  class Resource_PersistentVolume;
  class Resource_PersistentVolumeDefaultTypeInternal;
  extern Resource_PersistentVolumeDefaultTypeInternal _Resource_PersistentVolume_default_instance_;
  class TaskManager;
  class TaskManagerDefaultTypeInternal;
  extern TaskManagerDefaultTypeInternal _TaskManager_default_instance_;
  }  // namespace flyteidl_flink
  namespace google {
  namespace protobuf {
  template<> ::flyteidl_flink::FlinkExecutionInfo* Arena::CreateMaybeMessage<::flyteidl_flink::FlinkExecutionInfo>(Arena*);
  template<> ::flyteidl_flink::FlinkJob* Arena::CreateMaybeMessage<::flyteidl_flink::FlinkJob>(Arena*);
  template<> ::flyteidl_flink::FlinkJob_FlinkPropertiesEntry_DoNotUse* Arena::CreateMaybeMessage<::flyteidl_flink::FlinkJob_FlinkPropertiesEntry_DoNotUse>(Arena*);
  template<> ::flyteidl_flink::JobExecutionInfo* Arena::CreateMaybeMessage<::flyteidl_flink::JobExecutionInfo>(Arena*);
  template<> ::flyteidl_flink::JobManager* Arena::CreateMaybeMessage<::flyteidl_flink::JobManager>(Arena*);
  template<> ::flyteidl_flink::JobManagerExecutionInfo* Arena::CreateMaybeMessage<::flyteidl_flink::JobManagerExecutionInfo>(Arena*);
  template<> ::flyteidl_flink::Resource* Arena::CreateMaybeMessage<::flyteidl_flink::Resource>(Arena*);
  template<> ::flyteidl_flink::Resource_PersistentVolume* Arena::CreateMaybeMessage<::flyteidl_flink::Resource_PersistentVolume>(Arena*);
  template<> ::flyteidl_flink::TaskManager* Arena::CreateMaybeMessage<::flyteidl_flink::TaskManager>(Arena*);
  }  // namespace protobuf
  }  // namespace google
  namespace flyteidl_flink {
  
  enum Resource_PersistentVolume_Type {
    Resource_PersistentVolume_Type_PD_STANDARD = 0,
    Resource_PersistentVolume_Type_PD_SSD = 1,
    Resource_PersistentVolume_Type_Resource_PersistentVolume_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::google::protobuf::int32>::min(),
    Resource_PersistentVolume_Type_Resource_PersistentVolume_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::google::protobuf::int32>::max()
  };
  bool Resource_PersistentVolume_Type_IsValid(int value);
  const Resource_PersistentVolume_Type Resource_PersistentVolume_Type_Type_MIN = Resource_PersistentVolume_Type_PD_STANDARD;
  const Resource_PersistentVolume_Type Resource_PersistentVolume_Type_Type_MAX = Resource_PersistentVolume_Type_PD_SSD;
  const int Resource_PersistentVolume_Type_Type_ARRAYSIZE = Resource_PersistentVolume_Type_Type_MAX + 1;
  
  const ::google::protobuf::EnumDescriptor* Resource_PersistentVolume_Type_descriptor();
  inline const ::std::string& Resource_PersistentVolume_Type_Name(Resource_PersistentVolume_Type value) {
    return ::google::protobuf::internal::NameOfEnum(
      Resource_PersistentVolume_Type_descriptor(), value);
  }
  inline bool Resource_PersistentVolume_Type_Parse(
      const ::std::string& name, Resource_PersistentVolume_Type* value) {
    return ::google::protobuf::internal::ParseNamedEnum<Resource_PersistentVolume_Type>(
      Resource_PersistentVolume_Type_descriptor(), name, value);
  }
  // ===================================================================
  
  class Resource_PersistentVolume final :
      public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:flyteidl_flink.Resource.PersistentVolume) */ {
   public:
    Resource_PersistentVolume();
    virtual ~Resource_PersistentVolume();
  
    Resource_PersistentVolume(const Resource_PersistentVolume& from);
  
    inline Resource_PersistentVolume& operator=(const Resource_PersistentVolume& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    Resource_PersistentVolume(Resource_PersistentVolume&& from) noexcept
      : Resource_PersistentVolume() {
      *this = ::std::move(from);
    }
  
    inline Resource_PersistentVolume& operator=(Resource_PersistentVolume&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor() {
      return default_instance().GetDescriptor();
    }
    static const Resource_PersistentVolume& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const Resource_PersistentVolume* internal_default_instance() {
      return reinterpret_cast<const Resource_PersistentVolume*>(
                 &_Resource_PersistentVolume_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      0;
  
    void Swap(Resource_PersistentVolume* other);
    friend void swap(Resource_PersistentVolume& a, Resource_PersistentVolume& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline Resource_PersistentVolume* New() const final {
      return CreateMaybeMessage<Resource_PersistentVolume>(nullptr);
    }
  
    Resource_PersistentVolume* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<Resource_PersistentVolume>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const Resource_PersistentVolume& from);
    void MergeFrom(const Resource_PersistentVolume& from);
    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
    ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
    #else
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(Resource_PersistentVolume* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return nullptr;
    }
    inline void* MaybeArenaPtr() const {
      return nullptr;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    typedef Resource_PersistentVolume_Type Type;
    static const Type PD_STANDARD =
      Resource_PersistentVolume_Type_PD_STANDARD;
    static const Type PD_SSD =
      Resource_PersistentVolume_Type_PD_SSD;
    static inline bool Type_IsValid(int value) {
      return Resource_PersistentVolume_Type_IsValid(value);
    }
    static const Type Type_MIN =
      Resource_PersistentVolume_Type_Type_MIN;
    static const Type Type_MAX =
      Resource_PersistentVolume_Type_Type_MAX;
    static const int Type_ARRAYSIZE =
      Resource_PersistentVolume_Type_Type_ARRAYSIZE;
    static inline const ::google::protobuf::EnumDescriptor*
    Type_descriptor() {
      return Resource_PersistentVolume_Type_descriptor();
    }
    static inline const ::std::string& Type_Name(Type value) {
      return Resource_PersistentVolume_Type_Name(value);
    }
    static inline bool Type_Parse(const ::std::string& name,
        Type* value) {
      return Resource_PersistentVolume_Type_Parse(name, value);
    }
  
    // accessors -------------------------------------------------------
  
    // .k8s.io.apimachinery.pkg.api.resource.Quantity size = 2;
    bool has_size() const;
    void clear_size();
    static const int kSizeFieldNumber = 2;
    const ::k8s::io::apimachinery::pkg::api::resource::Quantity& size() const;
    ::k8s::io::apimachinery::pkg::api::resource::Quantity* release_size();
    ::k8s::io::apimachinery::pkg::api::resource::Quantity* mutable_size();
    void set_allocated_size(::k8s::io::apimachinery::pkg::api::resource::Quantity* size);
  
    // .flyteidl_flink.Resource.PersistentVolume.Type type = 1;
    void clear_type();
    static const int kTypeFieldNumber = 1;
    ::flyteidl_flink::Resource_PersistentVolume_Type type() const;
    void set_type(::flyteidl_flink::Resource_PersistentVolume_Type value);
  
    // @@protoc_insertion_point(class_scope:flyteidl_flink.Resource.PersistentVolume)
   private:
    class HasBitSetters;
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    ::k8s::io::apimachinery::pkg::api::resource::Quantity* size_;
    int type_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_flyteidl_2dflink_2fflink_2eproto;
  };
  // -------------------------------------------------------------------
  
  class Resource final :
      public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:flyteidl_flink.Resource) */ {
   public:
    Resource();
    virtual ~Resource();
  
    Resource(const Resource& from);
  
    inline Resource& operator=(const Resource& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    Resource(Resource&& from) noexcept
      : Resource() {
      *this = ::std::move(from);
    }
  
    inline Resource& operator=(Resource&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor() {
      return default_instance().GetDescriptor();
    }
    static const Resource& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const Resource* internal_default_instance() {
      return reinterpret_cast<const Resource*>(
                 &_Resource_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      1;
  
    void Swap(Resource* other);
    friend void swap(Resource& a, Resource& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline Resource* New() const final {
      return CreateMaybeMessage<Resource>(nullptr);
    }
  
    Resource* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<Resource>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const Resource& from);
    void MergeFrom(const Resource& from);
    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
    ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
    #else
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(Resource* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return nullptr;
    }
    inline void* MaybeArenaPtr() const {
      return nullptr;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    typedef Resource_PersistentVolume PersistentVolume;
  
    // accessors -------------------------------------------------------
  
    // .k8s.io.apimachinery.pkg.api.resource.Quantity cpu = 1;
    bool has_cpu() const;
    void clear_cpu();
    static const int kCpuFieldNumber = 1;
    const ::k8s::io::apimachinery::pkg::api::resource::Quantity& cpu() const;
    ::k8s::io::apimachinery::pkg::api::resource::Quantity* release_cpu();
    ::k8s::io::apimachinery::pkg::api::resource::Quantity* mutable_cpu();
    void set_allocated_cpu(::k8s::io::apimachinery::pkg::api::resource::Quantity* cpu);
  
    // .k8s.io.apimachinery.pkg.api.resource.Quantity memory = 2;
    bool has_memory() const;
    void clear_memory();
    static const int kMemoryFieldNumber = 2;
    const ::k8s::io::apimachinery::pkg::api::resource::Quantity& memory() const;
    ::k8s::io::apimachinery::pkg::api::resource::Quantity* release_memory();
    ::k8s::io::apimachinery::pkg::api::resource::Quantity* mutable_memory();
    void set_allocated_memory(::k8s::io::apimachinery::pkg::api::resource::Quantity* memory);
  
    // .flyteidl_flink.Resource.PersistentVolume persistentVolume = 3;
    bool has_persistentvolume() const;
    void clear_persistentvolume();
    static const int kPersistentVolumeFieldNumber = 3;
    const ::flyteidl_flink::Resource_PersistentVolume& persistentvolume() const;
    ::flyteidl_flink::Resource_PersistentVolume* release_persistentvolume();
    ::flyteidl_flink::Resource_PersistentVolume* mutable_persistentvolume();
    void set_allocated_persistentvolume(::flyteidl_flink::Resource_PersistentVolume* persistentvolume);
  
    // @@protoc_insertion_point(class_scope:flyteidl_flink.Resource)
   private:
    class HasBitSetters;
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    ::k8s::io::apimachinery::pkg::api::resource::Quantity* cpu_;
    ::k8s::io::apimachinery::pkg::api::resource::Quantity* memory_;
    ::flyteidl_flink::Resource_PersistentVolume* persistentvolume_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_flyteidl_2dflink_2fflink_2eproto;
  };
  // -------------------------------------------------------------------
  
  class JobManager final :
      public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:flyteidl_flink.JobManager) */ {
   public:
    JobManager();
    virtual ~JobManager();
  
    JobManager(const JobManager& from);
  
    inline JobManager& operator=(const JobManager& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    JobManager(JobManager&& from) noexcept
      : JobManager() {
      *this = ::std::move(from);
    }
  
    inline JobManager& operator=(JobManager&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor() {
      return default_instance().GetDescriptor();
    }
    static const JobManager& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const JobManager* internal_default_instance() {
      return reinterpret_cast<const JobManager*>(
                 &_JobManager_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      2;
  
    void Swap(JobManager* other);
    friend void swap(JobManager& a, JobManager& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline JobManager* New() const final {
      return CreateMaybeMessage<JobManager>(nullptr);
    }
  
    JobManager* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<JobManager>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const JobManager& from);
    void MergeFrom(const JobManager& from);
    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
    ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
    #else
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(JobManager* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return nullptr;
    }
    inline void* MaybeArenaPtr() const {
      return nullptr;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // .flyteidl_flink.Resource resource = 1;
    bool has_resource() const;
    void clear_resource();
    static const int kResourceFieldNumber = 1;
    const ::flyteidl_flink::Resource& resource() const;
    ::flyteidl_flink::Resource* release_resource();
    ::flyteidl_flink::Resource* mutable_resource();
    void set_allocated_resource(::flyteidl_flink::Resource* resource);
  
    // @@protoc_insertion_point(class_scope:flyteidl_flink.JobManager)
   private:
    class HasBitSetters;
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    ::flyteidl_flink::Resource* resource_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_flyteidl_2dflink_2fflink_2eproto;
  };
  // -------------------------------------------------------------------
  
  class TaskManager final :
      public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:flyteidl_flink.TaskManager) */ {
   public:
    TaskManager();
    virtual ~TaskManager();
  
    TaskManager(const TaskManager& from);
  
    inline TaskManager& operator=(const TaskManager& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    TaskManager(TaskManager&& from) noexcept
      : TaskManager() {
      *this = ::std::move(from);
    }
  
    inline TaskManager& operator=(TaskManager&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor() {
      return default_instance().GetDescriptor();
    }
    static const TaskManager& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const TaskManager* internal_default_instance() {
      return reinterpret_cast<const TaskManager*>(
                 &_TaskManager_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      3;
  
    void Swap(TaskManager* other);
    friend void swap(TaskManager& a, TaskManager& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline TaskManager* New() const final {
      return CreateMaybeMessage<TaskManager>(nullptr);
    }
  
    TaskManager* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<TaskManager>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const TaskManager& from);
    void MergeFrom(const TaskManager& from);
    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
    ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
    #else
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(TaskManager* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return nullptr;
    }
    inline void* MaybeArenaPtr() const {
      return nullptr;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // .flyteidl_flink.Resource resource = 1;
    bool has_resource() const;
    void clear_resource();
    static const int kResourceFieldNumber = 1;
    const ::flyteidl_flink::Resource& resource() const;
    ::flyteidl_flink::Resource* release_resource();
    ::flyteidl_flink::Resource* mutable_resource();
    void set_allocated_resource(::flyteidl_flink::Resource* resource);
  
    // int32 replicas = 2;
    void clear_replicas();
    static const int kReplicasFieldNumber = 2;
    ::google::protobuf::int32 replicas() const;
    void set_replicas(::google::protobuf::int32 value);
  
    // @@protoc_insertion_point(class_scope:flyteidl_flink.TaskManager)
   private:
    class HasBitSetters;
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    ::flyteidl_flink::Resource* resource_;
    ::google::protobuf::int32 replicas_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_flyteidl_2dflink_2fflink_2eproto;
  };
  // -------------------------------------------------------------------
  
  class FlinkJob_FlinkPropertiesEntry_DoNotUse : public ::google::protobuf::internal::MapEntry<FlinkJob_FlinkPropertiesEntry_DoNotUse, 
      ::std::string, ::std::string,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      0 > {
  public:
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static bool _ParseMap(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    typedef ::google::protobuf::internal::MapEntry<FlinkJob_FlinkPropertiesEntry_DoNotUse, 
      ::std::string, ::std::string,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      0 > SuperType;
    FlinkJob_FlinkPropertiesEntry_DoNotUse();
    FlinkJob_FlinkPropertiesEntry_DoNotUse(::google::protobuf::Arena* arena);
    void MergeFrom(const FlinkJob_FlinkPropertiesEntry_DoNotUse& other);
    static const FlinkJob_FlinkPropertiesEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const FlinkJob_FlinkPropertiesEntry_DoNotUse*>(&_FlinkJob_FlinkPropertiesEntry_DoNotUse_default_instance_); }
    void MergeFrom(const ::google::protobuf::Message& other) final;
    ::google::protobuf::Metadata GetMetadata() const;
  };
  
  // -------------------------------------------------------------------
  
  class FlinkJob final :
      public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:flyteidl_flink.FlinkJob) */ {
   public:
    FlinkJob();
    virtual ~FlinkJob();
  
    FlinkJob(const FlinkJob& from);
  
    inline FlinkJob& operator=(const FlinkJob& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    FlinkJob(FlinkJob&& from) noexcept
      : FlinkJob() {
      *this = ::std::move(from);
    }
  
    inline FlinkJob& operator=(FlinkJob&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor() {
      return default_instance().GetDescriptor();
    }
    static const FlinkJob& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const FlinkJob* internal_default_instance() {
      return reinterpret_cast<const FlinkJob*>(
                 &_FlinkJob_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      5;
  
    void Swap(FlinkJob* other);
    friend void swap(FlinkJob& a, FlinkJob& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline FlinkJob* New() const final {
      return CreateMaybeMessage<FlinkJob>(nullptr);
    }
  
    FlinkJob* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<FlinkJob>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const FlinkJob& from);
    void MergeFrom(const FlinkJob& from);
    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
    ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
    #else
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(FlinkJob* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return nullptr;
    }
    inline void* MaybeArenaPtr() const {
      return nullptr;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
  
    // accessors -------------------------------------------------------
  
    // repeated string args = 3;
    int args_size() const;
    void clear_args();
    static const int kArgsFieldNumber = 3;
    const ::std::string& args(int index) const;
    ::std::string* mutable_args(int index);
    void set_args(int index, const ::std::string& value);
    #if LANG_CXX11
    void set_args(int index, ::std::string&& value);
    #endif
    void set_args(int index, const char* value);
    void set_args(int index, const char* value, size_t size);
    ::std::string* add_args();
    void add_args(const ::std::string& value);
    #if LANG_CXX11
    void add_args(::std::string&& value);
    #endif
    void add_args(const char* value);
    void add_args(const char* value, size_t size);
    const ::google::protobuf::RepeatedPtrField<::std::string>& args() const;
    ::google::protobuf::RepeatedPtrField<::std::string>* mutable_args();
  
    // map<string, string> flinkProperties = 4;
    int flinkproperties_size() const;
    void clear_flinkproperties();
    static const int kFlinkPropertiesFieldNumber = 4;
    const ::google::protobuf::Map< ::std::string, ::std::string >&
        flinkproperties() const;
    ::google::protobuf::Map< ::std::string, ::std::string >*
        mutable_flinkproperties();
  
    // string jarFile = 1;
    void clear_jarfile();
    static const int kJarFileFieldNumber = 1;
    const ::std::string& jarfile() const;
    void set_jarfile(const ::std::string& value);
    #if LANG_CXX11
    void set_jarfile(::std::string&& value);
    #endif
    void set_jarfile(const char* value);
    void set_jarfile(const char* value, size_t size);
    ::std::string* mutable_jarfile();
    ::std::string* release_jarfile();
    void set_allocated_jarfile(::std::string* jarfile);
  
    // string mainClass = 2;
    void clear_mainclass();
    static const int kMainClassFieldNumber = 2;
    const ::std::string& mainclass() const;
    void set_mainclass(const ::std::string& value);
    #if LANG_CXX11
    void set_mainclass(::std::string&& value);
    #endif
    void set_mainclass(const char* value);
    void set_mainclass(const char* value, size_t size);
    ::std::string* mutable_mainclass();
    ::std::string* release_mainclass();
    void set_allocated_mainclass(::std::string* mainclass);
  
    // string serviceAccount = 7;
    void clear_serviceaccount();
    static const int kServiceAccountFieldNumber = 7;
    const ::std::string& serviceaccount() const;
    void set_serviceaccount(const ::std::string& value);
    #if LANG_CXX11
    void set_serviceaccount(::std::string&& value);
    #endif
    void set_serviceaccount(const char* value);
    void set_serviceaccount(const char* value, size_t size);
    ::std::string* mutable_serviceaccount();
    ::std::string* release_serviceaccount();
    void set_allocated_serviceaccount(::std::string* serviceaccount);
  
    // string image = 8;
    void clear_image();
    static const int kImageFieldNumber = 8;
    const ::std::string& image() const;
    void set_image(const ::std::string& value);
    #if LANG_CXX11
    void set_image(::std::string&& value);
    #endif
    void set_image(const char* value);
    void set_image(const char* value, size_t size);
    ::std::string* mutable_image();
    ::std::string* release_image();
    void set_allocated_image(::std::string* image);
  
    // .flyteidl_flink.JobManager jobManager = 5;
    bool has_jobmanager() const;
    void clear_jobmanager();
    static const int kJobManagerFieldNumber = 5;
    const ::flyteidl_flink::JobManager& jobmanager() const;
    ::flyteidl_flink::JobManager* release_jobmanager();
    ::flyteidl_flink::JobManager* mutable_jobmanager();
    void set_allocated_jobmanager(::flyteidl_flink::JobManager* jobmanager);
  
    // .flyteidl_flink.TaskManager taskManager = 6;
    bool has_taskmanager() const;
    void clear_taskmanager();
    static const int kTaskManagerFieldNumber = 6;
    const ::flyteidl_flink::TaskManager& taskmanager() const;
    ::flyteidl_flink::TaskManager* release_taskmanager();
    ::flyteidl_flink::TaskManager* mutable_taskmanager();
    void set_allocated_taskmanager(::flyteidl_flink::TaskManager* taskmanager);
  
    // @@protoc_insertion_point(class_scope:flyteidl_flink.FlinkJob)
   private:
    class HasBitSetters;
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    ::google::protobuf::RepeatedPtrField<::std::string> args_;
    ::google::protobuf::internal::MapField<
        FlinkJob_FlinkPropertiesEntry_DoNotUse,
        ::std::string, ::std::string,
        ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
        ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
        0 > flinkproperties_;
    ::google::protobuf::internal::ArenaStringPtr jarfile_;
    ::google::protobuf::internal::ArenaStringPtr mainclass_;
    ::google::protobuf::internal::ArenaStringPtr serviceaccount_;
    ::google::protobuf::internal::ArenaStringPtr image_;
    ::flyteidl_flink::JobManager* jobmanager_;
    ::flyteidl_flink::TaskManager* taskmanager_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_flyteidl_2dflink_2fflink_2eproto;
  };
  // -------------------------------------------------------------------
  
  class JobExecutionInfo final :
      public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:flyteidl_flink.JobExecutionInfo) */ {
   public:
    JobExecutionInfo();
    virtual ~JobExecutionInfo();
  
    JobExecutionInfo(const JobExecutionInfo& from);
  
    inline JobExecutionInfo& operator=(const JobExecutionInfo& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    JobExecutionInfo(JobExecutionInfo&& from) noexcept
      : JobExecutionInfo() {
      *this = ::std::move(from);
    }
  
    inline JobExecutionInfo& operator=(JobExecutionInfo&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor() {
      return default_instance().GetDescriptor();
    }
    static const JobExecutionInfo& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const JobExecutionInfo* internal_default_instance() {
      return reinterpret_cast<const JobExecutionInfo*>(
                 &_JobExecutionInfo_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      6;
  
    void Swap(JobExecutionInfo* other);
    friend void swap(JobExecutionInfo& a, JobExecutionInfo& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline JobExecutionInfo* New() const final {
      return CreateMaybeMessage<JobExecutionInfo>(nullptr);
    }
  
    JobExecutionInfo* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<JobExecutionInfo>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const JobExecutionInfo& from);
    void MergeFrom(const JobExecutionInfo& from);
    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
    ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
    #else
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(JobExecutionInfo* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return nullptr;
    }
    inline void* MaybeArenaPtr() const {
      return nullptr;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // string id = 1;
    void clear_id();
    static const int kIdFieldNumber = 1;
    const ::std::string& id() const;
    void set_id(const ::std::string& value);
    #if LANG_CXX11
    void set_id(::std::string&& value);
    #endif
    void set_id(const char* value);
    void set_id(const char* value, size_t size);
    ::std::string* mutable_id();
    ::std::string* release_id();
    void set_allocated_id(::std::string* id);
  
    // @@protoc_insertion_point(class_scope:flyteidl_flink.JobExecutionInfo)
   private:
    class HasBitSetters;
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    ::google::protobuf::internal::ArenaStringPtr id_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_flyteidl_2dflink_2fflink_2eproto;
  };
  // -------------------------------------------------------------------
  
  class JobManagerExecutionInfo final :
      public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:flyteidl_flink.JobManagerExecutionInfo) */ {
   public:
    JobManagerExecutionInfo();
    virtual ~JobManagerExecutionInfo();
  
    JobManagerExecutionInfo(const JobManagerExecutionInfo& from);
  
    inline JobManagerExecutionInfo& operator=(const JobManagerExecutionInfo& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    JobManagerExecutionInfo(JobManagerExecutionInfo&& from) noexcept
      : JobManagerExecutionInfo() {
      *this = ::std::move(from);
    }
  
    inline JobManagerExecutionInfo& operator=(JobManagerExecutionInfo&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor() {
      return default_instance().GetDescriptor();
    }
    static const JobManagerExecutionInfo& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const JobManagerExecutionInfo* internal_default_instance() {
      return reinterpret_cast<const JobManagerExecutionInfo*>(
                 &_JobManagerExecutionInfo_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      7;
  
    void Swap(JobManagerExecutionInfo* other);
    friend void swap(JobManagerExecutionInfo& a, JobManagerExecutionInfo& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline JobManagerExecutionInfo* New() const final {
      return CreateMaybeMessage<JobManagerExecutionInfo>(nullptr);
    }
  
    JobManagerExecutionInfo* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<JobManagerExecutionInfo>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const JobManagerExecutionInfo& from);
    void MergeFrom(const JobManagerExecutionInfo& from);
    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
    ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
    #else
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(JobManagerExecutionInfo* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return nullptr;
    }
    inline void* MaybeArenaPtr() const {
      return nullptr;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // repeated string ingressURLs = 1;
    int ingressurls_size() const;
    void clear_ingressurls();
    static const int kIngressURLsFieldNumber = 1;
    const ::std::string& ingressurls(int index) const;
    ::std::string* mutable_ingressurls(int index);
    void set_ingressurls(int index, const ::std::string& value);
    #if LANG_CXX11
    void set_ingressurls(int index, ::std::string&& value);
    #endif
    void set_ingressurls(int index, const char* value);
    void set_ingressurls(int index, const char* value, size_t size);
    ::std::string* add_ingressurls();
    void add_ingressurls(const ::std::string& value);
    #if LANG_CXX11
    void add_ingressurls(::std::string&& value);
    #endif
    void add_ingressurls(const char* value);
    void add_ingressurls(const char* value, size_t size);
    const ::google::protobuf::RepeatedPtrField<::std::string>& ingressurls() const;
    ::google::protobuf::RepeatedPtrField<::std::string>* mutable_ingressurls();
  
    // @@protoc_insertion_point(class_scope:flyteidl_flink.JobManagerExecutionInfo)
   private:
    class HasBitSetters;
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    ::google::protobuf::RepeatedPtrField<::std::string> ingressurls_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_flyteidl_2dflink_2fflink_2eproto;
  };
  // -------------------------------------------------------------------
  
  class FlinkExecutionInfo final :
      public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:flyteidl_flink.FlinkExecutionInfo) */ {
   public:
    FlinkExecutionInfo();
    virtual ~FlinkExecutionInfo();
  
    FlinkExecutionInfo(const FlinkExecutionInfo& from);
  
    inline FlinkExecutionInfo& operator=(const FlinkExecutionInfo& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    FlinkExecutionInfo(FlinkExecutionInfo&& from) noexcept
      : FlinkExecutionInfo() {
      *this = ::std::move(from);
    }
  
    inline FlinkExecutionInfo& operator=(FlinkExecutionInfo&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor() {
      return default_instance().GetDescriptor();
    }
    static const FlinkExecutionInfo& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const FlinkExecutionInfo* internal_default_instance() {
      return reinterpret_cast<const FlinkExecutionInfo*>(
                 &_FlinkExecutionInfo_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      8;
  
    void Swap(FlinkExecutionInfo* other);
    friend void swap(FlinkExecutionInfo& a, FlinkExecutionInfo& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline FlinkExecutionInfo* New() const final {
      return CreateMaybeMessage<FlinkExecutionInfo>(nullptr);
    }
  
    FlinkExecutionInfo* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<FlinkExecutionInfo>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const FlinkExecutionInfo& from);
    void MergeFrom(const FlinkExecutionInfo& from);
    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
    ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
    #else
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(FlinkExecutionInfo* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return nullptr;
    }
    inline void* MaybeArenaPtr() const {
      return nullptr;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // .flyteidl_flink.JobExecutionInfo job = 1;
    bool has_job() const;
    void clear_job();
    static const int kJobFieldNumber = 1;
    const ::flyteidl_flink::JobExecutionInfo& job() const;
    ::flyteidl_flink::JobExecutionInfo* release_job();
    ::flyteidl_flink::JobExecutionInfo* mutable_job();
    void set_allocated_job(::flyteidl_flink::JobExecutionInfo* job);
  
    // .flyteidl_flink.JobManagerExecutionInfo jobManager = 2;
    bool has_jobmanager() const;
    void clear_jobmanager();
    static const int kJobManagerFieldNumber = 2;
    const ::flyteidl_flink::JobManagerExecutionInfo& jobmanager() const;
    ::flyteidl_flink::JobManagerExecutionInfo* release_jobmanager();
    ::flyteidl_flink::JobManagerExecutionInfo* mutable_jobmanager();
    void set_allocated_jobmanager(::flyteidl_flink::JobManagerExecutionInfo* jobmanager);
  
    // @@protoc_insertion_point(class_scope:flyteidl_flink.FlinkExecutionInfo)
   private:
    class HasBitSetters;
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    ::flyteidl_flink::JobExecutionInfo* job_;
    ::flyteidl_flink::JobManagerExecutionInfo* jobmanager_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_flyteidl_2dflink_2fflink_2eproto;
  };
  // ===================================================================
  
  
  // ===================================================================
  
  #ifdef __GNUC__
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wstrict-aliasing"
  #endif  // __GNUC__
  // Resource_PersistentVolume
  
  // .flyteidl_flink.Resource.PersistentVolume.Type type = 1;
  inline void Resource_PersistentVolume::clear_type() {
    type_ = 0;
  }
  inline ::flyteidl_flink::Resource_PersistentVolume_Type Resource_PersistentVolume::type() const {
    // @@protoc_insertion_point(field_get:flyteidl_flink.Resource.PersistentVolume.type)
    return static_cast< ::flyteidl_flink::Resource_PersistentVolume_Type >(type_);
  }
  inline void Resource_PersistentVolume::set_type(::flyteidl_flink::Resource_PersistentVolume_Type value) {
    
    type_ = value;
    // @@protoc_insertion_point(field_set:flyteidl_flink.Resource.PersistentVolume.type)
  }
  
  // .k8s.io.apimachinery.pkg.api.resource.Quantity size = 2;
  inline bool Resource_PersistentVolume::has_size() const {
    return this != internal_default_instance() && size_ != nullptr;
  }
  inline const ::k8s::io::apimachinery::pkg::api::resource::Quantity& Resource_PersistentVolume::size() const {
    const ::k8s::io::apimachinery::pkg::api::resource::Quantity* p = size_;
    // @@protoc_insertion_point(field_get:flyteidl_flink.Resource.PersistentVolume.size)
    return p != nullptr ? *p : *reinterpret_cast<const ::k8s::io::apimachinery::pkg::api::resource::Quantity*>(
        &::k8s::io::apimachinery::pkg::api::resource::_Quantity_default_instance_);
  }
  inline ::k8s::io::apimachinery::pkg::api::resource::Quantity* Resource_PersistentVolume::release_size() {
    // @@protoc_insertion_point(field_release:flyteidl_flink.Resource.PersistentVolume.size)
    
    ::k8s::io::apimachinery::pkg::api::resource::Quantity* temp = size_;
    size_ = nullptr;
    return temp;
  }
  inline ::k8s::io::apimachinery::pkg::api::resource::Quantity* Resource_PersistentVolume::mutable_size() {
    
    if (size_ == nullptr) {
      auto* p = CreateMaybeMessage<::k8s::io::apimachinery::pkg::api::resource::Quantity>(GetArenaNoVirtual());
      size_ = p;
    }
    // @@protoc_insertion_point(field_mutable:flyteidl_flink.Resource.PersistentVolume.size)
    return size_;
  }
  inline void Resource_PersistentVolume::set_allocated_size(::k8s::io::apimachinery::pkg::api::resource::Quantity* size) {
    ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
    if (message_arena == nullptr) {
      delete reinterpret_cast< ::google::protobuf::MessageLite*>(size_);
    }
    if (size) {
      ::google::protobuf::Arena* submessage_arena = nullptr;
      if (message_arena != submessage_arena) {
        size = ::google::protobuf::internal::GetOwnedMessage(
            message_arena, size, submessage_arena);
      }
      
    } else {
      
    }
    size_ = size;
    // @@protoc_insertion_point(field_set_allocated:flyteidl_flink.Resource.PersistentVolume.size)
  }
  
  // -------------------------------------------------------------------
  
  // Resource
  
  // .k8s.io.apimachinery.pkg.api.resource.Quantity cpu = 1;
  inline bool Resource::has_cpu() const {
    return this != internal_default_instance() && cpu_ != nullptr;
  }
  inline const ::k8s::io::apimachinery::pkg::api::resource::Quantity& Resource::cpu() const {
    const ::k8s::io::apimachinery::pkg::api::resource::Quantity* p = cpu_;
    // @@protoc_insertion_point(field_get:flyteidl_flink.Resource.cpu)
    return p != nullptr ? *p : *reinterpret_cast<const ::k8s::io::apimachinery::pkg::api::resource::Quantity*>(
        &::k8s::io::apimachinery::pkg::api::resource::_Quantity_default_instance_);
  }
  inline ::k8s::io::apimachinery::pkg::api::resource::Quantity* Resource::release_cpu() {
    // @@protoc_insertion_point(field_release:flyteidl_flink.Resource.cpu)
    
    ::k8s::io::apimachinery::pkg::api::resource::Quantity* temp = cpu_;
    cpu_ = nullptr;
    return temp;
  }
  inline ::k8s::io::apimachinery::pkg::api::resource::Quantity* Resource::mutable_cpu() {
    
    if (cpu_ == nullptr) {
      auto* p = CreateMaybeMessage<::k8s::io::apimachinery::pkg::api::resource::Quantity>(GetArenaNoVirtual());
      cpu_ = p;
    }
    // @@protoc_insertion_point(field_mutable:flyteidl_flink.Resource.cpu)
    return cpu_;
  }
  inline void Resource::set_allocated_cpu(::k8s::io::apimachinery::pkg::api::resource::Quantity* cpu) {
    ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
    if (message_arena == nullptr) {
      delete reinterpret_cast< ::google::protobuf::MessageLite*>(cpu_);
    }
    if (cpu) {
      ::google::protobuf::Arena* submessage_arena = nullptr;
      if (message_arena != submessage_arena) {
        cpu = ::google::protobuf::internal::GetOwnedMessage(
            message_arena, cpu, submessage_arena);
      }
      
    } else {
      
    }
    cpu_ = cpu;
    // @@protoc_insertion_point(field_set_allocated:flyteidl_flink.Resource.cpu)
  }
  
  // .k8s.io.apimachinery.pkg.api.resource.Quantity memory = 2;
  inline bool Resource::has_memory() const {
    return this != internal_default_instance() && memory_ != nullptr;
  }
  inline const ::k8s::io::apimachinery::pkg::api::resource::Quantity& Resource::memory() const {
    const ::k8s::io::apimachinery::pkg::api::resource::Quantity* p = memory_;
    // @@protoc_insertion_point(field_get:flyteidl_flink.Resource.memory)
    return p != nullptr ? *p : *reinterpret_cast<const ::k8s::io::apimachinery::pkg::api::resource::Quantity*>(
        &::k8s::io::apimachinery::pkg::api::resource::_Quantity_default_instance_);
  }
  inline ::k8s::io::apimachinery::pkg::api::resource::Quantity* Resource::release_memory() {
    // @@protoc_insertion_point(field_release:flyteidl_flink.Resource.memory)
    
    ::k8s::io::apimachinery::pkg::api::resource::Quantity* temp = memory_;
    memory_ = nullptr;
    return temp;
  }
  inline ::k8s::io::apimachinery::pkg::api::resource::Quantity* Resource::mutable_memory() {
    
    if (memory_ == nullptr) {
      auto* p = CreateMaybeMessage<::k8s::io::apimachinery::pkg::api::resource::Quantity>(GetArenaNoVirtual());
      memory_ = p;
    }
    // @@protoc_insertion_point(field_mutable:flyteidl_flink.Resource.memory)
    return memory_;
  }
  inline void Resource::set_allocated_memory(::k8s::io::apimachinery::pkg::api::resource::Quantity* memory) {
    ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
    if (message_arena == nullptr) {
      delete reinterpret_cast< ::google::protobuf::MessageLite*>(memory_);
    }
    if (memory) {
      ::google::protobuf::Arena* submessage_arena = nullptr;
      if (message_arena != submessage_arena) {
        memory = ::google::protobuf::internal::GetOwnedMessage(
            message_arena, memory, submessage_arena);
      }
      
    } else {
      
    }
    memory_ = memory;
    // @@protoc_insertion_point(field_set_allocated:flyteidl_flink.Resource.memory)
  }
  
  // .flyteidl_flink.Resource.PersistentVolume persistentVolume = 3;
  inline bool Resource::has_persistentvolume() const {
    return this != internal_default_instance() && persistentvolume_ != nullptr;
  }
  inline void Resource::clear_persistentvolume() {
    if (GetArenaNoVirtual() == nullptr && persistentvolume_ != nullptr) {
      delete persistentvolume_;
    }
    persistentvolume_ = nullptr;
  }
  inline const ::flyteidl_flink::Resource_PersistentVolume& Resource::persistentvolume() const {
    const ::flyteidl_flink::Resource_PersistentVolume* p = persistentvolume_;
    // @@protoc_insertion_point(field_get:flyteidl_flink.Resource.persistentVolume)
    return p != nullptr ? *p : *reinterpret_cast<const ::flyteidl_flink::Resource_PersistentVolume*>(
        &::flyteidl_flink::_Resource_PersistentVolume_default_instance_);
  }
  inline ::flyteidl_flink::Resource_PersistentVolume* Resource::release_persistentvolume() {
    // @@protoc_insertion_point(field_release:flyteidl_flink.Resource.persistentVolume)
    
    ::flyteidl_flink::Resource_PersistentVolume* temp = persistentvolume_;
    persistentvolume_ = nullptr;
    return temp;
  }
  inline ::flyteidl_flink::Resource_PersistentVolume* Resource::mutable_persistentvolume() {
    
    if (persistentvolume_ == nullptr) {
      auto* p = CreateMaybeMessage<::flyteidl_flink::Resource_PersistentVolume>(GetArenaNoVirtual());
      persistentvolume_ = p;
    }
    // @@protoc_insertion_point(field_mutable:flyteidl_flink.Resource.persistentVolume)
    return persistentvolume_;
  }
  inline void Resource::set_allocated_persistentvolume(::flyteidl_flink::Resource_PersistentVolume* persistentvolume) {
    ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
    if (message_arena == nullptr) {
      delete persistentvolume_;
    }
    if (persistentvolume) {
      ::google::protobuf::Arena* submessage_arena = nullptr;
      if (message_arena != submessage_arena) {
        persistentvolume = ::google::protobuf::internal::GetOwnedMessage(
            message_arena, persistentvolume, submessage_arena);
      }
      
    } else {
      
    }
    persistentvolume_ = persistentvolume;
    // @@protoc_insertion_point(field_set_allocated:flyteidl_flink.Resource.persistentVolume)
  }
  
  // -------------------------------------------------------------------
  
  // JobManager
  
  // .flyteidl_flink.Resource resource = 1;
  inline bool JobManager::has_resource() const {
    return this != internal_default_instance() && resource_ != nullptr;
  }
  inline void JobManager::clear_resource() {
    if (GetArenaNoVirtual() == nullptr && resource_ != nullptr) {
      delete resource_;
    }
    resource_ = nullptr;
  }
  inline const ::flyteidl_flink::Resource& JobManager::resource() const {
    const ::flyteidl_flink::Resource* p = resource_;
    // @@protoc_insertion_point(field_get:flyteidl_flink.JobManager.resource)
    return p != nullptr ? *p : *reinterpret_cast<const ::flyteidl_flink::Resource*>(
        &::flyteidl_flink::_Resource_default_instance_);
  }
  inline ::flyteidl_flink::Resource* JobManager::release_resource() {
    // @@protoc_insertion_point(field_release:flyteidl_flink.JobManager.resource)
    
    ::flyteidl_flink::Resource* temp = resource_;
    resource_ = nullptr;
    return temp;
  }
  inline ::flyteidl_flink::Resource* JobManager::mutable_resource() {
    
    if (resource_ == nullptr) {
      auto* p = CreateMaybeMessage<::flyteidl_flink::Resource>(GetArenaNoVirtual());
      resource_ = p;
    }
    // @@protoc_insertion_point(field_mutable:flyteidl_flink.JobManager.resource)
    return resource_;
  }
  inline void JobManager::set_allocated_resource(::flyteidl_flink::Resource* resource) {
    ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
    if (message_arena == nullptr) {
      delete resource_;
    }
    if (resource) {
      ::google::protobuf::Arena* submessage_arena = nullptr;
      if (message_arena != submessage_arena) {
        resource = ::google::protobuf::internal::GetOwnedMessage(
            message_arena, resource, submessage_arena);
      }
      
    } else {
      
    }
    resource_ = resource;
    // @@protoc_insertion_point(field_set_allocated:flyteidl_flink.JobManager.resource)
  }
  
  // -------------------------------------------------------------------
  
  // TaskManager
  
  // .flyteidl_flink.Resource resource = 1;
  inline bool TaskManager::has_resource() const {
    return this != internal_default_instance() && resource_ != nullptr;
  }
  inline void TaskManager::clear_resource() {
    if (GetArenaNoVirtual() == nullptr && resource_ != nullptr) {
      delete resource_;
    }
    resource_ = nullptr;
  }
  inline const ::flyteidl_flink::Resource& TaskManager::resource() const {
    const ::flyteidl_flink::Resource* p = resource_;
    // @@protoc_insertion_point(field_get:flyteidl_flink.TaskManager.resource)
    return p != nullptr ? *p : *reinterpret_cast<const ::flyteidl_flink::Resource*>(
        &::flyteidl_flink::_Resource_default_instance_);
  }
  inline ::flyteidl_flink::Resource* TaskManager::release_resource() {
    // @@protoc_insertion_point(field_release:flyteidl_flink.TaskManager.resource)
    
    ::flyteidl_flink::Resource* temp = resource_;
    resource_ = nullptr;
    return temp;
  }
  inline ::flyteidl_flink::Resource* TaskManager::mutable_resource() {
    
    if (resource_ == nullptr) {
      auto* p = CreateMaybeMessage<::flyteidl_flink::Resource>(GetArenaNoVirtual());
      resource_ = p;
    }
    // @@protoc_insertion_point(field_mutable:flyteidl_flink.TaskManager.resource)
    return resource_;
  }
  inline void TaskManager::set_allocated_resource(::flyteidl_flink::Resource* resource) {
    ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
    if (message_arena == nullptr) {
      delete resource_;
    }
    if (resource) {
      ::google::protobuf::Arena* submessage_arena = nullptr;
      if (message_arena != submessage_arena) {
        resource = ::google::protobuf::internal::GetOwnedMessage(
            message_arena, resource, submessage_arena);
      }
      
    } else {
      
    }
    resource_ = resource;
    // @@protoc_insertion_point(field_set_allocated:flyteidl_flink.TaskManager.resource)
  }
  
  // int32 replicas = 2;
  inline void TaskManager::clear_replicas() {
    replicas_ = 0;
  }
  inline ::google::protobuf::int32 TaskManager::replicas() const {
    // @@protoc_insertion_point(field_get:flyteidl_flink.TaskManager.replicas)
    return replicas_;
  }
  inline void TaskManager::set_replicas(::google::protobuf::int32 value) {
    
    replicas_ = value;
    // @@protoc_insertion_point(field_set:flyteidl_flink.TaskManager.replicas)
  }
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // FlinkJob
  
  // string jarFile = 1;
  inline void FlinkJob::clear_jarfile() {
    jarfile_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  inline const ::std::string& FlinkJob::jarfile() const {
    // @@protoc_insertion_point(field_get:flyteidl_flink.FlinkJob.jarFile)
    return jarfile_.GetNoArena();
  }
  inline void FlinkJob::set_jarfile(const ::std::string& value) {
    
    jarfile_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set:flyteidl_flink.FlinkJob.jarFile)
  }
  #if LANG_CXX11
  inline void FlinkJob::set_jarfile(::std::string&& value) {
    
    jarfile_.SetNoArena(
      &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
    // @@protoc_insertion_point(field_set_rvalue:flyteidl_flink.FlinkJob.jarFile)
  }
  #endif
  inline void FlinkJob::set_jarfile(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    jarfile_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
    // @@protoc_insertion_point(field_set_char:flyteidl_flink.FlinkJob.jarFile)
  }
  inline void FlinkJob::set_jarfile(const char* value, size_t size) {
    
    jarfile_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        ::std::string(reinterpret_cast<const char*>(value), size));
    // @@protoc_insertion_point(field_set_pointer:flyteidl_flink.FlinkJob.jarFile)
  }
  inline ::std::string* FlinkJob::mutable_jarfile() {
    
    // @@protoc_insertion_point(field_mutable:flyteidl_flink.FlinkJob.jarFile)
    return jarfile_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  inline ::std::string* FlinkJob::release_jarfile() {
    // @@protoc_insertion_point(field_release:flyteidl_flink.FlinkJob.jarFile)
    
    return jarfile_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  inline void FlinkJob::set_allocated_jarfile(::std::string* jarfile) {
    if (jarfile != nullptr) {
      
    } else {
      
    }
    jarfile_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), jarfile);
    // @@protoc_insertion_point(field_set_allocated:flyteidl_flink.FlinkJob.jarFile)
  }
  
  // string mainClass = 2;
  inline void FlinkJob::clear_mainclass() {
    mainclass_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  inline const ::std::string& FlinkJob::mainclass() const {
    // @@protoc_insertion_point(field_get:flyteidl_flink.FlinkJob.mainClass)
    return mainclass_.GetNoArena();
  }
  inline void FlinkJob::set_mainclass(const ::std::string& value) {
    
    mainclass_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set:flyteidl_flink.FlinkJob.mainClass)
  }
  #if LANG_CXX11
  inline void FlinkJob::set_mainclass(::std::string&& value) {
    
    mainclass_.SetNoArena(
      &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
    // @@protoc_insertion_point(field_set_rvalue:flyteidl_flink.FlinkJob.mainClass)
  }
  #endif
  inline void FlinkJob::set_mainclass(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    mainclass_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
    // @@protoc_insertion_point(field_set_char:flyteidl_flink.FlinkJob.mainClass)
  }
  inline void FlinkJob::set_mainclass(const char* value, size_t size) {
    
    mainclass_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        ::std::string(reinterpret_cast<const char*>(value), size));
    // @@protoc_insertion_point(field_set_pointer:flyteidl_flink.FlinkJob.mainClass)
  }
  inline ::std::string* FlinkJob::mutable_mainclass() {
    
    // @@protoc_insertion_point(field_mutable:flyteidl_flink.FlinkJob.mainClass)
    return mainclass_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  inline ::std::string* FlinkJob::release_mainclass() {
    // @@protoc_insertion_point(field_release:flyteidl_flink.FlinkJob.mainClass)
    
    return mainclass_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  inline void FlinkJob::set_allocated_mainclass(::std::string* mainclass) {
    if (mainclass != nullptr) {
      
    } else {
      
    }
    mainclass_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), mainclass);
    // @@protoc_insertion_point(field_set_allocated:flyteidl_flink.FlinkJob.mainClass)
  }
  
  // repeated string args = 3;
  inline int FlinkJob::args_size() const {
    return args_.size();
  }
  inline void FlinkJob::clear_args() {
    args_.Clear();
  }
  inline const ::std::string& FlinkJob::args(int index) const {
    // @@protoc_insertion_point(field_get:flyteidl_flink.FlinkJob.args)
    return args_.Get(index);
  }
  inline ::std::string* FlinkJob::mutable_args(int index) {
    // @@protoc_insertion_point(field_mutable:flyteidl_flink.FlinkJob.args)
    return args_.Mutable(index);
  }
  inline void FlinkJob::set_args(int index, const ::std::string& value) {
    // @@protoc_insertion_point(field_set:flyteidl_flink.FlinkJob.args)
    args_.Mutable(index)->assign(value);
  }
  #if LANG_CXX11
  inline void FlinkJob::set_args(int index, ::std::string&& value) {
    // @@protoc_insertion_point(field_set:flyteidl_flink.FlinkJob.args)
    args_.Mutable(index)->assign(std::move(value));
  }
  #endif
  inline void FlinkJob::set_args(int index, const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    args_.Mutable(index)->assign(value);
    // @@protoc_insertion_point(field_set_char:flyteidl_flink.FlinkJob.args)
  }
  inline void FlinkJob::set_args(int index, const char* value, size_t size) {
    args_.Mutable(index)->assign(
      reinterpret_cast<const char*>(value), size);
    // @@protoc_insertion_point(field_set_pointer:flyteidl_flink.FlinkJob.args)
  }
  inline ::std::string* FlinkJob::add_args() {
    // @@protoc_insertion_point(field_add_mutable:flyteidl_flink.FlinkJob.args)
    return args_.Add();
  }
  inline void FlinkJob::add_args(const ::std::string& value) {
    args_.Add()->assign(value);
    // @@protoc_insertion_point(field_add:flyteidl_flink.FlinkJob.args)
  }
  #if LANG_CXX11
  inline void FlinkJob::add_args(::std::string&& value) {
    args_.Add(std::move(value));
    // @@protoc_insertion_point(field_add:flyteidl_flink.FlinkJob.args)
  }
  #endif
  inline void FlinkJob::add_args(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    args_.Add()->assign(value);
    // @@protoc_insertion_point(field_add_char:flyteidl_flink.FlinkJob.args)
  }
  inline void FlinkJob::add_args(const char* value, size_t size) {
    args_.Add()->assign(reinterpret_cast<const char*>(value), size);
    // @@protoc_insertion_point(field_add_pointer:flyteidl_flink.FlinkJob.args)
  }
  inline const ::google::protobuf::RepeatedPtrField<::std::string>&
  FlinkJob::args() const {
    // @@protoc_insertion_point(field_list:flyteidl_flink.FlinkJob.args)
    return args_;
  }
  inline ::google::protobuf::RepeatedPtrField<::std::string>*
  FlinkJob::mutable_args() {
    // @@protoc_insertion_point(field_mutable_list:flyteidl_flink.FlinkJob.args)
    return &args_;
  }
  
  // map<string, string> flinkProperties = 4;
  inline int FlinkJob::flinkproperties_size() const {
    return flinkproperties_.size();
  }
  inline void FlinkJob::clear_flinkproperties() {
    flinkproperties_.Clear();
  }
  inline const ::google::protobuf::Map< ::std::string, ::std::string >&
  FlinkJob::flinkproperties() const {
    // @@protoc_insertion_point(field_map:flyteidl_flink.FlinkJob.flinkProperties)
    return flinkproperties_.GetMap();
  }
  inline ::google::protobuf::Map< ::std::string, ::std::string >*
  FlinkJob::mutable_flinkproperties() {
    // @@protoc_insertion_point(field_mutable_map:flyteidl_flink.FlinkJob.flinkProperties)
    return flinkproperties_.MutableMap();
  }
  
  // .flyteidl_flink.JobManager jobManager = 5;
  inline bool FlinkJob::has_jobmanager() const {
    return this != internal_default_instance() && jobmanager_ != nullptr;
  }
  inline void FlinkJob::clear_jobmanager() {
    if (GetArenaNoVirtual() == nullptr && jobmanager_ != nullptr) {
      delete jobmanager_;
    }
    jobmanager_ = nullptr;
  }
  inline const ::flyteidl_flink::JobManager& FlinkJob::jobmanager() const {
    const ::flyteidl_flink::JobManager* p = jobmanager_;
    // @@protoc_insertion_point(field_get:flyteidl_flink.FlinkJob.jobManager)
    return p != nullptr ? *p : *reinterpret_cast<const ::flyteidl_flink::JobManager*>(
        &::flyteidl_flink::_JobManager_default_instance_);
  }
  inline ::flyteidl_flink::JobManager* FlinkJob::release_jobmanager() {
    // @@protoc_insertion_point(field_release:flyteidl_flink.FlinkJob.jobManager)
    
    ::flyteidl_flink::JobManager* temp = jobmanager_;
    jobmanager_ = nullptr;
    return temp;
  }
  inline ::flyteidl_flink::JobManager* FlinkJob::mutable_jobmanager() {
    
    if (jobmanager_ == nullptr) {
      auto* p = CreateMaybeMessage<::flyteidl_flink::JobManager>(GetArenaNoVirtual());
      jobmanager_ = p;
    }
    // @@protoc_insertion_point(field_mutable:flyteidl_flink.FlinkJob.jobManager)
    return jobmanager_;
  }
  inline void FlinkJob::set_allocated_jobmanager(::flyteidl_flink::JobManager* jobmanager) {
    ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
    if (message_arena == nullptr) {
      delete jobmanager_;
    }
    if (jobmanager) {
      ::google::protobuf::Arena* submessage_arena = nullptr;
      if (message_arena != submessage_arena) {
        jobmanager = ::google::protobuf::internal::GetOwnedMessage(
            message_arena, jobmanager, submessage_arena);
      }
      
    } else {
      
    }
    jobmanager_ = jobmanager;
    // @@protoc_insertion_point(field_set_allocated:flyteidl_flink.FlinkJob.jobManager)
  }
  
  // .flyteidl_flink.TaskManager taskManager = 6;
  inline bool FlinkJob::has_taskmanager() const {
    return this != internal_default_instance() && taskmanager_ != nullptr;
  }
  inline void FlinkJob::clear_taskmanager() {
    if (GetArenaNoVirtual() == nullptr && taskmanager_ != nullptr) {
      delete taskmanager_;
    }
    taskmanager_ = nullptr;
  }
  inline const ::flyteidl_flink::TaskManager& FlinkJob::taskmanager() const {
    const ::flyteidl_flink::TaskManager* p = taskmanager_;
    // @@protoc_insertion_point(field_get:flyteidl_flink.FlinkJob.taskManager)
    return p != nullptr ? *p : *reinterpret_cast<const ::flyteidl_flink::TaskManager*>(
        &::flyteidl_flink::_TaskManager_default_instance_);
  }
  inline ::flyteidl_flink::TaskManager* FlinkJob::release_taskmanager() {
    // @@protoc_insertion_point(field_release:flyteidl_flink.FlinkJob.taskManager)
    
    ::flyteidl_flink::TaskManager* temp = taskmanager_;
    taskmanager_ = nullptr;
    return temp;
  }
  inline ::flyteidl_flink::TaskManager* FlinkJob::mutable_taskmanager() {
    
    if (taskmanager_ == nullptr) {
      auto* p = CreateMaybeMessage<::flyteidl_flink::TaskManager>(GetArenaNoVirtual());
      taskmanager_ = p;
    }
    // @@protoc_insertion_point(field_mutable:flyteidl_flink.FlinkJob.taskManager)
    return taskmanager_;
  }
  inline void FlinkJob::set_allocated_taskmanager(::flyteidl_flink::TaskManager* taskmanager) {
    ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
    if (message_arena == nullptr) {
      delete taskmanager_;
    }
    if (taskmanager) {
      ::google::protobuf::Arena* submessage_arena = nullptr;
      if (message_arena != submessage_arena) {
        taskmanager = ::google::protobuf::internal::GetOwnedMessage(
            message_arena, taskmanager, submessage_arena);
      }
      
    } else {
      
    }
    taskmanager_ = taskmanager;
    // @@protoc_insertion_point(field_set_allocated:flyteidl_flink.FlinkJob.taskManager)
  }
  
  // string serviceAccount = 7;
  inline void FlinkJob::clear_serviceaccount() {
    serviceaccount_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  inline const ::std::string& FlinkJob::serviceaccount() const {
    // @@protoc_insertion_point(field_get:flyteidl_flink.FlinkJob.serviceAccount)
    return serviceaccount_.GetNoArena();
  }
  inline void FlinkJob::set_serviceaccount(const ::std::string& value) {
    
    serviceaccount_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set:flyteidl_flink.FlinkJob.serviceAccount)
  }
  #if LANG_CXX11
  inline void FlinkJob::set_serviceaccount(::std::string&& value) {
    
    serviceaccount_.SetNoArena(
      &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
    // @@protoc_insertion_point(field_set_rvalue:flyteidl_flink.FlinkJob.serviceAccount)
  }
  #endif
  inline void FlinkJob::set_serviceaccount(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    serviceaccount_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
    // @@protoc_insertion_point(field_set_char:flyteidl_flink.FlinkJob.serviceAccount)
  }
  inline void FlinkJob::set_serviceaccount(const char* value, size_t size) {
    
    serviceaccount_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        ::std::string(reinterpret_cast<const char*>(value), size));
    // @@protoc_insertion_point(field_set_pointer:flyteidl_flink.FlinkJob.serviceAccount)
  }
  inline ::std::string* FlinkJob::mutable_serviceaccount() {
    
    // @@protoc_insertion_point(field_mutable:flyteidl_flink.FlinkJob.serviceAccount)
    return serviceaccount_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  inline ::std::string* FlinkJob::release_serviceaccount() {
    // @@protoc_insertion_point(field_release:flyteidl_flink.FlinkJob.serviceAccount)
    
    return serviceaccount_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  inline void FlinkJob::set_allocated_serviceaccount(::std::string* serviceaccount) {
    if (serviceaccount != nullptr) {
      
    } else {
      
    }
    serviceaccount_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), serviceaccount);
    // @@protoc_insertion_point(field_set_allocated:flyteidl_flink.FlinkJob.serviceAccount)
  }
  
  // string image = 8;
  inline void FlinkJob::clear_image() {
    image_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  inline const ::std::string& FlinkJob::image() const {
    // @@protoc_insertion_point(field_get:flyteidl_flink.FlinkJob.image)
    return image_.GetNoArena();
  }
  inline void FlinkJob::set_image(const ::std::string& value) {
    
    image_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set:flyteidl_flink.FlinkJob.image)
  }
  #if LANG_CXX11
  inline void FlinkJob::set_image(::std::string&& value) {
    
    image_.SetNoArena(
      &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
    // @@protoc_insertion_point(field_set_rvalue:flyteidl_flink.FlinkJob.image)
  }
  #endif
  inline void FlinkJob::set_image(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    image_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
    // @@protoc_insertion_point(field_set_char:flyteidl_flink.FlinkJob.image)
  }
  inline void FlinkJob::set_image(const char* value, size_t size) {
    
    image_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        ::std::string(reinterpret_cast<const char*>(value), size));
    // @@protoc_insertion_point(field_set_pointer:flyteidl_flink.FlinkJob.image)
  }
  inline ::std::string* FlinkJob::mutable_image() {
    
    // @@protoc_insertion_point(field_mutable:flyteidl_flink.FlinkJob.image)
    return image_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  inline ::std::string* FlinkJob::release_image() {
    // @@protoc_insertion_point(field_release:flyteidl_flink.FlinkJob.image)
    
    return image_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  inline void FlinkJob::set_allocated_image(::std::string* image) {
    if (image != nullptr) {
      
    } else {
      
    }
    image_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), image);
    // @@protoc_insertion_point(field_set_allocated:flyteidl_flink.FlinkJob.image)
  }
  
  // -------------------------------------------------------------------
  
  // JobExecutionInfo
  
  // string id = 1;
  inline void JobExecutionInfo::clear_id() {
    id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  inline const ::std::string& JobExecutionInfo::id() const {
    // @@protoc_insertion_point(field_get:flyteidl_flink.JobExecutionInfo.id)
    return id_.GetNoArena();
  }
  inline void JobExecutionInfo::set_id(const ::std::string& value) {
    
    id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set:flyteidl_flink.JobExecutionInfo.id)
  }
  #if LANG_CXX11
  inline void JobExecutionInfo::set_id(::std::string&& value) {
    
    id_.SetNoArena(
      &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
    // @@protoc_insertion_point(field_set_rvalue:flyteidl_flink.JobExecutionInfo.id)
  }
  #endif
  inline void JobExecutionInfo::set_id(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
    // @@protoc_insertion_point(field_set_char:flyteidl_flink.JobExecutionInfo.id)
  }
  inline void JobExecutionInfo::set_id(const char* value, size_t size) {
    
    id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        ::std::string(reinterpret_cast<const char*>(value), size));
    // @@protoc_insertion_point(field_set_pointer:flyteidl_flink.JobExecutionInfo.id)
  }
  inline ::std::string* JobExecutionInfo::mutable_id() {
    
    // @@protoc_insertion_point(field_mutable:flyteidl_flink.JobExecutionInfo.id)
    return id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  inline ::std::string* JobExecutionInfo::release_id() {
    // @@protoc_insertion_point(field_release:flyteidl_flink.JobExecutionInfo.id)
    
    return id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  inline void JobExecutionInfo::set_allocated_id(::std::string* id) {
    if (id != nullptr) {
      
    } else {
      
    }
    id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), id);
    // @@protoc_insertion_point(field_set_allocated:flyteidl_flink.JobExecutionInfo.id)
  }
  
  // -------------------------------------------------------------------
  
  // JobManagerExecutionInfo
  
  // repeated string ingressURLs = 1;
  inline int JobManagerExecutionInfo::ingressurls_size() const {
    return ingressurls_.size();
  }
  inline void JobManagerExecutionInfo::clear_ingressurls() {
    ingressurls_.Clear();
  }
  inline const ::std::string& JobManagerExecutionInfo::ingressurls(int index) const {
    // @@protoc_insertion_point(field_get:flyteidl_flink.JobManagerExecutionInfo.ingressURLs)
    return ingressurls_.Get(index);
  }
  inline ::std::string* JobManagerExecutionInfo::mutable_ingressurls(int index) {
    // @@protoc_insertion_point(field_mutable:flyteidl_flink.JobManagerExecutionInfo.ingressURLs)
    return ingressurls_.Mutable(index);
  }
  inline void JobManagerExecutionInfo::set_ingressurls(int index, const ::std::string& value) {
    // @@protoc_insertion_point(field_set:flyteidl_flink.JobManagerExecutionInfo.ingressURLs)
    ingressurls_.Mutable(index)->assign(value);
  }
  #if LANG_CXX11
  inline void JobManagerExecutionInfo::set_ingressurls(int index, ::std::string&& value) {
    // @@protoc_insertion_point(field_set:flyteidl_flink.JobManagerExecutionInfo.ingressURLs)
    ingressurls_.Mutable(index)->assign(std::move(value));
  }
  #endif
  inline void JobManagerExecutionInfo::set_ingressurls(int index, const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    ingressurls_.Mutable(index)->assign(value);
    // @@protoc_insertion_point(field_set_char:flyteidl_flink.JobManagerExecutionInfo.ingressURLs)
  }
  inline void JobManagerExecutionInfo::set_ingressurls(int index, const char* value, size_t size) {
    ingressurls_.Mutable(index)->assign(
      reinterpret_cast<const char*>(value), size);
    // @@protoc_insertion_point(field_set_pointer:flyteidl_flink.JobManagerExecutionInfo.ingressURLs)
  }
  inline ::std::string* JobManagerExecutionInfo::add_ingressurls() {
    // @@protoc_insertion_point(field_add_mutable:flyteidl_flink.JobManagerExecutionInfo.ingressURLs)
    return ingressurls_.Add();
  }
  inline void JobManagerExecutionInfo::add_ingressurls(const ::std::string& value) {
    ingressurls_.Add()->assign(value);
    // @@protoc_insertion_point(field_add:flyteidl_flink.JobManagerExecutionInfo.ingressURLs)
  }
  #if LANG_CXX11
  inline void JobManagerExecutionInfo::add_ingressurls(::std::string&& value) {
    ingressurls_.Add(std::move(value));
    // @@protoc_insertion_point(field_add:flyteidl_flink.JobManagerExecutionInfo.ingressURLs)
  }
  #endif
  inline void JobManagerExecutionInfo::add_ingressurls(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    ingressurls_.Add()->assign(value);
    // @@protoc_insertion_point(field_add_char:flyteidl_flink.JobManagerExecutionInfo.ingressURLs)
  }
  inline void JobManagerExecutionInfo::add_ingressurls(const char* value, size_t size) {
    ingressurls_.Add()->assign(reinterpret_cast<const char*>(value), size);
    // @@protoc_insertion_point(field_add_pointer:flyteidl_flink.JobManagerExecutionInfo.ingressURLs)
  }
  inline const ::google::protobuf::RepeatedPtrField<::std::string>&
  JobManagerExecutionInfo::ingressurls() const {
    // @@protoc_insertion_point(field_list:flyteidl_flink.JobManagerExecutionInfo.ingressURLs)
    return ingressurls_;
  }
  inline ::google::protobuf::RepeatedPtrField<::std::string>*
  JobManagerExecutionInfo::mutable_ingressurls() {
    // @@protoc_insertion_point(field_mutable_list:flyteidl_flink.JobManagerExecutionInfo.ingressURLs)
    return &ingressurls_;
  }
  
  // -------------------------------------------------------------------
  
  // FlinkExecutionInfo
  
  // .flyteidl_flink.JobExecutionInfo job = 1;
  inline bool FlinkExecutionInfo::has_job() const {
    return this != internal_default_instance() && job_ != nullptr;
  }
  inline void FlinkExecutionInfo::clear_job() {
    if (GetArenaNoVirtual() == nullptr && job_ != nullptr) {
      delete job_;
    }
    job_ = nullptr;
  }
  inline const ::flyteidl_flink::JobExecutionInfo& FlinkExecutionInfo::job() const {
    const ::flyteidl_flink::JobExecutionInfo* p = job_;
    // @@protoc_insertion_point(field_get:flyteidl_flink.FlinkExecutionInfo.job)
    return p != nullptr ? *p : *reinterpret_cast<const ::flyteidl_flink::JobExecutionInfo*>(
        &::flyteidl_flink::_JobExecutionInfo_default_instance_);
  }
  inline ::flyteidl_flink::JobExecutionInfo* FlinkExecutionInfo::release_job() {
    // @@protoc_insertion_point(field_release:flyteidl_flink.FlinkExecutionInfo.job)
    
    ::flyteidl_flink::JobExecutionInfo* temp = job_;
    job_ = nullptr;
    return temp;
  }
  inline ::flyteidl_flink::JobExecutionInfo* FlinkExecutionInfo::mutable_job() {
    
    if (job_ == nullptr) {
      auto* p = CreateMaybeMessage<::flyteidl_flink::JobExecutionInfo>(GetArenaNoVirtual());
      job_ = p;
    }
    // @@protoc_insertion_point(field_mutable:flyteidl_flink.FlinkExecutionInfo.job)
    return job_;
  }
  inline void FlinkExecutionInfo::set_allocated_job(::flyteidl_flink::JobExecutionInfo* job) {
    ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
    if (message_arena == nullptr) {
      delete job_;
    }
    if (job) {
      ::google::protobuf::Arena* submessage_arena = nullptr;
      if (message_arena != submessage_arena) {
        job = ::google::protobuf::internal::GetOwnedMessage(
            message_arena, job, submessage_arena);
      }
      
    } else {
      
    }
    job_ = job;
    // @@protoc_insertion_point(field_set_allocated:flyteidl_flink.FlinkExecutionInfo.job)
  }
  
  // .flyteidl_flink.JobManagerExecutionInfo jobManager = 2;
  inline bool FlinkExecutionInfo::has_jobmanager() const {
    return this != internal_default_instance() && jobmanager_ != nullptr;
  }
  inline void FlinkExecutionInfo::clear_jobmanager() {
    if (GetArenaNoVirtual() == nullptr && jobmanager_ != nullptr) {
      delete jobmanager_;
    }
    jobmanager_ = nullptr;
  }
  inline const ::flyteidl_flink::JobManagerExecutionInfo& FlinkExecutionInfo::jobmanager() const {
    const ::flyteidl_flink::JobManagerExecutionInfo* p = jobmanager_;
    // @@protoc_insertion_point(field_get:flyteidl_flink.FlinkExecutionInfo.jobManager)
    return p != nullptr ? *p : *reinterpret_cast<const ::flyteidl_flink::JobManagerExecutionInfo*>(
        &::flyteidl_flink::_JobManagerExecutionInfo_default_instance_);
  }
  inline ::flyteidl_flink::JobManagerExecutionInfo* FlinkExecutionInfo::release_jobmanager() {
    // @@protoc_insertion_point(field_release:flyteidl_flink.FlinkExecutionInfo.jobManager)
    
    ::flyteidl_flink::JobManagerExecutionInfo* temp = jobmanager_;
    jobmanager_ = nullptr;
    return temp;
  }
  inline ::flyteidl_flink::JobManagerExecutionInfo* FlinkExecutionInfo::mutable_jobmanager() {
    
    if (jobmanager_ == nullptr) {
      auto* p = CreateMaybeMessage<::flyteidl_flink::JobManagerExecutionInfo>(GetArenaNoVirtual());
      jobmanager_ = p;
    }
    // @@protoc_insertion_point(field_mutable:flyteidl_flink.FlinkExecutionInfo.jobManager)
    return jobmanager_;
  }
  inline void FlinkExecutionInfo::set_allocated_jobmanager(::flyteidl_flink::JobManagerExecutionInfo* jobmanager) {
    ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
    if (message_arena == nullptr) {
      delete jobmanager_;
    }
    if (jobmanager) {
      ::google::protobuf::Arena* submessage_arena = nullptr;
      if (message_arena != submessage_arena) {
        jobmanager = ::google::protobuf::internal::GetOwnedMessage(
            message_arena, jobmanager, submessage_arena);
      }
      
    } else {
      
    }
    jobmanager_ = jobmanager;
    // @@protoc_insertion_point(field_set_allocated:flyteidl_flink.FlinkExecutionInfo.jobManager)
  }
  
  #ifdef __GNUC__
    #pragma GCC diagnostic pop
  #endif  // __GNUC__
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  
  // @@protoc_insertion_point(namespace_scope)
  
  }  // namespace flyteidl_flink
  
  namespace google {
  namespace protobuf {
  
  template <> struct is_proto_enum< ::flyteidl_flink::Resource_PersistentVolume_Type> : ::std::true_type {};
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::flyteidl_flink::Resource_PersistentVolume_Type>() {
    return ::flyteidl_flink::Resource_PersistentVolume_Type_descriptor();
  }
  
  }  // namespace protobuf
  }  // namespace google
  
  // @@protoc_insertion_point(global_scope)
  
  #include <google/protobuf/port_undef.inc>
  #endif  // PROTOBUF_INCLUDED_flyteidl_2dflink_2fflink_2eproto
  