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

#import "GPBProtocolBuffers_RuntimeSupport.h"

#import "google/protobuf/Descriptor.pbobjc.h"

#pragma mark - GPBDescriptorRoot

@implementation GPBDescriptorRoot

@end

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) {
    descriptor = [[GPBFileDescriptor alloc] initWithPackage:@"google.protobuf"
                                                     syntax:GPBFileSyntaxProto2];
  }
  return descriptor;
}

#pragma mark - GPBFileDescriptorSet

@implementation GPBFileDescriptorSet

@dynamic fileArray;

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 = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "fileArray",
        .number = GPBFileDescriptorSet_FieldNumber_FileArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBFileDescriptorSet_Storage, fileArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBFileDescriptorProto),
        .fieldOptions = NULL,
      },
    };
    descriptor = [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];
  }
  return descriptor;
}

@end

#pragma mark - GPBFileDescriptorProto

@implementation GPBFileDescriptorProto

@dynamic hasName, name;
@dynamic hasPackage, package;
@dynamic dependencyArray;
@dynamic publicDependencyArray;
@dynamic weakDependencyArray;
@dynamic messageTypeArray;
@dynamic enumTypeArray;
@dynamic serviceArray;
@dynamic extensionArray;
@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 = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "name",
        .number = GPBFileDescriptorProto_FieldNumber_Name,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBFileDescriptorProto_Storage, name),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "package",
        .number = GPBFileDescriptorProto_FieldNumber_Package,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBFileDescriptorProto_Storage, package),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "dependencyArray",
        .number = GPBFileDescriptorProto_FieldNumber_DependencyArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeString,
        .offset = offsetof(GPBFileDescriptorProto_Storage, dependencyArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "messageTypeArray",
        .number = GPBFileDescriptorProto_FieldNumber_MessageTypeArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBFileDescriptorProto_Storage, messageTypeArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "enumTypeArray",
        .number = GPBFileDescriptorProto_FieldNumber_EnumTypeArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBFileDescriptorProto_Storage, enumTypeArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBEnumDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "serviceArray",
        .number = GPBFileDescriptorProto_FieldNumber_ServiceArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBFileDescriptorProto_Storage, serviceArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBServiceDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "extensionArray",
        .number = GPBFileDescriptorProto_FieldNumber_ExtensionArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBFileDescriptorProto_Storage, extensionArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBFieldDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "options",
        .number = GPBFileDescriptorProto_FieldNumber_Options,
        .hasIndex = 9,
        .flags = GPBFieldOptional,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBFileDescriptorProto_Storage, options),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBFileOptions),
        .fieldOptions = NULL,
      },
      {
        .name = "sourceCodeInfo",
        .number = GPBFileDescriptorProto_FieldNumber_SourceCodeInfo,
        .hasIndex = 10,
        .flags = GPBFieldOptional,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBFileDescriptorProto_Storage, sourceCodeInfo),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBSourceCodeInfo),
        .fieldOptions = NULL,
      },
      {
        .name = "publicDependencyArray",
        .number = GPBFileDescriptorProto_FieldNumber_PublicDependencyArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeInt32,
        .offset = offsetof(GPBFileDescriptorProto_Storage, publicDependencyArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "weakDependencyArray",
        .number = GPBFileDescriptorProto_FieldNumber_WeakDependencyArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeInt32,
        .offset = offsetof(GPBFileDescriptorProto_Storage, weakDependencyArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "syntax",
        .number = GPBFileDescriptorProto_FieldNumber_Syntax,
        .hasIndex = 11,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBFileDescriptorProto_Storage, syntax),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    descriptor = [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];
  }
  return descriptor;
}

@end

#pragma mark - GPBDescriptorProto

@implementation GPBDescriptorProto

@dynamic hasName, name;
@dynamic fieldArray;
@dynamic extensionArray;
@dynamic nestedTypeArray;
@dynamic enumTypeArray;
@dynamic extensionRangeArray;
@dynamic oneofDeclArray;
@dynamic hasOptions, options;

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;
} GPBDescriptorProto_Storage;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "name",
        .number = GPBDescriptorProto_FieldNumber_Name,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBDescriptorProto_Storage, name),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "fieldArray",
        .number = GPBDescriptorProto_FieldNumber_FieldArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBDescriptorProto_Storage, fieldArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBFieldDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "nestedTypeArray",
        .number = GPBDescriptorProto_FieldNumber_NestedTypeArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBDescriptorProto_Storage, nestedTypeArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "enumTypeArray",
        .number = GPBDescriptorProto_FieldNumber_EnumTypeArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBDescriptorProto_Storage, enumTypeArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBEnumDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "extensionRangeArray",
        .number = GPBDescriptorProto_FieldNumber_ExtensionRangeArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBDescriptorProto_Storage, extensionRangeArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBDescriptorProto_ExtensionRange),
        .fieldOptions = NULL,
      },
      {
        .name = "extensionArray",
        .number = GPBDescriptorProto_FieldNumber_ExtensionArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBDescriptorProto_Storage, extensionArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBFieldDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "options",
        .number = GPBDescriptorProto_FieldNumber_Options,
        .hasIndex = 7,
        .flags = GPBFieldOptional,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBDescriptorProto_Storage, options),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBMessageOptions),
        .fieldOptions = NULL,
      },
      {
        .name = "oneofDeclArray",
        .number = GPBDescriptorProto_FieldNumber_OneofDeclArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBDescriptorProto_Storage, oneofDeclArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBOneofDescriptorProto),
        .fieldOptions = NULL,
      },
    };
    descriptor = [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];
  }
  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 = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "start",
        .number = GPBDescriptorProto_ExtensionRange_FieldNumber_Start,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .type = GPBTypeInt32,
        .offset = offsetof(GPBDescriptorProto_ExtensionRange_Storage, start),
        .defaultValue.valueInt32 = 0,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "end",
        .number = GPBDescriptorProto_ExtensionRange_FieldNumber_End,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .type = GPBTypeInt32,
        .offset = offsetof(GPBDescriptorProto_ExtensionRange_Storage, end),
        .defaultValue.valueInt32 = 0,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    descriptor = [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];
  }
  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 = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "name",
        .number = GPBFieldDescriptorProto_FieldNumber_Name,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBFieldDescriptorProto_Storage, name),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "extendee",
        .number = GPBFieldDescriptorProto_FieldNumber_Extendee,
        .hasIndex = 5,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBFieldDescriptorProto_Storage, extendee),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "number",
        .number = GPBFieldDescriptorProto_FieldNumber_Number,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .type = GPBTypeInt32,
        .offset = offsetof(GPBFieldDescriptorProto_Storage, number),
        .defaultValue.valueInt32 = 0,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "label",
        .number = GPBFieldDescriptorProto_FieldNumber_Label,
        .hasIndex = 2,
        .flags = GPBFieldOptional | GPBFieldHasEnumDescriptor,
        .type = GPBTypeEnum,
        .offset = offsetof(GPBFieldDescriptorProto_Storage, label),
        .defaultValue.valueEnum = GPBFieldDescriptorProto_Label_LabelOptional,
        .typeSpecific.enumDescFunc = GPBFieldDescriptorProto_Label_EnumDescriptor,
        .fieldOptions = NULL,
      },
      {
        .name = "type",
        .number = GPBFieldDescriptorProto_FieldNumber_Type,
        .hasIndex = 3,
        .flags = GPBFieldOptional | GPBFieldHasEnumDescriptor,
        .type = GPBTypeEnum,
        .offset = offsetof(GPBFieldDescriptorProto_Storage, type),
        .defaultValue.valueEnum = GPBFieldDescriptorProto_Type_TypeDouble,
        .typeSpecific.enumDescFunc = GPBFieldDescriptorProto_Type_EnumDescriptor,
        .fieldOptions = NULL,
      },
      {
        .name = "typeName",
        .number = GPBFieldDescriptorProto_FieldNumber_TypeName,
        .hasIndex = 4,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBFieldDescriptorProto_Storage, typeName),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "defaultValue",
        .number = GPBFieldDescriptorProto_FieldNumber_DefaultValue,
        .hasIndex = 6,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBFieldDescriptorProto_Storage, defaultValue),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "options",
        .number = GPBFieldDescriptorProto_FieldNumber_Options,
        .hasIndex = 8,
        .flags = GPBFieldOptional,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBFieldDescriptorProto_Storage, options),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBFieldOptions),
        .fieldOptions = NULL,
      },
      {
        .name = "oneofIndex",
        .number = GPBFieldDescriptorProto_FieldNumber_OneofIndex,
        .hasIndex = 7,
        .flags = GPBFieldOptional,
        .type = GPBTypeInt32,
        .offset = offsetof(GPBFieldDescriptorProto_Storage, oneofIndex),
        .defaultValue.valueInt32 = 0,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    static GPBMessageEnumDescription enums[] = {
      { .enumDescriptorFunc = GPBFieldDescriptorProto_Type_EnumDescriptor },
      { .enumDescriptorFunc = GPBFieldDescriptorProto_Label_EnumDescriptor },
    };
    descriptor = [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];
  }
  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 = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "name",
        .number = GPBOneofDescriptorProto_FieldNumber_Name,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBOneofDescriptorProto_Storage, name),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    descriptor = [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];
  }
  return descriptor;
}

@end

#pragma mark - GPBEnumDescriptorProto

@implementation GPBEnumDescriptorProto

@dynamic hasName, name;
@dynamic valueArray;
@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 = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "name",
        .number = GPBEnumDescriptorProto_FieldNumber_Name,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBEnumDescriptorProto_Storage, name),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "valueArray",
        .number = GPBEnumDescriptorProto_FieldNumber_ValueArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBEnumDescriptorProto_Storage, valueArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBEnumValueDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "options",
        .number = GPBEnumDescriptorProto_FieldNumber_Options,
        .hasIndex = 2,
        .flags = GPBFieldOptional,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBEnumDescriptorProto_Storage, options),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBEnumOptions),
        .fieldOptions = NULL,
      },
    };
    descriptor = [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];
  }
  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 = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "name",
        .number = GPBEnumValueDescriptorProto_FieldNumber_Name,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBEnumValueDescriptorProto_Storage, name),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "number",
        .number = GPBEnumValueDescriptorProto_FieldNumber_Number,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .type = GPBTypeInt32,
        .offset = offsetof(GPBEnumValueDescriptorProto_Storage, number),
        .defaultValue.valueInt32 = 0,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "options",
        .number = GPBEnumValueDescriptorProto_FieldNumber_Options,
        .hasIndex = 2,
        .flags = GPBFieldOptional,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBEnumValueDescriptorProto_Storage, options),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBEnumValueOptions),
        .fieldOptions = NULL,
      },
    };
    descriptor = [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];
  }
  return descriptor;
}

@end

#pragma mark - GPBServiceDescriptorProto

@implementation GPBServiceDescriptorProto

@dynamic hasName, name;
@dynamic methodArray;
@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 = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "name",
        .number = GPBServiceDescriptorProto_FieldNumber_Name,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBServiceDescriptorProto_Storage, name),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "methodArray",
        .number = GPBServiceDescriptorProto_FieldNumber_MethodArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBServiceDescriptorProto_Storage, methodArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBMethodDescriptorProto),
        .fieldOptions = NULL,
      },
      {
        .name = "options",
        .number = GPBServiceDescriptorProto_FieldNumber_Options,
        .hasIndex = 2,
        .flags = GPBFieldOptional,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBServiceDescriptorProto_Storage, options),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBServiceOptions),
        .fieldOptions = NULL,
      },
    };
    descriptor = [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];
  }
  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 = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "name",
        .number = GPBMethodDescriptorProto_FieldNumber_Name,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBMethodDescriptorProto_Storage, name),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "inputType",
        .number = GPBMethodDescriptorProto_FieldNumber_InputType,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBMethodDescriptorProto_Storage, inputType),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "outputType",
        .number = GPBMethodDescriptorProto_FieldNumber_OutputType,
        .hasIndex = 2,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBMethodDescriptorProto_Storage, outputType),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "options",
        .number = GPBMethodDescriptorProto_FieldNumber_Options,
        .hasIndex = 3,
        .flags = GPBFieldOptional,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBMethodDescriptorProto_Storage, options),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBMethodOptions),
        .fieldOptions = NULL,
      },
      {
        .name = "clientStreaming",
        .number = GPBMethodDescriptorProto_FieldNumber_ClientStreaming,
        .hasIndex = 4,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .type = GPBTypeBool,
        .offset = offsetof(GPBMethodDescriptorProto_Storage, clientStreaming),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "serverStreaming",
        .number = GPBMethodDescriptorProto_FieldNumber_ServerStreaming,
        .hasIndex = 5,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .type = GPBTypeBool,
        .offset = offsetof(GPBMethodDescriptorProto_Storage, serverStreaming),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    descriptor = [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];
  }
  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 uninterpretedOptionArray;

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;
  NSMutableArray *uninterpretedOptionArray;
} GPBFileOptions_Storage;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "javaPackage",
        .number = GPBFileOptions_FieldNumber_JavaPackage,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBFileOptions_Storage, javaPackage),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "javaOuterClassname",
        .number = GPBFileOptions_FieldNumber_JavaOuterClassname,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBFileOptions_Storage, javaOuterClassname),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "optimizeFor",
        .number = GPBFileOptions_FieldNumber_OptimizeFor,
        .hasIndex = 5,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue | GPBFieldHasEnumDescriptor,
        .type = GPBTypeEnum,
        .offset = offsetof(GPBFileOptions_Storage, optimizeFor),
        .defaultValue.valueEnum = GPBFileOptions_OptimizeMode_Speed,
        .typeSpecific.enumDescFunc = GPBFileOptions_OptimizeMode_EnumDescriptor,
        .fieldOptions = NULL,
      },
      {
        .name = "javaMultipleFiles",
        .number = GPBFileOptions_FieldNumber_JavaMultipleFiles,
        .hasIndex = 2,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .type = GPBTypeBool,
        .offset = offsetof(GPBFileOptions_Storage, javaMultipleFiles),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "goPackage",
        .number = GPBFileOptions_FieldNumber_GoPackage,
        .hasIndex = 6,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBFileOptions_Storage, goPackage),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "ccGenericServices",
        .number = GPBFileOptions_FieldNumber_CcGenericServices,
        .hasIndex = 7,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .type = GPBTypeBool,
        .offset = offsetof(GPBFileOptions_Storage, ccGenericServices),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "javaGenericServices",
        .number = GPBFileOptions_FieldNumber_JavaGenericServices,
        .hasIndex = 8,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .type = GPBTypeBool,
        .offset = offsetof(GPBFileOptions_Storage, javaGenericServices),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "pyGenericServices",
        .number = GPBFileOptions_FieldNumber_PyGenericServices,
        .hasIndex = 9,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .type = GPBTypeBool,
        .offset = offsetof(GPBFileOptions_Storage, pyGenericServices),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "javaGenerateEqualsAndHash",
        .number = GPBFileOptions_FieldNumber_JavaGenerateEqualsAndHash,
        .hasIndex = 3,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .type = GPBTypeBool,
        .offset = offsetof(GPBFileOptions_Storage, javaGenerateEqualsAndHash),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "deprecated",
        .number = GPBFileOptions_FieldNumber_Deprecated,
        .hasIndex = 10,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .type = GPBTypeBool,
        .offset = offsetof(GPBFileOptions_Storage, deprecated),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "javaStringCheckUtf8",
        .number = GPBFileOptions_FieldNumber_JavaStringCheckUtf8,
        .hasIndex = 4,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .type = GPBTypeBool,
        .offset = offsetof(GPBFileOptions_Storage, javaStringCheckUtf8),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "ccEnableArenas",
        .number = GPBFileOptions_FieldNumber_CcEnableArenas,
        .hasIndex = 11,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .type = GPBTypeBool,
        .offset = offsetof(GPBFileOptions_Storage, ccEnableArenas),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "objcClassPrefix",
        .number = GPBFileOptions_FieldNumber_ObjcClassPrefix,
        .hasIndex = 12,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBFileOptions_Storage, objcClassPrefix),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "uninterpretedOptionArray",
        .number = GPBFileOptions_FieldNumber_UninterpretedOptionArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBFileOptions_Storage, uninterpretedOptionArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
        .fieldOptions = NULL,
      },
    };
    static GPBMessageEnumDescription enums[] = {
      { .enumDescriptorFunc = GPBFileOptions_OptimizeMode_EnumDescriptor },
    };
    static GPBExtensionRange ranges[] = {
      { .start = 1000, .end = 536870912 },
    };
    descriptor = [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];
  }
  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;

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 = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "messageSetWireFormat",
        .number = GPBMessageOptions_FieldNumber_MessageSetWireFormat,
        .hasIndex = 0,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .type = GPBTypeBool,
        .offset = offsetof(GPBMessageOptions_Storage, messageSetWireFormat),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "noStandardDescriptorAccessor",
        .number = GPBMessageOptions_FieldNumber_NoStandardDescriptorAccessor,
        .hasIndex = 1,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .type = GPBTypeBool,
        .offset = offsetof(GPBMessageOptions_Storage, noStandardDescriptorAccessor),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "deprecated",
        .number = GPBMessageOptions_FieldNumber_Deprecated,
        .hasIndex = 2,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .type = GPBTypeBool,
        .offset = offsetof(GPBMessageOptions_Storage, deprecated),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "mapEntry",
        .number = GPBMessageOptions_FieldNumber_MapEntry,
        .hasIndex = 3,
        .flags = GPBFieldOptional,
        .type = GPBTypeBool,
        .offset = offsetof(GPBMessageOptions_Storage, mapEntry),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "uninterpretedOptionArray",
        .number = GPBMessageOptions_FieldNumber_UninterpretedOptionArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBMessageOptions_Storage, uninterpretedOptionArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
        .fieldOptions = NULL,
      },
    };
    static GPBExtensionRange ranges[] = {
      { .start = 1000, .end = 536870912 },
    };
    descriptor = [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];
  }
  return descriptor;
}

@end

#pragma mark - GPBFieldOptions

@implementation GPBFieldOptions

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

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

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "ctype",
        .number = GPBFieldOptions_FieldNumber_Ctype,
        .hasIndex = 0,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue | GPBFieldHasEnumDescriptor,
        .type = GPBTypeEnum,
        .offset = offsetof(GPBFieldOptions_Storage, ctype),
        .defaultValue.valueEnum = GPBFieldOptions_CType_String,
        .typeSpecific.enumDescFunc = GPBFieldOptions_CType_EnumDescriptor,
        .fieldOptions = NULL,
      },
      {
        .name = "packed",
        .number = GPBFieldOptions_FieldNumber_Packed,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .type = GPBTypeBool,
        .offset = offsetof(GPBFieldOptions_Storage, packed),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "deprecated",
        .number = GPBFieldOptions_FieldNumber_Deprecated,
        .hasIndex = 3,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .type = GPBTypeBool,
        .offset = offsetof(GPBFieldOptions_Storage, deprecated),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "lazy",
        .number = GPBFieldOptions_FieldNumber_Lazy,
        .hasIndex = 2,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .type = GPBTypeBool,
        .offset = offsetof(GPBFieldOptions_Storage, lazy),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "weak",
        .number = GPBFieldOptions_FieldNumber_Weak,
        .hasIndex = 4,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .type = GPBTypeBool,
        .offset = offsetof(GPBFieldOptions_Storage, weak),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "uninterpretedOptionArray",
        .number = GPBFieldOptions_FieldNumber_UninterpretedOptionArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBFieldOptions_Storage, uninterpretedOptionArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
        .fieldOptions = NULL,
      },
    };
    static GPBMessageEnumDescription enums[] = {
      { .enumDescriptorFunc = GPBFieldOptions_CType_EnumDescriptor },
    };
    static GPBExtensionRange ranges[] = {
      { .start = 1000, .end = 536870912 },
    };
    descriptor = [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];
  }
  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 - GPBEnumOptions

@implementation GPBEnumOptions

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

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 = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "allowAlias",
        .number = GPBEnumOptions_FieldNumber_AllowAlias,
        .hasIndex = 0,
        .flags = GPBFieldOptional,
        .type = GPBTypeBool,
        .offset = offsetof(GPBEnumOptions_Storage, allowAlias),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "deprecated",
        .number = GPBEnumOptions_FieldNumber_Deprecated,
        .hasIndex = 1,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .type = GPBTypeBool,
        .offset = offsetof(GPBEnumOptions_Storage, deprecated),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "uninterpretedOptionArray",
        .number = GPBEnumOptions_FieldNumber_UninterpretedOptionArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBEnumOptions_Storage, uninterpretedOptionArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
        .fieldOptions = NULL,
      },
    };
    static GPBExtensionRange ranges[] = {
      { .start = 1000, .end = 536870912 },
    };
    descriptor = [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];
  }
  return descriptor;
}

@end

#pragma mark - GPBEnumValueOptions

@implementation GPBEnumValueOptions

@dynamic hasDeprecated, deprecated;
@dynamic uninterpretedOptionArray;

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 = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "deprecated",
        .number = GPBEnumValueOptions_FieldNumber_Deprecated,
        .hasIndex = 0,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .type = GPBTypeBool,
        .offset = offsetof(GPBEnumValueOptions_Storage, deprecated),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "uninterpretedOptionArray",
        .number = GPBEnumValueOptions_FieldNumber_UninterpretedOptionArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBEnumValueOptions_Storage, uninterpretedOptionArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
        .fieldOptions = NULL,
      },
    };
    static GPBExtensionRange ranges[] = {
      { .start = 1000, .end = 536870912 },
    };
    descriptor = [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];
  }
  return descriptor;
}

@end

#pragma mark - GPBServiceOptions

@implementation GPBServiceOptions

@dynamic hasDeprecated, deprecated;
@dynamic uninterpretedOptionArray;

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 = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "deprecated",
        .number = GPBServiceOptions_FieldNumber_Deprecated,
        .hasIndex = 0,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .type = GPBTypeBool,
        .offset = offsetof(GPBServiceOptions_Storage, deprecated),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "uninterpretedOptionArray",
        .number = GPBServiceOptions_FieldNumber_UninterpretedOptionArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBServiceOptions_Storage, uninterpretedOptionArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
        .fieldOptions = NULL,
      },
    };
    static GPBExtensionRange ranges[] = {
      { .start = 1000, .end = 536870912 },
    };
    descriptor = [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];
  }
  return descriptor;
}

@end

#pragma mark - GPBMethodOptions

@implementation GPBMethodOptions

@dynamic hasDeprecated, deprecated;
@dynamic uninterpretedOptionArray;

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 = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "deprecated",
        .number = GPBMethodOptions_FieldNumber_Deprecated,
        .hasIndex = 0,
        .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
        .type = GPBTypeBool,
        .offset = offsetof(GPBMethodOptions_Storage, deprecated),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "uninterpretedOptionArray",
        .number = GPBMethodOptions_FieldNumber_UninterpretedOptionArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBMethodOptions_Storage, uninterpretedOptionArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
        .fieldOptions = NULL,
      },
    };
    static GPBExtensionRange ranges[] = {
      { .start = 1000, .end = 536870912 },
    };
    descriptor = [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];
  }
  return descriptor;
}

@end

#pragma mark - GPBUninterpretedOption

@implementation GPBUninterpretedOption

@dynamic nameArray;
@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 = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "nameArray",
        .number = GPBUninterpretedOption_FieldNumber_NameArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBUninterpretedOption_Storage, nameArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption_NamePart),
        .fieldOptions = NULL,
      },
      {
        .name = "identifierValue",
        .number = GPBUninterpretedOption_FieldNumber_IdentifierValue,
        .hasIndex = 1,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBUninterpretedOption_Storage, identifierValue),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "positiveIntValue",
        .number = GPBUninterpretedOption_FieldNumber_PositiveIntValue,
        .hasIndex = 2,
        .flags = GPBFieldOptional,
        .type = GPBTypeUInt64,
        .offset = offsetof(GPBUninterpretedOption_Storage, positiveIntValue),
        .defaultValue.valueUInt64 = 0ULL,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "negativeIntValue",
        .number = GPBUninterpretedOption_FieldNumber_NegativeIntValue,
        .hasIndex = 3,
        .flags = GPBFieldOptional,
        .type = GPBTypeInt64,
        .offset = offsetof(GPBUninterpretedOption_Storage, negativeIntValue),
        .defaultValue.valueInt64 = 0LL,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "doubleValue",
        .number = GPBUninterpretedOption_FieldNumber_DoubleValue,
        .hasIndex = 4,
        .flags = GPBFieldOptional,
        .type = GPBTypeDouble,
        .offset = offsetof(GPBUninterpretedOption_Storage, doubleValue),
        .defaultValue.valueDouble = 0,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "stringValue",
        .number = GPBUninterpretedOption_FieldNumber_StringValue,
        .hasIndex = 5,
        .flags = GPBFieldOptional,
        .type = GPBTypeData,
        .offset = offsetof(GPBUninterpretedOption_Storage, stringValue),
        .defaultValue.valueData = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "aggregateValue",
        .number = GPBUninterpretedOption_FieldNumber_AggregateValue,
        .hasIndex = 6,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBUninterpretedOption_Storage, aggregateValue),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    descriptor = [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];
  }
  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 = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "namePart",
        .number = GPBUninterpretedOption_NamePart_FieldNumber_NamePart,
        .hasIndex = 0,
        .flags = GPBFieldRequired,
        .type = GPBTypeString,
        .offset = offsetof(GPBUninterpretedOption_NamePart_Storage, namePart),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "isExtension",
        .number = GPBUninterpretedOption_NamePart_FieldNumber_IsExtension,
        .hasIndex = 1,
        .flags = GPBFieldRequired,
        .type = GPBTypeBool,
        .offset = offsetof(GPBUninterpretedOption_NamePart_Storage, isExtension),
        .defaultValue.valueBool = NO,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    descriptor = [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];
  }
  return descriptor;
}

@end

#pragma mark - GPBSourceCodeInfo

@implementation GPBSourceCodeInfo

@dynamic locationArray;

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 = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "locationArray",
        .number = GPBSourceCodeInfo_FieldNumber_LocationArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeMessage,
        .offset = offsetof(GPBSourceCodeInfo_Storage, locationArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = GPBStringifySymbol(GPBSourceCodeInfo_Location),
        .fieldOptions = NULL,
      },
    };
    descriptor = [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];
  }
  return descriptor;
}

@end

#pragma mark - GPBSourceCodeInfo_Location

@implementation GPBSourceCodeInfo_Location

@dynamic pathArray;
@dynamic spanArray;
@dynamic hasLeadingComments, leadingComments;
@dynamic hasTrailingComments, trailingComments;
@dynamic leadingDetachedCommentsArray;

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 = NULL;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "pathArray",
        .number = GPBSourceCodeInfo_Location_FieldNumber_PathArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated | GPBFieldPacked,
        .type = GPBTypeInt32,
        .offset = offsetof(GPBSourceCodeInfo_Location_Storage, pathArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.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,
        .type = GPBTypeInt32,
        .offset = offsetof(GPBSourceCodeInfo_Location_Storage, spanArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.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,
        .type = GPBTypeString,
        .offset = offsetof(GPBSourceCodeInfo_Location_Storage, leadingComments),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "trailingComments",
        .number = GPBSourceCodeInfo_Location_FieldNumber_TrailingComments,
        .hasIndex = 3,
        .flags = GPBFieldOptional,
        .type = GPBTypeString,
        .offset = offsetof(GPBSourceCodeInfo_Location_Storage, trailingComments),
        .defaultValue.valueString = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
      {
        .name = "leadingDetachedCommentsArray",
        .number = GPBSourceCodeInfo_Location_FieldNumber_LeadingDetachedCommentsArray,
        .hasIndex = GPBNoHasBit,
        .flags = GPBFieldRepeated,
        .type = GPBTypeString,
        .offset = offsetof(GPBSourceCodeInfo_Location_Storage, leadingDetachedCommentsArray),
        .defaultValue.valueMessage = nil,
        .typeSpecific.className = NULL,
        .fieldOptions = NULL,
      },
    };
    descriptor = [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];
  }
  return descriptor;
}

@end