Newest Commit

Signed-off-by: James Simon <jamsimox@amazon.com>
Change-Id: I9786889a4335d4b79b02ec3d505882fc85e71601

2 files changed, 2473 insertions, 1307 deletions

diff --git a/build/generated/source/proto/main/cpp/messages/VehicleRemoteHvac.pb.cc b/build/generated/source/proto/main/cpp/messages/VehicleRemoteHvac.pb.cc
index 894932e..f4e7efe 100644
--- a/build/generated/source/proto/main/cpp/messages/VehicleRemoteHvac.pb.cc
+++ b/build/generated/source/proto/main/cpp/messages/VehicleRemoteHvac.pb.cc
@@ -19,223 +19,267 @@ PROTOBUF_PRAGMA_INIT_SEG
 namespace _pb = ::PROTOBUF_NAMESPACE_ID;
 namespace _pbi = ::PROTOBUF_NAMESPACE_ID::internal;
 namespace messages {
-PROTOBUF_CONSTEXPR CabinPreconditionRequest::CabinPreconditionRequest(
+namespace hvac {
+PROTOBUF_CONSTEXPR Temperature::Temperature(
     ::_pbi::ConstantInitialized): _impl_{
-    /*decltype(_impl_.messageheader_)*/nullptr
-  , /*decltype(_impl_.setacstatus_)*/nullptr
-  , /*decltype(_impl_.settemp_)*/nullptr
+    /*decltype(_impl_.unit_)*/ {
+    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
+  }
+
+  , /*decltype(_impl_.value_)*/ 0
+
   , /*decltype(_impl_._cached_size_)*/{}} {}
-struct CabinPreconditionRequestDefaultTypeInternal {
-  PROTOBUF_CONSTEXPR CabinPreconditionRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
-  ~CabinPreconditionRequestDefaultTypeInternal() {}
+struct TemperatureDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR TemperatureDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~TemperatureDefaultTypeInternal() {}
   union {
-    CabinPreconditionRequest _instance;
+    Temperature _instance;
   };
 };
 
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
-    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CabinPreconditionRequestDefaultTypeInternal _CabinPreconditionRequest_default_instance_;
-PROTOBUF_CONSTEXPR CabinPreConditionReponse::CabinPreConditionReponse(
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TemperatureDefaultTypeInternal _Temperature_default_instance_;
+PROTOBUF_CONSTEXPR HVACZone::HVACZone(
     ::_pbi::ConstantInitialized): _impl_{
-    /*decltype(_impl_.messageheader_)*/nullptr
-  , /*decltype(_impl_.setacstatusreply_)*/nullptr
-  , /*decltype(_impl_.settemperaturereply_)*/nullptr
+    /*decltype(_impl_.target_temperature_)*/nullptr
+  , /*decltype(_impl_.zone_)*/ 0
+
   , /*decltype(_impl_._cached_size_)*/{}} {}
-struct CabinPreConditionReponseDefaultTypeInternal {
-  PROTOBUF_CONSTEXPR CabinPreConditionReponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
-  ~CabinPreConditionReponseDefaultTypeInternal() {}
+struct HVACZoneDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR HVACZoneDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~HVACZoneDefaultTypeInternal() {}
   union {
-    CabinPreConditionReponse _instance;
+    HVACZone _instance;
   };
 };
 
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
-    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CabinPreConditionReponseDefaultTypeInternal _CabinPreConditionReponse_default_instance_;
-PROTOBUF_CONSTEXPR SetAcStatusRequest::SetAcStatusRequest(
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HVACZoneDefaultTypeInternal _HVACZone_default_instance_;
+PROTOBUF_CONSTEXPR PreconditionRequest::PreconditionRequest(
     ::_pbi::ConstantInitialized): _impl_{
-    /*decltype(_impl_.desiredstatus_)*/ 0
-
+    /*decltype(_impl_.hvac_zones_)*/{}
+  , /*decltype(_impl_.start_time_)*/nullptr
   , /*decltype(_impl_._cached_size_)*/{}} {}
-struct SetAcStatusRequestDefaultTypeInternal {
-  PROTOBUF_CONSTEXPR SetAcStatusRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
-  ~SetAcStatusRequestDefaultTypeInternal() {}
+struct PreconditionRequestDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PreconditionRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PreconditionRequestDefaultTypeInternal() {}
   union {
-    SetAcStatusRequest _instance;
+    PreconditionRequest _instance;
   };
 };
 
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
-    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetAcStatusRequestDefaultTypeInternal _SetAcStatusRequest_default_instance_;
-PROTOBUF_CONSTEXPR SetAcStatusReply::SetAcStatusReply(
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PreconditionRequestDefaultTypeInternal _PreconditionRequest_default_instance_;
+PROTOBUF_CONSTEXPR PreconditionResponse::PreconditionResponse(
     ::_pbi::ConstantInitialized): _impl_{
-    /*decltype(_impl_.status_)*/ 0
+    /*decltype(_impl_.message_)*/ {
+    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
+  }
+
+  , /*decltype(_impl_.status_)*/ 0
 
   , /*decltype(_impl_._cached_size_)*/{}} {}
-struct SetAcStatusReplyDefaultTypeInternal {
-  PROTOBUF_CONSTEXPR SetAcStatusReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
-  ~SetAcStatusReplyDefaultTypeInternal() {}
+struct PreconditionResponseDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR PreconditionResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~PreconditionResponseDefaultTypeInternal() {}
   union {
-    SetAcStatusReply _instance;
+    PreconditionResponse _instance;
   };
 };
 
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
-    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetAcStatusReplyDefaultTypeInternal _SetAcStatusReply_default_instance_;
-PROTOBUF_CONSTEXPR SetTemperatureRequest::SetTemperatureRequest(
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PreconditionResponseDefaultTypeInternal _PreconditionResponse_default_instance_;
+PROTOBUF_CONSTEXPR HVACState::HVACState(
     ::_pbi::ConstantInitialized): _impl_{
-    /*decltype(_impl_.temperature_)*/ 0
+    /*decltype(_impl_.current_zone_)*/nullptr
+  , /*decltype(_impl_.state_)*/ 0
 
   , /*decltype(_impl_._cached_size_)*/{}} {}
-struct SetTemperatureRequestDefaultTypeInternal {
-  PROTOBUF_CONSTEXPR SetTemperatureRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
-  ~SetTemperatureRequestDefaultTypeInternal() {}
+struct HVACStateDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR HVACStateDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~HVACStateDefaultTypeInternal() {}
   union {
-    SetTemperatureRequest _instance;
+    HVACState _instance;
   };
 };
 
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
-    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetTemperatureRequestDefaultTypeInternal _SetTemperatureRequest_default_instance_;
-PROTOBUF_CONSTEXPR SetTemperatureReply::SetTemperatureReply(
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HVACStateDefaultTypeInternal _HVACState_default_instance_;
+PROTOBUF_CONSTEXPR CabinTemperature::CabinTemperature(
     ::_pbi::ConstantInitialized): _impl_{
-    /*decltype(_impl_.tempstatus_)*/ 0
+    /*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 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 SetTemperatureReplyDefaultTypeInternal {
-  PROTOBUF_CONSTEXPR SetTemperatureReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
-  ~SetTemperatureReplyDefaultTypeInternal() {}
+struct CabinConditionStatusPublishDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR CabinConditionStatusPublishDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~CabinConditionStatusPublishDefaultTypeInternal() {}
   union {
-    SetTemperatureReply _instance;
+    CabinConditionStatusPublish _instance;
   };
 };
 
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
-    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetTemperatureReplyDefaultTypeInternal _SetTemperatureReply_default_instance_;
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CabinConditionStatusPublishDefaultTypeInternal _CabinConditionStatusPublish_default_instance_;
+}  // namespace hvac
 }  // namespace messages
-static ::_pb::Metadata file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[6];
-static const ::_pb::EnumDescriptor* file_level_enum_descriptors_messages_2fVehicleRemoteHvac_2eproto[2];
+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(::messages::CabinPreconditionRequest, _internal_metadata_),
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::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(::messages::CabinPreconditionRequest, _impl_.messageheader_),
-    PROTOBUF_FIELD_OFFSET(::messages::CabinPreconditionRequest, _impl_.setacstatus_),
-    PROTOBUF_FIELD_OFFSET(::messages::CabinPreconditionRequest, _impl_.settemp_),
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::Temperature, _impl_.value_),
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::Temperature, _impl_.unit_),
     ~0u,  // no _has_bits_
-    PROTOBUF_FIELD_OFFSET(::messages::CabinPreConditionReponse, _internal_metadata_),
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::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(::messages::CabinPreConditionReponse, _impl_.messageheader_),
-    PROTOBUF_FIELD_OFFSET(::messages::CabinPreConditionReponse, _impl_.setacstatusreply_),
-    PROTOBUF_FIELD_OFFSET(::messages::CabinPreConditionReponse, _impl_.settemperaturereply_),
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::HVACZone, _impl_.zone_),
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::HVACZone, _impl_.target_temperature_),
     ~0u,  // no _has_bits_
-    PROTOBUF_FIELD_OFFSET(::messages::SetAcStatusRequest, _internal_metadata_),
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::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(::messages::SetAcStatusRequest, _impl_.desiredstatus_),
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::PreconditionRequest, _impl_.hvac_zones_),
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::PreconditionRequest, _impl_.start_time_),
     ~0u,  // no _has_bits_
-    PROTOBUF_FIELD_OFFSET(::messages::SetAcStatusReply, _internal_metadata_),
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::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(::messages::SetAcStatusReply, _impl_.status_),
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::PreconditionResponse, _impl_.status_),
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::PreconditionResponse, _impl_.message_),
     ~0u,  // no _has_bits_
-    PROTOBUF_FIELD_OFFSET(::messages::SetTemperatureRequest, _internal_metadata_),
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::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(::messages::SetTemperatureRequest, _impl_.temperature_),
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::HVACState, _impl_.state_),
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::HVACState, _impl_.current_zone_),
     ~0u,  // no _has_bits_
-    PROTOBUF_FIELD_OFFSET(::messages::SetTemperatureReply, _internal_metadata_),
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::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(::messages::SetTemperatureReply, _impl_.tempstatus_),
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::CabinTemperature, _impl_.temperature_),
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::CabinTemperature, _impl_.zone_),
+    ~0u,  // no _has_bits_
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::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(::messages::hvac::CabinConditionStatusPublish, _impl_.event_time_),
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::CabinConditionStatusPublish, _impl_.hvac_state_),
+    PROTOBUF_FIELD_OFFSET(::messages::hvac::CabinConditionStatusPublish, _impl_.cabin_temperature_),
 };
 
 static const ::_pbi::MigrationSchema
     schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
-        { 0, -1, -1, sizeof(::messages::CabinPreconditionRequest)},
-        { 11, -1, -1, sizeof(::messages::CabinPreConditionReponse)},
-        { 22, -1, -1, sizeof(::messages::SetAcStatusRequest)},
-        { 31, -1, -1, sizeof(::messages::SetAcStatusReply)},
-        { 40, -1, -1, sizeof(::messages::SetTemperatureRequest)},
-        { 49, -1, -1, sizeof(::messages::SetTemperatureReply)},
+        { 0, -1, -1, sizeof(::messages::hvac::Temperature)},
+        { 10, -1, -1, sizeof(::messages::hvac::HVACZone)},
+        { 20, -1, -1, sizeof(::messages::hvac::PreconditionRequest)},
+        { 30, -1, -1, sizeof(::messages::hvac::PreconditionResponse)},
+        { 40, -1, -1, sizeof(::messages::hvac::HVACState)},
+        { 50, -1, -1, sizeof(::messages::hvac::CabinTemperature)},
+        { 60, -1, -1, sizeof(::messages::hvac::CabinConditionStatusPublish)},
 };
 
 static const ::_pb::Message* const file_default_instances[] = {
-    &::messages::_CabinPreconditionRequest_default_instance_._instance,
-    &::messages::_CabinPreConditionReponse_default_instance_._instance,
-    &::messages::_SetAcStatusRequest_default_instance_._instance,
-    &::messages::_SetAcStatusReply_default_instance_._instance,
-    &::messages::_SetTemperatureRequest_default_instance_._instance,
-    &::messages::_SetTemperatureReply_default_instance_._instance,
+    &::messages::hvac::_Temperature_default_instance_._instance,
+    &::messages::hvac::_HVACZone_default_instance_._instance,
+    &::messages::hvac::_PreconditionRequest_default_instance_._instance,
+    &::messages::hvac::_PreconditionResponse_default_instance_._instance,
+    &::messages::hvac::_HVACState_default_instance_._instance,
+    &::messages::hvac::_CabinTemperature_default_instance_._instance,
+    &::messages::hvac::_CabinConditionStatusPublish_default_instance_._instance,
 };
 const char descriptor_table_protodef_messages_2fVehicleRemoteHvac_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
-    "\n messages/VehicleRemoteHvac.proto\022\010mess"
-    "ages\032\017vss/vspec.proto\032#messages/VehicleM"
-    "essageHeader.proto\"\267\001\n\030CabinPrecondition"
-    "Request\0226\n\rmessageHeader\030\001 \001(\0132\037.message"
-    "s.VehicleMessageHeading\0221\n\013setAcStatus\030\002"
-    " \001(\0132\034.messages.SetAcStatusRequest\0220\n\007se"
-    "tTemp\030\003 \001(\0132\037.messages.SetTemperatureReq"
-    "uest\"\304\001\n\030CabinPreConditionReponse\0226\n\rmes"
-    "sageHeader\030\001 \001(\0132\037.messages.VehicleMessa"
-    "geHeading\0224\n\020setAcStatusReply\030\002 \001(\0132\032.me"
-    "ssages.SetAcStatusReply\022:\n\023setTemperatur"
-    "eReply\030\003 \001(\0132\035.messages.SetTemperatureRe"
-    "ply\"C\n\022SetAcStatusRequest\022-\n\rdesiredStat"
-    "us\030\001 \001(\0162\026.messages.AcStatusEnum\":\n\020SetA"
-    "cStatusReply\022&\n\006status\030\001 \001(\0162\026.messages."
-    "AcStatusEnum\",\n\025SetTemperatureRequest\022\023\n"
-    "\013temperature\030\001 \001(\002\"F\n\023SetTemperatureRepl"
-    "y\022/\n\ntempStatus\030\001 \001(\0162\033.messages.SetTemp"
-    "StatusEnum*2\n\014AcStatusEnum\022\006\n\002ON\020\000\022\007\n\003OF"
-    "F\020\001\022\021\n\rUKNONWN_ERROR\020\002*5\n\021SetTempStatusE"
-    "num\022\020\n\014TEMP_SUCCESS\020\000\022\016\n\nTEMP_ERROR\020\001b\006p"
-    "roto3"
+    "\n messages/VehicleRemoteHvac.proto\022\rmess"
+    "ages.hvac\032\037google/protobuf/timestamp.pro"
+    "to\"*\n\013Temperature\022\r\n\005value\030\001 \001(\002\022\014\n\004unit"
+    "\030\002 \001(\t\"\260\001\n\010HVACZone\022*\n\004zone\030\001 \001(\0162\034.mess"
+    "ages.hvac.HVACZone.Zone\0226\n\022target_temper"
+    "ature\030\002 \001(\0132\032.messages.hvac.Temperature\""
+    "@\n\004Zone\022\n\n\006DRIVER\020\000\022\r\n\tPASSENGER\020\001\022\r\n\tRE"
+    "AR_LEFT\020\002\022\016\n\nREAR_RIGHT\020\003\"r\n\023Preconditio"
+    "nRequest\022+\n\nhvac_zones\030\001 \003(\0132\027.messages."
+    "hvac.HVACZone\022.\n\nstart_time\030\002 \001(\0132\032.goog"
+    "le.protobuf.Timestamp\"\224\001\n\024PreconditionRe"
+    "sponse\022:\n\006status\030\001 \001(\0162*.messages.hvac.P"
+    "reconditionResponse.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\"\237\001\n\tHVACState\022-\n\005state\030\001 \001("
+    "\0162\036.messages.hvac.HVACState.State\022-\n\014cur"
+    "rent_zone\030\002 \001(\0132\027.messages.hvac.HVACZone"
+    "\"4\n\005State\022\007\n\003OFF\020\000\022\013\n\007HEATING\020\001\022\013\n\007COOLI"
+    "NG\020\002\022\010\n\004IDLE\020\003\"j\n\020CabinTemperature\022/\n\013te"
+    "mperature\030\001 \001(\0132\032.messages.hvac.Temperat"
+    "ure\022%\n\004zone\030\002 \001(\0132\027.messages.hvac.HVACZo"
+    "ne\"\267\001\n\033CabinConditionStatusPublish\022.\n\nev"
+    "ent_time\030\001 \001(\0132\032.google.protobuf.Timesta"
+    "mp\022,\n\nhvac_state\030\002 \001(\0132\030.messages.hvac.H"
+    "VACState\022:\n\021cabin_temperature\030\003 \001(\0132\037.me"
+    "ssages.hvac.CabinTemperatureb\006proto3"
 };
-static const ::_pbi::DescriptorTable* const descriptor_table_messages_2fVehicleRemoteHvac_2eproto_deps[2] =
+static const ::_pbi::DescriptorTable* const descriptor_table_messages_2fVehicleRemoteHvac_2eproto_deps[1] =
     {
-        &::descriptor_table_messages_2fVehicleMessageHeader_2eproto,
-        &::descriptor_table_vss_2fvspec_2eproto,
+        &::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,
-    845,
+    1036,
     descriptor_table_protodef_messages_2fVehicleRemoteHvac_2eproto,
     "messages/VehicleRemoteHvac.proto",
     &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once,
     descriptor_table_messages_2fVehicleRemoteHvac_2eproto_deps,
-    2,
-    6,
+    1,
+    7,
     schemas,
     file_default_instances,
     TableStruct_messages_2fVehicleRemoteHvac_2eproto::offsets,
@@ -262,99 +306,374 @@ PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_messages
 PROTOBUF_ATTRIBUTE_INIT_PRIORITY2
 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_messages_2fVehicleRemoteHvac_2eproto(&descriptor_table_messages_2fVehicleRemoteHvac_2eproto);
 namespace messages {
-const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AcStatusEnum_descriptor() {
+namespace hvac {
+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[0];
 }
-bool AcStatusEnum_IsValid(int value) {
+bool HVACZone_Zone_IsValid(int value) {
   switch (value) {
     case 0:
     case 1:
     case 2:
+    case 3:
       return true;
     default:
       return false;
   }
 }
-const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SetTempStatusEnum_descriptor() {
+#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* PreconditionResponse_Status_descriptor() {
   ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_messages_2fVehicleRemoteHvac_2eproto);
   return file_level_enum_descriptors_messages_2fVehicleRemoteHvac_2eproto[1];
 }
-bool SetTempStatusEnum_IsValid(int value) {
+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* 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 CabinPreconditionRequest::_Internal {
+class Temperature::_Internal {
  public:
-  static const ::messages::VehicleMessageHeading& messageheader(const CabinPreconditionRequest* msg);
-  static const ::messages::SetAcStatusRequest& setacstatus(const CabinPreconditionRequest* msg);
-  static const ::messages::SetTemperatureRequest& settemp(const CabinPreconditionRequest* msg);
 };
 
-const ::messages::VehicleMessageHeading&
-CabinPreconditionRequest::_Internal::messageheader(const CabinPreconditionRequest* msg) {
-  return *msg->_impl_.messageheader_;
+Temperature::Temperature(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
+  SharedCtor(arena);
+  // @@protoc_insertion_point(arena_constructor:messages.hvac.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:messages.hvac.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:messages.hvac.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:messages.hvac.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, "messages.hvac.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_
 }
-const ::messages::SetAcStatusRequest&
-CabinPreconditionRequest::_Internal::setacstatus(const CabinPreconditionRequest* msg) {
-  return *msg->_impl_.setacstatus_;
+
+::uint8_t* Temperature::_InternalSerialize(
+    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:messages.hvac.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, "messages.hvac.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:messages.hvac.Temperature)
+  return target;
 }
-const ::messages::SetTemperatureRequest&
-CabinPreconditionRequest::_Internal::settemp(const CabinPreconditionRequest* msg) {
-  return *msg->_impl_.settemp_;
+
+::size_t Temperature::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:messages.hvac.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_);
 }
-void CabinPreconditionRequest::clear_messageheader() {
-  if (GetArenaForAllocation() == nullptr && _impl_.messageheader_ != nullptr) {
-    delete _impl_.messageheader_;
+
+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:messages.hvac.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());
   }
-  _impl_.messageheader_ = nullptr;
+  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:messages.hvac.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_);
 }
-CabinPreconditionRequest::CabinPreconditionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+
+::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[0]);
+}
+// ===================================================================
+
+class HVACZone::_Internal {
+ public:
+  static const ::messages::hvac::Temperature& target_temperature(const HVACZone* msg);
+};
+
+const ::messages::hvac::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:messages.CabinPreconditionRequest)
+  // @@protoc_insertion_point(arena_constructor:messages.hvac.HVACZone)
 }
-CabinPreconditionRequest::CabinPreconditionRequest(const CabinPreconditionRequest& from)
+HVACZone::HVACZone(const HVACZone& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
-  CabinPreconditionRequest* const _this = this; (void)_this;
+  HVACZone* const _this = this; (void)_this;
   new (&_impl_) Impl_{
-      decltype(_impl_.messageheader_){nullptr}
-    , decltype(_impl_.setacstatus_){nullptr}
-    , decltype(_impl_.settemp_){nullptr}
+      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_messageheader()) {
-    _this->_impl_.messageheader_ = new ::messages::VehicleMessageHeading(*from._impl_.messageheader_);
-  }
-  if (from._internal_has_setacstatus()) {
-    _this->_impl_.setacstatus_ = new ::messages::SetAcStatusRequest(*from._impl_.setacstatus_);
+  if (from._internal_has_target_temperature()) {
+    _this->_impl_.target_temperature_ = new ::messages::hvac::Temperature(*from._impl_.target_temperature_);
   }
-  if (from._internal_has_settemp()) {
-    _this->_impl_.settemp_ = new ::messages::SetTemperatureRequest(*from._impl_.settemp_);
-  }
-  // @@protoc_insertion_point(copy_constructor:messages.CabinPreconditionRequest)
+  _this->_impl_.zone_ = from._impl_.zone_;
+  // @@protoc_insertion_point(copy_constructor:messages.hvac.HVACZone)
 }
 
-inline void CabinPreconditionRequest::SharedCtor(::_pb::Arena* arena) {
+inline void HVACZone::SharedCtor(::_pb::Arena* arena) {
   (void)arena;
   new (&_impl_) Impl_{
-      decltype(_impl_.messageheader_){nullptr}
-    , decltype(_impl_.setacstatus_){nullptr}
-    , decltype(_impl_.settemp_){nullptr}
+      decltype(_impl_.target_temperature_){nullptr}
+    , decltype(_impl_.zone_) { 0 }
+
     , /*decltype(_impl_._cached_size_)*/{}
   };
 }
 
-CabinPreconditionRequest::~CabinPreconditionRequest() {
-  // @@protoc_insertion_point(destructor:messages.CabinPreconditionRequest)
+HVACZone::~HVACZone() {
+  // @@protoc_insertion_point(destructor:messages.hvac.HVACZone)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -362,66 +681,49 @@ CabinPreconditionRequest::~CabinPreconditionRequest() {
   SharedDtor();
 }
 
-inline void CabinPreconditionRequest::SharedDtor() {
+inline void HVACZone::SharedDtor() {
   ABSL_DCHECK(GetArenaForAllocation() == nullptr);
-  if (this != internal_default_instance()) delete _impl_.messageheader_;
-  if (this != internal_default_instance()) delete _impl_.setacstatus_;
-  if (this != internal_default_instance()) delete _impl_.settemp_;
+  if (this != internal_default_instance()) delete _impl_.target_temperature_;
 }
 
-void CabinPreconditionRequest::SetCachedSize(int size) const {
+void HVACZone::SetCachedSize(int size) const {
   _impl_._cached_size_.Set(size);
 }
 
-void CabinPreconditionRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:messages.CabinPreconditionRequest)
+void HVACZone::Clear() {
+// @@protoc_insertion_point(message_clear_start:messages.hvac.HVACZone)
   ::uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  if (GetArenaForAllocation() == nullptr && _impl_.messageheader_ != nullptr) {
-    delete _impl_.messageheader_;
-  }
-  _impl_.messageheader_ = nullptr;
-  if (GetArenaForAllocation() == nullptr && _impl_.setacstatus_ != nullptr) {
-    delete _impl_.setacstatus_;
+  if (GetArenaForAllocation() == nullptr && _impl_.target_temperature_ != nullptr) {
+    delete _impl_.target_temperature_;
   }
-  _impl_.setacstatus_ = nullptr;
-  if (GetArenaForAllocation() == nullptr && _impl_.settemp_ != nullptr) {
-    delete _impl_.settemp_;
-  }
-  _impl_.settemp_ = nullptr;
+  _impl_.target_temperature_ = nullptr;
+  _impl_.zone_ = 0;
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-const char* CabinPreconditionRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+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) {
-      // .messages.VehicleMessageHeading messageHeader = 1;
+      // .messages.hvac.HVACZone.Zone zone = 1;
       case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
-          ptr = ctx->ParseMessage(_internal_mutable_messageheader(), ptr);
+        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<::messages::hvac::HVACZone_Zone>(val));
         } else {
           goto handle_unusual;
         }
         continue;
-      // .messages.SetAcStatusRequest setAcStatus = 2;
+      // .messages.hvac.Temperature target_temperature = 2;
       case 2:
         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
-          ptr = ctx->ParseMessage(_internal_mutable_setacstatus(), ptr);
-          CHK_(ptr);
-        } else {
-          goto handle_unusual;
-        }
-        continue;
-      // .messages.SetTemperatureRequest setTemp = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
-          ptr = ctx->ParseMessage(_internal_mutable_settemp(), ptr);
+          ptr = ctx->ParseMessage(_internal_mutable_target_temperature(), ptr);
           CHK_(ptr);
         } else {
           goto handle_unusual;
@@ -450,196 +752,158 @@ failure:
 #undef CHK_
 }
 
-::uint8_t* CabinPreconditionRequest::_InternalSerialize(
+::uint8_t* HVACZone::_InternalSerialize(
     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:messages.CabinPreconditionRequest)
+  // @@protoc_insertion_point(serialize_to_array_start:messages.hvac.HVACZone)
   ::uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // .messages.VehicleMessageHeading messageHeader = 1;
-  if (this->_internal_has_messageheader()) {
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(1, _Internal::messageheader(this),
-        _Internal::messageheader(this).GetCachedSize(), target, stream);
-  }
-
-  // .messages.SetAcStatusRequest setAcStatus = 2;
-  if (this->_internal_has_setacstatus()) {
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(2, _Internal::setacstatus(this),
-        _Internal::setacstatus(this).GetCachedSize(), target, stream);
+  // .messages.hvac.HVACZone.Zone zone = 1;
+  if (this->_internal_zone() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::_pbi::WireFormatLite::WriteEnumToArray(
+        1, this->_internal_zone(), target);
   }
 
-  // .messages.SetTemperatureRequest setTemp = 3;
-  if (this->_internal_has_settemp()) {
+  // .messages.hvac.Temperature target_temperature = 2;
+  if (this->_internal_has_target_temperature()) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(3, _Internal::settemp(this),
-        _Internal::settemp(this).GetCachedSize(), target, stream);
+      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:messages.CabinPreconditionRequest)
+  // @@protoc_insertion_point(serialize_to_array_end:messages.hvac.HVACZone)
   return target;
 }
 
-::size_t CabinPreconditionRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:messages.CabinPreconditionRequest)
+::size_t HVACZone::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:messages.hvac.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;
 
-  // .messages.VehicleMessageHeading messageHeader = 1;
-  if (this->_internal_has_messageheader()) {
+  // .messages.hvac.Temperature target_temperature = 2;
+  if (this->_internal_has_target_temperature()) {
     total_size += 1 +
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *_impl_.messageheader_);
+        *_impl_.target_temperature_);
   }
 
-  // .messages.SetAcStatusRequest setAcStatus = 2;
-  if (this->_internal_has_setacstatus()) {
+  // .messages.hvac.HVACZone.Zone zone = 1;
+  if (this->_internal_zone() != 0) {
     total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *_impl_.setacstatus_);
-  }
-
-  // .messages.SetTemperatureRequest setTemp = 3;
-  if (this->_internal_has_settemp()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *_impl_.settemp_);
+                  ::_pbi::WireFormatLite::EnumSize(this->_internal_zone());
   }
 
   return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
 }
 
-const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CabinPreconditionRequest::_class_data_ = {
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HVACZone::_class_data_ = {
     ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
-    CabinPreconditionRequest::MergeImpl
+    HVACZone::MergeImpl
 };
-const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CabinPreconditionRequest::GetClassData() const { return &_class_data_; }
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HVACZone::GetClassData() const { return &_class_data_; }
 
 
-void CabinPreconditionRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
-  auto* const _this = static_cast<CabinPreconditionRequest*>(&to_msg);
-  auto& from = static_cast<const CabinPreconditionRequest&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:messages.CabinPreconditionRequest)
+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:messages.hvac.HVACZone)
   ABSL_DCHECK_NE(&from, _this);
   ::uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  if (from._internal_has_messageheader()) {
-    _this->_internal_mutable_messageheader()->::messages::VehicleMessageHeading::MergeFrom(
-        from._internal_messageheader());
+  if (from._internal_has_target_temperature()) {
+    _this->_internal_mutable_target_temperature()->::messages::hvac::Temperature::MergeFrom(
+        from._internal_target_temperature());
   }
-  if (from._internal_has_setacstatus()) {
-    _this->_internal_mutable_setacstatus()->::messages::SetAcStatusRequest::MergeFrom(
-        from._internal_setacstatus());
-  }
-  if (from._internal_has_settemp()) {
-    _this->_internal_mutable_settemp()->::messages::SetTemperatureRequest::MergeFrom(
-        from._internal_settemp());
+  if (from._internal_zone() != 0) {
+    _this->_internal_set_zone(from._internal_zone());
   }
   _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 }
 
-void CabinPreconditionRequest::CopyFrom(const CabinPreconditionRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:messages.CabinPreconditionRequest)
+void HVACZone::CopyFrom(const HVACZone& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:messages.hvac.HVACZone)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool CabinPreconditionRequest::IsInitialized() const {
+bool HVACZone::IsInitialized() const {
   return true;
 }
 
-void CabinPreconditionRequest::InternalSwap(CabinPreconditionRequest* other) {
+void HVACZone::InternalSwap(HVACZone* other) {
   using std::swap;
   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(CabinPreconditionRequest, _impl_.settemp_)
-      + sizeof(CabinPreconditionRequest::_impl_.settemp_)
-      - PROTOBUF_FIELD_OFFSET(CabinPreconditionRequest, _impl_.messageheader_)>(
-          reinterpret_cast<char*>(&_impl_.messageheader_),
-          reinterpret_cast<char*>(&other->_impl_.messageheader_));
+      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 CabinPreconditionRequest::GetMetadata() const {
+::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[0]);
+      file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[1]);
 }
 // ===================================================================
 
-class CabinPreConditionReponse::_Internal {
+class PreconditionRequest::_Internal {
  public:
-  static const ::messages::VehicleMessageHeading& messageheader(const CabinPreConditionReponse* msg);
-  static const ::messages::SetAcStatusReply& setacstatusreply(const CabinPreConditionReponse* msg);
-  static const ::messages::SetTemperatureReply& settemperaturereply(const CabinPreConditionReponse* msg);
+  static const ::PROTOBUF_NAMESPACE_ID::Timestamp& start_time(const PreconditionRequest* msg);
 };
 
-const ::messages::VehicleMessageHeading&
-CabinPreConditionReponse::_Internal::messageheader(const CabinPreConditionReponse* msg) {
-  return *msg->_impl_.messageheader_;
+const ::PROTOBUF_NAMESPACE_ID::Timestamp&
+PreconditionRequest::_Internal::start_time(const PreconditionRequest* msg) {
+  return *msg->_impl_.start_time_;
 }
-const ::messages::SetAcStatusReply&
-CabinPreConditionReponse::_Internal::setacstatusreply(const CabinPreConditionReponse* msg) {
-  return *msg->_impl_.setacstatusreply_;
-}
-const ::messages::SetTemperatureReply&
-CabinPreConditionReponse::_Internal::settemperaturereply(const CabinPreConditionReponse* msg) {
-  return *msg->_impl_.settemperaturereply_;
-}
-void CabinPreConditionReponse::clear_messageheader() {
-  if (GetArenaForAllocation() == nullptr && _impl_.messageheader_ != nullptr) {
-    delete _impl_.messageheader_;
+void PreconditionRequest::clear_start_time() {
+  if (GetArenaForAllocation() == nullptr && _impl_.start_time_ != nullptr) {
+    delete _impl_.start_time_;
   }
-  _impl_.messageheader_ = nullptr;
+  _impl_.start_time_ = nullptr;
 }
-CabinPreConditionReponse::CabinPreConditionReponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+PreconditionRequest::PreconditionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
   SharedCtor(arena);
-  // @@protoc_insertion_point(arena_constructor:messages.CabinPreConditionReponse)
+  // @@protoc_insertion_point(arena_constructor:messages.hvac.PreconditionRequest)
 }
-CabinPreConditionReponse::CabinPreConditionReponse(const CabinPreConditionReponse& from)
+PreconditionRequest::PreconditionRequest(const PreconditionRequest& from)
   : ::PROTOBUF_NAMESPACE_ID::Message() {
-  CabinPreConditionReponse* const _this = this; (void)_this;
+  PreconditionRequest* const _this = this; (void)_this;
   new (&_impl_) Impl_{
-      decltype(_impl_.messageheader_){nullptr}
-    , decltype(_impl_.setacstatusreply_){nullptr}
-    , decltype(_impl_.settemperaturereply_){nullptr}
+      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_messageheader()) {
-    _this->_impl_.messageheader_ = new ::messages::VehicleMessageHeading(*from._impl_.messageheader_);
-  }
-  if (from._internal_has_setacstatusreply()) {
-    _this->_impl_.setacstatusreply_ = new ::messages::SetAcStatusReply(*from._impl_.setacstatusreply_);
+  if (from._internal_has_start_time()) {
+    _this->_impl_.start_time_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.start_time_);
   }
-  if (from._internal_has_settemperaturereply()) {
-    _this->_impl_.settemperaturereply_ = new ::messages::SetTemperatureReply(*from._impl_.settemperaturereply_);
-  }
-  // @@protoc_insertion_point(copy_constructor:messages.CabinPreConditionReponse)
+  // @@protoc_insertion_point(copy_constructor:messages.hvac.PreconditionRequest)
 }
 
-inline void CabinPreConditionReponse::SharedCtor(::_pb::Arena* arena) {
+inline void PreconditionRequest::SharedCtor(::_pb::Arena* arena) {
   (void)arena;
   new (&_impl_) Impl_{
-      decltype(_impl_.messageheader_){nullptr}
-    , decltype(_impl_.setacstatusreply_){nullptr}
-    , decltype(_impl_.settemperaturereply_){nullptr}
+      decltype(_impl_.hvac_zones_){arena}
+    , decltype(_impl_.start_time_){nullptr}
     , /*decltype(_impl_._cached_size_)*/{}
   };
 }
 
-CabinPreConditionReponse::~CabinPreConditionReponse() {
-  // @@protoc_insertion_point(destructor:messages.CabinPreConditionReponse)
+PreconditionRequest::~PreconditionRequest() {
+  // @@protoc_insertion_point(destructor:messages.hvac.PreconditionRequest)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -647,66 +911,54 @@ CabinPreConditionReponse::~CabinPreConditionReponse() {
   SharedDtor();
 }
 
-inline void CabinPreConditionReponse::SharedDtor() {
+inline void PreconditionRequest::SharedDtor() {
   ABSL_DCHECK(GetArenaForAllocation() == nullptr);
-  if (this != internal_default_instance()) delete _impl_.messageheader_;
-  if (this != internal_default_instance()) delete _impl_.setacstatusreply_;
-  if (this != internal_default_instance()) delete _impl_.settemperaturereply_;
+  _impl_.hvac_zones_.~RepeatedPtrField();
+  if (this != internal_default_instance()) delete _impl_.start_time_;
 }
 
-void CabinPreConditionReponse::SetCachedSize(int size) const {
+void PreconditionRequest::SetCachedSize(int size) const {
   _impl_._cached_size_.Set(size);
 }
 
-void CabinPreConditionReponse::Clear() {
-// @@protoc_insertion_point(message_clear_start:messages.CabinPreConditionReponse)
+void PreconditionRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:messages.hvac.PreconditionRequest)
   ::uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  if (GetArenaForAllocation() == nullptr && _impl_.messageheader_ != nullptr) {
-    delete _impl_.messageheader_;
-  }
-  _impl_.messageheader_ = nullptr;
-  if (GetArenaForAllocation() == nullptr && _impl_.setacstatusreply_ != nullptr) {
-    delete _impl_.setacstatusreply_;
+  _impl_.hvac_zones_.Clear();
+  if (GetArenaForAllocation() == nullptr && _impl_.start_time_ != nullptr) {
+    delete _impl_.start_time_;
   }
-  _impl_.setacstatusreply_ = nullptr;
-  if (GetArenaForAllocation() == nullptr && _impl_.settemperaturereply_ != nullptr) {
-    delete _impl_.settemperaturereply_;
-  }
-  _impl_.settemperaturereply_ = nullptr;
+  _impl_.start_time_ = nullptr;
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-const char* CabinPreConditionReponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+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) {
-      // .messages.VehicleMessageHeading messageHeader = 1;
+      // repeated .messages.hvac.HVACZone hvac_zones = 1;
       case 1:
         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
-          ptr = ctx->ParseMessage(_internal_mutable_messageheader(), ptr);
-          CHK_(ptr);
+          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;
-      // .messages.SetAcStatusReply setAcStatusReply = 2;
+      // .google.protobuf.Timestamp start_time = 2;
       case 2:
         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
-          ptr = ctx->ParseMessage(_internal_mutable_setacstatusreply(), ptr);
-          CHK_(ptr);
-        } else {
-          goto handle_unusual;
-        }
-        continue;
-      // .messages.SetTemperatureReply setTemperatureReply = 3;
-      case 3:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
-          ptr = ctx->ParseMessage(_internal_mutable_settemperaturereply(), ptr);
+          ptr = ctx->ParseMessage(_internal_mutable_start_time(), ptr);
           CHK_(ptr);
         } else {
           goto handle_unusual;
@@ -735,159 +987,156 @@ failure:
 #undef CHK_
 }
 
-::uint8_t* CabinPreConditionReponse::_InternalSerialize(
+::uint8_t* PreconditionRequest::_InternalSerialize(
     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:messages.CabinPreConditionReponse)
+  // @@protoc_insertion_point(serialize_to_array_start:messages.hvac.PreconditionRequest)
   ::uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // .messages.VehicleMessageHeading messageHeader = 1;
-  if (this->_internal_has_messageheader()) {
-    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(1, _Internal::messageheader(this),
-        _Internal::messageheader(this).GetCachedSize(), target, stream);
-  }
-
-  // .messages.SetAcStatusReply setAcStatusReply = 2;
-  if (this->_internal_has_setacstatusreply()) {
+  // repeated .messages.hvac.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(2, _Internal::setacstatusreply(this),
-        _Internal::setacstatusreply(this).GetCachedSize(), target, stream);
+        InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
   }
 
-  // .messages.SetTemperatureReply setTemperatureReply = 3;
-  if (this->_internal_has_settemperaturereply()) {
+  // .google.protobuf.Timestamp start_time = 2;
+  if (this->_internal_has_start_time()) {
     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
-      InternalWriteMessage(3, _Internal::settemperaturereply(this),
-        _Internal::settemperaturereply(this).GetCachedSize(), target, stream);
+      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:messages.CabinPreConditionReponse)
+  // @@protoc_insertion_point(serialize_to_array_end:messages.hvac.PreconditionRequest)
   return target;
 }
 
-::size_t CabinPreConditionReponse::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:messages.CabinPreConditionReponse)
+::size_t PreconditionRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:messages.hvac.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;
 
-  // .messages.VehicleMessageHeading messageHeader = 1;
-  if (this->_internal_has_messageheader()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *_impl_.messageheader_);
-  }
-
-  // .messages.SetAcStatusReply setAcStatusReply = 2;
-  if (this->_internal_has_setacstatusreply()) {
-    total_size += 1 +
-      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *_impl_.setacstatusreply_);
+  // repeated .messages.hvac.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);
   }
 
-  // .messages.SetTemperatureReply setTemperatureReply = 3;
-  if (this->_internal_has_settemperaturereply()) {
+  // .google.protobuf.Timestamp start_time = 2;
+  if (this->_internal_has_start_time()) {
     total_size += 1 +
       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
-        *_impl_.settemperaturereply_);
+        *_impl_.start_time_);
   }
 
   return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
 }
 
-const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CabinPreConditionReponse::_class_data_ = {
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PreconditionRequest::_class_data_ = {
     ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
-    CabinPreConditionReponse::MergeImpl
+    PreconditionRequest::MergeImpl
 };
-const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CabinPreConditionReponse::GetClassData() const { return &_class_data_; }
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PreconditionRequest::GetClassData() const { return &_class_data_; }
 
 
-void CabinPreConditionReponse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
-  auto* const _this = static_cast<CabinPreConditionReponse*>(&to_msg);
-  auto& from = static_cast<const CabinPreConditionReponse&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:messages.CabinPreConditionReponse)
+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:messages.hvac.PreconditionRequest)
   ABSL_DCHECK_NE(&from, _this);
   ::uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  if (from._internal_has_messageheader()) {
-    _this->_internal_mutable_messageheader()->::messages::VehicleMessageHeading::MergeFrom(
-        from._internal_messageheader());
-  }
-  if (from._internal_has_setacstatusreply()) {
-    _this->_internal_mutable_setacstatusreply()->::messages::SetAcStatusReply::MergeFrom(
-        from._internal_setacstatusreply());
-  }
-  if (from._internal_has_settemperaturereply()) {
-    _this->_internal_mutable_settemperaturereply()->::messages::SetTemperatureReply::MergeFrom(
-        from._internal_settemperaturereply());
+  _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 CabinPreConditionReponse::CopyFrom(const CabinPreConditionReponse& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:messages.CabinPreConditionReponse)
+void PreconditionRequest::CopyFrom(const PreconditionRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:messages.hvac.PreconditionRequest)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool CabinPreConditionReponse::IsInitialized() const {
+bool PreconditionRequest::IsInitialized() const {
   return true;
 }
 
-void CabinPreConditionReponse::InternalSwap(CabinPreConditionReponse* other) {
+void PreconditionRequest::InternalSwap(PreconditionRequest* other) {
   using std::swap;
   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
-  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
-      PROTOBUF_FIELD_OFFSET(CabinPreConditionReponse, _impl_.settemperaturereply_)
-      + sizeof(CabinPreConditionReponse::_impl_.settemperaturereply_)
-      - PROTOBUF_FIELD_OFFSET(CabinPreConditionReponse, _impl_.messageheader_)>(
-          reinterpret_cast<char*>(&_impl_.messageheader_),
-          reinterpret_cast<char*>(&other->_impl_.messageheader_));
+  _impl_.hvac_zones_.InternalSwap(&other->_impl_.hvac_zones_);
+  swap(_impl_.start_time_, other->_impl_.start_time_);
 }
 
-::PROTOBUF_NAMESPACE_ID::Metadata CabinPreConditionReponse::GetMetadata() const {
+::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]);
+      file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[2]);
 }
 // ===================================================================
 
-class SetAcStatusRequest::_Internal {
+class PreconditionResponse::_Internal {
  public:
 };
 
-SetAcStatusRequest::SetAcStatusRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+PreconditionResponse::PreconditionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
   : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
   SharedCtor(arena);
-  // @@protoc_insertion_point(arena_constructor:messages.SetAcStatusRequest)
+  // @@protoc_insertion_point(arena_constructor:messages.hvac.PreconditionResponse)
 }
-SetAcStatusRequest::SetAcStatusRequest(const SetAcStatusRequest& from)
-  : ::PROTOBUF_NAMESPACE_ID::Message(), _impl_(from._impl_) {
-  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(
-      from._internal_metadata_);
-  // @@protoc_insertion_point(copy_constructor:messages.SetAcStatusRequest)
+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:messages.hvac.PreconditionResponse)
 }
 
-inline void SetAcStatusRequest::SharedCtor(::_pb::Arena* arena) {
+inline void PreconditionResponse::SharedCtor(::_pb::Arena* arena) {
   (void)arena;
   new (&_impl_) Impl_{
-      decltype(_impl_.desiredstatus_) { 0 }
+      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
 }
 
-SetAcStatusRequest::~SetAcStatusRequest() {
-  // @@protoc_insertion_point(destructor:messages.SetAcStatusRequest)
+PreconditionResponse::~PreconditionResponse() {
+  // @@protoc_insertion_point(destructor:messages.hvac.PreconditionResponse)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -895,36 +1144,49 @@ SetAcStatusRequest::~SetAcStatusRequest() {
   SharedDtor();
 }
 
-inline void SetAcStatusRequest::SharedDtor() {
+inline void PreconditionResponse::SharedDtor() {
   ABSL_DCHECK(GetArenaForAllocation() == nullptr);
+  _impl_.message_.Destroy();
 }
 
-void SetAcStatusRequest::SetCachedSize(int size) const {
+void PreconditionResponse::SetCachedSize(int size) const {
   _impl_._cached_size_.Set(size);
 }
 
-void SetAcStatusRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:messages.SetAcStatusRequest)
+void PreconditionResponse::Clear() {
+// @@protoc_insertion_point(message_clear_start:messages.hvac.PreconditionResponse)
   ::uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  _impl_.desiredstatus_ = 0;
+  _impl_.message_.ClearToEmpty();
+  _impl_.status_ = 0;
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
-const char* SetAcStatusRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+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) {
-      // .messages.AcStatusEnum desiredStatus = 1;
+      // .messages.hvac.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_desiredstatus(static_cast<::messages::AcStatusEnum>(val));
+          _internal_set_status(static_cast<::messages::hvac::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, "messages.hvac.PreconditionResponse.message"));
         } else {
           goto handle_unusual;
         }
@@ -952,116 +1214,153 @@ failure:
 #undef CHK_
 }
 
-::uint8_t* SetAcStatusRequest::_InternalSerialize(
+::uint8_t* PreconditionResponse::_InternalSerialize(
     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:messages.SetAcStatusRequest)
+  // @@protoc_insertion_point(serialize_to_array_start:messages.hvac.PreconditionResponse)
   ::uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // .messages.AcStatusEnum desiredStatus = 1;
-  if (this->_internal_desiredstatus() != 0) {
+  // .messages.hvac.PreconditionResponse.Status status = 1;
+  if (this->_internal_status() != 0) {
     target = stream->EnsureSpace(target);
     target = ::_pbi::WireFormatLite::WriteEnumToArray(
-        1, this->_internal_desiredstatus(), target);
+        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, "messages.hvac.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:messages.SetAcStatusRequest)
+  // @@protoc_insertion_point(serialize_to_array_end:messages.hvac.PreconditionResponse)
   return target;
 }
 
-::size_t SetAcStatusRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:messages.SetAcStatusRequest)
+::size_t PreconditionResponse::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:messages.hvac.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;
 
-  // .messages.AcStatusEnum desiredStatus = 1;
-  if (this->_internal_desiredstatus() != 0) {
+  // string message = 2;
+  if (!this->_internal_message().empty()) {
+    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+                                    this->_internal_message());
+  }
+
+  // .messages.hvac.PreconditionResponse.Status status = 1;
+  if (this->_internal_status() != 0) {
     total_size += 1 +
-                  ::_pbi::WireFormatLite::EnumSize(this->_internal_desiredstatus());
+                  ::_pbi::WireFormatLite::EnumSize(this->_internal_status());
   }
 
   return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
 }
 
-const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SetAcStatusRequest::_class_data_ = {
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PreconditionResponse::_class_data_ = {
     ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
-    SetAcStatusRequest::MergeImpl
+    PreconditionResponse::MergeImpl
 };
-const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SetAcStatusRequest::GetClassData() const { return &_class_data_; }
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PreconditionResponse::GetClassData() const { return &_class_data_; }
 
 
-void SetAcStatusRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
-  auto* const _this = static_cast<SetAcStatusRequest*>(&to_msg);
-  auto& from = static_cast<const SetAcStatusRequest&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:messages.SetAcStatusRequest)
+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:messages.hvac.PreconditionResponse)
   ABSL_DCHECK_NE(&from, _this);
   ::uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  if (from._internal_desiredstatus() != 0) {
-    _this->_internal_set_desiredstatus(from._internal_desiredstatus());
+  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 SetAcStatusRequest::CopyFrom(const SetAcStatusRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:messages.SetAcStatusRequest)
+void PreconditionResponse::CopyFrom(const PreconditionResponse& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:messages.hvac.PreconditionResponse)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool SetAcStatusRequest::IsInitialized() const {
+bool PreconditionResponse::IsInitialized() const {
   return true;
 }
 
-void SetAcStatusRequest::InternalSwap(SetAcStatusRequest* other) {
+void PreconditionResponse::InternalSwap(PreconditionResponse* other) {
   using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
-  swap(_impl_.desiredstatus_, other->_impl_.desiredstatus_);
+  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.message_, lhs_arena,
+                                       &other->_impl_.message_, rhs_arena);
+  swap(_impl_.status_, other->_impl_.status_);
 }
 
-::PROTOBUF_NAMESPACE_ID::Metadata SetAcStatusRequest::GetMetadata() const {
+::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]);
+      file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[3]);
 }
 // ===================================================================
 
-class SetAcStatusReply::_Internal {
+class HVACState::_Internal {
  public:
+  static const ::messages::hvac::HVACZone& current_zone(const HVACState* msg);
 };
 
-SetAcStatusReply::SetAcStatusReply(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+const ::messages::hvac::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:messages.SetAcStatusReply)
+  // @@protoc_insertion_point(arena_constructor:messages.hvac.HVACState)
 }
-SetAcStatusReply::SetAcStatusReply(const SetAcStatusReply& from)
-  : ::PROTOBUF_NAMESPACE_ID::Message(), _impl_(from._impl_) {
-  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(
-      from._internal_metadata_);
-  // @@protoc_insertion_point(copy_constructor:messages.SetAcStatusReply)
+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 ::messages::hvac::HVACZone(*from._impl_.current_zone_);
+  }
+  _this->_impl_.state_ = from._impl_.state_;
+  // @@protoc_insertion_point(copy_constructor:messages.hvac.HVACState)
 }
 
-inline void SetAcStatusReply::SharedCtor(::_pb::Arena* arena) {
+inline void HVACState::SharedCtor(::_pb::Arena* arena) {
   (void)arena;
   new (&_impl_) Impl_{
-      decltype(_impl_.status_) { 0 }
+      decltype(_impl_.current_zone_){nullptr}
+    , decltype(_impl_.state_) { 0 }
 
     , /*decltype(_impl_._cached_size_)*/{}
   };
 }
 
-SetAcStatusReply::~SetAcStatusReply() {
-  // @@protoc_insertion_point(destructor:messages.SetAcStatusReply)
+HVACState::~HVACState() {
+  // @@protoc_insertion_point(destructor:messages.hvac.HVACState)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -1069,36 +1368,50 @@ SetAcStatusReply::~SetAcStatusReply() {
   SharedDtor();
 }
 
-inline void SetAcStatusReply::SharedDtor() {
+inline void HVACState::SharedDtor() {
   ABSL_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete _impl_.current_zone_;
 }
 
-void SetAcStatusReply::SetCachedSize(int size) const {
+void HVACState::SetCachedSize(int size) const {
   _impl_._cached_size_.Set(size);
 }
 
-void SetAcStatusReply::Clear() {
-// @@protoc_insertion_point(message_clear_start:messages.SetAcStatusReply)
+void HVACState::Clear() {
+// @@protoc_insertion_point(message_clear_start:messages.hvac.HVACState)
   ::uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  _impl_.status_ = 0;
+  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* SetAcStatusReply::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+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) {
-      // .messages.AcStatusEnum status = 1;
+      // .messages.hvac.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_status(static_cast<::messages::AcStatusEnum>(val));
+          _internal_set_state(static_cast<::messages::hvac::HVACState_State>(val));
+        } else {
+          goto handle_unusual;
+        }
+        continue;
+      // .messages.hvac.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;
         }
@@ -1126,116 +1439,160 @@ failure:
 #undef CHK_
 }
 
-::uint8_t* SetAcStatusReply::_InternalSerialize(
+::uint8_t* HVACState::_InternalSerialize(
     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:messages.SetAcStatusReply)
+  // @@protoc_insertion_point(serialize_to_array_start:messages.hvac.HVACState)
   ::uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // .messages.AcStatusEnum status = 1;
-  if (this->_internal_status() != 0) {
+  // .messages.hvac.HVACState.State state = 1;
+  if (this->_internal_state() != 0) {
     target = stream->EnsureSpace(target);
     target = ::_pbi::WireFormatLite::WriteEnumToArray(
-        1, this->_internal_status(), target);
+        1, this->_internal_state(), target);
+  }
+
+  // .messages.hvac.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:messages.SetAcStatusReply)
+  // @@protoc_insertion_point(serialize_to_array_end:messages.hvac.HVACState)
   return target;
 }
 
-::size_t SetAcStatusReply::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:messages.SetAcStatusReply)
+::size_t HVACState::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:messages.hvac.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;
 
-  // .messages.AcStatusEnum status = 1;
-  if (this->_internal_status() != 0) {
+  // .messages.hvac.HVACZone current_zone = 2;
+  if (this->_internal_has_current_zone()) {
     total_size += 1 +
-                  ::_pbi::WireFormatLite::EnumSize(this->_internal_status());
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.current_zone_);
+  }
+
+  // .messages.hvac.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 SetAcStatusReply::_class_data_ = {
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HVACState::_class_data_ = {
     ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
-    SetAcStatusReply::MergeImpl
+    HVACState::MergeImpl
 };
-const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SetAcStatusReply::GetClassData() const { return &_class_data_; }
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HVACState::GetClassData() const { return &_class_data_; }
 
 
-void SetAcStatusReply::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
-  auto* const _this = static_cast<SetAcStatusReply*>(&to_msg);
-  auto& from = static_cast<const SetAcStatusReply&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:messages.SetAcStatusReply)
+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:messages.hvac.HVACState)
   ABSL_DCHECK_NE(&from, _this);
   ::uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  if (from._internal_status() != 0) {
-    _this->_internal_set_status(from._internal_status());
+  if (from._internal_has_current_zone()) {
+    _this->_internal_mutable_current_zone()->::messages::hvac::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 SetAcStatusReply::CopyFrom(const SetAcStatusReply& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:messages.SetAcStatusReply)
+void HVACState::CopyFrom(const HVACState& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:messages.hvac.HVACState)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool SetAcStatusReply::IsInitialized() const {
+bool HVACState::IsInitialized() const {
   return true;
 }
 
-void SetAcStatusReply::InternalSwap(SetAcStatusReply* other) {
+void HVACState::InternalSwap(HVACState* other) {
   using std::swap;
   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
-  swap(_impl_.status_, other->_impl_.status_);
+  ::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 SetAcStatusReply::GetMetadata() const {
+::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[3]);
+      file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[4]);
 }
 // ===================================================================
 
-class SetTemperatureRequest::_Internal {
+class CabinTemperature::_Internal {
  public:
+  static const ::messages::hvac::Temperature& temperature(const CabinTemperature* msg);
+  static const ::messages::hvac::HVACZone& zone(const CabinTemperature* msg);
 };
 
-SetTemperatureRequest::SetTemperatureRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+const ::messages::hvac::Temperature&
+CabinTemperature::_Internal::temperature(const CabinTemperature* msg) {
+  return *msg->_impl_.temperature_;
+}
+const ::messages::hvac::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:messages.SetTemperatureRequest)
+  // @@protoc_insertion_point(arena_constructor:messages.hvac.CabinTemperature)
 }
-SetTemperatureRequest::SetTemperatureRequest(const SetTemperatureRequest& from)
-  : ::PROTOBUF_NAMESPACE_ID::Message(), _impl_(from._impl_) {
-  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(
-      from._internal_metadata_);
-  // @@protoc_insertion_point(copy_constructor:messages.SetTemperatureRequest)
+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 ::messages::hvac::Temperature(*from._impl_.temperature_);
+  }
+  if (from._internal_has_zone()) {
+    _this->_impl_.zone_ = new ::messages::hvac::HVACZone(*from._impl_.zone_);
+  }
+  // @@protoc_insertion_point(copy_constructor:messages.hvac.CabinTemperature)
 }
 
-inline void SetTemperatureRequest::SharedCtor(::_pb::Arena* arena) {
+inline void CabinTemperature::SharedCtor(::_pb::Arena* arena) {
   (void)arena;
   new (&_impl_) Impl_{
-      decltype(_impl_.temperature_) { 0 }
-
+      decltype(_impl_.temperature_){nullptr}
+    , decltype(_impl_.zone_){nullptr}
     , /*decltype(_impl_._cached_size_)*/{}
   };
 }
 
-SetTemperatureRequest::~SetTemperatureRequest() {
-  // @@protoc_insertion_point(destructor:messages.SetTemperatureRequest)
+CabinTemperature::~CabinTemperature() {
+  // @@protoc_insertion_point(destructor:messages.hvac.CabinTemperature)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -1243,35 +1600,53 @@ SetTemperatureRequest::~SetTemperatureRequest() {
   SharedDtor();
 }
 
-inline void SetTemperatureRequest::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 SetTemperatureRequest::SetCachedSize(int size) const {
+void CabinTemperature::SetCachedSize(int size) const {
   _impl_._cached_size_.Set(size);
 }
 
-void SetTemperatureRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:messages.SetTemperatureRequest)
+void CabinTemperature::Clear() {
+// @@protoc_insertion_point(message_clear_start:messages.hvac.CabinTemperature)
   ::uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  _impl_.temperature_ = 0;
+  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* SetTemperatureRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+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) {
-      // float temperature = 1;
+      // .messages.hvac.Temperature temperature = 1;
       case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 13)) {
-          _impl_.temperature_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
-          ptr += sizeof(float);
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_temperature(), ptr);
+          CHK_(ptr);
+        } else {
+          goto handle_unusual;
+        }
+        continue;
+      // .messages.hvac.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;
         }
@@ -1299,128 +1674,178 @@ failure:
 #undef CHK_
 }
 
-::uint8_t* SetTemperatureRequest::_InternalSerialize(
+::uint8_t* CabinTemperature::_InternalSerialize(
     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:messages.SetTemperatureRequest)
+  // @@protoc_insertion_point(serialize_to_array_start:messages.hvac.CabinTemperature)
   ::uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // float temperature = 1;
-  static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size.");
-  float tmp_temperature = this->_internal_temperature();
-  ::uint32_t raw_temperature;
-  memcpy(&raw_temperature, &tmp_temperature, sizeof(tmp_temperature));
-  if (raw_temperature != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::_pbi::WireFormatLite::WriteFloatToArray(
-        1, this->_internal_temperature(), target);
+  // .messages.hvac.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);
+  }
+
+  // .messages.hvac.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:messages.SetTemperatureRequest)
+  // @@protoc_insertion_point(serialize_to_array_end:messages.hvac.CabinTemperature)
   return target;
 }
 
-::size_t SetTemperatureRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:messages.SetTemperatureRequest)
+::size_t CabinTemperature::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:messages.hvac.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;
 
-  // float temperature = 1;
-  static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size.");
-  float tmp_temperature = this->_internal_temperature();
-  ::uint32_t raw_temperature;
-  memcpy(&raw_temperature, &tmp_temperature, sizeof(tmp_temperature));
-  if (raw_temperature != 0) {
-    total_size += 5;
+  // .messages.hvac.Temperature temperature = 1;
+  if (this->_internal_has_temperature()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.temperature_);
+  }
+
+  // .messages.hvac.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 SetTemperatureRequest::_class_data_ = {
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CabinTemperature::_class_data_ = {
     ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
-    SetTemperatureRequest::MergeImpl
+    CabinTemperature::MergeImpl
 };
-const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SetTemperatureRequest::GetClassData() const { return &_class_data_; }
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CabinTemperature::GetClassData() const { return &_class_data_; }
 
 
-void SetTemperatureRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
-  auto* const _this = static_cast<SetTemperatureRequest*>(&to_msg);
-  auto& from = static_cast<const SetTemperatureRequest&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:messages.SetTemperatureRequest)
+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:messages.hvac.CabinTemperature)
   ABSL_DCHECK_NE(&from, _this);
   ::uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size.");
-  float tmp_temperature = from._internal_temperature();
-  ::uint32_t raw_temperature;
-  memcpy(&raw_temperature, &tmp_temperature, sizeof(tmp_temperature));
-  if (raw_temperature != 0) {
-    _this->_internal_set_temperature(from._internal_temperature());
+  if (from._internal_has_temperature()) {
+    _this->_internal_mutable_temperature()->::messages::hvac::Temperature::MergeFrom(
+        from._internal_temperature());
+  }
+  if (from._internal_has_zone()) {
+    _this->_internal_mutable_zone()->::messages::hvac::HVACZone::MergeFrom(
+        from._internal_zone());
   }
   _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 }
 
-void SetTemperatureRequest::CopyFrom(const SetTemperatureRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:messages.SetTemperatureRequest)
+void CabinTemperature::CopyFrom(const CabinTemperature& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:messages.hvac.CabinTemperature)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool SetTemperatureRequest::IsInitialized() const {
+bool CabinTemperature::IsInitialized() const {
   return true;
 }
 
-void SetTemperatureRequest::InternalSwap(SetTemperatureRequest* other) {
+void CabinTemperature::InternalSwap(CabinTemperature* other) {
   using std::swap;
   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
-
-  swap(_impl_.temperature_, other->_impl_.temperature_);
+  ::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 SetTemperatureRequest::GetMetadata() const {
+::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[4]);
+      file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[5]);
 }
 // ===================================================================
 
-class SetTemperatureReply::_Internal {
+class CabinConditionStatusPublish::_Internal {
  public:
+  static const ::PROTOBUF_NAMESPACE_ID::Timestamp& event_time(const CabinConditionStatusPublish* msg);
+  static const ::messages::hvac::HVACState& hvac_state(const CabinConditionStatusPublish* msg);
+  static const ::messages::hvac::CabinTemperature& cabin_temperature(const CabinConditionStatusPublish* msg);
 };
 
-SetTemperatureReply::SetTemperatureReply(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+const ::PROTOBUF_NAMESPACE_ID::Timestamp&
+CabinConditionStatusPublish::_Internal::event_time(const CabinConditionStatusPublish* msg) {
+  return *msg->_impl_.event_time_;
+}
+const ::messages::hvac::HVACState&
+CabinConditionStatusPublish::_Internal::hvac_state(const CabinConditionStatusPublish* msg) {
+  return *msg->_impl_.hvac_state_;
+}
+const ::messages::hvac::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:messages.SetTemperatureReply)
+  // @@protoc_insertion_point(arena_constructor:messages.hvac.CabinConditionStatusPublish)
 }
-SetTemperatureReply::SetTemperatureReply(const SetTemperatureReply& from)
-  : ::PROTOBUF_NAMESPACE_ID::Message(), _impl_(from._impl_) {
-  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(
-      from._internal_metadata_);
-  // @@protoc_insertion_point(copy_constructor:messages.SetTemperatureReply)
+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 ::messages::hvac::HVACState(*from._impl_.hvac_state_);
+  }
+  if (from._internal_has_cabin_temperature()) {
+    _this->_impl_.cabin_temperature_ = new ::messages::hvac::CabinTemperature(*from._impl_.cabin_temperature_);
+  }
+  // @@protoc_insertion_point(copy_constructor:messages.hvac.CabinConditionStatusPublish)
 }
 
-inline void SetTemperatureReply::SharedCtor(::_pb::Arena* arena) {
+inline void CabinConditionStatusPublish::SharedCtor(::_pb::Arena* arena) {
   (void)arena;
   new (&_impl_) Impl_{
-      decltype(_impl_.tempstatus_) { 0 }
-
+      decltype(_impl_.event_time_){nullptr}
+    , decltype(_impl_.hvac_state_){nullptr}
+    , decltype(_impl_.cabin_temperature_){nullptr}
     , /*decltype(_impl_._cached_size_)*/{}
   };
 }
 
-SetTemperatureReply::~SetTemperatureReply() {
-  // @@protoc_insertion_point(destructor:messages.SetTemperatureReply)
+CabinConditionStatusPublish::~CabinConditionStatusPublish() {
+  // @@protoc_insertion_point(destructor:messages.hvac.CabinConditionStatusPublish)
   if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
   (void)arena;
     return;
@@ -1428,36 +1853,67 @@ SetTemperatureReply::~SetTemperatureReply() {
   SharedDtor();
 }
 
-inline void SetTemperatureReply::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 SetTemperatureReply::SetCachedSize(int size) const {
+void CabinConditionStatusPublish::SetCachedSize(int size) const {
   _impl_._cached_size_.Set(size);
 }
 
-void SetTemperatureReply::Clear() {
-// @@protoc_insertion_point(message_clear_start:messages.SetTemperatureReply)
+void CabinConditionStatusPublish::Clear() {
+// @@protoc_insertion_point(message_clear_start:messages.hvac.CabinConditionStatusPublish)
   ::uint32_t cached_has_bits = 0;
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  _impl_.tempstatus_ = 0;
+  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* SetTemperatureReply::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
+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) {
-      // .messages.SetTempStatusEnum tempStatus = 1;
+      // .google.protobuf.Timestamp event_time = 1;
       case 1:
-        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
-          ::uint32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+        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;
+      // .messages.hvac.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;
+      // .messages.hvac.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);
-          _internal_set_tempstatus(static_cast<::messages::SetTempStatusEnum>(val));
         } else {
           goto handle_unusual;
         }
@@ -1485,113 +1941,161 @@ failure:
 #undef CHK_
 }
 
-::uint8_t* SetTemperatureReply::_InternalSerialize(
+::uint8_t* CabinConditionStatusPublish::_InternalSerialize(
     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
-  // @@protoc_insertion_point(serialize_to_array_start:messages.SetTemperatureReply)
+  // @@protoc_insertion_point(serialize_to_array_start:messages.hvac.CabinConditionStatusPublish)
   ::uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  // .messages.SetTempStatusEnum tempStatus = 1;
-  if (this->_internal_tempstatus() != 0) {
-    target = stream->EnsureSpace(target);
-    target = ::_pbi::WireFormatLite::WriteEnumToArray(
-        1, this->_internal_tempstatus(), target);
+  // .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);
+  }
+
+  // .messages.hvac.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);
+  }
+
+  // .messages.hvac.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:messages.SetTemperatureReply)
+  // @@protoc_insertion_point(serialize_to_array_end:messages.hvac.CabinConditionStatusPublish)
   return target;
 }
 
-::size_t SetTemperatureReply::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:messages.SetTemperatureReply)
+::size_t CabinConditionStatusPublish::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:messages.hvac.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;
 
-  // .messages.SetTempStatusEnum tempStatus = 1;
-  if (this->_internal_tempstatus() != 0) {
+  // .google.protobuf.Timestamp event_time = 1;
+  if (this->_internal_has_event_time()) {
     total_size += 1 +
-                  ::_pbi::WireFormatLite::EnumSize(this->_internal_tempstatus());
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.event_time_);
+  }
+
+  // .messages.hvac.HVACState hvac_state = 2;
+  if (this->_internal_has_hvac_state()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *_impl_.hvac_state_);
+  }
+
+  // .messages.hvac.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 SetTemperatureReply::_class_data_ = {
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CabinConditionStatusPublish::_class_data_ = {
     ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
-    SetTemperatureReply::MergeImpl
+    CabinConditionStatusPublish::MergeImpl
 };
-const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SetTemperatureReply::GetClassData() const { return &_class_data_; }
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CabinConditionStatusPublish::GetClassData() const { return &_class_data_; }
 
 
-void SetTemperatureReply::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
-  auto* const _this = static_cast<SetTemperatureReply*>(&to_msg);
-  auto& from = static_cast<const SetTemperatureReply&>(from_msg);
-  // @@protoc_insertion_point(class_specific_merge_from_start:messages.SetTemperatureReply)
+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:messages.hvac.CabinConditionStatusPublish)
   ABSL_DCHECK_NE(&from, _this);
   ::uint32_t cached_has_bits = 0;
   (void) cached_has_bits;
 
-  if (from._internal_tempstatus() != 0) {
-    _this->_internal_set_tempstatus(from._internal_tempstatus());
+  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()->::messages::hvac::HVACState::MergeFrom(
+        from._internal_hvac_state());
+  }
+  if (from._internal_has_cabin_temperature()) {
+    _this->_internal_mutable_cabin_temperature()->::messages::hvac::CabinTemperature::MergeFrom(
+        from._internal_cabin_temperature());
   }
   _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
 }
 
-void SetTemperatureReply::CopyFrom(const SetTemperatureReply& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:messages.SetTemperatureReply)
+void CabinConditionStatusPublish::CopyFrom(const CabinConditionStatusPublish& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:messages.hvac.CabinConditionStatusPublish)
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool SetTemperatureReply::IsInitialized() const {
+bool CabinConditionStatusPublish::IsInitialized() const {
   return true;
 }
 
-void SetTemperatureReply::InternalSwap(SetTemperatureReply* other) {
+void CabinConditionStatusPublish::InternalSwap(CabinConditionStatusPublish* other) {
   using std::swap;
   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
-  swap(_impl_.tempstatus_, other->_impl_.tempstatus_);
+  ::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 SetTemperatureReply::GetMetadata() const {
+::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[5]);
+      file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[6]);
 }
 // @@protoc_insertion_point(namespace_scope)
+}  // namespace hvac
 }  // namespace messages
 PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_NOINLINE ::messages::CabinPreconditionRequest*
-Arena::CreateMaybeMessage< ::messages::CabinPreconditionRequest >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::messages::CabinPreconditionRequest >(arena);
+template<> PROTOBUF_NOINLINE ::messages::hvac::Temperature*
+Arena::CreateMaybeMessage< ::messages::hvac::Temperature >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::messages::hvac::Temperature >(arena);
+}
+template<> PROTOBUF_NOINLINE ::messages::hvac::HVACZone*
+Arena::CreateMaybeMessage< ::messages::hvac::HVACZone >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::messages::hvac::HVACZone >(arena);
 }
-template<> PROTOBUF_NOINLINE ::messages::CabinPreConditionReponse*
-Arena::CreateMaybeMessage< ::messages::CabinPreConditionReponse >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::messages::CabinPreConditionReponse >(arena);
+template<> PROTOBUF_NOINLINE ::messages::hvac::PreconditionRequest*
+Arena::CreateMaybeMessage< ::messages::hvac::PreconditionRequest >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::messages::hvac::PreconditionRequest >(arena);
 }
-template<> PROTOBUF_NOINLINE ::messages::SetAcStatusRequest*
-Arena::CreateMaybeMessage< ::messages::SetAcStatusRequest >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::messages::SetAcStatusRequest >(arena);
+template<> PROTOBUF_NOINLINE ::messages::hvac::PreconditionResponse*
+Arena::CreateMaybeMessage< ::messages::hvac::PreconditionResponse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::messages::hvac::PreconditionResponse >(arena);
 }
-template<> PROTOBUF_NOINLINE ::messages::SetAcStatusReply*
-Arena::CreateMaybeMessage< ::messages::SetAcStatusReply >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::messages::SetAcStatusReply >(arena);
+template<> PROTOBUF_NOINLINE ::messages::hvac::HVACState*
+Arena::CreateMaybeMessage< ::messages::hvac::HVACState >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::messages::hvac::HVACState >(arena);
 }
-template<> PROTOBUF_NOINLINE ::messages::SetTemperatureRequest*
-Arena::CreateMaybeMessage< ::messages::SetTemperatureRequest >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::messages::SetTemperatureRequest >(arena);
+template<> PROTOBUF_NOINLINE ::messages::hvac::CabinTemperature*
+Arena::CreateMaybeMessage< ::messages::hvac::CabinTemperature >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::messages::hvac::CabinTemperature >(arena);
 }
-template<> PROTOBUF_NOINLINE ::messages::SetTemperatureReply*
-Arena::CreateMaybeMessage< ::messages::SetTemperatureReply >(Arena* arena) {
-  return Arena::CreateMessageInternal< ::messages::SetTemperatureReply >(arena);
+template<> PROTOBUF_NOINLINE ::messages::hvac::CabinConditionStatusPublish*
+Arena::CreateMaybeMessage< ::messages::hvac::CabinConditionStatusPublish >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::messages::hvac::CabinConditionStatusPublish >(arena);
 }
 PROTOBUF_NAMESPACE_CLOSE
 // @@protoc_insertion_point(global_scope)
diff --git a/build/generated/source/proto/main/cpp/messages/VehicleRemoteHvac.pb.h b/build/generated/source/proto/main/cpp/messages/VehicleRemoteHvac.pb.h
index af50b78..c65ed7a 100644
--- a/build/generated/source/proto/main/cpp/messages/VehicleRemoteHvac.pb.h
+++ b/build/generated/source/proto/main/cpp/messages/VehicleRemoteHvac.pb.h
@@ -32,8 +32,7 @@
 #include "google/protobuf/extension_set.h"  // IWYU pragma: export
 #include "google/protobuf/generated_enum_reflection.h"
 #include "google/protobuf/unknown_field_set.h"
-#include "vss/vspec.pb.h"
-#include "messages/VehicleMessageHeader.pb.h"
+#include "google/protobuf/timestamp.pb.h"
 // @@protoc_insertion_point(includes)
 
 // Must be included last.
@@ -54,105 +53,149 @@ struct TableStruct_messages_2fVehicleRemoteHvac_2eproto {
 extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable
     descriptor_table_messages_2fVehicleRemoteHvac_2eproto;
 namespace messages {
-class CabinPreConditionReponse;
-struct CabinPreConditionReponseDefaultTypeInternal;
-extern CabinPreConditionReponseDefaultTypeInternal _CabinPreConditionReponse_default_instance_;
-class CabinPreconditionRequest;
-struct CabinPreconditionRequestDefaultTypeInternal;
-extern CabinPreconditionRequestDefaultTypeInternal _CabinPreconditionRequest_default_instance_;
-class SetAcStatusReply;
-struct SetAcStatusReplyDefaultTypeInternal;
-extern SetAcStatusReplyDefaultTypeInternal _SetAcStatusReply_default_instance_;
-class SetAcStatusRequest;
-struct SetAcStatusRequestDefaultTypeInternal;
-extern SetAcStatusRequestDefaultTypeInternal _SetAcStatusRequest_default_instance_;
-class SetTemperatureReply;
-struct SetTemperatureReplyDefaultTypeInternal;
-extern SetTemperatureReplyDefaultTypeInternal _SetTemperatureReply_default_instance_;
-class SetTemperatureRequest;
-struct SetTemperatureRequestDefaultTypeInternal;
-extern SetTemperatureRequestDefaultTypeInternal _SetTemperatureRequest_default_instance_;
+namespace hvac {
+class CabinConditionStatusPublish;
+struct CabinConditionStatusPublishDefaultTypeInternal;
+extern CabinConditionStatusPublishDefaultTypeInternal _CabinConditionStatusPublish_default_instance_;
+class CabinTemperature;
+struct CabinTemperatureDefaultTypeInternal;
+extern CabinTemperatureDefaultTypeInternal _CabinTemperature_default_instance_;
+class HVACState;
+struct HVACStateDefaultTypeInternal;
+extern HVACStateDefaultTypeInternal _HVACState_default_instance_;
+class HVACZone;
+struct HVACZoneDefaultTypeInternal;
+extern HVACZoneDefaultTypeInternal _HVACZone_default_instance_;
+class PreconditionRequest;
+struct PreconditionRequestDefaultTypeInternal;
+extern PreconditionRequestDefaultTypeInternal _PreconditionRequest_default_instance_;
+class PreconditionResponse;
+struct PreconditionResponseDefaultTypeInternal;
+extern PreconditionResponseDefaultTypeInternal _PreconditionResponse_default_instance_;
+class Temperature;
+struct TemperatureDefaultTypeInternal;
+extern TemperatureDefaultTypeInternal _Temperature_default_instance_;
+}  // namespace hvac
 }  // namespace messages
 PROTOBUF_NAMESPACE_OPEN
 template <>
-::messages::CabinPreConditionReponse* Arena::CreateMaybeMessage<::messages::CabinPreConditionReponse>(Arena*);
+::messages::hvac::CabinConditionStatusPublish* Arena::CreateMaybeMessage<::messages::hvac::CabinConditionStatusPublish>(Arena*);
 template <>
-::messages::CabinPreconditionRequest* Arena::CreateMaybeMessage<::messages::CabinPreconditionRequest>(Arena*);
+::messages::hvac::CabinTemperature* Arena::CreateMaybeMessage<::messages::hvac::CabinTemperature>(Arena*);
 template <>
-::messages::SetAcStatusReply* Arena::CreateMaybeMessage<::messages::SetAcStatusReply>(Arena*);
+::messages::hvac::HVACState* Arena::CreateMaybeMessage<::messages::hvac::HVACState>(Arena*);
 template <>
-::messages::SetAcStatusRequest* Arena::CreateMaybeMessage<::messages::SetAcStatusRequest>(Arena*);
+::messages::hvac::HVACZone* Arena::CreateMaybeMessage<::messages::hvac::HVACZone>(Arena*);
 template <>
-::messages::SetTemperatureReply* Arena::CreateMaybeMessage<::messages::SetTemperatureReply>(Arena*);
+::messages::hvac::PreconditionRequest* Arena::CreateMaybeMessage<::messages::hvac::PreconditionRequest>(Arena*);
 template <>
-::messages::SetTemperatureRequest* Arena::CreateMaybeMessage<::messages::SetTemperatureRequest>(Arena*);
+::messages::hvac::PreconditionResponse* Arena::CreateMaybeMessage<::messages::hvac::PreconditionResponse>(Arena*);
+template <>
+::messages::hvac::Temperature* Arena::CreateMaybeMessage<::messages::hvac::Temperature>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
 
 namespace messages {
-enum AcStatusEnum : int {
-  ON = 0,
-  OFF = 1,
-  UKNONWN_ERROR = 2,
-  AcStatusEnum_INT_MIN_SENTINEL_DO_NOT_USE_ =
+namespace hvac {
+enum HVACZone_Zone : int {
+  HVACZone_Zone_DRIVER = 0,
+  HVACZone_Zone_PASSENGER = 1,
+  HVACZone_Zone_REAR_LEFT = 2,
+  HVACZone_Zone_REAR_RIGHT = 3,
+  HVACZone_Zone_HVACZone_Zone_INT_MIN_SENTINEL_DO_NOT_USE_ =
+      std::numeric_limits<::int32_t>::min(),
+  HVACZone_Zone_HVACZone_Zone_INT_MAX_SENTINEL_DO_NOT_USE_ =
+      std::numeric_limits<::int32_t>::max(),
+};
+
+bool HVACZone_Zone_IsValid(int value);
+constexpr HVACZone_Zone HVACZone_Zone_Zone_MIN = static_cast<HVACZone_Zone>(0);
+constexpr HVACZone_Zone HVACZone_Zone_Zone_MAX = static_cast<HVACZone_Zone>(3);
+constexpr int HVACZone_Zone_Zone_ARRAYSIZE = 3 + 1;
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+HVACZone_Zone_descriptor();
+template <typename T>
+const std::string& HVACZone_Zone_Name(T value) {
+  static_assert(std::is_same<T, HVACZone_Zone>::value ||
+                    std::is_integral<T>::value,
+                "Incorrect type passed to Zone_Name().");
+  return HVACZone_Zone_Name(static_cast<HVACZone_Zone>(value));
+}
+template <>
+inline const std::string& HVACZone_Zone_Name(HVACZone_Zone value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum<HVACZone_Zone_descriptor,
+                                                 0, 3>(
+      static_cast<int>(value));
+}
+inline bool HVACZone_Zone_Parse(absl::string_view name, HVACZone_Zone* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HVACZone_Zone>(
+      HVACZone_Zone_descriptor(), name, value);
+}
+enum PreconditionResponse_Status : int {
+  PreconditionResponse_Status_SUCCESS = 0,
+  PreconditionResponse_Status_FAILURE = 1,
+  PreconditionResponse_Status_PENDING = 2,
+  PreconditionResponse_Status_PreconditionResponse_Status_INT_MIN_SENTINEL_DO_NOT_USE_ =
       std::numeric_limits<::int32_t>::min(),
-  AcStatusEnum_INT_MAX_SENTINEL_DO_NOT_USE_ =
+  PreconditionResponse_Status_PreconditionResponse_Status_INT_MAX_SENTINEL_DO_NOT_USE_ =
       std::numeric_limits<::int32_t>::max(),
 };
 
-bool AcStatusEnum_IsValid(int value);
-constexpr AcStatusEnum AcStatusEnum_MIN = static_cast<AcStatusEnum>(0);
-constexpr AcStatusEnum AcStatusEnum_MAX = static_cast<AcStatusEnum>(2);
-constexpr int AcStatusEnum_ARRAYSIZE = 2 + 1;
+bool PreconditionResponse_Status_IsValid(int value);
+constexpr PreconditionResponse_Status PreconditionResponse_Status_Status_MIN = static_cast<PreconditionResponse_Status>(0);
+constexpr PreconditionResponse_Status PreconditionResponse_Status_Status_MAX = static_cast<PreconditionResponse_Status>(2);
+constexpr int PreconditionResponse_Status_Status_ARRAYSIZE = 2 + 1;
 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
-AcStatusEnum_descriptor();
+PreconditionResponse_Status_descriptor();
 template <typename T>
-const std::string& AcStatusEnum_Name(T value) {
-  static_assert(std::is_same<T, AcStatusEnum>::value ||
+const std::string& PreconditionResponse_Status_Name(T value) {
+  static_assert(std::is_same<T, PreconditionResponse_Status>::value ||
                     std::is_integral<T>::value,
-                "Incorrect type passed to AcStatusEnum_Name().");
-  return AcStatusEnum_Name(static_cast<AcStatusEnum>(value));
+                "Incorrect type passed to Status_Name().");
+  return PreconditionResponse_Status_Name(static_cast<PreconditionResponse_Status>(value));
 }
 template <>
-inline const std::string& AcStatusEnum_Name(AcStatusEnum value) {
-  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum<AcStatusEnum_descriptor,
+inline const std::string& PreconditionResponse_Status_Name(PreconditionResponse_Status value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum<PreconditionResponse_Status_descriptor,
                                                  0, 2>(
       static_cast<int>(value));
 }
-inline bool AcStatusEnum_Parse(absl::string_view name, AcStatusEnum* value) {
-  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<AcStatusEnum>(
-      AcStatusEnum_descriptor(), name, value);
+inline bool PreconditionResponse_Status_Parse(absl::string_view name, PreconditionResponse_Status* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PreconditionResponse_Status>(
+      PreconditionResponse_Status_descriptor(), name, value);
 }
-enum SetTempStatusEnum : int {
-  TEMP_SUCCESS = 0,
-  TEMP_ERROR = 1,
-  SetTempStatusEnum_INT_MIN_SENTINEL_DO_NOT_USE_ =
+enum HVACState_State : int {
+  HVACState_State_OFF = 0,
+  HVACState_State_HEATING = 1,
+  HVACState_State_COOLING = 2,
+  HVACState_State_IDLE = 3,
+  HVACState_State_HVACState_State_INT_MIN_SENTINEL_DO_NOT_USE_ =
       std::numeric_limits<::int32_t>::min(),
-  SetTempStatusEnum_INT_MAX_SENTINEL_DO_NOT_USE_ =
+  HVACState_State_HVACState_State_INT_MAX_SENTINEL_DO_NOT_USE_ =
       std::numeric_limits<::int32_t>::max(),
 };
 
-bool SetTempStatusEnum_IsValid(int value);
-constexpr SetTempStatusEnum SetTempStatusEnum_MIN = static_cast<SetTempStatusEnum>(0);
-constexpr SetTempStatusEnum SetTempStatusEnum_MAX = static_cast<SetTempStatusEnum>(1);
-constexpr int SetTempStatusEnum_ARRAYSIZE = 1 + 1;
+bool HVACState_State_IsValid(int value);
+constexpr HVACState_State HVACState_State_State_MIN = static_cast<HVACState_State>(0);
+constexpr HVACState_State HVACState_State_State_MAX = static_cast<HVACState_State>(3);
+constexpr int HVACState_State_State_ARRAYSIZE = 3 + 1;
 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
-SetTempStatusEnum_descriptor();
+HVACState_State_descriptor();
 template <typename T>
-const std::string& SetTempStatusEnum_Name(T value) {
-  static_assert(std::is_same<T, SetTempStatusEnum>::value ||
+const std::string& HVACState_State_Name(T value) {
+  static_assert(std::is_same<T, HVACState_State>::value ||
                     std::is_integral<T>::value,
-                "Incorrect type passed to SetTempStatusEnum_Name().");
-  return SetTempStatusEnum_Name(static_cast<SetTempStatusEnum>(value));
+                "Incorrect type passed to State_Name().");
+  return HVACState_State_Name(static_cast<HVACState_State>(value));
 }
 template <>
-inline const std::string& SetTempStatusEnum_Name(SetTempStatusEnum value) {
-  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum<SetTempStatusEnum_descriptor,
-                                                 0, 1>(
+inline const std::string& HVACState_State_Name(HVACState_State value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum<HVACState_State_descriptor,
+                                                 0, 3>(
       static_cast<int>(value));
 }
-inline bool SetTempStatusEnum_Parse(absl::string_view name, SetTempStatusEnum* value) {
-  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SetTempStatusEnum>(
-      SetTempStatusEnum_descriptor(), name, value);
+inline bool HVACState_State_Parse(absl::string_view name, HVACState_State* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HVACState_State>(
+      HVACState_State_descriptor(), name, value);
 }
 
 // ===================================================================
@@ -160,24 +203,24 @@ inline bool SetTempStatusEnum_Parse(absl::string_view name, SetTempStatusEnum* v
 
 // -------------------------------------------------------------------
 
-class CabinPreconditionRequest final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.CabinPreconditionRequest) */ {
+class Temperature final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.hvac.Temperature) */ {
  public:
-  inline CabinPreconditionRequest() : CabinPreconditionRequest(nullptr) {}
-  ~CabinPreconditionRequest() override;
-  explicit PROTOBUF_CONSTEXPR CabinPreconditionRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  inline Temperature() : Temperature(nullptr) {}
+  ~Temperature() override;
+  explicit PROTOBUF_CONSTEXPR Temperature(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
-  CabinPreconditionRequest(const CabinPreconditionRequest& from);
-  CabinPreconditionRequest(CabinPreconditionRequest&& from) noexcept
-    : CabinPreconditionRequest() {
+  Temperature(const Temperature& from);
+  Temperature(Temperature&& from) noexcept
+    : Temperature() {
     *this = ::std::move(from);
   }
 
-  inline CabinPreconditionRequest& operator=(const CabinPreconditionRequest& from) {
+  inline Temperature& operator=(const Temperature& from) {
     CopyFrom(from);
     return *this;
   }
-  inline CabinPreconditionRequest& operator=(CabinPreconditionRequest&& from) noexcept {
+  inline Temperature& operator=(Temperature&& from) noexcept {
     if (this == &from) return *this;
     if (GetOwningArena() == from.GetOwningArena()
   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
@@ -200,20 +243,20 @@ class CabinPreconditionRequest final :
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
     return default_instance().GetMetadata().reflection;
   }
-  static const CabinPreconditionRequest& default_instance() {
+  static const Temperature& default_instance() {
     return *internal_default_instance();
   }
-  static inline const CabinPreconditionRequest* internal_default_instance() {
-    return reinterpret_cast<const CabinPreconditionRequest*>(
-               &_CabinPreconditionRequest_default_instance_);
+  static inline const Temperature* internal_default_instance() {
+    return reinterpret_cast<const Temperature*>(
+               &_Temperature_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
     0;
 
-  friend void swap(CabinPreconditionRequest& a, CabinPreconditionRequest& b) {
+  friend void swap(Temperature& a, Temperature& b) {
     a.Swap(&b);
   }
-  inline void Swap(CabinPreconditionRequest* other) {
+  inline void Swap(Temperature* other) {
     if (other == this) return;
   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
     if (GetOwningArena() != nullptr &&
@@ -226,7 +269,7 @@ class CabinPreconditionRequest final :
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
     }
   }
-  void UnsafeArenaSwap(CabinPreconditionRequest* other) {
+  void UnsafeArenaSwap(Temperature* other) {
     if (other == this) return;
     ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
     InternalSwap(other);
@@ -234,14 +277,14 @@ class CabinPreconditionRequest final :
 
   // implements Message ----------------------------------------------
 
-  CabinPreconditionRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<CabinPreconditionRequest>(arena);
+  Temperature* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Temperature>(arena);
   }
   using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const CabinPreconditionRequest& from);
+  void CopyFrom(const Temperature& from);
   using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const CabinPreconditionRequest& from) {
-    CabinPreconditionRequest::MergeImpl(*this, from);
+  void MergeFrom( const Temperature& from) {
+    Temperature::MergeImpl(*this, from);
   }
   private:
   static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
@@ -259,15 +302,15 @@ class CabinPreconditionRequest final :
   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   void SharedDtor();
   void SetCachedSize(int size) const final;
-  void InternalSwap(CabinPreconditionRequest* other);
+  void InternalSwap(Temperature* other);
 
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() {
-    return "messages.CabinPreconditionRequest";
+    return "messages.hvac.Temperature";
   }
   protected:
-  explicit CabinPreconditionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit Temperature(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   public:
 
   static const ClassData _class_data_;
@@ -280,65 +323,229 @@ class CabinPreconditionRequest final :
   // accessors -------------------------------------------------------
 
   enum : int {
-    kMessageHeaderFieldNumber = 1,
-    kSetAcStatusFieldNumber = 2,
-    kSetTempFieldNumber = 3,
+    kUnitFieldNumber = 2,
+    kValueFieldNumber = 1,
   };
-  // .messages.VehicleMessageHeading messageHeader = 1;
-  bool has_messageheader() const;
+  // string unit = 2;
+  void clear_unit() ;
+  const std::string& unit() const;
+
+
+
+
+  template <typename Arg_ = const std::string&, typename... Args_>
+  void set_unit(Arg_&& arg, Args_... args);
+  std::string* mutable_unit();
+  PROTOBUF_NODISCARD std::string* release_unit();
+  void set_allocated_unit(std::string* ptr);
+
   private:
-  bool _internal_has_messageheader() const;
+  const std::string& _internal_unit() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_unit(
+      const std::string& value);
+  std::string* _internal_mutable_unit();
 
   public:
-  void clear_messageheader() ;
-  const ::messages::VehicleMessageHeading& messageheader() const;
-  PROTOBUF_NODISCARD ::messages::VehicleMessageHeading* release_messageheader();
-  ::messages::VehicleMessageHeading* mutable_messageheader();
-  void set_allocated_messageheader(::messages::VehicleMessageHeading* messageheader);
+  // float value = 1;
+  void clear_value() ;
+  float value() const;
+  void set_value(float value);
+
   private:
-  const ::messages::VehicleMessageHeading& _internal_messageheader() const;
-  ::messages::VehicleMessageHeading* _internal_mutable_messageheader();
+  float _internal_value() const;
+  void _internal_set_value(float value);
+
   public:
-  void unsafe_arena_set_allocated_messageheader(
-      ::messages::VehicleMessageHeading* messageheader);
-  ::messages::VehicleMessageHeading* unsafe_arena_release_messageheader();
-  // .messages.SetAcStatusRequest setAcStatus = 2;
-  bool has_setacstatus() const;
-  private:
-  bool _internal_has_setacstatus() const;
+  // @@protoc_insertion_point(class_scope:messages.hvac.Temperature)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr unit_;
+    float value_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_messages_2fVehicleRemoteHvac_2eproto;
+};// -------------------------------------------------------------------
+
+class HVACZone final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.hvac.HVACZone) */ {
+ public:
+  inline HVACZone() : HVACZone(nullptr) {}
+  ~HVACZone() override;
+  explicit PROTOBUF_CONSTEXPR HVACZone(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  HVACZone(const HVACZone& from);
+  HVACZone(HVACZone&& from) noexcept
+    : HVACZone() {
+    *this = ::std::move(from);
+  }
 
+  inline HVACZone& operator=(const HVACZone& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline HVACZone& operator=(HVACZone&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const HVACZone& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const HVACZone* internal_default_instance() {
+    return reinterpret_cast<const HVACZone*>(
+               &_HVACZone_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(HVACZone& a, HVACZone& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(HVACZone* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(HVACZone* other) {
+    if (other == this) return;
+    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  HVACZone* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<HVACZone>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const HVACZone& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const HVACZone& from) {
+    HVACZone::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
   public:
-  void clear_setacstatus() ;
-  const ::messages::SetAcStatusRequest& setacstatus() const;
-  PROTOBUF_NODISCARD ::messages::SetAcStatusRequest* release_setacstatus();
-  ::messages::SetAcStatusRequest* mutable_setacstatus();
-  void set_allocated_setacstatus(::messages::SetAcStatusRequest* setacstatus);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  ::size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::uint8_t* _InternalSerialize(
+      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(HVACZone* other);
+
   private:
-  const ::messages::SetAcStatusRequest& _internal_setacstatus() const;
-  ::messages::SetAcStatusRequest* _internal_mutable_setacstatus();
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::absl::string_view FullMessageName() {
+    return "messages.hvac.HVACZone";
+  }
+  protected:
+  explicit HVACZone(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   public:
-  void unsafe_arena_set_allocated_setacstatus(
-      ::messages::SetAcStatusRequest* setacstatus);
-  ::messages::SetAcStatusRequest* unsafe_arena_release_setacstatus();
-  // .messages.SetTemperatureRequest setTemp = 3;
-  bool has_settemp() const;
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  using Zone = HVACZone_Zone;
+  static constexpr Zone DRIVER = HVACZone_Zone_DRIVER;
+  static constexpr Zone PASSENGER = HVACZone_Zone_PASSENGER;
+  static constexpr Zone REAR_LEFT = HVACZone_Zone_REAR_LEFT;
+  static constexpr Zone REAR_RIGHT = HVACZone_Zone_REAR_RIGHT;
+  static inline bool Zone_IsValid(int value) {
+    return HVACZone_Zone_IsValid(value);
+  }
+  static constexpr Zone Zone_MIN = HVACZone_Zone_Zone_MIN;
+  static constexpr Zone Zone_MAX = HVACZone_Zone_Zone_MAX;
+  static constexpr int Zone_ARRAYSIZE = HVACZone_Zone_Zone_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Zone_descriptor() {
+    return HVACZone_Zone_descriptor();
+  }
+  template <typename T>
+  static inline const std::string& Zone_Name(T value) {
+    return HVACZone_Zone_Name(value);
+  }
+  static inline bool Zone_Parse(absl::string_view name, Zone* value) {
+    return HVACZone_Zone_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTargetTemperatureFieldNumber = 2,
+    kZoneFieldNumber = 1,
+  };
+  // .messages.hvac.Temperature target_temperature = 2;
+  bool has_target_temperature() const;
   private:
-  bool _internal_has_settemp() const;
+  bool _internal_has_target_temperature() const;
 
   public:
-  void clear_settemp() ;
-  const ::messages::SetTemperatureRequest& settemp() const;
-  PROTOBUF_NODISCARD ::messages::SetTemperatureRequest* release_settemp();
-  ::messages::SetTemperatureRequest* mutable_settemp();
-  void set_allocated_settemp(::messages::SetTemperatureRequest* settemp);
+  void clear_target_temperature() ;
+  const ::messages::hvac::Temperature& target_temperature() const;
+  PROTOBUF_NODISCARD ::messages::hvac::Temperature* release_target_temperature();
+  ::messages::hvac::Temperature* mutable_target_temperature();
+  void set_allocated_target_temperature(::messages::hvac::Temperature* target_temperature);
   private:
-  const ::messages::SetTemperatureRequest& _internal_settemp() const;
-  ::messages::SetTemperatureRequest* _internal_mutable_settemp();
+  const ::messages::hvac::Temperature& _internal_target_temperature() const;
+  ::messages::hvac::Temperature* _internal_mutable_target_temperature();
   public:
-  void unsafe_arena_set_allocated_settemp(
-      ::messages::SetTemperatureRequest* settemp);
-  ::messages::SetTemperatureRequest* unsafe_arena_release_settemp();
-  // @@protoc_insertion_point(class_scope:messages.CabinPreconditionRequest)
+  void unsafe_arena_set_allocated_target_temperature(
+      ::messages::hvac::Temperature* target_temperature);
+  ::messages::hvac::Temperature* unsafe_arena_release_target_temperature();
+  // .messages.hvac.HVACZone.Zone zone = 1;
+  void clear_zone() ;
+  ::messages::hvac::HVACZone_Zone zone() const;
+  void set_zone(::messages::hvac::HVACZone_Zone value);
+
+  private:
+  ::messages::hvac::HVACZone_Zone _internal_zone() const;
+  void _internal_set_zone(::messages::hvac::HVACZone_Zone value);
+
+  public:
+  // @@protoc_insertion_point(class_scope:messages.hvac.HVACZone)
  private:
   class _Internal;
 
@@ -346,33 +553,32 @@ class CabinPreconditionRequest final :
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
   struct Impl_ {
-    ::messages::VehicleMessageHeading* messageheader_;
-    ::messages::SetAcStatusRequest* setacstatus_;
-    ::messages::SetTemperatureRequest* settemp_;
+    ::messages::hvac::Temperature* target_temperature_;
+    int zone_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_messages_2fVehicleRemoteHvac_2eproto;
 };// -------------------------------------------------------------------
 
-class CabinPreConditionReponse final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.CabinPreConditionReponse) */ {
+class PreconditionRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.hvac.PreconditionRequest) */ {
  public:
-  inline CabinPreConditionReponse() : CabinPreConditionReponse(nullptr) {}
-  ~CabinPreConditionReponse() override;
-  explicit PROTOBUF_CONSTEXPR CabinPreConditionReponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  inline PreconditionRequest() : PreconditionRequest(nullptr) {}
+  ~PreconditionRequest() override;
+  explicit PROTOBUF_CONSTEXPR PreconditionRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
-  CabinPreConditionReponse(const CabinPreConditionReponse& from);
-  CabinPreConditionReponse(CabinPreConditionReponse&& from) noexcept
-    : CabinPreConditionReponse() {
+  PreconditionRequest(const PreconditionRequest& from);
+  PreconditionRequest(PreconditionRequest&& from) noexcept
+    : PreconditionRequest() {
     *this = ::std::move(from);
   }
 
-  inline CabinPreConditionReponse& operator=(const CabinPreConditionReponse& from) {
+  inline PreconditionRequest& operator=(const PreconditionRequest& from) {
     CopyFrom(from);
     return *this;
   }
-  inline CabinPreConditionReponse& operator=(CabinPreConditionReponse&& from) noexcept {
+  inline PreconditionRequest& operator=(PreconditionRequest&& from) noexcept {
     if (this == &from) return *this;
     if (GetOwningArena() == from.GetOwningArena()
   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
@@ -395,20 +601,20 @@ class CabinPreConditionReponse final :
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
     return default_instance().GetMetadata().reflection;
   }
-  static const CabinPreConditionReponse& default_instance() {
+  static const PreconditionRequest& default_instance() {
     return *internal_default_instance();
   }
-  static inline const CabinPreConditionReponse* internal_default_instance() {
-    return reinterpret_cast<const CabinPreConditionReponse*>(
-               &_CabinPreConditionReponse_default_instance_);
+  static inline const PreconditionRequest* internal_default_instance() {
+    return reinterpret_cast<const PreconditionRequest*>(
+               &_PreconditionRequest_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    1;
+    2;
 
-  friend void swap(CabinPreConditionReponse& a, CabinPreConditionReponse& b) {
+  friend void swap(PreconditionRequest& a, PreconditionRequest& b) {
     a.Swap(&b);
   }
-  inline void Swap(CabinPreConditionReponse* other) {
+  inline void Swap(PreconditionRequest* other) {
     if (other == this) return;
   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
     if (GetOwningArena() != nullptr &&
@@ -421,7 +627,7 @@ class CabinPreConditionReponse final :
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
     }
   }
-  void UnsafeArenaSwap(CabinPreConditionReponse* other) {
+  void UnsafeArenaSwap(PreconditionRequest* other) {
     if (other == this) return;
     ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
     InternalSwap(other);
@@ -429,14 +635,14 @@ class CabinPreConditionReponse final :
 
   // implements Message ----------------------------------------------
 
-  CabinPreConditionReponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<CabinPreConditionReponse>(arena);
+  PreconditionRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<PreconditionRequest>(arena);
   }
   using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const CabinPreConditionReponse& from);
+  void CopyFrom(const PreconditionRequest& from);
   using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const CabinPreConditionReponse& from) {
-    CabinPreConditionReponse::MergeImpl(*this, from);
+  void MergeFrom( const PreconditionRequest& from) {
+    PreconditionRequest::MergeImpl(*this, from);
   }
   private:
   static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
@@ -454,15 +660,15 @@ class CabinPreConditionReponse final :
   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   void SharedDtor();
   void SetCachedSize(int size) const final;
-  void InternalSwap(CabinPreConditionReponse* other);
+  void InternalSwap(PreconditionRequest* other);
 
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() {
-    return "messages.CabinPreConditionReponse";
+    return "messages.hvac.PreconditionRequest";
   }
   protected:
-  explicit CabinPreConditionReponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit PreconditionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   public:
 
   static const ClassData _class_data_;
@@ -475,65 +681,46 @@ class CabinPreConditionReponse final :
   // accessors -------------------------------------------------------
 
   enum : int {
-    kMessageHeaderFieldNumber = 1,
-    kSetAcStatusReplyFieldNumber = 2,
-    kSetTemperatureReplyFieldNumber = 3,
+    kHvacZonesFieldNumber = 1,
+    kStartTimeFieldNumber = 2,
   };
-  // .messages.VehicleMessageHeading messageHeader = 1;
-  bool has_messageheader() const;
+  // repeated .messages.hvac.HVACZone hvac_zones = 1;
+  int hvac_zones_size() const;
   private:
-  bool _internal_has_messageheader() const;
+  int _internal_hvac_zones_size() const;
 
   public:
-  void clear_messageheader() ;
-  const ::messages::VehicleMessageHeading& messageheader() const;
-  PROTOBUF_NODISCARD ::messages::VehicleMessageHeading* release_messageheader();
-  ::messages::VehicleMessageHeading* mutable_messageheader();
-  void set_allocated_messageheader(::messages::VehicleMessageHeading* messageheader);
+  void clear_hvac_zones() ;
+  ::messages::hvac::HVACZone* mutable_hvac_zones(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::messages::hvac::HVACZone >*
+      mutable_hvac_zones();
   private:
-  const ::messages::VehicleMessageHeading& _internal_messageheader() const;
-  ::messages::VehicleMessageHeading* _internal_mutable_messageheader();
+  const ::messages::hvac::HVACZone& _internal_hvac_zones(int index) const;
+  ::messages::hvac::HVACZone* _internal_add_hvac_zones();
   public:
-  void unsafe_arena_set_allocated_messageheader(
-      ::messages::VehicleMessageHeading* messageheader);
-  ::messages::VehicleMessageHeading* unsafe_arena_release_messageheader();
-  // .messages.SetAcStatusReply setAcStatusReply = 2;
-  bool has_setacstatusreply() const;
+  const ::messages::hvac::HVACZone& hvac_zones(int index) const;
+  ::messages::hvac::HVACZone* add_hvac_zones();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::messages::hvac::HVACZone >&
+      hvac_zones() const;
+  // .google.protobuf.Timestamp start_time = 2;
+  bool has_start_time() const;
   private:
-  bool _internal_has_setacstatusreply() const;
+  bool _internal_has_start_time() const;
 
   public:
-  void clear_setacstatusreply() ;
-  const ::messages::SetAcStatusReply& setacstatusreply() const;
-  PROTOBUF_NODISCARD ::messages::SetAcStatusReply* release_setacstatusreply();
-  ::messages::SetAcStatusReply* mutable_setacstatusreply();
-  void set_allocated_setacstatusreply(::messages::SetAcStatusReply* setacstatusreply);
+  void clear_start_time() ;
+  const ::PROTOBUF_NAMESPACE_ID::Timestamp& start_time() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Timestamp* release_start_time();
+  ::PROTOBUF_NAMESPACE_ID::Timestamp* mutable_start_time();
+  void set_allocated_start_time(::PROTOBUF_NAMESPACE_ID::Timestamp* start_time);
   private:
-  const ::messages::SetAcStatusReply& _internal_setacstatusreply() const;
-  ::messages::SetAcStatusReply* _internal_mutable_setacstatusreply();
+  const ::PROTOBUF_NAMESPACE_ID::Timestamp& _internal_start_time() const;
+  ::PROTOBUF_NAMESPACE_ID::Timestamp* _internal_mutable_start_time();
   public:
-  void unsafe_arena_set_allocated_setacstatusreply(
-      ::messages::SetAcStatusReply* setacstatusreply);
-  ::messages::SetAcStatusReply* unsafe_arena_release_setacstatusreply();
-  // .messages.SetTemperatureReply setTemperatureReply = 3;
-  bool has_settemperaturereply() const;
-  private:
-  bool _internal_has_settemperaturereply() const;
-
-  public:
-  void clear_settemperaturereply() ;
-  const ::messages::SetTemperatureReply& settemperaturereply() const;
-  PROTOBUF_NODISCARD ::messages::SetTemperatureReply* release_settemperaturereply();
-  ::messages::SetTemperatureReply* mutable_settemperaturereply();
-  void set_allocated_settemperaturereply(::messages::SetTemperatureReply* settemperaturereply);
-  private:
-  const ::messages::SetTemperatureReply& _internal_settemperaturereply() const;
-  ::messages::SetTemperatureReply* _internal_mutable_settemperaturereply();
-  public:
-  void unsafe_arena_set_allocated_settemperaturereply(
-      ::messages::SetTemperatureReply* settemperaturereply);
-  ::messages::SetTemperatureReply* unsafe_arena_release_settemperaturereply();
-  // @@protoc_insertion_point(class_scope:messages.CabinPreConditionReponse)
+  void unsafe_arena_set_allocated_start_time(
+      ::PROTOBUF_NAMESPACE_ID::Timestamp* start_time);
+  ::PROTOBUF_NAMESPACE_ID::Timestamp* unsafe_arena_release_start_time();
+  // @@protoc_insertion_point(class_scope:messages.hvac.PreconditionRequest)
  private:
   class _Internal;
 
@@ -541,33 +728,32 @@ class CabinPreConditionReponse final :
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
   struct Impl_ {
-    ::messages::VehicleMessageHeading* messageheader_;
-    ::messages::SetAcStatusReply* setacstatusreply_;
-    ::messages::SetTemperatureReply* settemperaturereply_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::messages::hvac::HVACZone > hvac_zones_;
+    ::PROTOBUF_NAMESPACE_ID::Timestamp* start_time_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_messages_2fVehicleRemoteHvac_2eproto;
 };// -------------------------------------------------------------------
 
-class SetAcStatusRequest final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.SetAcStatusRequest) */ {
+class PreconditionResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.hvac.PreconditionResponse) */ {
  public:
-  inline SetAcStatusRequest() : SetAcStatusRequest(nullptr) {}
-  ~SetAcStatusRequest() override;
-  explicit PROTOBUF_CONSTEXPR SetAcStatusRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  inline PreconditionResponse() : PreconditionResponse(nullptr) {}
+  ~PreconditionResponse() override;
+  explicit PROTOBUF_CONSTEXPR PreconditionResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
-  SetAcStatusRequest(const SetAcStatusRequest& from);
-  SetAcStatusRequest(SetAcStatusRequest&& from) noexcept
-    : SetAcStatusRequest() {
+  PreconditionResponse(const PreconditionResponse& from);
+  PreconditionResponse(PreconditionResponse&& from) noexcept
+    : PreconditionResponse() {
     *this = ::std::move(from);
   }
 
-  inline SetAcStatusRequest& operator=(const SetAcStatusRequest& from) {
+  inline PreconditionResponse& operator=(const PreconditionResponse& from) {
     CopyFrom(from);
     return *this;
   }
-  inline SetAcStatusRequest& operator=(SetAcStatusRequest&& from) noexcept {
+  inline PreconditionResponse& operator=(PreconditionResponse&& from) noexcept {
     if (this == &from) return *this;
     if (GetOwningArena() == from.GetOwningArena()
   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
@@ -590,20 +776,20 @@ class SetAcStatusRequest final :
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
     return default_instance().GetMetadata().reflection;
   }
-  static const SetAcStatusRequest& default_instance() {
+  static const PreconditionResponse& default_instance() {
     return *internal_default_instance();
   }
-  static inline const SetAcStatusRequest* internal_default_instance() {
-    return reinterpret_cast<const SetAcStatusRequest*>(
-               &_SetAcStatusRequest_default_instance_);
+  static inline const PreconditionResponse* internal_default_instance() {
+    return reinterpret_cast<const PreconditionResponse*>(
+               &_PreconditionResponse_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    2;
+    3;
 
-  friend void swap(SetAcStatusRequest& a, SetAcStatusRequest& b) {
+  friend void swap(PreconditionResponse& a, PreconditionResponse& b) {
     a.Swap(&b);
   }
-  inline void Swap(SetAcStatusRequest* other) {
+  inline void Swap(PreconditionResponse* other) {
     if (other == this) return;
   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
     if (GetOwningArena() != nullptr &&
@@ -616,7 +802,7 @@ class SetAcStatusRequest final :
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
     }
   }
-  void UnsafeArenaSwap(SetAcStatusRequest* other) {
+  void UnsafeArenaSwap(PreconditionResponse* other) {
     if (other == this) return;
     ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
     InternalSwap(other);
@@ -624,14 +810,14 @@ class SetAcStatusRequest final :
 
   // implements Message ----------------------------------------------
 
-  SetAcStatusRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<SetAcStatusRequest>(arena);
+  PreconditionResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<PreconditionResponse>(arena);
   }
   using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const SetAcStatusRequest& from);
+  void CopyFrom(const PreconditionResponse& from);
   using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const SetAcStatusRequest& from) {
-    SetAcStatusRequest::MergeImpl(*this, from);
+  void MergeFrom( const PreconditionResponse& from) {
+    PreconditionResponse::MergeImpl(*this, from);
   }
   private:
   static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
@@ -649,15 +835,15 @@ class SetAcStatusRequest final :
   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   void SharedDtor();
   void SetCachedSize(int size) const final;
-  void InternalSwap(SetAcStatusRequest* other);
+  void InternalSwap(PreconditionResponse* other);
 
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() {
-    return "messages.SetAcStatusRequest";
+    return "messages.hvac.PreconditionResponse";
   }
   protected:
-  explicit SetAcStatusRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit PreconditionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   public:
 
   static const ClassData _class_data_;
@@ -667,22 +853,64 @@ class SetAcStatusRequest final :
 
   // nested types ----------------------------------------------------
 
+  using Status = PreconditionResponse_Status;
+  static constexpr Status SUCCESS = PreconditionResponse_Status_SUCCESS;
+  static constexpr Status FAILURE = PreconditionResponse_Status_FAILURE;
+  static constexpr Status PENDING = PreconditionResponse_Status_PENDING;
+  static inline bool Status_IsValid(int value) {
+    return PreconditionResponse_Status_IsValid(value);
+  }
+  static constexpr Status Status_MIN = PreconditionResponse_Status_Status_MIN;
+  static constexpr Status Status_MAX = PreconditionResponse_Status_Status_MAX;
+  static constexpr int Status_ARRAYSIZE = PreconditionResponse_Status_Status_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Status_descriptor() {
+    return PreconditionResponse_Status_descriptor();
+  }
+  template <typename T>
+  static inline const std::string& Status_Name(T value) {
+    return PreconditionResponse_Status_Name(value);
+  }
+  static inline bool Status_Parse(absl::string_view name, Status* value) {
+    return PreconditionResponse_Status_Parse(name, value);
+  }
+
   // accessors -------------------------------------------------------
 
   enum : int {
-    kDesiredStatusFieldNumber = 1,
+    kMessageFieldNumber = 2,
+    kStatusFieldNumber = 1,
   };
-  // .messages.AcStatusEnum desiredStatus = 1;
-  void clear_desiredstatus() ;
-  ::messages::AcStatusEnum desiredstatus() const;
-  void set_desiredstatus(::messages::AcStatusEnum value);
+  // string message = 2;
+  void clear_message() ;
+  const std::string& message() const;
+
+
+
+
+  template <typename Arg_ = const std::string&, typename... Args_>
+  void set_message(Arg_&& arg, Args_... args);
+  std::string* mutable_message();
+  PROTOBUF_NODISCARD std::string* release_message();
+  void set_allocated_message(std::string* ptr);
+
+  private:
+  const std::string& _internal_message() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_message(
+      const std::string& value);
+  std::string* _internal_mutable_message();
+
+  public:
+  // .messages.hvac.PreconditionResponse.Status status = 1;
+  void clear_status() ;
+  ::messages::hvac::PreconditionResponse_Status status() const;
+  void set_status(::messages::hvac::PreconditionResponse_Status value);
 
   private:
-  ::messages::AcStatusEnum _internal_desiredstatus() const;
-  void _internal_set_desiredstatus(::messages::AcStatusEnum value);
+  ::messages::hvac::PreconditionResponse_Status _internal_status() const;
+  void _internal_set_status(::messages::hvac::PreconditionResponse_Status value);
 
   public:
-  // @@protoc_insertion_point(class_scope:messages.SetAcStatusRequest)
+  // @@protoc_insertion_point(class_scope:messages.hvac.PreconditionResponse)
  private:
   class _Internal;
 
@@ -690,31 +918,32 @@ class SetAcStatusRequest final :
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
   struct Impl_ {
-    int desiredstatus_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_;
+    int status_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_messages_2fVehicleRemoteHvac_2eproto;
 };// -------------------------------------------------------------------
 
-class SetAcStatusReply final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.SetAcStatusReply) */ {
+class HVACState final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.hvac.HVACState) */ {
  public:
-  inline SetAcStatusReply() : SetAcStatusReply(nullptr) {}
-  ~SetAcStatusReply() override;
-  explicit PROTOBUF_CONSTEXPR SetAcStatusReply(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  inline HVACState() : HVACState(nullptr) {}
+  ~HVACState() override;
+  explicit PROTOBUF_CONSTEXPR HVACState(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
-  SetAcStatusReply(const SetAcStatusReply& from);
-  SetAcStatusReply(SetAcStatusReply&& from) noexcept
-    : SetAcStatusReply() {
+  HVACState(const HVACState& from);
+  HVACState(HVACState&& from) noexcept
+    : HVACState() {
     *this = ::std::move(from);
   }
 
-  inline SetAcStatusReply& operator=(const SetAcStatusReply& from) {
+  inline HVACState& operator=(const HVACState& from) {
     CopyFrom(from);
     return *this;
   }
-  inline SetAcStatusReply& operator=(SetAcStatusReply&& from) noexcept {
+  inline HVACState& operator=(HVACState&& from) noexcept {
     if (this == &from) return *this;
     if (GetOwningArena() == from.GetOwningArena()
   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
@@ -737,20 +966,20 @@ class SetAcStatusReply final :
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
     return default_instance().GetMetadata().reflection;
   }
-  static const SetAcStatusReply& default_instance() {
+  static const HVACState& default_instance() {
     return *internal_default_instance();
   }
-  static inline const SetAcStatusReply* internal_default_instance() {
-    return reinterpret_cast<const SetAcStatusReply*>(
-               &_SetAcStatusReply_default_instance_);
+  static inline const HVACState* internal_default_instance() {
+    return reinterpret_cast<const HVACState*>(
+               &_HVACState_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    3;
+    4;
 
-  friend void swap(SetAcStatusReply& a, SetAcStatusReply& b) {
+  friend void swap(HVACState& a, HVACState& b) {
     a.Swap(&b);
   }
-  inline void Swap(SetAcStatusReply* other) {
+  inline void Swap(HVACState* other) {
     if (other == this) return;
   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
     if (GetOwningArena() != nullptr &&
@@ -763,7 +992,7 @@ class SetAcStatusReply final :
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
     }
   }
-  void UnsafeArenaSwap(SetAcStatusReply* other) {
+  void UnsafeArenaSwap(HVACState* other) {
     if (other == this) return;
     ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
     InternalSwap(other);
@@ -771,14 +1000,14 @@ class SetAcStatusReply final :
 
   // implements Message ----------------------------------------------
 
-  SetAcStatusReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<SetAcStatusReply>(arena);
+  HVACState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<HVACState>(arena);
   }
   using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const SetAcStatusReply& from);
+  void CopyFrom(const HVACState& from);
   using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const SetAcStatusReply& from) {
-    SetAcStatusReply::MergeImpl(*this, from);
+  void MergeFrom( const HVACState& from) {
+    HVACState::MergeImpl(*this, from);
   }
   private:
   static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
@@ -796,15 +1025,15 @@ class SetAcStatusReply final :
   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   void SharedDtor();
   void SetCachedSize(int size) const final;
-  void InternalSwap(SetAcStatusReply* other);
+  void InternalSwap(HVACState* other);
 
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() {
-    return "messages.SetAcStatusReply";
+    return "messages.hvac.HVACState";
   }
   protected:
-  explicit SetAcStatusReply(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit HVACState(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   public:
 
   static const ClassData _class_data_;
@@ -814,22 +1043,63 @@ class SetAcStatusReply final :
 
   // nested types ----------------------------------------------------
 
+  using State = HVACState_State;
+  static constexpr State OFF = HVACState_State_OFF;
+  static constexpr State HEATING = HVACState_State_HEATING;
+  static constexpr State COOLING = HVACState_State_COOLING;
+  static constexpr State IDLE = HVACState_State_IDLE;
+  static inline bool State_IsValid(int value) {
+    return HVACState_State_IsValid(value);
+  }
+  static constexpr State State_MIN = HVACState_State_State_MIN;
+  static constexpr State State_MAX = HVACState_State_State_MAX;
+  static constexpr int State_ARRAYSIZE = HVACState_State_State_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* State_descriptor() {
+    return HVACState_State_descriptor();
+  }
+  template <typename T>
+  static inline const std::string& State_Name(T value) {
+    return HVACState_State_Name(value);
+  }
+  static inline bool State_Parse(absl::string_view name, State* value) {
+    return HVACState_State_Parse(name, value);
+  }
+
   // accessors -------------------------------------------------------
 
   enum : int {
-    kStatusFieldNumber = 1,
+    kCurrentZoneFieldNumber = 2,
+    kStateFieldNumber = 1,
   };
-  // .messages.AcStatusEnum status = 1;
-  void clear_status() ;
-  ::messages::AcStatusEnum status() const;
-  void set_status(::messages::AcStatusEnum value);
+  // .messages.hvac.HVACZone current_zone = 2;
+  bool has_current_zone() const;
+  private:
+  bool _internal_has_current_zone() const;
+
+  public:
+  void clear_current_zone() ;
+  const ::messages::hvac::HVACZone& current_zone() const;
+  PROTOBUF_NODISCARD ::messages::hvac::HVACZone* release_current_zone();
+  ::messages::hvac::HVACZone* mutable_current_zone();
+  void set_allocated_current_zone(::messages::hvac::HVACZone* current_zone);
+  private:
+  const ::messages::hvac::HVACZone& _internal_current_zone() const;
+  ::messages::hvac::HVACZone* _internal_mutable_current_zone();
+  public:
+  void unsafe_arena_set_allocated_current_zone(
+      ::messages::hvac::HVACZone* current_zone);
+  ::messages::hvac::HVACZone* unsafe_arena_release_current_zone();
+  // .messages.hvac.HVACState.State state = 1;
+  void clear_state() ;
+  ::messages::hvac::HVACState_State state() const;
+  void set_state(::messages::hvac::HVACState_State value);
 
   private:
-  ::messages::AcStatusEnum _internal_status() const;
-  void _internal_set_status(::messages::AcStatusEnum value);
+  ::messages::hvac::HVACState_State _internal_state() const;
+  void _internal_set_state(::messages::hvac::HVACState_State value);
 
   public:
-  // @@protoc_insertion_point(class_scope:messages.SetAcStatusReply)
+  // @@protoc_insertion_point(class_scope:messages.hvac.HVACState)
  private:
   class _Internal;
 
@@ -837,31 +1107,32 @@ class SetAcStatusReply final :
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
   struct Impl_ {
-    int status_;
+    ::messages::hvac::HVACZone* current_zone_;
+    int state_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_messages_2fVehicleRemoteHvac_2eproto;
 };// -------------------------------------------------------------------
 
-class SetTemperatureRequest final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.SetTemperatureRequest) */ {
+class CabinTemperature final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.hvac.CabinTemperature) */ {
  public:
-  inline SetTemperatureRequest() : SetTemperatureRequest(nullptr) {}
-  ~SetTemperatureRequest() override;
-  explicit PROTOBUF_CONSTEXPR SetTemperatureRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  inline CabinTemperature() : CabinTemperature(nullptr) {}
+  ~CabinTemperature() override;
+  explicit PROTOBUF_CONSTEXPR CabinTemperature(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
-  SetTemperatureRequest(const SetTemperatureRequest& from);
-  SetTemperatureRequest(SetTemperatureRequest&& from) noexcept
-    : SetTemperatureRequest() {
+  CabinTemperature(const CabinTemperature& from);
+  CabinTemperature(CabinTemperature&& from) noexcept
+    : CabinTemperature() {
     *this = ::std::move(from);
   }
 
-  inline SetTemperatureRequest& operator=(const SetTemperatureRequest& from) {
+  inline CabinTemperature& operator=(const CabinTemperature& from) {
     CopyFrom(from);
     return *this;
   }
-  inline SetTemperatureRequest& operator=(SetTemperatureRequest&& from) noexcept {
+  inline CabinTemperature& operator=(CabinTemperature&& from) noexcept {
     if (this == &from) return *this;
     if (GetOwningArena() == from.GetOwningArena()
   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
@@ -884,20 +1155,20 @@ class SetTemperatureRequest final :
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
     return default_instance().GetMetadata().reflection;
   }
-  static const SetTemperatureRequest& default_instance() {
+  static const CabinTemperature& default_instance() {
     return *internal_default_instance();
   }
-  static inline const SetTemperatureRequest* internal_default_instance() {
-    return reinterpret_cast<const SetTemperatureRequest*>(
-               &_SetTemperatureRequest_default_instance_);
+  static inline const CabinTemperature* internal_default_instance() {
+    return reinterpret_cast<const CabinTemperature*>(
+               &_CabinTemperature_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    4;
+    5;
 
-  friend void swap(SetTemperatureRequest& a, SetTemperatureRequest& b) {
+  friend void swap(CabinTemperature& a, CabinTemperature& b) {
     a.Swap(&b);
   }
-  inline void Swap(SetTemperatureRequest* other) {
+  inline void Swap(CabinTemperature* other) {
     if (other == this) return;
   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
     if (GetOwningArena() != nullptr &&
@@ -910,7 +1181,7 @@ class SetTemperatureRequest final :
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
     }
   }
-  void UnsafeArenaSwap(SetTemperatureRequest* other) {
+  void UnsafeArenaSwap(CabinTemperature* other) {
     if (other == this) return;
     ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
     InternalSwap(other);
@@ -918,14 +1189,14 @@ class SetTemperatureRequest final :
 
   // implements Message ----------------------------------------------
 
-  SetTemperatureRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<SetTemperatureRequest>(arena);
+  CabinTemperature* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CabinTemperature>(arena);
   }
   using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const SetTemperatureRequest& from);
+  void CopyFrom(const CabinTemperature& from);
   using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const SetTemperatureRequest& from) {
-    SetTemperatureRequest::MergeImpl(*this, from);
+  void MergeFrom( const CabinTemperature& from) {
+    CabinTemperature::MergeImpl(*this, from);
   }
   private:
   static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
@@ -943,15 +1214,15 @@ class SetTemperatureRequest final :
   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   void SharedDtor();
   void SetCachedSize(int size) const final;
-  void InternalSwap(SetTemperatureRequest* other);
+  void InternalSwap(CabinTemperature* other);
 
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() {
-    return "messages.SetTemperatureRequest";
+    return "messages.hvac.CabinTemperature";
   }
   protected:
-  explicit SetTemperatureRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit CabinTemperature(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   public:
 
   static const ClassData _class_data_;
@@ -965,18 +1236,45 @@ class SetTemperatureRequest final :
 
   enum : int {
     kTemperatureFieldNumber = 1,
+    kZoneFieldNumber = 2,
   };
-  // float temperature = 1;
-  void clear_temperature() ;
-  float temperature() const;
-  void set_temperature(float value);
+  // .messages.hvac.Temperature temperature = 1;
+  bool has_temperature() const;
+  private:
+  bool _internal_has_temperature() const;
 
+  public:
+  void clear_temperature() ;
+  const ::messages::hvac::Temperature& temperature() const;
+  PROTOBUF_NODISCARD ::messages::hvac::Temperature* release_temperature();
+  ::messages::hvac::Temperature* mutable_temperature();
+  void set_allocated_temperature(::messages::hvac::Temperature* temperature);
+  private:
+  const ::messages::hvac::Temperature& _internal_temperature() const;
+  ::messages::hvac::Temperature* _internal_mutable_temperature();
+  public:
+  void unsafe_arena_set_allocated_temperature(
+      ::messages::hvac::Temperature* temperature);
+  ::messages::hvac::Temperature* unsafe_arena_release_temperature();
+  // .messages.hvac.HVACZone zone = 2;
+  bool has_zone() const;
   private:
-  float _internal_temperature() const;
-  void _internal_set_temperature(float value);
+  bool _internal_has_zone() const;
 
   public:
-  // @@protoc_insertion_point(class_scope:messages.SetTemperatureRequest)
+  void clear_zone() ;
+  const ::messages::hvac::HVACZone& zone() const;
+  PROTOBUF_NODISCARD ::messages::hvac::HVACZone* release_zone();
+  ::messages::hvac::HVACZone* mutable_zone();
+  void set_allocated_zone(::messages::hvac::HVACZone* zone);
+  private:
+  const ::messages::hvac::HVACZone& _internal_zone() const;
+  ::messages::hvac::HVACZone* _internal_mutable_zone();
+  public:
+  void unsafe_arena_set_allocated_zone(
+      ::messages::hvac::HVACZone* zone);
+  ::messages::hvac::HVACZone* unsafe_arena_release_zone();
+  // @@protoc_insertion_point(class_scope:messages.hvac.CabinTemperature)
  private:
   class _Internal;
 
@@ -984,31 +1282,32 @@ class SetTemperatureRequest final :
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
   struct Impl_ {
-    float temperature_;
+    ::messages::hvac::Temperature* temperature_;
+    ::messages::hvac::HVACZone* zone_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   };
   union { Impl_ _impl_; };
   friend struct ::TableStruct_messages_2fVehicleRemoteHvac_2eproto;
 };// -------------------------------------------------------------------
 
-class SetTemperatureReply final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.SetTemperatureReply) */ {
+class CabinConditionStatusPublish final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.hvac.CabinConditionStatusPublish) */ {
  public:
-  inline SetTemperatureReply() : SetTemperatureReply(nullptr) {}
-  ~SetTemperatureReply() override;
-  explicit PROTOBUF_CONSTEXPR SetTemperatureReply(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  inline CabinConditionStatusPublish() : CabinConditionStatusPublish(nullptr) {}
+  ~CabinConditionStatusPublish() override;
+  explicit PROTOBUF_CONSTEXPR CabinConditionStatusPublish(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
-  SetTemperatureReply(const SetTemperatureReply& from);
-  SetTemperatureReply(SetTemperatureReply&& from) noexcept
-    : SetTemperatureReply() {
+  CabinConditionStatusPublish(const CabinConditionStatusPublish& from);
+  CabinConditionStatusPublish(CabinConditionStatusPublish&& from) noexcept
+    : CabinConditionStatusPublish() {
     *this = ::std::move(from);
   }
 
-  inline SetTemperatureReply& operator=(const SetTemperatureReply& from) {
+  inline CabinConditionStatusPublish& operator=(const CabinConditionStatusPublish& from) {
     CopyFrom(from);
     return *this;
   }
-  inline SetTemperatureReply& operator=(SetTemperatureReply&& from) noexcept {
+  inline CabinConditionStatusPublish& operator=(CabinConditionStatusPublish&& from) noexcept {
     if (this == &from) return *this;
     if (GetOwningArena() == from.GetOwningArena()
   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
@@ -1031,20 +1330,20 @@ class SetTemperatureReply final :
   static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
     return default_instance().GetMetadata().reflection;
   }
-  static const SetTemperatureReply& default_instance() {
+  static const CabinConditionStatusPublish& default_instance() {
     return *internal_default_instance();
   }
-  static inline const SetTemperatureReply* internal_default_instance() {
-    return reinterpret_cast<const SetTemperatureReply*>(
-               &_SetTemperatureReply_default_instance_);
+  static inline const CabinConditionStatusPublish* internal_default_instance() {
+    return reinterpret_cast<const CabinConditionStatusPublish*>(
+               &_CabinConditionStatusPublish_default_instance_);
   }
   static constexpr int kIndexInFileMessages =
-    5;
+    6;
 
-  friend void swap(SetTemperatureReply& a, SetTemperatureReply& b) {
+  friend void swap(CabinConditionStatusPublish& a, CabinConditionStatusPublish& b) {
     a.Swap(&b);
   }
-  inline void Swap(SetTemperatureReply* other) {
+  inline void Swap(CabinConditionStatusPublish* other) {
     if (other == this) return;
   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
     if (GetOwningArena() != nullptr &&
@@ -1057,7 +1356,7 @@ class SetTemperatureReply final :
       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
     }
   }
-  void UnsafeArenaSwap(SetTemperatureReply* other) {
+  void UnsafeArenaSwap(CabinConditionStatusPublish* other) {
     if (other == this) return;
     ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
     InternalSwap(other);
@@ -1065,14 +1364,14 @@ class SetTemperatureReply final :
 
   // implements Message ----------------------------------------------
 
-  SetTemperatureReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<SetTemperatureReply>(arena);
+  CabinConditionStatusPublish* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CabinConditionStatusPublish>(arena);
   }
   using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const SetTemperatureReply& from);
+  void CopyFrom(const CabinConditionStatusPublish& from);
   using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const SetTemperatureReply& from) {
-    SetTemperatureReply::MergeImpl(*this, from);
+  void MergeFrom( const CabinConditionStatusPublish& from) {
+    CabinConditionStatusPublish::MergeImpl(*this, from);
   }
   private:
   static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
@@ -1090,15 +1389,15 @@ class SetTemperatureReply final :
   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   void SharedDtor();
   void SetCachedSize(int size) const final;
-  void InternalSwap(SetTemperatureReply* other);
+  void InternalSwap(CabinConditionStatusPublish* other);
 
   private:
   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
   static ::absl::string_view FullMessageName() {
-    return "messages.SetTemperatureReply";
+    return "messages.hvac.CabinConditionStatusPublish";
   }
   protected:
-  explicit SetTemperatureReply(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  explicit CabinConditionStatusPublish(::PROTOBUF_NAMESPACE_ID::Arena* arena);
   public:
 
   static const ClassData _class_data_;
@@ -1111,19 +1410,65 @@ class SetTemperatureReply final :
   // accessors -------------------------------------------------------
 
   enum : int {
-    kTempStatusFieldNumber = 1,
+    kEventTimeFieldNumber = 1,
+    kHvacStateFieldNumber = 2,
+    kCabinTemperatureFieldNumber = 3,
   };
-  // .messages.SetTempStatusEnum tempStatus = 1;
-  void clear_tempstatus() ;
-  ::messages::SetTempStatusEnum tempstatus() const;
-  void set_tempstatus(::messages::SetTempStatusEnum value);
+  // .google.protobuf.Timestamp event_time = 1;
+  bool has_event_time() const;
+  private:
+  bool _internal_has_event_time() const;
+
+  public:
+  void clear_event_time() ;
+  const ::PROTOBUF_NAMESPACE_ID::Timestamp& event_time() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Timestamp* release_event_time();
+  ::PROTOBUF_NAMESPACE_ID::Timestamp* mutable_event_time();
+  void set_allocated_event_time(::PROTOBUF_NAMESPACE_ID::Timestamp* event_time);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Timestamp& _internal_event_time() const;
+  ::PROTOBUF_NAMESPACE_ID::Timestamp* _internal_mutable_event_time();
+  public:
+  void unsafe_arena_set_allocated_event_time(
+      ::PROTOBUF_NAMESPACE_ID::Timestamp* event_time);
+  ::PROTOBUF_NAMESPACE_ID::Timestamp* unsafe_arena_release_event_time();
+  // .messages.hvac.HVACState hvac_state = 2;
+  bool has_hvac_state() const;
+  private:
+  bool _internal_has_hvac_state() const;
 
+  public:
+  void clear_hvac_state() ;
+  const ::messages::hvac::HVACState& hvac_state() const;
+  PROTOBUF_NODISCARD ::messages::hvac::HVACState* release_hvac_state();
+  ::messages::hvac::HVACState* mutable_hvac_state();
+  void set_allocated_hvac_state(::messages::hvac::HVACState* hvac_state);
   private:
-  ::messages::SetTempStatusEnum _internal_tempstatus() const;
-  void _internal_set_tempstatus(::messages::SetTempStatusEnum value);
+  const ::messages::hvac::HVACState& _internal_hvac_state() const;
+  ::messages::hvac::HVACState* _internal_mutable_hvac_state();
+  public:
+  void unsafe_arena_set_allocated_hvac_state(
+      ::messages::hvac::HVACState* hvac_state);
+  ::messages::hvac::HVACState* unsafe_arena_release_hvac_state();
+  // .messages.hvac.CabinTemperature cabin_temperature = 3;
+  bool has_cabin_temperature() const;
+  private:
+  bool _internal_has_cabin_temperature() const;
 
   public:
-  // @@protoc_insertion_point(class_scope:messages.SetTemperatureReply)
+  void clear_cabin_temperature() ;
+  const ::messages::hvac::CabinTemperature& cabin_temperature() const;
+  PROTOBUF_NODISCARD ::messages::hvac::CabinTemperature* release_cabin_temperature();
+  ::messages::hvac::CabinTemperature* mutable_cabin_temperature();
+  void set_allocated_cabin_temperature(::messages::hvac::CabinTemperature* cabin_temperature);
+  private:
+  const ::messages::hvac::CabinTemperature& _internal_cabin_temperature() const;
+  ::messages::hvac::CabinTemperature* _internal_mutable_cabin_temperature();
+  public:
+  void unsafe_arena_set_allocated_cabin_temperature(
+      ::messages::hvac::CabinTemperature* cabin_temperature);
+  ::messages::hvac::CabinTemperature* unsafe_arena_release_cabin_temperature();
+  // @@protoc_insertion_point(class_scope:messages.hvac.CabinConditionStatusPublish)
  private:
   class _Internal;
 
@@ -1131,7 +1476,9 @@ class SetTemperatureReply final :
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
   struct Impl_ {
-    int tempstatus_;
+    ::PROTOBUF_NAMESPACE_ID::Timestamp* event_time_;
+    ::messages::hvac::HVACState* hvac_state_;
+    ::messages::hvac::CabinTemperature* cabin_temperature_;
     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
   };
   union { Impl_ _impl_; };
@@ -1152,36 +1499,133 @@ class SetTemperatureReply final :
 #endif  // __GNUC__
 // -------------------------------------------------------------------
 
-// CabinPreconditionRequest
+// Temperature
+
+// float value = 1;
+inline void Temperature::clear_value() {
+  _impl_.value_ = 0;
+}
+inline float Temperature::value() const {
+  // @@protoc_insertion_point(field_get:messages.hvac.Temperature.value)
+  return _internal_value();
+}
+inline void Temperature::set_value(float value) {
+  _internal_set_value(value);
+  // @@protoc_insertion_point(field_set:messages.hvac.Temperature.value)
+}
+inline float Temperature::_internal_value() const {
+  return _impl_.value_;
+}
+inline void Temperature::_internal_set_value(float value) {
+  ;
+  _impl_.value_ = value;
+}
+
+// string unit = 2;
+inline void Temperature::clear_unit() {
+  _impl_.unit_.ClearToEmpty();
+}
+inline const std::string& Temperature::unit() const {
+  // @@protoc_insertion_point(field_get:messages.hvac.Temperature.unit)
+  return _internal_unit();
+}
+template <typename Arg_, typename... Args_>
+inline PROTOBUF_ALWAYS_INLINE void Temperature::set_unit(Arg_&& arg,
+                                                     Args_... args) {
+  ;
+  _impl_.unit_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:messages.hvac.Temperature.unit)
+}
+inline std::string* Temperature::mutable_unit() {
+  std::string* _s = _internal_mutable_unit();
+  // @@protoc_insertion_point(field_mutable:messages.hvac.Temperature.unit)
+  return _s;
+}
+inline const std::string& Temperature::_internal_unit() const {
+  return _impl_.unit_.Get();
+}
+inline void Temperature::_internal_set_unit(const std::string& value) {
+  ;
+
+
+  _impl_.unit_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Temperature::_internal_mutable_unit() {
+  ;
+  return _impl_.unit_.Mutable( GetArenaForAllocation());
+}
+inline std::string* Temperature::release_unit() {
+  // @@protoc_insertion_point(field_release:messages.hvac.Temperature.unit)
+  return _impl_.unit_.Release();
+}
+inline void Temperature::set_allocated_unit(std::string* value) {
+  _impl_.unit_.SetAllocated(value, GetArenaForAllocation());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        if (_impl_.unit_.IsDefault()) {
+          _impl_.unit_.Set("", GetArenaForAllocation());
+        }
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:messages.hvac.Temperature.unit)
+}
+
+// -------------------------------------------------------------------
+
+// HVACZone
+
+// .messages.hvac.HVACZone.Zone zone = 1;
+inline void HVACZone::clear_zone() {
+  _impl_.zone_ = 0;
+}
+inline ::messages::hvac::HVACZone_Zone HVACZone::zone() const {
+  // @@protoc_insertion_point(field_get:messages.hvac.HVACZone.zone)
+  return _internal_zone();
+}
+inline void HVACZone::set_zone(::messages::hvac::HVACZone_Zone value) {
+   _internal_set_zone(value);
+  // @@protoc_insertion_point(field_set:messages.hvac.HVACZone.zone)
+}
+inline ::messages::hvac::HVACZone_Zone HVACZone::_internal_zone() const {
+  return static_cast<::messages::hvac::HVACZone_Zone>(_impl_.zone_);
+}
+inline void HVACZone::_internal_set_zone(::messages::hvac::HVACZone_Zone value) {
+  ;
+  _impl_.zone_ = value;
+}
 
-// .messages.VehicleMessageHeading messageHeader = 1;
-inline bool CabinPreconditionRequest::_internal_has_messageheader() const {
-  return this != internal_default_instance() && _impl_.messageheader_ != nullptr;
+// .messages.hvac.Temperature target_temperature = 2;
+inline bool HVACZone::_internal_has_target_temperature() const {
+  return this != internal_default_instance() && _impl_.target_temperature_ != nullptr;
 }
-inline bool CabinPreconditionRequest::has_messageheader() const {
-  return _internal_has_messageheader();
+inline bool HVACZone::has_target_temperature() const {
+  return _internal_has_target_temperature();
 }
-inline const ::messages::VehicleMessageHeading& CabinPreconditionRequest::_internal_messageheader() const {
-  const ::messages::VehicleMessageHeading* p = _impl_.messageheader_;
-  return p != nullptr ? *p : reinterpret_cast<const ::messages::VehicleMessageHeading&>(
-      ::messages::_VehicleMessageHeading_default_instance_);
+inline void HVACZone::clear_target_temperature() {
+  if (GetArenaForAllocation() == nullptr && _impl_.target_temperature_ != nullptr) {
+    delete _impl_.target_temperature_;
+  }
+  _impl_.target_temperature_ = nullptr;
+}
+inline const ::messages::hvac::Temperature& HVACZone::_internal_target_temperature() const {
+  const ::messages::hvac::Temperature* p = _impl_.target_temperature_;
+  return p != nullptr ? *p : reinterpret_cast<const ::messages::hvac::Temperature&>(
+      ::messages::hvac::_Temperature_default_instance_);
 }
-inline const ::messages::VehicleMessageHeading& CabinPreconditionRequest::messageheader() const {
-  // @@protoc_insertion_point(field_get:messages.CabinPreconditionRequest.messageHeader)
-  return _internal_messageheader();
+inline const ::messages::hvac::Temperature& HVACZone::target_temperature() const {
+  // @@protoc_insertion_point(field_get:messages.hvac.HVACZone.target_temperature)
+  return _internal_target_temperature();
 }
-inline void CabinPreconditionRequest::unsafe_arena_set_allocated_messageheader(
-    ::messages::VehicleMessageHeading* messageheader) {
+inline void HVACZone::unsafe_arena_set_allocated_target_temperature(
+    ::messages::hvac::Temperature* target_temperature) {
   if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messageheader_);
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.target_temperature_);
   }
-  _impl_.messageheader_ = messageheader;
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.CabinPreconditionRequest.messageHeader)
+  _impl_.target_temperature_ = target_temperature;
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.hvac.HVACZone.target_temperature)
 }
-inline ::messages::VehicleMessageHeading* CabinPreconditionRequest::release_messageheader() {
+inline ::messages::hvac::Temperature* HVACZone::release_target_temperature() {
   
-  ::messages::VehicleMessageHeading* temp = _impl_.messageheader_;
-  _impl_.messageheader_ = nullptr;
+  ::messages::hvac::Temperature* temp = _impl_.target_temperature_;
+  _impl_.target_temperature_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
@@ -1193,81 +1637,118 @@ inline ::messages::VehicleMessageHeading* CabinPreconditionRequest::release_mess
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
   return temp;
 }
-inline ::messages::VehicleMessageHeading* CabinPreconditionRequest::unsafe_arena_release_messageheader() {
-  // @@protoc_insertion_point(field_release:messages.CabinPreconditionRequest.messageHeader)
+inline ::messages::hvac::Temperature* HVACZone::unsafe_arena_release_target_temperature() {
+  // @@protoc_insertion_point(field_release:messages.hvac.HVACZone.target_temperature)
   
-  ::messages::VehicleMessageHeading* temp = _impl_.messageheader_;
-  _impl_.messageheader_ = nullptr;
+  ::messages::hvac::Temperature* temp = _impl_.target_temperature_;
+  _impl_.target_temperature_ = nullptr;
   return temp;
 }
-inline ::messages::VehicleMessageHeading* CabinPreconditionRequest::_internal_mutable_messageheader() {
+inline ::messages::hvac::Temperature* HVACZone::_internal_mutable_target_temperature() {
   
-  if (_impl_.messageheader_ == nullptr) {
-    auto* p = CreateMaybeMessage<::messages::VehicleMessageHeading>(GetArenaForAllocation());
-    _impl_.messageheader_ = p;
+  if (_impl_.target_temperature_ == nullptr) {
+    auto* p = CreateMaybeMessage<::messages::hvac::Temperature>(GetArenaForAllocation());
+    _impl_.target_temperature_ = p;
   }
-  return _impl_.messageheader_;
+  return _impl_.target_temperature_;
 }
-inline ::messages::VehicleMessageHeading* CabinPreconditionRequest::mutable_messageheader() {
-  ::messages::VehicleMessageHeading* _msg = _internal_mutable_messageheader();
-  // @@protoc_insertion_point(field_mutable:messages.CabinPreconditionRequest.messageHeader)
+inline ::messages::hvac::Temperature* HVACZone::mutable_target_temperature() {
+  ::messages::hvac::Temperature* _msg = _internal_mutable_target_temperature();
+  // @@protoc_insertion_point(field_mutable:messages.hvac.HVACZone.target_temperature)
   return _msg;
 }
-inline void CabinPreconditionRequest::set_allocated_messageheader(::messages::VehicleMessageHeading* messageheader) {
+inline void HVACZone::set_allocated_target_temperature(::messages::hvac::Temperature* target_temperature) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   if (message_arena == nullptr) {
-    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messageheader_);
+    delete _impl_.target_temperature_;
   }
-  if (messageheader) {
+  if (target_temperature) {
     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
-                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(messageheader));
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(target_temperature);
     if (message_arena != submessage_arena) {
-      messageheader = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, messageheader, submessage_arena);
+      target_temperature = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, target_temperature, submessage_arena);
     }
 
   } else {
 
   }
-  _impl_.messageheader_ = messageheader;
-  // @@protoc_insertion_point(field_set_allocated:messages.CabinPreconditionRequest.messageHeader)
+  _impl_.target_temperature_ = target_temperature;
+  // @@protoc_insertion_point(field_set_allocated:messages.hvac.HVACZone.target_temperature)
 }
 
-// .messages.SetAcStatusRequest setAcStatus = 2;
-inline bool CabinPreconditionRequest::_internal_has_setacstatus() const {
-  return this != internal_default_instance() && _impl_.setacstatus_ != nullptr;
+// -------------------------------------------------------------------
+
+// PreconditionRequest
+
+// repeated .messages.hvac.HVACZone hvac_zones = 1;
+inline int PreconditionRequest::_internal_hvac_zones_size() const {
+  return _impl_.hvac_zones_.size();
 }
-inline bool CabinPreconditionRequest::has_setacstatus() const {
-  return _internal_has_setacstatus();
+inline int PreconditionRequest::hvac_zones_size() const {
+  return _internal_hvac_zones_size();
 }
-inline void CabinPreconditionRequest::clear_setacstatus() {
-  if (GetArenaForAllocation() == nullptr && _impl_.setacstatus_ != nullptr) {
-    delete _impl_.setacstatus_;
-  }
-  _impl_.setacstatus_ = nullptr;
+inline void PreconditionRequest::clear_hvac_zones() {
+  _impl_.hvac_zones_.Clear();
+}
+inline ::messages::hvac::HVACZone* PreconditionRequest::mutable_hvac_zones(int index) {
+  // @@protoc_insertion_point(field_mutable:messages.hvac.PreconditionRequest.hvac_zones)
+  return _impl_.hvac_zones_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::messages::hvac::HVACZone >*
+PreconditionRequest::mutable_hvac_zones() {
+  // @@protoc_insertion_point(field_mutable_list:messages.hvac.PreconditionRequest.hvac_zones)
+  return &_impl_.hvac_zones_;
 }
-inline const ::messages::SetAcStatusRequest& CabinPreconditionRequest::_internal_setacstatus() const {
-  const ::messages::SetAcStatusRequest* p = _impl_.setacstatus_;
-  return p != nullptr ? *p : reinterpret_cast<const ::messages::SetAcStatusRequest&>(
-      ::messages::_SetAcStatusRequest_default_instance_);
+inline const ::messages::hvac::HVACZone& PreconditionRequest::_internal_hvac_zones(int index) const {
+  return _impl_.hvac_zones_.Get(index);
 }
-inline const ::messages::SetAcStatusRequest& CabinPreconditionRequest::setacstatus() const {
-  // @@protoc_insertion_point(field_get:messages.CabinPreconditionRequest.setAcStatus)
-  return _internal_setacstatus();
+inline const ::messages::hvac::HVACZone& PreconditionRequest::hvac_zones(int index) const {
+  // @@protoc_insertion_point(field_get:messages.hvac.PreconditionRequest.hvac_zones)
+  return _internal_hvac_zones(index);
 }
-inline void CabinPreconditionRequest::unsafe_arena_set_allocated_setacstatus(
-    ::messages::SetAcStatusRequest* setacstatus) {
+inline ::messages::hvac::HVACZone* PreconditionRequest::_internal_add_hvac_zones() {
+  return _impl_.hvac_zones_.Add();
+}
+inline ::messages::hvac::HVACZone* PreconditionRequest::add_hvac_zones() {
+  ::messages::hvac::HVACZone* _add = _internal_add_hvac_zones();
+  // @@protoc_insertion_point(field_add:messages.hvac.PreconditionRequest.hvac_zones)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::messages::hvac::HVACZone >&
+PreconditionRequest::hvac_zones() const {
+  // @@protoc_insertion_point(field_list:messages.hvac.PreconditionRequest.hvac_zones)
+  return _impl_.hvac_zones_;
+}
+
+// .google.protobuf.Timestamp start_time = 2;
+inline bool PreconditionRequest::_internal_has_start_time() const {
+  return this != internal_default_instance() && _impl_.start_time_ != nullptr;
+}
+inline bool PreconditionRequest::has_start_time() const {
+  return _internal_has_start_time();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& PreconditionRequest::_internal_start_time() const {
+  const ::PROTOBUF_NAMESPACE_ID::Timestamp* p = _impl_.start_time_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Timestamp&>(
+      ::PROTOBUF_NAMESPACE_ID::_Timestamp_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& PreconditionRequest::start_time() const {
+  // @@protoc_insertion_point(field_get:messages.hvac.PreconditionRequest.start_time)
+  return _internal_start_time();
+}
+inline void PreconditionRequest::unsafe_arena_set_allocated_start_time(
+    ::PROTOBUF_NAMESPACE_ID::Timestamp* start_time) {
   if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.setacstatus_);
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.start_time_);
   }
-  _impl_.setacstatus_ = setacstatus;
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.CabinPreconditionRequest.setAcStatus)
+  _impl_.start_time_ = start_time;
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.hvac.PreconditionRequest.start_time)
 }
-inline ::messages::SetAcStatusRequest* CabinPreconditionRequest::release_setacstatus() {
+inline ::PROTOBUF_NAMESPACE_ID::Timestamp* PreconditionRequest::release_start_time() {
   
-  ::messages::SetAcStatusRequest* temp = _impl_.setacstatus_;
-  _impl_.setacstatus_ = nullptr;
+  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = _impl_.start_time_;
+  _impl_.start_time_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
@@ -1279,80 +1760,176 @@ inline ::messages::SetAcStatusRequest* CabinPreconditionRequest::release_setacst
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
   return temp;
 }
-inline ::messages::SetAcStatusRequest* CabinPreconditionRequest::unsafe_arena_release_setacstatus() {
-  // @@protoc_insertion_point(field_release:messages.CabinPreconditionRequest.setAcStatus)
+inline ::PROTOBUF_NAMESPACE_ID::Timestamp* PreconditionRequest::unsafe_arena_release_start_time() {
+  // @@protoc_insertion_point(field_release:messages.hvac.PreconditionRequest.start_time)
   
-  ::messages::SetAcStatusRequest* temp = _impl_.setacstatus_;
-  _impl_.setacstatus_ = nullptr;
+  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = _impl_.start_time_;
+  _impl_.start_time_ = nullptr;
   return temp;
 }
-inline ::messages::SetAcStatusRequest* CabinPreconditionRequest::_internal_mutable_setacstatus() {
+inline ::PROTOBUF_NAMESPACE_ID::Timestamp* PreconditionRequest::_internal_mutable_start_time() {
   
-  if (_impl_.setacstatus_ == nullptr) {
-    auto* p = CreateMaybeMessage<::messages::SetAcStatusRequest>(GetArenaForAllocation());
-    _impl_.setacstatus_ = p;
+  if (_impl_.start_time_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Timestamp>(GetArenaForAllocation());
+    _impl_.start_time_ = p;
   }
-  return _impl_.setacstatus_;
+  return _impl_.start_time_;
 }
-inline ::messages::SetAcStatusRequest* CabinPreconditionRequest::mutable_setacstatus() {
-  ::messages::SetAcStatusRequest* _msg = _internal_mutable_setacstatus();
-  // @@protoc_insertion_point(field_mutable:messages.CabinPreconditionRequest.setAcStatus)
+inline ::PROTOBUF_NAMESPACE_ID::Timestamp* PreconditionRequest::mutable_start_time() {
+  ::PROTOBUF_NAMESPACE_ID::Timestamp* _msg = _internal_mutable_start_time();
+  // @@protoc_insertion_point(field_mutable:messages.hvac.PreconditionRequest.start_time)
   return _msg;
 }
-inline void CabinPreconditionRequest::set_allocated_setacstatus(::messages::SetAcStatusRequest* setacstatus) {
+inline void PreconditionRequest::set_allocated_start_time(::PROTOBUF_NAMESPACE_ID::Timestamp* start_time) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   if (message_arena == nullptr) {
-    delete _impl_.setacstatus_;
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.start_time_);
   }
-  if (setacstatus) {
+  if (start_time) {
     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(setacstatus);
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(start_time));
     if (message_arena != submessage_arena) {
-      setacstatus = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, setacstatus, submessage_arena);
+      start_time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, start_time, submessage_arena);
     }
 
   } else {
 
   }
-  _impl_.setacstatus_ = setacstatus;
-  // @@protoc_insertion_point(field_set_allocated:messages.CabinPreconditionRequest.setAcStatus)
+  _impl_.start_time_ = start_time;
+  // @@protoc_insertion_point(field_set_allocated:messages.hvac.PreconditionRequest.start_time)
+}
+
+// -------------------------------------------------------------------
+
+// PreconditionResponse
+
+// .messages.hvac.PreconditionResponse.Status status = 1;
+inline void PreconditionResponse::clear_status() {
+  _impl_.status_ = 0;
+}
+inline ::messages::hvac::PreconditionResponse_Status PreconditionResponse::status() const {
+  // @@protoc_insertion_point(field_get:messages.hvac.PreconditionResponse.status)
+  return _internal_status();
+}
+inline void PreconditionResponse::set_status(::messages::hvac::PreconditionResponse_Status value) {
+   _internal_set_status(value);
+  // @@protoc_insertion_point(field_set:messages.hvac.PreconditionResponse.status)
+}
+inline ::messages::hvac::PreconditionResponse_Status PreconditionResponse::_internal_status() const {
+  return static_cast<::messages::hvac::PreconditionResponse_Status>(_impl_.status_);
+}
+inline void PreconditionResponse::_internal_set_status(::messages::hvac::PreconditionResponse_Status value) {
+  ;
+  _impl_.status_ = value;
+}
+
+// string message = 2;
+inline void PreconditionResponse::clear_message() {
+  _impl_.message_.ClearToEmpty();
+}
+inline const std::string& PreconditionResponse::message() const {
+  // @@protoc_insertion_point(field_get:messages.hvac.PreconditionResponse.message)
+  return _internal_message();
+}
+template <typename Arg_, typename... Args_>
+inline PROTOBUF_ALWAYS_INLINE void PreconditionResponse::set_message(Arg_&& arg,
+                                                     Args_... args) {
+  ;
+  _impl_.message_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:messages.hvac.PreconditionResponse.message)
+}
+inline std::string* PreconditionResponse::mutable_message() {
+  std::string* _s = _internal_mutable_message();
+  // @@protoc_insertion_point(field_mutable:messages.hvac.PreconditionResponse.message)
+  return _s;
+}
+inline const std::string& PreconditionResponse::_internal_message() const {
+  return _impl_.message_.Get();
+}
+inline void PreconditionResponse::_internal_set_message(const std::string& value) {
+  ;
+
+
+  _impl_.message_.Set(value, GetArenaForAllocation());
+}
+inline std::string* PreconditionResponse::_internal_mutable_message() {
+  ;
+  return _impl_.message_.Mutable( GetArenaForAllocation());
+}
+inline std::string* PreconditionResponse::release_message() {
+  // @@protoc_insertion_point(field_release:messages.hvac.PreconditionResponse.message)
+  return _impl_.message_.Release();
+}
+inline void PreconditionResponse::set_allocated_message(std::string* value) {
+  _impl_.message_.SetAllocated(value, GetArenaForAllocation());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        if (_impl_.message_.IsDefault()) {
+          _impl_.message_.Set("", GetArenaForAllocation());
+        }
+  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:messages.hvac.PreconditionResponse.message)
+}
+
+// -------------------------------------------------------------------
+
+// HVACState
+
+// .messages.hvac.HVACState.State state = 1;
+inline void HVACState::clear_state() {
+  _impl_.state_ = 0;
+}
+inline ::messages::hvac::HVACState_State HVACState::state() const {
+  // @@protoc_insertion_point(field_get:messages.hvac.HVACState.state)
+  return _internal_state();
+}
+inline void HVACState::set_state(::messages::hvac::HVACState_State value) {
+   _internal_set_state(value);
+  // @@protoc_insertion_point(field_set:messages.hvac.HVACState.state)
+}
+inline ::messages::hvac::HVACState_State HVACState::_internal_state() const {
+  return static_cast<::messages::hvac::HVACState_State>(_impl_.state_);
+}
+inline void HVACState::_internal_set_state(::messages::hvac::HVACState_State value) {
+  ;
+  _impl_.state_ = value;
 }
 
-// .messages.SetTemperatureRequest setTemp = 3;
-inline bool CabinPreconditionRequest::_internal_has_settemp() const {
-  return this != internal_default_instance() && _impl_.settemp_ != nullptr;
+// .messages.hvac.HVACZone current_zone = 2;
+inline bool HVACState::_internal_has_current_zone() const {
+  return this != internal_default_instance() && _impl_.current_zone_ != nullptr;
 }
-inline bool CabinPreconditionRequest::has_settemp() const {
-  return _internal_has_settemp();
+inline bool HVACState::has_current_zone() const {
+  return _internal_has_current_zone();
 }
-inline void CabinPreconditionRequest::clear_settemp() {
-  if (GetArenaForAllocation() == nullptr && _impl_.settemp_ != nullptr) {
-    delete _impl_.settemp_;
+inline void HVACState::clear_current_zone() {
+  if (GetArenaForAllocation() == nullptr && _impl_.current_zone_ != nullptr) {
+    delete _impl_.current_zone_;
   }
-  _impl_.settemp_ = nullptr;
+  _impl_.current_zone_ = nullptr;
 }
-inline const ::messages::SetTemperatureRequest& CabinPreconditionRequest::_internal_settemp() const {
-  const ::messages::SetTemperatureRequest* p = _impl_.settemp_;
-  return p != nullptr ? *p : reinterpret_cast<const ::messages::SetTemperatureRequest&>(
-      ::messages::_SetTemperatureRequest_default_instance_);
+inline const ::messages::hvac::HVACZone& HVACState::_internal_current_zone() const {
+  const ::messages::hvac::HVACZone* p = _impl_.current_zone_;
+  return p != nullptr ? *p : reinterpret_cast<const ::messages::hvac::HVACZone&>(
+      ::messages::hvac::_HVACZone_default_instance_);
 }
-inline const ::messages::SetTemperatureRequest& CabinPreconditionRequest::settemp() const {
-  // @@protoc_insertion_point(field_get:messages.CabinPreconditionRequest.setTemp)
-  return _internal_settemp();
+inline const ::messages::hvac::HVACZone& HVACState::current_zone() const {
+  // @@protoc_insertion_point(field_get:messages.hvac.HVACState.current_zone)
+  return _internal_current_zone();
 }
-inline void CabinPreconditionRequest::unsafe_arena_set_allocated_settemp(
-    ::messages::SetTemperatureRequest* settemp) {
+inline void HVACState::unsafe_arena_set_allocated_current_zone(
+    ::messages::hvac::HVACZone* current_zone) {
   if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.settemp_);
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.current_zone_);
   }
-  _impl_.settemp_ = settemp;
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.CabinPreconditionRequest.setTemp)
+  _impl_.current_zone_ = current_zone;
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.hvac.HVACState.current_zone)
 }
-inline ::messages::SetTemperatureRequest* CabinPreconditionRequest::release_settemp() {
+inline ::messages::hvac::HVACZone* HVACState::release_current_zone() {
   
-  ::messages::SetTemperatureRequest* temp = _impl_.settemp_;
-  _impl_.settemp_ = nullptr;
+  ::messages::hvac::HVACZone* temp = _impl_.current_zone_;
+  _impl_.current_zone_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
@@ -1364,78 +1941,84 @@ inline ::messages::SetTemperatureRequest* CabinPreconditionRequest::release_sett
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
   return temp;
 }
-inline ::messages::SetTemperatureRequest* CabinPreconditionRequest::unsafe_arena_release_settemp() {
-  // @@protoc_insertion_point(field_release:messages.CabinPreconditionRequest.setTemp)
+inline ::messages::hvac::HVACZone* HVACState::unsafe_arena_release_current_zone() {
+  // @@protoc_insertion_point(field_release:messages.hvac.HVACState.current_zone)
   
-  ::messages::SetTemperatureRequest* temp = _impl_.settemp_;
-  _impl_.settemp_ = nullptr;
+  ::messages::hvac::HVACZone* temp = _impl_.current_zone_;
+  _impl_.current_zone_ = nullptr;
   return temp;
 }
-inline ::messages::SetTemperatureRequest* CabinPreconditionRequest::_internal_mutable_settemp() {
+inline ::messages::hvac::HVACZone* HVACState::_internal_mutable_current_zone() {
   
-  if (_impl_.settemp_ == nullptr) {
-    auto* p = CreateMaybeMessage<::messages::SetTemperatureRequest>(GetArenaForAllocation());
-    _impl_.settemp_ = p;
+  if (_impl_.current_zone_ == nullptr) {
+    auto* p = CreateMaybeMessage<::messages::hvac::HVACZone>(GetArenaForAllocation());
+    _impl_.current_zone_ = p;
   }
-  return _impl_.settemp_;
+  return _impl_.current_zone_;
 }
-inline ::messages::SetTemperatureRequest* CabinPreconditionRequest::mutable_settemp() {
-  ::messages::SetTemperatureRequest* _msg = _internal_mutable_settemp();
-  // @@protoc_insertion_point(field_mutable:messages.CabinPreconditionRequest.setTemp)
+inline ::messages::hvac::HVACZone* HVACState::mutable_current_zone() {
+  ::messages::hvac::HVACZone* _msg = _internal_mutable_current_zone();
+  // @@protoc_insertion_point(field_mutable:messages.hvac.HVACState.current_zone)
   return _msg;
 }
-inline void CabinPreconditionRequest::set_allocated_settemp(::messages::SetTemperatureRequest* settemp) {
+inline void HVACState::set_allocated_current_zone(::messages::hvac::HVACZone* current_zone) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   if (message_arena == nullptr) {
-    delete _impl_.settemp_;
+    delete _impl_.current_zone_;
   }
-  if (settemp) {
+  if (current_zone) {
     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(settemp);
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(current_zone);
     if (message_arena != submessage_arena) {
-      settemp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, settemp, submessage_arena);
+      current_zone = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, current_zone, submessage_arena);
     }
 
   } else {
 
   }
-  _impl_.settemp_ = settemp;
-  // @@protoc_insertion_point(field_set_allocated:messages.CabinPreconditionRequest.setTemp)
+  _impl_.current_zone_ = current_zone;
+  // @@protoc_insertion_point(field_set_allocated:messages.hvac.HVACState.current_zone)
 }
 
 // -------------------------------------------------------------------
 
-// CabinPreConditionReponse
+// CabinTemperature
 
-// .messages.VehicleMessageHeading messageHeader = 1;
-inline bool CabinPreConditionReponse::_internal_has_messageheader() const {
-  return this != internal_default_instance() && _impl_.messageheader_ != nullptr;
+// .messages.hvac.Temperature temperature = 1;
+inline bool CabinTemperature::_internal_has_temperature() const {
+  return this != internal_default_instance() && _impl_.temperature_ != nullptr;
+}
+inline bool CabinTemperature::has_temperature() const {
+  return _internal_has_temperature();
 }
-inline bool CabinPreConditionReponse::has_messageheader() const {
-  return _internal_has_messageheader();
+inline void CabinTemperature::clear_temperature() {
+  if (GetArenaForAllocation() == nullptr && _impl_.temperature_ != nullptr) {
+    delete _impl_.temperature_;
+  }
+  _impl_.temperature_ = nullptr;
 }
-inline const ::messages::VehicleMessageHeading& CabinPreConditionReponse::_internal_messageheader() const {
-  const ::messages::VehicleMessageHeading* p = _impl_.messageheader_;
-  return p != nullptr ? *p : reinterpret_cast<const ::messages::VehicleMessageHeading&>(
-      ::messages::_VehicleMessageHeading_default_instance_);
+inline const ::messages::hvac::Temperature& CabinTemperature::_internal_temperature() const {
+  const ::messages::hvac::Temperature* p = _impl_.temperature_;
+  return p != nullptr ? *p : reinterpret_cast<const ::messages::hvac::Temperature&>(
+      ::messages::hvac::_Temperature_default_instance_);
 }
-inline const ::messages::VehicleMessageHeading& CabinPreConditionReponse::messageheader() const {
-  // @@protoc_insertion_point(field_get:messages.CabinPreConditionReponse.messageHeader)
-  return _internal_messageheader();
+inline const ::messages::hvac::Temperature& CabinTemperature::temperature() const {
+  // @@protoc_insertion_point(field_get:messages.hvac.CabinTemperature.temperature)
+  return _internal_temperature();
 }
-inline void CabinPreConditionReponse::unsafe_arena_set_allocated_messageheader(
-    ::messages::VehicleMessageHeading* messageheader) {
+inline void CabinTemperature::unsafe_arena_set_allocated_temperature(
+    ::messages::hvac::Temperature* temperature) {
   if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messageheader_);
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.temperature_);
   }
-  _impl_.messageheader_ = messageheader;
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.CabinPreConditionReponse.messageHeader)
+  _impl_.temperature_ = temperature;
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.hvac.CabinTemperature.temperature)
 }
-inline ::messages::VehicleMessageHeading* CabinPreConditionReponse::release_messageheader() {
+inline ::messages::hvac::Temperature* CabinTemperature::release_temperature() {
   
-  ::messages::VehicleMessageHeading* temp = _impl_.messageheader_;
-  _impl_.messageheader_ = nullptr;
+  ::messages::hvac::Temperature* temp = _impl_.temperature_;
+  _impl_.temperature_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
@@ -1447,81 +2030,80 @@ inline ::messages::VehicleMessageHeading* CabinPreConditionReponse::release_mess
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
   return temp;
 }
-inline ::messages::VehicleMessageHeading* CabinPreConditionReponse::unsafe_arena_release_messageheader() {
-  // @@protoc_insertion_point(field_release:messages.CabinPreConditionReponse.messageHeader)
+inline ::messages::hvac::Temperature* CabinTemperature::unsafe_arena_release_temperature() {
+  // @@protoc_insertion_point(field_release:messages.hvac.CabinTemperature.temperature)
   
-  ::messages::VehicleMessageHeading* temp = _impl_.messageheader_;
-  _impl_.messageheader_ = nullptr;
+  ::messages::hvac::Temperature* temp = _impl_.temperature_;
+  _impl_.temperature_ = nullptr;
   return temp;
 }
-inline ::messages::VehicleMessageHeading* CabinPreConditionReponse::_internal_mutable_messageheader() {
+inline ::messages::hvac::Temperature* CabinTemperature::_internal_mutable_temperature() {
   
-  if (_impl_.messageheader_ == nullptr) {
-    auto* p = CreateMaybeMessage<::messages::VehicleMessageHeading>(GetArenaForAllocation());
-    _impl_.messageheader_ = p;
+  if (_impl_.temperature_ == nullptr) {
+    auto* p = CreateMaybeMessage<::messages::hvac::Temperature>(GetArenaForAllocation());
+    _impl_.temperature_ = p;
   }
-  return _impl_.messageheader_;
+  return _impl_.temperature_;
 }
-inline ::messages::VehicleMessageHeading* CabinPreConditionReponse::mutable_messageheader() {
-  ::messages::VehicleMessageHeading* _msg = _internal_mutable_messageheader();
-  // @@protoc_insertion_point(field_mutable:messages.CabinPreConditionReponse.messageHeader)
+inline ::messages::hvac::Temperature* CabinTemperature::mutable_temperature() {
+  ::messages::hvac::Temperature* _msg = _internal_mutable_temperature();
+  // @@protoc_insertion_point(field_mutable:messages.hvac.CabinTemperature.temperature)
   return _msg;
 }
-inline void CabinPreConditionReponse::set_allocated_messageheader(::messages::VehicleMessageHeading* messageheader) {
+inline void CabinTemperature::set_allocated_temperature(::messages::hvac::Temperature* temperature) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   if (message_arena == nullptr) {
-    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messageheader_);
+    delete _impl_.temperature_;
   }
-  if (messageheader) {
+  if (temperature) {
     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
-                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(messageheader));
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(temperature);
     if (message_arena != submessage_arena) {
-      messageheader = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, messageheader, submessage_arena);
+      temperature = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, temperature, submessage_arena);
     }
 
   } else {
 
   }
-  _impl_.messageheader_ = messageheader;
-  // @@protoc_insertion_point(field_set_allocated:messages.CabinPreConditionReponse.messageHeader)
+  _impl_.temperature_ = temperature;
+  // @@protoc_insertion_point(field_set_allocated:messages.hvac.CabinTemperature.temperature)
 }
 
-// .messages.SetAcStatusReply setAcStatusReply = 2;
-inline bool CabinPreConditionReponse::_internal_has_setacstatusreply() const {
-  return this != internal_default_instance() && _impl_.setacstatusreply_ != nullptr;
+// .messages.hvac.HVACZone zone = 2;
+inline bool CabinTemperature::_internal_has_zone() const {
+  return this != internal_default_instance() && _impl_.zone_ != nullptr;
 }
-inline bool CabinPreConditionReponse::has_setacstatusreply() const {
-  return _internal_has_setacstatusreply();
+inline bool CabinTemperature::has_zone() const {
+  return _internal_has_zone();
 }
-inline void CabinPreConditionReponse::clear_setacstatusreply() {
-  if (GetArenaForAllocation() == nullptr && _impl_.setacstatusreply_ != nullptr) {
-    delete _impl_.setacstatusreply_;
+inline void CabinTemperature::clear_zone() {
+  if (GetArenaForAllocation() == nullptr && _impl_.zone_ != nullptr) {
+    delete _impl_.zone_;
   }
-  _impl_.setacstatusreply_ = nullptr;
+  _impl_.zone_ = nullptr;
 }
-inline const ::messages::SetAcStatusReply& CabinPreConditionReponse::_internal_setacstatusreply() const {
-  const ::messages::SetAcStatusReply* p = _impl_.setacstatusreply_;
-  return p != nullptr ? *p : reinterpret_cast<const ::messages::SetAcStatusReply&>(
-      ::messages::_SetAcStatusReply_default_instance_);
+inline const ::messages::hvac::HVACZone& CabinTemperature::_internal_zone() const {
+  const ::messages::hvac::HVACZone* p = _impl_.zone_;
+  return p != nullptr ? *p : reinterpret_cast<const ::messages::hvac::HVACZone&>(
+      ::messages::hvac::_HVACZone_default_instance_);
 }
-inline const ::messages::SetAcStatusReply& CabinPreConditionReponse::setacstatusreply() const {
-  // @@protoc_insertion_point(field_get:messages.CabinPreConditionReponse.setAcStatusReply)
-  return _internal_setacstatusreply();
+inline const ::messages::hvac::HVACZone& CabinTemperature::zone() const {
+  // @@protoc_insertion_point(field_get:messages.hvac.CabinTemperature.zone)
+  return _internal_zone();
 }
-inline void CabinPreConditionReponse::unsafe_arena_set_allocated_setacstatusreply(
-    ::messages::SetAcStatusReply* setacstatusreply) {
+inline void CabinTemperature::unsafe_arena_set_allocated_zone(
+    ::messages::hvac::HVACZone* zone) {
   if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.setacstatusreply_);
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.zone_);
   }
-  _impl_.setacstatusreply_ = setacstatusreply;
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.CabinPreConditionReponse.setAcStatusReply)
+  _impl_.zone_ = zone;
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.hvac.CabinTemperature.zone)
 }
-inline ::messages::SetAcStatusReply* CabinPreConditionReponse::release_setacstatusreply() {
+inline ::messages::hvac::HVACZone* CabinTemperature::release_zone() {
   
-  ::messages::SetAcStatusReply* temp = _impl_.setacstatusreply_;
-  _impl_.setacstatusreply_ = nullptr;
+  ::messages::hvac::HVACZone* temp = _impl_.zone_;
+  _impl_.zone_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
@@ -1533,80 +2115,78 @@ inline ::messages::SetAcStatusReply* CabinPreConditionReponse::release_setacstat
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
   return temp;
 }
-inline ::messages::SetAcStatusReply* CabinPreConditionReponse::unsafe_arena_release_setacstatusreply() {
-  // @@protoc_insertion_point(field_release:messages.CabinPreConditionReponse.setAcStatusReply)
+inline ::messages::hvac::HVACZone* CabinTemperature::unsafe_arena_release_zone() {
+  // @@protoc_insertion_point(field_release:messages.hvac.CabinTemperature.zone)
   
-  ::messages::SetAcStatusReply* temp = _impl_.setacstatusreply_;
-  _impl_.setacstatusreply_ = nullptr;
+  ::messages::hvac::HVACZone* temp = _impl_.zone_;
+  _impl_.zone_ = nullptr;
   return temp;
 }
-inline ::messages::SetAcStatusReply* CabinPreConditionReponse::_internal_mutable_setacstatusreply() {
+inline ::messages::hvac::HVACZone* CabinTemperature::_internal_mutable_zone() {
   
-  if (_impl_.setacstatusreply_ == nullptr) {
-    auto* p = CreateMaybeMessage<::messages::SetAcStatusReply>(GetArenaForAllocation());
-    _impl_.setacstatusreply_ = p;
+  if (_impl_.zone_ == nullptr) {
+    auto* p = CreateMaybeMessage<::messages::hvac::HVACZone>(GetArenaForAllocation());
+    _impl_.zone_ = p;
   }
-  return _impl_.setacstatusreply_;
+  return _impl_.zone_;
 }
-inline ::messages::SetAcStatusReply* CabinPreConditionReponse::mutable_setacstatusreply() {
-  ::messages::SetAcStatusReply* _msg = _internal_mutable_setacstatusreply();
-  // @@protoc_insertion_point(field_mutable:messages.CabinPreConditionReponse.setAcStatusReply)
+inline ::messages::hvac::HVACZone* CabinTemperature::mutable_zone() {
+  ::messages::hvac::HVACZone* _msg = _internal_mutable_zone();
+  // @@protoc_insertion_point(field_mutable:messages.hvac.CabinTemperature.zone)
   return _msg;
 }
-inline void CabinPreConditionReponse::set_allocated_setacstatusreply(::messages::SetAcStatusReply* setacstatusreply) {
+inline void CabinTemperature::set_allocated_zone(::messages::hvac::HVACZone* zone) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   if (message_arena == nullptr) {
-    delete _impl_.setacstatusreply_;
+    delete _impl_.zone_;
   }
-  if (setacstatusreply) {
+  if (zone) {
     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(setacstatusreply);
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(zone);
     if (message_arena != submessage_arena) {
-      setacstatusreply = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, setacstatusreply, submessage_arena);
+      zone = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, zone, submessage_arena);
     }
 
   } else {
 
   }
-  _impl_.setacstatusreply_ = setacstatusreply;
-  // @@protoc_insertion_point(field_set_allocated:messages.CabinPreConditionReponse.setAcStatusReply)
+  _impl_.zone_ = zone;
+  // @@protoc_insertion_point(field_set_allocated:messages.hvac.CabinTemperature.zone)
 }
 
-// .messages.SetTemperatureReply setTemperatureReply = 3;
-inline bool CabinPreConditionReponse::_internal_has_settemperaturereply() const {
-  return this != internal_default_instance() && _impl_.settemperaturereply_ != nullptr;
-}
-inline bool CabinPreConditionReponse::has_settemperaturereply() const {
-  return _internal_has_settemperaturereply();
+// -------------------------------------------------------------------
+
+// CabinConditionStatusPublish
+
+// .google.protobuf.Timestamp event_time = 1;
+inline bool CabinConditionStatusPublish::_internal_has_event_time() const {
+  return this != internal_default_instance() && _impl_.event_time_ != nullptr;
 }
-inline void CabinPreConditionReponse::clear_settemperaturereply() {
-  if (GetArenaForAllocation() == nullptr && _impl_.settemperaturereply_ != nullptr) {
-    delete _impl_.settemperaturereply_;
-  }
-  _impl_.settemperaturereply_ = nullptr;
+inline bool CabinConditionStatusPublish::has_event_time() const {
+  return _internal_has_event_time();
 }
-inline const ::messages::SetTemperatureReply& CabinPreConditionReponse::_internal_settemperaturereply() const {
-  const ::messages::SetTemperatureReply* p = _impl_.settemperaturereply_;
-  return p != nullptr ? *p : reinterpret_cast<const ::messages::SetTemperatureReply&>(
-      ::messages::_SetTemperatureReply_default_instance_);
+inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& CabinConditionStatusPublish::_internal_event_time() const {
+  const ::PROTOBUF_NAMESPACE_ID::Timestamp* p = _impl_.event_time_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Timestamp&>(
+      ::PROTOBUF_NAMESPACE_ID::_Timestamp_default_instance_);
 }
-inline const ::messages::SetTemperatureReply& CabinPreConditionReponse::settemperaturereply() const {
-  // @@protoc_insertion_point(field_get:messages.CabinPreConditionReponse.setTemperatureReply)
-  return _internal_settemperaturereply();
+inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& CabinConditionStatusPublish::event_time() const {
+  // @@protoc_insertion_point(field_get:messages.hvac.CabinConditionStatusPublish.event_time)
+  return _internal_event_time();
 }
-inline void CabinPreConditionReponse::unsafe_arena_set_allocated_settemperaturereply(
-    ::messages::SetTemperatureReply* settemperaturereply) {
+inline void CabinConditionStatusPublish::unsafe_arena_set_allocated_event_time(
+    ::PROTOBUF_NAMESPACE_ID::Timestamp* event_time) {
   if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.settemperaturereply_);
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.event_time_);
   }
-  _impl_.settemperaturereply_ = settemperaturereply;
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.CabinPreConditionReponse.setTemperatureReply)
+  _impl_.event_time_ = event_time;
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.hvac.CabinConditionStatusPublish.event_time)
 }
-inline ::messages::SetTemperatureReply* CabinPreConditionReponse::release_settemperaturereply() {
+inline ::PROTOBUF_NAMESPACE_ID::Timestamp* CabinConditionStatusPublish::release_event_time() {
   
-  ::messages::SetTemperatureReply* temp = _impl_.settemperaturereply_;
-  _impl_.settemperaturereply_ = nullptr;
+  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = _impl_.event_time_;
+  _impl_.event_time_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
@@ -1618,140 +2198,215 @@ inline ::messages::SetTemperatureReply* CabinPreConditionReponse::release_settem
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
   return temp;
 }
-inline ::messages::SetTemperatureReply* CabinPreConditionReponse::unsafe_arena_release_settemperaturereply() {
-  // @@protoc_insertion_point(field_release:messages.CabinPreConditionReponse.setTemperatureReply)
+inline ::PROTOBUF_NAMESPACE_ID::Timestamp* CabinConditionStatusPublish::unsafe_arena_release_event_time() {
+  // @@protoc_insertion_point(field_release:messages.hvac.CabinConditionStatusPublish.event_time)
   
-  ::messages::SetTemperatureReply* temp = _impl_.settemperaturereply_;
-  _impl_.settemperaturereply_ = nullptr;
+  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = _impl_.event_time_;
+  _impl_.event_time_ = nullptr;
   return temp;
 }
-inline ::messages::SetTemperatureReply* CabinPreConditionReponse::_internal_mutable_settemperaturereply() {
+inline ::PROTOBUF_NAMESPACE_ID::Timestamp* CabinConditionStatusPublish::_internal_mutable_event_time() {
   
-  if (_impl_.settemperaturereply_ == nullptr) {
-    auto* p = CreateMaybeMessage<::messages::SetTemperatureReply>(GetArenaForAllocation());
-    _impl_.settemperaturereply_ = p;
+  if (_impl_.event_time_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Timestamp>(GetArenaForAllocation());
+    _impl_.event_time_ = p;
   }
-  return _impl_.settemperaturereply_;
+  return _impl_.event_time_;
 }
-inline ::messages::SetTemperatureReply* CabinPreConditionReponse::mutable_settemperaturereply() {
-  ::messages::SetTemperatureReply* _msg = _internal_mutable_settemperaturereply();
-  // @@protoc_insertion_point(field_mutable:messages.CabinPreConditionReponse.setTemperatureReply)
+inline ::PROTOBUF_NAMESPACE_ID::Timestamp* CabinConditionStatusPublish::mutable_event_time() {
+  ::PROTOBUF_NAMESPACE_ID::Timestamp* _msg = _internal_mutable_event_time();
+  // @@protoc_insertion_point(field_mutable:messages.hvac.CabinConditionStatusPublish.event_time)
   return _msg;
 }
-inline void CabinPreConditionReponse::set_allocated_settemperaturereply(::messages::SetTemperatureReply* settemperaturereply) {
+inline void CabinConditionStatusPublish::set_allocated_event_time(::PROTOBUF_NAMESPACE_ID::Timestamp* event_time) {
   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
   if (message_arena == nullptr) {
-    delete _impl_.settemperaturereply_;
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.event_time_);
   }
-  if (settemperaturereply) {
+  if (event_time) {
     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(settemperaturereply);
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(event_time));
     if (message_arena != submessage_arena) {
-      settemperaturereply = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, settemperaturereply, submessage_arena);
+      event_time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, event_time, submessage_arena);
     }
 
   } else {
 
   }
-  _impl_.settemperaturereply_ = settemperaturereply;
-  // @@protoc_insertion_point(field_set_allocated:messages.CabinPreConditionReponse.setTemperatureReply)
+  _impl_.event_time_ = event_time;
+  // @@protoc_insertion_point(field_set_allocated:messages.hvac.CabinConditionStatusPublish.event_time)
 }
 
-// -------------------------------------------------------------------
-
-// SetAcStatusRequest
-
-// .messages.AcStatusEnum desiredStatus = 1;
-inline void SetAcStatusRequest::clear_desiredstatus() {
-  _impl_.desiredstatus_ = 0;
+// .messages.hvac.HVACState hvac_state = 2;
+inline bool CabinConditionStatusPublish::_internal_has_hvac_state() const {
+  return this != internal_default_instance() && _impl_.hvac_state_ != nullptr;
 }
-inline ::messages::AcStatusEnum SetAcStatusRequest::desiredstatus() const {
-  // @@protoc_insertion_point(field_get:messages.SetAcStatusRequest.desiredStatus)
-  return _internal_desiredstatus();
+inline bool CabinConditionStatusPublish::has_hvac_state() const {
+  return _internal_has_hvac_state();
 }
-inline void SetAcStatusRequest::set_desiredstatus(::messages::AcStatusEnum value) {
-   _internal_set_desiredstatus(value);
-  // @@protoc_insertion_point(field_set:messages.SetAcStatusRequest.desiredStatus)
+inline void CabinConditionStatusPublish::clear_hvac_state() {
+  if (GetArenaForAllocation() == nullptr && _impl_.hvac_state_ != nullptr) {
+    delete _impl_.hvac_state_;
+  }
+  _impl_.hvac_state_ = nullptr;
 }
-inline ::messages::AcStatusEnum SetAcStatusRequest::_internal_desiredstatus() const {
-  return static_cast<::messages::AcStatusEnum>(_impl_.desiredstatus_);
+inline const ::messages::hvac::HVACState& CabinConditionStatusPublish::_internal_hvac_state() const {
+  const ::messages::hvac::HVACState* p = _impl_.hvac_state_;
+  return p != nullptr ? *p : reinterpret_cast<const ::messages::hvac::HVACState&>(
+      ::messages::hvac::_HVACState_default_instance_);
 }
-inline void SetAcStatusRequest::_internal_set_desiredstatus(::messages::AcStatusEnum value) {
-  ;
-  _impl_.desiredstatus_ = value;
+inline const ::messages::hvac::HVACState& CabinConditionStatusPublish::hvac_state() const {
+  // @@protoc_insertion_point(field_get:messages.hvac.CabinConditionStatusPublish.hvac_state)
+  return _internal_hvac_state();
 }
-
-// -------------------------------------------------------------------
-
-// SetAcStatusReply
-
-// .messages.AcStatusEnum status = 1;
-inline void SetAcStatusReply::clear_status() {
-  _impl_.status_ = 0;
+inline void CabinConditionStatusPublish::unsafe_arena_set_allocated_hvac_state(
+    ::messages::hvac::HVACState* hvac_state) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hvac_state_);
+  }
+  _impl_.hvac_state_ = hvac_state;
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.hvac.CabinConditionStatusPublish.hvac_state)
 }
-inline ::messages::AcStatusEnum SetAcStatusReply::status() const {
-  // @@protoc_insertion_point(field_get:messages.SetAcStatusReply.status)
-  return _internal_status();
+inline ::messages::hvac::HVACState* CabinConditionStatusPublish::release_hvac_state() {
+  
+  ::messages::hvac::HVACState* temp = _impl_.hvac_state_;
+  _impl_.hvac_state_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
 }
-inline void SetAcStatusReply::set_status(::messages::AcStatusEnum value) {
-   _internal_set_status(value);
-  // @@protoc_insertion_point(field_set:messages.SetAcStatusReply.status)
+inline ::messages::hvac::HVACState* CabinConditionStatusPublish::unsafe_arena_release_hvac_state() {
+  // @@protoc_insertion_point(field_release:messages.hvac.CabinConditionStatusPublish.hvac_state)
+  
+  ::messages::hvac::HVACState* temp = _impl_.hvac_state_;
+  _impl_.hvac_state_ = nullptr;
+  return temp;
 }
-inline ::messages::AcStatusEnum SetAcStatusReply::_internal_status() const {
-  return static_cast<::messages::AcStatusEnum>(_impl_.status_);
+inline ::messages::hvac::HVACState* CabinConditionStatusPublish::_internal_mutable_hvac_state() {
+  
+  if (_impl_.hvac_state_ == nullptr) {
+    auto* p = CreateMaybeMessage<::messages::hvac::HVACState>(GetArenaForAllocation());
+    _impl_.hvac_state_ = p;
+  }
+  return _impl_.hvac_state_;
 }
-inline void SetAcStatusReply::_internal_set_status(::messages::AcStatusEnum value) {
-  ;
-  _impl_.status_ = value;
+inline ::messages::hvac::HVACState* CabinConditionStatusPublish::mutable_hvac_state() {
+  ::messages::hvac::HVACState* _msg = _internal_mutable_hvac_state();
+  // @@protoc_insertion_point(field_mutable:messages.hvac.CabinConditionStatusPublish.hvac_state)
+  return _msg;
 }
+inline void CabinConditionStatusPublish::set_allocated_hvac_state(::messages::hvac::HVACState* hvac_state) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.hvac_state_;
+  }
+  if (hvac_state) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hvac_state);
+    if (message_arena != submessage_arena) {
+      hvac_state = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, hvac_state, submessage_arena);
+    }
 
-// -------------------------------------------------------------------
+  } else {
 
-// SetTemperatureRequest
+  }
+  _impl_.hvac_state_ = hvac_state;
+  // @@protoc_insertion_point(field_set_allocated:messages.hvac.CabinConditionStatusPublish.hvac_state)
+}
 
-// float temperature = 1;
-inline void SetTemperatureRequest::clear_temperature() {
-  _impl_.temperature_ = 0;
+// .messages.hvac.CabinTemperature cabin_temperature = 3;
+inline bool CabinConditionStatusPublish::_internal_has_cabin_temperature() const {
+  return this != internal_default_instance() && _impl_.cabin_temperature_ != nullptr;
 }
-inline float SetTemperatureRequest::temperature() const {
-  // @@protoc_insertion_point(field_get:messages.SetTemperatureRequest.temperature)
-  return _internal_temperature();
+inline bool CabinConditionStatusPublish::has_cabin_temperature() const {
+  return _internal_has_cabin_temperature();
 }
-inline void SetTemperatureRequest::set_temperature(float value) {
-  _internal_set_temperature(value);
-  // @@protoc_insertion_point(field_set:messages.SetTemperatureRequest.temperature)
+inline void CabinConditionStatusPublish::clear_cabin_temperature() {
+  if (GetArenaForAllocation() == nullptr && _impl_.cabin_temperature_ != nullptr) {
+    delete _impl_.cabin_temperature_;
+  }
+  _impl_.cabin_temperature_ = nullptr;
 }
-inline float SetTemperatureRequest::_internal_temperature() const {
-  return _impl_.temperature_;
+inline const ::messages::hvac::CabinTemperature& CabinConditionStatusPublish::_internal_cabin_temperature() const {
+  const ::messages::hvac::CabinTemperature* p = _impl_.cabin_temperature_;
+  return p != nullptr ? *p : reinterpret_cast<const ::messages::hvac::CabinTemperature&>(
+      ::messages::hvac::_CabinTemperature_default_instance_);
 }
-inline void SetTemperatureRequest::_internal_set_temperature(float value) {
-  ;
-  _impl_.temperature_ = value;
+inline const ::messages::hvac::CabinTemperature& CabinConditionStatusPublish::cabin_temperature() const {
+  // @@protoc_insertion_point(field_get:messages.hvac.CabinConditionStatusPublish.cabin_temperature)
+  return _internal_cabin_temperature();
 }
-
-// -------------------------------------------------------------------
-
-// SetTemperatureReply
-
-// .messages.SetTempStatusEnum tempStatus = 1;
-inline void SetTemperatureReply::clear_tempstatus() {
-  _impl_.tempstatus_ = 0;
+inline void CabinConditionStatusPublish::unsafe_arena_set_allocated_cabin_temperature(
+    ::messages::hvac::CabinTemperature* cabin_temperature) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cabin_temperature_);
+  }
+  _impl_.cabin_temperature_ = cabin_temperature;
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.hvac.CabinConditionStatusPublish.cabin_temperature)
 }
-inline ::messages::SetTempStatusEnum SetTemperatureReply::tempstatus() const {
-  // @@protoc_insertion_point(field_get:messages.SetTemperatureReply.tempStatus)
-  return _internal_tempstatus();
+inline ::messages::hvac::CabinTemperature* CabinConditionStatusPublish::release_cabin_temperature() {
+  
+  ::messages::hvac::CabinTemperature* temp = _impl_.cabin_temperature_;
+  _impl_.cabin_temperature_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
 }
-inline void SetTemperatureReply::set_tempstatus(::messages::SetTempStatusEnum value) {
-   _internal_set_tempstatus(value);
-  // @@protoc_insertion_point(field_set:messages.SetTemperatureReply.tempStatus)
+inline ::messages::hvac::CabinTemperature* CabinConditionStatusPublish::unsafe_arena_release_cabin_temperature() {
+  // @@protoc_insertion_point(field_release:messages.hvac.CabinConditionStatusPublish.cabin_temperature)
+  
+  ::messages::hvac::CabinTemperature* temp = _impl_.cabin_temperature_;
+  _impl_.cabin_temperature_ = nullptr;
+  return temp;
 }
-inline ::messages::SetTempStatusEnum SetTemperatureReply::_internal_tempstatus() const {
-  return static_cast<::messages::SetTempStatusEnum>(_impl_.tempstatus_);
+inline ::messages::hvac::CabinTemperature* CabinConditionStatusPublish::_internal_mutable_cabin_temperature() {
+  
+  if (_impl_.cabin_temperature_ == nullptr) {
+    auto* p = CreateMaybeMessage<::messages::hvac::CabinTemperature>(GetArenaForAllocation());
+    _impl_.cabin_temperature_ = p;
+  }
+  return _impl_.cabin_temperature_;
 }
-inline void SetTemperatureReply::_internal_set_tempstatus(::messages::SetTempStatusEnum value) {
-  ;
-  _impl_.tempstatus_ = value;
+inline ::messages::hvac::CabinTemperature* CabinConditionStatusPublish::mutable_cabin_temperature() {
+  ::messages::hvac::CabinTemperature* _msg = _internal_mutable_cabin_temperature();
+  // @@protoc_insertion_point(field_mutable:messages.hvac.CabinConditionStatusPublish.cabin_temperature)
+  return _msg;
+}
+inline void CabinConditionStatusPublish::set_allocated_cabin_temperature(::messages::hvac::CabinTemperature* cabin_temperature) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.cabin_temperature_;
+  }
+  if (cabin_temperature) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cabin_temperature);
+    if (message_arena != submessage_arena) {
+      cabin_temperature = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, cabin_temperature, submessage_arena);
+    }
+
+  } else {
+
+  }
+  _impl_.cabin_temperature_ = cabin_temperature;
+  // @@protoc_insertion_point(field_set_allocated:messages.hvac.CabinConditionStatusPublish.cabin_temperature)
 }
 
 #ifdef __GNUC__
@@ -1759,22 +2414,29 @@ inline void SetTemperatureReply::_internal_set_tempstatus(::messages::SetTempSta
 #endif  // __GNUC__
 
 // @@protoc_insertion_point(namespace_scope)
+}  // namespace hvac
 }  // namespace messages
 
 
 PROTOBUF_NAMESPACE_OPEN
 
 template <>
-struct is_proto_enum<::messages::AcStatusEnum> : std::true_type {};
+struct is_proto_enum<::messages::hvac::HVACZone_Zone> : std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor<::messages::hvac::HVACZone_Zone>() {
+  return ::messages::hvac::HVACZone_Zone_descriptor();
+}
+template <>
+struct is_proto_enum<::messages::hvac::PreconditionResponse_Status> : std::true_type {};
 template <>
-inline const EnumDescriptor* GetEnumDescriptor<::messages::AcStatusEnum>() {
-  return ::messages::AcStatusEnum_descriptor();
+inline const EnumDescriptor* GetEnumDescriptor<::messages::hvac::PreconditionResponse_Status>() {
+  return ::messages::hvac::PreconditionResponse_Status_descriptor();
 }
 template <>
-struct is_proto_enum<::messages::SetTempStatusEnum> : std::true_type {};
+struct is_proto_enum<::messages::hvac::HVACState_State> : std::true_type {};
 template <>
-inline const EnumDescriptor* GetEnumDescriptor<::messages::SetTempStatusEnum>() {
-  return ::messages::SetTempStatusEnum_descriptor();
+inline const EnumDescriptor* GetEnumDescriptor<::messages::hvac::HVACState_State>() {
+  return ::messages::hvac::HVACState_State_descriptor();
 }
 
 PROTOBUF_NAMESPACE_CLOSE