// Generated by the protocol buffer compiler.  DO NOT EDIT!
// clang-format off
// source: keyapis/vc/v1/keyapis_vc_camera_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/vc/v1/KeyapisVcCameraV1.pbobjc.h"
#import "google/api/Annotations.pbobjc.h"
#import "google/api/FieldBehavior.pbobjc.h"
#import "google/protobuf/Descriptor.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(GPBBoolValue);
GPBObjCClassDeclaration(GPBInt32Value);
GPBObjCClassDeclaration(GPBTimestamp);
GPBObjCClassDeclaration(KEYAPISVCV1Camera);
GPBObjCClassDeclaration(KEYAPISVCV1CameraFilter);
GPBObjCClassDeclaration(KEYAPISVCV1CameraPaging);
GPBObjCClassDeclaration(KEYAPISVCV1CameraRoom);
GPBObjCClassDeclaration(KEYAPISVCV1CameraRoomFilter);
GPBObjCClassDeclaration(KEYAPISVCV1CameraRoomPaging);
GPBObjCClassDeclaration(KEYAPISVCV1CameraScope);
GPBObjCClassDeclaration(KEYAPISVCV1Camera_ValidationError);
GPBObjCClassDeclaration(KEYAPISVCV1Camera_ValidationError_OneFieldMacOrSerialNumberRequired);
GPBObjCClassDeclaration(KEYAPISVCV1Camera_ValidationError_RtspUrlRequired);
GPBObjCClassDeclaration(KEYAPISVCV1DeleteCameraRequest);
GPBObjCClassDeclaration(KEYAPISVCV1DeleteCameraResponse);
GPBObjCClassDeclaration(KEYAPISVCV1DeleteCameraResponse_Error);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraCalendarRequest);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraCalendarResponse);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraCalendarResponse_Caledar);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraCalendarResponse_Error);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraCalendarResponse_Error_VcError);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraIntervalsRequest);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraIntervalsResponse);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraIntervalsResponse_Error);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraIntervalsResponse_Error_VcError);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraIntervalsResponse_Interval);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraIntervalsResponse_Interval_Item);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraListRequest);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraListResponse);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraListResponse_Data);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraListResponse_Error);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraRequest);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraResponse);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraResponse_Error);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraRoomCountRequest);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraRoomCountResponse);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraRoomCountResponse_Error);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraRoomListRequest);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraRoomListResponse);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraRoomListResponse_Error);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraRtspUrlExternalIdRequest);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraRtspUrlExternalIdResponse);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_CameraRtspUrl);
GPBObjCClassDeclaration(KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_Error);
GPBObjCClassDeclaration(KEYAPISVCV1PostCameraRequest);
GPBObjCClassDeclaration(KEYAPISVCV1PostCameraResponse);
GPBObjCClassDeclaration(KEYAPISVCV1PostCameraResponse_Error);
GPBObjCClassDeclaration(KEYAPISVCV1PostCameraResponse_Error_VcError);
GPBObjCClassDeclaration(KEYAPISVCV1PutCameraRoomAttachListRequest);
GPBObjCClassDeclaration(KEYAPISVCV1PutCameraRoomAttachListResponse);
GPBObjCClassDeclaration(KEYAPISVCV1PutCameraRoomAttachListResponse_Error);
GPBObjCClassDeclaration(KEYAPISVCV1PutCameraRoomAttachRequest);
GPBObjCClassDeclaration(KEYAPISVCV1PutCameraRoomAttachResponse);
GPBObjCClassDeclaration(KEYAPISVCV1PutCameraRoomAttachResponse_Error);
GPBObjCClassDeclaration(KEYAPISVCV1PutCameraRoomDetachListRequest);
GPBObjCClassDeclaration(KEYAPISVCV1PutCameraRoomDetachListResponse);
GPBObjCClassDeclaration(KEYAPISVCV1PutCameraRoomDetachListResponse_Error);
GPBObjCClassDeclaration(KEYAPISVCV1PutCameraRoomDetachRequest);
GPBObjCClassDeclaration(KEYAPISVCV1PutCameraRoomDetachResponse);
GPBObjCClassDeclaration(KEYAPISVCV1PutCameraRoomDetachResponse_Error);
GPBObjCClassDeclaration(KEYAPISVCV1ValidationError);

#pragma mark - KEYAPISVCV1KeyapisVcCameraV1Root

@implementation KEYAPISVCV1KeyapisVcCameraV1Root

+ (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 KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription = {
  .package = "keyapis.vc.v1",
  .prefix = "KEYAPISVCV1",
  .syntax = GPBFileSyntaxProto3
};

#pragma mark - Enum KEYAPISVCV1CameraRoomPaging_DirectionType

GPBEnumDescriptor *KEYAPISVCV1CameraRoomPaging_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[] = {
        KEYAPISVCV1CameraRoomPaging_DirectionType_DirectionTypeUnknown,
        KEYAPISVCV1CameraRoomPaging_DirectionType_Desc,
        KEYAPISVCV1CameraRoomPaging_DirectionType_Asc,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISVCV1CameraRoomPaging_DirectionType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISVCV1CameraRoomPaging_DirectionType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISVCV1CameraRoomPaging_DirectionType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISVCV1CameraRoomPaging_DirectionType_DirectionTypeUnknown:
    case KEYAPISVCV1CameraRoomPaging_DirectionType_Desc:
    case KEYAPISVCV1CameraRoomPaging_DirectionType_Asc:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISVCV1CameraRoomPaging_OrderByType

GPBEnumDescriptor *KEYAPISVCV1CameraRoomPaging_OrderByType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "OrderByTypeUnknown\000CameraUid\000OrponRoomNu"
        "mber\000";
    static const int32_t values[] = {
        KEYAPISVCV1CameraRoomPaging_OrderByType_OrderByTypeUnknown,
        KEYAPISVCV1CameraRoomPaging_OrderByType_CameraUid,
        KEYAPISVCV1CameraRoomPaging_OrderByType_OrponRoomNumber,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISVCV1CameraRoomPaging_OrderByType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISVCV1CameraRoomPaging_OrderByType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISVCV1CameraRoomPaging_OrderByType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISVCV1CameraRoomPaging_OrderByType_OrderByTypeUnknown:
    case KEYAPISVCV1CameraRoomPaging_OrderByType_CameraUid:
    case KEYAPISVCV1CameraRoomPaging_OrderByType_OrponRoomNumber:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISVCV1Camera_Type

GPBEnumDescriptor *KEYAPISVCV1Camera_Type_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "TypeUnknown\000Dvr\000Vms\000Rose\000Violet\000";
    static const int32_t values[] = {
        KEYAPISVCV1Camera_Type_TypeUnknown,
        KEYAPISVCV1Camera_Type_Dvr,
        KEYAPISVCV1Camera_Type_Vms,
        KEYAPISVCV1Camera_Type_Rose,
        KEYAPISVCV1Camera_Type_Violet,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISVCV1Camera_Type)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISVCV1Camera_Type_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISVCV1Camera_Type_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISVCV1Camera_Type_TypeUnknown:
    case KEYAPISVCV1Camera_Type_Dvr:
    case KEYAPISVCV1Camera_Type_Vms:
    case KEYAPISVCV1Camera_Type_Rose:
    case KEYAPISVCV1Camera_Type_Violet:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISVCV1CameraPaging_DirectionType

GPBEnumDescriptor *KEYAPISVCV1CameraPaging_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[] = {
        KEYAPISVCV1CameraPaging_DirectionType_DirectionTypeUnknown,
        KEYAPISVCV1CameraPaging_DirectionType_Desc,
        KEYAPISVCV1CameraPaging_DirectionType_Asc,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISVCV1CameraPaging_DirectionType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISVCV1CameraPaging_DirectionType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISVCV1CameraPaging_DirectionType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISVCV1CameraPaging_DirectionType_DirectionTypeUnknown:
    case KEYAPISVCV1CameraPaging_DirectionType_Desc:
    case KEYAPISVCV1CameraPaging_DirectionType_Asc:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum KEYAPISVCV1CameraPaging_OrderByType

GPBEnumDescriptor *KEYAPISVCV1CameraPaging_OrderByType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static const char *valueNames =
        "OrderByTypeUnknown\000Uid\000";
    static const int32_t values[] = {
        KEYAPISVCV1CameraPaging_OrderByType_OrderByTypeUnknown,
        KEYAPISVCV1CameraPaging_OrderByType_Uid,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KEYAPISVCV1CameraPaging_OrderByType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KEYAPISVCV1CameraPaging_OrderByType_IsValidValue
                                            flags:GPBEnumDescriptorInitializationFlag_None];
    GPBEnumDescriptor *expected = nil;
    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
      [worker release];
    }
  }
  return descriptor;
}

BOOL KEYAPISVCV1CameraPaging_OrderByType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KEYAPISVCV1CameraPaging_OrderByType_OrderByTypeUnknown:
    case KEYAPISVCV1CameraPaging_OrderByType_Uid:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - KEYAPISVCV1CameraRoom

@implementation KEYAPISVCV1CameraRoom

@dynamic cameraUid;
@dynamic orpon;
@dynamic roomNumber;

typedef struct KEYAPISVCV1CameraRoom__storage_ {
  uint32_t _has_storage_[1];
  NSString *cameraUid;
  NSString *roomNumber;
  int64_t orpon;
} KEYAPISVCV1CameraRoom__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 = "cameraUid",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1CameraRoom_FieldNumber_CameraUid,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1CameraRoom__storage_, cameraUid),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "orpon",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1CameraRoom_FieldNumber_Orpon,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1CameraRoom__storage_, orpon),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt64,
      },
      {
        .name = "roomNumber",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1CameraRoom_FieldNumber_RoomNumber,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISVCV1CameraRoom__storage_, roomNumber),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1CameraRoom)
                                   messageName:@"CameraRoom"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1CameraRoom__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 - KEYAPISVCV1CameraRoomFilter

@implementation KEYAPISVCV1CameraRoomFilter

@dynamic cameraUidsArray, cameraUidsArray_Count;
@dynamic orponsArray, orponsArray_Count;
@dynamic roomNumbersArray, roomNumbersArray_Count;

typedef struct KEYAPISVCV1CameraRoomFilter__storage_ {
  uint32_t _has_storage_[1];
  NSMutableArray *cameraUidsArray;
  GPBInt64Array *orponsArray;
  NSMutableArray *roomNumbersArray;
} KEYAPISVCV1CameraRoomFilter__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 = "cameraUidsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1CameraRoomFilter_FieldNumber_CameraUidsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISVCV1CameraRoomFilter__storage_, cameraUidsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "orponsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1CameraRoomFilter_FieldNumber_OrponsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISVCV1CameraRoomFilter__storage_, orponsArray),
        .flags = (GPBFieldFlags)(GPBFieldRepeated | GPBFieldPacked),
        .dataType = GPBDataTypeInt64,
      },
      {
        .name = "roomNumbersArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1CameraRoomFilter_FieldNumber_RoomNumbersArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISVCV1CameraRoomFilter__storage_, roomNumbersArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1CameraRoomFilter)
                                   messageName:@"CameraRoomFilter"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1CameraRoomFilter__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 - KEYAPISVCV1CameraRoomPaging

@implementation KEYAPISVCV1CameraRoomPaging

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

typedef struct KEYAPISVCV1CameraRoomPaging__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISVCV1CameraRoomPaging_OrderByType orderByType;
  KEYAPISVCV1CameraRoomPaging_DirectionType directionType;
  int32_t limit;
  int32_t offset;
} KEYAPISVCV1CameraRoomPaging__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 = KEYAPISVCV1CameraRoomPaging_OrderByType_EnumDescriptor,
        .number = KEYAPISVCV1CameraRoomPaging_FieldNumber_OrderByType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1CameraRoomPaging__storage_, orderByType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "directionType",
        .dataTypeSpecific.enumDescFunc = KEYAPISVCV1CameraRoomPaging_DirectionType_EnumDescriptor,
        .number = KEYAPISVCV1CameraRoomPaging_FieldNumber_DirectionType,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1CameraRoomPaging__storage_, directionType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "limit",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1CameraRoomPaging_FieldNumber_Limit,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISVCV1CameraRoomPaging__storage_, limit),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1CameraRoomPaging_FieldNumber_Offset,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISVCV1CameraRoomPaging__storage_, offset),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1CameraRoomPaging)
                                   messageName:@"CameraRoomPaging"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1CameraRoomPaging__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 KEYAPISVCV1CameraRoomPaging_OrderByType_RawValue(KEYAPISVCV1CameraRoomPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1CameraRoomPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISVCV1CameraRoomPaging_FieldNumber_OrderByType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISVCV1CameraRoomPaging_OrderByType_RawValue(KEYAPISVCV1CameraRoomPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISVCV1CameraRoomPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISVCV1CameraRoomPaging_FieldNumber_OrderByType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISVCV1CameraRoomPaging_DirectionType_RawValue(KEYAPISVCV1CameraRoomPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1CameraRoomPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISVCV1CameraRoomPaging_FieldNumber_DirectionType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISVCV1CameraRoomPaging_DirectionType_RawValue(KEYAPISVCV1CameraRoomPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISVCV1CameraRoomPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISVCV1CameraRoomPaging_FieldNumber_DirectionType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISVCV1Camera

@implementation KEYAPISVCV1Camera

@dynamic id_p;
@dynamic uid;
@dynamic name;
@dynamic isOnline;
@dynamic isActiveUserCamera;
@dynamic hasStatusChangedAt, statusChangedAt;
@dynamic mac;
@dynamic ip;
@dynamic remoteIp;
@dynamic hasTariffStartedAt, tariffStartedAt;
@dynamic hasTariffEndedAt, tariffEndedAt;
@dynamic tariffTitle;
@dynamic type;
@dynamic cameraCategoryId;
@dynamic rtspURL;
@dynamic serialNumber;
@dynamic companyId;

typedef struct KEYAPISVCV1Camera__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISVCV1Camera_Type type;
  int32_t cameraCategoryId;
  int32_t companyId;
  NSString *id_p;
  NSString *uid;
  NSString *name;
  GPBTimestamp *statusChangedAt;
  NSString *mac;
  NSString *ip;
  NSString *remoteIp;
  GPBTimestamp *tariffStartedAt;
  GPBTimestamp *tariffEndedAt;
  NSString *tariffTitle;
  NSString *rtspURL;
  NSString *serialNumber;
} KEYAPISVCV1Camera__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 = KEYAPISVCV1Camera_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1Camera__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "uid",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1Camera_FieldNumber_Uid,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1Camera__storage_, uid),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "name",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1Camera_FieldNumber_Name,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISVCV1Camera__storage_, name),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "isOnline",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1Camera_FieldNumber_IsOnline,
        .hasIndex = 3,
        .offset = 4,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "isActiveUserCamera",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1Camera_FieldNumber_IsActiveUserCamera,
        .hasIndex = 5,
        .offset = 6,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "statusChangedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISVCV1Camera_FieldNumber_StatusChangedAt,
        .hasIndex = 7,
        .offset = (uint32_t)offsetof(KEYAPISVCV1Camera__storage_, statusChangedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "mac",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1Camera_FieldNumber_Mac,
        .hasIndex = 8,
        .offset = (uint32_t)offsetof(KEYAPISVCV1Camera__storage_, mac),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "ip",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1Camera_FieldNumber_Ip,
        .hasIndex = 9,
        .offset = (uint32_t)offsetof(KEYAPISVCV1Camera__storage_, ip),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "remoteIp",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1Camera_FieldNumber_RemoteIp,
        .hasIndex = 10,
        .offset = (uint32_t)offsetof(KEYAPISVCV1Camera__storage_, remoteIp),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "tariffStartedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISVCV1Camera_FieldNumber_TariffStartedAt,
        .hasIndex = 11,
        .offset = (uint32_t)offsetof(KEYAPISVCV1Camera__storage_, tariffStartedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "tariffEndedAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISVCV1Camera_FieldNumber_TariffEndedAt,
        .hasIndex = 12,
        .offset = (uint32_t)offsetof(KEYAPISVCV1Camera__storage_, tariffEndedAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "tariffTitle",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1Camera_FieldNumber_TariffTitle,
        .hasIndex = 13,
        .offset = (uint32_t)offsetof(KEYAPISVCV1Camera__storage_, tariffTitle),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "type",
        .dataTypeSpecific.enumDescFunc = KEYAPISVCV1Camera_Type_EnumDescriptor,
        .number = KEYAPISVCV1Camera_FieldNumber_Type,
        .hasIndex = 14,
        .offset = (uint32_t)offsetof(KEYAPISVCV1Camera__storage_, type),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "cameraCategoryId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1Camera_FieldNumber_CameraCategoryId,
        .hasIndex = 15,
        .offset = (uint32_t)offsetof(KEYAPISVCV1Camera__storage_, cameraCategoryId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "rtspURL",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1Camera_FieldNumber_RtspURL,
        .hasIndex = 16,
        .offset = (uint32_t)offsetof(KEYAPISVCV1Camera__storage_, rtspURL),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "serialNumber",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1Camera_FieldNumber_SerialNumber,
        .hasIndex = 17,
        .offset = (uint32_t)offsetof(KEYAPISVCV1Camera__storage_, serialNumber),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "companyId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1Camera_FieldNumber_CompanyId,
        .hasIndex = 18,
        .offset = (uint32_t)offsetof(KEYAPISVCV1Camera__storage_, companyId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1Camera)
                                   messageName:@"Camera"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1Camera__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\017\004\241!!\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KEYAPISVCV1Camera_Type_RawValue(KEYAPISVCV1Camera *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1Camera descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISVCV1Camera_FieldNumber_Type];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISVCV1Camera_Type_RawValue(KEYAPISVCV1Camera *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISVCV1Camera descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISVCV1Camera_FieldNumber_Type];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISVCV1Camera_ValidationError

@implementation KEYAPISVCV1Camera_ValidationError

@dynamic reasonOneOfCase;
@dynamic rtspURLRequired;
@dynamic oneFieldMacOrSerialNumberRequired;

typedef struct KEYAPISVCV1Camera_ValidationError__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1Camera_ValidationError_RtspUrlRequired *rtspURLRequired;
  KEYAPISVCV1Camera_ValidationError_OneFieldMacOrSerialNumberRequired *oneFieldMacOrSerialNumberRequired;
} KEYAPISVCV1Camera_ValidationError__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "rtspURLRequired",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1Camera_ValidationError_RtspUrlRequired),
        .number = KEYAPISVCV1Camera_ValidationError_FieldNumber_RtspURLRequired,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1Camera_ValidationError__storage_, rtspURLRequired),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom),
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "oneFieldMacOrSerialNumberRequired",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1Camera_ValidationError_OneFieldMacOrSerialNumberRequired),
        .number = KEYAPISVCV1Camera_ValidationError_FieldNumber_OneFieldMacOrSerialNumberRequired,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1Camera_ValidationError__storage_, oneFieldMacOrSerialNumberRequired),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1Camera_ValidationError)
                                   messageName:@"ValidationError"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1Camera_ValidationError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    static const char *oneofs[] = {
      "reason",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\001\004\241!!\250\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISVCV1Camera)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISVCV1Camera_ValidationError_RtspUrlRequired


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

@end

#pragma mark - KEYAPISVCV1Camera_ValidationError_OneFieldMacOrSerialNumberRequired

@implementation KEYAPISVCV1Camera_ValidationError_OneFieldMacOrSerialNumberRequired


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

@end

#pragma mark - KEYAPISVCV1CameraFilter

@implementation KEYAPISVCV1CameraFilter

@dynamic hasIsActive, isActive;
@dynamic hasIsChannelAlive, isChannelAlive;
@dynamic hasIsOnline, isOnline;
@dynamic cameraType;

typedef struct KEYAPISVCV1CameraFilter__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISVCV1Camera_Type cameraType;
  GPBBoolValue *isActive;
  GPBBoolValue *isChannelAlive;
  GPBBoolValue *isOnline;
} KEYAPISVCV1CameraFilter__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 = "isActive",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBBoolValue),
        .number = KEYAPISVCV1CameraFilter_FieldNumber_IsActive,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1CameraFilter__storage_, isActive),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "isChannelAlive",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBBoolValue),
        .number = KEYAPISVCV1CameraFilter_FieldNumber_IsChannelAlive,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1CameraFilter__storage_, isChannelAlive),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "isOnline",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBBoolValue),
        .number = KEYAPISVCV1CameraFilter_FieldNumber_IsOnline,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISVCV1CameraFilter__storage_, isOnline),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "cameraType",
        .dataTypeSpecific.enumDescFunc = KEYAPISVCV1Camera_Type_EnumDescriptor,
        .number = KEYAPISVCV1CameraFilter_FieldNumber_CameraType,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISVCV1CameraFilter__storage_, cameraType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1CameraFilter)
                                   messageName:@"CameraFilter"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1CameraFilter__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 KEYAPISVCV1CameraFilter_CameraType_RawValue(KEYAPISVCV1CameraFilter *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1CameraFilter descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISVCV1CameraFilter_FieldNumber_CameraType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISVCV1CameraFilter_CameraType_RawValue(KEYAPISVCV1CameraFilter *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISVCV1CameraFilter descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISVCV1CameraFilter_FieldNumber_CameraType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISVCV1CameraPaging

@implementation KEYAPISVCV1CameraPaging

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

typedef struct KEYAPISVCV1CameraPaging__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISVCV1CameraPaging_OrderByType orderByType;
  KEYAPISVCV1CameraPaging_DirectionType directionType;
  int32_t limit;
  int32_t offset;
} KEYAPISVCV1CameraPaging__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 = KEYAPISVCV1CameraPaging_OrderByType_EnumDescriptor,
        .number = KEYAPISVCV1CameraPaging_FieldNumber_OrderByType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1CameraPaging__storage_, orderByType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "directionType",
        .dataTypeSpecific.enumDescFunc = KEYAPISVCV1CameraPaging_DirectionType_EnumDescriptor,
        .number = KEYAPISVCV1CameraPaging_FieldNumber_DirectionType,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1CameraPaging__storage_, directionType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "limit",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1CameraPaging_FieldNumber_Limit,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KEYAPISVCV1CameraPaging__storage_, limit),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1CameraPaging_FieldNumber_Offset,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KEYAPISVCV1CameraPaging__storage_, offset),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1CameraPaging)
                                   messageName:@"CameraPaging"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1CameraPaging__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 KEYAPISVCV1CameraPaging_OrderByType_RawValue(KEYAPISVCV1CameraPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1CameraPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISVCV1CameraPaging_FieldNumber_OrderByType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISVCV1CameraPaging_OrderByType_RawValue(KEYAPISVCV1CameraPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISVCV1CameraPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISVCV1CameraPaging_FieldNumber_OrderByType];
  GPBSetMessageRawEnumField(message, field, value);
}

int32_t KEYAPISVCV1CameraPaging_DirectionType_RawValue(KEYAPISVCV1CameraPaging *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1CameraPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISVCV1CameraPaging_FieldNumber_DirectionType];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKEYAPISVCV1CameraPaging_DirectionType_RawValue(KEYAPISVCV1CameraPaging *message, int32_t value) {
  GPBDescriptor *descriptor = [KEYAPISVCV1CameraPaging descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KEYAPISVCV1CameraPaging_FieldNumber_DirectionType];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KEYAPISVCV1CameraScope

@implementation KEYAPISVCV1CameraScope

@dynamic vcCompanyId;

typedef struct KEYAPISVCV1CameraScope__storage_ {
  uint32_t _has_storage_[1];
  int32_t vcCompanyId;
} KEYAPISVCV1CameraScope__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 = "vcCompanyId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1CameraScope_FieldNumber_VcCompanyId,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1CameraScope__storage_, vcCompanyId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1CameraScope)
                                   messageName:@"CameraScope"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1CameraScope__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 - KEYAPISVCV1GetCameraListRequest

@implementation KEYAPISVCV1GetCameraListRequest

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

typedef struct KEYAPISVCV1GetCameraListRequest__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1CameraScope *scope;
  KEYAPISVCV1CameraFilter *filter;
  KEYAPISVCV1CameraPaging *paging;
} KEYAPISVCV1GetCameraListRequest__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 = "scope",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1CameraScope),
        .number = KEYAPISVCV1GetCameraListRequest_FieldNumber_Scope,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraListRequest__storage_, scope),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "filter",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1CameraFilter),
        .number = KEYAPISVCV1GetCameraListRequest_FieldNumber_Filter,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraListRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "paging",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1CameraPaging),
        .number = KEYAPISVCV1GetCameraListRequest_FieldNumber_Paging,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraListRequest__storage_, paging),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraListRequest)
                                   messageName:@"GetCameraListRequest"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraListRequest__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 KEYAPISVCV1GetCameraListRequest_ClearPaginationOneOfCase(KEYAPISVCV1GetCameraListRequest *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1GetCameraListRequest descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISVCV1GetCameraListResponse

@implementation KEYAPISVCV1GetCameraListResponse

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

typedef struct KEYAPISVCV1GetCameraListResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1GetCameraListResponse_Data *data_p;
  KEYAPISVCV1GetCameraListResponse_Error *error;
} KEYAPISVCV1GetCameraListResponse__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(KEYAPISVCV1GetCameraListResponse_Data),
        .number = KEYAPISVCV1GetCameraListResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraListResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1GetCameraListResponse_Error),
        .number = KEYAPISVCV1GetCameraListResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraListResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraListResponse)
                                   messageName:@"GetCameraListResponse"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraListResponse__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 KEYAPISVCV1GetCameraListResponse_ClearTypeOneOfCase(KEYAPISVCV1GetCameraListResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1GetCameraListResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISVCV1GetCameraListResponse_Error

@implementation KEYAPISVCV1GetCameraListResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISVCV1GetCameraListResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1ValidationError *validation;
} KEYAPISVCV1GetCameraListResponse_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(KEYAPISVCV1ValidationError),
        .number = KEYAPISVCV1GetCameraListResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraListResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraListResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraListResponse_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(KEYAPISVCV1GetCameraListResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISVCV1GetCameraListResponse_Data

@dynamic itemsArray, itemsArray_Count;
@dynamic total;

typedef struct KEYAPISVCV1GetCameraListResponse_Data__storage_ {
  uint32_t _has_storage_[1];
  int32_t total;
  NSMutableArray *itemsArray;
} KEYAPISVCV1GetCameraListResponse_Data__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 = "itemsArray",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1Camera),
        .number = KEYAPISVCV1GetCameraListResponse_Data_FieldNumber_ItemsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraListResponse_Data__storage_, itemsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "total",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1GetCameraListResponse_Data_FieldNumber_Total,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraListResponse_Data__storage_, total),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraListResponse_Data)
                                   messageName:@"Data"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraListResponse_Data__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISVCV1GetCameraListResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISVCV1GetCameraRequest

@implementation KEYAPISVCV1GetCameraRequest

@dynamic hasScope, scope;
@dynamic uid;

typedef struct KEYAPISVCV1GetCameraRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISVCV1CameraScope *scope;
  NSString *uid;
} KEYAPISVCV1GetCameraRequest__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 = "scope",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1CameraScope),
        .number = KEYAPISVCV1GetCameraRequest_FieldNumber_Scope,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraRequest__storage_, scope),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "uid",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1GetCameraRequest_FieldNumber_Uid,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraRequest__storage_, uid),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraRequest)
                                   messageName:@"GetCameraRequest"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraRequest__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 - KEYAPISVCV1GetCameraResponse

@implementation KEYAPISVCV1GetCameraResponse

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

typedef struct KEYAPISVCV1GetCameraResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1Camera *data_p;
  KEYAPISVCV1GetCameraResponse_Error *error;
} KEYAPISVCV1GetCameraResponse__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(KEYAPISVCV1Camera),
        .number = KEYAPISVCV1GetCameraResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1GetCameraResponse_Error),
        .number = KEYAPISVCV1GetCameraResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraResponse)
                                   messageName:@"GetCameraResponse"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraResponse__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 KEYAPISVCV1GetCameraResponse_ClearTypeOneOfCase(KEYAPISVCV1GetCameraResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1GetCameraResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISVCV1GetCameraResponse_Error

@implementation KEYAPISVCV1GetCameraResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISVCV1GetCameraResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1ValidationError *validation;
} KEYAPISVCV1GetCameraResponse_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(KEYAPISVCV1ValidationError),
        .number = KEYAPISVCV1GetCameraResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraResponse_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(KEYAPISVCV1GetCameraResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISVCV1GetCameraRtspUrlExternalIdRequest

@dynamic externalId;

typedef struct KEYAPISVCV1GetCameraRtspUrlExternalIdRequest__storage_ {
  uint32_t _has_storage_[1];
  NSString *externalId;
} KEYAPISVCV1GetCameraRtspUrlExternalIdRequest__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 = "externalId",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1GetCameraRtspUrlExternalIdRequest_FieldNumber_ExternalId,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraRtspUrlExternalIdRequest__storage_, externalId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraRtspUrlExternalIdRequest)
                                   messageName:@"GetCameraRtspUrlExternalIdRequest"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraRtspUrlExternalIdRequest__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 - KEYAPISVCV1GetCameraRtspUrlExternalIdResponse

@implementation KEYAPISVCV1GetCameraRtspUrlExternalIdResponse

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

typedef struct KEYAPISVCV1GetCameraRtspUrlExternalIdResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_CameraRtspUrl *data_p;
  KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_Error *error;
} KEYAPISVCV1GetCameraRtspUrlExternalIdResponse__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(KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_CameraRtspUrl),
        .number = KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraRtspUrlExternalIdResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_Error),
        .number = KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraRtspUrlExternalIdResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraRtspUrlExternalIdResponse)
                                   messageName:@"GetCameraRtspUrlExternalIdResponse"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraRtspUrlExternalIdResponse__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 KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_ClearTypeOneOfCase(KEYAPISVCV1GetCameraRtspUrlExternalIdResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1GetCameraRtspUrlExternalIdResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_CameraRtspUrl

@implementation KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_CameraRtspUrl

@dynamic rtspURL;

typedef struct KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_CameraRtspUrl__storage_ {
  uint32_t _has_storage_[1];
  NSString *rtspURL;
} KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_CameraRtspUrl__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 = "rtspURL",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_CameraRtspUrl_FieldNumber_RtspURL,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_CameraRtspUrl__storage_, rtspURL),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_CameraRtspUrl)
                                   messageName:@"CameraRtspUrl"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_CameraRtspUrl__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\001\004\241!!\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISVCV1GetCameraRtspUrlExternalIdResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_Error

@implementation KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1ValidationError *validation;
} KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_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(KEYAPISVCV1ValidationError),
        .number = KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraRtspUrlExternalIdResponse_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(KEYAPISVCV1GetCameraRtspUrlExternalIdResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISVCV1PutCameraRoomAttachRequest

@dynamic hasData_p, data_p;

typedef struct KEYAPISVCV1PutCameraRoomAttachRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISVCV1CameraRoom *data_p;
} KEYAPISVCV1PutCameraRoomAttachRequest__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(KEYAPISVCV1CameraRoom),
        .number = KEYAPISVCV1PutCameraRoomAttachRequest_FieldNumber_Data_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1PutCameraRoomAttachRequest__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1PutCameraRoomAttachRequest)
                                   messageName:@"PutCameraRoomAttachRequest"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1PutCameraRoomAttachRequest__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 - KEYAPISVCV1PutCameraRoomAttachResponse

@implementation KEYAPISVCV1PutCameraRoomAttachResponse

@dynamic typeOneOfCase;
@dynamic error;

typedef struct KEYAPISVCV1PutCameraRoomAttachResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1PutCameraRoomAttachResponse_Error *error;
} KEYAPISVCV1PutCameraRoomAttachResponse__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 = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1PutCameraRoomAttachResponse_Error),
        .number = KEYAPISVCV1PutCameraRoomAttachResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1PutCameraRoomAttachResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1PutCameraRoomAttachResponse)
                                   messageName:@"PutCameraRoomAttachResponse"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1PutCameraRoomAttachResponse__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 KEYAPISVCV1PutCameraRoomAttachResponse_ClearTypeOneOfCase(KEYAPISVCV1PutCameraRoomAttachResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1PutCameraRoomAttachResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISVCV1PutCameraRoomAttachResponse_Error

@implementation KEYAPISVCV1PutCameraRoomAttachResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISVCV1PutCameraRoomAttachResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1ValidationError *validation;
} KEYAPISVCV1PutCameraRoomAttachResponse_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(KEYAPISVCV1ValidationError),
        .number = KEYAPISVCV1PutCameraRoomAttachResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1PutCameraRoomAttachResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1PutCameraRoomAttachResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1PutCameraRoomAttachResponse_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(KEYAPISVCV1PutCameraRoomAttachResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISVCV1PutCameraRoomAttachListRequest

@dynamic dataArray, dataArray_Count;

typedef struct KEYAPISVCV1PutCameraRoomAttachListRequest__storage_ {
  uint32_t _has_storage_[1];
  NSMutableArray *dataArray;
} KEYAPISVCV1PutCameraRoomAttachListRequest__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 = "dataArray",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1CameraRoom),
        .number = KEYAPISVCV1PutCameraRoomAttachListRequest_FieldNumber_DataArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISVCV1PutCameraRoomAttachListRequest__storage_, dataArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1PutCameraRoomAttachListRequest)
                                   messageName:@"PutCameraRoomAttachListRequest"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1PutCameraRoomAttachListRequest__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 - KEYAPISVCV1PutCameraRoomAttachListResponse

@implementation KEYAPISVCV1PutCameraRoomAttachListResponse

@dynamic typeOneOfCase;
@dynamic error;

typedef struct KEYAPISVCV1PutCameraRoomAttachListResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1PutCameraRoomAttachListResponse_Error *error;
} KEYAPISVCV1PutCameraRoomAttachListResponse__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 = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1PutCameraRoomAttachListResponse_Error),
        .number = KEYAPISVCV1PutCameraRoomAttachListResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1PutCameraRoomAttachListResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1PutCameraRoomAttachListResponse)
                                   messageName:@"PutCameraRoomAttachListResponse"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1PutCameraRoomAttachListResponse__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 KEYAPISVCV1PutCameraRoomAttachListResponse_ClearTypeOneOfCase(KEYAPISVCV1PutCameraRoomAttachListResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1PutCameraRoomAttachListResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISVCV1PutCameraRoomAttachListResponse_Error

@implementation KEYAPISVCV1PutCameraRoomAttachListResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISVCV1PutCameraRoomAttachListResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1ValidationError *validation;
} KEYAPISVCV1PutCameraRoomAttachListResponse_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(KEYAPISVCV1ValidationError),
        .number = KEYAPISVCV1PutCameraRoomAttachListResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1PutCameraRoomAttachListResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1PutCameraRoomAttachListResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1PutCameraRoomAttachListResponse_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(KEYAPISVCV1PutCameraRoomAttachListResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISVCV1PutCameraRoomDetachRequest

@dynamic hasData_p, data_p;

typedef struct KEYAPISVCV1PutCameraRoomDetachRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISVCV1CameraRoom *data_p;
} KEYAPISVCV1PutCameraRoomDetachRequest__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(KEYAPISVCV1CameraRoom),
        .number = KEYAPISVCV1PutCameraRoomDetachRequest_FieldNumber_Data_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1PutCameraRoomDetachRequest__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1PutCameraRoomDetachRequest)
                                   messageName:@"PutCameraRoomDetachRequest"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1PutCameraRoomDetachRequest__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 - KEYAPISVCV1PutCameraRoomDetachResponse

@implementation KEYAPISVCV1PutCameraRoomDetachResponse

@dynamic typeOneOfCase;
@dynamic error;

typedef struct KEYAPISVCV1PutCameraRoomDetachResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1PutCameraRoomDetachResponse_Error *error;
} KEYAPISVCV1PutCameraRoomDetachResponse__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 = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1PutCameraRoomDetachResponse_Error),
        .number = KEYAPISVCV1PutCameraRoomDetachResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1PutCameraRoomDetachResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1PutCameraRoomDetachResponse)
                                   messageName:@"PutCameraRoomDetachResponse"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1PutCameraRoomDetachResponse__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 KEYAPISVCV1PutCameraRoomDetachResponse_ClearTypeOneOfCase(KEYAPISVCV1PutCameraRoomDetachResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1PutCameraRoomDetachResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISVCV1PutCameraRoomDetachResponse_Error

@implementation KEYAPISVCV1PutCameraRoomDetachResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISVCV1PutCameraRoomDetachResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1ValidationError *validation;
} KEYAPISVCV1PutCameraRoomDetachResponse_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(KEYAPISVCV1ValidationError),
        .number = KEYAPISVCV1PutCameraRoomDetachResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1PutCameraRoomDetachResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1PutCameraRoomDetachResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1PutCameraRoomDetachResponse_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(KEYAPISVCV1PutCameraRoomDetachResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISVCV1PutCameraRoomDetachListRequest

@dynamic dataArray, dataArray_Count;

typedef struct KEYAPISVCV1PutCameraRoomDetachListRequest__storage_ {
  uint32_t _has_storage_[1];
  NSMutableArray *dataArray;
} KEYAPISVCV1PutCameraRoomDetachListRequest__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 = "dataArray",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1CameraRoom),
        .number = KEYAPISVCV1PutCameraRoomDetachListRequest_FieldNumber_DataArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISVCV1PutCameraRoomDetachListRequest__storage_, dataArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1PutCameraRoomDetachListRequest)
                                   messageName:@"PutCameraRoomDetachListRequest"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1PutCameraRoomDetachListRequest__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 - KEYAPISVCV1PutCameraRoomDetachListResponse

@implementation KEYAPISVCV1PutCameraRoomDetachListResponse

@dynamic typeOneOfCase;
@dynamic error;

typedef struct KEYAPISVCV1PutCameraRoomDetachListResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1PutCameraRoomDetachListResponse_Error *error;
} KEYAPISVCV1PutCameraRoomDetachListResponse__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 = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1PutCameraRoomDetachListResponse_Error),
        .number = KEYAPISVCV1PutCameraRoomDetachListResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1PutCameraRoomDetachListResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1PutCameraRoomDetachListResponse)
                                   messageName:@"PutCameraRoomDetachListResponse"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1PutCameraRoomDetachListResponse__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 KEYAPISVCV1PutCameraRoomDetachListResponse_ClearTypeOneOfCase(KEYAPISVCV1PutCameraRoomDetachListResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1PutCameraRoomDetachListResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISVCV1PutCameraRoomDetachListResponse_Error

@implementation KEYAPISVCV1PutCameraRoomDetachListResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISVCV1PutCameraRoomDetachListResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1ValidationError *validation;
} KEYAPISVCV1PutCameraRoomDetachListResponse_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(KEYAPISVCV1ValidationError),
        .number = KEYAPISVCV1PutCameraRoomDetachListResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1PutCameraRoomDetachListResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1PutCameraRoomDetachListResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1PutCameraRoomDetachListResponse_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(KEYAPISVCV1PutCameraRoomDetachListResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISVCV1GetCameraRoomCountRequest

@dynamic hasFilter, filter;

typedef struct KEYAPISVCV1GetCameraRoomCountRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISVCV1CameraRoomFilter *filter;
} KEYAPISVCV1GetCameraRoomCountRequest__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(KEYAPISVCV1CameraRoomFilter),
        .number = KEYAPISVCV1GetCameraRoomCountRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraRoomCountRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraRoomCountRequest)
                                   messageName:@"GetCameraRoomCountRequest"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraRoomCountRequest__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 - KEYAPISVCV1GetCameraRoomCountResponse

@implementation KEYAPISVCV1GetCameraRoomCountResponse

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

typedef struct KEYAPISVCV1GetCameraRoomCountResponse__storage_ {
  uint32_t _has_storage_[2];
  int32_t data_p;
  KEYAPISVCV1GetCameraRoomCountResponse_Error *error;
} KEYAPISVCV1GetCameraRoomCountResponse__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 = KEYAPISVCV1GetCameraRoomCountResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraRoomCountResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeInt32,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1GetCameraRoomCountResponse_Error),
        .number = KEYAPISVCV1GetCameraRoomCountResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraRoomCountResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraRoomCountResponse)
                                   messageName:@"GetCameraRoomCountResponse"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraRoomCountResponse__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 KEYAPISVCV1GetCameraRoomCountResponse_ClearTypeOneOfCase(KEYAPISVCV1GetCameraRoomCountResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1GetCameraRoomCountResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISVCV1GetCameraRoomCountResponse_Error

@implementation KEYAPISVCV1GetCameraRoomCountResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISVCV1GetCameraRoomCountResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1ValidationError *validation;
} KEYAPISVCV1GetCameraRoomCountResponse_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(KEYAPISVCV1ValidationError),
        .number = KEYAPISVCV1GetCameraRoomCountResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraRoomCountResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraRoomCountResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraRoomCountResponse_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(KEYAPISVCV1GetCameraRoomCountResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISVCV1GetCameraRoomListRequest

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

typedef struct KEYAPISVCV1GetCameraRoomListRequest__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1CameraRoomFilter *filter;
  KEYAPISVCV1CameraRoomPaging *paging;
} KEYAPISVCV1GetCameraRoomListRequest__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(KEYAPISVCV1CameraRoomFilter),
        .number = KEYAPISVCV1GetCameraRoomListRequest_FieldNumber_Filter,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraRoomListRequest__storage_, filter),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "paging",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1CameraRoomPaging),
        .number = KEYAPISVCV1GetCameraRoomListRequest_FieldNumber_Paging,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraRoomListRequest__storage_, paging),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraRoomListRequest)
                                   messageName:@"GetCameraRoomListRequest"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraRoomListRequest__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 KEYAPISVCV1GetCameraRoomListRequest_ClearPaginationOneOfCase(KEYAPISVCV1GetCameraRoomListRequest *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1GetCameraRoomListRequest descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISVCV1GetCameraRoomListResponse

@implementation KEYAPISVCV1GetCameraRoomListResponse

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

typedef struct KEYAPISVCV1GetCameraRoomListResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1CameraRoom *data_p;
  KEYAPISVCV1GetCameraRoomListResponse_Error *error;
} KEYAPISVCV1GetCameraRoomListResponse__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(KEYAPISVCV1CameraRoom),
        .number = KEYAPISVCV1GetCameraRoomListResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraRoomListResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1GetCameraRoomListResponse_Error),
        .number = KEYAPISVCV1GetCameraRoomListResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraRoomListResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraRoomListResponse)
                                   messageName:@"GetCameraRoomListResponse"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraRoomListResponse__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 KEYAPISVCV1GetCameraRoomListResponse_ClearTypeOneOfCase(KEYAPISVCV1GetCameraRoomListResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1GetCameraRoomListResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISVCV1GetCameraRoomListResponse_Error

@implementation KEYAPISVCV1GetCameraRoomListResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISVCV1GetCameraRoomListResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1ValidationError *validation;
} KEYAPISVCV1GetCameraRoomListResponse_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(KEYAPISVCV1ValidationError),
        .number = KEYAPISVCV1GetCameraRoomListResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraRoomListResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraRoomListResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraRoomListResponse_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(KEYAPISVCV1GetCameraRoomListResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISVCV1DeleteCameraRequest

@dynamic uid;
@dynamic isDeletePermanently;

typedef struct KEYAPISVCV1DeleteCameraRequest__storage_ {
  uint32_t _has_storage_[1];
  NSString *uid;
} KEYAPISVCV1DeleteCameraRequest__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 = "uid",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1DeleteCameraRequest_FieldNumber_Uid,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1DeleteCameraRequest__storage_, uid),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "isDeletePermanently",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1DeleteCameraRequest_FieldNumber_IsDeletePermanently,
        .hasIndex = 1,
        .offset = 2,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1DeleteCameraRequest)
                                   messageName:@"DeleteCameraRequest"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1DeleteCameraRequest__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 - KEYAPISVCV1DeleteCameraResponse

@implementation KEYAPISVCV1DeleteCameraResponse

@dynamic typeOneOfCase;
@dynamic error;

typedef struct KEYAPISVCV1DeleteCameraResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1DeleteCameraResponse_Error *error;
} KEYAPISVCV1DeleteCameraResponse__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 = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1DeleteCameraResponse_Error),
        .number = KEYAPISVCV1DeleteCameraResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1DeleteCameraResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1DeleteCameraResponse)
                                   messageName:@"DeleteCameraResponse"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1DeleteCameraResponse__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 KEYAPISVCV1DeleteCameraResponse_ClearTypeOneOfCase(KEYAPISVCV1DeleteCameraResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1DeleteCameraResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISVCV1DeleteCameraResponse_Error

@implementation KEYAPISVCV1DeleteCameraResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;

typedef struct KEYAPISVCV1DeleteCameraResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1ValidationError *validation;
} KEYAPISVCV1DeleteCameraResponse_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(KEYAPISVCV1ValidationError),
        .number = KEYAPISVCV1DeleteCameraResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1DeleteCameraResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1DeleteCameraResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1DeleteCameraResponse_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(KEYAPISVCV1DeleteCameraResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISVCV1PostCameraRequest

@dynamic hasData_p, data_p;

typedef struct KEYAPISVCV1PostCameraRequest__storage_ {
  uint32_t _has_storage_[1];
  KEYAPISVCV1Camera *data_p;
} KEYAPISVCV1PostCameraRequest__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(KEYAPISVCV1Camera),
        .number = KEYAPISVCV1PostCameraRequest_FieldNumber_Data_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1PostCameraRequest__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1PostCameraRequest)
                                   messageName:@"PostCameraRequest"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1PostCameraRequest__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 - KEYAPISVCV1PostCameraResponse

@implementation KEYAPISVCV1PostCameraResponse

@dynamic typeOneOfCase;
@dynamic error;

typedef struct KEYAPISVCV1PostCameraResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1PostCameraResponse_Error *error;
} KEYAPISVCV1PostCameraResponse__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 = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1PostCameraResponse_Error),
        .number = KEYAPISVCV1PostCameraResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1PostCameraResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1PostCameraResponse)
                                   messageName:@"PostCameraResponse"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1PostCameraResponse__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 KEYAPISVCV1PostCameraResponse_ClearTypeOneOfCase(KEYAPISVCV1PostCameraResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1PostCameraResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISVCV1PostCameraResponse_Error

@implementation KEYAPISVCV1PostCameraResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;
@dynamic cameraValidation;
@dynamic vc;

typedef struct KEYAPISVCV1PostCameraResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1ValidationError *validation;
  KEYAPISVCV1Camera_ValidationError *cameraValidation;
  KEYAPISVCV1PostCameraResponse_Error_VcError *vc;
} KEYAPISVCV1PostCameraResponse_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(KEYAPISVCV1ValidationError),
        .number = KEYAPISVCV1PostCameraResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1PostCameraResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "cameraValidation",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1Camera_ValidationError),
        .number = KEYAPISVCV1PostCameraResponse_Error_FieldNumber_CameraValidation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1PostCameraResponse_Error__storage_, cameraValidation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "vc",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1PostCameraResponse_Error_VcError),
        .number = KEYAPISVCV1PostCameraResponse_Error_FieldNumber_Vc,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1PostCameraResponse_Error__storage_, vc),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1PostCameraResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1PostCameraResponse_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(KEYAPISVCV1PostCameraResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISVCV1PostCameraResponse_Error_VcError

@dynamic text;

typedef struct KEYAPISVCV1PostCameraResponse_Error_VcError__storage_ {
  uint32_t _has_storage_[1];
  NSString *text;
} KEYAPISVCV1PostCameraResponse_Error_VcError__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 = "text",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1PostCameraResponse_Error_VcError_FieldNumber_Text,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1PostCameraResponse_Error_VcError__storage_, text),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1PostCameraResponse_Error_VcError)
                                   messageName:@"VcError"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1PostCameraResponse_Error_VcError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISVCV1PostCameraResponse_Error)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISVCV1GetCameraCalendarRequest

@implementation KEYAPISVCV1GetCameraCalendarRequest

@dynamic uid;
@dynamic hasOffset, offset;

typedef struct KEYAPISVCV1GetCameraCalendarRequest__storage_ {
  uint32_t _has_storage_[1];
  NSString *uid;
  GPBInt32Value *offset;
} KEYAPISVCV1GetCameraCalendarRequest__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 = "uid",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1GetCameraCalendarRequest_FieldNumber_Uid,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraCalendarRequest__storage_, uid),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISVCV1GetCameraCalendarRequest_FieldNumber_Offset,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraCalendarRequest__storage_, offset),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraCalendarRequest)
                                   messageName:@"GetCameraCalendarRequest"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraCalendarRequest__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 - KEYAPISVCV1GetCameraCalendarResponse

@implementation KEYAPISVCV1GetCameraCalendarResponse

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

typedef struct KEYAPISVCV1GetCameraCalendarResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1GetCameraCalendarResponse_Caledar *data_p;
  KEYAPISVCV1GetCameraCalendarResponse_Error *error;
} KEYAPISVCV1GetCameraCalendarResponse__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(KEYAPISVCV1GetCameraCalendarResponse_Caledar),
        .number = KEYAPISVCV1GetCameraCalendarResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraCalendarResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1GetCameraCalendarResponse_Error),
        .number = KEYAPISVCV1GetCameraCalendarResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraCalendarResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraCalendarResponse)
                                   messageName:@"GetCameraCalendarResponse"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraCalendarResponse__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 KEYAPISVCV1GetCameraCalendarResponse_ClearTypeOneOfCase(KEYAPISVCV1GetCameraCalendarResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1GetCameraCalendarResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISVCV1GetCameraCalendarResponse_Caledar

@implementation KEYAPISVCV1GetCameraCalendarResponse_Caledar

@dynamic itemsArray, itemsArray_Count;

typedef struct KEYAPISVCV1GetCameraCalendarResponse_Caledar__storage_ {
  uint32_t _has_storage_[1];
  NSMutableArray *itemsArray;
} KEYAPISVCV1GetCameraCalendarResponse_Caledar__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 = "itemsArray",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1GetCameraCalendarResponse_Caledar_FieldNumber_ItemsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraCalendarResponse_Caledar__storage_, itemsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraCalendarResponse_Caledar)
                                   messageName:@"Caledar"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraCalendarResponse_Caledar__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISVCV1GetCameraCalendarResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISVCV1GetCameraCalendarResponse_Error

@implementation KEYAPISVCV1GetCameraCalendarResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;
@dynamic vc;

typedef struct KEYAPISVCV1GetCameraCalendarResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1ValidationError *validation;
  KEYAPISVCV1GetCameraCalendarResponse_Error_VcError *vc;
} KEYAPISVCV1GetCameraCalendarResponse_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(KEYAPISVCV1ValidationError),
        .number = KEYAPISVCV1GetCameraCalendarResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraCalendarResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "vc",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1GetCameraCalendarResponse_Error_VcError),
        .number = KEYAPISVCV1GetCameraCalendarResponse_Error_FieldNumber_Vc,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraCalendarResponse_Error__storage_, vc),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraCalendarResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraCalendarResponse_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(KEYAPISVCV1GetCameraCalendarResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISVCV1GetCameraCalendarResponse_Error_VcError

@dynamic text;

typedef struct KEYAPISVCV1GetCameraCalendarResponse_Error_VcError__storage_ {
  uint32_t _has_storage_[1];
  NSString *text;
} KEYAPISVCV1GetCameraCalendarResponse_Error_VcError__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 = "text",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1GetCameraCalendarResponse_Error_VcError_FieldNumber_Text,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraCalendarResponse_Error_VcError__storage_, text),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraCalendarResponse_Error_VcError)
                                   messageName:@"VcError"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraCalendarResponse_Error_VcError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISVCV1GetCameraCalendarResponse_Error)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISVCV1GetCameraIntervalsRequest

@implementation KEYAPISVCV1GetCameraIntervalsRequest

@dynamic uid;
@dynamic hasOffset, offset;

typedef struct KEYAPISVCV1GetCameraIntervalsRequest__storage_ {
  uint32_t _has_storage_[1];
  NSString *uid;
  GPBInt32Value *offset;
} KEYAPISVCV1GetCameraIntervalsRequest__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 = "uid",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1GetCameraIntervalsRequest_FieldNumber_Uid,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraIntervalsRequest__storage_, uid),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "offset",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBInt32Value),
        .number = KEYAPISVCV1GetCameraIntervalsRequest_FieldNumber_Offset,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraIntervalsRequest__storage_, offset),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraIntervalsRequest)
                                   messageName:@"GetCameraIntervalsRequest"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraIntervalsRequest__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 - KEYAPISVCV1GetCameraIntervalsResponse

@implementation KEYAPISVCV1GetCameraIntervalsResponse

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

typedef struct KEYAPISVCV1GetCameraIntervalsResponse__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1GetCameraIntervalsResponse_Interval *data_p;
  KEYAPISVCV1GetCameraIntervalsResponse_Error *error;
} KEYAPISVCV1GetCameraIntervalsResponse__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(KEYAPISVCV1GetCameraIntervalsResponse_Interval),
        .number = KEYAPISVCV1GetCameraIntervalsResponse_FieldNumber_Data_p,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraIntervalsResponse__storage_, data_p),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "error",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1GetCameraIntervalsResponse_Error),
        .number = KEYAPISVCV1GetCameraIntervalsResponse_FieldNumber_Error,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraIntervalsResponse__storage_, error),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraIntervalsResponse)
                                   messageName:@"GetCameraIntervalsResponse"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraIntervalsResponse__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 KEYAPISVCV1GetCameraIntervalsResponse_ClearTypeOneOfCase(KEYAPISVCV1GetCameraIntervalsResponse *message) {
  GPBDescriptor *descriptor = [KEYAPISVCV1GetCameraIntervalsResponse descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - KEYAPISVCV1GetCameraIntervalsResponse_Interval

@implementation KEYAPISVCV1GetCameraIntervalsResponse_Interval

@dynamic itemsArray, itemsArray_Count;

typedef struct KEYAPISVCV1GetCameraIntervalsResponse_Interval__storage_ {
  uint32_t _has_storage_[1];
  NSMutableArray *itemsArray;
} KEYAPISVCV1GetCameraIntervalsResponse_Interval__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 = "itemsArray",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1GetCameraIntervalsResponse_Interval_Item),
        .number = KEYAPISVCV1GetCameraIntervalsResponse_Interval_FieldNumber_ItemsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraIntervalsResponse_Interval__storage_, itemsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraIntervalsResponse_Interval)
                                   messageName:@"Interval"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraIntervalsResponse_Interval__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISVCV1GetCameraIntervalsResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISVCV1GetCameraIntervalsResponse_Interval_Item

@implementation KEYAPISVCV1GetCameraIntervalsResponse_Interval_Item

@dynamic hasSinceAt, sinceAt;
@dynamic hasTillAt, tillAt;

typedef struct KEYAPISVCV1GetCameraIntervalsResponse_Interval_Item__storage_ {
  uint32_t _has_storage_[1];
  GPBTimestamp *sinceAt;
  GPBTimestamp *tillAt;
} KEYAPISVCV1GetCameraIntervalsResponse_Interval_Item__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 = "sinceAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISVCV1GetCameraIntervalsResponse_Interval_Item_FieldNumber_SinceAt,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraIntervalsResponse_Interval_Item__storage_, sinceAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "tillAt",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBTimestamp),
        .number = KEYAPISVCV1GetCameraIntervalsResponse_Interval_Item_FieldNumber_TillAt,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraIntervalsResponse_Interval_Item__storage_, tillAt),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraIntervalsResponse_Interval_Item)
                                   messageName:@"Item"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraIntervalsResponse_Interval_Item__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISVCV1GetCameraIntervalsResponse_Interval)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISVCV1GetCameraIntervalsResponse_Error

@implementation KEYAPISVCV1GetCameraIntervalsResponse_Error

@dynamic reasonOneOfCase;
@dynamic validation;
@dynamic vc;

typedef struct KEYAPISVCV1GetCameraIntervalsResponse_Error__storage_ {
  uint32_t _has_storage_[2];
  KEYAPISVCV1ValidationError *validation;
  KEYAPISVCV1GetCameraIntervalsResponse_Error_VcError *vc;
} KEYAPISVCV1GetCameraIntervalsResponse_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(KEYAPISVCV1ValidationError),
        .number = KEYAPISVCV1GetCameraIntervalsResponse_Error_FieldNumber_Validation,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraIntervalsResponse_Error__storage_, validation),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "vc",
        .dataTypeSpecific.clazz = GPBObjCClass(KEYAPISVCV1GetCameraIntervalsResponse_Error_VcError),
        .number = KEYAPISVCV1GetCameraIntervalsResponse_Error_FieldNumber_Vc,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraIntervalsResponse_Error__storage_, vc),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraIntervalsResponse_Error)
                                   messageName:@"Error"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraIntervalsResponse_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(KEYAPISVCV1GetCameraIntervalsResponse)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

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

@implementation KEYAPISVCV1GetCameraIntervalsResponse_Error_VcError

@dynamic text;

typedef struct KEYAPISVCV1GetCameraIntervalsResponse_Error_VcError__storage_ {
  uint32_t _has_storage_[1];
  NSString *text;
} KEYAPISVCV1GetCameraIntervalsResponse_Error_VcError__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 = "text",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1GetCameraIntervalsResponse_Error_VcError_FieldNumber_Text,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1GetCameraIntervalsResponse_Error_VcError__storage_, text),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1GetCameraIntervalsResponse_Error_VcError)
                                   messageName:@"VcError"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1GetCameraIntervalsResponse_Error_VcError__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KEYAPISVCV1GetCameraIntervalsResponse_Error)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KEYAPISVCV1ValidationError

@implementation KEYAPISVCV1ValidationError

@dynamic path;
@dynamic message;

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

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "path",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1ValidationError_FieldNumber_Path,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KEYAPISVCV1ValidationError__storage_, path),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "message",
        .dataTypeSpecific.clazz = Nil,
        .number = KEYAPISVCV1ValidationError_FieldNumber_Message,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KEYAPISVCV1ValidationError__storage_, message),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(KEYAPISVCV1ValidationError)
                                   messageName:@"ValidationError"
                               fileDescription:&KEYAPISVCV1KeyapisVcCameraV1Root_FileDescription
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KEYAPISVCV1ValidationError__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