// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: deviceapis/device/v1/deviceapis_device_video_v1.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5fvideo_5fv1_2eproto_2epb_2eh
#define GOOGLE_PROTOBUF_INCLUDED_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5fvideo_5fv1_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>

#include "google/protobuf/port_def.inc"
#if PROTOBUF_VERSION < 4023000
#error "This file was generated by a newer version of protoc which is"
#error "incompatible with your Protocol Buffer headers. Please update"
#error "your headers."
#endif  // PROTOBUF_VERSION

#if 4023001 < PROTOBUF_MIN_PROTOC_VERSION
#error "This file was generated by an older version of protoc which is"
#error "incompatible with your Protocol Buffer headers. Please"
#error "regenerate this file with a newer version of protoc."
#endif  // PROTOBUF_MIN_PROTOC_VERSION
#include "google/protobuf/port_undef.inc"
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/message_lite.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
#include "google/protobuf/generated_enum_util.h"
#include "deviceapis/device/v1/deviceapis_device_common_v1.pb.h"
#include "google/api/annotations.pb.h"
#include "google/api/field_behavior.pb.h"
#include "google/protobuf/field_mask.pb.h"
#include "protoc-gen-openapiv2/options/annotations.pb.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5fvideo_5fv1_2eproto

PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5fvideo_5fv1_2eproto {
  static const ::uint32_t offsets[];
};
namespace deviceapis {
namespace device {
namespace v1 {
class EditVideoChannelRequest;
struct EditVideoChannelRequestDefaultTypeInternal;
extern EditVideoChannelRequestDefaultTypeInternal _EditVideoChannelRequest_default_instance_;
class EditVideoChannelResponse;
struct EditVideoChannelResponseDefaultTypeInternal;
extern EditVideoChannelResponseDefaultTypeInternal _EditVideoChannelResponse_default_instance_;
class EditVideoChannelResponse_Error;
struct EditVideoChannelResponse_ErrorDefaultTypeInternal;
extern EditVideoChannelResponse_ErrorDefaultTypeInternal _EditVideoChannelResponse_Error_default_instance_;
class GetVideoChannelListRequest;
struct GetVideoChannelListRequestDefaultTypeInternal;
extern GetVideoChannelListRequestDefaultTypeInternal _GetVideoChannelListRequest_default_instance_;
class GetVideoChannelListResponse;
struct GetVideoChannelListResponseDefaultTypeInternal;
extern GetVideoChannelListResponseDefaultTypeInternal _GetVideoChannelListResponse_default_instance_;
class VideoChannel;
struct VideoChannelDefaultTypeInternal;
extern VideoChannelDefaultTypeInternal _VideoChannel_default_instance_;
}  // namespace v1
}  // namespace device
}  // namespace deviceapis
PROTOBUF_NAMESPACE_OPEN
template <>
::deviceapis::device::v1::EditVideoChannelRequest* Arena::CreateMaybeMessage<::deviceapis::device::v1::EditVideoChannelRequest>(Arena*);
template <>
::deviceapis::device::v1::EditVideoChannelResponse* Arena::CreateMaybeMessage<::deviceapis::device::v1::EditVideoChannelResponse>(Arena*);
template <>
::deviceapis::device::v1::EditVideoChannelResponse_Error* Arena::CreateMaybeMessage<::deviceapis::device::v1::EditVideoChannelResponse_Error>(Arena*);
template <>
::deviceapis::device::v1::GetVideoChannelListRequest* Arena::CreateMaybeMessage<::deviceapis::device::v1::GetVideoChannelListRequest>(Arena*);
template <>
::deviceapis::device::v1::GetVideoChannelListResponse* Arena::CreateMaybeMessage<::deviceapis::device::v1::GetVideoChannelListResponse>(Arena*);
template <>
::deviceapis::device::v1::VideoChannel* Arena::CreateMaybeMessage<::deviceapis::device::v1::VideoChannel>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

namespace deviceapis {
namespace device {
namespace v1 {
enum VideoChannel_FlowControlModeType : int {
  VideoChannel_FlowControlModeType_FLOW_CONTROL_MODE_TYPE_UNKNOWN = 0,
  VideoChannel_FlowControlModeType_VBR = 1,
  VideoChannel_FlowControlModeType_CBR = 2,
  VideoChannel_FlowControlModeType_CVBR = 3,
  VideoChannel_FlowControlModeType_AVBR = 4,
  VideoChannel_FlowControlModeType_FIXP = 5,
  VideoChannel_FlowControlModeType_QVBR = 6,
  VideoChannel_FlowControlModeType_VideoChannel_FlowControlModeType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  VideoChannel_FlowControlModeType_VideoChannel_FlowControlModeType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool VideoChannel_FlowControlModeType_IsValid(int value);
constexpr VideoChannel_FlowControlModeType VideoChannel_FlowControlModeType_FlowControlModeType_MIN = static_cast<VideoChannel_FlowControlModeType>(0);
constexpr VideoChannel_FlowControlModeType VideoChannel_FlowControlModeType_FlowControlModeType_MAX = static_cast<VideoChannel_FlowControlModeType>(6);
constexpr int VideoChannel_FlowControlModeType_FlowControlModeType_ARRAYSIZE = 6 + 1;
const std::string& VideoChannel_FlowControlModeType_Name(VideoChannel_FlowControlModeType value);
template <typename T>
const std::string& VideoChannel_FlowControlModeType_Name(T value) {
  static_assert(std::is_same<T, VideoChannel_FlowControlModeType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to FlowControlModeType_Name().");
  return VideoChannel_FlowControlModeType_Name(static_cast<VideoChannel_FlowControlModeType>(value));
}
const std::string& VideoChannel_FlowControlModeType_Name(VideoChannel_FlowControlModeType value);
bool VideoChannel_FlowControlModeType_Parse(absl::string_view name, VideoChannel_FlowControlModeType* value);
enum VideoChannel_FormatType : int {
  VideoChannel_FormatType_FORMAT_TYPE_UNKNOWN = 0,
  VideoChannel_FormatType_MPEG = 1,
  VideoChannel_FormatType_H264 = 2,
  VideoChannel_FormatType_H264_PLUS = 3,
  VideoChannel_FormatType_H265 = 4,
  VideoChannel_FormatType_VideoChannel_FormatType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  VideoChannel_FormatType_VideoChannel_FormatType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool VideoChannel_FormatType_IsValid(int value);
constexpr VideoChannel_FormatType VideoChannel_FormatType_FormatType_MIN = static_cast<VideoChannel_FormatType>(0);
constexpr VideoChannel_FormatType VideoChannel_FormatType_FormatType_MAX = static_cast<VideoChannel_FormatType>(4);
constexpr int VideoChannel_FormatType_FormatType_ARRAYSIZE = 4 + 1;
const std::string& VideoChannel_FormatType_Name(VideoChannel_FormatType value);
template <typename T>
const std::string& VideoChannel_FormatType_Name(T value) {
  static_assert(std::is_same<T, VideoChannel_FormatType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to FormatType_Name().");
  return VideoChannel_FormatType_Name(static_cast<VideoChannel_FormatType>(value));
}
const std::string& VideoChannel_FormatType_Name(VideoChannel_FormatType value);
bool VideoChannel_FormatType_Parse(absl::string_view name, VideoChannel_FormatType* value);
enum VideoChannel_ProfileType : int {
  VideoChannel_ProfileType_PROFILE_TYPE_UNKNOWN = 0,
  VideoChannel_ProfileType_PROFILE_HIGH = 1,
  VideoChannel_ProfileType_PROFILE_MAIN = 2,
  VideoChannel_ProfileType_PROFILE_BASE = 3,
  VideoChannel_ProfileType_VideoChannel_ProfileType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  VideoChannel_ProfileType_VideoChannel_ProfileType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool VideoChannel_ProfileType_IsValid(int value);
constexpr VideoChannel_ProfileType VideoChannel_ProfileType_ProfileType_MIN = static_cast<VideoChannel_ProfileType>(0);
constexpr VideoChannel_ProfileType VideoChannel_ProfileType_ProfileType_MAX = static_cast<VideoChannel_ProfileType>(3);
constexpr int VideoChannel_ProfileType_ProfileType_ARRAYSIZE = 3 + 1;
const std::string& VideoChannel_ProfileType_Name(VideoChannel_ProfileType value);
template <typename T>
const std::string& VideoChannel_ProfileType_Name(T value) {
  static_assert(std::is_same<T, VideoChannel_ProfileType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to ProfileType_Name().");
  return VideoChannel_ProfileType_Name(static_cast<VideoChannel_ProfileType>(value));
}
const std::string& VideoChannel_ProfileType_Name(VideoChannel_ProfileType value);
bool VideoChannel_ProfileType_Parse(absl::string_view name, VideoChannel_ProfileType* value);
enum VideoChannel_ResolutionType : int {
  VideoChannel_ResolutionType_RESOLUTION_TYPE_UNKNOWN = 0,
  VideoChannel_ResolutionType_R2K = 1,
  VideoChannel_ResolutionType_FULLHD = 2,
  VideoChannel_ResolutionType_HD = 3,
  VideoChannel_ResolutionType_SD = 4,
  VideoChannel_ResolutionType_R4CIF = 5,
  VideoChannel_ResolutionType_VGA = 6,
  VideoChannel_ResolutionType_VideoChannel_ResolutionType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  VideoChannel_ResolutionType_VideoChannel_ResolutionType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool VideoChannel_ResolutionType_IsValid(int value);
constexpr VideoChannel_ResolutionType VideoChannel_ResolutionType_ResolutionType_MIN = static_cast<VideoChannel_ResolutionType>(0);
constexpr VideoChannel_ResolutionType VideoChannel_ResolutionType_ResolutionType_MAX = static_cast<VideoChannel_ResolutionType>(6);
constexpr int VideoChannel_ResolutionType_ResolutionType_ARRAYSIZE = 6 + 1;
const std::string& VideoChannel_ResolutionType_Name(VideoChannel_ResolutionType value);
template <typename T>
const std::string& VideoChannel_ResolutionType_Name(T value) {
  static_assert(std::is_same<T, VideoChannel_ResolutionType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to ResolutionType_Name().");
  return VideoChannel_ResolutionType_Name(static_cast<VideoChannel_ResolutionType>(value));
}
const std::string& VideoChannel_ResolutionType_Name(VideoChannel_ResolutionType value);
bool VideoChannel_ResolutionType_Parse(absl::string_view name, VideoChannel_ResolutionType* value);

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


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

class EditVideoChannelRequest final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:deviceapis.device.v1.EditVideoChannelRequest) */ {
 public:
  inline EditVideoChannelRequest() : EditVideoChannelRequest(nullptr) {}
  ~EditVideoChannelRequest() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR EditVideoChannelRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline EditVideoChannelRequest& operator=(const EditVideoChannelRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline EditVideoChannelRequest& operator=(EditVideoChannelRequest&& 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;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const EditVideoChannelRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const EditVideoChannelRequest* internal_default_instance() {
    return reinterpret_cast<const EditVideoChannelRequest*>(
               &_EditVideoChannelRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(EditVideoChannelRequest& a, EditVideoChannelRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(EditVideoChannelRequest* 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(EditVideoChannelRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  EditVideoChannelRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<EditVideoChannelRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const EditVideoChannelRequest& from);
  void MergeFrom(const EditVideoChannelRequest& from);
  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;
  void InternalSwap(EditVideoChannelRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "deviceapis.device.v1.EditVideoChannelRequest";
  }
  protected:
  explicit EditVideoChannelRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kDataFieldNumber = 1,
    kUpdateMaskFieldNumber = 2,
  };
  // .deviceapis.device.v1.VideoChannel data = 1 [(.google.api.field_behavior) = REQUIRED];
  bool has_data() const;
  void clear_data() ;
  const ::deviceapis::device::v1::VideoChannel& data() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::VideoChannel* release_data();
  ::deviceapis::device::v1::VideoChannel* mutable_data();
  void set_allocated_data(::deviceapis::device::v1::VideoChannel* data);
  private:
  const ::deviceapis::device::v1::VideoChannel& _internal_data() const;
  ::deviceapis::device::v1::VideoChannel* _internal_mutable_data();
  public:
  void unsafe_arena_set_allocated_data(
      ::deviceapis::device::v1::VideoChannel* data);
  ::deviceapis::device::v1::VideoChannel* unsafe_arena_release_data();
  // .google.protobuf.FieldMask update_mask = 2;
  bool has_update_mask() const;
  void clear_update_mask() ;
  const ::PROTOBUF_NAMESPACE_ID::FieldMask& update_mask() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::FieldMask* release_update_mask();
  ::PROTOBUF_NAMESPACE_ID::FieldMask* mutable_update_mask();
  void set_allocated_update_mask(::PROTOBUF_NAMESPACE_ID::FieldMask* update_mask);
  private:
  const ::PROTOBUF_NAMESPACE_ID::FieldMask& _internal_update_mask() const;
  ::PROTOBUF_NAMESPACE_ID::FieldMask* _internal_mutable_update_mask();
  public:
  void unsafe_arena_set_allocated_update_mask(
      ::PROTOBUF_NAMESPACE_ID::FieldMask* update_mask);
  ::PROTOBUF_NAMESPACE_ID::FieldMask* unsafe_arena_release_update_mask();
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.EditVideoChannelRequest)
 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::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::deviceapis::device::v1::VideoChannel* data_;
    ::PROTOBUF_NAMESPACE_ID::FieldMask* update_mask_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5fvideo_5fv1_2eproto;
};// -------------------------------------------------------------------

class EditVideoChannelResponse_Error final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:deviceapis.device.v1.EditVideoChannelResponse.Error) */ {
 public:
  inline EditVideoChannelResponse_Error() : EditVideoChannelResponse_Error(nullptr) {}
  ~EditVideoChannelResponse_Error() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR EditVideoChannelResponse_Error(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline EditVideoChannelResponse_Error& operator=(const EditVideoChannelResponse_Error& from) {
    CopyFrom(from);
    return *this;
  }
  inline EditVideoChannelResponse_Error& operator=(EditVideoChannelResponse_Error&& 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;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const EditVideoChannelResponse_Error& default_instance() {
    return *internal_default_instance();
  }
  enum ReasonCase {
    kValidation = 1,
    REASON_NOT_SET = 0,
  };

  static inline const EditVideoChannelResponse_Error* internal_default_instance() {
    return reinterpret_cast<const EditVideoChannelResponse_Error*>(
               &_EditVideoChannelResponse_Error_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(EditVideoChannelResponse_Error& a, EditVideoChannelResponse_Error& b) {
    a.Swap(&b);
  }
  inline void Swap(EditVideoChannelResponse_Error* 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(EditVideoChannelResponse_Error* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  EditVideoChannelResponse_Error* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<EditVideoChannelResponse_Error>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const EditVideoChannelResponse_Error& from);
  void MergeFrom(const EditVideoChannelResponse_Error& from);
  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;
  void InternalSwap(EditVideoChannelResponse_Error* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "deviceapis.device.v1.EditVideoChannelResponse.Error";
  }
  protected:
  explicit EditVideoChannelResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kValidationFieldNumber = 1,
  };
  // .deviceapis.device.v1.ValidationError validation = 1;
  bool has_validation() const;
  private:
  bool _internal_has_validation() const;

  public:
  void clear_validation() ;
  const ::deviceapis::device::v1::ValidationError& validation() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::ValidationError* release_validation();
  ::deviceapis::device::v1::ValidationError* mutable_validation();
  void set_allocated_validation(::deviceapis::device::v1::ValidationError* validation);
  private:
  const ::deviceapis::device::v1::ValidationError& _internal_validation() const;
  ::deviceapis::device::v1::ValidationError* _internal_mutable_validation();
  public:
  void unsafe_arena_set_allocated_validation(
      ::deviceapis::device::v1::ValidationError* validation);
  ::deviceapis::device::v1::ValidationError* unsafe_arena_release_validation();
  void clear_reason();
  ReasonCase reason_case() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.EditVideoChannelResponse.Error)
 private:
  class _Internal;
  void set_has_validation();

  inline bool has_reason() const;
  inline void clear_has_reason();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union ReasonUnion {
      constexpr ReasonUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::deviceapis::device::v1::ValidationError* validation_;
    } reason_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5fvideo_5fv1_2eproto;
};// -------------------------------------------------------------------

class EditVideoChannelResponse final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:deviceapis.device.v1.EditVideoChannelResponse) */ {
 public:
  inline EditVideoChannelResponse() : EditVideoChannelResponse(nullptr) {}
  ~EditVideoChannelResponse() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR EditVideoChannelResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline EditVideoChannelResponse& operator=(const EditVideoChannelResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline EditVideoChannelResponse& operator=(EditVideoChannelResponse&& 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;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const EditVideoChannelResponse& default_instance() {
    return *internal_default_instance();
  }
  enum TypeCase {
    kData = 1,
    kError = 2,
    TYPE_NOT_SET = 0,
  };

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

  friend void swap(EditVideoChannelResponse& a, EditVideoChannelResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(EditVideoChannelResponse* 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(EditVideoChannelResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  EditVideoChannelResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<EditVideoChannelResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const EditVideoChannelResponse& from);
  void MergeFrom(const EditVideoChannelResponse& from);
  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;
  void InternalSwap(EditVideoChannelResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "deviceapis.device.v1.EditVideoChannelResponse";
  }
  protected:
  explicit EditVideoChannelResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

  typedef EditVideoChannelResponse_Error Error;

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

  enum : int {
    kDataFieldNumber = 1,
    kErrorFieldNumber = 2,
  };
  // .deviceapis.device.v1.VideoChannel data = 1;
  bool has_data() const;
  private:
  bool _internal_has_data() const;

  public:
  void clear_data() ;
  const ::deviceapis::device::v1::VideoChannel& data() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::VideoChannel* release_data();
  ::deviceapis::device::v1::VideoChannel* mutable_data();
  void set_allocated_data(::deviceapis::device::v1::VideoChannel* data);
  private:
  const ::deviceapis::device::v1::VideoChannel& _internal_data() const;
  ::deviceapis::device::v1::VideoChannel* _internal_mutable_data();
  public:
  void unsafe_arena_set_allocated_data(
      ::deviceapis::device::v1::VideoChannel* data);
  ::deviceapis::device::v1::VideoChannel* unsafe_arena_release_data();
  // .deviceapis.device.v1.EditVideoChannelResponse.Error error = 2;
  bool has_error() const;
  private:
  bool _internal_has_error() const;

  public:
  void clear_error() ;
  const ::deviceapis::device::v1::EditVideoChannelResponse_Error& error() const;
  PROTOBUF_NODISCARD ::deviceapis::device::v1::EditVideoChannelResponse_Error* release_error();
  ::deviceapis::device::v1::EditVideoChannelResponse_Error* mutable_error();
  void set_allocated_error(::deviceapis::device::v1::EditVideoChannelResponse_Error* error);
  private:
  const ::deviceapis::device::v1::EditVideoChannelResponse_Error& _internal_error() const;
  ::deviceapis::device::v1::EditVideoChannelResponse_Error* _internal_mutable_error();
  public:
  void unsafe_arena_set_allocated_error(
      ::deviceapis::device::v1::EditVideoChannelResponse_Error* error);
  ::deviceapis::device::v1::EditVideoChannelResponse_Error* unsafe_arena_release_error();
  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.EditVideoChannelResponse)
 private:
  class _Internal;
  void set_has_data();
  void set_has_error();

  inline bool has_type() const;
  inline void clear_has_type();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union TypeUnion {
      constexpr TypeUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::deviceapis::device::v1::VideoChannel* data_;
      ::deviceapis::device::v1::EditVideoChannelResponse_Error* error_;
    } type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5fvideo_5fv1_2eproto;
};// -------------------------------------------------------------------

class GetVideoChannelListRequest final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:deviceapis.device.v1.GetVideoChannelListRequest) */ {
 public:
  inline GetVideoChannelListRequest() : GetVideoChannelListRequest(nullptr) {}
  ~GetVideoChannelListRequest() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR GetVideoChannelListRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline GetVideoChannelListRequest& operator=(const GetVideoChannelListRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetVideoChannelListRequest& operator=(GetVideoChannelListRequest&& 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;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

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

  friend void swap(GetVideoChannelListRequest& a, GetVideoChannelListRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(GetVideoChannelListRequest* 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(GetVideoChannelListRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  GetVideoChannelListRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetVideoChannelListRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetVideoChannelListRequest& from);
  void MergeFrom(const GetVideoChannelListRequest& from);
  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;
  void InternalSwap(GetVideoChannelListRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "deviceapis.device.v1.GetVideoChannelListRequest";
  }
  protected:
  explicit GetVideoChannelListRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

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

  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.GetVideoChannelListRequest)
 private:
  class _Internal;

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

class GetVideoChannelListResponse final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:deviceapis.device.v1.GetVideoChannelListResponse) */ {
 public:
  inline GetVideoChannelListResponse() : GetVideoChannelListResponse(nullptr) {}
  ~GetVideoChannelListResponse() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR GetVideoChannelListResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline GetVideoChannelListResponse& operator=(const GetVideoChannelListResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetVideoChannelListResponse& operator=(GetVideoChannelListResponse&& 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;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

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

  friend void swap(GetVideoChannelListResponse& a, GetVideoChannelListResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(GetVideoChannelListResponse* 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(GetVideoChannelListResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  GetVideoChannelListResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetVideoChannelListResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GetVideoChannelListResponse& from);
  void MergeFrom(const GetVideoChannelListResponse& from);
  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;
  void InternalSwap(GetVideoChannelListResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "deviceapis.device.v1.GetVideoChannelListResponse";
  }
  protected:
  explicit GetVideoChannelListResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kDataFieldNumber = 1,
  };
  // repeated .deviceapis.device.v1.VideoChannel data = 1;
  int data_size() const;
  private:
  int _internal_data_size() const;

  public:
  void clear_data() ;
  ::deviceapis::device::v1::VideoChannel* mutable_data(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::VideoChannel >*
      mutable_data();
  private:
  const ::deviceapis::device::v1::VideoChannel& _internal_data(int index) const;
  ::deviceapis::device::v1::VideoChannel* _internal_add_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::VideoChannel>& _internal_data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::VideoChannel>* _internal_mutable_data();
  public:
  const ::deviceapis::device::v1::VideoChannel& data(int index) const;
  ::deviceapis::device::v1::VideoChannel* add_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::VideoChannel >&
      data() const;
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.GetVideoChannelListResponse)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::VideoChannel > data_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5fvideo_5fv1_2eproto;
};// -------------------------------------------------------------------

class VideoChannel final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:deviceapis.device.v1.VideoChannel) */ {
 public:
  inline VideoChannel() : VideoChannel(nullptr) {}
  ~VideoChannel() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR VideoChannel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline VideoChannel& operator=(const VideoChannel& from) {
    CopyFrom(from);
    return *this;
  }
  inline VideoChannel& operator=(VideoChannel&& 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;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const VideoChannel& default_instance() {
    return *internal_default_instance();
  }
  static inline const VideoChannel* internal_default_instance() {
    return reinterpret_cast<const VideoChannel*>(
               &_VideoChannel_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(VideoChannel& a, VideoChannel& b) {
    a.Swap(&b);
  }
  inline void Swap(VideoChannel* 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(VideoChannel* other) {
    if (other == this) return;
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  VideoChannel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<VideoChannel>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const VideoChannel& from);
  void MergeFrom(const VideoChannel& from);
  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;
  void InternalSwap(VideoChannel* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "deviceapis.device.v1.VideoChannel";
  }
  protected:
  explicit VideoChannel(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

  using FlowControlModeType = VideoChannel_FlowControlModeType;
  static constexpr FlowControlModeType FLOW_CONTROL_MODE_TYPE_UNKNOWN = VideoChannel_FlowControlModeType_FLOW_CONTROL_MODE_TYPE_UNKNOWN;
  static constexpr FlowControlModeType VBR = VideoChannel_FlowControlModeType_VBR;
  static constexpr FlowControlModeType CBR = VideoChannel_FlowControlModeType_CBR;
  static constexpr FlowControlModeType CVBR = VideoChannel_FlowControlModeType_CVBR;
  static constexpr FlowControlModeType AVBR = VideoChannel_FlowControlModeType_AVBR;
  static constexpr FlowControlModeType FIXP = VideoChannel_FlowControlModeType_FIXP;
  static constexpr FlowControlModeType QVBR = VideoChannel_FlowControlModeType_QVBR;
  static inline bool FlowControlModeType_IsValid(int value) {
    return VideoChannel_FlowControlModeType_IsValid(value);
  }
  static constexpr FlowControlModeType FlowControlModeType_MIN = VideoChannel_FlowControlModeType_FlowControlModeType_MIN;
  static constexpr FlowControlModeType FlowControlModeType_MAX = VideoChannel_FlowControlModeType_FlowControlModeType_MAX;
  static constexpr int FlowControlModeType_ARRAYSIZE = VideoChannel_FlowControlModeType_FlowControlModeType_ARRAYSIZE;
  template <typename T>
  static inline const std::string& FlowControlModeType_Name(T value) {
    return VideoChannel_FlowControlModeType_Name(value);
  }
  static inline bool FlowControlModeType_Parse(absl::string_view name, FlowControlModeType* value) {
    return VideoChannel_FlowControlModeType_Parse(name, value);
  }

  using FormatType = VideoChannel_FormatType;
  static constexpr FormatType FORMAT_TYPE_UNKNOWN = VideoChannel_FormatType_FORMAT_TYPE_UNKNOWN;
  static constexpr FormatType MPEG = VideoChannel_FormatType_MPEG;
  static constexpr FormatType H264 = VideoChannel_FormatType_H264;
  static constexpr FormatType H264_PLUS = VideoChannel_FormatType_H264_PLUS;
  static constexpr FormatType H265 = VideoChannel_FormatType_H265;
  static inline bool FormatType_IsValid(int value) {
    return VideoChannel_FormatType_IsValid(value);
  }
  static constexpr FormatType FormatType_MIN = VideoChannel_FormatType_FormatType_MIN;
  static constexpr FormatType FormatType_MAX = VideoChannel_FormatType_FormatType_MAX;
  static constexpr int FormatType_ARRAYSIZE = VideoChannel_FormatType_FormatType_ARRAYSIZE;
  template <typename T>
  static inline const std::string& FormatType_Name(T value) {
    return VideoChannel_FormatType_Name(value);
  }
  static inline bool FormatType_Parse(absl::string_view name, FormatType* value) {
    return VideoChannel_FormatType_Parse(name, value);
  }

  using ProfileType = VideoChannel_ProfileType;
  static constexpr ProfileType PROFILE_TYPE_UNKNOWN = VideoChannel_ProfileType_PROFILE_TYPE_UNKNOWN;
  static constexpr ProfileType PROFILE_HIGH = VideoChannel_ProfileType_PROFILE_HIGH;
  static constexpr ProfileType PROFILE_MAIN = VideoChannel_ProfileType_PROFILE_MAIN;
  static constexpr ProfileType PROFILE_BASE = VideoChannel_ProfileType_PROFILE_BASE;
  static inline bool ProfileType_IsValid(int value) {
    return VideoChannel_ProfileType_IsValid(value);
  }
  static constexpr ProfileType ProfileType_MIN = VideoChannel_ProfileType_ProfileType_MIN;
  static constexpr ProfileType ProfileType_MAX = VideoChannel_ProfileType_ProfileType_MAX;
  static constexpr int ProfileType_ARRAYSIZE = VideoChannel_ProfileType_ProfileType_ARRAYSIZE;
  template <typename T>
  static inline const std::string& ProfileType_Name(T value) {
    return VideoChannel_ProfileType_Name(value);
  }
  static inline bool ProfileType_Parse(absl::string_view name, ProfileType* value) {
    return VideoChannel_ProfileType_Parse(name, value);
  }

  using ResolutionType = VideoChannel_ResolutionType;
  static constexpr ResolutionType RESOLUTION_TYPE_UNKNOWN = VideoChannel_ResolutionType_RESOLUTION_TYPE_UNKNOWN;
  static constexpr ResolutionType R2K = VideoChannel_ResolutionType_R2K;
  static constexpr ResolutionType FULLHD = VideoChannel_ResolutionType_FULLHD;
  static constexpr ResolutionType HD = VideoChannel_ResolutionType_HD;
  static constexpr ResolutionType SD = VideoChannel_ResolutionType_SD;
  static constexpr ResolutionType R4CIF = VideoChannel_ResolutionType_R4CIF;
  static constexpr ResolutionType VGA = VideoChannel_ResolutionType_VGA;
  static inline bool ResolutionType_IsValid(int value) {
    return VideoChannel_ResolutionType_IsValid(value);
  }
  static constexpr ResolutionType ResolutionType_MIN = VideoChannel_ResolutionType_ResolutionType_MIN;
  static constexpr ResolutionType ResolutionType_MAX = VideoChannel_ResolutionType_ResolutionType_MAX;
  static constexpr int ResolutionType_ARRAYSIZE = VideoChannel_ResolutionType_ResolutionType_ARRAYSIZE;
  template <typename T>
  static inline const std::string& ResolutionType_Name(T value) {
    return VideoChannel_ResolutionType_Name(value);
  }
  static inline bool ResolutionType_Parse(absl::string_view name, ResolutionType* value) {
    return VideoChannel_ResolutionType_Parse(name, value);
  }

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

  enum : int {
    kChanelNumberFieldNumber = 1,
    kResolutionTypeFieldNumber = 3,
    kFormatTypeFieldNumber = 4,
    kProfileTypeFieldNumber = 5,
    kFpsFieldNumber = 6,
    kGopFieldNumber = 7,
    kIsEnabledFieldNumber = 2,
    kIsRtspAudioFieldNumber = 10,
    kIsUsedForSipFieldNumber = 11,
    kFlowControlModeTypeFieldNumber = 8,
    kBiterateFieldNumber = 9,
  };
  // int32 chanel_number = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  void clear_chanel_number() ;
  ::int32_t chanel_number() const;
  void set_chanel_number(::int32_t value);

  private:
  ::int32_t _internal_chanel_number() const;
  void _internal_set_chanel_number(::int32_t value);

  public:
  // .deviceapis.device.v1.VideoChannel.ResolutionType resolution_type = 3 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  void clear_resolution_type() ;
  ::deviceapis::device::v1::VideoChannel_ResolutionType resolution_type() const;
  void set_resolution_type(::deviceapis::device::v1::VideoChannel_ResolutionType value);

  private:
  ::deviceapis::device::v1::VideoChannel_ResolutionType _internal_resolution_type() const;
  void _internal_set_resolution_type(::deviceapis::device::v1::VideoChannel_ResolutionType value);

  public:
  // .deviceapis.device.v1.VideoChannel.FormatType format_type = 4 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  void clear_format_type() ;
  ::deviceapis::device::v1::VideoChannel_FormatType format_type() const;
  void set_format_type(::deviceapis::device::v1::VideoChannel_FormatType value);

  private:
  ::deviceapis::device::v1::VideoChannel_FormatType _internal_format_type() const;
  void _internal_set_format_type(::deviceapis::device::v1::VideoChannel_FormatType value);

  public:
  // .deviceapis.device.v1.VideoChannel.ProfileType profile_type = 5 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  void clear_profile_type() ;
  ::deviceapis::device::v1::VideoChannel_ProfileType profile_type() const;
  void set_profile_type(::deviceapis::device::v1::VideoChannel_ProfileType value);

  private:
  ::deviceapis::device::v1::VideoChannel_ProfileType _internal_profile_type() const;
  void _internal_set_profile_type(::deviceapis::device::v1::VideoChannel_ProfileType value);

  public:
  // int32 fps = 6 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  void clear_fps() ;
  ::int32_t fps() const;
  void set_fps(::int32_t value);

  private:
  ::int32_t _internal_fps() const;
  void _internal_set_fps(::int32_t value);

  public:
  // int32 gop = 7 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  void clear_gop() ;
  ::int32_t gop() const;
  void set_gop(::int32_t value);

  private:
  ::int32_t _internal_gop() const;
  void _internal_set_gop(::int32_t value);

  public:
  // bool is_enabled = 2 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  void clear_is_enabled() ;
  bool is_enabled() const;
  void set_is_enabled(bool value);

  private:
  bool _internal_is_enabled() const;
  void _internal_set_is_enabled(bool value);

  public:
  // bool is_rtsp_audio = 10 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  void clear_is_rtsp_audio() ;
  bool is_rtsp_audio() const;
  void set_is_rtsp_audio(bool value);

  private:
  bool _internal_is_rtsp_audio() const;
  void _internal_set_is_rtsp_audio(bool value);

  public:
  // bool is_used_for_sip = 11 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  void clear_is_used_for_sip() ;
  bool is_used_for_sip() const;
  void set_is_used_for_sip(bool value);

  private:
  bool _internal_is_used_for_sip() const;
  void _internal_set_is_used_for_sip(bool value);

  public:
  // .deviceapis.device.v1.VideoChannel.FlowControlModeType flow_control_mode_type = 8 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  void clear_flow_control_mode_type() ;
  ::deviceapis::device::v1::VideoChannel_FlowControlModeType flow_control_mode_type() const;
  void set_flow_control_mode_type(::deviceapis::device::v1::VideoChannel_FlowControlModeType value);

  private:
  ::deviceapis::device::v1::VideoChannel_FlowControlModeType _internal_flow_control_mode_type() const;
  void _internal_set_flow_control_mode_type(::deviceapis::device::v1::VideoChannel_FlowControlModeType value);

  public:
  // int32 biterate = 9 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  void clear_biterate() ;
  ::int32_t biterate() const;
  void set_biterate(::int32_t value);

  private:
  ::int32_t _internal_biterate() const;
  void _internal_set_biterate(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:deviceapis.device.v1.VideoChannel)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::int32_t chanel_number_;
    int resolution_type_;
    int format_type_;
    int profile_type_;
    ::int32_t fps_;
    ::int32_t gop_;
    bool is_enabled_;
    bool is_rtsp_audio_;
    bool is_used_for_sip_;
    int flow_control_mode_type_;
    ::int32_t biterate_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5fvideo_5fv1_2eproto;
};

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




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


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

// EditVideoChannelRequest

// .deviceapis.device.v1.VideoChannel data = 1 [(.google.api.field_behavior) = REQUIRED];
inline bool EditVideoChannelRequest::has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.data_ != nullptr);
  return value;
}
inline void EditVideoChannelRequest::clear_data() {
  if (_impl_.data_ != nullptr) _impl_.data_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::deviceapis::device::v1::VideoChannel& EditVideoChannelRequest::_internal_data() const {
  const ::deviceapis::device::v1::VideoChannel* p = _impl_.data_;
  return p != nullptr ? *p : reinterpret_cast<const ::deviceapis::device::v1::VideoChannel&>(
      ::deviceapis::device::v1::_VideoChannel_default_instance_);
}
inline const ::deviceapis::device::v1::VideoChannel& EditVideoChannelRequest::data() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.EditVideoChannelRequest.data)
  return _internal_data();
}
inline void EditVideoChannelRequest::unsafe_arena_set_allocated_data(
    ::deviceapis::device::v1::VideoChannel* data) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.data_);
  }
  _impl_.data_ = data;
  if (data) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:deviceapis.device.v1.EditVideoChannelRequest.data)
}
inline ::deviceapis::device::v1::VideoChannel* EditVideoChannelRequest::release_data() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::deviceapis::device::v1::VideoChannel* temp = _impl_.data_;
  _impl_.data_ = 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 ::deviceapis::device::v1::VideoChannel* EditVideoChannelRequest::unsafe_arena_release_data() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.EditVideoChannelRequest.data)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::deviceapis::device::v1::VideoChannel* temp = _impl_.data_;
  _impl_.data_ = nullptr;
  return temp;
}
inline ::deviceapis::device::v1::VideoChannel* EditVideoChannelRequest::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.data_ == nullptr) {
    auto* p = CreateMaybeMessage<::deviceapis::device::v1::VideoChannel>(GetArenaForAllocation());
    _impl_.data_ = p;
  }
  return _impl_.data_;
}
inline ::deviceapis::device::v1::VideoChannel* EditVideoChannelRequest::mutable_data() {
  ::deviceapis::device::v1::VideoChannel* _msg = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.EditVideoChannelRequest.data)
  return _msg;
}
inline void EditVideoChannelRequest::set_allocated_data(::deviceapis::device::v1::VideoChannel* data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.data_;
  }
  if (data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(data);
    if (message_arena != submessage_arena) {
      data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.data_ = data;
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.EditVideoChannelRequest.data)
}

// .google.protobuf.FieldMask update_mask = 2;
inline bool EditVideoChannelRequest::has_update_mask() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.update_mask_ != nullptr);
  return value;
}
inline const ::PROTOBUF_NAMESPACE_ID::FieldMask& EditVideoChannelRequest::_internal_update_mask() const {
  const ::PROTOBUF_NAMESPACE_ID::FieldMask* p = _impl_.update_mask_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::FieldMask&>(
      ::PROTOBUF_NAMESPACE_ID::_FieldMask_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::FieldMask& EditVideoChannelRequest::update_mask() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.EditVideoChannelRequest.update_mask)
  return _internal_update_mask();
}
inline void EditVideoChannelRequest::unsafe_arena_set_allocated_update_mask(
    ::PROTOBUF_NAMESPACE_ID::FieldMask* update_mask) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.update_mask_);
  }
  _impl_.update_mask_ = update_mask;
  if (update_mask) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:deviceapis.device.v1.EditVideoChannelRequest.update_mask)
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* EditVideoChannelRequest::release_update_mask() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::PROTOBUF_NAMESPACE_ID::FieldMask* temp = _impl_.update_mask_;
  _impl_.update_mask_ = 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 ::PROTOBUF_NAMESPACE_ID::FieldMask* EditVideoChannelRequest::unsafe_arena_release_update_mask() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.EditVideoChannelRequest.update_mask)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::PROTOBUF_NAMESPACE_ID::FieldMask* temp = _impl_.update_mask_;
  _impl_.update_mask_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* EditVideoChannelRequest::_internal_mutable_update_mask() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.update_mask_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FieldMask>(GetArenaForAllocation());
    _impl_.update_mask_ = p;
  }
  return _impl_.update_mask_;
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* EditVideoChannelRequest::mutable_update_mask() {
  ::PROTOBUF_NAMESPACE_ID::FieldMask* _msg = _internal_mutable_update_mask();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.EditVideoChannelRequest.update_mask)
  return _msg;
}
inline void EditVideoChannelRequest::set_allocated_update_mask(::PROTOBUF_NAMESPACE_ID::FieldMask* update_mask) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.update_mask_);
  }
  if (update_mask) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(update_mask));
    if (message_arena != submessage_arena) {
      update_mask = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, update_mask, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.update_mask_ = update_mask;
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.EditVideoChannelRequest.update_mask)
}

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

// EditVideoChannelResponse_Error

// .deviceapis.device.v1.ValidationError validation = 1;
inline bool EditVideoChannelResponse_Error::has_validation() const {
  return reason_case() == kValidation;
}
inline bool EditVideoChannelResponse_Error::_internal_has_validation() const {
  return reason_case() == kValidation;
}
inline void EditVideoChannelResponse_Error::set_has_validation() {
  _impl_._oneof_case_[0] = kValidation;
}
inline ::deviceapis::device::v1::ValidationError* EditVideoChannelResponse_Error::release_validation() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.EditVideoChannelResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::deviceapis::device::v1::ValidationError* temp = _impl_.reason_.validation_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.reason_.validation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::deviceapis::device::v1::ValidationError& EditVideoChannelResponse_Error::_internal_validation() const {
  return reason_case() == kValidation
      ? *_impl_.reason_.validation_
      : reinterpret_cast<::deviceapis::device::v1::ValidationError&>(::deviceapis::device::v1::_ValidationError_default_instance_);
}
inline const ::deviceapis::device::v1::ValidationError& EditVideoChannelResponse_Error::validation() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.EditVideoChannelResponse.Error.validation)
  return _internal_validation();
}
inline ::deviceapis::device::v1::ValidationError* EditVideoChannelResponse_Error::unsafe_arena_release_validation() {
  // @@protoc_insertion_point(field_unsafe_arena_release:deviceapis.device.v1.EditVideoChannelResponse.Error.validation)
  if (reason_case() == kValidation) {
    clear_has_reason();
    ::deviceapis::device::v1::ValidationError* temp = _impl_.reason_.validation_;
    _impl_.reason_.validation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void EditVideoChannelResponse_Error::unsafe_arena_set_allocated_validation(::deviceapis::device::v1::ValidationError* validation) {
  clear_reason();
  if (validation) {
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:deviceapis.device.v1.EditVideoChannelResponse.Error.validation)
}
inline ::deviceapis::device::v1::ValidationError* EditVideoChannelResponse_Error::_internal_mutable_validation() {
  if (reason_case() != kValidation) {
    clear_reason();
    set_has_validation();
    _impl_.reason_.validation_ = CreateMaybeMessage< ::deviceapis::device::v1::ValidationError >(GetArenaForAllocation());
  }
  return _impl_.reason_.validation_;
}
inline ::deviceapis::device::v1::ValidationError* EditVideoChannelResponse_Error::mutable_validation() {
  ::deviceapis::device::v1::ValidationError* _msg = _internal_mutable_validation();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.EditVideoChannelResponse.Error.validation)
  return _msg;
}

inline bool EditVideoChannelResponse_Error::has_reason() const {
  return reason_case() != REASON_NOT_SET;
}
inline void EditVideoChannelResponse_Error::clear_has_reason() {
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}
inline EditVideoChannelResponse_Error::ReasonCase EditVideoChannelResponse_Error::reason_case() const {
  return EditVideoChannelResponse_Error::ReasonCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// EditVideoChannelResponse

// .deviceapis.device.v1.VideoChannel data = 1;
inline bool EditVideoChannelResponse::has_data() const {
  return type_case() == kData;
}
inline bool EditVideoChannelResponse::_internal_has_data() const {
  return type_case() == kData;
}
inline void EditVideoChannelResponse::set_has_data() {
  _impl_._oneof_case_[0] = kData;
}
inline void EditVideoChannelResponse::clear_data() {
  if (type_case() == kData) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.type_.data_;
    }
    clear_has_type();
  }
}
inline ::deviceapis::device::v1::VideoChannel* EditVideoChannelResponse::release_data() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.EditVideoChannelResponse.data)
  if (type_case() == kData) {
    clear_has_type();
    ::deviceapis::device::v1::VideoChannel* temp = _impl_.type_.data_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.type_.data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::deviceapis::device::v1::VideoChannel& EditVideoChannelResponse::_internal_data() const {
  return type_case() == kData
      ? *_impl_.type_.data_
      : reinterpret_cast<::deviceapis::device::v1::VideoChannel&>(::deviceapis::device::v1::_VideoChannel_default_instance_);
}
inline const ::deviceapis::device::v1::VideoChannel& EditVideoChannelResponse::data() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.EditVideoChannelResponse.data)
  return _internal_data();
}
inline ::deviceapis::device::v1::VideoChannel* EditVideoChannelResponse::unsafe_arena_release_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:deviceapis.device.v1.EditVideoChannelResponse.data)
  if (type_case() == kData) {
    clear_has_type();
    ::deviceapis::device::v1::VideoChannel* temp = _impl_.type_.data_;
    _impl_.type_.data_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void EditVideoChannelResponse::unsafe_arena_set_allocated_data(::deviceapis::device::v1::VideoChannel* data) {
  clear_type();
  if (data) {
    set_has_data();
    _impl_.type_.data_ = data;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:deviceapis.device.v1.EditVideoChannelResponse.data)
}
inline ::deviceapis::device::v1::VideoChannel* EditVideoChannelResponse::_internal_mutable_data() {
  if (type_case() != kData) {
    clear_type();
    set_has_data();
    _impl_.type_.data_ = CreateMaybeMessage< ::deviceapis::device::v1::VideoChannel >(GetArenaForAllocation());
  }
  return _impl_.type_.data_;
}
inline ::deviceapis::device::v1::VideoChannel* EditVideoChannelResponse::mutable_data() {
  ::deviceapis::device::v1::VideoChannel* _msg = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.EditVideoChannelResponse.data)
  return _msg;
}

// .deviceapis.device.v1.EditVideoChannelResponse.Error error = 2;
inline bool EditVideoChannelResponse::has_error() const {
  return type_case() == kError;
}
inline bool EditVideoChannelResponse::_internal_has_error() const {
  return type_case() == kError;
}
inline void EditVideoChannelResponse::set_has_error() {
  _impl_._oneof_case_[0] = kError;
}
inline void EditVideoChannelResponse::clear_error() {
  if (type_case() == kError) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.type_.error_;
    }
    clear_has_type();
  }
}
inline ::deviceapis::device::v1::EditVideoChannelResponse_Error* EditVideoChannelResponse::release_error() {
  // @@protoc_insertion_point(field_release:deviceapis.device.v1.EditVideoChannelResponse.error)
  if (type_case() == kError) {
    clear_has_type();
    ::deviceapis::device::v1::EditVideoChannelResponse_Error* temp = _impl_.type_.error_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.type_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::deviceapis::device::v1::EditVideoChannelResponse_Error& EditVideoChannelResponse::_internal_error() const {
  return type_case() == kError
      ? *_impl_.type_.error_
      : reinterpret_cast<::deviceapis::device::v1::EditVideoChannelResponse_Error&>(::deviceapis::device::v1::_EditVideoChannelResponse_Error_default_instance_);
}
inline const ::deviceapis::device::v1::EditVideoChannelResponse_Error& EditVideoChannelResponse::error() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.EditVideoChannelResponse.error)
  return _internal_error();
}
inline ::deviceapis::device::v1::EditVideoChannelResponse_Error* EditVideoChannelResponse::unsafe_arena_release_error() {
  // @@protoc_insertion_point(field_unsafe_arena_release:deviceapis.device.v1.EditVideoChannelResponse.error)
  if (type_case() == kError) {
    clear_has_type();
    ::deviceapis::device::v1::EditVideoChannelResponse_Error* temp = _impl_.type_.error_;
    _impl_.type_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void EditVideoChannelResponse::unsafe_arena_set_allocated_error(::deviceapis::device::v1::EditVideoChannelResponse_Error* error) {
  clear_type();
  if (error) {
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:deviceapis.device.v1.EditVideoChannelResponse.error)
}
inline ::deviceapis::device::v1::EditVideoChannelResponse_Error* EditVideoChannelResponse::_internal_mutable_error() {
  if (type_case() != kError) {
    clear_type();
    set_has_error();
    _impl_.type_.error_ = CreateMaybeMessage< ::deviceapis::device::v1::EditVideoChannelResponse_Error >(GetArenaForAllocation());
  }
  return _impl_.type_.error_;
}
inline ::deviceapis::device::v1::EditVideoChannelResponse_Error* EditVideoChannelResponse::mutable_error() {
  ::deviceapis::device::v1::EditVideoChannelResponse_Error* _msg = _internal_mutable_error();
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.EditVideoChannelResponse.error)
  return _msg;
}

inline bool EditVideoChannelResponse::has_type() const {
  return type_case() != TYPE_NOT_SET;
}
inline void EditVideoChannelResponse::clear_has_type() {
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}
inline EditVideoChannelResponse::TypeCase EditVideoChannelResponse::type_case() const {
  return EditVideoChannelResponse::TypeCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// GetVideoChannelListRequest

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

// GetVideoChannelListResponse

// repeated .deviceapis.device.v1.VideoChannel data = 1;
inline int GetVideoChannelListResponse::_internal_data_size() const {
  return _impl_.data_.size();
}
inline int GetVideoChannelListResponse::data_size() const {
  return _internal_data_size();
}
inline void GetVideoChannelListResponse::clear_data() {
  _internal_mutable_data()->Clear();
}
inline ::deviceapis::device::v1::VideoChannel* GetVideoChannelListResponse::mutable_data(int index) {
  // @@protoc_insertion_point(field_mutable:deviceapis.device.v1.GetVideoChannelListResponse.data)
  return _internal_mutable_data()->Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::VideoChannel >*
GetVideoChannelListResponse::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:deviceapis.device.v1.GetVideoChannelListResponse.data)
  return _internal_mutable_data();
}
inline const ::deviceapis::device::v1::VideoChannel& GetVideoChannelListResponse::_internal_data(int index) const {
  return _internal_data().Get(index);
}
inline const ::deviceapis::device::v1::VideoChannel& GetVideoChannelListResponse::data(int index) const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.GetVideoChannelListResponse.data)
  return _internal_data(index);
}
inline ::deviceapis::device::v1::VideoChannel* GetVideoChannelListResponse::_internal_add_data() {
  return _internal_mutable_data()->Add();
}
inline ::deviceapis::device::v1::VideoChannel* GetVideoChannelListResponse::add_data() {
  ::deviceapis::device::v1::VideoChannel* _add = _internal_add_data();
  // @@protoc_insertion_point(field_add:deviceapis.device.v1.GetVideoChannelListResponse.data)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::deviceapis::device::v1::VideoChannel >&
GetVideoChannelListResponse::data() const {
  // @@protoc_insertion_point(field_list:deviceapis.device.v1.GetVideoChannelListResponse.data)
  return _internal_data();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::VideoChannel>&
GetVideoChannelListResponse::_internal_data() const {
  return _impl_.data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::deviceapis::device::v1::VideoChannel>*
GetVideoChannelListResponse::_internal_mutable_data() {
  return &_impl_.data_;
}

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

// VideoChannel

// int32 chanel_number = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
inline void VideoChannel::clear_chanel_number() {
  _impl_.chanel_number_ = 0;
}
inline ::int32_t VideoChannel::chanel_number() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.VideoChannel.chanel_number)
  return _internal_chanel_number();
}
inline void VideoChannel::set_chanel_number(::int32_t value) {
  _internal_set_chanel_number(value);
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.VideoChannel.chanel_number)
}
inline ::int32_t VideoChannel::_internal_chanel_number() const {
  return _impl_.chanel_number_;
}
inline void VideoChannel::_internal_set_chanel_number(::int32_t value) {
  ;
  _impl_.chanel_number_ = value;
}

// bool is_enabled = 2 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
inline void VideoChannel::clear_is_enabled() {
  _impl_.is_enabled_ = false;
}
inline bool VideoChannel::is_enabled() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.VideoChannel.is_enabled)
  return _internal_is_enabled();
}
inline void VideoChannel::set_is_enabled(bool value) {
  _internal_set_is_enabled(value);
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.VideoChannel.is_enabled)
}
inline bool VideoChannel::_internal_is_enabled() const {
  return _impl_.is_enabled_;
}
inline void VideoChannel::_internal_set_is_enabled(bool value) {
  ;
  _impl_.is_enabled_ = value;
}

// .deviceapis.device.v1.VideoChannel.ResolutionType resolution_type = 3 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
inline void VideoChannel::clear_resolution_type() {
  _impl_.resolution_type_ = 0;
}
inline ::deviceapis::device::v1::VideoChannel_ResolutionType VideoChannel::resolution_type() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.VideoChannel.resolution_type)
  return _internal_resolution_type();
}
inline void VideoChannel::set_resolution_type(::deviceapis::device::v1::VideoChannel_ResolutionType value) {
   _internal_set_resolution_type(value);
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.VideoChannel.resolution_type)
}
inline ::deviceapis::device::v1::VideoChannel_ResolutionType VideoChannel::_internal_resolution_type() const {
  return static_cast<::deviceapis::device::v1::VideoChannel_ResolutionType>(_impl_.resolution_type_);
}
inline void VideoChannel::_internal_set_resolution_type(::deviceapis::device::v1::VideoChannel_ResolutionType value) {
  ;
  _impl_.resolution_type_ = value;
}

// .deviceapis.device.v1.VideoChannel.FormatType format_type = 4 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
inline void VideoChannel::clear_format_type() {
  _impl_.format_type_ = 0;
}
inline ::deviceapis::device::v1::VideoChannel_FormatType VideoChannel::format_type() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.VideoChannel.format_type)
  return _internal_format_type();
}
inline void VideoChannel::set_format_type(::deviceapis::device::v1::VideoChannel_FormatType value) {
   _internal_set_format_type(value);
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.VideoChannel.format_type)
}
inline ::deviceapis::device::v1::VideoChannel_FormatType VideoChannel::_internal_format_type() const {
  return static_cast<::deviceapis::device::v1::VideoChannel_FormatType>(_impl_.format_type_);
}
inline void VideoChannel::_internal_set_format_type(::deviceapis::device::v1::VideoChannel_FormatType value) {
  ;
  _impl_.format_type_ = value;
}

// .deviceapis.device.v1.VideoChannel.ProfileType profile_type = 5 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
inline void VideoChannel::clear_profile_type() {
  _impl_.profile_type_ = 0;
}
inline ::deviceapis::device::v1::VideoChannel_ProfileType VideoChannel::profile_type() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.VideoChannel.profile_type)
  return _internal_profile_type();
}
inline void VideoChannel::set_profile_type(::deviceapis::device::v1::VideoChannel_ProfileType value) {
   _internal_set_profile_type(value);
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.VideoChannel.profile_type)
}
inline ::deviceapis::device::v1::VideoChannel_ProfileType VideoChannel::_internal_profile_type() const {
  return static_cast<::deviceapis::device::v1::VideoChannel_ProfileType>(_impl_.profile_type_);
}
inline void VideoChannel::_internal_set_profile_type(::deviceapis::device::v1::VideoChannel_ProfileType value) {
  ;
  _impl_.profile_type_ = value;
}

// int32 fps = 6 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
inline void VideoChannel::clear_fps() {
  _impl_.fps_ = 0;
}
inline ::int32_t VideoChannel::fps() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.VideoChannel.fps)
  return _internal_fps();
}
inline void VideoChannel::set_fps(::int32_t value) {
  _internal_set_fps(value);
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.VideoChannel.fps)
}
inline ::int32_t VideoChannel::_internal_fps() const {
  return _impl_.fps_;
}
inline void VideoChannel::_internal_set_fps(::int32_t value) {
  ;
  _impl_.fps_ = value;
}

// int32 gop = 7 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
inline void VideoChannel::clear_gop() {
  _impl_.gop_ = 0;
}
inline ::int32_t VideoChannel::gop() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.VideoChannel.gop)
  return _internal_gop();
}
inline void VideoChannel::set_gop(::int32_t value) {
  _internal_set_gop(value);
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.VideoChannel.gop)
}
inline ::int32_t VideoChannel::_internal_gop() const {
  return _impl_.gop_;
}
inline void VideoChannel::_internal_set_gop(::int32_t value) {
  ;
  _impl_.gop_ = value;
}

// .deviceapis.device.v1.VideoChannel.FlowControlModeType flow_control_mode_type = 8 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
inline void VideoChannel::clear_flow_control_mode_type() {
  _impl_.flow_control_mode_type_ = 0;
}
inline ::deviceapis::device::v1::VideoChannel_FlowControlModeType VideoChannel::flow_control_mode_type() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.VideoChannel.flow_control_mode_type)
  return _internal_flow_control_mode_type();
}
inline void VideoChannel::set_flow_control_mode_type(::deviceapis::device::v1::VideoChannel_FlowControlModeType value) {
   _internal_set_flow_control_mode_type(value);
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.VideoChannel.flow_control_mode_type)
}
inline ::deviceapis::device::v1::VideoChannel_FlowControlModeType VideoChannel::_internal_flow_control_mode_type() const {
  return static_cast<::deviceapis::device::v1::VideoChannel_FlowControlModeType>(_impl_.flow_control_mode_type_);
}
inline void VideoChannel::_internal_set_flow_control_mode_type(::deviceapis::device::v1::VideoChannel_FlowControlModeType value) {
  ;
  _impl_.flow_control_mode_type_ = value;
}

// int32 biterate = 9 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
inline void VideoChannel::clear_biterate() {
  _impl_.biterate_ = 0;
}
inline ::int32_t VideoChannel::biterate() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.VideoChannel.biterate)
  return _internal_biterate();
}
inline void VideoChannel::set_biterate(::int32_t value) {
  _internal_set_biterate(value);
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.VideoChannel.biterate)
}
inline ::int32_t VideoChannel::_internal_biterate() const {
  return _impl_.biterate_;
}
inline void VideoChannel::_internal_set_biterate(::int32_t value) {
  ;
  _impl_.biterate_ = value;
}

// bool is_rtsp_audio = 10 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
inline void VideoChannel::clear_is_rtsp_audio() {
  _impl_.is_rtsp_audio_ = false;
}
inline bool VideoChannel::is_rtsp_audio() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.VideoChannel.is_rtsp_audio)
  return _internal_is_rtsp_audio();
}
inline void VideoChannel::set_is_rtsp_audio(bool value) {
  _internal_set_is_rtsp_audio(value);
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.VideoChannel.is_rtsp_audio)
}
inline bool VideoChannel::_internal_is_rtsp_audio() const {
  return _impl_.is_rtsp_audio_;
}
inline void VideoChannel::_internal_set_is_rtsp_audio(bool value) {
  ;
  _impl_.is_rtsp_audio_ = value;
}

// bool is_used_for_sip = 11 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
inline void VideoChannel::clear_is_used_for_sip() {
  _impl_.is_used_for_sip_ = false;
}
inline bool VideoChannel::is_used_for_sip() const {
  // @@protoc_insertion_point(field_get:deviceapis.device.v1.VideoChannel.is_used_for_sip)
  return _internal_is_used_for_sip();
}
inline void VideoChannel::set_is_used_for_sip(bool value) {
  _internal_set_is_used_for_sip(value);
  // @@protoc_insertion_point(field_set:deviceapis.device.v1.VideoChannel.is_used_for_sip)
}
inline bool VideoChannel::_internal_is_used_for_sip() const {
  return _impl_.is_used_for_sip_;
}
inline void VideoChannel::_internal_set_is_used_for_sip(bool value) {
  ;
  _impl_.is_used_for_sip_ = value;
}

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

// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace device
}  // namespace deviceapis


PROTOBUF_NAMESPACE_OPEN

template <>
struct is_proto_enum<::deviceapis::device::v1::VideoChannel_FlowControlModeType> : std::true_type {};
template <>
struct is_proto_enum<::deviceapis::device::v1::VideoChannel_FormatType> : std::true_type {};
template <>
struct is_proto_enum<::deviceapis::device::v1::VideoChannel_ProfileType> : std::true_type {};
template <>
struct is_proto_enum<::deviceapis::device::v1::VideoChannel_ResolutionType> : std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"

#endif  // GOOGLE_PROTOBUF_INCLUDED_deviceapis_2fdevice_2fv1_2fdeviceapis_5fdevice_5fvideo_5fv1_2eproto_2epb_2eh