// Generated by the protocol buffer compiler.  DO NOT EDIT!
// clang-format off
// source: keyapis/telemetry_control/v1/keyapis_telemetry_control_building_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/KeyapisTelemetryControlBuildingV1.pbobjc.h"
#import "google/api/Annotations.pbobjc.h"
#import "google/api/FieldBehavior.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(GPBStringValue);
GPBObjCClassDeclaration(GPBTimestamp);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1Building);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1BuildingFilter);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1BuildingGroup);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1BuildingGroupFilter);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1BuildingPaging);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1DeleteBuildingRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1DeleteBuildingResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetBuildingCountRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetBuildingCountResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetBuildingListRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetBuildingListResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetBuildingRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1GetBuildingResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Error);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Error_UnknownError);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Success);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_RemoveBuildingEvent);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_UpsertBuildingEvent);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostBuildingRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PostBuildingResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PutBuildingGroupAttachRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PutBuildingGroupAttachResponse);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PutBuildingGroupDetachRequest);
GPBObjCClassDeclaration(KEYAPISTELEMETRYCONTROLV1PutBuildingGroupDetachResponse);

#pragma mark - KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root

@implementation KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root

+ (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]];
  }
  return registry;
}

@end

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

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_OrderByType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_OrderByType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "OrderByTypeUnknown\000GroupId\000BuildingId\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_OrderByType_OrderByTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_OrderByType_GroupId,
        KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_OrderByType_BuildingId,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_OrderByType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_OrderByType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_OrderByType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_OrderByType_OrderByTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_OrderByType_GroupId:
    case KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_OrderByType_BuildingId:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_DirectionType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_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[] = {
        KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_DirectionType_DirectionTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_DirectionType_Desc,
        KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_DirectionType_Asc,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_DirectionType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_DirectionType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_DirectionType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_DirectionType_DirectionTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_DirectionType_Desc:
    case KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_DirectionType_Asc:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "OrderByTypeUnknown\000Id\000Title\000CreatedAt\000Ch"
        "angedAt\000FiasId\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType_OrderByTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType_Id,
        KEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType_Title,
        KEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType_CreatedAt,
        KEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType_ChangedAt,
        KEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType_FiasId,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType_OrderByTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType_Id:
    case KEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType_Title:
    case KEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType_CreatedAt:
    case KEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType_ChangedAt:
    case KEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType_FiasId:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1BuildingPaging_DirectionType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1BuildingPaging_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[] = {
        KEYAPISTELEMETRYCONTROLV1BuildingPaging_DirectionType_DirectionTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1BuildingPaging_DirectionType_Desc,
        KEYAPISTELEMETRYCONTROLV1BuildingPaging_DirectionType_Asc,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1BuildingPaging_DirectionType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1BuildingPaging_DirectionType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1BuildingPaging_DirectionType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1BuildingPaging_DirectionType_DirectionTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1BuildingPaging_DirectionType_Desc:
    case KEYAPISTELEMETRYCONTROLV1BuildingPaging_DirectionType_Asc:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1Building_MrfType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1Building_MrfType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "MrfTypeUnknown\000Tsentr\000Yug\000Ural\000Sibir\000Sev"
        "eroZapad\000DalniyVostok\000Volga\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1Building_MrfType_MrfTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1Building_MrfType_Tsentr,
        KEYAPISTELEMETRYCONTROLV1Building_MrfType_Yug,
        KEYAPISTELEMETRYCONTROLV1Building_MrfType_Ural,
        KEYAPISTELEMETRYCONTROLV1Building_MrfType_Sibir,
        KEYAPISTELEMETRYCONTROLV1Building_MrfType_SeveroZapad,
        KEYAPISTELEMETRYCONTROLV1Building_MrfType_DalniyVostok,
        KEYAPISTELEMETRYCONTROLV1Building_MrfType_Volga,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1Building_MrfType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1Building_MrfType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1Building_MrfType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1Building_MrfType_MrfTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1Building_MrfType_Tsentr:
    case KEYAPISTELEMETRYCONTROLV1Building_MrfType_Yug:
    case KEYAPISTELEMETRYCONTROLV1Building_MrfType_Ural:
    case KEYAPISTELEMETRYCONTROLV1Building_MrfType_Sibir:
    case KEYAPISTELEMETRYCONTROLV1Building_MrfType_SeveroZapad:
    case KEYAPISTELEMETRYCONTROLV1Building_MrfType_DalniyVostok:
    case KEYAPISTELEMETRYCONTROLV1Building_MrfType_Volga:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1Building_RfType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1Building_RfType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "RfTypeUnknown\000Ufa\000Kirov\000Ivanovo\000Kaluga\000K"
        "ostroma\000Kursk\000Lipetsk\000Mosoblast\000Orel\000Rya"
        "zan\000Tambov\000Tver\000Yaroslavl\000Smolensk\000Tula\000"
        "Moscow\000Eao\000Kurgan\000Tumen\000Hanty\000Amur\000Kamch"
        "atka\000Magadan\000Primorye\000Sakhalin\000Khabarovs"
        "k\000Chita\000Chukotka\000Archangelsk\000Vologda\000Kal"
        "iningrad\000Karelia\000Komi\000Lenoblast\000Murmansk"
        "\000Novgorod\000Pskov\000Spb\000Altai\000Buryatiya\000Irku"
        "tsk\000Kemerovo\000Krasnoyarsk\000Omsk\000Hakasiya\000R"
        "altay\000Tuva\000Tomsk\000Orenburg\000Belgorod\000Sakha"
        "\000Ekt\000Volgograd\000Yamal\000Chelyabinsk\000Perm\000Ma"
        "ryel\000Penza\000Ingushetia\000Nalchik\000Elista\000Ros"
        "tov\000Mahachkala\000Mordoviya\000Kazan\000Samara\000Sa"
        "ratov\000Udmurtiya\000Ulyanovsk\000Chuvashiya\000Nno"
        "vgorod\000Bryansk\000Vladimir\000Voronezh\000Vladika"
        "vkaz\000Stavropol\000Cherkessk\000Maykop\000Astrakha"
        "n\000Krasnodar\000Test\000Novosibirsk\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1Building_RfType_RfTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Ufa,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Kirov,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Ivanovo,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Kaluga,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Kostroma,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Kursk,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Lipetsk,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Mosoblast,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Orel,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Ryazan,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Tambov,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Tver,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Yaroslavl,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Smolensk,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Tula,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Moscow,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Eao,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Kurgan,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Tumen,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Hanty,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Amur,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Kamchatka,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Magadan,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Primorye,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Sakhalin,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Khabarovsk,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Chita,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Chukotka,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Archangelsk,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Vologda,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Kaliningrad,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Karelia,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Komi,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Lenoblast,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Murmansk,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Novgorod,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Pskov,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Spb,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Altai,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Buryatiya,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Irkutsk,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Kemerovo,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Krasnoyarsk,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Omsk,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Hakasiya,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Raltay,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Tuva,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Tomsk,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Orenburg,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Belgorod,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Sakha,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Ekt,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Volgograd,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Yamal,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Chelyabinsk,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Perm,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Maryel,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Penza,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Ingushetia,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Nalchik,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Elista,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Rostov,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Mahachkala,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Mordoviya,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Kazan,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Samara,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Saratov,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Udmurtiya,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Ulyanovsk,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Chuvashiya,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Nnovgorod,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Bryansk,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Vladimir,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Voronezh,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Vladikavkaz,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Stavropol,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Cherkessk,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Maykop,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Astrakhan,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Krasnodar,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Test,
        KEYAPISTELEMETRYCONTROLV1Building_RfType_Novosibirsk,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1Building_RfType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1Building_RfType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1Building_RfType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_RfTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Ufa:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Kirov:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Ivanovo:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Kaluga:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Kostroma:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Kursk:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Lipetsk:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Mosoblast:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Orel:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Ryazan:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Tambov:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Tver:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Yaroslavl:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Smolensk:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Tula:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Moscow:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Eao:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Kurgan:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Tumen:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Hanty:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Amur:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Kamchatka:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Magadan:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Primorye:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Sakhalin:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Khabarovsk:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Chita:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Chukotka:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Archangelsk:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Vologda:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Kaliningrad:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Karelia:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Komi:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Lenoblast:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Murmansk:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Novgorod:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Pskov:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Spb:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Altai:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Buryatiya:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Irkutsk:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Kemerovo:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Krasnoyarsk:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Omsk:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Hakasiya:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Raltay:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Tuva:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Tomsk:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Orenburg:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Belgorod:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Sakha:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Ekt:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Volgograd:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Yamal:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Chelyabinsk:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Perm:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Maryel:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Penza:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Ingushetia:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Nalchik:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Elista:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Rostov:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Mahachkala:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Mordoviya:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Kazan:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Samara:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Saratov:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Udmurtiya:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Ulyanovsk:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Chuvashiya:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Nnovgorod:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Bryansk:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Vladimir:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Voronezh:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Vladikavkaz:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Stavropol:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Cherkessk:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Maykop:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Astrakhan:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Krasnodar:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Test:
    case KEYAPISTELEMETRYCONTROLV1Building_RfType_Novosibirsk:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISTELEMETRYCONTROLV1Building_StatusType

GPBEnumDescriptor *KEYAPISTELEMETRYCONTROLV1Building_StatusType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "StatusTypeUnknown\000Building\000Acceptance\000Ac"
        "tive\000Archive\000Cancelled\000TestStatusType\000";
    static const int32_t values[] = {
        KEYAPISTELEMETRYCONTROLV1Building_StatusType_StatusTypeUnknown,
        KEYAPISTELEMETRYCONTROLV1Building_StatusType_Building,
        KEYAPISTELEMETRYCONTROLV1Building_StatusType_Acceptance,
        KEYAPISTELEMETRYCONTROLV1Building_StatusType_Active,
        KEYAPISTELEMETRYCONTROLV1Building_StatusType_Archive,
        KEYAPISTELEMETRYCONTROLV1Building_StatusType_Cancelled,
        KEYAPISTELEMETRYCONTROLV1Building_StatusType_TestStatusType,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISTELEMETRYCONTROLV1Building_StatusType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISTELEMETRYCONTROLV1Building_StatusType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISTELEMETRYCONTROLV1Building_StatusType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISTELEMETRYCONTROLV1Building_StatusType_StatusTypeUnknown:
    case KEYAPISTELEMETRYCONTROLV1Building_StatusType_Building:
    case KEYAPISTELEMETRYCONTROLV1Building_StatusType_Acceptance:
    case KEYAPISTELEMETRYCONTROLV1Building_StatusType_Active:
    case KEYAPISTELEMETRYCONTROLV1Building_StatusType_Archive:
    case KEYAPISTELEMETRYCONTROLV1Building_StatusType_Cancelled:
    case KEYAPISTELEMETRYCONTROLV1Building_StatusType_TestStatusType:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - KEYAPISTELEMETRYCONTROLV1PostBuildingRequest

@implementation KEYAPISTELEMETRYCONTROLV1PostBuildingRequest

@dynamic hasData_p, data_p;

typedef struct KEYAPISTELEMETRYCONTROLV1PostBuildingRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1Building *data_p;
} KEYAPISTELEMETRYCONTROLV1PostBuildingRequest__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(KEYAPISTELEMETRYCONTROLV1Building),
        .number = KEYAPISTELEMETRYCONTROLV1PostBuildingRequest_FieldNumber_Data_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostBuildingRequest__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostBuildingRequest)
                                   messageName:@"PostBuildingRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostBuildingRequest__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 - KEYAPISTELEMETRYCONTROLV1PutBuildingGroupAttachRequest

@implementation KEYAPISTELEMETRYCONTROLV1PutBuildingGroupAttachRequest

@dynamic hasBuildingGroup, buildingGroup;

typedef struct KEYAPISTELEMETRYCONTROLV1PutBuildingGroupAttachRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1BuildingGroup *buildingGroup;
} KEYAPISTELEMETRYCONTROLV1PutBuildingGroupAttachRequest__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 = "buildingGroup",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1BuildingGroup),
        .number = KEYAPISTELEMETRYCONTROLV1PutBuildingGroupAttachRequest_FieldNumber_BuildingGroup,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PutBuildingGroupAttachRequest__storage_, buildingGroup),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PutBuildingGroupAttachRequest)
                                   messageName:@"PutBuildingGroupAttachRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PutBuildingGroupAttachRequest__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 - KEYAPISTELEMETRYCONTROLV1PostBuildingResponse

@implementation KEYAPISTELEMETRYCONTROLV1PostBuildingResponse

@dynamic typeOneOfCase;
@dynamic data_p;

typedef struct KEYAPISTELEMETRYCONTROLV1PostBuildingResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1Building *data_p;
} KEYAPISTELEMETRYCONTROLV1PostBuildingResponse__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(KEYAPISTELEMETRYCONTROLV1Building),
        .number = KEYAPISTELEMETRYCONTROLV1PostBuildingResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostBuildingResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostBuildingResponse)
                                   messageName:@"PostBuildingResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostBuildingResponse__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 KEYAPISTELEMETRYCONTROLV1PostBuildingResponse_ClearTypeOneOfCase(KEYAPISTELEMETRYCONTROLV1PostBuildingResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1PostBuildingResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1PutBuildingGroupAttachResponse

@implementation KEYAPISTELEMETRYCONTROLV1PutBuildingGroupAttachResponse


typedef struct KEYAPISTELEMETRYCONTROLV1PutBuildingGroupAttachResponse__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1PutBuildingGroupAttachResponse__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(KEYAPISTELEMETRYCONTROLV1PutBuildingGroupAttachResponse)
                                   messageName:@"PutBuildingGroupAttachResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PutBuildingGroupAttachResponse__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 - KEYAPISTELEMETRYCONTROLV1GetBuildingRequest

@implementation KEYAPISTELEMETRYCONTROLV1GetBuildingRequest

@dynamic id_p;

typedef struct KEYAPISTELEMETRYCONTROLV1GetBuildingRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
} KEYAPISTELEMETRYCONTROLV1GetBuildingRequest__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 = KEYAPISTELEMETRYCONTROLV1GetBuildingRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetBuildingRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetBuildingRequest)
                                   messageName:@"GetBuildingRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetBuildingRequest__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 - KEYAPISTELEMETRYCONTROLV1GetBuildingResponse

@implementation KEYAPISTELEMETRYCONTROLV1GetBuildingResponse

@dynamic typeOneOfCase;
@dynamic data_p;

typedef struct KEYAPISTELEMETRYCONTROLV1GetBuildingResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1Building *data_p;
} KEYAPISTELEMETRYCONTROLV1GetBuildingResponse__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(KEYAPISTELEMETRYCONTROLV1Building),
        .number = KEYAPISTELEMETRYCONTROLV1GetBuildingResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetBuildingResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetBuildingResponse)
                                   messageName:@"GetBuildingResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetBuildingResponse__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 KEYAPISTELEMETRYCONTROLV1GetBuildingResponse_ClearTypeOneOfCase(KEYAPISTELEMETRYCONTROLV1GetBuildingResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetBuildingResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1GetBuildingListRequest

@implementation KEYAPISTELEMETRYCONTROLV1GetBuildingListRequest

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

typedef struct KEYAPISTELEMETRYCONTROLV1GetBuildingListRequest__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1BuildingFilter *filter;
  KEYAPISTELEMETRYCONTROLV1BuildingPaging *paging;
} KEYAPISTELEMETRYCONTROLV1GetBuildingListRequest__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(KEYAPISTELEMETRYCONTROLV1BuildingFilter),
        .number = KEYAPISTELEMETRYCONTROLV1GetBuildingListRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetBuildingListRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "paging",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1BuildingPaging),
        .number = KEYAPISTELEMETRYCONTROLV1GetBuildingListRequest_FieldNumber_Paging,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetBuildingListRequest__storage_, paging),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetBuildingListRequest)
                                   messageName:@"GetBuildingListRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetBuildingListRequest__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 KEYAPISTELEMETRYCONTROLV1GetBuildingListRequest_ClearPaginationOneOfCase(KEYAPISTELEMETRYCONTROLV1GetBuildingListRequest *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetBuildingListRequest descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListRequest

@implementation KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListRequest

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

typedef struct KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListRequest__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1BuildingGroupFilter *filter;
  KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging *paging;
} KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListRequest__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(KEYAPISTELEMETRYCONTROLV1BuildingGroupFilter),
        .number = KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "paging",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging),
        .number = KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListRequest_FieldNumber_Paging,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListRequest__storage_, paging),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListRequest)
                                   messageName:@"GetBuildingGroupListRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListRequest__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 KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListRequest_ClearPaginationOneOfCase(KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListRequest *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListRequest descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging

@implementation KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging

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

typedef struct KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_OrderByType orderByType;
  KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_DirectionType directionType;
  int32_t limit;
  int32_t offset;
} KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging__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 = KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_OrderByType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_FieldNumber_OrderByType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging__storage_, orderByType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "directionType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_DirectionType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_FieldNumber_DirectionType,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging__storage_, directionType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "limit",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_FieldNumber_Limit,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging__storage_, limit),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_FieldNumber_Offset,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging__storage_, offset),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging)
                                   messageName:@"BuildingGroupPaging"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging__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 KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_OrderByType_RawValue(KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_FieldNumber_OrderByType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_OrderByType_RawValue(KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_FieldNumber_OrderByType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_DirectionType_RawValue(KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_FieldNumber_DirectionType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_DirectionType_RawValue(KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1BuildingGroupPaging_FieldNumber_DirectionType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISTELEMETRYCONTROLV1BuildingPaging

@implementation KEYAPISTELEMETRYCONTROLV1BuildingPaging

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

typedef struct KEYAPISTELEMETRYCONTROLV1BuildingPaging__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType orderByType;
  KEYAPISTELEMETRYCONTROLV1BuildingPaging_DirectionType directionType;
  int32_t limit;
  int32_t offset;
} KEYAPISTELEMETRYCONTROLV1BuildingPaging__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 = KEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1BuildingPaging_FieldNumber_OrderByType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1BuildingPaging__storage_, orderByType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "directionType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1BuildingPaging_DirectionType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1BuildingPaging_FieldNumber_DirectionType,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1BuildingPaging__storage_, directionType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "limit",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1BuildingPaging_FieldNumber_Limit,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1BuildingPaging__storage_, limit),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1BuildingPaging_FieldNumber_Offset,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1BuildingPaging__storage_, offset),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1BuildingPaging)
                                   messageName:@"BuildingPaging"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1BuildingPaging__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 KEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType_RawValue(KEYAPISTELEMETRYCONTROLV1BuildingPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1BuildingPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1BuildingPaging_FieldNumber_OrderByType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1BuildingPaging_OrderByType_RawValue(KEYAPISTELEMETRYCONTROLV1BuildingPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1BuildingPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1BuildingPaging_FieldNumber_OrderByType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISTELEMETRYCONTROLV1BuildingPaging_DirectionType_RawValue(KEYAPISTELEMETRYCONTROLV1BuildingPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1BuildingPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1BuildingPaging_FieldNumber_DirectionType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1BuildingPaging_DirectionType_RawValue(KEYAPISTELEMETRYCONTROLV1BuildingPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1BuildingPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1BuildingPaging_FieldNumber_DirectionType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISTELEMETRYCONTROLV1GetBuildingListResponse

@implementation KEYAPISTELEMETRYCONTROLV1GetBuildingListResponse

@dynamic typeOneOfCase;
@dynamic data_p;

typedef struct KEYAPISTELEMETRYCONTROLV1GetBuildingListResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1Building *data_p;
} KEYAPISTELEMETRYCONTROLV1GetBuildingListResponse__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(KEYAPISTELEMETRYCONTROLV1Building),
        .number = KEYAPISTELEMETRYCONTROLV1GetBuildingListResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetBuildingListResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetBuildingListResponse)
                                   messageName:@"GetBuildingListResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetBuildingListResponse__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 KEYAPISTELEMETRYCONTROLV1GetBuildingListResponse_ClearTypeOneOfCase(KEYAPISTELEMETRYCONTROLV1GetBuildingListResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetBuildingListResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListResponse

@implementation KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListResponse

@dynamic typeOneOfCase;
@dynamic data_p;

typedef struct KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1BuildingGroup *data_p;
} KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListResponse__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(KEYAPISTELEMETRYCONTROLV1BuildingGroup),
        .number = KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListResponse)
                                   messageName:@"GetBuildingGroupListResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListResponse__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 KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListResponse_ClearTypeOneOfCase(KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetBuildingGroupListResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse

@implementation KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse

@dynamic eventOneOfCase;
@dynamic requestId;
@dynamic upsertBuildingEvent;
@dynamic removeBuildingEvent;

typedef struct KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse__storage_ {
  uint32_t _has_storage_[2];
  NSString *requestId;
  KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_UpsertBuildingEvent *upsertBuildingEvent;
  KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_RemoveBuildingEvent *removeBuildingEvent;
} KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse__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 = KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_FieldNumber_RequestId,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse__storage_, requestId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "upsertBuildingEvent",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_UpsertBuildingEvent),
        .number = KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_FieldNumber_UpsertBuildingEvent,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse__storage_, upsertBuildingEvent),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "removeBuildingEvent",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_RemoveBuildingEvent),
        .number = KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_FieldNumber_RemoveBuildingEvent,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse__storage_, removeBuildingEvent),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse)
                                   messageName:@"PostBuildingFullDuplexResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse__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 KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_ClearEventOneOfCase(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_RemoveBuildingEvent

@implementation KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_RemoveBuildingEvent

@dynamic id_p;

typedef struct KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_RemoveBuildingEvent__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
} KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_RemoveBuildingEvent__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 = KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_RemoveBuildingEvent_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_RemoveBuildingEvent__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_RemoveBuildingEvent)
                                   messageName:@"RemoveBuildingEvent"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_RemoveBuildingEvent__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_UpsertBuildingEvent

@implementation KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_UpsertBuildingEvent

@dynamic hasData_p, data_p;

typedef struct KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_UpsertBuildingEvent__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1Building *data_p;
} KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_UpsertBuildingEvent__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(KEYAPISTELEMETRYCONTROLV1Building),
        .number = KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_UpsertBuildingEvent_FieldNumber_Data_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_UpsertBuildingEvent__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_UpsertBuildingEvent)
                                   messageName:@"UpsertBuildingEvent"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse_UpsertBuildingEvent__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest

@implementation KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest

@dynamic taskOneOfCase;
@dynamic requestId;
@dynamic buildingAsyncStatus;

typedef struct KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest__storage_ {
  uint32_t _has_storage_[2];
  NSString *requestId;
  KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus *buildingAsyncStatus;
} KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest__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 = KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_FieldNumber_RequestId,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest__storage_, requestId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "buildingAsyncStatus",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus),
        .number = KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_FieldNumber_BuildingAsyncStatus,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest__storage_, buildingAsyncStatus),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest)
                                   messageName:@"PostBuildingFullDuplexRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest__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 KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_ClearTaskOneOfCase(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus

@implementation KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus

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

typedef struct KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus__storage_ {
  uint32_t _has_storage_[2];
  int32_t buildingId;
  KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Success *data_p;
  KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Error *error;
} KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus__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 = "buildingId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_FieldNumber_BuildingId,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus__storage_, buildingId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "data_p",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Success),
        .number = KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Error),
        .number = KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus)
                                   messageName:@"BuildingAsyncStatus"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus__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(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Success


typedef struct KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Success__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_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(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Success)
                                   messageName:@"Success"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Success__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Error

@implementation KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Error

@dynamic reasonOneOfCase;
@dynamic unknown;

typedef struct KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Error_UnknownError *unknown;
} KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_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 = "unknown",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Error_UnknownError),
        .number = KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Error_FieldNumber_Unknown,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Error__storage_, unknown),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_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(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Error_UnknownError

@dynamic message;

typedef struct KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Error_UnknownError__storage_ {
  uint32_t _has_storage_[1];
  NSString *message;
} KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_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 = KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Error_UnknownError_FieldNumber_Message,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Error_UnknownError__storage_, message),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Error_UnknownError)
                                   messageName:@"UnknownError"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Error_UnknownError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PostBuildingFullDuplexRequest_BuildingAsyncStatus_Error)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISTELEMETRYCONTROLV1BuildingFilter

@implementation KEYAPISTELEMETRYCONTROLV1BuildingFilter

@dynamic fiasIdArray, fiasIdArray_Count;
@dynamic hasTitle, title;
@dynamic hasAfterCreatedAt, afterCreatedAt;
@dynamic hasBeforeCreatedAt, beforeCreatedAt;
@dynamic mrfTypesArray, mrfTypesArray_Count;
@dynamic rfTypesArray, rfTypesArray_Count;
@dynamic statusTypesArray, statusTypesArray_Count;
@dynamic orponsArray, orponsArray_Count;

typedef struct KEYAPISTELEMETRYCONTROLV1BuildingFilter__storage_ {
  uint32_t _has_storage_[1];
  NSMutableArray *fiasIdArray;
  GPBStringValue *title;
  GPBTimestamp *afterCreatedAt;
  GPBTimestamp *beforeCreatedAt;
  GPBEnumArray *mrfTypesArray;
  GPBEnumArray *rfTypesArray;
  GPBEnumArray *statusTypesArray;
  GPBInt64Array *orponsArray;
} KEYAPISTELEMETRYCONTROLV1BuildingFilter__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 = "fiasIdArray",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISTELEMETRYCONTROLV1BuildingFilter_FieldNumber_FiasIdArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1BuildingFilter__storage_, fiasIdArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "title",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISTELEMETRYCONTROLV1BuildingFilter_FieldNumber_Title,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1BuildingFilter__storage_, title),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "afterCreatedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISTELEMETRYCONTROLV1BuildingFilter_FieldNumber_AfterCreatedAt,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1BuildingFilter__storage_, afterCreatedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "beforeCreatedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISTELEMETRYCONTROLV1BuildingFilter_FieldNumber_BeforeCreatedAt,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1BuildingFilter__storage_, beforeCreatedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "mrfTypesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Building_MrfType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1BuildingFilter_FieldNumber_MrfTypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1BuildingFilter__storage_, mrfTypesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "rfTypesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Building_RfType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1BuildingFilter_FieldNumber_RfTypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1BuildingFilter__storage_, rfTypesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "statusTypesArray",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Building_StatusType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1BuildingFilter_FieldNumber_StatusTypesArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1BuildingFilter__storage_, statusTypesArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked | GPBFieldHasEnumDescriptor),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "orponsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1BuildingFilter_FieldNumber_OrponsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1BuildingFilter__storage_, orponsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt64,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1BuildingFilter)
                                   messageName:@"BuildingFilter"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1BuildingFilter__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 - KEYAPISTELEMETRYCONTROLV1BuildingGroupFilter

@implementation KEYAPISTELEMETRYCONTROLV1BuildingGroupFilter

@dynamic groupIdsArray, groupIdsArray_Count;
@dynamic buildingIdsArray, buildingIdsArray_Count;

typedef struct KEYAPISTELEMETRYCONTROLV1BuildingGroupFilter__storage_ {
  uint32_t _has_storage_[1];
  NSMutableArray *groupIdsArray;
  GPBInt32Array *buildingIdsArray;
} KEYAPISTELEMETRYCONTROLV1BuildingGroupFilter__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 = KEYAPISTELEMETRYCONTROLV1BuildingGroupFilter_FieldNumber_GroupIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1BuildingGroupFilter__storage_, groupIdsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "buildingIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1BuildingGroupFilter_FieldNumber_BuildingIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1BuildingGroupFilter__storage_, buildingIdsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1BuildingGroupFilter)
                                   messageName:@"BuildingGroupFilter"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1BuildingGroupFilter__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 - KEYAPISTELEMETRYCONTROLV1GetBuildingCountRequest

@implementation KEYAPISTELEMETRYCONTROLV1GetBuildingCountRequest

@dynamic hasFilter, filter;

typedef struct KEYAPISTELEMETRYCONTROLV1GetBuildingCountRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1BuildingFilter *filter;
} KEYAPISTELEMETRYCONTROLV1GetBuildingCountRequest__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(KEYAPISTELEMETRYCONTROLV1BuildingFilter),
        .number = KEYAPISTELEMETRYCONTROLV1GetBuildingCountRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetBuildingCountRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetBuildingCountRequest)
                                   messageName:@"GetBuildingCountRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetBuildingCountRequest__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 - KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountRequest

@implementation KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountRequest

@dynamic hasFilter, filter;

typedef struct KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1BuildingGroupFilter *filter;
} KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountRequest__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(KEYAPISTELEMETRYCONTROLV1BuildingGroupFilter),
        .number = KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountRequest)
                                   messageName:@"GetBuildingGroupCountRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountRequest__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 - KEYAPISTELEMETRYCONTROLV1GetBuildingCountResponse

@implementation KEYAPISTELEMETRYCONTROLV1GetBuildingCountResponse

@dynamic typeOneOfCase;
@dynamic data_p;

typedef struct KEYAPISTELEMETRYCONTROLV1GetBuildingCountResponse__storage_ {
  uint32_t _has_storage_[2];
  int32_t data_p;
} KEYAPISTELEMETRYCONTROLV1GetBuildingCountResponse__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 = KEYAPISTELEMETRYCONTROLV1GetBuildingCountResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetBuildingCountResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetBuildingCountResponse)
                                   messageName:@"GetBuildingCountResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetBuildingCountResponse__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 KEYAPISTELEMETRYCONTROLV1GetBuildingCountResponse_ClearTypeOneOfCase(KEYAPISTELEMETRYCONTROLV1GetBuildingCountResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetBuildingCountResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountResponse

@implementation KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountResponse

@dynamic typeOneOfCase;
@dynamic data_p;

typedef struct KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountResponse__storage_ {
  uint32_t _has_storage_[2];
  int32_t data_p;
} KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountResponse__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 = KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountResponse)
                                   messageName:@"GetBuildingGroupCountResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountResponse__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 KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountResponse_ClearTypeOneOfCase(KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1GetBuildingGroupCountResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISTELEMETRYCONTROLV1DeleteBuildingRequest

@implementation KEYAPISTELEMETRYCONTROLV1DeleteBuildingRequest

@dynamic id_p;

typedef struct KEYAPISTELEMETRYCONTROLV1DeleteBuildingRequest__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
} KEYAPISTELEMETRYCONTROLV1DeleteBuildingRequest__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 = KEYAPISTELEMETRYCONTROLV1DeleteBuildingRequest_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1DeleteBuildingRequest__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1DeleteBuildingRequest)
                                   messageName:@"DeleteBuildingRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1DeleteBuildingRequest__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 - KEYAPISTELEMETRYCONTROLV1DeleteBuildingResponse

@implementation KEYAPISTELEMETRYCONTROLV1DeleteBuildingResponse


typedef struct KEYAPISTELEMETRYCONTROLV1DeleteBuildingResponse__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1DeleteBuildingResponse__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(KEYAPISTELEMETRYCONTROLV1DeleteBuildingResponse)
                                   messageName:@"DeleteBuildingResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1DeleteBuildingResponse__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 - KEYAPISTELEMETRYCONTROLV1PutBuildingGroupDetachRequest

@implementation KEYAPISTELEMETRYCONTROLV1PutBuildingGroupDetachRequest

@dynamic hasBuildingGroup, buildingGroup;

typedef struct KEYAPISTELEMETRYCONTROLV1PutBuildingGroupDetachRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISTELEMETRYCONTROLV1BuildingGroup *buildingGroup;
} KEYAPISTELEMETRYCONTROLV1PutBuildingGroupDetachRequest__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 = "buildingGroup",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISTELEMETRYCONTROLV1BuildingGroup),
        .number = KEYAPISTELEMETRYCONTROLV1PutBuildingGroupDetachRequest_FieldNumber_BuildingGroup,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1PutBuildingGroupDetachRequest__storage_, buildingGroup),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1PutBuildingGroupDetachRequest)
                                   messageName:@"PutBuildingGroupDetachRequest"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PutBuildingGroupDetachRequest__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 - KEYAPISTELEMETRYCONTROLV1PutBuildingGroupDetachResponse

@implementation KEYAPISTELEMETRYCONTROLV1PutBuildingGroupDetachResponse


typedef struct KEYAPISTELEMETRYCONTROLV1PutBuildingGroupDetachResponse__storage_ {
  uint32_t _has_storage_[1];
} KEYAPISTELEMETRYCONTROLV1PutBuildingGroupDetachResponse__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(KEYAPISTELEMETRYCONTROLV1PutBuildingGroupDetachResponse)
                                   messageName:@"PutBuildingGroupDetachResponse"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:NULL
                                    fieldCount:0
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1PutBuildingGroupDetachResponse__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 - KEYAPISTELEMETRYCONTROLV1Building

@implementation KEYAPISTELEMETRYCONTROLV1Building

@dynamic id_p;
@dynamic title;
@dynamic hasCreatedAt, createdAt;
@dynamic hasChangedAt, changedAt;
@dynamic utcOffset;
@dynamic hasFiasId, fiasId;
@dynamic mrfType;
@dynamic rfType;
@dynamic statusType;
@dynamic fullAddress;
@dynamic orpon;

typedef struct KEYAPISTELEMETRYCONTROLV1Building__storage_ {
  uint32_t _has_storage_[1];
  int32_t id_p;
  int32_t utcOffset;
  KEYAPISTELEMETRYCONTROLV1Building_MrfType mrfType;
  KEYAPISTELEMETRYCONTROLV1Building_RfType rfType;
  KEYAPISTELEMETRYCONTROLV1Building_StatusType statusType;
  NSString *title;
  GPBTimestamp *createdAt;
  GPBTimestamp *changedAt;
  GPBStringValue *fiasId;
  NSString *fullAddress;
  int64_t orpon;
} KEYAPISTELEMETRYCONTROLV1Building__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 = KEYAPISTELEMETRYCONTROLV1Building_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Building__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "title",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Building_FieldNumber_Title,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Building__storage_, title),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "createdAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISTELEMETRYCONTROLV1Building_FieldNumber_CreatedAt,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Building__storage_, createdAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "changedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISTELEMETRYCONTROLV1Building_FieldNumber_ChangedAt,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Building__storage_, changedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "utcOffset",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Building_FieldNumber_UtcOffset,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Building__storage_, utcOffset),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "fiasId",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISTELEMETRYCONTROLV1Building_FieldNumber_FiasId,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Building__storage_, fiasId),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "mrfType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Building_MrfType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1Building_FieldNumber_MrfType,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Building__storage_, mrfType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "rfType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Building_RfType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1Building_FieldNumber_RfType,
        .hasIndex = 7,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Building__storage_, rfType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "statusType",
        .dataTypeSpecific.enumDescFunc = KEYAPISTELEMETRYCONTROLV1Building_StatusType_EnumDescriptor,
        .number = KEYAPISTELEMETRYCONTROLV1Building_FieldNumber_StatusType,
        .hasIndex = 8,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Building__storage_, statusType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "fullAddress",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Building_FieldNumber_FullAddress,
        .hasIndex = 9,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Building__storage_, fullAddress),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "orpon",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1Building_FieldNumber_Orpon,
        .hasIndex = 10,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1Building__storage_, orpon),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt64,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1Building)
                                   messageName:@"Building"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1Building__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 KEYAPISTELEMETRYCONTROLV1Building_MrfType_RawValue(KEYAPISTELEMETRYCONTROLV1Building *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Building descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Building_FieldNumber_MrfType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1Building_MrfType_RawValue(KEYAPISTELEMETRYCONTROLV1Building *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Building descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Building_FieldNumber_MrfType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISTELEMETRYCONTROLV1Building_RfType_RawValue(KEYAPISTELEMETRYCONTROLV1Building *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Building descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Building_FieldNumber_RfType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1Building_RfType_RawValue(KEYAPISTELEMETRYCONTROLV1Building *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Building descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Building_FieldNumber_RfType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISTELEMETRYCONTROLV1Building_StatusType_RawValue(KEYAPISTELEMETRYCONTROLV1Building *message) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Building descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Building_FieldNumber_StatusType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISTELEMETRYCONTROLV1Building_StatusType_RawValue(KEYAPISTELEMETRYCONTROLV1Building *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISTELEMETRYCONTROLV1Building descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISTELEMETRYCONTROLV1Building_FieldNumber_StatusType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISTELEMETRYCONTROLV1BuildingGroup

@implementation KEYAPISTELEMETRYCONTROLV1BuildingGroup

@dynamic groupId;
@dynamic buildingId;

typedef struct KEYAPISTELEMETRYCONTROLV1BuildingGroup__storage_ {
  uint32_t _has_storage_[1];
  int32_t buildingId;
  NSString *groupId;
} KEYAPISTELEMETRYCONTROLV1BuildingGroup__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 = KEYAPISTELEMETRYCONTROLV1BuildingGroup_FieldNumber_GroupId,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1BuildingGroup__storage_, groupId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "buildingId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISTELEMETRYCONTROLV1BuildingGroup_FieldNumber_BuildingId,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISTELEMETRYCONTROLV1BuildingGroup__storage_, buildingId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISTELEMETRYCONTROLV1BuildingGroup)
                                   messageName:@"BuildingGroup"
                               fileDescription:&KEYAPISTELEMETRYCONTROLV1KeyapisTelemetryControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISTELEMETRYCONTROLV1BuildingGroup__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
