// Generated by the protocol buffer compiler.  DO NOT EDIT!
// clang-format off
// source: keyapis/telemetry_control/v1/keyapis_telemetry_control_device_v1.proto

// This CPP symbol can be defined to use imports that match up to the framework
// imports needed when using CocoaPods.
#if !defined(GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS)
 #define GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS 0
#endif

#if GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS
 #import <Protobuf/GPBProtocolBuffers_RuntimeSupport.h>
#else
 #import "GPBProtocolBuffers_RuntimeSupport.h"
#endif

#if GOOGLE_PROTOBUF_OBJC_VERSION < 30007
#error This file was generated by a newer version of protoc which is incompatible with your Protocol Buffer library sources.
#endif
#if 30007 < GOOGLE_PROTOBUF_OBJC_MIN_SUPPORTED_VERSION
#error This file was generated by an older version of protoc which is incompatible with your Protocol Buffer library sources.
#endif

#import <stdatomic.h>

#import "keyapis/telemetry_control/v1/KeyapisTelemetryControlDeviceV1.pbobjc.h"
#import "google/api/Annotations.pbobjc.h"
#import "google/api/FieldBehavior.pbobjc.h"
#import "google/api/Visibility.pbobjc.h"
// @@protoc_insertion_point(imports)

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
#pragma clang diagnostic ignored "-Wdirect-ivar-access"
#pragma clang diagnostic ignored "-Wdollar-in-identifier-extension"

#pragma mark - Objective-C Class declarations
// Forward declarations of Objective-C classes that we can use as
// static values in struct initializers.
// We don't use [Foo class] because it is not a static value.
GPBObjCClassDeclaration(GPBFloatValue);
GPBObjCClassDeclaration(GPBInt32Value);
GPBObjCClassDeclaration(GPBStringValue);
GPBObjCClassDeclaration(GPBTimestamp);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1DeleteDeviceIndicatorRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1DeleteDeviceIndicatorResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1DeleteDeviceRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1DeleteDeviceResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1Device);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1DeviceFilter);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1DeviceFilter_ValidationError);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1DeviceGroup);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1DeviceGroupFilter);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPoint);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointFilter);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1DevicePaging);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_LimitInvalid);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_OffsetInvalid);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1Device_ValidationError);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceCountRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse_Error);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse_Error);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse_Error);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceListRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse_Error);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetDeviceResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1Indicator);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1IndicatorFilter);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1IndicatorFilter_ValidationError);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1IndicatorPaging);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_LimitInvalid);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_OffsetInvalid);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1Indicator_ValidationError);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_IpError);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_NetworkAddressError);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_PortError);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_UnknownError);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Success);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse_Error);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_CreateIndicatorsFail);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_MetricPointNotFound);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_MultiLinkedMetricPoint);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_ReplaceDeviceNotFound);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_WrongBuilding);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostDeviceResponse_Error);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PutDeviceGroupAttachRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PutDeviceGroupAttachResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PutDeviceGroupDetachRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PutDeviceGroupDetachResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointAttachRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointAttachResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointDetachRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointDetachResponse);

#pragma mark - KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root

@implementation KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root

+ (GPBExtensionRegistry*)extensionRegistry {
  // This is called by +initialize so there is no need to worry
  // about thread safety and initialization of registry.
  static GPBExtensionRegistry* registry = nil;
  if (!registry) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    registry = [[GPBExtensionRegistry alloc] init];
    // Merge in the imports (direct or indirect) that defined extensions.
    [registry addExtensions:[GAPIAnnotationsRoot extensionRegistry]];
    [registry addExtensions:[GAPIFieldBehaviorRoot extensionRegistry]];
    [registry addExtensions:[GAPIVisibilityRoot extensionRegistry]];
  }
  return registry;
}

@end

static GPBFileDescription KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription = {
  .package = "keyapis.telemetry_control.v1",
  .prefix = "KEYAPISTELEMETRYCONTROLV1",
  .syntax = GPBFileSyntaxProto3
};

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_OrderByType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_OrderByType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "OrderByTypeUnknown\000GroupId\000DeviceId\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_OrderByType_OrderByTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_OrderByType_GroupId,
        KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_OrderByType_DeviceId,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_OrderByType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_OrderByType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_OrderByType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_OrderByType_OrderByTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_OrderByType_GroupId:
    case KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_OrderByType_DeviceId:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_DirectionType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_DirectionType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "DirectionTypeUnknown\000Desc\000Asc\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_DirectionType_DirectionTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_DirectionType_Desc,
        KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_DirectionType_Asc,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_DirectionType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_DirectionType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_DirectionType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_DirectionType_DirectionTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_DirectionType_Desc:
    case KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_DirectionType_Asc:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1IndicatorPaging_OrderByType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1IndicatorPaging_OrderByType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "OrderByTypeUnknown\000Id\000SignType\000DeviceId\000"
        "CreatedAt\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1IndicatorPaging_OrderByType_OrderByTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1IndicatorPaging_OrderByType_Id,
        KEYAPISTELEMETRYCONTROLV1IndicatorPaging_OrderByType_SignType,
        KEYAPISTELEMETRYCONTROLV1IndicatorPaging_OrderByType_DeviceId,
        KEYAPISTELEMETRYCONTROLV1IndicatorPaging_OrderByType_CreatedAt,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1IndicatorPaging_OrderByType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1IndicatorPaging_OrderByType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1IndicatorPaging_OrderByType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1IndicatorPaging_OrderByType_OrderByTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1IndicatorPaging_OrderByType_Id:
    case KEYAPISTELEMETRYCONTROLV1IndicatorPaging_OrderByType_SignType:
    case KEYAPISTELEMETRYCONTROLV1IndicatorPaging_OrderByType_DeviceId:
    case KEYAPISTELEMETRYCONTROLV1IndicatorPaging_OrderByType_CreatedAt:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1IndicatorPaging_DirectionType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1IndicatorPaging_DirectionType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "DirectionTypeUnknown\000Desc\000Asc\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1IndicatorPaging_DirectionType_DirectionTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1IndicatorPaging_DirectionType_Desc,
        KEYAPISTELEMETRYCONTROLV1IndicatorPaging_DirectionType_Asc,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1IndicatorPaging_DirectionType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1IndicatorPaging_DirectionType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1IndicatorPaging_DirectionType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1IndicatorPaging_DirectionType_DirectionTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1IndicatorPaging_DirectionType_Desc:
    case KEYAPISTELEMETRYCONTROLV1IndicatorPaging_DirectionType_Asc:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1Indicator_VendorType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1Indicator_VendorType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "VendorTypeUnknown\000Enviro\000Lartech\000Rtk\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1Indicator_VendorType_VendorTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1Indicator_VendorType_Enviro,
        KEYAPISTELEMETRYCONTROLV1Indicator_VendorType_Lartech,
        KEYAPISTELEMETRYCONTROLV1Indicator_VendorType_Rtk,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1Indicator_VendorType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1Indicator_VendorType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1Indicator_VendorType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1Indicator_VendorType_VendorTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1Indicator_VendorType_Enviro:
    case KEYAPISTELEMETRYCONTROLV1Indicator_VendorType_Lartech:
    case KEYAPISTELEMETRYCONTROLV1Indicator_VendorType_Rtk:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1Indicator_UnitType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "UnitTypeUnknown\000Percent\000C\000Wt\000Gkal\000Value\000"
        "Kwh\000KgCm2\000KgfCm2\000M3\000M3H\000Mpa\000Ms\000Boolean\000T"
        "\000TH\000H\000NonMeasurable\000Imp\000J\000Kj\000Gj\000Wth\000Kwt\000"
        "Min\000S\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_UnitTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Percent,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_C,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Wt,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Gkal,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Value,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Kwh,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_KgCm2,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_KgfCm2,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_M3,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_M3H,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Mpa,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Ms,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Boolean,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_T,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_TH,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_H,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_NonMeasurable,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Imp,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_J,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Kj,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Gj,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Wth,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Kwt,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Min,
        KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_S,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1Indicator_UnitType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_UnitTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Percent:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_C:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Wt:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Gkal:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Value:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Kwh:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_KgCm2:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_KgfCm2:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_M3:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_M3H:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Mpa:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Ms:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Boolean:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_T:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_TH:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_H:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_NonMeasurable:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Imp:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_J:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Kj:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Gj:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Wth:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Kwt:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_Min:
    case KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_S:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1Indicator_SignType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1Indicator_SignType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "SignTypeUnknown\000AbsoluteDs\000AbsoluteRc\000In"
        "tervalDs\000IntervalRc\000CurrentDs\000CurrentRs\000"
        "Volume\000Parameter\000Flag\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1Indicator_SignType_SignTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1Indicator_SignType_AbsoluteDs,
        KEYAPISTELEMETRYCONTROLV1Indicator_SignType_AbsoluteRc,
        KEYAPISTELEMETRYCONTROLV1Indicator_SignType_IntervalDs,
        KEYAPISTELEMETRYCONTROLV1Indicator_SignType_IntervalRc,
        KEYAPISTELEMETRYCONTROLV1Indicator_SignType_CurrentDs,
        KEYAPISTELEMETRYCONTROLV1Indicator_SignType_CurrentRs,
        KEYAPISTELEMETRYCONTROLV1Indicator_SignType_Volume,
        KEYAPISTELEMETRYCONTROLV1Indicator_SignType_Parameter,
        KEYAPISTELEMETRYCONTROLV1Indicator_SignType_Flag,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1Indicator_SignType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1Indicator_SignType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1Indicator_SignType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1Indicator_SignType_SignTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1Indicator_SignType_AbsoluteDs:
    case KEYAPISTELEMETRYCONTROLV1Indicator_SignType_AbsoluteRc:
    case KEYAPISTELEMETRYCONTROLV1Indicator_SignType_IntervalDs:
    case KEYAPISTELEMETRYCONTROLV1Indicator_SignType_IntervalRc:
    case KEYAPISTELEMETRYCONTROLV1Indicator_SignType_CurrentDs:
    case KEYAPISTELEMETRYCONTROLV1Indicator_SignType_CurrentRs:
    case KEYAPISTELEMETRYCONTROLV1Indicator_SignType_Volume:
    case KEYAPISTELEMETRYCONTROLV1Indicator_SignType_Parameter:
    case KEYAPISTELEMETRYCONTROLV1Indicator_SignType_Flag:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "ArchiveTypeUnknown\000Current\000Halfhour\000Hour"
        "\000Day\000Month\000Year\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType_ArchiveTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType_Current,
        KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType_Halfhour,
        KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType_Hour,
        KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType_Day,
        KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType_Month,
        KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType_Year,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType_ArchiveTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType_Current:
    case KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType_Halfhour:
    case KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType_Hour:
    case KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType_Day:
    case KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType_Month:
    case KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType_Year:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1Device_SecondaryCurrentType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1Device_SecondaryCurrentType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "SecondaryCurrentTypeUnknown\000Tt1A\000Tt2A\000Tt"
        "5A\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1Device_SecondaryCurrentType_SecondaryCurrentTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1Device_SecondaryCurrentType_Tt1A,
        KEYAPISTELEMETRYCONTROLV1Device_SecondaryCurrentType_Tt2A,
        KEYAPISTELEMETRYCONTROLV1Device_SecondaryCurrentType_Tt5A,
    };
    static const char *extraTextFormatInfo = "\003\001b\002\000\002b\002\000\003b\002\000";
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1Device_SecondaryCurrentType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1Device_SecondaryCurrentType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None
                              extraTextFormatInfo:extraTextFormatInfo];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1Device_SecondaryCurrentType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1Device_SecondaryCurrentType_SecondaryCurrentTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1Device_SecondaryCurrentType_Tt1A:
    case KEYAPISTELEMETRYCONTROLV1Device_SecondaryCurrentType_Tt2A:
    case KEYAPISTELEMETRYCONTROLV1Device_SecondaryCurrentType_Tt5A:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1Device_Type

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1Device_Type_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "TypeUnknown\000Hub\000PulseCounterRecorder\000Pul"
        "seCounterRecorderLr\000MeteringDevice\000Inter"
        "faceConverter\000MBusHub\000CommunicationModul"
        "eLr\000BaseLr\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1Device_Type_TypeUnknown,
        KEYAPISTELEMETRYCONTROLV1Device_Type_Hub,
        KEYAPISTELEMETRYCONTROLV1Device_Type_PulseCounterRecorder,
        KEYAPISTELEMETRYCONTROLV1Device_Type_PulseCounterRecorderLr,
        KEYAPISTELEMETRYCONTROLV1Device_Type_MeteringDevice,
        KEYAPISTELEMETRYCONTROLV1Device_Type_InterfaceConverter,
        KEYAPISTELEMETRYCONTROLV1Device_Type_MBusHub,
        KEYAPISTELEMETRYCONTROLV1Device_Type_CommunicationModuleLr,
        KEYAPISTELEMETRYCONTROLV1Device_Type_BaseLr,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1Device_Type)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1Device_Type_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1Device_Type_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1Device_Type_TypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1Device_Type_Hub:
    case KEYAPISTELEMETRYCONTROLV1Device_Type_PulseCounterRecorder:
    case KEYAPISTELEMETRYCONTROLV1Device_Type_PulseCounterRecorderLr:
    case KEYAPISTELEMETRYCONTROLV1Device_Type_MeteringDevice:
    case KEYAPISTELEMETRYCONTROLV1Device_Type_InterfaceConverter:
    case KEYAPISTELEMETRYCONTROLV1Device_Type_MBusHub:
    case KEYAPISTELEMETRYCONTROLV1Device_Type_CommunicationModuleLr:
    case KEYAPISTELEMETRYCONTROLV1Device_Type_BaseLr:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1Device_StatusType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1Device_StatusType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "StatusTypeUnknown\000Received\000Active\000Wrong\000"
        "Archive\000Delete\000Unlink\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1Device_StatusType_StatusTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1Device_StatusType_Received,
        KEYAPISTELEMETRYCONTROLV1Device_StatusType_Active,
        KEYAPISTELEMETRYCONTROLV1Device_StatusType_Wrong,
        KEYAPISTELEMETRYCONTROLV1Device_StatusType_Archive,
        KEYAPISTELEMETRYCONTROLV1Device_StatusType_Delete,
        KEYAPISTELEMETRYCONTROLV1Device_StatusType_Unlink,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1Device_StatusType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1Device_StatusType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1Device_StatusType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1Device_StatusType_StatusTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1Device_StatusType_Received:
    case KEYAPISTELEMETRYCONTROLV1Device_StatusType_Active:
    case KEYAPISTELEMETRYCONTROLV1Device_StatusType_Wrong:
    case KEYAPISTELEMETRYCONTROLV1Device_StatusType_Archive:
    case KEYAPISTELEMETRYCONTROLV1Device_StatusType_Delete:
    case KEYAPISTELEMETRYCONTROLV1Device_StatusType_Unlink:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1Device_PlanType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1Device_PlanType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "PlanTypeUnknown\000Single\000Double\000Triple\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1Device_PlanType_PlanTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1Device_PlanType_Single,
        KEYAPISTELEMETRYCONTROLV1Device_PlanType_Double,
        KEYAPISTELEMETRYCONTROLV1Device_PlanType_Triple,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1Device_PlanType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1Device_PlanType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1Device_PlanType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1Device_PlanType_PlanTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1Device_PlanType_Single:
    case KEYAPISTELEMETRYCONTROLV1Device_PlanType_Double:
    case KEYAPISTELEMETRYCONTROLV1Device_PlanType_Triple:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1Device_PipeType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1Device_PipeType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "PipeTypeUnknown\000Infeed\000Circulating\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1Device_PipeType_PipeTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1Device_PipeType_Infeed,
        KEYAPISTELEMETRYCONTROLV1Device_PipeType_Circulating,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1Device_PipeType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1Device_PipeType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1Device_PipeType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1Device_PipeType_PipeTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1Device_PipeType_Infeed:
    case KEYAPISTELEMETRYCONTROLV1Device_PipeType_Circulating:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "MetricTypeUnknown\000HotWater\000ColdWater\000Hea"
        "t\000Gas\000Electricity\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType_MetricTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType_HotWater,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType_ColdWater,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType_Heat,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType_Gas,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType_Electricity,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType_MetricTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType_HotWater:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType_ColdWater:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType_Heat:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType_Gas:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType_Electricity:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_StatusType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_StatusType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "StatusTypeUnknown\000Active\000Wrong\000Archive\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_StatusType_StatusTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_StatusType_Active,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_StatusType_Wrong,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_StatusType_Archive,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_StatusType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_StatusType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_StatusType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_StatusType_StatusTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_StatusType_Active:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_StatusType_Wrong:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_StatusType_Archive:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_AccountingType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_AccountingType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "AccountingTypeUnknown\000Commercial\000Technic"
        "al\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_AccountingType_AccountingTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_AccountingType_Commercial,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_AccountingType_Technical,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_AccountingType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_AccountingType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_AccountingType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_AccountingType_AccountingTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_AccountingType_Commercial:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_AccountingType_Technical:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "PrimaryCurrentTypeUnknown\000Tt1A\000Tt5A\000Tt10"
        "A\000Tt15A\000Tt20A\000Tt30A\000Tt40A\000Tt50A\000Tt75A\000Tt"
        "80A\000Tt100A\000Tt150A\000Tt200A\000Tt300A\000Tt400A\000T"
        "t500A\000Tt600A\000Tt750A\000Tt800A\000Tt1000A\000Tt120"
        "0A\000Tt1500A\000Tt2000A\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_PrimaryCurrentTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt1A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt5A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt10A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt15A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt20A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt30A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt40A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt50A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt75A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt80A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt100A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt150A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt200A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt300A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt400A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt500A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt600A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt750A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt800A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt1000A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt1200A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt1500A,
        KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt2000A,
    };
    static const char *extraTextFormatInfo = "\027\001b\002\000\002b\002\000\003b\003\000\004b\003\000\005b\003\000\006b\003\000\007b\003\000\010b\003\000\tb\003\000\nb\003\000\013b\004\000\014b\004\000\rb\004\000\016b\004\000\017b\004\000\020b\004\000\021b\004\000\022b\004\000\023b\004\000\024b\005\000\025b\005\000\026b\005\000\027b\005\000";
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None
                              extraTextFormatInfo:extraTextFormatInfo];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_PrimaryCurrentTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt1A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt5A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt10A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt15A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt20A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt30A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt40A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt50A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt75A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt80A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt100A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt150A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt200A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt300A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt400A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt500A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt600A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt750A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt800A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt1000A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt1200A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt1500A:
    case KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_Tt2000A:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1DevicePaging_OrderByType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1DevicePaging_OrderByType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "OrderByTypeUnknown\000Id\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1DevicePaging_OrderByType_OrderByTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1DevicePaging_OrderByType_Id,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1DevicePaging_OrderByType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1DevicePaging_OrderByType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1DevicePaging_OrderByType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1DevicePaging_OrderByType_OrderByTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1DevicePaging_OrderByType_Id:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1DevicePaging_DirectionType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1DevicePaging_DirectionType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "DirectionTypeUnknown\000Desc\000Asc\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1DevicePaging_DirectionType_DirectionTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1DevicePaging_DirectionType_Desc,
        KEYAPISTELEMETRYCONTROLV1DevicePaging_DirectionType_Asc,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1DevicePaging_DirectionType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1DevicePaging_DirectionType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1DevicePaging_DirectionType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1DevicePaging_DirectionType_DirectionTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1DevicePaging_DirectionType_Desc:
    case KEYAPISTELEMETRYCONTROLV1DevicePaging_DirectionType_Asc:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_OrderByType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_OrderByType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "OrderByTypeUnknown\000IndicatorId\000MetricPoi"
        "ntId\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_OrderByType_OrderByTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_OrderByType_IndicatorId,
        KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_OrderByType_MetricPointId,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_OrderByType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_OrderByType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_OrderByType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_OrderByType_OrderByTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_OrderByType_IndicatorId:
    case KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_OrderByType_MetricPointId:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_DirectionType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_DirectionType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "DirectionTypeUnknown\000Desc\000Asc\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_DirectionType_DirectionTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_DirectionType_Desc,
        KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_DirectionType_Asc,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_DirectionType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_DirectionType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_DirectionType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_DirectionType_DirectionTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_DirectionType_Desc:
    case KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_DirectionType_Asc:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - KEYAPISTELEMETRYCONTROLV1DeleteDeviceRequest

@implementation KEYAPISTELEMETRYCONTROLV1DeleteDeviceRequest

@dynamic id_p;

typedef struct KEYAPISTELEMETRYCONTROLV1DeleteDeviceRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
} KEYAPISTELEMETRYCONTROLV1DeleteDeviceRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeleteDeviceRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeleteDeviceRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeleteDeviceRequest)
                                   messageName:@"DeleteDeviceRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1DeleteDeviceRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1DeleteDeviceResponse

@implementation KEYAPISTELEMETRYCONTROLV1DeleteDeviceResponse


typedef struct KEYAPISTELEMETRYCONTROLV1DeleteDeviceResponse__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1DeleteDeviceResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeleteDeviceResponse)
                                   messageName:@"DeleteDeviceResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1DeleteDeviceResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PutDeviceGroupAttachRequest

@implementation KEYAPISTELEMETRYCONTROLV1PutDeviceGroupAttachRequest

@dynamic hasDeviceGroup, deviceGroup;

typedef struct KEYAPISTELEMETRYCONTROLV1PutDeviceGroupAttachRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1DeviceGroup *deviceGroup;
} KEYAPISTELEMETRYCONTROLV1PutDeviceGroupAttachRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "deviceGroup",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceGroup),
        .number = KEYAPISTELEMETRYCONTROLV1PutDeviceGroupAttachRequest_FieldNumber_DeviceGroup,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PutDeviceGroupAttachRequest__storage_, deviceGroup),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PutDeviceGroupAttachRequest)
                                   messageName:@"PutDeviceGroupAttachRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PutDeviceGroupAttachRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PutDeviceGroupAttachResponse

@implementation KEYAPISTELEMETRYCONTROLV1PutDeviceGroupAttachResponse


typedef struct KEYAPISTELEMETRYCONTROLV1PutDeviceGroupAttachResponse__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1PutDeviceGroupAttachResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PutDeviceGroupAttachResponse)
                                   messageName:@"PutDeviceGroupAttachResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PutDeviceGroupAttachResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListRequest

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListRequest

@dynamic paginationOneOfCase;
@dynamic hasFilter, filter;
@dynamic paging;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListRequest__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1DeviceGroupFilter *filter;
  KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging *paging;
} KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "filter",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceGroupFilter),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "paging",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListRequest_FieldNumber_Paging,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListRequest__storage_, paging),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListRequest)
                                   messageName:@"GetDeviceGroupListRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "pagination",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListRequest_ClearPaginationOneOfCase(KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListRequest *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListRequest descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging

@implementation KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging

@dynamic orderByType;
@dynamic directionType;
@dynamic limit;
@dynamic offset;

typedef struct KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_OrderByType orderByType;
  KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_DirectionType directionType;
  int32_t limit;
  int32_t offset;
} KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "orderByType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_OrderByType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_FieldNumber_OrderByType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging__storage_, orderByType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "directionType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_DirectionType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_FieldNumber_DirectionType,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging__storage_, directionType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "limit",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_FieldNumber_Limit,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging__storage_, limit),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_FieldNumber_Offset,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging__storage_, offset),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging)
                                   messageName:@"DeviceGroupPaging"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_OrderByType_RawValue(KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_FieldNumber_OrderByType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_OrderByType_RawValue(KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_FieldNumber_OrderByType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_DirectionType_RawValue(KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_FieldNumber_DirectionType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_DirectionType_RawValue(KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1DeviceGroupPaging_FieldNumber_DirectionType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListResponse

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListResponse

@dynamic typeOneOfCase;
@dynamic data_p;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1DeviceGroup *data_p;
} KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceGroup),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListResponse)
                                   messageName:@"GetDeviceGroupListResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListResponse_ClearTypeOneOfCase(KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetDeviceGroupListResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountRequest

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountRequest

@dynamic hasFilter, filter;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1DeviceGroupFilter *filter;
} KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "filter",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceGroupFilter),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountRequest)
                                   messageName:@"GetDeviceGroupCountRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1DeviceGroupFilter

@implementation KEYAPISTELEMETRYCONTROLV1DeviceGroupFilter

@dynamic groupIdsArray, groupIdsArray_Count;
@dynamic deviceIdsArray, deviceIdsArray_Count;

typedef struct KEYAPISTELEMETRYCONTROLV1DeviceGroupFilter__storage_ {
  uint32_t _has_storage_[1];
  NSMutableArray *groupIdsArray;
  GPBInt32Array *deviceIdsArray;
} KEYAPISTELEMETRYCONTROLV1DeviceGroupFilter__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "groupIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceGroupFilter_FieldNumber_GroupIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceGroupFilter__storage_, groupIdsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "deviceIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceGroupFilter_FieldNumber_DeviceIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceGroupFilter__storage_, deviceIdsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceGroupFilter)
                                   messageName:@"DeviceGroupFilter"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1DeviceGroupFilter__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountResponse

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountResponse

@dynamic typeOneOfCase;
@dynamic data_p;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountResponse__storage_ {
  uint32_t _has_storage_[2];
  int32_t data_p;
} KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountResponse)
                                   messageName:@"GetDeviceGroupCountResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountResponse_ClearTypeOneOfCase(KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetDeviceGroupCountResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1PutDeviceGroupDetachRequest

@implementation KEYAPISTELEMETRYCONTROLV1PutDeviceGroupDetachRequest

@dynamic hasDeviceGroup, deviceGroup;

typedef struct KEYAPISTELEMETRYCONTROLV1PutDeviceGroupDetachRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1DeviceGroup *deviceGroup;
} KEYAPISTELEMETRYCONTROLV1PutDeviceGroupDetachRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "deviceGroup",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceGroup),
        .number = KEYAPISTELEMETRYCONTROLV1PutDeviceGroupDetachRequest_FieldNumber_DeviceGroup,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PutDeviceGroupDetachRequest__storage_, deviceGroup),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PutDeviceGroupDetachRequest)
                                   messageName:@"PutDeviceGroupDetachRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PutDeviceGroupDetachRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PutDeviceGroupDetachResponse

@implementation KEYAPISTELEMETRYCONTROLV1PutDeviceGroupDetachResponse


typedef struct KEYAPISTELEMETRYCONTROLV1PutDeviceGroupDetachResponse__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1PutDeviceGroupDetachResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PutDeviceGroupDetachResponse)
                                   messageName:@"PutDeviceGroupDetachResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PutDeviceGroupDetachResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1DeviceGroup

@implementation KEYAPISTELEMETRYCONTROLV1DeviceGroup

@dynamic groupId;
@dynamic deviceId;

typedef struct KEYAPISTELEMETRYCONTROLV1DeviceGroup__storage_ {
  uint32_t _has_storage_[1];
  int32_t deviceId;
  NSString *groupId;
} KEYAPISTELEMETRYCONTROLV1DeviceGroup__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "groupId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceGroup_FieldNumber_GroupId,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceGroup__storage_, groupId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "deviceId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceGroup_FieldNumber_DeviceId,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceGroup__storage_, deviceId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceGroup)
                                   messageName:@"DeviceGroup"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1DeviceGroup__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorRequest

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorRequest

@dynamic hasData_p, data_p;

typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1Indicator *data_p;
} KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Indicator),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorRequest_FieldNumber_Data_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorRequest__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorRequest)
                                   messageName:@"PostDeviceIndicatorRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse

@dynamic typeOneOfCase;
@dynamic data_p;
@dynamic error;

typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1Indicator *data_p;
  KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse_Error *error;
} KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Indicator),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse_Error),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse)
                                   messageName:@"PostDeviceIndicatorResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse_ClearTypeOneOfCase(KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse_Error

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1Indicator_ValidationError *validation;
} KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "validation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Indicator_ValidationError),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse_Error__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse_Error_ClearReasonOneOfCase(KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse_Error *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1PostDeviceIndicatorResponse_Error descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorRequest

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorRequest

@dynamic id_p;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
} KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorRequest)
                                   messageName:@"GetDeviceIndicatorRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorResponse

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorResponse

@dynamic typeOneOfCase;
@dynamic data_p;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1Indicator *data_p;
} KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Indicator),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorResponse)
                                   messageName:@"GetDeviceIndicatorResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorResponse_ClearTypeOneOfCase(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceRequest

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceRequest

@dynamic id_p;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
} KEYAPISTELEMETRYCONTROLV1GetDeviceRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceRequest)
                                   messageName:@"GetDeviceRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceResponse

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceResponse

@dynamic typeOneOfCase;
@dynamic data_p;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1Device *data_p;
} KEYAPISTELEMETRYCONTROLV1GetDeviceResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Device),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceResponse)
                                   messageName:@"GetDeviceResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1GetDeviceResponse_ClearTypeOneOfCase(KEYAPISTELEMETRYCONTROLV1GetDeviceResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetDeviceResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListRequest

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListRequest

@dynamic paginationOneOfCase;
@dynamic hasFilter, filter;
@dynamic paging;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListRequest__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1IndicatorFilter *filter;
  KEYAPISTELEMETRYCONTROLV1IndicatorPaging *paging;
} KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "filter",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1IndicatorFilter),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "paging",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1IndicatorPaging),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListRequest_FieldNumber_Paging,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListRequest__storage_, paging),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListRequest)
                                   messageName:@"GetDeviceIndicatorListRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "pagination",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListRequest_ClearPaginationOneOfCase(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListRequest *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListRequest descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1IndicatorPaging

@implementation KEYAPISTELEMETRYCONTROLV1IndicatorPaging

@dynamic orderByType;
@dynamic directionType;
@dynamic limit;
@dynamic offset;

typedef struct KEYAPISTELEMETRYCONTROLV1IndicatorPaging__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1IndicatorPaging_OrderByType orderByType;
  KEYAPISTELEMETRYCONTROLV1IndicatorPaging_DirectionType directionType;
  int32_t limit;
  int32_t offset;
} KEYAPISTELEMETRYCONTROLV1IndicatorPaging__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "orderByType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1IndicatorPaging_OrderByType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1IndicatorPaging_FieldNumber_OrderByType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1IndicatorPaging__storage_, orderByType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "directionType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1IndicatorPaging_DirectionType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1IndicatorPaging_FieldNumber_DirectionType,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1IndicatorPaging__storage_, directionType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "limit",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1IndicatorPaging_FieldNumber_Limit,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1IndicatorPaging__storage_, limit),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1IndicatorPaging_FieldNumber_Offset,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1IndicatorPaging__storage_, offset),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1IndicatorPaging)
                                   messageName:@"IndicatorPaging"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1IndicatorPaging__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISTELEMETRYCONTROLV1IndicatorPaging_OrderByType_RawValue(KEYAPISTELEMETRYCONTROLV1IndicatorPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1IndicatorPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1IndicatorPaging_FieldNumber_OrderByType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1IndicatorPaging_OrderByType_RawValue(KEYAPISTELEMETRYCONTROLV1IndicatorPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1IndicatorPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1IndicatorPaging_FieldNumber_OrderByType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISTELEMETRYCONTROLV1IndicatorPaging_DirectionType_RawValue(KEYAPISTELEMETRYCONTROLV1IndicatorPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1IndicatorPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1IndicatorPaging_FieldNumber_DirectionType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1IndicatorPaging_DirectionType_RawValue(KEYAPISTELEMETRYCONTROLV1IndicatorPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1IndicatorPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1IndicatorPaging_FieldNumber_DirectionType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError

@implementation KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError

@dynamic reasonOneOfCase;
@dynamic limit;
@dynamic offset;

typedef struct KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_LimitInvalid *limit;
  KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_OffsetInvalid *offset;
} KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "limit",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_LimitInvalid),
        .number = KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_FieldNumber_Limit,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError__storage_, limit),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_OffsetInvalid),
        .number = KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_FieldNumber_Offset,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError__storage_, offset),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError)
                                   messageName:@"ValidationError"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1IndicatorPaging)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_ClearReasonOneOfCase(KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_LimitInvalid

@implementation KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_LimitInvalid


typedef struct KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_LimitInvalid__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_LimitInvalid__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_LimitInvalid)
                                   messageName:@"LimitInvalid"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_LimitInvalid__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_OffsetInvalid

@implementation KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_OffsetInvalid


typedef struct KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_OffsetInvalid__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_OffsetInvalid__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_OffsetInvalid)
                                   messageName:@"OffsetInvalid"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError_OffsetInvalid__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse

@dynamic typeOneOfCase;
@dynamic data_p;
@dynamic error;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1Indicator *data_p;
  KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse_Error *error;
} KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Indicator),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse_Error),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse)
                                   messageName:@"GetDeviceIndicatorListResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse_ClearTypeOneOfCase(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse_Error

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse_Error

@dynamic reasonOneOfCase;
@dynamic deviceFilterValidation;
@dynamic devicePagingValidation;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1IndicatorFilter_ValidationError *deviceFilterValidation;
  KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError *devicePagingValidation;
} KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "deviceFilterValidation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1IndicatorFilter_ValidationError),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse_Error_FieldNumber_DeviceFilterValidation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse_Error__storage_, deviceFilterValidation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "devicePagingValidation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1IndicatorPaging_ValidationError),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse_Error_FieldNumber_DevicePagingValidation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse_Error__storage_, devicePagingValidation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse_Error__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse_Error_ClearReasonOneOfCase(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse_Error *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorListResponse_Error descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1IndicatorFilter

@implementation KEYAPISTELEMETRYCONTROLV1IndicatorFilter

@dynamic deviceIdsArray, deviceIdsArray_Count;
@dynamic signTypesArray, signTypesArray_Count;
@dynamic idsArray, idsArray_Count;
@dynamic deviceSerialNumbersArray, deviceSerialNumbersArray_Count;
@dynamic buildingIdsArray, buildingIdsArray_Count;
@dynamic roomNumbersArray, roomNumbersArray_Count;
@dynamic roomLabelsArray, roomLabelsArray_Count;
@dynamic metricPointIdsArray, metricPointIdsArray_Count;
@dynamic indicatorVendorTypesArray, indicatorVendorTypesArray_Count;

typedef struct KEYAPISTELEMETRYCONTROLV1IndicatorFilter__storage_ {
  uint32_t _has_storage_[1];
  GPBInt32Array *deviceIdsArray;
  GPBEnumArray *signTypesArray;
  GPBInt32Array *idsArray;
  NSMutableArray *deviceSerialNumbersArray;
  GPBInt32Array *buildingIdsArray;
  NSMutableArray *roomNumbersArray;
  NSMutableArray *roomLabelsArray;
  NSMutableArray *metricPointIdsArray;
  GPBEnumArray *indicatorVendorTypesArray;
} KEYAPISTELEMETRYCONTROLV1IndicatorFilter__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "deviceIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1IndicatorFilter_FieldNumber_DeviceIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1IndicatorFilter__storage_, deviceIdsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "signTypesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Indicator_SignType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1IndicatorFilter_FieldNumber_SignTypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1IndicatorFilter__storage_, signTypesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "idsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1IndicatorFilter_FieldNumber_IdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1IndicatorFilter__storage_, idsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "deviceSerialNumbersArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1IndicatorFilter_FieldNumber_DeviceSerialNumbersArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1IndicatorFilter__storage_, deviceSerialNumbersArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "buildingIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1IndicatorFilter_FieldNumber_BuildingIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1IndicatorFilter__storage_, buildingIdsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "roomNumbersArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1IndicatorFilter_FieldNumber_RoomNumbersArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1IndicatorFilter__storage_, roomNumbersArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "roomLabelsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1IndicatorFilter_FieldNumber_RoomLabelsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1IndicatorFilter__storage_, roomLabelsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "metricPointIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1IndicatorFilter_FieldNumber_MetricPointIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1IndicatorFilter__storage_, metricPointIdsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "indicatorVendorTypesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Indicator_VendorType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1IndicatorFilter_FieldNumber_IndicatorVendorTypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1IndicatorFilter__storage_, indicatorVendorTypesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1IndicatorFilter)
                                   messageName:@"IndicatorFilter"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1IndicatorFilter__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1IndicatorFilter_ValidationError

@implementation KEYAPISTELEMETRYCONTROLV1IndicatorFilter_ValidationError

@dynamic path;
@dynamic message;

typedef struct KEYAPISTELEMETRYCONTROLV1IndicatorFilter_ValidationError__storage_ {
  uint32_t _has_storage_[1];
  NSString *path;
  NSString *message;
} KEYAPISTELEMETRYCONTROLV1IndicatorFilter_ValidationError__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "path",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1IndicatorFilter_ValidationError_FieldNumber_Path,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1IndicatorFilter_ValidationError__storage_, path),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "message",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1IndicatorFilter_ValidationError_FieldNumber_Message,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1IndicatorFilter_ValidationError__storage_, message),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1IndicatorFilter_ValidationError)
                                   messageName:@"ValidationError"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1IndicatorFilter_ValidationError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1IndicatorFilter)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountRequest

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountRequest

@dynamic hasFilter, filter;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1IndicatorFilter *filter;
} KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "filter",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1IndicatorFilter),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountRequest)
                                   messageName:@"GetDeviceIndicatorCountRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse

@dynamic typeOneOfCase;
@dynamic data_p;
@dynamic error;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse__storage_ {
  uint32_t _has_storage_[2];
  int32_t data_p;
  KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse_Error *error;
} KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse_Error),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse)
                                   messageName:@"GetDeviceIndicatorCountResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse_ClearTypeOneOfCase(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse_Error

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse_Error

@dynamic reasonOneOfCase;
@dynamic deviceFilterValidation;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1IndicatorFilter_ValidationError *deviceFilterValidation;
} KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "deviceFilterValidation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1IndicatorFilter_ValidationError),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse_Error_FieldNumber_DeviceFilterValidation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse_Error__storage_, deviceFilterValidation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse_Error__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse_Error_ClearReasonOneOfCase(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse_Error *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorCountResponse_Error descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1DeleteDeviceIndicatorRequest

@implementation KEYAPISTELEMETRYCONTROLV1DeleteDeviceIndicatorRequest

@dynamic id_p;

typedef struct KEYAPISTELEMETRYCONTROLV1DeleteDeviceIndicatorRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
} KEYAPISTELEMETRYCONTROLV1DeleteDeviceIndicatorRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeleteDeviceIndicatorRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeleteDeviceIndicatorRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeleteDeviceIndicatorRequest)
                                   messageName:@"DeleteDeviceIndicatorRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1DeleteDeviceIndicatorRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1DeleteDeviceIndicatorResponse

@implementation KEYAPISTELEMETRYCONTROLV1DeleteDeviceIndicatorResponse


typedef struct KEYAPISTELEMETRYCONTROLV1DeleteDeviceIndicatorResponse__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1DeleteDeviceIndicatorResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeleteDeviceIndicatorResponse)
                                   messageName:@"DeleteDeviceIndicatorResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1DeleteDeviceIndicatorResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest

@dynamic taskOneOfCase;
@dynamic requestId;
@dynamic postDeviceFullDuplexDeviceAsyncStatus;

typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest__storage_ {
  uint32_t _has_storage_[2];
  NSString *requestId;
  KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus *postDeviceFullDuplexDeviceAsyncStatus;
} KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "requestId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_FieldNumber_RequestId,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest__storage_, requestId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "postDeviceFullDuplexDeviceAsyncStatus",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_FieldNumber_PostDeviceFullDuplexDeviceAsyncStatus,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest__storage_, postDeviceFullDuplexDeviceAsyncStatus),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest)
                                   messageName:@"PostDeviceFullDuplexRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "task",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_ClearTaskOneOfCase(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus

@dynamic typeOneOfCase;
@dynamic deviceId;
@dynamic data_p;
@dynamic error;

typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus__storage_ {
  uint32_t _has_storage_[2];
  int32_t deviceId;
  KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Success *data_p;
  KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error *error;
} KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "deviceId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_FieldNumber_DeviceId,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus__storage_, deviceId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Success),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus)
                                   messageName:@"DeviceAsyncStatus"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_ClearTypeOneOfCase(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Success

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Success


typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Success__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Success__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Success)
                                   messageName:@"Success"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Success__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error

@dynamic reasonOneOfCase;
@dynamic postDeviceRequestUnknown;
@dynamic postDeviceRequestIp;
@dynamic postDeviceRequestPort;
@dynamic postDeviceRequestNetworkAddress;

typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_UnknownError *postDeviceRequestUnknown;
  KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_IpError *postDeviceRequestIp;
  KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_PortError *postDeviceRequestPort;
  KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_NetworkAddressError *postDeviceRequestNetworkAddress;
} KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "postDeviceRequestUnknown",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_UnknownError),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_FieldNumber_PostDeviceRequestUnknown,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error__storage_, postDeviceRequestUnknown),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "postDeviceRequestIp",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_IpError),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_FieldNumber_PostDeviceRequestIp,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error__storage_, postDeviceRequestIp),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "postDeviceRequestPort",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_PortError),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_FieldNumber_PostDeviceRequestPort,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error__storage_, postDeviceRequestPort),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "postDeviceRequestNetworkAddress",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_NetworkAddressError),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_FieldNumber_PostDeviceRequestNetworkAddress,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error__storage_, postDeviceRequestNetworkAddress),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_ClearReasonOneOfCase(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_UnknownError

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_UnknownError

@dynamic message;

typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_UnknownError__storage_ {
  uint32_t _has_storage_[1];
  NSString *message;
} KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_UnknownError__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "message",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_UnknownError_FieldNumber_Message,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_UnknownError__storage_, message),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_UnknownError)
                                   messageName:@"UnknownError"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_UnknownError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_IpError

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_IpError


typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_IpError__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_IpError__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_IpError)
                                   messageName:@"IpError"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_IpError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_PortError

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_PortError


typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_PortError__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_PortError__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_PortError)
                                   messageName:@"PortError"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_PortError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_NetworkAddressError

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_NetworkAddressError


typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_NetworkAddressError__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_NetworkAddressError__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_NetworkAddressError)
                                   messageName:@"NetworkAddressError"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error_NetworkAddressError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexRequest_DeviceAsyncStatus_Error)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceRequest

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceRequest

@dynamic hasDevice, device;

typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1Device *device;
} KEYAPISTELEMETRYCONTROLV1PostDeviceRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "device",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Device),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceRequest_FieldNumber_Device,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceRequest__storage_, device),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceRequest)
                                   messageName:@"PostDeviceRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceRequest

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceRequest

@dynamic replaceDeviceId;
@dynamic hasDevice, device;

typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t replaceDeviceId;
  KEYAPISTELEMETRYCONTROLV1Device *device;
} KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "replaceDeviceId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceRequest_FieldNumber_ReplaceDeviceId,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceRequest__storage_, replaceDeviceId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "device",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Device),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceRequest_FieldNumber_Device,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceRequest__storage_, device),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceRequest)
                                   messageName:@"PostDeviceReplaceRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse

@dynamic typeOneOfCase;
@dynamic data_p;
@dynamic error;

typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1Device *data_p;
  KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error *error;
} KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Device),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse)
                                   messageName:@"PostDeviceReplaceResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_ClearTypeOneOfCase(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;
@dynamic replaceDeviceNotFound;
@dynamic createIndicatorsFail;
@dynamic multiLinkedMetricPoint;
@dynamic wrongBuilding;
@dynamic metricPointNotFound;

typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1Device_ValidationError *validation;
  KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_ReplaceDeviceNotFound *replaceDeviceNotFound;
  KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_CreateIndicatorsFail *createIndicatorsFail;
  KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_MultiLinkedMetricPoint *multiLinkedMetricPoint;
  KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_WrongBuilding *wrongBuilding;
  KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_MetricPointNotFound *metricPointNotFound;
} KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "validation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Device_ValidationError),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "replaceDeviceNotFound",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_ReplaceDeviceNotFound),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_FieldNumber_ReplaceDeviceNotFound,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error__storage_, replaceDeviceNotFound),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "createIndicatorsFail",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_CreateIndicatorsFail),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_FieldNumber_CreateIndicatorsFail,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error__storage_, createIndicatorsFail),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "multiLinkedMetricPoint",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_MultiLinkedMetricPoint),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_FieldNumber_MultiLinkedMetricPoint,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error__storage_, multiLinkedMetricPoint),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "wrongBuilding",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_WrongBuilding),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_FieldNumber_WrongBuilding,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error__storage_, wrongBuilding),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "metricPointNotFound",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_MetricPointNotFound),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_FieldNumber_MetricPointNotFound,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error__storage_, metricPointNotFound),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_ClearReasonOneOfCase(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_ReplaceDeviceNotFound

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_ReplaceDeviceNotFound


typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_ReplaceDeviceNotFound__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_ReplaceDeviceNotFound__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_ReplaceDeviceNotFound)
                                   messageName:@"ReplaceDeviceNotFound"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_ReplaceDeviceNotFound__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_CreateIndicatorsFail

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_CreateIndicatorsFail


typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_CreateIndicatorsFail__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_CreateIndicatorsFail__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_CreateIndicatorsFail)
                                   messageName:@"CreateIndicatorsFail"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_CreateIndicatorsFail__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_MultiLinkedMetricPoint

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_MultiLinkedMetricPoint


typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_MultiLinkedMetricPoint__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_MultiLinkedMetricPoint__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_MultiLinkedMetricPoint)
                                   messageName:@"MultiLinkedMetricPoint"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_MultiLinkedMetricPoint__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_WrongBuilding

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_WrongBuilding


typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_WrongBuilding__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_WrongBuilding__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_WrongBuilding)
                                   messageName:@"WrongBuilding"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_WrongBuilding__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_MetricPointNotFound

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_MetricPointNotFound


typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_MetricPointNotFound__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_MetricPointNotFound__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_MetricPointNotFound)
                                   messageName:@"MetricPointNotFound"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error_MetricPointNotFound__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceReplaceResponse_Error)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexResponse

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexResponse

@dynamic eventOneOfCase;
@dynamic requestId;
@dynamic postDevice;

typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexResponse__storage_ {
  uint32_t _has_storage_[2];
  NSString *requestId;
  KEYAPISTELEMETRYCONTROLV1PostDeviceResponse *postDevice;
} KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "requestId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexResponse_FieldNumber_RequestId,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexResponse__storage_, requestId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "postDevice",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceResponse),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexResponse_FieldNumber_PostDevice,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexResponse__storage_, postDevice),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexResponse)
                                   messageName:@"PostDeviceFullDuplexResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "event",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexResponse_ClearEventOneOfCase(KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1PostDeviceFullDuplexResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceResponse

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceResponse

@dynamic typeOneOfCase;
@dynamic data_p;
@dynamic error;

typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1Device *data_p;
  KEYAPISTELEMETRYCONTROLV1PostDeviceResponse_Error *error;
} KEYAPISTELEMETRYCONTROLV1PostDeviceResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Device),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceResponse_Error),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceResponse)
                                   messageName:@"PostDeviceResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1PostDeviceResponse_ClearTypeOneOfCase(KEYAPISTELEMETRYCONTROLV1PostDeviceResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1PostDeviceResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1PostDeviceResponse_Error

@implementation KEYAPISTELEMETRYCONTROLV1PostDeviceResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISTELEMETRYCONTROLV1PostDeviceResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1Device_ValidationError *validation;
} KEYAPISTELEMETRYCONTROLV1PostDeviceResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "validation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Device_ValidationError),
        .number = KEYAPISTELEMETRYCONTROLV1PostDeviceResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostDeviceResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostDeviceResponse_Error__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostDeviceResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1PostDeviceResponse_Error_ClearReasonOneOfCase(KEYAPISTELEMETRYCONTROLV1PostDeviceResponse_Error *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1PostDeviceResponse_Error descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1Indicator

@implementation KEYAPISTELEMETRYCONTROLV1Indicator

@dynamic id_p;
@dynamic deviceId;
@dynamic title;
@dynamic unitType;
@dynamic signType;
@dynamic hasCreatedAt, createdAt;
@dynamic hasChangedAt, changedAt;
@dynamic isIndividual;
@dynamic hasCompatibilityCode, compatibilityCode;
@dynamic archiveType;
@dynamic presentationUnitType;
@dynamic hasCoefficient, coefficient;
@dynamic hasShift, shift;
@dynamic hasRoundDecimalDigits, roundDecimalDigits;
@dynamic metricExpectedFreq;
@dynamic hasChannelNumber, channelNumber;
@dynamic hasChannelOrder, channelOrder;
@dynamic vendorType;
@dynamic hasLastSyncedAt, lastSyncedAt;

typedef struct KEYAPISTELEMETRYCONTROLV1Indicator__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
  int32_t deviceId;
  KEYAPISTELEMETRYCONTROLV1Indicator_UnitType unitType;
  KEYAPISTELEMETRYCONTROLV1Indicator_SignType signType;
  KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType archiveType;
  KEYAPISTELEMETRYCONTROLV1Indicator_UnitType presentationUnitType;
  int32_t metricExpectedFreq;
  KEYAPISTELEMETRYCONTROLV1Indicator_VendorType vendorType;
  NSString *title;
  GPBTimestamp *createdAt;
  GPBTimestamp *changedAt;
  GPBStringValue *compatibilityCode;
  GPBFloatValue *coefficient;
  GPBFloatValue *shift;
  GPBInt32Value *roundDecimalDigits;
  GPBStringValue *channelNumber;
  GPBInt32Value *channelOrder;
  GPBTimestamp *lastSyncedAt;
} KEYAPISTELEMETRYCONTROLV1Indicator__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Indicator__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "deviceId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_DeviceId,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Indicator__storage_, deviceId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "title",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_Title,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Indicator__storage_, title),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "unitType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_UnitType,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Indicator__storage_, unitType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "signType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Indicator_SignType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_SignType,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Indicator__storage_, signType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "createdAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_CreatedAt,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Indicator__storage_, createdAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "changedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_ChangedAt,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Indicator__storage_, changedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "isIndividual",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_IsIndividual,
        .hasIndex = 7,
        .offset = 8,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "compatibilityCode",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_CompatibilityCode,
        .hasIndex = 9,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Indicator__storage_, compatibilityCode),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "archiveType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_ArchiveType,
        .hasIndex = 10,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Indicator__storage_, archiveType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "presentationUnitType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_PresentationUnitType,
        .hasIndex = 11,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Indicator__storage_, presentationUnitType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "coefficient",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBFloatValue),
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_Coefficient,
        .hasIndex = 12,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Indicator__storage_, coefficient),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "shift",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBFloatValue),
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_Shift,
        .hasIndex = 13,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Indicator__storage_, shift),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "roundDecimalDigits",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_RoundDecimalDigits,
        .hasIndex = 14,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Indicator__storage_, roundDecimalDigits),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "metricExpectedFreq",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_MetricExpectedFreq,
        .hasIndex = 15,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Indicator__storage_, metricExpectedFreq),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "channelNumber",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_ChannelNumber,
        .hasIndex = 16,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Indicator__storage_, channelNumber),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "channelOrder",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_ChannelOrder,
        .hasIndex = 17,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Indicator__storage_, channelOrder),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "vendorType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Indicator_VendorType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_VendorType,
        .hasIndex = 18,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Indicator__storage_, vendorType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "lastSyncedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_LastSyncedAt,
        .hasIndex = 19,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Indicator__storage_, lastSyncedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Indicator)
                                   messageName:@"Indicator"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1Indicator__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISTELEMETRYCONTROLV1Indicator_UnitType_RawValue(KEYAPISTELEMETRYCONTROLV1Indicator *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Indicator descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_UnitType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1Indicator_UnitType_RawValue(KEYAPISTELEMETRYCONTROLV1Indicator *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Indicator descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_UnitType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISTELEMETRYCONTROLV1Indicator_SignType_RawValue(KEYAPISTELEMETRYCONTROLV1Indicator *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Indicator descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_SignType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1Indicator_SignType_RawValue(KEYAPISTELEMETRYCONTROLV1Indicator *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Indicator descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_SignType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType_RawValue(KEYAPISTELEMETRYCONTROLV1Indicator *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Indicator descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_ArchiveType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1Indicator_ArchiveType_RawValue(KEYAPISTELEMETRYCONTROLV1Indicator *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Indicator descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_ArchiveType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISTELEMETRYCONTROLV1Indicator_PresentationUnitType_RawValue(KEYAPISTELEMETRYCONTROLV1Indicator *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Indicator descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_PresentationUnitType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1Indicator_PresentationUnitType_RawValue(KEYAPISTELEMETRYCONTROLV1Indicator *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Indicator descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_PresentationUnitType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISTELEMETRYCONTROLV1Indicator_VendorType_RawValue(KEYAPISTELEMETRYCONTROLV1Indicator *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Indicator descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_VendorType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1Indicator_VendorType_RawValue(KEYAPISTELEMETRYCONTROLV1Indicator *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Indicator descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Indicator_FieldNumber_VendorType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISTELEMETRYCONTROLV1Indicator_ValidationError

@implementation KEYAPISTELEMETRYCONTROLV1Indicator_ValidationError

@dynamic path;
@dynamic message;

typedef struct KEYAPISTELEMETRYCONTROLV1Indicator_ValidationError__storage_ {
  uint32_t _has_storage_[1];
  NSString *path;
  NSString *message;
} KEYAPISTELEMETRYCONTROLV1Indicator_ValidationError__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "path",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_ValidationError_FieldNumber_Path,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Indicator_ValidationError__storage_, path),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "message",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Indicator_ValidationError_FieldNumber_Message,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Indicator_ValidationError__storage_, message),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Indicator_ValidationError)
                                   messageName:@"ValidationError"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1Indicator_ValidationError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Indicator)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1Device

@implementation KEYAPISTELEMETRYCONTROLV1Device

@dynamic id_p;
@dynamic indicatorsArray, indicatorsArray_Count;
@dynamic hasMetricPoint, metricPoint;
@dynamic hasCreatedAt, createdAt;
@dynamic hasChangedAt, changedAt;
@dynamic type;
@dynamic serialNumber;
@dynamic model;
@dynamic year;
@dynamic fiasId;
@dynamic resourceOwnerId;
@dynamic statusType;
@dynamic hasInstalledAt, installedAt;
@dynamic hasRemovedAt, removedAt;
@dynamic hasCheckAt, checkAt;
@dynamic hasNextCheckAt, nextCheckAt;
@dynamic hasExternalId, externalId;
@dynamic planType;
@dynamic hasParentId, parentId;
@dynamic pipeType;
@dynamic hasDevEui, devEui;
@dynamic hasMac, mac;
@dynamic hasPort, port;
@dynamic hasNetworkAddress, networkAddress;
@dynamic hasCommChannel, commChannel;
@dynamic hasSimNumber, simNumber;
@dynamic hasSimSerial, simSerial;
@dynamic hasIpAddressSim, ipAddressSim;
@dynamic hasPlacement, placement;
@dynamic hasInstallationPlace, installationPlace;
@dynamic hasAppkey, appkey;
@dynamic hasAppeui, appeui;
@dynamic hasProtocolTypeLabel, protocolTypeLabel;
@dynamic hasChannelNumber, channelNumber;
@dynamic hasWireInterface, wireInterface;
@dynamic buildingId;
@dynamic hasManufactureYear, manufactureYear;
@dynamic indicatorVendorType;

typedef struct KEYAPISTELEMETRYCONTROLV1Device__storage_ {
  uint32_t _has_storage_[2];
  int32_t id_p;
  KEYAPISTELEMETRYCONTROLV1Device_Type type;
  int32_t year;
  KEYAPISTELEMETRYCONTROLV1Device_StatusType statusType;
  KEYAPISTELEMETRYCONTROLV1Device_PlanType planType;
  KEYAPISTELEMETRYCONTROLV1Device_PipeType pipeType;
  int32_t buildingId;
  KEYAPISTELEMETRYCONTROLV1Indicator_VendorType indicatorVendorType;
  NSMutableArray *indicatorsArray;
  KEYAPISTELEMETRYCONTROLV1Device_MetricPoint *metricPoint;
  GPBTimestamp *createdAt;
  GPBTimestamp *changedAt;
  NSString *serialNumber;
  NSString *model;
  NSString *fiasId;
  NSString *resourceOwnerId;
  GPBTimestamp *installedAt;
  GPBTimestamp *removedAt;
  GPBTimestamp *checkAt;
  GPBTimestamp *nextCheckAt;
  GPBStringValue *externalId;
  GPBInt32Value *parentId;
  GPBStringValue *devEui;
  GPBStringValue *mac;
  GPBInt32Value *port;
  GPBStringValue *networkAddress;
  GPBStringValue *commChannel;
  GPBStringValue *simNumber;
  GPBStringValue *simSerial;
  GPBStringValue *ipAddressSim;
  GPBStringValue *placement;
  GPBStringValue *installationPlace;
  GPBStringValue *appkey;
  GPBStringValue *appeui;
  GPBStringValue *protocolTypeLabel;
  GPBInt32Value *channelNumber;
  GPBStringValue *wireInterface;
  GPBInt32Value *manufactureYear;
} KEYAPISTELEMETRYCONTROLV1Device__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "indicatorsArray",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Indicator),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_IndicatorsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, indicatorsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "metricPoint",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_MetricPoint,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, metricPoint),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "createdAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_CreatedAt,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, createdAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "changedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_ChangedAt,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, changedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "type",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Device_Type_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_Type,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, type),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "serialNumber",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_SerialNumber,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, serialNumber),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "model",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_Model,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, model),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "year",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_Year,
        .hasIndex = 7,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, year),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "fiasId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_FiasId,
        .hasIndex = 8,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, fiasId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "resourceOwnerId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_ResourceOwnerId,
        .hasIndex = 9,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, resourceOwnerId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "statusType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Device_StatusType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_StatusType,
        .hasIndex = 10,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, statusType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "installedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_InstalledAt,
        .hasIndex = 11,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, installedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "removedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_RemovedAt,
        .hasIndex = 12,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, removedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "checkAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_CheckAt,
        .hasIndex = 13,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, checkAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "nextCheckAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_NextCheckAt,
        .hasIndex = 14,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, nextCheckAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "externalId",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_ExternalId,
        .hasIndex = 15,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, externalId),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "planType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Device_PlanType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_PlanType,
        .hasIndex = 16,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, planType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "parentId",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_ParentId,
        .hasIndex = 17,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, parentId),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "pipeType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Device_PipeType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_PipeType,
        .hasIndex = 18,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, pipeType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "devEui",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_DevEui,
        .hasIndex = 19,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, devEui),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "mac",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_Mac,
        .hasIndex = 20,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, mac),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "port",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_Port,
        .hasIndex = 21,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, port),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "networkAddress",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_NetworkAddress,
        .hasIndex = 22,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, networkAddress),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "commChannel",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_CommChannel,
        .hasIndex = 23,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, commChannel),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "simNumber",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_SimNumber,
        .hasIndex = 24,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, simNumber),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "simSerial",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_SimSerial,
        .hasIndex = 25,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, simSerial),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "ipAddressSim",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_IpAddressSim,
        .hasIndex = 26,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, ipAddressSim),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "placement",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_Placement,
        .hasIndex = 27,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, placement),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "installationPlace",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_InstallationPlace,
        .hasIndex = 28,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, installationPlace),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "appkey",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_Appkey,
        .hasIndex = 29,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, appkey),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "appeui",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_Appeui,
        .hasIndex = 30,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, appeui),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "protocolTypeLabel",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_ProtocolTypeLabel,
        .hasIndex = 31,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, protocolTypeLabel),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "channelNumber",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_ChannelNumber,
        .hasIndex = 32,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, channelNumber),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "wireInterface",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_WireInterface,
        .hasIndex = 33,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, wireInterface),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "buildingId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_BuildingId,
        .hasIndex = 34,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, buildingId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "manufactureYear",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_ManufactureYear,
        .hasIndex = 35,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, manufactureYear),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "indicatorVendorType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Indicator_VendorType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_IndicatorVendorType,
        .hasIndex = 36,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device__storage_, indicatorVendorType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Device)
                                   messageName:@"Device"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1Device__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISTELEMETRYCONTROLV1Device_Type_RawValue(KEYAPISTELEMETRYCONTROLV1Device *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Device descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_Type];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1Device_Type_RawValue(KEYAPISTELEMETRYCONTROLV1Device *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Device descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_Type];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISTELEMETRYCONTROLV1Device_StatusType_RawValue(KEYAPISTELEMETRYCONTROLV1Device *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Device descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_StatusType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1Device_StatusType_RawValue(KEYAPISTELEMETRYCONTROLV1Device *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Device descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_StatusType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISTELEMETRYCONTROLV1Device_PlanType_RawValue(KEYAPISTELEMETRYCONTROLV1Device *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Device descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_PlanType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1Device_PlanType_RawValue(KEYAPISTELEMETRYCONTROLV1Device *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Device descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_PlanType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISTELEMETRYCONTROLV1Device_PipeType_RawValue(KEYAPISTELEMETRYCONTROLV1Device *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Device descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_PipeType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1Device_PipeType_RawValue(KEYAPISTELEMETRYCONTROLV1Device *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Device descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_PipeType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISTELEMETRYCONTROLV1Device_IndicatorVendorType_RawValue(KEYAPISTELEMETRYCONTROLV1Device *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Device descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_IndicatorVendorType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1Device_IndicatorVendorType_RawValue(KEYAPISTELEMETRYCONTROLV1Device *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Device descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Device_FieldNumber_IndicatorVendorType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISTELEMETRYCONTROLV1Device_ValidationError

@implementation KEYAPISTELEMETRYCONTROLV1Device_ValidationError

@dynamic path;
@dynamic message;

typedef struct KEYAPISTELEMETRYCONTROLV1Device_ValidationError__storage_ {
  uint32_t _has_storage_[1];
  NSString *path;
  NSString *message;
} KEYAPISTELEMETRYCONTROLV1Device_ValidationError__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "path",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Device_ValidationError_FieldNumber_Path,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device_ValidationError__storage_, path),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "message",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Device_ValidationError_FieldNumber_Message,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device_ValidationError__storage_, message),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Device_ValidationError)
                                   messageName:@"ValidationError"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1Device_ValidationError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Device)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1Device_MetricPoint

@implementation KEYAPISTELEMETRYCONTROLV1Device_MetricPoint

@dynamic id_p;
@dynamic metricType;
@dynamic roomNumber;
@dynamic roomLabel;
@dynamic hasZoneLabel, zoneLabel;
@dynamic statusType;
@dynamic accountingType;
@dynamic hasCreatedAt, createdAt;
@dynamic primaryCurrentType;
@dynamic secondaryCurrentType;
@dynamic buildingId;
@dynamic hasChangedAt, changedAt;
@dynamic buildingLevel;
@dynamic buildingSection;

typedef struct KEYAPISTELEMETRYCONTROLV1Device_MetricPoint__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType metricType;
  KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_StatusType statusType;
  KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_AccountingType accountingType;
  KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType primaryCurrentType;
  KEYAPISTELEMETRYCONTROLV1Device_SecondaryCurrentType secondaryCurrentType;
  int32_t buildingId;
  int32_t buildingLevel;
  int32_t buildingSection;
  NSString *id_p;
  NSString *roomNumber;
  NSString *roomLabel;
  GPBStringValue *zoneLabel;
  GPBTimestamp *createdAt;
  GPBTimestamp *changedAt;
} KEYAPISTELEMETRYCONTROLV1Device_MetricPoint__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "metricType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_MetricType,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint__storage_, metricType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "roomNumber",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_RoomNumber,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint__storage_, roomNumber),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "roomLabel",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_RoomLabel,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint__storage_, roomLabel),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "zoneLabel",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_ZoneLabel,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint__storage_, zoneLabel),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "statusType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_StatusType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_StatusType,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint__storage_, statusType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "accountingType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_AccountingType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_AccountingType,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint__storage_, accountingType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "createdAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_CreatedAt,
        .hasIndex = 7,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint__storage_, createdAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "primaryCurrentType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_PrimaryCurrentType,
        .hasIndex = 8,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint__storage_, primaryCurrentType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "secondaryCurrentType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Device_SecondaryCurrentType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_SecondaryCurrentType,
        .hasIndex = 9,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint__storage_, secondaryCurrentType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "buildingId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_BuildingId,
        .hasIndex = 10,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint__storage_, buildingId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "changedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_ChangedAt,
        .hasIndex = 11,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint__storage_, changedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "buildingLevel",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_BuildingLevel,
        .hasIndex = 12,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint__storage_, buildingLevel),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "buildingSection",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_BuildingSection,
        .hasIndex = 13,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint__storage_, buildingSection),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint)
                                   messageName:@"MetricPoint"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Device)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType_RawValue(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Device_MetricPoint descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_MetricType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType_RawValue(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Device_MetricPoint descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_MetricType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_StatusType_RawValue(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Device_MetricPoint descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_StatusType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1Device_MetricPoint_StatusType_RawValue(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Device_MetricPoint descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_StatusType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_AccountingType_RawValue(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Device_MetricPoint descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_AccountingType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1Device_MetricPoint_AccountingType_RawValue(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Device_MetricPoint descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_AccountingType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_RawValue(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Device_MetricPoint descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_PrimaryCurrentType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1Device_MetricPoint_PrimaryCurrentType_RawValue(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Device_MetricPoint descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_PrimaryCurrentType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_SecondaryCurrentType_RawValue(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Device_MetricPoint descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_SecondaryCurrentType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1Device_MetricPoint_SecondaryCurrentType_RawValue(KEYAPISTELEMETRYCONTROLV1Device_MetricPoint *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Device_MetricPoint descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_FieldNumber_SecondaryCurrentType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceListRequest

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceListRequest

@dynamic paginationOneOfCase;
@dynamic hasFilter, filter;
@dynamic paging;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceListRequest__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1DeviceFilter *filter;
  KEYAPISTELEMETRYCONTROLV1DevicePaging *paging;
} KEYAPISTELEMETRYCONTROLV1GetDeviceListRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "filter",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceFilter),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceListRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceListRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "paging",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DevicePaging),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceListRequest_FieldNumber_Paging,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceListRequest__storage_, paging),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceListRequest)
                                   messageName:@"GetDeviceListRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceListRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "pagination",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1GetDeviceListRequest_ClearPaginationOneOfCase(KEYAPISTELEMETRYCONTROLV1GetDeviceListRequest *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetDeviceListRequest descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1DevicePaging

@implementation KEYAPISTELEMETRYCONTROLV1DevicePaging

@dynamic orderByType;
@dynamic directionType;
@dynamic limit;
@dynamic offset;

typedef struct KEYAPISTELEMETRYCONTROLV1DevicePaging__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1DevicePaging_OrderByType orderByType;
  KEYAPISTELEMETRYCONTROLV1DevicePaging_DirectionType directionType;
  int32_t limit;
  int32_t offset;
} KEYAPISTELEMETRYCONTROLV1DevicePaging__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "orderByType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1DevicePaging_OrderByType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1DevicePaging_FieldNumber_OrderByType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DevicePaging__storage_, orderByType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "directionType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1DevicePaging_DirectionType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1DevicePaging_FieldNumber_DirectionType,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DevicePaging__storage_, directionType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "limit",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DevicePaging_FieldNumber_Limit,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DevicePaging__storage_, limit),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DevicePaging_FieldNumber_Offset,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DevicePaging__storage_, offset),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DevicePaging)
                                   messageName:@"DevicePaging"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1DevicePaging__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISTELEMETRYCONTROLV1DevicePaging_OrderByType_RawValue(KEYAPISTELEMETRYCONTROLV1DevicePaging *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1DevicePaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1DevicePaging_FieldNumber_OrderByType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1DevicePaging_OrderByType_RawValue(KEYAPISTELEMETRYCONTROLV1DevicePaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1DevicePaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1DevicePaging_FieldNumber_OrderByType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISTELEMETRYCONTROLV1DevicePaging_DirectionType_RawValue(KEYAPISTELEMETRYCONTROLV1DevicePaging *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1DevicePaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1DevicePaging_FieldNumber_DirectionType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1DevicePaging_DirectionType_RawValue(KEYAPISTELEMETRYCONTROLV1DevicePaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1DevicePaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1DevicePaging_FieldNumber_DirectionType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError

@implementation KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError

@dynamic reasonOneOfCase;
@dynamic limit;
@dynamic offset;

typedef struct KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_LimitInvalid *limit;
  KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_OffsetInvalid *offset;
} KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "limit",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_LimitInvalid),
        .number = KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_FieldNumber_Limit,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError__storage_, limit),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_OffsetInvalid),
        .number = KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_FieldNumber_Offset,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError__storage_, offset),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError)
                                   messageName:@"ValidationError"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DevicePaging)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_ClearReasonOneOfCase(KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_LimitInvalid

@implementation KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_LimitInvalid


typedef struct KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_LimitInvalid__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_LimitInvalid__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_LimitInvalid)
                                   messageName:@"LimitInvalid"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_LimitInvalid__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_OffsetInvalid

@implementation KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_OffsetInvalid


typedef struct KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_OffsetInvalid__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_OffsetInvalid__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_OffsetInvalid)
                                   messageName:@"OffsetInvalid"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError_OffsetInvalid__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse

@dynamic typeOneOfCase;
@dynamic data_p;
@dynamic error;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1Device *data_p;
  KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse_Error *error;
} KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Device),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse_Error),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse)
                                   messageName:@"GetDeviceListResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse_ClearTypeOneOfCase(KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse_Error

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse_Error

@dynamic reasonOneOfCase;
@dynamic deviceFilterValidation;
@dynamic devicePagingValidation;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1DeviceFilter_ValidationError *deviceFilterValidation;
  KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError *devicePagingValidation;
} KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "deviceFilterValidation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceFilter_ValidationError),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse_Error_FieldNumber_DeviceFilterValidation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse_Error__storage_, deviceFilterValidation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "devicePagingValidation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DevicePaging_ValidationError),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse_Error_FieldNumber_DevicePagingValidation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse_Error__storage_, devicePagingValidation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse_Error__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse_Error_ClearReasonOneOfCase(KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse_Error *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetDeviceListResponse_Error descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1DeviceFilter

@implementation KEYAPISTELEMETRYCONTROLV1DeviceFilter

@dynamic fiasIdsArray, fiasIdsArray_Count;
@dynamic typesArray, typesArray_Count;
@dynamic statusTypesArray, statusTypesArray_Count;
@dynamic modelsArray, modelsArray_Count;
@dynamic metricPointMetricTypesArray, metricPointMetricTypesArray_Count;
@dynamic roomNumbersArray, roomNumbersArray_Count;
@dynamic roomLabelsArray, roomLabelsArray_Count;
@dynamic parentIdsArray, parentIdsArray_Count;
@dynamic idsArray, idsArray_Count;
@dynamic buildingIdsArray, buildingIdsArray_Count;
@dynamic serialNumbersArray, serialNumbersArray_Count;
@dynamic metricPointIdsArray, metricPointIdsArray_Count;
@dynamic serialIdsArray, serialIdsArray_Count;
@dynamic orponsArray, orponsArray_Count;
@dynamic indicatorVendorTypesArray, indicatorVendorTypesArray_Count;

typedef struct KEYAPISTELEMETRYCONTROLV1DeviceFilter__storage_ {
  uint32_t _has_storage_[1];
  NSMutableArray *fiasIdsArray;
  GPBEnumArray *typesArray;
  GPBEnumArray *statusTypesArray;
  NSMutableArray *modelsArray;
  GPBEnumArray *metricPointMetricTypesArray;
  NSMutableArray *roomNumbersArray;
  NSMutableArray *roomLabelsArray;
  GPBInt32Array *parentIdsArray;
  GPBInt32Array *idsArray;
  GPBInt32Array *buildingIdsArray;
  NSMutableArray *serialNumbersArray;
  NSMutableArray *metricPointIdsArray;
  NSMutableArray *serialIdsArray;
  GPBInt64Array *orponsArray;
  GPBEnumArray *indicatorVendorTypesArray;
} KEYAPISTELEMETRYCONTROLV1DeviceFilter__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "fiasIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceFilter_FieldNumber_FiasIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceFilter__storage_, fiasIdsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "typesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Device_Type_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceFilter_FieldNumber_TypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceFilter__storage_, typesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "statusTypesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Device_StatusType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceFilter_FieldNumber_StatusTypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceFilter__storage_, statusTypesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "modelsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceFilter_FieldNumber_ModelsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceFilter__storage_, modelsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "metricPointMetricTypesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Device_MetricPoint_MetricType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceFilter_FieldNumber_MetricPointMetricTypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceFilter__storage_, metricPointMetricTypesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "roomNumbersArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceFilter_FieldNumber_RoomNumbersArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceFilter__storage_, roomNumbersArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "roomLabelsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceFilter_FieldNumber_RoomLabelsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceFilter__storage_, roomLabelsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "parentIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceFilter_FieldNumber_ParentIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceFilter__storage_, parentIdsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "idsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceFilter_FieldNumber_IdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceFilter__storage_, idsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "buildingIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceFilter_FieldNumber_BuildingIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceFilter__storage_, buildingIdsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "serialNumbersArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceFilter_FieldNumber_SerialNumbersArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceFilter__storage_, serialNumbersArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "metricPointIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceFilter_FieldNumber_MetricPointIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceFilter__storage_, metricPointIdsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "serialIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceFilter_FieldNumber_SerialIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceFilter__storage_, serialIdsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "orponsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceFilter_FieldNumber_OrponsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceFilter__storage_, orponsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt64,
      },
      {
        .name = "indicatorVendorTypesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Indicator_VendorType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceFilter_FieldNumber_IndicatorVendorTypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceFilter__storage_, indicatorVendorTypesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceFilter)
                                   messageName:@"DeviceFilter"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1DeviceFilter__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1DeviceFilter_ValidationError

@implementation KEYAPISTELEMETRYCONTROLV1DeviceFilter_ValidationError

@dynamic path;
@dynamic message;

typedef struct KEYAPISTELEMETRYCONTROLV1DeviceFilter_ValidationError__storage_ {
  uint32_t _has_storage_[1];
  NSString *path;
  NSString *message;
} KEYAPISTELEMETRYCONTROLV1DeviceFilter_ValidationError__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "path",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceFilter_ValidationError_FieldNumber_Path,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceFilter_ValidationError__storage_, path),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "message",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceFilter_ValidationError_FieldNumber_Message,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceFilter_ValidationError__storage_, message),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceFilter_ValidationError)
                                   messageName:@"ValidationError"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1DeviceFilter_ValidationError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceFilter)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceCountRequest

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceCountRequest

@dynamic hasFilter, filter;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceCountRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1DeviceFilter *filter;
} KEYAPISTELEMETRYCONTROLV1GetDeviceCountRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "filter",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceFilter),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceCountRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceCountRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceCountRequest)
                                   messageName:@"GetDeviceCountRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceCountRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse

@dynamic typeOneOfCase;
@dynamic data_p;
@dynamic error;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse__storage_ {
  uint32_t _has_storage_[2];
  int32_t data_p;
  KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse_Error *error;
} KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse_Error),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse)
                                   messageName:@"GetDeviceCountResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse_ClearTypeOneOfCase(KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse_Error

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse_Error

@dynamic reasonOneOfCase;
@dynamic deviceFilterValidation;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1DeviceFilter_ValidationError *deviceFilterValidation;
} KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "deviceFilterValidation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceFilter_ValidationError),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse_Error_FieldNumber_DeviceFilterValidation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse_Error__storage_, deviceFilterValidation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse_Error__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse_Error_ClearReasonOneOfCase(KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse_Error *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetDeviceCountResponse_Error descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListRequest

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListRequest

@dynamic paginationOneOfCase;
@dynamic hasFilter, filter;
@dynamic paging;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListRequest__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointFilter *filter;
  KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging *paging;
} KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "filter",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointFilter),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "paging",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListRequest_FieldNumber_Paging,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListRequest__storage_, paging),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListRequest)
                                   messageName:@"GetDeviceIndicatorMetricPointListRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "pagination",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListRequest_ClearPaginationOneOfCase(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListRequest *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListRequest descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointFilter

@implementation KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointFilter

@dynamic indicatorIdArray, indicatorIdArray_Count;
@dynamic metricPointIdArray, metricPointIdArray_Count;

typedef struct KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointFilter__storage_ {
  uint32_t _has_storage_[1];
  GPBInt32Array *indicatorIdArray;
  NSMutableArray *metricPointIdArray;
} KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointFilter__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "indicatorIdArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointFilter_FieldNumber_IndicatorIdArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointFilter__storage_, indicatorIdArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "metricPointIdArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointFilter_FieldNumber_MetricPointIdArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointFilter__storage_, metricPointIdArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointFilter)
                                   messageName:@"DeviceIndicatorMetricPointFilter"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointFilter__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging

@implementation KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging

@dynamic orderByType;
@dynamic directionType;
@dynamic limit;
@dynamic offset;

typedef struct KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_OrderByType orderByType;
  KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_DirectionType directionType;
  int32_t limit;
  int32_t offset;
} KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "orderByType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_OrderByType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_FieldNumber_OrderByType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging__storage_, orderByType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "directionType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_DirectionType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_FieldNumber_DirectionType,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging__storage_, directionType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "limit",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_FieldNumber_Limit,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging__storage_, limit),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_FieldNumber_Offset,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging__storage_, offset),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging)
                                   messageName:@"DeviceIndicatorMetricPointPaging"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_OrderByType_RawValue(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_FieldNumber_OrderByType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_OrderByType_RawValue(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_FieldNumber_OrderByType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_DirectionType_RawValue(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_FieldNumber_DirectionType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_DirectionType_RawValue(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointPaging_FieldNumber_DirectionType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListResponse

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListResponse

@dynamic typeOneOfCase;
@dynamic data_p;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPoint *data_p;
} KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPoint),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListResponse)
                                   messageName:@"GetDeviceIndicatorMetricPointListResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListResponse_ClearTypeOneOfCase(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointListResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPoint

@implementation KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPoint

@dynamic indicatorId;
@dynamic metricPointId;

typedef struct KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPoint__storage_ {
  uint32_t _has_storage_[1];
  int32_t indicatorId;
  NSString *metricPointId;
} KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPoint__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "indicatorId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPoint_FieldNumber_IndicatorId,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPoint__storage_, indicatorId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "metricPointId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPoint_FieldNumber_MetricPointId,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPoint__storage_, metricPointId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPoint)
                                   messageName:@"DeviceIndicatorMetricPoint"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPoint__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountRequest

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountRequest

@dynamic hasFilter, filter;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointFilter *filter;
} KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "filter",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPointFilter),
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountRequest)
                                   messageName:@"GetDeviceIndicatorMetricPointCountRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountResponse

@implementation KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountResponse

@dynamic typeOneOfCase;
@dynamic data_p;

typedef struct KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountResponse__storage_ {
  uint32_t _has_storage_[2];
  int32_t data_p;
} KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountResponse)
                                   messageName:@"GetDeviceIndicatorMetricPointCountResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "type",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountResponse_ClearTypeOneOfCase(KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetDeviceIndicatorMetricPointCountResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointAttachRequest

@implementation KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointAttachRequest

@dynamic hasDeviceIndicatorMetricPoint, deviceIndicatorMetricPoint;

typedef struct KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointAttachRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPoint *deviceIndicatorMetricPoint;
} KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointAttachRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "deviceIndicatorMetricPoint",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPoint),
        .number = KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointAttachRequest_FieldNumber_DeviceIndicatorMetricPoint,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointAttachRequest__storage_, deviceIndicatorMetricPoint),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointAttachRequest)
                                   messageName:@"PutDeviceIndicatorMetricPointAttachRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointAttachRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointAttachResponse

@implementation KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointAttachResponse


typedef struct KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointAttachResponse__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointAttachResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointAttachResponse)
                                   messageName:@"PutDeviceIndicatorMetricPointAttachResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointAttachResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointDetachRequest

@implementation KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointDetachRequest

@dynamic hasDeviceIndicatorMetricPoint, deviceIndicatorMetricPoint;

typedef struct KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointDetachRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPoint *deviceIndicatorMetricPoint;
} KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointDetachRequest__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "deviceIndicatorMetricPoint",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeviceIndicatorMetricPoint),
        .number = KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointDetachRequest_FieldNumber_DeviceIndicatorMetricPoint,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointDetachRequest__storage_, deviceIndicatorMetricPoint),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointDetachRequest)
                                   messageName:@"PutDeviceIndicatorMetricPointDetachRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointDetachRequest__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointDetachResponse

@implementation KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointDetachResponse


typedef struct KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointDetachResponse__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointDetachResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointDetachResponse)
                                   messageName:@"PutDeviceIndicatorMetricPointDetachResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlDeviceV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PutDeviceIndicatorMetricPointDetachResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end


#pragma clang diagnostic pop

// @@protoc_insertion_point(global_scope)

// clang-format on
