// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: messages/VehicleRemoteHvac.proto

#include "messages/VehicleRemoteHvac.pb.h"

#include <algorithm>
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/extension_set.h"
#include "google/protobuf/wire_format_lite.h"
#include "google/protobuf/descriptor.h"
#include "google/protobuf/generated_message_reflection.h"
#include "google/protobuf/reflection_ops.h"
#include "google/protobuf/wire_format.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"
PROTOBUF_PRAGMA_INIT_SEG
namespace _pb = ::PROTOBUF_NAMESPACE_ID;
namespace _pbi = ::PROTOBUF_NAMESPACE_ID::internal;
PROTOBUF_CONSTEXPR CabinConditionStatusPublish::CabinConditionStatusPublish(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.event_time_)*/nullptr
  , /*decltype(_impl_.hvac_state_)*/nullptr
  , /*decltype(_impl_.cabin_temperature_)*/nullptr
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct CabinConditionStatusPublishDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CabinConditionStatusPublishDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~CabinConditionStatusPublishDefaultTypeInternal() {}
  union {
    CabinConditionStatusPublish _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CabinConditionStatusPublishDefaultTypeInternal _CabinConditionStatusPublish_default_instance_;
PROTOBUF_CONSTEXPR PreconditionRequest::PreconditionRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.hvac_zones_)*/{}
  , /*decltype(_impl_.start_time_)*/nullptr
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct PreconditionRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PreconditionRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PreconditionRequestDefaultTypeInternal() {}
  union {
    PreconditionRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PreconditionRequestDefaultTypeInternal _PreconditionRequest_default_instance_;
PROTOBUF_CONSTEXPR PreconditionResponse::PreconditionResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.message_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.status_)*/ 0

  , /*decltype(_impl_._cached_size_)*/{}} {}
struct PreconditionResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PreconditionResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PreconditionResponseDefaultTypeInternal() {}
  union {
    PreconditionResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PreconditionResponseDefaultTypeInternal _PreconditionResponse_default_instance_;
PROTOBUF_CONSTEXPR CabinTemperature::CabinTemperature(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.temperature_)*/nullptr
  , /*decltype(_impl_.zone_)*/nullptr
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct CabinTemperatureDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CabinTemperatureDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~CabinTemperatureDefaultTypeInternal() {}
  union {
    CabinTemperature _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CabinTemperatureDefaultTypeInternal _CabinTemperature_default_instance_;
PROTOBUF_CONSTEXPR Temperature::Temperature(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.unit_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.value_)*/ 0

  , /*decltype(_impl_._cached_size_)*/{}} {}
struct TemperatureDefaultTypeInternal {
  PROTOBUF_CONSTEXPR TemperatureDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~TemperatureDefaultTypeInternal() {}
  union {
    Temperature _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemperatureDefaultTypeInternal _Temperature_default_instance_;
PROTOBUF_CONSTEXPR HVACZone::HVACZone(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.target_temperature_)*/nullptr
  , /*decltype(_impl_.zone_)*/ 0

  , /*decltype(_impl_._cached_size_)*/{}} {}
struct HVACZoneDefaultTypeInternal {
  PROTOBUF_CONSTEXPR HVACZoneDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~HVACZoneDefaultTypeInternal() {}
  union {
    HVACZone _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HVACZoneDefaultTypeInternal _HVACZone_default_instance_;
PROTOBUF_CONSTEXPR HVACState::HVACState(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.current_zone_)*/nullptr
  , /*decltype(_impl_.state_)*/ 0

  , /*decltype(_impl_._cached_size_)*/{}} {}
struct HVACStateDefaultTypeInternal {
  PROTOBUF_CONSTEXPR HVACStateDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~HVACStateDefaultTypeInternal() {}
  union {
    HVACState _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HVACStateDefaultTypeInternal _HVACState_default_instance_;
static ::_pb::Metadata file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[7];
static const ::_pb::EnumDescriptor* file_level_enum_descriptors_messages_2fVehicleRemoteHvac_2eproto[3];
static constexpr const ::_pb::ServiceDescriptor**
    file_level_service_descriptors_messages_2fVehicleRemoteHvac_2eproto = nullptr;
const ::uint32_t TableStruct_messages_2fVehicleRemoteHvac_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(
    protodesc_cold) = {
    ~0u,  // no _has_bits_
    PROTOBUF_FIELD_OFFSET(::CabinConditionStatusPublish, _internal_metadata_),
    ~0u,  // no _extensions_
    ~0u,  // no _oneof_case_
    ~0u,  // no _weak_field_map_
    ~0u,  // no _inlined_string_donated_
    ~0u,  // no _split_
    ~0u,  // no sizeof(Split)
    PROTOBUF_FIELD_OFFSET(::CabinConditionStatusPublish, _impl_.event_time_),
    PROTOBUF_FIELD_OFFSET(::CabinConditionStatusPublish, _impl_.hvac_state_),
    PROTOBUF_FIELD_OFFSET(::CabinConditionStatusPublish, _impl_.cabin_temperature_),
    ~0u,  // no _has_bits_
    PROTOBUF_FIELD_OFFSET(::PreconditionRequest, _internal_metadata_),
    ~0u,  // no _extensions_
    ~0u,  // no _oneof_case_
    ~0u,  // no _weak_field_map_
    ~0u,  // no _inlined_string_donated_
    ~0u,  // no _split_
    ~0u,  // no sizeof(Split)
    PROTOBUF_FIELD_OFFSET(::PreconditionRequest, _impl_.hvac_zones_),
    PROTOBUF_FIELD_OFFSET(::PreconditionRequest, _impl_.start_time_),
    ~0u,  // no _has_bits_
    PROTOBUF_FIELD_OFFSET(::PreconditionResponse, _internal_metadata_),
    ~0u,  // no _extensions_
    ~0u,  // no _oneof_case_
    ~0u,  // no _weak_field_map_
    ~0u,  // no _inlined_string_donated_
    ~0u,  // no _split_
    ~0u,  // no sizeof(Split)
    PROTOBUF_FIELD_OFFSET(::PreconditionResponse, _impl_.status_),
    PROTOBUF_FIELD_OFFSET(::PreconditionResponse, _impl_.message_),
    ~0u,  // no _has_bits_
    PROTOBUF_FIELD_OFFSET(::CabinTemperature, _internal_metadata_),
    ~0u,  // no _extensions_
    ~0u,  // no _oneof_case_
    ~0u,  // no _weak_field_map_
    ~0u,  // no _inlined_string_donated_
    ~0u,  // no _split_
    ~0u,  // no sizeof(Split)
    PROTOBUF_FIELD_OFFSET(::CabinTemperature, _impl_.temperature_),
    PROTOBUF_FIELD_OFFSET(::CabinTemperature, _impl_.zone_),
    ~0u,  // no _has_bits_
    PROTOBUF_FIELD_OFFSET(::Temperature, _internal_metadata_),
    ~0u,  // no _extensions_
    ~0u,  // no _oneof_case_
    ~0u,  // no _weak_field_map_
    ~0u,  // no _inlined_string_donated_
    ~0u,  // no _split_
    ~0u,  // no sizeof(Split)
    PROTOBUF_FIELD_OFFSET(::Temperature, _impl_.value_),
    PROTOBUF_FIELD_OFFSET(::Temperature, _impl_.unit_),
    ~0u,  // no _has_bits_
    PROTOBUF_FIELD_OFFSET(::HVACZone, _internal_metadata_),
    ~0u,  // no _extensions_
    ~0u,  // no _oneof_case_
    ~0u,  // no _weak_field_map_
    ~0u,  // no _inlined_string_donated_
    ~0u,  // no _split_
    ~0u,  // no sizeof(Split)
    PROTOBUF_FIELD_OFFSET(::HVACZone, _impl_.zone_),
    PROTOBUF_FIELD_OFFSET(::HVACZone, _impl_.target_temperature_),
    ~0u,  // no _has_bits_
    PROTOBUF_FIELD_OFFSET(::HVACState, _internal_metadata_),
    ~0u,  // no _extensions_
    ~0u,  // no _oneof_case_
    ~0u,  // no _weak_field_map_
    ~0u,  // no _inlined_string_donated_
    ~0u,  // no _split_
    ~0u,  // no sizeof(Split)
    PROTOBUF_FIELD_OFFSET(::HVACState, _impl_.state_),
    PROTOBUF_FIELD_OFFSET(::HVACState, _impl_.current_zone_),
};

static const ::_pbi::MigrationSchema
    schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
        { 0, -1, -1, sizeof(::CabinConditionStatusPublish)},
        { 11, -1, -1, sizeof(::PreconditionRequest)},
        { 21, -1, -1, sizeof(::PreconditionResponse)},
        { 31, -1, -1, sizeof(::CabinTemperature)},
        { 41, -1, -1, sizeof(::Temperature)},
        { 51, -1, -1, sizeof(::HVACZone)},
        { 61, -1, -1, sizeof(::HVACState)},
};

static const ::_pb::Message* const file_default_instances[] = {
    &::_CabinConditionStatusPublish_default_instance_._instance,
    &::_PreconditionRequest_default_instance_._instance,
    &::_PreconditionResponse_default_instance_._instance,
    &::_CabinTemperature_default_instance_._instance,
    &::_Temperature_default_instance_._instance,
    &::_HVACZone_default_instance_._instance,
    &::_HVACState_default_instance_._instance,
};
const char descriptor_table_protodef_messages_2fVehicleRemoteHvac_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
    "\n messages/VehicleRemoteHvac.proto\032\037goog"
    "le/protobuf/timestamp.proto\"\233\001\n\033CabinCon"
    "ditionStatusPublish\022.\n\nevent_time\030\001 \001(\0132"
    "\032.google.protobuf.Timestamp\022\036\n\nhvac_stat"
    "e\030\002 \001(\0132\n.HVACState\022,\n\021cabin_temperature"
    "\030\003 \001(\0132\021.CabinTemperature\"d\n\023Preconditio"
    "nRequest\022\035\n\nhvac_zones\030\001 \003(\0132\t.HVACZone\022"
    ".\n\nstart_time\030\002 \001(\0132\032.google.protobuf.Ti"
    "mestamp\"\206\001\n\024PreconditionResponse\022,\n\006stat"
    "us\030\001 \001(\0162\034.PreconditionResponse.Status\022\017"
    "\n\007message\030\002 \001(\t\"/\n\006Status\022\013\n\007SUCCESS\020\000\022\013"
    "\n\007FAILURE\020\001\022\013\n\007PENDING\020\002\"N\n\020CabinTempera"
    "ture\022!\n\013temperature\030\001 \001(\0132\014.Temperature\022"
    "\027\n\004zone\030\002 \001(\0132\t.HVACZone\"*\n\013Temperature\022"
    "\r\n\005value\030\001 \001(\002\022\014\n\004unit\030\002 \001(\t\"\224\001\n\010HVACZon"
    "e\022\034\n\004zone\030\001 \001(\0162\016.HVACZone.Zone\022(\n\022targe"
    "t_temperature\030\002 \001(\0132\014.Temperature\"@\n\004Zon"
    "e\022\n\n\006DRIVER\020\000\022\r\n\tPASSENGER\020\001\022\r\n\tREAR_LEF"
    "T\020\002\022\016\n\nREAR_RIGHT\020\003\"\203\001\n\tHVACState\022\037\n\005sta"
    "te\030\001 \001(\0162\020.HVACState.State\022\037\n\014current_zo"
    "ne\030\002 \001(\0132\t.HVACZone\"4\n\005State\022\007\n\003OFF\020\000\022\013\n"
    "\007HEATING\020\001\022\013\n\007COOLING\020\002\022\010\n\004IDLE\020\003b\006proto"
    "3"
};
static const ::_pbi::DescriptorTable* const descriptor_table_messages_2fVehicleRemoteHvac_2eproto_deps[1] =
    {
        &::descriptor_table_google_2fprotobuf_2ftimestamp_2eproto,
};
static ::absl::once_flag descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once;
const ::_pbi::DescriptorTable descriptor_table_messages_2fVehicleRemoteHvac_2eproto = {
    false,
    false,
    881,
    descriptor_table_protodef_messages_2fVehicleRemoteHvac_2eproto,
    "messages/VehicleRemoteHvac.proto",
    &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once,
    descriptor_table_messages_2fVehicleRemoteHvac_2eproto_deps,
    1,
    7,
    schemas,
    file_default_instances,
    TableStruct_messages_2fVehicleRemoteHvac_2eproto::offsets,
    file_level_metadata_messages_2fVehicleRemoteHvac_2eproto,
    file_level_enum_descriptors_messages_2fVehicleRemoteHvac_2eproto,
    file_level_service_descriptors_messages_2fVehicleRemoteHvac_2eproto,
};

// This function exists to be marked as weak.
// It can significantly speed up compilation by breaking up LLVM's SCC
// in the .pb.cc translation units. Large translation units see a
// reduction of more than 35% of walltime for optimized builds. Without
// the weak attribute all the messages in the file, including all the
// vtables and everything they use become part of the same SCC through
// a cycle like:
// GetMetadata -> descriptor table -> default instances ->
//   vtables -> GetMetadata
// By adding a weak function here we break the connection from the
// individual vtables back into the descriptor table.
PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_messages_2fVehicleRemoteHvac_2eproto_getter() {
  return &descriptor_table_messages_2fVehicleRemoteHvac_2eproto;
}
// Force running AddDescriptors() at dynamic initialization time.
PROTOBUF_ATTRIBUTE_INIT_PRIORITY2
static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_messages_2fVehicleRemoteHvac_2eproto(&descriptor_table_messages_2fVehicleRemoteHvac_2eproto);
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PreconditionResponse_Status_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_messages_2fVehicleRemoteHvac_2eproto);
  return file_level_enum_descriptors_messages_2fVehicleRemoteHvac_2eproto[0];
}
bool PreconditionResponse_Status_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr PreconditionResponse_Status PreconditionResponse::SUCCESS;
constexpr PreconditionResponse_Status PreconditionResponse::FAILURE;
constexpr PreconditionResponse_Status PreconditionResponse::PENDING;
constexpr PreconditionResponse_Status PreconditionResponse::Status_MIN;
constexpr PreconditionResponse_Status PreconditionResponse::Status_MAX;
constexpr int PreconditionResponse::Status_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HVACZone_Zone_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_messages_2fVehicleRemoteHvac_2eproto);
  return file_level_enum_descriptors_messages_2fVehicleRemoteHvac_2eproto[1];
}
bool HVACZone_Zone_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr HVACZone_Zone HVACZone::DRIVER;
constexpr HVACZone_Zone HVACZone::PASSENGER;
constexpr HVACZone_Zone HVACZone::REAR_LEFT;
constexpr HVACZone_Zone HVACZone::REAR_RIGHT;
constexpr HVACZone_Zone HVACZone::Zone_MIN;
constexpr HVACZone_Zone HVACZone::Zone_MAX;
constexpr int HVACZone::Zone_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HVACState_State_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_messages_2fVehicleRemoteHvac_2eproto);
  return file_level_enum_descriptors_messages_2fVehicleRemoteHvac_2eproto[2];
}
bool HVACState_State_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr HVACState_State HVACState::OFF;
constexpr HVACState_State HVACState::HEATING;
constexpr HVACState_State HVACState::COOLING;
constexpr HVACState_State HVACState::IDLE;
constexpr HVACState_State HVACState::State_MIN;
constexpr HVACState_State HVACState::State_MAX;
constexpr int HVACState::State_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
// ===================================================================

class CabinConditionStatusPublish::_Internal {
 public:
  static const ::PROTOBUF_NAMESPACE_ID::Timestamp& event_time(const CabinConditionStatusPublish* msg);
  static const ::HVACState& hvac_state(const CabinConditionStatusPublish* msg);
  static const ::CabinTemperature& cabin_temperature(const CabinConditionStatusPublish* msg);
};

const ::PROTOBUF_NAMESPACE_ID::Timestamp&
CabinConditionStatusPublish::_Internal::event_time(const CabinConditionStatusPublish* msg) {
  return *msg->_impl_.event_time_;
}
const ::HVACState&
CabinConditionStatusPublish::_Internal::hvac_state(const CabinConditionStatusPublish* msg) {
  return *msg->_impl_.hvac_state_;
}
const ::CabinTemperature&
CabinConditionStatusPublish::_Internal::cabin_temperature(const CabinConditionStatusPublish* msg) {
  return *msg->_impl_.cabin_temperature_;
}
void CabinConditionStatusPublish::clear_event_time() {
  if (GetArenaForAllocation() == nullptr && _impl_.event_time_ != nullptr) {
    delete _impl_.event_time_;
  }
  _impl_.event_time_ = nullptr;
}
CabinConditionStatusPublish::CabinConditionStatusPublish(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:CabinConditionStatusPublish)
}
CabinConditionStatusPublish::CabinConditionStatusPublish(const CabinConditionStatusPublish& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  CabinConditionStatusPublish* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.event_time_){nullptr}
    , decltype(_impl_.hvac_state_){nullptr}
    , decltype(_impl_.cabin_temperature_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_event_time()) {
    _this->_impl_.event_time_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.event_time_);
  }
  if (from._internal_has_hvac_state()) {
    _this->_impl_.hvac_state_ = new ::HVACState(*from._impl_.hvac_state_);
  }
  if (from._internal_has_cabin_temperature()) {
    _this->_impl_.cabin_temperature_ = new ::CabinTemperature(*from._impl_.cabin_temperature_);
  }
  // @@protoc_insertion_point(copy_constructor:CabinConditionStatusPublish)
}

inline void CabinConditionStatusPublish::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.event_time_){nullptr}
    , decltype(_impl_.hvac_state_){nullptr}
    , decltype(_impl_.cabin_temperature_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

CabinConditionStatusPublish::~CabinConditionStatusPublish() {
  // @@protoc_insertion_point(destructor:CabinConditionStatusPublish)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CabinConditionStatusPublish::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.event_time_;
  if (this != internal_default_instance()) delete _impl_.hvac_state_;
  if (this != internal_default_instance()) delete _impl_.cabin_temperature_;
}

void CabinConditionStatusPublish::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CabinConditionStatusPublish::Clear() {
// @@protoc_insertion_point(message_clear_start:CabinConditionStatusPublish)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && _impl_.event_time_ != nullptr) {
    delete _impl_.event_time_;
  }
  _impl_.event_time_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.hvac_state_ != nullptr) {
    delete _impl_.hvac_state_;
  }
  _impl_.hvac_state_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.cabin_temperature_ != nullptr) {
    delete _impl_.cabin_temperature_;
  }
  _impl_.cabin_temperature_ = nullptr;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* CabinConditionStatusPublish::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .google.protobuf.Timestamp event_time = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_event_time(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .HVACState hvac_state = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_hvac_state(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .CabinTemperature cabin_temperature = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_cabin_temperature(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* CabinConditionStatusPublish::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:CabinConditionStatusPublish)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .google.protobuf.Timestamp event_time = 1;
  if (this->_internal_has_event_time()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::event_time(this),
        _Internal::event_time(this).GetCachedSize(), target, stream);
  }

  // .HVACState hvac_state = 2;
  if (this->_internal_has_hvac_state()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::hvac_state(this),
        _Internal::hvac_state(this).GetCachedSize(), target, stream);
  }

  // .CabinTemperature cabin_temperature = 3;
  if (this->_internal_has_cabin_temperature()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, _Internal::cabin_temperature(this),
        _Internal::cabin_temperature(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CabinConditionStatusPublish)
  return target;
}

::size_t CabinConditionStatusPublish::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:CabinConditionStatusPublish)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .google.protobuf.Timestamp event_time = 1;
  if (this->_internal_has_event_time()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.event_time_);
  }

  // .HVACState hvac_state = 2;
  if (this->_internal_has_hvac_state()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.hvac_state_);
  }

  // .CabinTemperature cabin_temperature = 3;
  if (this->_internal_has_cabin_temperature()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.cabin_temperature_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CabinConditionStatusPublish::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    CabinConditionStatusPublish::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CabinConditionStatusPublish::GetClassData() const { return &_class_data_; }


void CabinConditionStatusPublish::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<CabinConditionStatusPublish*>(&to_msg);
  auto& from = static_cast<const CabinConditionStatusPublish&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:CabinConditionStatusPublish)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_event_time()) {
    _this->_internal_mutable_event_time()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
        from._internal_event_time());
  }
  if (from._internal_has_hvac_state()) {
    _this->_internal_mutable_hvac_state()->::HVACState::MergeFrom(
        from._internal_hvac_state());
  }
  if (from._internal_has_cabin_temperature()) {
    _this->_internal_mutable_cabin_temperature()->::CabinTemperature::MergeFrom(
        from._internal_cabin_temperature());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void CabinConditionStatusPublish::CopyFrom(const CabinConditionStatusPublish& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:CabinConditionStatusPublish)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CabinConditionStatusPublish::IsInitialized() const {
  return true;
}

void CabinConditionStatusPublish::InternalSwap(CabinConditionStatusPublish* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(CabinConditionStatusPublish, _impl_.cabin_temperature_)
      + sizeof(CabinConditionStatusPublish::_impl_.cabin_temperature_)
      - PROTOBUF_FIELD_OFFSET(CabinConditionStatusPublish, _impl_.event_time_)>(
          reinterpret_cast<char*>(&_impl_.event_time_),
          reinterpret_cast<char*>(&other->_impl_.event_time_));
}

::PROTOBUF_NAMESPACE_ID::Metadata CabinConditionStatusPublish::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_getter, &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once,
      file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[0]);
}
// ===================================================================

class PreconditionRequest::_Internal {
 public:
  static const ::PROTOBUF_NAMESPACE_ID::Timestamp& start_time(const PreconditionRequest* msg);
};

const ::PROTOBUF_NAMESPACE_ID::Timestamp&
PreconditionRequest::_Internal::start_time(const PreconditionRequest* msg) {
  return *msg->_impl_.start_time_;
}
void PreconditionRequest::clear_start_time() {
  if (GetArenaForAllocation() == nullptr && _impl_.start_time_ != nullptr) {
    delete _impl_.start_time_;
  }
  _impl_.start_time_ = nullptr;
}
PreconditionRequest::PreconditionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:PreconditionRequest)
}
PreconditionRequest::PreconditionRequest(const PreconditionRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  PreconditionRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.hvac_zones_){from._impl_.hvac_zones_}
    , decltype(_impl_.start_time_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_start_time()) {
    _this->_impl_.start_time_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.start_time_);
  }
  // @@protoc_insertion_point(copy_constructor:PreconditionRequest)
}

inline void PreconditionRequest::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.hvac_zones_){arena}
    , decltype(_impl_.start_time_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

PreconditionRequest::~PreconditionRequest() {
  // @@protoc_insertion_point(destructor:PreconditionRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void PreconditionRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.hvac_zones_.~RepeatedPtrField();
  if (this != internal_default_instance()) delete _impl_.start_time_;
}

void PreconditionRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void PreconditionRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:PreconditionRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.hvac_zones_.Clear();
  if (GetArenaForAllocation() == nullptr && _impl_.start_time_ != nullptr) {
    delete _impl_.start_time_;
  }
  _impl_.start_time_ = nullptr;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* PreconditionRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .HVACZone hvac_zones = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_hvac_zones(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp start_time = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_start_time(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* PreconditionRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:PreconditionRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .HVACZone hvac_zones = 1;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_hvac_zones_size()); i < n; i++) {
    const auto& repfield = this->_internal_hvac_zones(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
  }

  // .google.protobuf.Timestamp start_time = 2;
  if (this->_internal_has_start_time()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::start_time(this),
        _Internal::start_time(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:PreconditionRequest)
  return target;
}

::size_t PreconditionRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:PreconditionRequest)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .HVACZone hvac_zones = 1;
  total_size += 1UL * this->_internal_hvac_zones_size();
  for (const auto& msg : this->_impl_.hvac_zones_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // .google.protobuf.Timestamp start_time = 2;
  if (this->_internal_has_start_time()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.start_time_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PreconditionRequest::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    PreconditionRequest::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PreconditionRequest::GetClassData() const { return &_class_data_; }


void PreconditionRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<PreconditionRequest*>(&to_msg);
  auto& from = static_cast<const PreconditionRequest&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:PreconditionRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_impl_.hvac_zones_.MergeFrom(from._impl_.hvac_zones_);
  if (from._internal_has_start_time()) {
    _this->_internal_mutable_start_time()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
        from._internal_start_time());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void PreconditionRequest::CopyFrom(const PreconditionRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:PreconditionRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PreconditionRequest::IsInitialized() const {
  return true;
}

void PreconditionRequest::InternalSwap(PreconditionRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.hvac_zones_.InternalSwap(&other->_impl_.hvac_zones_);
  swap(_impl_.start_time_, other->_impl_.start_time_);
}

::PROTOBUF_NAMESPACE_ID::Metadata PreconditionRequest::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_getter, &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once,
      file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[1]);
}
// ===================================================================

class PreconditionResponse::_Internal {
 public:
};

PreconditionResponse::PreconditionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:PreconditionResponse)
}
PreconditionResponse::PreconditionResponse(const PreconditionResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  PreconditionResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.message_) {}

    , decltype(_impl_.status_) {}

    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  _impl_.message_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.message_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_message().empty()) {
    _this->_impl_.message_.Set(from._internal_message(), _this->GetArenaForAllocation());
  }
  _this->_impl_.status_ = from._impl_.status_;
  // @@protoc_insertion_point(copy_constructor:PreconditionResponse)
}

inline void PreconditionResponse::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.message_) {}

    , decltype(_impl_.status_) { 0 }

    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.message_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.message_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

PreconditionResponse::~PreconditionResponse() {
  // @@protoc_insertion_point(destructor:PreconditionResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void PreconditionResponse::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.message_.Destroy();
}

void PreconditionResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void PreconditionResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:PreconditionResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.message_.ClearToEmpty();
  _impl_.status_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* PreconditionResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .PreconditionResponse.Status status = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          ::uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_status(static_cast<::PreconditionResponse_Status>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // string message = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_message();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, "PreconditionResponse.message"));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* PreconditionResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:PreconditionResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .PreconditionResponse.Status status = 1;
  if (this->_internal_status() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        1, this->_internal_status(), target);
  }

  // string message = 2;
  if (!this->_internal_message().empty()) {
    const std::string& _s = this->_internal_message();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "PreconditionResponse.message");
    target = stream->WriteStringMaybeAliased(2, _s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:PreconditionResponse)
  return target;
}

::size_t PreconditionResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:PreconditionResponse)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string message = 2;
  if (!this->_internal_message().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_message());
  }

  // .PreconditionResponse.Status status = 1;
  if (this->_internal_status() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_status());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PreconditionResponse::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    PreconditionResponse::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PreconditionResponse::GetClassData() const { return &_class_data_; }


void PreconditionResponse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<PreconditionResponse*>(&to_msg);
  auto& from = static_cast<const PreconditionResponse&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:PreconditionResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_message().empty()) {
    _this->_internal_set_message(from._internal_message());
  }
  if (from._internal_status() != 0) {
    _this->_internal_set_status(from._internal_status());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void PreconditionResponse::CopyFrom(const PreconditionResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:PreconditionResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PreconditionResponse::IsInitialized() const {
  return true;
}

void PreconditionResponse::InternalSwap(PreconditionResponse* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.message_, lhs_arena,
                                       &other->_impl_.message_, rhs_arena);
  swap(_impl_.status_, other->_impl_.status_);
}

::PROTOBUF_NAMESPACE_ID::Metadata PreconditionResponse::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_getter, &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once,
      file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[2]);
}
// ===================================================================

class CabinTemperature::_Internal {
 public:
  static const ::Temperature& temperature(const CabinTemperature* msg);
  static const ::HVACZone& zone(const CabinTemperature* msg);
};

const ::Temperature&
CabinTemperature::_Internal::temperature(const CabinTemperature* msg) {
  return *msg->_impl_.temperature_;
}
const ::HVACZone&
CabinTemperature::_Internal::zone(const CabinTemperature* msg) {
  return *msg->_impl_.zone_;
}
CabinTemperature::CabinTemperature(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:CabinTemperature)
}
CabinTemperature::CabinTemperature(const CabinTemperature& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  CabinTemperature* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.temperature_){nullptr}
    , decltype(_impl_.zone_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_temperature()) {
    _this->_impl_.temperature_ = new ::Temperature(*from._impl_.temperature_);
  }
  if (from._internal_has_zone()) {
    _this->_impl_.zone_ = new ::HVACZone(*from._impl_.zone_);
  }
  // @@protoc_insertion_point(copy_constructor:CabinTemperature)
}

inline void CabinTemperature::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.temperature_){nullptr}
    , decltype(_impl_.zone_){nullptr}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

CabinTemperature::~CabinTemperature() {
  // @@protoc_insertion_point(destructor:CabinTemperature)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CabinTemperature::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.temperature_;
  if (this != internal_default_instance()) delete _impl_.zone_;
}

void CabinTemperature::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CabinTemperature::Clear() {
// @@protoc_insertion_point(message_clear_start:CabinTemperature)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && _impl_.temperature_ != nullptr) {
    delete _impl_.temperature_;
  }
  _impl_.temperature_ = nullptr;
  if (GetArenaForAllocation() == nullptr && _impl_.zone_ != nullptr) {
    delete _impl_.zone_;
  }
  _impl_.zone_ = nullptr;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* CabinTemperature::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .Temperature temperature = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_temperature(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .HVACZone zone = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_zone(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* CabinTemperature::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:CabinTemperature)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .Temperature temperature = 1;
  if (this->_internal_has_temperature()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::temperature(this),
        _Internal::temperature(this).GetCachedSize(), target, stream);
  }

  // .HVACZone zone = 2;
  if (this->_internal_has_zone()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::zone(this),
        _Internal::zone(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CabinTemperature)
  return target;
}

::size_t CabinTemperature::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:CabinTemperature)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .Temperature temperature = 1;
  if (this->_internal_has_temperature()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.temperature_);
  }

  // .HVACZone zone = 2;
  if (this->_internal_has_zone()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.zone_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CabinTemperature::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    CabinTemperature::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CabinTemperature::GetClassData() const { return &_class_data_; }


void CabinTemperature::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<CabinTemperature*>(&to_msg);
  auto& from = static_cast<const CabinTemperature&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:CabinTemperature)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_temperature()) {
    _this->_internal_mutable_temperature()->::Temperature::MergeFrom(
        from._internal_temperature());
  }
  if (from._internal_has_zone()) {
    _this->_internal_mutable_zone()->::HVACZone::MergeFrom(
        from._internal_zone());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void CabinTemperature::CopyFrom(const CabinTemperature& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:CabinTemperature)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CabinTemperature::IsInitialized() const {
  return true;
}

void CabinTemperature::InternalSwap(CabinTemperature* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(CabinTemperature, _impl_.zone_)
      + sizeof(CabinTemperature::_impl_.zone_)
      - PROTOBUF_FIELD_OFFSET(CabinTemperature, _impl_.temperature_)>(
          reinterpret_cast<char*>(&_impl_.temperature_),
          reinterpret_cast<char*>(&other->_impl_.temperature_));
}

::PROTOBUF_NAMESPACE_ID::Metadata CabinTemperature::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_getter, &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once,
      file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[3]);
}
// ===================================================================

class Temperature::_Internal {
 public:
};

Temperature::Temperature(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:Temperature)
}
Temperature::Temperature(const Temperature& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  Temperature* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.unit_) {}

    , decltype(_impl_.value_) {}

    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  _impl_.unit_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.unit_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_unit().empty()) {
    _this->_impl_.unit_.Set(from._internal_unit(), _this->GetArenaForAllocation());
  }
  _this->_impl_.value_ = from._impl_.value_;
  // @@protoc_insertion_point(copy_constructor:Temperature)
}

inline void Temperature::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.unit_) {}

    , decltype(_impl_.value_) { 0 }

    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.unit_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.unit_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

Temperature::~Temperature() {
  // @@protoc_insertion_point(destructor:Temperature)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void Temperature::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.unit_.Destroy();
}

void Temperature::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void Temperature::Clear() {
// @@protoc_insertion_point(message_clear_start:Temperature)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.unit_.ClearToEmpty();
  _impl_.value_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Temperature::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // float value = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 13)) {
          _impl_.value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else {
          goto handle_unusual;
        }
        continue;
      // string unit = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_unit();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, "Temperature.unit"));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* Temperature::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Temperature)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // float value = 1;
  static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size.");
  float tmp_value = this->_internal_value();
  ::uint32_t raw_value;
  memcpy(&raw_value, &tmp_value, sizeof(tmp_value));
  if (raw_value != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFloatToArray(
        1, this->_internal_value(), target);
  }

  // string unit = 2;
  if (!this->_internal_unit().empty()) {
    const std::string& _s = this->_internal_unit();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "Temperature.unit");
    target = stream->WriteStringMaybeAliased(2, _s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Temperature)
  return target;
}

::size_t Temperature::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Temperature)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string unit = 2;
  if (!this->_internal_unit().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_unit());
  }

  // float value = 1;
  static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size.");
  float tmp_value = this->_internal_value();
  ::uint32_t raw_value;
  memcpy(&raw_value, &tmp_value, sizeof(tmp_value));
  if (raw_value != 0) {
    total_size += 5;
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Temperature::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    Temperature::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Temperature::GetClassData() const { return &_class_data_; }


void Temperature::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<Temperature*>(&to_msg);
  auto& from = static_cast<const Temperature&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:Temperature)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_unit().empty()) {
    _this->_internal_set_unit(from._internal_unit());
  }
  static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size.");
  float tmp_value = from._internal_value();
  ::uint32_t raw_value;
  memcpy(&raw_value, &tmp_value, sizeof(tmp_value));
  if (raw_value != 0) {
    _this->_internal_set_value(from._internal_value());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void Temperature::CopyFrom(const Temperature& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Temperature)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Temperature::IsInitialized() const {
  return true;
}

void Temperature::InternalSwap(Temperature* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.unit_, lhs_arena,
                                       &other->_impl_.unit_, rhs_arena);

  swap(_impl_.value_, other->_impl_.value_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Temperature::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_getter, &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once,
      file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[4]);
}
// ===================================================================

class HVACZone::_Internal {
 public:
  static const ::Temperature& target_temperature(const HVACZone* msg);
};

const ::Temperature&
HVACZone::_Internal::target_temperature(const HVACZone* msg) {
  return *msg->_impl_.target_temperature_;
}
HVACZone::HVACZone(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:HVACZone)
}
HVACZone::HVACZone(const HVACZone& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  HVACZone* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.target_temperature_){nullptr}
    , decltype(_impl_.zone_) {}

    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_target_temperature()) {
    _this->_impl_.target_temperature_ = new ::Temperature(*from._impl_.target_temperature_);
  }
  _this->_impl_.zone_ = from._impl_.zone_;
  // @@protoc_insertion_point(copy_constructor:HVACZone)
}

inline void HVACZone::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.target_temperature_){nullptr}
    , decltype(_impl_.zone_) { 0 }

    , /*decltype(_impl_._cached_size_)*/{}
  };
}

HVACZone::~HVACZone() {
  // @@protoc_insertion_point(destructor:HVACZone)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void HVACZone::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.target_temperature_;
}

void HVACZone::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void HVACZone::Clear() {
// @@protoc_insertion_point(message_clear_start:HVACZone)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && _impl_.target_temperature_ != nullptr) {
    delete _impl_.target_temperature_;
  }
  _impl_.target_temperature_ = nullptr;
  _impl_.zone_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* HVACZone::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .HVACZone.Zone zone = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          ::uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_zone(static_cast<::HVACZone_Zone>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // .Temperature target_temperature = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_target_temperature(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* HVACZone::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:HVACZone)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .HVACZone.Zone zone = 1;
  if (this->_internal_zone() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        1, this->_internal_zone(), target);
  }

  // .Temperature target_temperature = 2;
  if (this->_internal_has_target_temperature()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::target_temperature(this),
        _Internal::target_temperature(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:HVACZone)
  return target;
}

::size_t HVACZone::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:HVACZone)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .Temperature target_temperature = 2;
  if (this->_internal_has_target_temperature()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.target_temperature_);
  }

  // .HVACZone.Zone zone = 1;
  if (this->_internal_zone() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_zone());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HVACZone::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    HVACZone::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HVACZone::GetClassData() const { return &_class_data_; }


void HVACZone::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<HVACZone*>(&to_msg);
  auto& from = static_cast<const HVACZone&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:HVACZone)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_target_temperature()) {
    _this->_internal_mutable_target_temperature()->::Temperature::MergeFrom(
        from._internal_target_temperature());
  }
  if (from._internal_zone() != 0) {
    _this->_internal_set_zone(from._internal_zone());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void HVACZone::CopyFrom(const HVACZone& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:HVACZone)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool HVACZone::IsInitialized() const {
  return true;
}

void HVACZone::InternalSwap(HVACZone* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(HVACZone, _impl_.zone_)
      + sizeof(HVACZone::_impl_.zone_)
      - PROTOBUF_FIELD_OFFSET(HVACZone, _impl_.target_temperature_)>(
          reinterpret_cast<char*>(&_impl_.target_temperature_),
          reinterpret_cast<char*>(&other->_impl_.target_temperature_));
}

::PROTOBUF_NAMESPACE_ID::Metadata HVACZone::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_getter, &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once,
      file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[5]);
}
// ===================================================================

class HVACState::_Internal {
 public:
  static const ::HVACZone& current_zone(const HVACState* msg);
};

const ::HVACZone&
HVACState::_Internal::current_zone(const HVACState* msg) {
  return *msg->_impl_.current_zone_;
}
HVACState::HVACState(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:HVACState)
}
HVACState::HVACState(const HVACState& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  HVACState* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.current_zone_){nullptr}
    , decltype(_impl_.state_) {}

    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_current_zone()) {
    _this->_impl_.current_zone_ = new ::HVACZone(*from._impl_.current_zone_);
  }
  _this->_impl_.state_ = from._impl_.state_;
  // @@protoc_insertion_point(copy_constructor:HVACState)
}

inline void HVACState::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.current_zone_){nullptr}
    , decltype(_impl_.state_) { 0 }

    , /*decltype(_impl_._cached_size_)*/{}
  };
}

HVACState::~HVACState() {
  // @@protoc_insertion_point(destructor:HVACState)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void HVACState::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.current_zone_;
}

void HVACState::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void HVACState::Clear() {
// @@protoc_insertion_point(message_clear_start:HVACState)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && _impl_.current_zone_ != nullptr) {
    delete _impl_.current_zone_;
  }
  _impl_.current_zone_ = nullptr;
  _impl_.state_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* HVACState::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .HVACState.State state = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          ::uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_state(static_cast<::HVACState_State>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // .HVACZone current_zone = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_current_zone(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* HVACState::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:HVACState)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .HVACState.State state = 1;
  if (this->_internal_state() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        1, this->_internal_state(), target);
  }

  // .HVACZone current_zone = 2;
  if (this->_internal_has_current_zone()) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::current_zone(this),
        _Internal::current_zone(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:HVACState)
  return target;
}

::size_t HVACState::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:HVACState)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .HVACZone current_zone = 2;
  if (this->_internal_has_current_zone()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.current_zone_);
  }

  // .HVACState.State state = 1;
  if (this->_internal_state() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_state());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HVACState::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    HVACState::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HVACState::GetClassData() const { return &_class_data_; }


void HVACState::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<HVACState*>(&to_msg);
  auto& from = static_cast<const HVACState&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:HVACState)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_current_zone()) {
    _this->_internal_mutable_current_zone()->::HVACZone::MergeFrom(
        from._internal_current_zone());
  }
  if (from._internal_state() != 0) {
    _this->_internal_set_state(from._internal_state());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void HVACState::CopyFrom(const HVACState& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:HVACState)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool HVACState::IsInitialized() const {
  return true;
}

void HVACState::InternalSwap(HVACState* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(HVACState, _impl_.state_)
      + sizeof(HVACState::_impl_.state_)
      - PROTOBUF_FIELD_OFFSET(HVACState, _impl_.current_zone_)>(
          reinterpret_cast<char*>(&_impl_.current_zone_),
          reinterpret_cast<char*>(&other->_impl_.current_zone_));
}

::PROTOBUF_NAMESPACE_ID::Metadata HVACState::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_getter, &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once,
      file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[6]);
}
// @@protoc_insertion_point(namespace_scope)
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::CabinConditionStatusPublish*
Arena::CreateMaybeMessage< ::CabinConditionStatusPublish >(Arena* arena) {
  return Arena::CreateMessageInternal< ::CabinConditionStatusPublish >(arena);
}
template<> PROTOBUF_NOINLINE ::PreconditionRequest*
Arena::CreateMaybeMessage< ::PreconditionRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::PreconditionRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::PreconditionResponse*
Arena::CreateMaybeMessage< ::PreconditionResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::PreconditionResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::CabinTemperature*
Arena::CreateMaybeMessage< ::CabinTemperature >(Arena* arena) {
  return Arena::CreateMessageInternal< ::CabinTemperature >(arena);
}
template<> PROTOBUF_NOINLINE ::Temperature*
Arena::CreateMaybeMessage< ::Temperature >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Temperature >(arena);
}
template<> PROTOBUF_NOINLINE ::HVACZone*
Arena::CreateMaybeMessage< ::HVACZone >(Arena* arena) {
  return Arena::CreateMessageInternal< ::HVACZone >(arena);
}
template<> PROTOBUF_NOINLINE ::HVACState*
Arena::CreateMaybeMessage< ::HVACState >(Arena* arena) {
  return Arena::CreateMessageInternal< ::HVACState >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"