path: root/objectivec/google/protobuf/Descriptor.pbobjc.m

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: google/protobuf/descriptor.proto

#import "GPBProtocolBuffers_RuntimeSupport.h"
#import "google/protobuf/Descriptor.pbobjc.h"
// @@protoc_insertion_point(imports)

#pragma mark - GPBDescriptorRoot

@implementation GPBDescriptorRoot

@end

#pragma mark - GPBDescriptorRoot_FileDescriptor

static GPBFileDescriptor *GPBDescriptorRoot_FileDescriptor(void) {
  // This is called by +initialize so there is no need to worry
  // about thread safety of the singleton.
  static GPBFileDescriptor *descriptor = NULL;
  if (!descriptor) {
    GPBDebugCheckRuntimeVersion();
    descriptor = [[GPBFileDescriptor alloc] initWithPackage:@"google.protobuf"
                                                     syntax:GPBFileSyntaxProto2];
  }
  return descriptor;
}

#pragma mark - GPBFileDescriptorSet

@implementation GPBFileDescriptorSet

@dynamic fileArray, fileArray_Count;

typedef struct GPBFileDescriptorSet__storage_ {
  uint32_t _has_storage_[1];
  NSMutableArray *fileArray;
} GPBFileDescriptorSet__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "fileArray",
        .number = GPBFileDescriptorSet_FieldNumber_FileArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBFileDescriptorSet__storage_, fileArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBFileDescriptorProto),
        .fieldOptions = NULL,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBFileDescriptorSet class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:NULL
                                     enumCount:0
                                        ranges:NULL
                                    rangeCount:0
                                   storageSize:sizeof(GPBFileDescriptorSet__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - GPBFileDescriptorProto

@implementation GPBFileDescriptorProto

@dynamic hasName, name;
@dynamic hasPackage, package;
@dynamic dependencyArray, dependencyArray_Count;
@dynamic publicDependencyArray, publicDependencyArray_Count;
@dynamic weakDependencyArray, weakDependencyArray_Count;
@dynamic messageTypeArray, messageTypeArray_Count;
@dynamic enumTypeArray, enumTypeArray_Count;
@dynamic serviceArray, serviceArray_Count;
@dynamic extensionArray, extensionArray_Count;
@dynamic hasOptions, options;
@dynamic hasSourceCodeInfo, sourceCodeInfo;
@dynamic hasSyntax, syntax;

typedef struct GPBFileDescriptorProto__storage_ {
  uint32_t _has_storage_[1];
  NSString *name;
  NSString *package;
  NSMutableArray *dependencyArray;
  NSMutableArray *messageTypeArray;
  NSMutableArray *enumTypeArray;
  NSMutableArray *serviceArray;
  NSMutableArray *extensionArray;
  GPBFileOptions *options;
  GPBSourceCodeInfo *sourceCodeInfo;
  GPBInt32Array *publicDependencyArray;
  GPBInt32Array *weakDependencyArray;
  NSString *syntax;
} GPBFileDescriptorProto__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "name",
        .number = GPBFileDescriptorProto_FieldNumber_Name,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBFileDescriptorProto__storage_, name),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "package",
        .number = GPBFileDescriptorProto_FieldNumber_Package,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBFileDescriptorProto__storage_, package),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "dependencyArray",
        .number = GPBFileDescriptorProto_FieldNumber_DependencyArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBFileDescriptorProto__storage_, dependencyArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "messageTypeArray",
        .number = GPBFileDescriptorProto_FieldNumber_MessageTypeArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBFileDescriptorProto__storage_, messageTypeArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "enumTypeArray",
        .number = GPBFileDescriptorProto_FieldNumber_EnumTypeArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBFileDescriptorProto__storage_, enumTypeArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBEnumDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "serviceArray",
        .number = GPBFileDescriptorProto_FieldNumber_ServiceArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBFileDescriptorProto__storage_, serviceArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBServiceDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "extensionArray",
        .number = GPBFileDescriptorProto_FieldNumber_ExtensionArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBFileDescriptorProto__storage_, extensionArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBFieldDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "options",
        .number = GPBFileDescriptorProto_FieldNumber_Options,
        .hasIndex = 9,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBFileDescriptorProto__storage_, options),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBFileOptions),
        .fieldOptions = NULL,
      },
      {
        .name = "sourceCodeInfo",
        .number = GPBFileDescriptorProto_FieldNumber_SourceCodeInfo,
        .hasIndex = 10,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBFileDescriptorProto__storage_, sourceCodeInfo),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBSourceCodeInfo),
        .fieldOptions = NULL,
      },
      {
        .name = "publicDependencyArray",
        .number = GPBFileDescriptorProto_FieldNumber_PublicDependencyArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeInt32,
        .offset = offsetof(GPBFileDescriptorProto__storage_, publicDependencyArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "weakDependencyArray",
        .number = GPBFileDescriptorProto_FieldNumber_WeakDependencyArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeInt32,
        .offset = offsetof(GPBFileDescriptorProto__storage_, weakDependencyArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "syntax",
        .number = GPBFileDescriptorProto_FieldNumber_Syntax,
        .hasIndex = 11,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBFileDescriptorProto__storage_, syntax),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBFileDescriptorProto class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:NULL
                                     enumCount:0
                                        ranges:NULL
                                    rangeCount:0
                                   storageSize:sizeof(GPBFileDescriptorProto__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - GPBDescriptorProto

@implementation GPBDescriptorProto

@dynamic hasName, name;
@dynamic fieldArray, fieldArray_Count;
@dynamic extensionArray, extensionArray_Count;
@dynamic nestedTypeArray, nestedTypeArray_Count;
@dynamic enumTypeArray, enumTypeArray_Count;
@dynamic extensionRangeArray, extensionRangeArray_Count;
@dynamic oneofDeclArray, oneofDeclArray_Count;
@dynamic hasOptions, options;
@dynamic reservedRangeArray, reservedRangeArray_Count;
@dynamic reservedNameArray, reservedNameArray_Count;

typedef struct GPBDescriptorProto__storage_ {
  uint32_t _has_storage_[1];
  NSString *name;
  NSMutableArray *fieldArray;
  NSMutableArray *nestedTypeArray;
  NSMutableArray *enumTypeArray;
  NSMutableArray *extensionRangeArray;
  NSMutableArray *extensionArray;
  GPBMessageOptions *options;
  NSMutableArray *oneofDeclArray;
  NSMutableArray *reservedRangeArray;
  NSMutableArray *reservedNameArray;
} GPBDescriptorProto__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "name",
        .number = GPBDescriptorProto_FieldNumber_Name,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBDescriptorProto__storage_, name),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "fieldArray",
        .number = GPBDescriptorProto_FieldNumber_FieldArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBDescriptorProto__storage_, fieldArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBFieldDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "nestedTypeArray",
        .number = GPBDescriptorProto_FieldNumber_NestedTypeArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBDescriptorProto__storage_, nestedTypeArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "enumTypeArray",
        .number = GPBDescriptorProto_FieldNumber_EnumTypeArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBDescriptorProto__storage_, enumTypeArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBEnumDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "extensionRangeArray",
        .number = GPBDescriptorProto_FieldNumber_ExtensionRangeArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBDescriptorProto__storage_, extensionRangeArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBDescriptorProto_ExtensionRange),
        .fieldOptions = NULL,
      },
      {
        .name = "extensionArray",
        .number = GPBDescriptorProto_FieldNumber_ExtensionArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBDescriptorProto__storage_, extensionArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBFieldDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "options",
        .number = GPBDescriptorProto_FieldNumber_Options,
        .hasIndex = 7,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBDescriptorProto__storage_, options),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBMessageOptions),
        .fieldOptions = NULL,
      },
      {
        .name = "oneofDeclArray",
        .number = GPBDescriptorProto_FieldNumber_OneofDeclArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBDescriptorProto__storage_, oneofDeclArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBOneofDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "reservedRangeArray",
        .number = GPBDescriptorProto_FieldNumber_ReservedRangeArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBDescriptorProto__storage_, reservedRangeArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBDescriptorProto_ReservedRange),
        .fieldOptions = NULL,
      },
      {
        .name = "reservedNameArray",
        .number = GPBDescriptorProto_FieldNumber_ReservedNameArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBDescriptorProto__storage_, reservedNameArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBDescriptorProto class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:NULL
                                     enumCount:0
                                        ranges:NULL
                                    rangeCount:0
                                   storageSize:sizeof(GPBDescriptorProto__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - GPBDescriptorProto_ExtensionRange

@implementation GPBDescriptorProto_ExtensionRange

@dynamic hasStart, start;
@dynamic hasEnd, end;

typedef struct GPBDescriptorProto_ExtensionRange__storage_ {
  uint32_t _has_storage_[1];
  int32_t start;
  int32_t end;
} GPBDescriptorProto_ExtensionRange__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "start",
        .number = GPBDescriptorProto_ExtensionRange_FieldNumber_Start,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeInt32,
        .offset = offsetof(GPBDescriptorProto_ExtensionRange__storage_, start),
        .defaultValue.valueInt32 = 0,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "end",
        .number = GPBDescriptorProto_ExtensionRange_FieldNumber_End,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeInt32,
        .offset = offsetof(GPBDescriptorProto_ExtensionRange__storage_, end),
        .defaultValue.valueInt32 = 0,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBDescriptorProto_ExtensionRange class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:NULL
                                     enumCount:0
                                        ranges:NULL
                                    rangeCount:0
                                   storageSize:sizeof(GPBDescriptorProto_ExtensionRange__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - GPBDescriptorProto_ReservedRange

@implementation GPBDescriptorProto_ReservedRange

@dynamic hasStart, start;
@dynamic hasEnd, end;

typedef struct GPBDescriptorProto_ReservedRange__storage_ {
  uint32_t _has_storage_[1];
  int32_t start;
  int32_t end;
} GPBDescriptorProto_ReservedRange__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "start",
        .number = GPBDescriptorProto_ReservedRange_FieldNumber_Start,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeInt32,
        .offset = offsetof(GPBDescriptorProto_ReservedRange__storage_, start),
        .defaultValue.valueInt32 = 0,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "end",
        .number = GPBDescriptorProto_ReservedRange_FieldNumber_End,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeInt32,
        .offset = offsetof(GPBDescriptorProto_ReservedRange__storage_, end),
        .defaultValue.valueInt32 = 0,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBDescriptorProto_ReservedRange class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:NULL
                                     enumCount:0
                                        ranges:NULL
                                    rangeCount:0
                                   storageSize:sizeof(GPBDescriptorProto_ReservedRange__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - GPBFieldDescriptorProto

@implementation GPBFieldDescriptorProto

@dynamic hasName, name;
@dynamic hasNumber, number;
@dynamic hasLabel, label;
@dynamic hasType, type;
@dynamic hasTypeName, typeName;
@dynamic hasExtendee, extendee;
@dynamic hasDefaultValue, defaultValue;
@dynamic hasOneofIndex, oneofIndex;
@dynamic hasOptions, options;

typedef struct GPBFieldDescriptorProto__storage_ {
  uint32_t _has_storage_[1];
  int32_t number;
  GPBFieldDescriptorProto_Label label;
  GPBFieldDescriptorProto_Type type;
  int32_t oneofIndex;
  NSString *name;
  NSString *extendee;
  NSString *typeName;
  NSString *defaultValue;
  GPBFieldOptions *options;
} GPBFieldDescriptorProto__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "name",
        .number = GPBFieldDescriptorProto_FieldNumber_Name,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBFieldDescriptorProto__storage_, name),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "extendee",
        .number = GPBFieldDescriptorProto_FieldNumber_Extendee,
        .hasIndex = 5,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBFieldDescriptorProto__storage_, extendee),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "number",
        .number = GPBFieldDescriptorProto_FieldNumber_Number,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeInt32,
        .offset = offsetof(GPBFieldDescriptorProto__storage_, number),
        .defaultValue.valueInt32 = 0,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "label",
        .number = GPBFieldDescriptorProto_FieldNumber_Label,
        .hasIndex = 2,
        .flags = GPBFieldOptional | GPBFieldHasEnumDescriptor,
        .dataType = GPBDataTypeEnum,
        .offset = offsetof(GPBFieldDescriptorProto__storage_, label),
        .defaultValue.valueEnum = GPBFieldDescriptorProto_Label_LabelOptional,
        .dataTypeSpecific.enumDescFunc = GPBFieldDescriptorProto_Label_EnumDescriptor,
        .fieldOptions = NULL,
      },
      {
        .name = "type",
        .number = GPBFieldDescriptorProto_FieldNumber_Type,
        .hasIndex = 3,
        .flags = GPBFieldOptional | GPBFieldHasEnumDescriptor,
        .dataType = GPBDataTypeEnum,
        .offset = offsetof(GPBFieldDescriptorProto__storage_, type),
        .defaultValue.valueEnum = GPBFieldDescriptorProto_Type_TypeDouble,
        .dataTypeSpecific.enumDescFunc = GPBFieldDescriptorProto_Type_EnumDescriptor,
        .fieldOptions = NULL,
      },
      {
        .name = "typeName",
        .number = GPBFieldDescriptorProto_FieldNumber_TypeName,
        .hasIndex = 4,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBFieldDescriptorProto__storage_, typeName),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "defaultValue",
        .number = GPBFieldDescriptorProto_FieldNumber_DefaultValue,
        .hasIndex = 6,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBFieldDescriptorProto__storage_, defaultValue),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "options",
        .number = GPBFieldDescriptorProto_FieldNumber_Options,
        .hasIndex = 8,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBFieldDescriptorProto__storage_, options),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBFieldOptions),
        .fieldOptions = NULL,
      },
      {
        .name = "oneofIndex",
        .number = GPBFieldDescriptorProto_FieldNumber_OneofIndex,
        .hasIndex = 7,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeInt32,
        .offset = offsetof(GPBFieldDescriptorProto__storage_, oneofIndex),
        .defaultValue.valueInt32 = 0,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    static GPBMessageEnumDescription enums[] = {
      { .enumDescriptorFunc = GPBFieldDescriptorProto_Type_EnumDescriptor },
      { .enumDescriptorFunc = GPBFieldDescriptorProto_Label_EnumDescriptor },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBFieldDescriptorProto class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:enums
                                     enumCount:sizeof(enums) / sizeof(GPBMessageEnumDescription)
                                        ranges:NULL
                                    rangeCount:0
                                   storageSize:sizeof(GPBFieldDescriptorProto__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - Enum GPBFieldDescriptorProto_Type

GPBEnumDescriptor *GPBFieldDescriptorProto_Type_EnumDescriptor(void) {
  static GPBEnumDescriptor *descriptor = NULL;
  if (!descriptor) {
    static GPBMessageEnumValueDescription values[] = {
      { .name = "TypeDouble", .number = GPBFieldDescriptorProto_Type_TypeDouble },
      { .name = "TypeFloat", .number = GPBFieldDescriptorProto_Type_TypeFloat },
      { .name = "TypeInt64", .number = GPBFieldDescriptorProto_Type_TypeInt64 },
      { .name = "TypeUint64", .number = GPBFieldDescriptorProto_Type_TypeUint64 },
      { .name = "TypeInt32", .number = GPBFieldDescriptorProto_Type_TypeInt32 },
      { .name = "TypeFixed64", .number = GPBFieldDescriptorProto_Type_TypeFixed64 },
      { .name = "TypeFixed32", .number = GPBFieldDescriptorProto_Type_TypeFixed32 },
      { .name = "TypeBool", .number = GPBFieldDescriptorProto_Type_TypeBool },
      { .name = "TypeString", .number = GPBFieldDescriptorProto_Type_TypeString },
      { .name = "TypeGroup", .number = GPBFieldDescriptorProto_Type_TypeGroup },
      { .name = "TypeMessage", .number = GPBFieldDescriptorProto_Type_TypeMessage },
      { .name = "TypeBytes", .number = GPBFieldDescriptorProto_Type_TypeBytes },
      { .name = "TypeUint32", .number = GPBFieldDescriptorProto_Type_TypeUint32 },
      { .name = "TypeEnum", .number = GPBFieldDescriptorProto_Type_TypeEnum },
      { .name = "TypeSfixed32", .number = GPBFieldDescriptorProto_Type_TypeSfixed32 },
      { .name = "TypeSfixed64", .number = GPBFieldDescriptorProto_Type_TypeSfixed64 },
      { .name = "TypeSint32", .number = GPBFieldDescriptorProto_Type_TypeSint32 },
      { .name = "TypeSint64", .number = GPBFieldDescriptorProto_Type_TypeSint64 },
    };
    descriptor = [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GPBFieldDescriptorProto_Type)
                                                   values:values
                                               valueCount:sizeof(values) / sizeof(GPBMessageEnumValueDescription)
                                             enumVerifier:GPBFieldDescriptorProto_Type_IsValidValue];
  }
  return descriptor;
}

BOOL GPBFieldDescriptorProto_Type_IsValidValue(int32_t value__) {
  switch (value__) {
    case GPBFieldDescriptorProto_Type_TypeDouble:
    case GPBFieldDescriptorProto_Type_TypeFloat:
    case GPBFieldDescriptorProto_Type_TypeInt64:
    case GPBFieldDescriptorProto_Type_TypeUint64:
    case GPBFieldDescriptorProto_Type_TypeInt32:
    case GPBFieldDescriptorProto_Type_TypeFixed64:
    case GPBFieldDescriptorProto_Type_TypeFixed32:
    case GPBFieldDescriptorProto_Type_TypeBool:
    case GPBFieldDescriptorProto_Type_TypeString:
    case GPBFieldDescriptorProto_Type_TypeGroup:
    case GPBFieldDescriptorProto_Type_TypeMessage:
    case GPBFieldDescriptorProto_Type_TypeBytes:
    case GPBFieldDescriptorProto_Type_TypeUint32:
    case GPBFieldDescriptorProto_Type_TypeEnum:
    case GPBFieldDescriptorProto_Type_TypeSfixed32:
    case GPBFieldDescriptorProto_Type_TypeSfixed64:
    case GPBFieldDescriptorProto_Type_TypeSint32:
    case GPBFieldDescriptorProto_Type_TypeSint64:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum GPBFieldDescriptorProto_Label

GPBEnumDescriptor *GPBFieldDescriptorProto_Label_EnumDescriptor(void) {
  static GPBEnumDescriptor *descriptor = NULL;
  if (!descriptor) {
    static GPBMessageEnumValueDescription values[] = {
      { .name = "LabelOptional", .number = GPBFieldDescriptorProto_Label_LabelOptional },
      { .name = "LabelRequired", .number = GPBFieldDescriptorProto_Label_LabelRequired },
      { .name = "LabelRepeated", .number = GPBFieldDescriptorProto_Label_LabelRepeated },
    };
    descriptor = [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GPBFieldDescriptorProto_Label)
                                                   values:values
                                               valueCount:sizeof(values) / sizeof(GPBMessageEnumValueDescription)
                                             enumVerifier:GPBFieldDescriptorProto_Label_IsValidValue];
  }
  return descriptor;
}

BOOL GPBFieldDescriptorProto_Label_IsValidValue(int32_t value__) {
  switch (value__) {
    case GPBFieldDescriptorProto_Label_LabelOptional:
    case GPBFieldDescriptorProto_Label_LabelRequired:
    case GPBFieldDescriptorProto_Label_LabelRepeated:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - GPBOneofDescriptorProto

@implementation GPBOneofDescriptorProto

@dynamic hasName, name;

typedef struct GPBOneofDescriptorProto__storage_ {
  uint32_t _has_storage_[1];
  NSString *name;
} GPBOneofDescriptorProto__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "name",
        .number = GPBOneofDescriptorProto_FieldNumber_Name,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBOneofDescriptorProto__storage_, name),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBOneofDescriptorProto class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:NULL
                                     enumCount:0
                                        ranges:NULL
                                    rangeCount:0
                                   storageSize:sizeof(GPBOneofDescriptorProto__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - GPBEnumDescriptorProto

@implementation GPBEnumDescriptorProto

@dynamic hasName, name;
@dynamic valueArray, valueArray_Count;
@dynamic hasOptions, options;

typedef struct GPBEnumDescriptorProto__storage_ {
  uint32_t _has_storage_[1];
  NSString *name;
  NSMutableArray *valueArray;
  GPBEnumOptions *options;
} GPBEnumDescriptorProto__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "name",
        .number = GPBEnumDescriptorProto_FieldNumber_Name,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBEnumDescriptorProto__storage_, name),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "valueArray",
        .number = GPBEnumDescriptorProto_FieldNumber_ValueArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBEnumDescriptorProto__storage_, valueArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBEnumValueDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "options",
        .number = GPBEnumDescriptorProto_FieldNumber_Options,
        .hasIndex = 2,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBEnumDescriptorProto__storage_, options),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBEnumOptions),
        .fieldOptions = NULL,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBEnumDescriptorProto class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:NULL
                                     enumCount:0
                                        ranges:NULL
                                    rangeCount:0
                                   storageSize:sizeof(GPBEnumDescriptorProto__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - GPBEnumValueDescriptorProto

@implementation GPBEnumValueDescriptorProto

@dynamic hasName, name;
@dynamic hasNumber, number;
@dynamic hasOptions, options;

typedef struct GPBEnumValueDescriptorProto__storage_ {
  uint32_t _has_storage_[1];
  int32_t number;
  NSString *name;
  GPBEnumValueOptions *options;
} GPBEnumValueDescriptorProto__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "name",
        .number = GPBEnumValueDescriptorProto_FieldNumber_Name,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBEnumValueDescriptorProto__storage_, name),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "number",
        .number = GPBEnumValueDescriptorProto_FieldNumber_Number,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeInt32,
        .offset = offsetof(GPBEnumValueDescriptorProto__storage_, number),
        .defaultValue.valueInt32 = 0,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "options",
        .number = GPBEnumValueDescriptorProto_FieldNumber_Options,
        .hasIndex = 2,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBEnumValueDescriptorProto__storage_, options),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBEnumValueOptions),
        .fieldOptions = NULL,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBEnumValueDescriptorProto class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:NULL
                                     enumCount:0
                                        ranges:NULL
                                    rangeCount:0
                                   storageSize:sizeof(GPBEnumValueDescriptorProto__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - GPBServiceDescriptorProto

@implementation GPBServiceDescriptorProto

@dynamic hasName, name;
@dynamic methodArray, methodArray_Count;
@dynamic hasOptions, options;

typedef struct GPBServiceDescriptorProto__storage_ {
  uint32_t _has_storage_[1];
  NSString *name;
  NSMutableArray *methodArray;
  GPBServiceOptions *options;
} GPBServiceDescriptorProto__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "name",
        .number = GPBServiceDescriptorProto_FieldNumber_Name,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBServiceDescriptorProto__storage_, name),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "methodArray",
        .number = GPBServiceDescriptorProto_FieldNumber_MethodArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBServiceDescriptorProto__storage_, methodArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBMethodDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "options",
        .number = GPBServiceDescriptorProto_FieldNumber_Options,
        .hasIndex = 2,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBServiceDescriptorProto__storage_, options),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBServiceOptions),
        .fieldOptions = NULL,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBServiceDescriptorProto class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:NULL
                                     enumCount:0
                                        ranges:NULL
                                    rangeCount:0
                                   storageSize:sizeof(GPBServiceDescriptorProto__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - GPBMethodDescriptorProto

@implementation GPBMethodDescriptorProto

@dynamic hasName, name;
@dynamic hasInputType, inputType;
@dynamic hasOutputType, outputType;
@dynamic hasOptions, options;
@dynamic hasClientStreaming, clientStreaming;
@dynamic hasServerStreaming, serverStreaming;

typedef struct GPBMethodDescriptorProto__storage_ {
  uint32_t _has_storage_[1];
  BOOL clientStreaming;
  BOOL serverStreaming;
  NSString *name;
  NSString *inputType;
  NSString *outputType;
  GPBMethodOptions *options;
} GPBMethodDescriptorProto__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "name",
        .number = GPBMethodDescriptorProto_FieldNumber_Name,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBMethodDescriptorProto__storage_, name),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "inputType",
        .number = GPBMethodDescriptorProto_FieldNumber_InputType,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBMethodDescriptorProto__storage_, inputType),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "outputType",
        .number = GPBMethodDescriptorProto_FieldNumber_OutputType,
        .hasIndex = 2,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBMethodDescriptorProto__storage_, outputType),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "options",
        .number = GPBMethodDescriptorProto_FieldNumber_Options,
        .hasIndex = 3,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBMethodDescriptorProto__storage_, options),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBMethodOptions),
        .fieldOptions = NULL,
      },
      {
        .name = "clientStreaming",
        .number = GPBMethodDescriptorProto_FieldNumber_ClientStreaming,
        .hasIndex = 4,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBMethodDescriptorProto__storage_, clientStreaming),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "serverStreaming",
        .number = GPBMethodDescriptorProto_FieldNumber_ServerStreaming,
        .hasIndex = 5,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBMethodDescriptorProto__storage_, serverStreaming),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBMethodDescriptorProto class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:NULL
                                     enumCount:0
                                        ranges:NULL
                                    rangeCount:0
                                   storageSize:sizeof(GPBMethodDescriptorProto__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - GPBFileOptions

@implementation GPBFileOptions

@dynamic hasJavaPackage, javaPackage;
@dynamic hasJavaOuterClassname, javaOuterClassname;
@dynamic hasJavaMultipleFiles, javaMultipleFiles;
@dynamic hasJavaGenerateEqualsAndHash, javaGenerateEqualsAndHash;
@dynamic hasJavaStringCheckUtf8, javaStringCheckUtf8;
@dynamic hasOptimizeFor, optimizeFor;
@dynamic hasGoPackage, goPackage;
@dynamic hasCcGenericServices, ccGenericServices;
@dynamic hasJavaGenericServices, javaGenericServices;
@dynamic hasPyGenericServices, pyGenericServices;
@dynamic hasDeprecated, deprecated;
@dynamic hasCcEnableArenas, ccEnableArenas;
@dynamic hasObjcClassPrefix, objcClassPrefix;
@dynamic hasCsharpNamespace, csharpNamespace;
@dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;

typedef struct GPBFileOptions__storage_ {
  uint32_t _has_storage_[1];
  BOOL javaMultipleFiles;
  BOOL ccGenericServices;
  BOOL javaGenericServices;
  BOOL pyGenericServices;
  BOOL javaGenerateEqualsAndHash;
  BOOL deprecated;
  BOOL javaStringCheckUtf8;
  BOOL ccEnableArenas;
  GPBFileOptions_OptimizeMode optimizeFor;
  NSString *javaPackage;
  NSString *javaOuterClassname;
  NSString *goPackage;
  NSString *objcClassPrefix;
  NSString *csharpNamespace;
  NSMutableArray *uninterpretedOptionArray;
} GPBFileOptions__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "javaPackage",
        .number = GPBFileOptions_FieldNumber_JavaPackage,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBFileOptions__storage_, javaPackage),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "javaOuterClassname",
        .number = GPBFileOptions_FieldNumber_JavaOuterClassname,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBFileOptions__storage_, javaOuterClassname),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "optimizeFor",
        .number = GPBFileOptions_FieldNumber_OptimizeFor,
        .hasIndex = 5,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue | GPBFieldHasEnumDescriptor,
        .dataType = GPBDataTypeEnum,
        .offset = offsetof(GPBFileOptions__storage_, optimizeFor),
        .defaultValue.valueEnum = GPBFileOptions_OptimizeMode_Speed,
        .dataTypeSpecific.enumDescFunc = GPBFileOptions_OptimizeMode_EnumDescriptor,
        .fieldOptions = NULL,
      },
      {
        .name = "javaMultipleFiles",
        .number = GPBFileOptions_FieldNumber_JavaMultipleFiles,
        .hasIndex = 2,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBFileOptions__storage_, javaMultipleFiles),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "goPackage",
        .number = GPBFileOptions_FieldNumber_GoPackage,
        .hasIndex = 6,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBFileOptions__storage_, goPackage),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "ccGenericServices",
        .number = GPBFileOptions_FieldNumber_CcGenericServices,
        .hasIndex = 7,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBFileOptions__storage_, ccGenericServices),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "javaGenericServices",
        .number = GPBFileOptions_FieldNumber_JavaGenericServices,
        .hasIndex = 8,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBFileOptions__storage_, javaGenericServices),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "pyGenericServices",
        .number = GPBFileOptions_FieldNumber_PyGenericServices,
        .hasIndex = 9,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBFileOptions__storage_, pyGenericServices),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "javaGenerateEqualsAndHash",
        .number = GPBFileOptions_FieldNumber_JavaGenerateEqualsAndHash,
        .hasIndex = 3,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBFileOptions__storage_, javaGenerateEqualsAndHash),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "deprecated",
        .number = GPBFileOptions_FieldNumber_Deprecated,
        .hasIndex = 10,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBFileOptions__storage_, deprecated),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "javaStringCheckUtf8",
        .number = GPBFileOptions_FieldNumber_JavaStringCheckUtf8,
        .hasIndex = 4,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBFileOptions__storage_, javaStringCheckUtf8),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "ccEnableArenas",
        .number = GPBFileOptions_FieldNumber_CcEnableArenas,
        .hasIndex = 11,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBFileOptions__storage_, ccEnableArenas),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "objcClassPrefix",
        .number = GPBFileOptions_FieldNumber_ObjcClassPrefix,
        .hasIndex = 12,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBFileOptions__storage_, objcClassPrefix),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "csharpNamespace",
        .number = GPBFileOptions_FieldNumber_CsharpNamespace,
        .hasIndex = 13,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBFileOptions__storage_, csharpNamespace),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "uninterpretedOptionArray",
        .number = GPBFileOptions_FieldNumber_UninterpretedOptionArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBFileOptions__storage_, uninterpretedOptionArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
        .fieldOptions = NULL,
      },
    };
    static GPBMessageEnumDescription enums[] = {
      { .enumDescriptorFunc = GPBFileOptions_OptimizeMode_EnumDescriptor },
    };
    static GPBExtensionRange ranges[] = {
      { .start = 1000, .end = 536870912 },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBFileOptions class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:enums
                                     enumCount:sizeof(enums) / sizeof(GPBMessageEnumDescription)
                                        ranges:ranges
                                    rangeCount:sizeof(ranges) / sizeof(GPBExtensionRange)
                                   storageSize:sizeof(GPBFileOptions__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - Enum GPBFileOptions_OptimizeMode

GPBEnumDescriptor *GPBFileOptions_OptimizeMode_EnumDescriptor(void) {
  static GPBEnumDescriptor *descriptor = NULL;
  if (!descriptor) {
    static GPBMessageEnumValueDescription values[] = {
      { .name = "Speed", .number = GPBFileOptions_OptimizeMode_Speed },
      { .name = "CodeSize", .number = GPBFileOptions_OptimizeMode_CodeSize },
      { .name = "LiteRuntime", .number = GPBFileOptions_OptimizeMode_LiteRuntime },
    };
    descriptor = [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GPBFileOptions_OptimizeMode)
                                                   values:values
                                               valueCount:sizeof(values) / sizeof(GPBMessageEnumValueDescription)
                                             enumVerifier:GPBFileOptions_OptimizeMode_IsValidValue];
  }
  return descriptor;
}

BOOL GPBFileOptions_OptimizeMode_IsValidValue(int32_t value__) {
  switch (value__) {
    case GPBFileOptions_OptimizeMode_Speed:
    case GPBFileOptions_OptimizeMode_CodeSize:
    case GPBFileOptions_OptimizeMode_LiteRuntime:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - GPBMessageOptions

@implementation GPBMessageOptions

@dynamic hasMessageSetWireFormat, messageSetWireFormat;
@dynamic hasNoStandardDescriptorAccessor, noStandardDescriptorAccessor;
@dynamic hasDeprecated, deprecated;
@dynamic hasMapEntry, mapEntry;
@dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;

typedef struct GPBMessageOptions__storage_ {
  uint32_t _has_storage_[1];
  BOOL messageSetWireFormat;
  BOOL noStandardDescriptorAccessor;
  BOOL deprecated;
  BOOL mapEntry;
  NSMutableArray *uninterpretedOptionArray;
} GPBMessageOptions__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "messageSetWireFormat",
        .number = GPBMessageOptions_FieldNumber_MessageSetWireFormat,
        .hasIndex = 0,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBMessageOptions__storage_, messageSetWireFormat),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "noStandardDescriptorAccessor",
        .number = GPBMessageOptions_FieldNumber_NoStandardDescriptorAccessor,
        .hasIndex = 1,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBMessageOptions__storage_, noStandardDescriptorAccessor),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "deprecated",
        .number = GPBMessageOptions_FieldNumber_Deprecated,
        .hasIndex = 2,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBMessageOptions__storage_, deprecated),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "mapEntry",
        .number = GPBMessageOptions_FieldNumber_MapEntry,
        .hasIndex = 3,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBMessageOptions__storage_, mapEntry),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "uninterpretedOptionArray",
        .number = GPBMessageOptions_FieldNumber_UninterpretedOptionArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBMessageOptions__storage_, uninterpretedOptionArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
        .fieldOptions = NULL,
      },
    };
    static GPBExtensionRange ranges[] = {
      { .start = 1000, .end = 536870912 },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBMessageOptions class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:NULL
                                     enumCount:0
                                        ranges:ranges
                                    rangeCount:sizeof(ranges) / sizeof(GPBExtensionRange)
                                   storageSize:sizeof(GPBMessageOptions__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - GPBFieldOptions

@implementation GPBFieldOptions

@dynamic hasCtype, ctype;
@dynamic hasPacked, packed;
@dynamic hasJstype, jstype;
@dynamic hasLazy, lazy;
@dynamic hasDeprecated, deprecated;
@dynamic hasWeak, weak;
@dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;

typedef struct GPBFieldOptions__storage_ {
  uint32_t _has_storage_[1];
  BOOL packed;
  BOOL deprecated;
  BOOL lazy;
  BOOL weak;
  GPBFieldOptions_CType ctype;
  GPBFieldOptions_JSType jstype;
  NSMutableArray *uninterpretedOptionArray;
} GPBFieldOptions__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "ctype",
        .number = GPBFieldOptions_FieldNumber_Ctype,
        .hasIndex = 0,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue | GPBFieldHasEnumDescriptor,
        .dataType = GPBDataTypeEnum,
        .offset = offsetof(GPBFieldOptions__storage_, ctype),
        .defaultValue.valueEnum = GPBFieldOptions_CType_String,
        .dataTypeSpecific.enumDescFunc = GPBFieldOptions_CType_EnumDescriptor,
        .fieldOptions = NULL,
      },
      {
        .name = "packed",
        .number = GPBFieldOptions_FieldNumber_Packed,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBFieldOptions__storage_, packed),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "deprecated",
        .number = GPBFieldOptions_FieldNumber_Deprecated,
        .hasIndex = 4,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBFieldOptions__storage_, deprecated),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "lazy",
        .number = GPBFieldOptions_FieldNumber_Lazy,
        .hasIndex = 3,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBFieldOptions__storage_, lazy),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "jstype",
        .number = GPBFieldOptions_FieldNumber_Jstype,
        .hasIndex = 2,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue | GPBFieldHasEnumDescriptor,
        .dataType = GPBDataTypeEnum,
        .offset = offsetof(GPBFieldOptions__storage_, jstype),
        .defaultValue.valueEnum = GPBFieldOptions_JSType_JsNormal,
        .dataTypeSpecific.enumDescFunc = GPBFieldOptions_JSType_EnumDescriptor,
        .fieldOptions = NULL,
      },
      {
        .name = "weak",
        .number = GPBFieldOptions_FieldNumber_Weak,
        .hasIndex = 5,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBFieldOptions__storage_, weak),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "uninterpretedOptionArray",
        .number = GPBFieldOptions_FieldNumber_UninterpretedOptionArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBFieldOptions__storage_, uninterpretedOptionArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
        .fieldOptions = NULL,
      },
    };
    static GPBMessageEnumDescription enums[] = {
      { .enumDescriptorFunc = GPBFieldOptions_CType_EnumDescriptor },
      { .enumDescriptorFunc = GPBFieldOptions_JSType_EnumDescriptor },
    };
    static GPBExtensionRange ranges[] = {
      { .start = 1000, .end = 536870912 },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBFieldOptions class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:enums
                                     enumCount:sizeof(enums) / sizeof(GPBMessageEnumDescription)
                                        ranges:ranges
                                    rangeCount:sizeof(ranges) / sizeof(GPBExtensionRange)
                                   storageSize:sizeof(GPBFieldOptions__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - Enum GPBFieldOptions_CType

GPBEnumDescriptor *GPBFieldOptions_CType_EnumDescriptor(void) {
  static GPBEnumDescriptor *descriptor = NULL;
  if (!descriptor) {
    static GPBMessageEnumValueDescription values[] = {
      { .name = "String", .number = GPBFieldOptions_CType_String },
      { .name = "Cord", .number = GPBFieldOptions_CType_Cord },
      { .name = "StringPiece", .number = GPBFieldOptions_CType_StringPiece },
    };
    descriptor = [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GPBFieldOptions_CType)
                                                   values:values
                                               valueCount:sizeof(values) / sizeof(GPBMessageEnumValueDescription)
                                             enumVerifier:GPBFieldOptions_CType_IsValidValue];
  }
  return descriptor;
}

BOOL GPBFieldOptions_CType_IsValidValue(int32_t value__) {
  switch (value__) {
    case GPBFieldOptions_CType_String:
    case GPBFieldOptions_CType_Cord:
    case GPBFieldOptions_CType_StringPiece:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - Enum GPBFieldOptions_JSType

GPBEnumDescriptor *GPBFieldOptions_JSType_EnumDescriptor(void) {
  static GPBEnumDescriptor *descriptor = NULL;
  if (!descriptor) {
    static GPBMessageEnumValueDescription values[] = {
      { .name = "JsNormal", .number = GPBFieldOptions_JSType_JsNormal },
      { .name = "JsString", .number = GPBFieldOptions_JSType_JsString },
      { .name = "JsNumber", .number = GPBFieldOptions_JSType_JsNumber },
    };
    descriptor = [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GPBFieldOptions_JSType)
                                                   values:values
                                               valueCount:sizeof(values) / sizeof(GPBMessageEnumValueDescription)
                                             enumVerifier:GPBFieldOptions_JSType_IsValidValue];
  }
  return descriptor;
}

BOOL GPBFieldOptions_JSType_IsValidValue(int32_t value__) {
  switch (value__) {
    case GPBFieldOptions_JSType_JsNormal:
    case GPBFieldOptions_JSType_JsString:
    case GPBFieldOptions_JSType_JsNumber:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - GPBEnumOptions

@implementation GPBEnumOptions

@dynamic hasAllowAlias, allowAlias;
@dynamic hasDeprecated, deprecated;
@dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;

typedef struct GPBEnumOptions__storage_ {
  uint32_t _has_storage_[1];
  BOOL allowAlias;
  BOOL deprecated;
  NSMutableArray *uninterpretedOptionArray;
} GPBEnumOptions__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "allowAlias",
        .number = GPBEnumOptions_FieldNumber_AllowAlias,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBEnumOptions__storage_, allowAlias),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "deprecated",
        .number = GPBEnumOptions_FieldNumber_Deprecated,
        .hasIndex = 1,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBEnumOptions__storage_, deprecated),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "uninterpretedOptionArray",
        .number = GPBEnumOptions_FieldNumber_UninterpretedOptionArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBEnumOptions__storage_, uninterpretedOptionArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
        .fieldOptions = NULL,
      },
    };
    static GPBExtensionRange ranges[] = {
      { .start = 1000, .end = 536870912 },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBEnumOptions class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:NULL
                                     enumCount:0
                                        ranges:ranges
                                    rangeCount:sizeof(ranges) / sizeof(GPBExtensionRange)
                                   storageSize:sizeof(GPBEnumOptions__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - GPBEnumValueOptions

@implementation GPBEnumValueOptions

@dynamic hasDeprecated, deprecated;
@dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;

typedef struct GPBEnumValueOptions__storage_ {
  uint32_t _has_storage_[1];
  BOOL deprecated;
  NSMutableArray *uninterpretedOptionArray;
} GPBEnumValueOptions__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "deprecated",
        .number = GPBEnumValueOptions_FieldNumber_Deprecated,
        .hasIndex = 0,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBEnumValueOptions__storage_, deprecated),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "uninterpretedOptionArray",
        .number = GPBEnumValueOptions_FieldNumber_UninterpretedOptionArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBEnumValueOptions__storage_, uninterpretedOptionArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
        .fieldOptions = NULL,
      },
    };
    static GPBExtensionRange ranges[] = {
      { .start = 1000, .end = 536870912 },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBEnumValueOptions class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:NULL
                                     enumCount:0
                                        ranges:ranges
                                    rangeCount:sizeof(ranges) / sizeof(GPBExtensionRange)
                                   storageSize:sizeof(GPBEnumValueOptions__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - GPBServiceOptions

@implementation GPBServiceOptions

@dynamic hasDeprecated, deprecated;
@dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;

typedef struct GPBServiceOptions__storage_ {
  uint32_t _has_storage_[1];
  BOOL deprecated;
  NSMutableArray *uninterpretedOptionArray;
} GPBServiceOptions__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "deprecated",
        .number = GPBServiceOptions_FieldNumber_Deprecated,
        .hasIndex = 0,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBServiceOptions__storage_, deprecated),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "uninterpretedOptionArray",
        .number = GPBServiceOptions_FieldNumber_UninterpretedOptionArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBServiceOptions__storage_, uninterpretedOptionArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
        .fieldOptions = NULL,
      },
    };
    static GPBExtensionRange ranges[] = {
      { .start = 1000, .end = 536870912 },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBServiceOptions class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:NULL
                                     enumCount:0
                                        ranges:ranges
                                    rangeCount:sizeof(ranges) / sizeof(GPBExtensionRange)
                                   storageSize:sizeof(GPBServiceOptions__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - GPBMethodOptions

@implementation GPBMethodOptions

@dynamic hasDeprecated, deprecated;
@dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;

typedef struct GPBMethodOptions__storage_ {
  uint32_t _has_storage_[1];
  BOOL deprecated;
  NSMutableArray *uninterpretedOptionArray;
} GPBMethodOptions__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "deprecated",
        .number = GPBMethodOptions_FieldNumber_Deprecated,
        .hasIndex = 0,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBMethodOptions__storage_, deprecated),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "uninterpretedOptionArray",
        .number = GPBMethodOptions_FieldNumber_UninterpretedOptionArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBMethodOptions__storage_, uninterpretedOptionArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
        .fieldOptions = NULL,
      },
    };
    static GPBExtensionRange ranges[] = {
      { .start = 1000, .end = 536870912 },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBMethodOptions class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:NULL
                                     enumCount:0
                                        ranges:ranges
                                    rangeCount:sizeof(ranges) / sizeof(GPBExtensionRange)
                                   storageSize:sizeof(GPBMethodOptions__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - GPBUninterpretedOption

@implementation GPBUninterpretedOption

@dynamic nameArray, nameArray_Count;
@dynamic hasIdentifierValue, identifierValue;
@dynamic hasPositiveIntValue, positiveIntValue;
@dynamic hasNegativeIntValue, negativeIntValue;
@dynamic hasDoubleValue, doubleValue;
@dynamic hasStringValue, stringValue;
@dynamic hasAggregateValue, aggregateValue;

typedef struct GPBUninterpretedOption__storage_ {
  uint32_t _has_storage_[1];
  NSMutableArray *nameArray;
  NSString *identifierValue;
  NSData *stringValue;
  NSString *aggregateValue;
  uint64_t positiveIntValue;
  int64_t negativeIntValue;
  double doubleValue;
} GPBUninterpretedOption__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "nameArray",
        .number = GPBUninterpretedOption_FieldNumber_NameArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBUninterpretedOption__storage_, nameArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption_NamePart),
        .fieldOptions = NULL,
      },
      {
        .name = "identifierValue",
        .number = GPBUninterpretedOption_FieldNumber_IdentifierValue,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBUninterpretedOption__storage_, identifierValue),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "positiveIntValue",
        .number = GPBUninterpretedOption_FieldNumber_PositiveIntValue,
        .hasIndex = 2,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeUInt64,
        .offset = offsetof(GPBUninterpretedOption__storage_, positiveIntValue),
        .defaultValue.valueUInt64 = 0ULL,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "negativeIntValue",
        .number = GPBUninterpretedOption_FieldNumber_NegativeIntValue,
        .hasIndex = 3,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeInt64,
        .offset = offsetof(GPBUninterpretedOption__storage_, negativeIntValue),
        .defaultValue.valueInt64 = 0LL,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "doubleValue",
        .number = GPBUninterpretedOption_FieldNumber_DoubleValue,
        .hasIndex = 4,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeDouble,
        .offset = offsetof(GPBUninterpretedOption__storage_, doubleValue),
        .defaultValue.valueDouble = 0,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "stringValue",
        .number = GPBUninterpretedOption_FieldNumber_StringValue,
        .hasIndex = 5,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeBytes,
        .offset = offsetof(GPBUninterpretedOption__storage_, stringValue),
        .defaultValue.valueData = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "aggregateValue",
        .number = GPBUninterpretedOption_FieldNumber_AggregateValue,
        .hasIndex = 6,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBUninterpretedOption__storage_, aggregateValue),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBUninterpretedOption class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:NULL
                                     enumCount:0
                                        ranges:NULL
                                    rangeCount:0
                                   storageSize:sizeof(GPBUninterpretedOption__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - GPBUninterpretedOption_NamePart

@implementation GPBUninterpretedOption_NamePart

@dynamic hasNamePart, namePart;
@dynamic hasIsExtension, isExtension;

typedef struct GPBUninterpretedOption_NamePart__storage_ {
  uint32_t _has_storage_[1];
  BOOL isExtension;
  NSString *namePart;
} GPBUninterpretedOption_NamePart__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "namePart",
        .number = GPBUninterpretedOption_NamePart_FieldNumber_NamePart,
        .hasIndex = 0,
        .flags = GPBFieldRequired,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBUninterpretedOption_NamePart__storage_, namePart),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "isExtension",
        .number = GPBUninterpretedOption_NamePart_FieldNumber_IsExtension,
        .hasIndex = 1,
        .flags = GPBFieldRequired,
        .dataType = GPBDataTypeBool,
        .offset = offsetof(GPBUninterpretedOption_NamePart__storage_, isExtension),
        .defaultValue.valueBool = NO,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBUninterpretedOption_NamePart class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:NULL
                                     enumCount:0
                                        ranges:NULL
                                    rangeCount:0
                                   storageSize:sizeof(GPBUninterpretedOption_NamePart__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - GPBSourceCodeInfo

@implementation GPBSourceCodeInfo

@dynamic locationArray, locationArray_Count;

typedef struct GPBSourceCodeInfo__storage_ {
  uint32_t _has_storage_[1];
  NSMutableArray *locationArray;
} GPBSourceCodeInfo__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "locationArray",
        .number = GPBSourceCodeInfo_FieldNumber_LocationArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
        .offset = offsetof(GPBSourceCodeInfo__storage_, locationArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = GPBStringifySymbol(GPBSourceCodeInfo_Location),
        .fieldOptions = NULL,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBSourceCodeInfo class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:NULL
                                     enumCount:0
                                        ranges:NULL
                                    rangeCount:0
                                   storageSize:sizeof(GPBSourceCodeInfo__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - GPBSourceCodeInfo_Location

@implementation GPBSourceCodeInfo_Location

@dynamic pathArray, pathArray_Count;
@dynamic spanArray, spanArray_Count;
@dynamic hasLeadingComments, leadingComments;
@dynamic hasTrailingComments, trailingComments;
@dynamic leadingDetachedCommentsArray, leadingDetachedCommentsArray_Count;

typedef struct GPBSourceCodeInfo_Location__storage_ {
  uint32_t _has_storage_[1];
  GPBInt32Array *pathArray;
  GPBInt32Array *spanArray;
  NSString *leadingComments;
  NSString *trailingComments;
  NSMutableArray *leadingDetachedCommentsArray;
} GPBSourceCodeInfo_Location__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "pathArray",
        .number = GPBSourceCodeInfo_Location_FieldNumber_PathArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated | GPBFieldPacked,
        .dataType = GPBDataTypeInt32,
        .offset = offsetof(GPBSourceCodeInfo_Location__storage_, pathArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = NULL,
      #if GPBOBJC_INCLUDE_FIELD_OPTIONS
        .fieldOptions = "\000\000\000\002\020\001",
      #else
        .fieldOptions = NULL,
      #endif  // GPBOBJC_INCLUDE_FIELD_OPTIONS
      },
      {
        .name = "spanArray",
        .number = GPBSourceCodeInfo_Location_FieldNumber_SpanArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated | GPBFieldPacked,
        .dataType = GPBDataTypeInt32,
        .offset = offsetof(GPBSourceCodeInfo_Location__storage_, spanArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = NULL,
      #if GPBOBJC_INCLUDE_FIELD_OPTIONS
        .fieldOptions = "\000\000\000\002\020\001",
      #else
        .fieldOptions = NULL,
      #endif  // GPBOBJC_INCLUDE_FIELD_OPTIONS
      },
      {
        .name = "leadingComments",
        .number = GPBSourceCodeInfo_Location_FieldNumber_LeadingComments,
        .hasIndex = 2,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBSourceCodeInfo_Location__storage_, leadingComments),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "trailingComments",
        .number = GPBSourceCodeInfo_Location_FieldNumber_TrailingComments,
        .hasIndex = 3,
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBSourceCodeInfo_Location__storage_, trailingComments),
        .defaultValue.valueString = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "leadingDetachedCommentsArray",
        .number = GPBSourceCodeInfo_Location_FieldNumber_LeadingDetachedCommentsArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeString,
        .offset = offsetof(GPBSourceCodeInfo_Location__storage_, leadingDetachedCommentsArray),
        .defaultValue.valueMessage = nil,
        .dataTypeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[GPBSourceCodeInfo_Location class]
                                     rootClass:[GPBDescriptorRoot class]
                                          file:GPBDescriptorRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
                                        oneofs:NULL
                                    oneofCount:0
                                         enums:NULL
                                     enumCount:0
                                        ranges:NULL
                                    rangeCount:0
                                   storageSize:sizeof(GPBSourceCodeInfo_Location__storage_)
                                    wireFormat:NO];
    NSAssert(descriptor == nil, @"Startup recursed!");
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end


// @@protoc_insertion_point(global_scope)