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

interface

uses
  protobuf;
type

  PFileDescriptorSet = ^TFileDescriptorSet;
  TRepeatedFileDescriptorSet = {specialize} TRepeated<PFileDescriptorSet>;
  PFileDescriptorProto = ^TFileDescriptorProto;
  TRepeatedFileDescriptorProto = {specialize} TRepeated<PFileDescriptorProto>;
  PDescriptorProto = ^TDescriptorProto;
  TRepeatedDescriptorProto = {specialize} TRepeated<PDescriptorProto>;
  PFieldDescriptorProto = ^TFieldDescriptorProto;
  TRepeatedFieldDescriptorProto = {specialize} TRepeated<PFieldDescriptorProto>;
  PEnumDescriptorProto = ^TEnumDescriptorProto;
  TRepeatedEnumDescriptorProto = {specialize} TRepeated<PEnumDescriptorProto>;
  PEnumValueDescriptorProto = ^TEnumValueDescriptorProto;
  TRepeatedEnumValueDescriptorProto = {specialize} TRepeated<PEnumValueDescriptorProto>;
  PServiceDescriptorProto = ^TServiceDescriptorProto;
  TRepeatedServiceDescriptorProto = {specialize} TRepeated<PServiceDescriptorProto>;
  PMethodDescriptorProto = ^TMethodDescriptorProto;
  TRepeatedMethodDescriptorProto = {specialize} TRepeated<PMethodDescriptorProto>;
  PFileOptions = ^TFileOptions;
  TRepeatedFileOptions = {specialize} TRepeated<PFileOptions>;
  PMessageOptions = ^TMessageOptions;
  TRepeatedMessageOptions = {specialize} TRepeated<PMessageOptions>;
  PFieldOptions = ^TFieldOptions;
  TRepeatedFieldOptions = {specialize} TRepeated<PFieldOptions>;
  PEnumOptions = ^TEnumOptions;
  TRepeatedEnumOptions = {specialize} TRepeated<PEnumOptions>;
  PEnumValueOptions = ^TEnumValueOptions;
  TRepeatedEnumValueOptions = {specialize} TRepeated<PEnumValueOptions>;
  PServiceOptions = ^TServiceOptions;
  TRepeatedServiceOptions = {specialize} TRepeated<PServiceOptions>;
  PMethodOptions = ^TMethodOptions;
  TRepeatedMethodOptions = {specialize} TRepeated<PMethodOptions>;
  PUninterpretedOption = ^TUninterpretedOption;
  TRepeatedUninterpretedOption = {specialize} TRepeated<PUninterpretedOption>;
  PSourceCodeInfo = ^TSourceCodeInfo;
  TRepeatedSourceCodeInfo = {specialize} TRepeated<PSourceCodeInfo>;

  TFileDescriptorSet = object(TProtoMessageObject)
  public type
  
  
  
  private
      Ffile: TRepeatedFileDescriptorProto;
  
  public
    procedure Serialize(Func: TSerializeFunc); virtual;
    procedure Parse(Func: TParseFunc); virtual;
  end;
  
  TFileDescriptorProto = object(TProtoMessageObject)
  public type
  
  
  
  private
      FnameHas: Boolean;
      Fname: AnsiString;
      FpackageHas: Boolean;
      Fpackage: AnsiString;
      Fdependency: TRepeatedAnsiString;
      Fpublic_dependency: TRepeatedLongInt;
      Fweak_dependency: TRepeatedLongInt;
      Fmessage_type: TRepeatedDescriptorProto;
      Fenum_type: TRepeatedEnumDescriptorProto;
      Fservice: TRepeatedServiceDescriptorProto;
      Fextension: TRepeatedFieldDescriptorProto;
      FoptionsHas: Boolean;
      Foptions: PFileOptions;
      Fsource_code_infoHas: Boolean;
      Fsource_code_info: PSourceCodeInfo;
  
  public
    procedure Serialize(Func: TSerializeFunc); virtual;
    procedure Parse(Func: TParseFunc); virtual;
      procedure Setname(const _name: AnsiString);
      function  Getname: AnsiString;
      procedure Setpackage(const _package: AnsiString);
      function  Getpackage: AnsiString;
      procedure Setoptions(const _options: PFileOptions);
      function  Getoptions: PFileOptions;
      procedure Setsource_code_info(const _source_code_info: PSourceCodeInfo);
      function  Getsource_code_info: PSourceCodeInfo;
      property name: AnsiString read Getname write Setname;
      property package: AnsiString read Getpackage write Setpackage;
      property options: PFileOptions read Getoptions write Setoptions;
      property source_code_info: PSourceCodeInfo read Getsource_code_info write Setsource_code_info;
  end;
  
  TDescriptorProto = object(TProtoMessageObject)
  public type
  
    PExtensionRange = ^TExtensionRange;
    TRepeatedExtensionRange = {specialize} TRepeated<PExtensionRange>;
  
    TExtensionRange = object(TProtoMessageObject)
    public type
    
    
    
    private
        FstartHas: Boolean;
        Fstart: LongInt;
        FendHas: Boolean;
        Fend: LongInt;
    
    public
      procedure Serialize(Func: TSerializeFunc); virtual;
      procedure Parse(Func: TParseFunc); virtual;
        procedure Setstart(const _start: LongInt);
        function  Getstart: LongInt;
        procedure Setend(const _end: LongInt);
        function  Getend: LongInt;
        property start: LongInt read Getstart write Setstart;
        property &end: LongInt read Getend write Setend;
    end;
    
  
  private
      FnameHas: Boolean;
      Fname: AnsiString;
      Ffield: TRepeatedFieldDescriptorProto;
      Fextension: TRepeatedFieldDescriptorProto;
      Fnested_type: TRepeatedDescriptorProto;
      Fenum_type: TRepeatedEnumDescriptorProto;
      Fextension_range: TRepeatedExtensionRange;
      FoptionsHas: Boolean;
      Foptions: PMessageOptions;
  
  public
    procedure Serialize(Func: TSerializeFunc); virtual;
    procedure Parse(Func: TParseFunc); virtual;
      procedure Setname(const _name: AnsiString);
      function  Getname: AnsiString;
      procedure Setoptions(const _options: PMessageOptions);
      function  Getoptions: PMessageOptions;
      property name: AnsiString read Getname write Setname;
      property options: PMessageOptions read Getoptions write Setoptions;
  end;
  
  TFieldDescriptorProto = object(TProtoMessageObject)
  public type
    _Type = (
      TYPE_DOUBLE = 1,
      TYPE_FLOAT = 2,
      TYPE_INT64 = 3,
      TYPE_UINT64 = 4,
      TYPE_INT32 = 5,
      TYPE_FIXED64 = 6,
      TYPE_FIXED32 = 7,
      TYPE_BOOL = 8,
      TYPE_STRING = 9,
      TYPE_GROUP = 10,
      TYPE_MESSAGE = 11,
      TYPE_BYTES = 12,
      TYPE_UINT32 = 13,
      TYPE_ENUM = 14,
      TYPE_SFIXED32 = 15,
      TYPE_SFIXED64 = 16,
      TYPE_SINT32 = 17,
      TYPE_SINT64 = 18
    );
    
    _Label = (
      LABEL_OPTIONAL = 1,
      LABEL_REQUIRED = 2,
      LABEL_REPEATED = 3
    );
    
  
  
  
  private
      FnameHas: Boolean;
      Fname: AnsiString;
      FnumberHas: Boolean;
      Fnumber: LongInt;
      FlabelHas: Boolean;
      Flabel: _Label;
      FtypeHas: Boolean;
      Ftype: _Type;
      Ftype_nameHas: Boolean;
      Ftype_name: AnsiString;
      FextendeeHas: Boolean;
      Fextendee: AnsiString;
      Fdefault_valueHas: Boolean;
      Fdefault_value: AnsiString;
      FoptionsHas: Boolean;
      Foptions: PFieldOptions;
  
  public
    procedure Serialize(Func: TSerializeFunc); virtual;
    procedure Parse(Func: TParseFunc); virtual;
      procedure Setname(const _name: AnsiString);
      function  Getname: AnsiString;
      procedure Setnumber(const _number: LongInt);
      function  Getnumber: LongInt;
      procedure Setlabel(const _label: _Label);
      function  Getlabel: _Label;
      procedure Settype(const _type: _Type);
      function  Gettype: _Type;
      procedure Settype_name(const _type_name: AnsiString);
      function  Gettype_name: AnsiString;
      procedure Setextendee(const _extendee: AnsiString);
      function  Getextendee: AnsiString;
      procedure Setdefault_value(const _default_value: AnsiString);
      function  Getdefault_value: AnsiString;
      procedure Setoptions(const _options: PFieldOptions);
      function  Getoptions: PFieldOptions;
      property name: AnsiString read Getname write Setname;
      property number: LongInt read Getnumber write Setnumber;
      property &label: _Label read Getlabel write Setlabel;
      property &type: _Type read Gettype write Settype;
      property type_name: AnsiString read Gettype_name write Settype_name;
      property extendee: AnsiString read Getextendee write Setextendee;
      property default_value: AnsiString read Getdefault_value write Setdefault_value;
      property options: PFieldOptions read Getoptions write Setoptions;
  end;
  
  TEnumDescriptorProto = object(TProtoMessageObject)
  public type
  
  
  
  private
      FnameHas: Boolean;
      Fname: AnsiString;
      Fvalue: TRepeatedEnumValueDescriptorProto;
      FoptionsHas: Boolean;
      Foptions: PEnumOptions;
  
  public
    procedure Serialize(Func: TSerializeFunc); virtual;
    procedure Parse(Func: TParseFunc); virtual;
      procedure Setname(const _name: AnsiString);
      function  Getname: AnsiString;
      procedure Setoptions(const _options: PEnumOptions);
      function  Getoptions: PEnumOptions;
      property name: AnsiString read Getname write Setname;
      property options: PEnumOptions read Getoptions write Setoptions;
  end;
  
  TEnumValueDescriptorProto = object(TProtoMessageObject)
  public type
  
  
  
  private
      FnameHas: Boolean;
      Fname: AnsiString;
      FnumberHas: Boolean;
      Fnumber: LongInt;
      FoptionsHas: Boolean;
      Foptions: PEnumValueOptions;
  
  public
    procedure Serialize(Func: TSerializeFunc); virtual;
    procedure Parse(Func: TParseFunc); virtual;
      procedure Setname(const _name: AnsiString);
      function  Getname: AnsiString;
      procedure Setnumber(const _number: LongInt);
      function  Getnumber: LongInt;
      procedure Setoptions(const _options: PEnumValueOptions);
      function  Getoptions: PEnumValueOptions;
      property name: AnsiString read Getname write Setname;
      property number: LongInt read Getnumber write Setnumber;
      property options: PEnumValueOptions read Getoptions write Setoptions;
  end;
  
  TServiceDescriptorProto = object(TProtoMessageObject)
  public type
  
  
  
  private
      FnameHas: Boolean;
      Fname: AnsiString;
      Fmethod: TRepeatedMethodDescriptorProto;
      FoptionsHas: Boolean;
      Foptions: PServiceOptions;
  
  public
    procedure Serialize(Func: TSerializeFunc); virtual;
    procedure Parse(Func: TParseFunc); virtual;
      procedure Setname(const _name: AnsiString);
      function  Getname: AnsiString;
      procedure Setoptions(const _options: PServiceOptions);
      function  Getoptions: PServiceOptions;
      property name: AnsiString read Getname write Setname;
      property options: PServiceOptions read Getoptions write Setoptions;
  end;
  
  TMethodDescriptorProto = object(TProtoMessageObject)
  public type
  
  
  
  private
      FnameHas: Boolean;
      Fname: AnsiString;
      Finput_typeHas: Boolean;
      Finput_type: AnsiString;
      Foutput_typeHas: Boolean;
      Foutput_type: AnsiString;
      FoptionsHas: Boolean;
      Foptions: PMethodOptions;
  
  public
    procedure Serialize(Func: TSerializeFunc); virtual;
    procedure Parse(Func: TParseFunc); virtual;
      procedure Setname(const _name: AnsiString);
      function  Getname: AnsiString;
      procedure Setinput_type(const _input_type: AnsiString);
      function  Getinput_type: AnsiString;
      procedure Setoutput_type(const _output_type: AnsiString);
      function  Getoutput_type: AnsiString;
      procedure Setoptions(const _options: PMethodOptions);
      function  Getoptions: PMethodOptions;
      property name: AnsiString read Getname write Setname;
      property input_type: AnsiString read Getinput_type write Setinput_type;
      property output_type: AnsiString read Getoutput_type write Setoutput_type;
      property options: PMethodOptions read Getoptions write Setoptions;
  end;
  
  TFileOptions = object(TProtoMessageObject)
  public type
    _OptimizeMode = (
      SPEED = 1,
      CODE_SIZE = 2,
      LITE_RUNTIME = 3
    );
    
  
  
  
  private
      Fjava_packageHas: Boolean;
      Fjava_package: AnsiString;
      Fjava_outer_classnameHas: Boolean;
      Fjava_outer_classname: AnsiString;
      Fjava_multiple_filesHas: Boolean;
      Fjava_multiple_files: Boolean;
      Fjava_generate_equals_and_hashHas: Boolean;
      Fjava_generate_equals_and_hash: Boolean;
      Foptimize_forHas: Boolean;
      Foptimize_for: _OptimizeMode;
      Fgo_packageHas: Boolean;
      Fgo_package: AnsiString;
      Fcc_generic_servicesHas: Boolean;
      Fcc_generic_services: Boolean;
      Fjava_generic_servicesHas: Boolean;
      Fjava_generic_services: Boolean;
      Fpy_generic_servicesHas: Boolean;
      Fpy_generic_services: Boolean;
      Funinterpreted_option: TRepeatedUninterpretedOption;
  
  public
    procedure Serialize(Func: TSerializeFunc); virtual;
    procedure Parse(Func: TParseFunc); virtual;
      procedure Setjava_package(const _java_package: AnsiString);
      function  Getjava_package: AnsiString;
      procedure Setjava_outer_classname(const _java_outer_classname: AnsiString);
      function  Getjava_outer_classname: AnsiString;
      procedure Setjava_multiple_files(const _java_multiple_files: Boolean);
      function  Getjava_multiple_files: Boolean;
      procedure Setjava_generate_equals_and_hash(const _java_generate_equals_and_hash: Boolean);
      function  Getjava_generate_equals_and_hash: Boolean;
      procedure Setoptimize_for(const _optimize_for: _OptimizeMode);
      function  Getoptimize_for: _OptimizeMode;
      procedure Setgo_package(const _go_package: AnsiString);
      function  Getgo_package: AnsiString;
      procedure Setcc_generic_services(const _cc_generic_services: Boolean);
      function  Getcc_generic_services: Boolean;
      procedure Setjava_generic_services(const _java_generic_services: Boolean);
      function  Getjava_generic_services: Boolean;
      procedure Setpy_generic_services(const _py_generic_services: Boolean);
      function  Getpy_generic_services: Boolean;
      property java_package: AnsiString read Getjava_package write Setjava_package;
      property java_outer_classname: AnsiString read Getjava_outer_classname write Setjava_outer_classname;
      property java_multiple_files: Boolean read Getjava_multiple_files write Setjava_multiple_files;
      property java_generate_equals_and_hash: Boolean read Getjava_generate_equals_and_hash write Setjava_generate_equals_and_hash;
      property optimize_for: _OptimizeMode read Getoptimize_for write Setoptimize_for;
      property go_package: AnsiString read Getgo_package write Setgo_package;
      property cc_generic_services: Boolean read Getcc_generic_services write Setcc_generic_services;
      property java_generic_services: Boolean read Getjava_generic_services write Setjava_generic_services;
      property py_generic_services: Boolean read Getpy_generic_services write Setpy_generic_services;
  end;
  
  TMessageOptions = object(TProtoMessageObject)
  public type
  
  
  
  private
      Fmessage_set_wire_formatHas: Boolean;
      Fmessage_set_wire_format: Boolean;
      Fno_standard_descriptor_accessorHas: Boolean;
      Fno_standard_descriptor_accessor: Boolean;
      Funinterpreted_option: TRepeatedUninterpretedOption;
  
  public
    procedure Serialize(Func: TSerializeFunc); virtual;
    procedure Parse(Func: TParseFunc); virtual;
      procedure Setmessage_set_wire_format(const _message_set_wire_format: Boolean);
      function  Getmessage_set_wire_format: Boolean;
      procedure Setno_standard_descriptor_accessor(const _no_standard_descriptor_accessor: Boolean);
      function  Getno_standard_descriptor_accessor: Boolean;
      property message_set_wire_format: Boolean read Getmessage_set_wire_format write Setmessage_set_wire_format;
      property no_standard_descriptor_accessor: Boolean read Getno_standard_descriptor_accessor write Setno_standard_descriptor_accessor;
  end;
  
  TFieldOptions = object(TProtoMessageObject)
  public type
    _CType = (
      _STRING = 0,
      CORD = 1,
      STRING_PIECE = 2
    );
    
  
  
  
  private
      FctypeHas: Boolean;
      Fctype: _CType;
      FpackedHas: Boolean;
      Fpacked: Boolean;
      FlazyHas: Boolean;
      Flazy: Boolean;
      FdeprecatedHas: Boolean;
      Fdeprecated: Boolean;
      Fexperimental_map_keyHas: Boolean;
      Fexperimental_map_key: AnsiString;
      FweakHas: Boolean;
      Fweak: Boolean;
      Funinterpreted_option: TRepeatedUninterpretedOption;
  
  public
    procedure Serialize(Func: TSerializeFunc); virtual;
    procedure Parse(Func: TParseFunc); virtual;
      procedure Setctype(const _ctype: _CType);
      function  Getctype: _CType;
      procedure Setpacked(const _packed: Boolean);
      function  Getpacked: Boolean;
      procedure Setlazy(const _lazy: Boolean);
      function  Getlazy: Boolean;
      procedure Setdeprecated(const _deprecated: Boolean);
      function  Getdeprecated: Boolean;
      procedure Setexperimental_map_key(const _experimental_map_key: AnsiString);
      function  Getexperimental_map_key: AnsiString;
      procedure Setweak(const _weak: Boolean);
      function  Getweak: Boolean;
      property ctype: _CType read Getctype write Setctype;
      property &packed: Boolean read Getpacked write Setpacked;
      property lazy: Boolean read Getlazy write Setlazy;
      property deprecated: Boolean read Getdeprecated write Setdeprecated;
      property experimental_map_key: AnsiString read Getexperimental_map_key write Setexperimental_map_key;
      property weak: Boolean read Getweak write Setweak;
  end;
  
  TEnumOptions = object(TProtoMessageObject)
  public type
  
  
  
  private
      Fallow_aliasHas: Boolean;
      Fallow_alias: Boolean;
      Funinterpreted_option: TRepeatedUninterpretedOption;
  
  public
    procedure Serialize(Func: TSerializeFunc); virtual;
    procedure Parse(Func: TParseFunc); virtual;
      procedure Setallow_alias(const _allow_alias: Boolean);
      function  Getallow_alias: Boolean;
      property allow_alias: Boolean read Getallow_alias write Setallow_alias;
  end;
  
  TEnumValueOptions = object(TProtoMessageObject)
  public type
  
  
  
  private
      Funinterpreted_option: TRepeatedUninterpretedOption;
  
  public
    procedure Serialize(Func: TSerializeFunc); virtual;
    procedure Parse(Func: TParseFunc); virtual;
  end;
  
  TServiceOptions = object(TProtoMessageObject)
  public type
  
  
  
  private
      Funinterpreted_option: TRepeatedUninterpretedOption;
  
  public
    procedure Serialize(Func: TSerializeFunc); virtual;
    procedure Parse(Func: TParseFunc); virtual;
  end;
  
  TMethodOptions = object(TProtoMessageObject)
  public type
  
  
  
  private
      Funinterpreted_option: TRepeatedUninterpretedOption;
  
  public
    procedure Serialize(Func: TSerializeFunc); virtual;
    procedure Parse(Func: TParseFunc); virtual;
  end;
  
  TUninterpretedOption = object(TProtoMessageObject)
  public type
  
    PNamePart = ^TNamePart;
    TRepeatedNamePart = {specialize} TRepeated<PNamePart>;
  
    TNamePart = object(TProtoMessageObject)
    public type
    
    
    
    private
        Fname_part: AnsiString;
        Fis_extension: Boolean;
    
    public
      procedure Serialize(Func: TSerializeFunc); virtual;
      procedure Parse(Func: TParseFunc); virtual;
        procedure Setname_part(const _name_part: AnsiString);
        procedure Setis_extension(const _is_extension: Boolean);
    end;
    
  
  private
      Fname: TRepeatedNamePart;
      Fidentifier_valueHas: Boolean;
      Fidentifier_value: AnsiString;
      Fpositive_int_valueHas: Boolean;
      Fpositive_int_value: QWord;
      Fnegative_int_valueHas: Boolean;
      Fnegative_int_value: Int64;
      Fdouble_valueHas: Boolean;
      Fdouble_value: Double;
      Fstring_valueHas: Boolean;
      Fstring_value: TBytes;
      Faggregate_valueHas: Boolean;
      Faggregate_value: AnsiString;
  
  public
    procedure Serialize(Func: TSerializeFunc); virtual;
    procedure Parse(Func: TParseFunc); virtual;
      procedure Setidentifier_value(const _identifier_value: AnsiString);
      function  Getidentifier_value: AnsiString;
      procedure Setpositive_int_value(const _positive_int_value: QWord);
      function  Getpositive_int_value: QWord;
      procedure Setnegative_int_value(const _negative_int_value: Int64);
      function  Getnegative_int_value: Int64;
      procedure Setdouble_value(const _double_value: Double);
      function  Getdouble_value: Double;
      procedure Setstring_value(const _string_value: TBytes);
      function  Getstring_value: TBytes;
      procedure Setaggregate_value(const _aggregate_value: AnsiString);
      function  Getaggregate_value: AnsiString;
      property identifier_value: AnsiString read Getidentifier_value write Setidentifier_value;
      property positive_int_value: QWord read Getpositive_int_value write Setpositive_int_value;
      property negative_int_value: Int64 read Getnegative_int_value write Setnegative_int_value;
      property double_value: Double read Getdouble_value write Setdouble_value;
      property string_value: TBytes read Getstring_value write Setstring_value;
      property aggregate_value: AnsiString read Getaggregate_value write Setaggregate_value;
  end;
  
  TSourceCodeInfo = object(TProtoMessageObject)
  public type
  
    PLocation = ^TLocation;
    TRepeatedLocation = {specialize} TRepeated<PLocation>;
  
    TLocation = object(TProtoMessageObject)
    public type
    
    
    
    private
        Fpath: TRepeatedLongInt;
        Fspan: TRepeatedLongInt;
        Fleading_commentsHas: Boolean;
        Fleading_comments: AnsiString;
        Ftrailing_commentsHas: Boolean;
        Ftrailing_comments: AnsiString;
    
    public
      procedure Serialize(Func: TSerializeFunc); virtual;
      procedure Parse(Func: TParseFunc); virtual;
        procedure Setleading_comments(const _leading_comments: AnsiString);
        function  Getleading_comments: AnsiString;
        procedure Settrailing_comments(const _trailing_comments: AnsiString);
        function  Gettrailing_comments: AnsiString;
        property leading_comments: AnsiString read Getleading_comments write Setleading_comments;
        property trailing_comments: AnsiString read Gettrailing_comments write Settrailing_comments;
    end;
    
  
  private
      Flocation: TRepeatedLocation;
  
  public
    procedure Serialize(Func: TSerializeFunc); virtual;
    procedure Parse(Func: TParseFunc); virtual;
  end;
  


implementation
  
  procedure TFileDescriptorSet.Serialize(Func: TSerializeFunc);
  begin
  end;
  
  procedure TFileDescriptorSet.Parse(Func: TParseFunc);
  begin
  end;
    procedure TFileDescriptorProto.Setname(const _name: AnsiString);
    begin
      Fname := _name;
      FnameHas := True;
    end;
    
    function  TFileDescriptorProto.Getname: AnsiString;
    begin
      // TODO: maybe checking for Has here?
      Result := Fname;
    end;
    procedure TFileDescriptorProto.Setpackage(const _package: AnsiString);
    begin
      Fpackage := _package;
      FpackageHas := True;
    end;
    
    function  TFileDescriptorProto.Getpackage: AnsiString;
    begin
      // TODO: maybe checking for Has here?
      Result := Fpackage;
    end;
    procedure TFileDescriptorProto.Setoptions(const _options: PFileOptions);
    begin
      Foptions := _options;
      FoptionsHas := True;
    end;
    
    function  TFileDescriptorProto.Getoptions: PFileOptions;
    begin
      // TODO: maybe checking for Has here?
      Result := Foptions;
    end;
    procedure TFileDescriptorProto.Setsource_code_info(const _source_code_info: PSourceCodeInfo);
    begin
      Fsource_code_info := _source_code_info;
      Fsource_code_infoHas := True;
    end;
    
    function  TFileDescriptorProto.Getsource_code_info: PSourceCodeInfo;
    begin
      // TODO: maybe checking for Has here?
      Result := Fsource_code_info;
    end;
  
  procedure TFileDescriptorProto.Serialize(Func: TSerializeFunc);
  begin
      if FnameHas then TProtobuf.Serializestring(Func, 10, (Fname));
      if FpackageHas then TProtobuf.Serializestring(Func, 18, (Fpackage));
      if FoptionsHas then Foptions^.Serialize(Func);
      if Fsource_code_infoHas then Fsource_code_info^.Serialize(Func);
  end;
  
  procedure TFileDescriptorProto.Parse(Func: TParseFunc);
  begin
      {1:} TProtobuf.Parsestring(Func, (Fname));
      {2:} TProtobuf.Parsestring(Func, (Fpackage));
      {8:} Foptions^.Parse(Func);
      {9:} Fsource_code_info^.Parse(Func);
  end;
    procedure TDescriptorProto.Setname(const _name: AnsiString);
    begin
      Fname := _name;
      FnameHas := True;
    end;
    
    function  TDescriptorProto.Getname: AnsiString;
    begin
      // TODO: maybe checking for Has here?
      Result := Fname;
    end;
    procedure TDescriptorProto.Setoptions(const _options: PMessageOptions);
    begin
      Foptions := _options;
      FoptionsHas := True;
    end;
    
    function  TDescriptorProto.Getoptions: PMessageOptions;
    begin
      // TODO: maybe checking for Has here?
      Result := Foptions;
    end;
      procedure TDescriptorProto.TExtensionRange.Setstart(const _start: LongInt);
      begin
        Fstart := _start;
        FstartHas := True;
      end;
      
      function  TDescriptorProto.TExtensionRange.Getstart: LongInt;
      begin
        // TODO: maybe checking for Has here?
        Result := Fstart;
      end;
      procedure TDescriptorProto.TExtensionRange.Setend(const _end: LongInt);
      begin
        Fend := _end;
        FendHas := True;
      end;
      
      function  TDescriptorProto.TExtensionRange.Getend: LongInt;
      begin
        // TODO: maybe checking for Has here?
        Result := Fend;
      end;
    
    procedure TDescriptorProto.TExtensionRange.Serialize(Func: TSerializeFunc);
    begin
        if FstartHas then TProtobuf.SerializeInt32(Func, 8, (Fstart));
        if FendHas then TProtobuf.SerializeInt32(Func, 16, (Fend));
    end;
    
    procedure TDescriptorProto.TExtensionRange.Parse(Func: TParseFunc);
    begin
        {1:} TProtobuf.ParseInt32(Func, (Fstart));
        {2:} TProtobuf.ParseInt32(Func, (Fend));
    end;
  
  procedure TDescriptorProto.Serialize(Func: TSerializeFunc);
  begin
      if FnameHas then TProtobuf.Serializestring(Func, 10, (Fname));
      if FoptionsHas then Foptions^.Serialize(Func);
  end;
  
  procedure TDescriptorProto.Parse(Func: TParseFunc);
  begin
      {1:} TProtobuf.Parsestring(Func, (Fname));
      {7:} Foptions^.Parse(Func);
  end;
    procedure TFieldDescriptorProto.Setname(const _name: AnsiString);
    begin
      Fname := _name;
      FnameHas := True;
    end;
    
    function  TFieldDescriptorProto.Getname: AnsiString;
    begin
      // TODO: maybe checking for Has here?
      Result := Fname;
    end;
    procedure TFieldDescriptorProto.Setnumber(const _number: LongInt);
    begin
      Fnumber := _number;
      FnumberHas := True;
    end;
    
    function  TFieldDescriptorProto.Getnumber: LongInt;
    begin
      // TODO: maybe checking for Has here?
      Result := Fnumber;
    end;
    procedure TFieldDescriptorProto.Setlabel(const _label: _Label);
    begin
      Flabel := _label;
      FlabelHas := True;
    end;
    
    function  TFieldDescriptorProto.Getlabel: _Label;
    begin
      // TODO: maybe checking for Has here?
      Result := Flabel;
    end;
    procedure TFieldDescriptorProto.Settype(const _type: _Type);
    begin
      Ftype := _type;
      FtypeHas := True;
    end;
    
    function  TFieldDescriptorProto.Gettype: _Type;
    begin
      // TODO: maybe checking for Has here?
      Result := Ftype;
    end;
    procedure TFieldDescriptorProto.Settype_name(const _type_name: AnsiString);
    begin
      Ftype_name := _type_name;
      Ftype_nameHas := True;
    end;
    
    function  TFieldDescriptorProto.Gettype_name: AnsiString;
    begin
      // TODO: maybe checking for Has here?
      Result := Ftype_name;
    end;
    procedure TFieldDescriptorProto.Setextendee(const _extendee: AnsiString);
    begin
      Fextendee := _extendee;
      FextendeeHas := True;
    end;
    
    function  TFieldDescriptorProto.Getextendee: AnsiString;
    begin
      // TODO: maybe checking for Has here?
      Result := Fextendee;
    end;
    procedure TFieldDescriptorProto.Setdefault_value(const _default_value: AnsiString);
    begin
      Fdefault_value := _default_value;
      Fdefault_valueHas := True;
    end;
    
    function  TFieldDescriptorProto.Getdefault_value: AnsiString;
    begin
      // TODO: maybe checking for Has here?
      Result := Fdefault_value;
    end;
    procedure TFieldDescriptorProto.Setoptions(const _options: PFieldOptions);
    begin
      Foptions := _options;
      FoptionsHas := True;
    end;
    
    function  TFieldDescriptorProto.Getoptions: PFieldOptions;
    begin
      // TODO: maybe checking for Has here?
      Result := Foptions;
    end;
  
  procedure TFieldDescriptorProto.Serialize(Func: TSerializeFunc);
  begin
      if FnameHas then TProtobuf.Serializestring(Func, 10, (Fname));
      if FnumberHas then TProtobuf.SerializeInt32(Func, 24, (Fnumber));
      if FlabelHas then TProtobuf.SerializeEnum(Func, 32, Byte(Flabel));
      if FtypeHas then TProtobuf.SerializeEnum(Func, 40, Byte(Ftype));
      if Ftype_nameHas then TProtobuf.Serializestring(Func, 50, (Ftype_name));
      if FextendeeHas then TProtobuf.Serializestring(Func, 18, (Fextendee));
      if Fdefault_valueHas then TProtobuf.Serializestring(Func, 58, (Fdefault_value));
      if FoptionsHas then Foptions^.Serialize(Func);
  end;
  
  procedure TFieldDescriptorProto.Parse(Func: TParseFunc);
  begin
      {1:} TProtobuf.Parsestring(Func, (Fname));
      {3:} TProtobuf.ParseInt32(Func, (Fnumber));
      {4:} TProtobuf.ParseEnum(Func, Byte(Flabel));
      {5:} TProtobuf.ParseEnum(Func, Byte(Ftype));
      {6:} TProtobuf.Parsestring(Func, (Ftype_name));
      {2:} TProtobuf.Parsestring(Func, (Fextendee));
      {7:} TProtobuf.Parsestring(Func, (Fdefault_value));
      {8:} Foptions^.Parse(Func);
  end;
    procedure TEnumDescriptorProto.Setname(const _name: AnsiString);
    begin
      Fname := _name;
      FnameHas := True;
    end;
    
    function  TEnumDescriptorProto.Getname: AnsiString;
    begin
      // TODO: maybe checking for Has here?
      Result := Fname;
    end;
    procedure TEnumDescriptorProto.Setoptions(const _options: PEnumOptions);
    begin
      Foptions := _options;
      FoptionsHas := True;
    end;
    
    function  TEnumDescriptorProto.Getoptions: PEnumOptions;
    begin
      // TODO: maybe checking for Has here?
      Result := Foptions;
    end;
  
  procedure TEnumDescriptorProto.Serialize(Func: TSerializeFunc);
  begin
      if FnameHas then TProtobuf.Serializestring(Func, 10, (Fname));
      if FoptionsHas then Foptions^.Serialize(Func);
  end;
  
  procedure TEnumDescriptorProto.Parse(Func: TParseFunc);
  begin
      {1:} TProtobuf.Parsestring(Func, (Fname));
      {3:} Foptions^.Parse(Func);
  end;
    procedure TEnumValueDescriptorProto.Setname(const _name: AnsiString);
    begin
      Fname := _name;
      FnameHas := True;
    end;
    
    function  TEnumValueDescriptorProto.Getname: AnsiString;
    begin
      // TODO: maybe checking for Has here?
      Result := Fname;
    end;
    procedure TEnumValueDescriptorProto.Setnumber(const _number: LongInt);
    begin
      Fnumber := _number;
      FnumberHas := True;
    end;
    
    function  TEnumValueDescriptorProto.Getnumber: LongInt;
    begin
      // TODO: maybe checking for Has here?
      Result := Fnumber;
    end;
    procedure TEnumValueDescriptorProto.Setoptions(const _options: PEnumValueOptions);
    begin
      Foptions := _options;
      FoptionsHas := True;
    end;
    
    function  TEnumValueDescriptorProto.Getoptions: PEnumValueOptions;
    begin
      // TODO: maybe checking for Has here?
      Result := Foptions;
    end;
  
  procedure TEnumValueDescriptorProto.Serialize(Func: TSerializeFunc);
  begin
      if FnameHas then TProtobuf.Serializestring(Func, 10, (Fname));
      if FnumberHas then TProtobuf.SerializeInt32(Func, 16, (Fnumber));
      if FoptionsHas then Foptions^.Serialize(Func);
  end;
  
  procedure TEnumValueDescriptorProto.Parse(Func: TParseFunc);
  begin
      {1:} TProtobuf.Parsestring(Func, (Fname));
      {2:} TProtobuf.ParseInt32(Func, (Fnumber));
      {3:} Foptions^.Parse(Func);
  end;
    procedure TServiceDescriptorProto.Setname(const _name: AnsiString);
    begin
      Fname := _name;
      FnameHas := True;
    end;
    
    function  TServiceDescriptorProto.Getname: AnsiString;
    begin
      // TODO: maybe checking for Has here?
      Result := Fname;
    end;
    procedure TServiceDescriptorProto.Setoptions(const _options: PServiceOptions);
    begin
      Foptions := _options;
      FoptionsHas := True;
    end;
    
    function  TServiceDescriptorProto.Getoptions: PServiceOptions;
    begin
      // TODO: maybe checking for Has here?
      Result := Foptions;
    end;
  
  procedure TServiceDescriptorProto.Serialize(Func: TSerializeFunc);
  begin
      if FnameHas then TProtobuf.Serializestring(Func, 10, (Fname));
      if FoptionsHas then Foptions^.Serialize(Func);
  end;
  
  procedure TServiceDescriptorProto.Parse(Func: TParseFunc);
  begin
      {1:} TProtobuf.Parsestring(Func, (Fname));
      {3:} Foptions^.Parse(Func);
  end;
    procedure TMethodDescriptorProto.Setname(const _name: AnsiString);
    begin
      Fname := _name;
      FnameHas := True;
    end;
    
    function  TMethodDescriptorProto.Getname: AnsiString;
    begin
      // TODO: maybe checking for Has here?
      Result := Fname;
    end;
    procedure TMethodDescriptorProto.Setinput_type(const _input_type: AnsiString);
    begin
      Finput_type := _input_type;
      Finput_typeHas := True;
    end;
    
    function  TMethodDescriptorProto.Getinput_type: AnsiString;
    begin
      // TODO: maybe checking for Has here?
      Result := Finput_type;
    end;
    procedure TMethodDescriptorProto.Setoutput_type(const _output_type: AnsiString);
    begin
      Foutput_type := _output_type;
      Foutput_typeHas := True;
    end;
    
    function  TMethodDescriptorProto.Getoutput_type: AnsiString;
    begin
      // TODO: maybe checking for Has here?
      Result := Foutput_type;
    end;
    procedure TMethodDescriptorProto.Setoptions(const _options: PMethodOptions);
    begin
      Foptions := _options;
      FoptionsHas := True;
    end;
    
    function  TMethodDescriptorProto.Getoptions: PMethodOptions;
    begin
      // TODO: maybe checking for Has here?
      Result := Foptions;
    end;
  
  procedure TMethodDescriptorProto.Serialize(Func: TSerializeFunc);
  begin
      if FnameHas then TProtobuf.Serializestring(Func, 10, (Fname));
      if Finput_typeHas then TProtobuf.Serializestring(Func, 18, (Finput_type));
      if Foutput_typeHas then TProtobuf.Serializestring(Func, 26, (Foutput_type));
      if FoptionsHas then Foptions^.Serialize(Func);
  end;
  
  procedure TMethodDescriptorProto.Parse(Func: TParseFunc);
  begin
      {1:} TProtobuf.Parsestring(Func, (Fname));
      {2:} TProtobuf.Parsestring(Func, (Finput_type));
      {3:} TProtobuf.Parsestring(Func, (Foutput_type));
      {4:} Foptions^.Parse(Func);
  end;
    procedure TFileOptions.Setjava_package(const _java_package: AnsiString);
    begin
      Fjava_package := _java_package;
      Fjava_packageHas := True;
    end;
    
    function  TFileOptions.Getjava_package: AnsiString;
    begin
      // TODO: maybe checking for Has here?
      Result := Fjava_package;
    end;
    procedure TFileOptions.Setjava_outer_classname(const _java_outer_classname: AnsiString);
    begin
      Fjava_outer_classname := _java_outer_classname;
      Fjava_outer_classnameHas := True;
    end;
    
    function  TFileOptions.Getjava_outer_classname: AnsiString;
    begin
      // TODO: maybe checking for Has here?
      Result := Fjava_outer_classname;
    end;
    procedure TFileOptions.Setjava_multiple_files(const _java_multiple_files: Boolean);
    begin
      Fjava_multiple_files := _java_multiple_files;
      Fjava_multiple_filesHas := True;
    end;
    
    function  TFileOptions.Getjava_multiple_files: Boolean;
    begin
      // TODO: maybe checking for Has here?
      Result := Fjava_multiple_files;
    end;
    procedure TFileOptions.Setjava_generate_equals_and_hash(const _java_generate_equals_and_hash: Boolean);
    begin
      Fjava_generate_equals_and_hash := _java_generate_equals_and_hash;
      Fjava_generate_equals_and_hashHas := True;
    end;
    
    function  TFileOptions.Getjava_generate_equals_and_hash: Boolean;
    begin
      // TODO: maybe checking for Has here?
      Result := Fjava_generate_equals_and_hash;
    end;
    procedure TFileOptions.Setoptimize_for(const _optimize_for: _OptimizeMode);
    begin
      Foptimize_for := _optimize_for;
      Foptimize_forHas := True;
    end;
    
    function  TFileOptions.Getoptimize_for: _OptimizeMode;
    begin
      // TODO: maybe checking for Has here?
      Result := Foptimize_for;
    end;
    procedure TFileOptions.Setgo_package(const _go_package: AnsiString);
    begin
      Fgo_package := _go_package;
      Fgo_packageHas := True;
    end;
    
    function  TFileOptions.Getgo_package: AnsiString;
    begin
      // TODO: maybe checking for Has here?
      Result := Fgo_package;
    end;
    procedure TFileOptions.Setcc_generic_services(const _cc_generic_services: Boolean);
    begin
      Fcc_generic_services := _cc_generic_services;
      Fcc_generic_servicesHas := True;
    end;
    
    function  TFileOptions.Getcc_generic_services: Boolean;
    begin
      // TODO: maybe checking for Has here?
      Result := Fcc_generic_services;
    end;
    procedure TFileOptions.Setjava_generic_services(const _java_generic_services: Boolean);
    begin
      Fjava_generic_services := _java_generic_services;
      Fjava_generic_servicesHas := True;
    end;
    
    function  TFileOptions.Getjava_generic_services: Boolean;
    begin
      // TODO: maybe checking for Has here?
      Result := Fjava_generic_services;
    end;
    procedure TFileOptions.Setpy_generic_services(const _py_generic_services: Boolean);
    begin
      Fpy_generic_services := _py_generic_services;
      Fpy_generic_servicesHas := True;
    end;
    
    function  TFileOptions.Getpy_generic_services: Boolean;
    begin
      // TODO: maybe checking for Has here?
      Result := Fpy_generic_services;
    end;
  
  procedure TFileOptions.Serialize(Func: TSerializeFunc);
  begin
      if Fjava_packageHas then TProtobuf.Serializestring(Func, 10, (Fjava_package));
      if Fjava_outer_classnameHas then TProtobuf.Serializestring(Func, 66, (Fjava_outer_classname));
      if Fjava_multiple_filesHas then TProtobuf.SerializeBool(Func, 80, (Fjava_multiple_files));
      if Fjava_generate_equals_and_hashHas then TProtobuf.SerializeBool(Func, 160, (Fjava_generate_equals_and_hash));
      if Foptimize_forHas then TProtobuf.SerializeEnum(Func, 72, Byte(Foptimize_for));
      if Fgo_packageHas then TProtobuf.Serializestring(Func, 90, (Fgo_package));
      if Fcc_generic_servicesHas then TProtobuf.SerializeBool(Func, 128, (Fcc_generic_services));
      if Fjava_generic_servicesHas then TProtobuf.SerializeBool(Func, 136, (Fjava_generic_services));
      if Fpy_generic_servicesHas then TProtobuf.SerializeBool(Func, 144, (Fpy_generic_services));
  end;
  
  procedure TFileOptions.Parse(Func: TParseFunc);
  begin
      {1:} TProtobuf.Parsestring(Func, (Fjava_package));
      {8:} TProtobuf.Parsestring(Func, (Fjava_outer_classname));
      {10:} TProtobuf.ParseBool(Func, (Fjava_multiple_files));
      {20:} TProtobuf.ParseBool(Func, (Fjava_generate_equals_and_hash));
      {9:} TProtobuf.ParseEnum(Func, Byte(Foptimize_for));
      {11:} TProtobuf.Parsestring(Func, (Fgo_package));
      {16:} TProtobuf.ParseBool(Func, (Fcc_generic_services));
      {17:} TProtobuf.ParseBool(Func, (Fjava_generic_services));
      {18:} TProtobuf.ParseBool(Func, (Fpy_generic_services));
  end;
    procedure TMessageOptions.Setmessage_set_wire_format(const _message_set_wire_format: Boolean);
    begin
      Fmessage_set_wire_format := _message_set_wire_format;
      Fmessage_set_wire_formatHas := True;
    end;
    
    function  TMessageOptions.Getmessage_set_wire_format: Boolean;
    begin
      // TODO: maybe checking for Has here?
      Result := Fmessage_set_wire_format;
    end;
    procedure TMessageOptions.Setno_standard_descriptor_accessor(const _no_standard_descriptor_accessor: Boolean);
    begin
      Fno_standard_descriptor_accessor := _no_standard_descriptor_accessor;
      Fno_standard_descriptor_accessorHas := True;
    end;
    
    function  TMessageOptions.Getno_standard_descriptor_accessor: Boolean;
    begin
      // TODO: maybe checking for Has here?
      Result := Fno_standard_descriptor_accessor;
    end;
  
  procedure TMessageOptions.Serialize(Func: TSerializeFunc);
  begin
      if Fmessage_set_wire_formatHas then TProtobuf.SerializeBool(Func, 8, (Fmessage_set_wire_format));
      if Fno_standard_descriptor_accessorHas then TProtobuf.SerializeBool(Func, 16, (Fno_standard_descriptor_accessor));
  end;
  
  procedure TMessageOptions.Parse(Func: TParseFunc);
  begin
      {1:} TProtobuf.ParseBool(Func, (Fmessage_set_wire_format));
      {2:} TProtobuf.ParseBool(Func, (Fno_standard_descriptor_accessor));
  end;
    procedure TFieldOptions.Setctype(const _ctype: _CType);
    begin
      Fctype := _ctype;
      FctypeHas := True;
    end;
    
    function  TFieldOptions.Getctype: _CType;
    begin
      // TODO: maybe checking for Has here?
      Result := Fctype;
    end;
    procedure TFieldOptions.Setpacked(const _packed: Boolean);
    begin
      Fpacked := _packed;
      FpackedHas := True;
    end;
    
    function  TFieldOptions.Getpacked: Boolean;
    begin
      // TODO: maybe checking for Has here?
      Result := Fpacked;
    end;
    procedure TFieldOptions.Setlazy(const _lazy: Boolean);
    begin
      Flazy := _lazy;
      FlazyHas := True;
    end;
    
    function  TFieldOptions.Getlazy: Boolean;
    begin
      // TODO: maybe checking for Has here?
      Result := Flazy;
    end;
    procedure TFieldOptions.Setdeprecated(const _deprecated: Boolean);
    begin
      Fdeprecated := _deprecated;
      FdeprecatedHas := True;
    end;
    
    function  TFieldOptions.Getdeprecated: Boolean;
    begin
      // TODO: maybe checking for Has here?
      Result := Fdeprecated;
    end;
    procedure TFieldOptions.Setexperimental_map_key(const _experimental_map_key: AnsiString);
    begin
      Fexperimental_map_key := _experimental_map_key;
      Fexperimental_map_keyHas := True;
    end;
    
    function  TFieldOptions.Getexperimental_map_key: AnsiString;
    begin
      // TODO: maybe checking for Has here?
      Result := Fexperimental_map_key;
    end;
    procedure TFieldOptions.Setweak(const _weak: Boolean);
    begin
      Fweak := _weak;
      FweakHas := True;
    end;
    
    function  TFieldOptions.Getweak: Boolean;
    begin
      // TODO: maybe checking for Has here?
      Result := Fweak;
    end;
  
  procedure TFieldOptions.Serialize(Func: TSerializeFunc);
  begin
      if FctypeHas then TProtobuf.SerializeEnum(Func, 8, Byte(Fctype));
      if FpackedHas then TProtobuf.SerializeBool(Func, 16, (Fpacked));
      if FlazyHas then TProtobuf.SerializeBool(Func, 40, (Flazy));
      if FdeprecatedHas then TProtobuf.SerializeBool(Func, 24, (Fdeprecated));
      if Fexperimental_map_keyHas then TProtobuf.Serializestring(Func, 74, (Fexperimental_map_key));
      if FweakHas then TProtobuf.SerializeBool(Func, 80, (Fweak));
  end;
  
  procedure TFieldOptions.Parse(Func: TParseFunc);
  begin
      {1:} TProtobuf.ParseEnum(Func, Byte(Fctype));
      {2:} TProtobuf.ParseBool(Func, (Fpacked));
      {5:} TProtobuf.ParseBool(Func, (Flazy));
      {3:} TProtobuf.ParseBool(Func, (Fdeprecated));
      {9:} TProtobuf.Parsestring(Func, (Fexperimental_map_key));
      {10:} TProtobuf.ParseBool(Func, (Fweak));
  end;
    procedure TEnumOptions.Setallow_alias(const _allow_alias: Boolean);
    begin
      Fallow_alias := _allow_alias;
      Fallow_aliasHas := True;
    end;
    
    function  TEnumOptions.Getallow_alias: Boolean;
    begin
      // TODO: maybe checking for Has here?
      Result := Fallow_alias;
    end;
  
  procedure TEnumOptions.Serialize(Func: TSerializeFunc);
  begin
      if Fallow_aliasHas then TProtobuf.SerializeBool(Func, 16, (Fallow_alias));
  end;
  
  procedure TEnumOptions.Parse(Func: TParseFunc);
  begin
      {2:} TProtobuf.ParseBool(Func, (Fallow_alias));
  end;
  
  procedure TEnumValueOptions.Serialize(Func: TSerializeFunc);
  begin
  end;
  
  procedure TEnumValueOptions.Parse(Func: TParseFunc);
  begin
  end;
  
  procedure TServiceOptions.Serialize(Func: TSerializeFunc);
  begin
  end;
  
  procedure TServiceOptions.Parse(Func: TParseFunc);
  begin
  end;
  
  procedure TMethodOptions.Serialize(Func: TSerializeFunc);
  begin
  end;
  
  procedure TMethodOptions.Parse(Func: TParseFunc);
  begin
  end;
    procedure TUninterpretedOption.Setidentifier_value(const _identifier_value: AnsiString);
    begin
      Fidentifier_value := _identifier_value;
      Fidentifier_valueHas := True;
    end;
    
    function  TUninterpretedOption.Getidentifier_value: AnsiString;
    begin
      // TODO: maybe checking for Has here?
      Result := Fidentifier_value;
    end;
    procedure TUninterpretedOption.Setpositive_int_value(const _positive_int_value: QWord);
    begin
      Fpositive_int_value := _positive_int_value;
      Fpositive_int_valueHas := True;
    end;
    
    function  TUninterpretedOption.Getpositive_int_value: QWord;
    begin
      // TODO: maybe checking for Has here?
      Result := Fpositive_int_value;
    end;
    procedure TUninterpretedOption.Setnegative_int_value(const _negative_int_value: Int64);
    begin
      Fnegative_int_value := _negative_int_value;
      Fnegative_int_valueHas := True;
    end;
    
    function  TUninterpretedOption.Getnegative_int_value: Int64;
    begin
      // TODO: maybe checking for Has here?
      Result := Fnegative_int_value;
    end;
    procedure TUninterpretedOption.Setdouble_value(const _double_value: Double);
    begin
      Fdouble_value := _double_value;
      Fdouble_valueHas := True;
    end;
    
    function  TUninterpretedOption.Getdouble_value: Double;
    begin
      // TODO: maybe checking for Has here?
      Result := Fdouble_value;
    end;
    procedure TUninterpretedOption.Setstring_value(const _string_value: TBytes);
    begin
      Fstring_value := _string_value;
      Fstring_valueHas := True;
    end;
    
    function  TUninterpretedOption.Getstring_value: TBytes;
    begin
      // TODO: maybe checking for Has here?
      Result := Fstring_value;
    end;
    procedure TUninterpretedOption.Setaggregate_value(const _aggregate_value: AnsiString);
    begin
      Faggregate_value := _aggregate_value;
      Faggregate_valueHas := True;
    end;
    
    function  TUninterpretedOption.Getaggregate_value: AnsiString;
    begin
      // TODO: maybe checking for Has here?
      Result := Faggregate_value;
    end;
      procedure TUninterpretedOption.TNamePart.Setname_part(const _name_part: AnsiString);
      begin
        Fname_part := _name_part;
      end;
      procedure TUninterpretedOption.TNamePart.Setis_extension(const _is_extension: Boolean);
      begin
        Fis_extension := _is_extension;
      end;
    
    procedure TUninterpretedOption.TNamePart.Serialize(Func: TSerializeFunc);
    begin
        TProtobuf.Serializestring(Func, 10, Fname_part);
        TProtobuf.SerializeBool(Func, 16, Fis_extension);
    end;
    
    procedure TUninterpretedOption.TNamePart.Parse(Func: TParseFunc);
    begin
    end;
  
  procedure TUninterpretedOption.Serialize(Func: TSerializeFunc);
  begin
      if Fidentifier_valueHas then TProtobuf.Serializestring(Func, 26, (Fidentifier_value));
      if Fpositive_int_valueHas then TProtobuf.SerializeUInt64(Func, 32, (Fpositive_int_value));
      if Fnegative_int_valueHas then TProtobuf.SerializeInt64(Func, 40, (Fnegative_int_value));
      if Fdouble_valueHas then TProtobuf.SerializeDouble(Func, 49, (Fdouble_value));
      if Fstring_valueHas then TProtobuf.SerializeBytes(Func, 58, (Fstring_value));
      if Faggregate_valueHas then TProtobuf.Serializestring(Func, 66, (Faggregate_value));
  end;
  
  procedure TUninterpretedOption.Parse(Func: TParseFunc);
  begin
      {3:} TProtobuf.Parsestring(Func, (Fidentifier_value));
      {4:} TProtobuf.ParseUInt64(Func, (Fpositive_int_value));
      {5:} TProtobuf.ParseInt64(Func, (Fnegative_int_value));
      {6:} TProtobuf.ParseDouble(Func, (Fdouble_value));
      {7:} TProtobuf.ParseBytes(Func, (Fstring_value));
      {8:} TProtobuf.Parsestring(Func, (Faggregate_value));
  end;
      procedure TSourceCodeInfo.TLocation.Setleading_comments(const _leading_comments: AnsiString);
      begin
        Fleading_comments := _leading_comments;
        Fleading_commentsHas := True;
      end;
      
      function  TSourceCodeInfo.TLocation.Getleading_comments: AnsiString;
      begin
        // TODO: maybe checking for Has here?
        Result := Fleading_comments;
      end;
      procedure TSourceCodeInfo.TLocation.Settrailing_comments(const _trailing_comments: AnsiString);
      begin
        Ftrailing_comments := _trailing_comments;
        Ftrailing_commentsHas := True;
      end;
      
      function  TSourceCodeInfo.TLocation.Gettrailing_comments: AnsiString;
      begin
        // TODO: maybe checking for Has here?
        Result := Ftrailing_comments;
      end;
    
    procedure TSourceCodeInfo.TLocation.Serialize(Func: TSerializeFunc);
    begin
        if Fleading_commentsHas then TProtobuf.Serializestring(Func, 26, (Fleading_comments));
        if Ftrailing_commentsHas then TProtobuf.Serializestring(Func, 34, (Ftrailing_comments));
    end;
    
    procedure TSourceCodeInfo.TLocation.Parse(Func: TParseFunc);
    begin
        {3:} TProtobuf.Parsestring(Func, (Fleading_comments));
        {4:} TProtobuf.Parsestring(Func, (Ftrailing_comments));
    end;
  
  procedure TSourceCodeInfo.Serialize(Func: TSerializeFunc);
  begin
  end;
  
  procedure TSourceCodeInfo.Parse(Func: TParseFunc);
  begin
  end;

end.
