// Generated by the protocol buffer compiler.  DO NOT EDIT!
// clang-format off
// source: keyapis/access_control/v1/keyapis_access_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/access_control/v1/KeyapisAccessControlBuildingV1.pbobjc.h"
#import "google/api/Annotations.pbobjc.h"
#import "google/api/FieldBehavior.pbobjc.h"
#import "keyapis/access_control/v1/KeyapisAccessControlAccessControlV1.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(GPBDoubleValue);
GPBObjCClassDeclaration(GPBInt32Value);
GPBObjCClassDeclaration(GPBInt64Value);
GPBObjCClassDeclaration(GPBStringValue);
GPBObjCClassDeclaration(GPBTimestamp);
GPBObjCClassDeclaration(KEYAPISACCESSCONTROLV1Building);
GPBObjCClassDeclaration(KEYAPISACCESSCONTROLV1BuildingFilter);
GPBObjCClassDeclaration(KEYAPISACCESSCONTROLV1BuildingPaging);
GPBObjCClassDeclaration(KEYAPISACCESSCONTROLV1BuildingSubscriptionMode);
GPBObjCClassDeclaration(KEYAPISACCESSCONTROLV1GetBuildingCountRequest);
GPBObjCClassDeclaration(KEYAPISACCESSCONTROLV1GetBuildingCountResponse);
GPBObjCClassDeclaration(KEYAPISACCESSCONTROLV1GetBuildingListRequest);
GPBObjCClassDeclaration(KEYAPISACCESSCONTROLV1GetBuildingListResponse);
GPBObjCClassDeclaration(KEYAPISACCESSCONTROLV1GetBuildingListResponse_Error);
GPBObjCClassDeclaration(KEYAPISACCESSCONTROLV1GetBuildingOrponExistsRequest);
GPBObjCClassDeclaration(KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse);
GPBObjCClassDeclaration(KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse_Error);
GPBObjCClassDeclaration(KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeRequest);
GPBObjCClassDeclaration(KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse);
GPBObjCClassDeclaration(KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse_Error);
GPBObjCClassDeclaration(KEYAPISACCESSCONTROLV1GetBuildingRequest);
GPBObjCClassDeclaration(KEYAPISACCESSCONTROLV1GetBuildingResponse);
GPBObjCClassDeclaration(KEYAPISACCESSCONTROLV1GetBuildingResponse_Error);
GPBObjCClassDeclaration(KEYAPISACCESSCONTROLV1ValidationError);

#pragma mark - KEYAPISACCESSCONTROLV1KeyapisAccessControlBuildingV1Root

@implementation KEYAPISACCESSCONTROLV1KeyapisAccessControlBuildingV1Root

+ (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 KEYAPISACCESSCONTROLV1KeyapisAccessControlBuildingV1Root_FileDescription = {
  .package = "keyapis.access_control.v1",
  .prefix = "KEYAPISACCESSCONTROLV1",
  .syntax = GPBFileSyntaxProto3
};

#pragma mark - Enum KEYAPISACCESSCONTROLV1BuildingPaging_OrderByType

GPBEnumDescriptor *KEYAPISACCESSCONTROLV1BuildingPaging_OrderByType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "OrderByTypeUnknown\000Id\000CreatedAt\000StreetTh"
        "enNumberThenPart\000";
    static const int32_t values[] = {
        KEYAPISACCESSCONTROLV1BuildingPaging_OrderByType_OrderByTypeUnknown,
        KEYAPISACCESSCONTROLV1BuildingPaging_OrderByType_Id,
        KEYAPISACCESSCONTROLV1BuildingPaging_OrderByType_CreatedAt,
        KEYAPISACCESSCONTROLV1BuildingPaging_OrderByType_StreetThenNumberThenPart,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISACCESSCONTROLV1BuildingPaging_OrderByType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISACCESSCONTROLV1BuildingPaging_OrderByType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISACCESSCONTROLV1BuildingPaging_OrderByType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISACCESSCONTROLV1BuildingPaging_OrderByType_OrderByTypeUnknown:
    case KEYAPISACCESSCONTROLV1BuildingPaging_OrderByType_Id:
    case KEYAPISACCESSCONTROLV1BuildingPaging_OrderByType_CreatedAt:
    case KEYAPISACCESSCONTROLV1BuildingPaging_OrderByType_StreetThenNumberThenPart:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISACCESSCONTROLV1BuildingPaging_DirectionType

GPBEnumDescriptor *KEYAPISACCESSCONTROLV1BuildingPaging_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[] = {
        KEYAPISACCESSCONTROLV1BuildingPaging_DirectionType_DirectionTypeUnknown,
        KEYAPISACCESSCONTROLV1BuildingPaging_DirectionType_Desc,
        KEYAPISACCESSCONTROLV1BuildingPaging_DirectionType_Asc,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISACCESSCONTROLV1BuildingPaging_DirectionType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISACCESSCONTROLV1BuildingPaging_DirectionType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISACCESSCONTROLV1BuildingPaging_DirectionType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISACCESSCONTROLV1BuildingPaging_DirectionType_DirectionTypeUnknown:
    case KEYAPISACCESSCONTROLV1BuildingPaging_DirectionType_Desc:
    case KEYAPISACCESSCONTROLV1BuildingPaging_DirectionType_Asc:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISACCESSCONTROLV1BuildingSubscriptionMode_SubscriptionModeType

GPBEnumDescriptor *KEYAPISACCESSCONTROLV1BuildingSubscriptionMode_SubscriptionModeType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "SubscriptionModeTypeUnknown\000Enabled\000Part"
        "iallyEnabled\000Disabled\000";
    static const int32_t values[] = {
        KEYAPISACCESSCONTROLV1BuildingSubscriptionMode_SubscriptionModeType_SubscriptionModeTypeUnknown,
        KEYAPISACCESSCONTROLV1BuildingSubscriptionMode_SubscriptionModeType_Enabled,
        KEYAPISACCESSCONTROLV1BuildingSubscriptionMode_SubscriptionModeType_PartiallyEnabled,
        KEYAPISACCESSCONTROLV1BuildingSubscriptionMode_SubscriptionModeType_Disabled,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISACCESSCONTROLV1BuildingSubscriptionMode_SubscriptionModeType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISACCESSCONTROLV1BuildingSubscriptionMode_SubscriptionModeType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISACCESSCONTROLV1BuildingSubscriptionMode_SubscriptionModeType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISACCESSCONTROLV1BuildingSubscriptionMode_SubscriptionModeType_SubscriptionModeTypeUnknown:
    case KEYAPISACCESSCONTROLV1BuildingSubscriptionMode_SubscriptionModeType_Enabled:
    case KEYAPISACCESSCONTROLV1BuildingSubscriptionMode_SubscriptionModeType_PartiallyEnabled:
    case KEYAPISACCESSCONTROLV1BuildingSubscriptionMode_SubscriptionModeType_Disabled:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - KEYAPISACCESSCONTROLV1Building

@implementation KEYAPISACCESSCONTROLV1Building

@dynamic id_p;
@dynamic rfId;
@dynamic mrfId;
@dynamic orpon;
@dynamic city;
@dynamic street;
@dynamic number;
@dynamic part;
@dynamic companyId;
@dynamic prefix;
@dynamic hasCreatedAt, createdAt;
@dynamic hasDeletedAt, deletedAt;
@dynamic flatgrammId;
@dynamic cityOrpon;
@dynamic hasFias, fias;
@dynamic hasDistrict, district;
@dynamic hasUnom, unom;
@dynamic regionOrpon;
@dynamic utcOffset;
@dynamic isKeyPurchasePossibleInSalePoints;
@dynamic isKeyPurchasePossibleInManagementCompany;
@dynamic isKeyPurchasePossibleInIntercomCompany;
@dynamic isRfidMifareSupported;
@dynamic hasArea, area;
@dynamic hasAreaOrpon, areaOrpon;
@dynamic hasAreaKladr, areaKladr;
@dynamic hasCapitalMarker, capitalMarker;
@dynamic hasCityKladr, cityKladr;
@dynamic hasKladr, kladr;
@dynamic hasFiasLevel, fiasLevel;
@dynamic hasFiasActualityState, fiasActualityState;
@dynamic hasGeoLat, geoLat;
@dynamic hasGeoLon, geoLon;
@dynamic hasOkato, okato;
@dynamic hasOktmo, oktmo;
@dynamic hasPostalCode, postalCode;
@dynamic hasRegion, region;
@dynamic hasRegionKladr, regionKladr;
@dynamic hasStreetKladr, streetKladr;
@dynamic hasStreetOrpon, streetOrpon;
@dynamic hasHouseKladr, houseKladr;

typedef struct KEYAPISACCESSCONTROLV1Building__storage_ {
  uint32_t _has_storage_[2];
  int32_t id_p;
  int32_t rfId;
  int32_t mrfId;
  int32_t companyId;
  int32_t flatgrammId;
  int32_t utcOffset;
  NSString *city;
  NSString *street;
  NSString *number;
  NSString *part;
  NSString *prefix;
  GPBTimestamp *createdAt;
  GPBTimestamp *deletedAt;
  GPBStringValue *fias;
  GPBStringValue *district;
  GPBInt64Value *unom;
  GPBStringValue *area;
  GPBInt64Value *areaOrpon;
  GPBStringValue *areaKladr;
  GPBInt32Value *capitalMarker;
  GPBStringValue *cityKladr;
  GPBStringValue *kladr;
  GPBInt32Value *fiasLevel;
  GPBInt32Value *fiasActualityState;
  GPBDoubleValue *geoLat;
  GPBDoubleValue *geoLon;
  GPBInt64Value *okato;
  GPBInt64Value *oktmo;
  GPBInt32Value *postalCode;
  GPBStringValue *region;
  GPBStringValue *regionKladr;
  GPBStringValue *streetKladr;
  GPBInt64Value *streetOrpon;
  GPBStringValue *houseKladr;
  int64_t orpon;
  int64_t cityOrpon;
  int64_t regionOrpon;
} KEYAPISACCESSCONTROLV1Building__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 = KEYAPISACCESSCONTROLV1Building_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "rfId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_RfId,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, rfId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "mrfId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_MrfId,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, mrfId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "orpon",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_Orpon,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, orpon),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt64,
      },
      {
        .name = "city",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_City,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, city),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "street",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_Street,
        .hasIndex = 5,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, street),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "number",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_Number,
        .hasIndex = 6,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, number),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "part",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_Part,
        .hasIndex = 7,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, part),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "companyId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_CompanyId,
        .hasIndex = 8,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, companyId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "prefix",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_Prefix,
        .hasIndex = 9,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, prefix),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "createdAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_CreatedAt,
        .hasIndex = 10,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, createdAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "deletedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_DeletedAt,
        .hasIndex = 11,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, deletedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "flatgrammId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_FlatgrammId,
        .hasIndex = 12,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, flatgrammId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "cityOrpon",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_CityOrpon,
        .hasIndex = 13,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, cityOrpon),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt64,
      },
      {
        .name = "fias",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_Fias,
        .hasIndex = 14,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, fias),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "district",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_District,
        .hasIndex = 15,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, district),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "unom",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt64Value),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_Unom,
        .hasIndex = 16,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, unom),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "regionOrpon",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_RegionOrpon,
        .hasIndex = 17,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, regionOrpon),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt64,
      },
      {
        .name = "utcOffset",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_UtcOffset,
        .hasIndex = 18,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, utcOffset),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "isKeyPurchasePossibleInSalePoints",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_IsKeyPurchasePossibleInSalePoints,
        .hasIndex = 19,
        .offset = 20,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "isKeyPurchasePossibleInManagementCompany",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_IsKeyPurchasePossibleInManagementCompany,
        .hasIndex = 21,
        .offset = 22,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "isKeyPurchasePossibleInIntercomCompany",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_IsKeyPurchasePossibleInIntercomCompany,
        .hasIndex = 23,
        .offset = 24,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "isRfidMifareSupported",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_IsRfidMifareSupported,
        .hasIndex = 25,
        .offset = 26,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "area",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_Area,
        .hasIndex = 27,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, area),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "areaOrpon",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt64Value),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_AreaOrpon,
        .hasIndex = 28,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, areaOrpon),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "areaKladr",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_AreaKladr,
        .hasIndex = 29,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, areaKladr),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "capitalMarker",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_CapitalMarker,
        .hasIndex = 30,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, capitalMarker),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "cityKladr",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_CityKladr,
        .hasIndex = 31,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, cityKladr),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "kladr",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_Kladr,
        .hasIndex = 32,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, kladr),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "fiasLevel",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_FiasLevel,
        .hasIndex = 33,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, fiasLevel),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "fiasActualityState",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_FiasActualityState,
        .hasIndex = 34,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, fiasActualityState),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "geoLat",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBDoubleValue),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_GeoLat,
        .hasIndex = 35,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, geoLat),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "geoLon",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBDoubleValue),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_GeoLon,
        .hasIndex = 36,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, geoLon),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "okato",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt64Value),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_Okato,
        .hasIndex = 37,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, okato),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "oktmo",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt64Value),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_Oktmo,
        .hasIndex = 38,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, oktmo),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "postalCode",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_PostalCode,
        .hasIndex = 39,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, postalCode),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "region",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_Region,
        .hasIndex = 40,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, region),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "regionKladr",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_RegionKladr,
        .hasIndex = 41,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, regionKladr),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "streetKladr",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_StreetKladr,
        .hasIndex = 42,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, streetKladr),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "streetOrpon",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt64Value),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_StreetOrpon,
        .hasIndex = 43,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, streetOrpon),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "houseKladr",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBStringValue),
        .number = KEYAPISACCESSCONTROLV1Building_FieldNumber_HouseKladr,
        .hasIndex = 44,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1Building__storage_, houseKladr),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISACCESSCONTROLV1Building)
                                   messageName:@"Building"
                               fileDescription:&KEYAPISACCESSCONTROLV1KeyapisAccessControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISACCESSCONTROLV1Building__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 - KEYAPISACCESSCONTROLV1GetBuildingRequest

@implementation KEYAPISACCESSCONTROLV1GetBuildingRequest

@dynamic id_p;

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

@implementation KEYAPISACCESSCONTROLV1GetBuildingResponse

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

typedef struct KEYAPISACCESSCONTROLV1GetBuildingResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISACCESSCONTROLV1Building *data_p;
  KEYAPISACCESSCONTROLV1GetBuildingResponse_Error *error;
} KEYAPISACCESSCONTROLV1GetBuildingResponse__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(KEYAPISACCESSCONTROLV1Building),
        .number = KEYAPISACCESSCONTROLV1GetBuildingResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1GetBuildingResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISACCESSCONTROLV1GetBuildingResponse_Error),
        .number = KEYAPISACCESSCONTROLV1GetBuildingResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1GetBuildingResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISACCESSCONTROLV1GetBuildingResponse)
                                   messageName:@"GetBuildingResponse"
                               fileDescription:&KEYAPISACCESSCONTROLV1KeyapisAccessControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISACCESSCONTROLV1GetBuildingResponse__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 KEYAPISACCESSCONTROLV1GetBuildingResponse_ClearTypeOneOfCase(KEYAPISACCESSCONTROLV1GetBuildingResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISACCESSCONTROLV1GetBuildingResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISACCESSCONTROLV1GetBuildingResponse_Error

@implementation KEYAPISACCESSCONTROLV1GetBuildingResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISACCESSCONTROLV1GetBuildingResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISACCESSCONTROLV1ValidationError *validation;
} KEYAPISACCESSCONTROLV1GetBuildingResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "validation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISACCESSCONTROLV1ValidationError),
        .number = KEYAPISACCESSCONTROLV1GetBuildingResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1GetBuildingResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISACCESSCONTROLV1GetBuildingResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISACCESSCONTROLV1KeyapisAccessControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISACCESSCONTROLV1GetBuildingResponse_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(KEYAPISACCESSCONTROLV1GetBuildingResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISACCESSCONTROLV1GetBuildingListRequest

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

typedef struct KEYAPISACCESSCONTROLV1GetBuildingListRequest__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISACCESSCONTROLV1BuildingFilter *filter;
  KEYAPISACCESSCONTROLV1BuildingPaging *paging;
} KEYAPISACCESSCONTROLV1GetBuildingListRequest__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(KEYAPISACCESSCONTROLV1BuildingFilter),
        .number = KEYAPISACCESSCONTROLV1GetBuildingListRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1GetBuildingListRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "paging",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISACCESSCONTROLV1BuildingPaging),
        .number = KEYAPISACCESSCONTROLV1GetBuildingListRequest_FieldNumber_Paging,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1GetBuildingListRequest__storage_, paging),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISACCESSCONTROLV1GetBuildingListRequest)
                                   messageName:@"GetBuildingListRequest"
                               fileDescription:&KEYAPISACCESSCONTROLV1KeyapisAccessControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISACCESSCONTROLV1GetBuildingListRequest__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 KEYAPISACCESSCONTROLV1GetBuildingListRequest_ClearPaginationOneOfCase(KEYAPISACCESSCONTROLV1GetBuildingListRequest *message) {
  GPBDescriptor *descriptor = [KEYAPISACCESSCONTROLV1GetBuildingListRequest descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISACCESSCONTROLV1GetBuildingListResponse

@implementation KEYAPISACCESSCONTROLV1GetBuildingListResponse

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

typedef struct KEYAPISACCESSCONTROLV1GetBuildingListResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISACCESSCONTROLV1Building *data_p;
  KEYAPISACCESSCONTROLV1GetBuildingListResponse_Error *error;
} KEYAPISACCESSCONTROLV1GetBuildingListResponse__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(KEYAPISACCESSCONTROLV1Building),
        .number = KEYAPISACCESSCONTROLV1GetBuildingListResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1GetBuildingListResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISACCESSCONTROLV1GetBuildingListResponse_Error),
        .number = KEYAPISACCESSCONTROLV1GetBuildingListResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1GetBuildingListResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISACCESSCONTROLV1GetBuildingListResponse)
                                   messageName:@"GetBuildingListResponse"
                               fileDescription:&KEYAPISACCESSCONTROLV1KeyapisAccessControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISACCESSCONTROLV1GetBuildingListResponse__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 KEYAPISACCESSCONTROLV1GetBuildingListResponse_ClearTypeOneOfCase(KEYAPISACCESSCONTROLV1GetBuildingListResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISACCESSCONTROLV1GetBuildingListResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISACCESSCONTROLV1GetBuildingListResponse_Error

@implementation KEYAPISACCESSCONTROLV1GetBuildingListResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISACCESSCONTROLV1GetBuildingListResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISACCESSCONTROLV1ValidationError *validation;
} KEYAPISACCESSCONTROLV1GetBuildingListResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "validation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISACCESSCONTROLV1ValidationError),
        .number = KEYAPISACCESSCONTROLV1GetBuildingListResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1GetBuildingListResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISACCESSCONTROLV1GetBuildingListResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISACCESSCONTROLV1KeyapisAccessControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISACCESSCONTROLV1GetBuildingListResponse_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(KEYAPISACCESSCONTROLV1GetBuildingListResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISACCESSCONTROLV1GetBuildingCountRequest

@dynamic hasFilter, filter;

typedef struct KEYAPISACCESSCONTROLV1GetBuildingCountRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISACCESSCONTROLV1BuildingFilter *filter;
} KEYAPISACCESSCONTROLV1GetBuildingCountRequest__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(KEYAPISACCESSCONTROLV1BuildingFilter),
        .number = KEYAPISACCESSCONTROLV1GetBuildingCountRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1GetBuildingCountRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISACCESSCONTROLV1GetBuildingCountRequest)
                                   messageName:@"GetBuildingCountRequest"
                               fileDescription:&KEYAPISACCESSCONTROLV1KeyapisAccessControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISACCESSCONTROLV1GetBuildingCountRequest__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 - KEYAPISACCESSCONTROLV1GetBuildingCountResponse

@implementation KEYAPISACCESSCONTROLV1GetBuildingCountResponse

@dynamic typeOneOfCase;
@dynamic data_p;

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

@implementation KEYAPISACCESSCONTROLV1BuildingFilter

@dynamic mrfIdsArray, mrfIdsArray_Count;
@dynamic rfIdsArray, rfIdsArray_Count;
@dynamic deviceIdsArray, deviceIdsArray_Count;
@dynamic flatgrammIdsArray, flatgrammIdsArray_Count;
@dynamic orponsArray, orponsArray_Count;

typedef struct KEYAPISACCESSCONTROLV1BuildingFilter__storage_ {
  uint32_t _has_storage_[1];
  GPBInt32Array *mrfIdsArray;
  GPBInt32Array *rfIdsArray;
  GPBInt32Array *deviceIdsArray;
  GPBInt32Array *flatgrammIdsArray;
  GPBInt64Array *orponsArray;
} KEYAPISACCESSCONTROLV1BuildingFilter__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 = "mrfIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1BuildingFilter_FieldNumber_MrfIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1BuildingFilter__storage_, mrfIdsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "rfIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1BuildingFilter_FieldNumber_RfIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1BuildingFilter__storage_, rfIdsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "deviceIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1BuildingFilter_FieldNumber_DeviceIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1BuildingFilter__storage_, deviceIdsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "flatgrammIdsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1BuildingFilter_FieldNumber_FlatgrammIdsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1BuildingFilter__storage_, flatgrammIdsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "orponsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1BuildingFilter_FieldNumber_OrponsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1BuildingFilter__storage_, orponsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt64,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISACCESSCONTROLV1BuildingFilter)
                                   messageName:@"BuildingFilter"
                               fileDescription:&KEYAPISACCESSCONTROLV1KeyapisAccessControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISACCESSCONTROLV1BuildingFilter__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 - KEYAPISACCESSCONTROLV1BuildingPaging

@implementation KEYAPISACCESSCONTROLV1BuildingPaging

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

typedef struct KEYAPISACCESSCONTROLV1BuildingPaging__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISACCESSCONTROLV1BuildingPaging_OrderByType orderByType;
  KEYAPISACCESSCONTROLV1BuildingPaging_DirectionType directionType;
  int32_t limit;
  int32_t offset;
} KEYAPISACCESSCONTROLV1BuildingPaging__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 = KEYAPISACCESSCONTROLV1BuildingPaging_OrderByType_EnumDescriptor,
        .number = KEYAPISACCESSCONTROLV1BuildingPaging_FieldNumber_OrderByType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1BuildingPaging__storage_, orderByType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "directionType",
        .dataTypeSpecific.enumDescFunc = KEYAPISACCESSCONTROLV1BuildingPaging_DirectionType_EnumDescriptor,
        .number = KEYAPISACCESSCONTROLV1BuildingPaging_FieldNumber_DirectionType,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1BuildingPaging__storage_, directionType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "limit",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1BuildingPaging_FieldNumber_Limit,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1BuildingPaging__storage_, limit),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1BuildingPaging_FieldNumber_Offset,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1BuildingPaging__storage_, offset),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISACCESSCONTROLV1BuildingPaging)
                                   messageName:@"BuildingPaging"
                               fileDescription:&KEYAPISACCESSCONTROLV1KeyapisAccessControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISACCESSCONTROLV1BuildingPaging__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 KEYAPISACCESSCONTROLV1BuildingPaging_OrderByType_RawValue(KEYAPISACCESSCONTROLV1BuildingPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISACCESSCONTROLV1BuildingPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISACCESSCONTROLV1BuildingPaging_FieldNumber_OrderByType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISACCESSCONTROLV1BuildingPaging_OrderByType_RawValue(KEYAPISACCESSCONTROLV1BuildingPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISACCESSCONTROLV1BuildingPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISACCESSCONTROLV1BuildingPaging_FieldNumber_OrderByType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISACCESSCONTROLV1BuildingPaging_DirectionType_RawValue(KEYAPISACCESSCONTROLV1BuildingPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISACCESSCONTROLV1BuildingPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISACCESSCONTROLV1BuildingPaging_FieldNumber_DirectionType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISACCESSCONTROLV1BuildingPaging_DirectionType_RawValue(KEYAPISACCESSCONTROLV1BuildingPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISACCESSCONTROLV1BuildingPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISACCESSCONTROLV1BuildingPaging_FieldNumber_DirectionType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISACCESSCONTROLV1BuildingSubscriptionMode

@implementation KEYAPISACCESSCONTROLV1BuildingSubscriptionMode

@dynamic subscriptionModeType;

typedef struct KEYAPISACCESSCONTROLV1BuildingSubscriptionMode__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISACCESSCONTROLV1BuildingSubscriptionMode_SubscriptionModeType subscriptionModeType;
} KEYAPISACCESSCONTROLV1BuildingSubscriptionMode__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 = "subscriptionModeType",
        .dataTypeSpecific.enumDescFunc = KEYAPISACCESSCONTROLV1BuildingSubscriptionMode_SubscriptionModeType_EnumDescriptor,
        .number = KEYAPISACCESSCONTROLV1BuildingSubscriptionMode_FieldNumber_SubscriptionModeType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1BuildingSubscriptionMode__storage_, subscriptionModeType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISACCESSCONTROLV1BuildingSubscriptionMode)
                                   messageName:@"BuildingSubscriptionMode"
                               fileDescription:&KEYAPISACCESSCONTROLV1KeyapisAccessControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISACCESSCONTROLV1BuildingSubscriptionMode__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 KEYAPISACCESSCONTROLV1BuildingSubscriptionMode_SubscriptionModeType_RawValue(KEYAPISACCESSCONTROLV1BuildingSubscriptionMode *message) {
  GPBDescriptor *descriptor = [KEYAPISACCESSCONTROLV1BuildingSubscriptionMode descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISACCESSCONTROLV1BuildingSubscriptionMode_FieldNumber_SubscriptionModeType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISACCESSCONTROLV1BuildingSubscriptionMode_SubscriptionModeType_RawValue(KEYAPISACCESSCONTROLV1BuildingSubscriptionMode *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISACCESSCONTROLV1BuildingSubscriptionMode descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISACCESSCONTROLV1BuildingSubscriptionMode_FieldNumber_SubscriptionModeType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeRequest

@implementation KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeRequest

@dynamic orpon;

typedef struct KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeRequest__storage_ {
  uint32_t _has_storage_[1];
  int64_t orpon;
} KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeRequest__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 = "orpon",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeRequest_FieldNumber_Orpon,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeRequest__storage_, orpon),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt64,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeRequest)
                                   messageName:@"GetBuildingOrponSubscriptionModeRequest"
                               fileDescription:&KEYAPISACCESSCONTROLV1KeyapisAccessControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeRequest__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 - KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse

@implementation KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse

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

typedef struct KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISACCESSCONTROLV1BuildingSubscriptionMode *data_p;
  KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse_Error *error;
} KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse__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(KEYAPISACCESSCONTROLV1BuildingSubscriptionMode),
        .number = KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse_Error),
        .number = KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse)
                                   messageName:@"GetBuildingOrponSubscriptionModeResponse"
                               fileDescription:&KEYAPISACCESSCONTROLV1KeyapisAccessControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse__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 KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse_ClearTypeOneOfCase(KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse_Error

@implementation KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISACCESSCONTROLV1ValidationError *validation;
} KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "validation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISACCESSCONTROLV1ValidationError),
        .number = KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISACCESSCONTROLV1KeyapisAccessControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse_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(KEYAPISACCESSCONTROLV1GetBuildingOrponSubscriptionModeResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISACCESSCONTROLV1GetBuildingOrponExistsRequest

@dynamic orpon;

typedef struct KEYAPISACCESSCONTROLV1GetBuildingOrponExistsRequest__storage_ {
  uint32_t _has_storage_[1];
  int64_t orpon;
} KEYAPISACCESSCONTROLV1GetBuildingOrponExistsRequest__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 = "orpon",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISACCESSCONTROLV1GetBuildingOrponExistsRequest_FieldNumber_Orpon,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1GetBuildingOrponExistsRequest__storage_, orpon),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt64,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISACCESSCONTROLV1GetBuildingOrponExistsRequest)
                                   messageName:@"GetBuildingOrponExistsRequest"
                               fileDescription:&KEYAPISACCESSCONTROLV1KeyapisAccessControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISACCESSCONTROLV1GetBuildingOrponExistsRequest__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 - KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse

@implementation KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse

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

typedef struct KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse_Error *error;
} KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse__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 = KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = 0,  // Stored in _has_storage_ to save space.
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse_Error),
        .number = KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse)
                                   messageName:@"GetBuildingOrponExistsResponse"
                               fileDescription:&KEYAPISACCESSCONTROLV1KeyapisAccessControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse__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 KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse_ClearTypeOneOfCase(KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse_Error

@implementation KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISACCESSCONTROLV1ValidationError *validation;
} KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse_Error__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "validation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISACCESSCONTROLV1ValidationError),
        .number = KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISACCESSCONTROLV1KeyapisAccessControlBuildingV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse_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(KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse_Error_ClearReasonOneOfCase(KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse_Error *message) {
  GPBDescriptor *descriptor = [KEYAPISACCESSCONTROLV1GetBuildingOrponExistsResponse_Error descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}

#pragma clang diagnostic pop

// @@protoc_insertion_point(global_scope)

// clang-format on
