// Custom options for defining:
// - Maximum size of string/bytes
// - Maximum number of elements in array
//
// These are used by nanopb to generate statically allocable structures
// for memory-limited environments.

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v5.29.3
// source: meshtastic/nanopb.proto

package meshtastic

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	descriptorpb "google.golang.org/protobuf/types/descriptorpb"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

type FieldType int32

const (
	FieldType_FT_DEFAULT  FieldType = 0 // Automatically decide field type, generate static field if possible.
	FieldType_FT_CALLBACK FieldType = 1 // Always generate a callback field.
	FieldType_FT_POINTER  FieldType = 4 // Always generate a dynamically allocated field.
	FieldType_FT_STATIC   FieldType = 2 // Generate a static field or raise an exception if not possible.
	FieldType_FT_IGNORE   FieldType = 3 // Ignore the field completely.
	FieldType_FT_INLINE   FieldType = 5 // Legacy option, use the separate 'fixed_length' option instead
)

// Enum value maps for FieldType.
var (
	FieldType_name = map[int32]string{
		0: "FT_DEFAULT",
		1: "FT_CALLBACK",
		4: "FT_POINTER",
		2: "FT_STATIC",
		3: "FT_IGNORE",
		5: "FT_INLINE",
	}
	FieldType_value = map[string]int32{
		"FT_DEFAULT":  0,
		"FT_CALLBACK": 1,
		"FT_POINTER":  4,
		"FT_STATIC":   2,
		"FT_IGNORE":   3,
		"FT_INLINE":   5,
	}
)

func (x FieldType) Enum() *FieldType {
	p := new(FieldType)
	*p = x
	return p
}

func (x FieldType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (FieldType) Descriptor() protoreflect.EnumDescriptor {
	return file_meshtastic_nanopb_proto_enumTypes[0].Descriptor()
}

func (FieldType) Type() protoreflect.EnumType {
	return &file_meshtastic_nanopb_proto_enumTypes[0]
}

func (x FieldType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Do not use.
func (x *FieldType) UnmarshalJSON(b []byte) error {
	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
	if err != nil {
		return err
	}
	*x = FieldType(num)
	return nil
}

// Deprecated: Use FieldType.Descriptor instead.
func (FieldType) EnumDescriptor() ([]byte, []int) {
	return file_meshtastic_nanopb_proto_rawDescGZIP(), []int{0}
}

type IntSize int32

const (
	IntSize_IS_DEFAULT IntSize = 0 // Default, 32/64bit based on type in .proto
	IntSize_IS_8       IntSize = 8
	IntSize_IS_16      IntSize = 16
	IntSize_IS_32      IntSize = 32
	IntSize_IS_64      IntSize = 64
)

// Enum value maps for IntSize.
var (
	IntSize_name = map[int32]string{
		0:  "IS_DEFAULT",
		8:  "IS_8",
		16: "IS_16",
		32: "IS_32",
		64: "IS_64",
	}
	IntSize_value = map[string]int32{
		"IS_DEFAULT": 0,
		"IS_8":       8,
		"IS_16":      16,
		"IS_32":      32,
		"IS_64":      64,
	}
)

func (x IntSize) Enum() *IntSize {
	p := new(IntSize)
	*p = x
	return p
}

func (x IntSize) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (IntSize) Descriptor() protoreflect.EnumDescriptor {
	return file_meshtastic_nanopb_proto_enumTypes[1].Descriptor()
}

func (IntSize) Type() protoreflect.EnumType {
	return &file_meshtastic_nanopb_proto_enumTypes[1]
}

func (x IntSize) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Do not use.
func (x *IntSize) UnmarshalJSON(b []byte) error {
	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
	if err != nil {
		return err
	}
	*x = IntSize(num)
	return nil
}

// Deprecated: Use IntSize.Descriptor instead.
func (IntSize) EnumDescriptor() ([]byte, []int) {
	return file_meshtastic_nanopb_proto_rawDescGZIP(), []int{1}
}

type TypenameMangling int32

const (
	TypenameMangling_M_NONE             TypenameMangling = 0 // Default, no typename mangling
	TypenameMangling_M_STRIP_PACKAGE    TypenameMangling = 1 // Strip current package name
	TypenameMangling_M_FLATTEN          TypenameMangling = 2 // Only use last path component
	TypenameMangling_M_PACKAGE_INITIALS TypenameMangling = 3 // Replace the package name by the initials
)

// Enum value maps for TypenameMangling.
var (
	TypenameMangling_name = map[int32]string{
		0: "M_NONE",
		1: "M_STRIP_PACKAGE",
		2: "M_FLATTEN",
		3: "M_PACKAGE_INITIALS",
	}
	TypenameMangling_value = map[string]int32{
		"M_NONE":             0,
		"M_STRIP_PACKAGE":    1,
		"M_FLATTEN":          2,
		"M_PACKAGE_INITIALS": 3,
	}
)

func (x TypenameMangling) Enum() *TypenameMangling {
	p := new(TypenameMangling)
	*p = x
	return p
}

func (x TypenameMangling) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (TypenameMangling) Descriptor() protoreflect.EnumDescriptor {
	return file_meshtastic_nanopb_proto_enumTypes[2].Descriptor()
}

func (TypenameMangling) Type() protoreflect.EnumType {
	return &file_meshtastic_nanopb_proto_enumTypes[2]
}

func (x TypenameMangling) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Do not use.
func (x *TypenameMangling) UnmarshalJSON(b []byte) error {
	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
	if err != nil {
		return err
	}
	*x = TypenameMangling(num)
	return nil
}

// Deprecated: Use TypenameMangling.Descriptor instead.
func (TypenameMangling) EnumDescriptor() ([]byte, []int) {
	return file_meshtastic_nanopb_proto_rawDescGZIP(), []int{2}
}

type DescriptorSize int32

const (
	DescriptorSize_DS_AUTO DescriptorSize = 0 // Select minimal size based on field type
	DescriptorSize_DS_1    DescriptorSize = 1 // 1 word; up to 15 byte fields, no arrays
	DescriptorSize_DS_2    DescriptorSize = 2 // 2 words; up to 4095 byte fields, 4095 entry arrays
	DescriptorSize_DS_4    DescriptorSize = 4 // 4 words; up to 2^32-1 byte fields, 2^16-1 entry arrays
	DescriptorSize_DS_8    DescriptorSize = 8 // 8 words; up to 2^32-1 entry arrays
)

// Enum value maps for DescriptorSize.
var (
	DescriptorSize_name = map[int32]string{
		0: "DS_AUTO",
		1: "DS_1",
		2: "DS_2",
		4: "DS_4",
		8: "DS_8",
	}
	DescriptorSize_value = map[string]int32{
		"DS_AUTO": 0,
		"DS_1":    1,
		"DS_2":    2,
		"DS_4":    4,
		"DS_8":    8,
	}
)

func (x DescriptorSize) Enum() *DescriptorSize {
	p := new(DescriptorSize)
	*p = x
	return p
}

func (x DescriptorSize) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (DescriptorSize) Descriptor() protoreflect.EnumDescriptor {
	return file_meshtastic_nanopb_proto_enumTypes[3].Descriptor()
}

func (DescriptorSize) Type() protoreflect.EnumType {
	return &file_meshtastic_nanopb_proto_enumTypes[3]
}

func (x DescriptorSize) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Do not use.
func (x *DescriptorSize) UnmarshalJSON(b []byte) error {
	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
	if err != nil {
		return err
	}
	*x = DescriptorSize(num)
	return nil
}

// Deprecated: Use DescriptorSize.Descriptor instead.
func (DescriptorSize) EnumDescriptor() ([]byte, []int) {
	return file_meshtastic_nanopb_proto_rawDescGZIP(), []int{3}
}

// This is the inner options message, which basically defines options for
// a field. When it is used in message or file scope, it applies to all
// fields.
type NanoPBOptions struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Allocated size for 'bytes' and 'string' fields.
	// For string fields, this should include the space for null terminator.
	MaxSize *int32 `protobuf:"varint,1,opt,name=max_size,json=maxSize" json:"max_size,omitempty"`
	// Maximum length for 'string' fields. Setting this is equivalent
	// to setting max_size to a value of length+1.
	MaxLength *int32 `protobuf:"varint,14,opt,name=max_length,json=maxLength" json:"max_length,omitempty"`
	// Allocated number of entries in arrays ('repeated' fields)
	MaxCount *int32 `protobuf:"varint,2,opt,name=max_count,json=maxCount" json:"max_count,omitempty"`
	// Size of integer fields. Can save some memory if you don't need
	// full 32 bits for the value.
	IntSize *IntSize `protobuf:"varint,7,opt,name=int_size,json=intSize,enum=IntSize,def=0" json:"int_size,omitempty"`
	// Force type of field (callback or static allocation)
	Type *FieldType `protobuf:"varint,3,opt,name=type,enum=FieldType,def=0" json:"type,omitempty"`
	// Use long names for enums, i.e. EnumName_EnumValue.
	LongNames *bool `protobuf:"varint,4,opt,name=long_names,json=longNames,def=1" json:"long_names,omitempty"`
	// Add 'packed' attribute to generated structs.
	// Note: this cannot be used on CPUs that break on unaligned
	// accesses to variables.
	PackedStruct *bool `protobuf:"varint,5,opt,name=packed_struct,json=packedStruct,def=0" json:"packed_struct,omitempty"`
	// Add 'packed' attribute to generated enums.
	PackedEnum *bool `protobuf:"varint,10,opt,name=packed_enum,json=packedEnum,def=0" json:"packed_enum,omitempty"`
	// Skip this message
	SkipMessage *bool `protobuf:"varint,6,opt,name=skip_message,json=skipMessage,def=0" json:"skip_message,omitempty"`
	// Generate oneof fields as normal optional fields instead of union.
	NoUnions *bool `protobuf:"varint,8,opt,name=no_unions,json=noUnions,def=0" json:"no_unions,omitempty"`
	// integer type tag for a message
	Msgid *uint32 `protobuf:"varint,9,opt,name=msgid" json:"msgid,omitempty"`
	// decode oneof as anonymous union
	AnonymousOneof *bool `protobuf:"varint,11,opt,name=anonymous_oneof,json=anonymousOneof,def=0" json:"anonymous_oneof,omitempty"`
	// Proto3 singular field does not generate a "has_" flag
	Proto3 *bool `protobuf:"varint,12,opt,name=proto3,def=0" json:"proto3,omitempty"`
	// Force proto3 messages to have no "has_" flag.
	// This was default behavior until nanopb-0.4.0.
	Proto3SingularMsgs *bool `protobuf:"varint,21,opt,name=proto3_singular_msgs,json=proto3SingularMsgs,def=0" json:"proto3_singular_msgs,omitempty"`
	// Generate an enum->string mapping function (can take up lots of space).
	EnumToString *bool `protobuf:"varint,13,opt,name=enum_to_string,json=enumToString,def=0" json:"enum_to_string,omitempty"`
	// Generate bytes arrays with fixed length
	FixedLength *bool `protobuf:"varint,15,opt,name=fixed_length,json=fixedLength,def=0" json:"fixed_length,omitempty"`
	// Generate repeated field with fixed count
	FixedCount *bool `protobuf:"varint,16,opt,name=fixed_count,json=fixedCount,def=0" json:"fixed_count,omitempty"`
	// Generate message-level callback that is called before decoding submessages.
	// This can be used to set callback fields for submsgs inside oneofs.
	SubmsgCallback *bool `protobuf:"varint,22,opt,name=submsg_callback,json=submsgCallback,def=0" json:"submsg_callback,omitempty"`
	// Shorten or remove package names from type names.
	// This option applies only on the file level.
	MangleNames *TypenameMangling `protobuf:"varint,17,opt,name=mangle_names,json=mangleNames,enum=TypenameMangling,def=0" json:"mangle_names,omitempty"`
	// Data type for storage associated with callback fields.
	CallbackDatatype *string `protobuf:"bytes,18,opt,name=callback_datatype,json=callbackDatatype,def=pb_callback_t" json:"callback_datatype,omitempty"`
	// Callback function used for encoding and decoding.
	// Prior to nanopb-0.4.0, the callback was specified in per-field pb_callback_t
	// structure. This is still supported, but does not work inside e.g. oneof or pointer
	// fields. Instead, a new method allows specifying a per-message callback that
	// will be called for all callback fields in a message type.
	CallbackFunction *string `protobuf:"bytes,19,opt,name=callback_function,json=callbackFunction,def=pb_default_field_callback" json:"callback_function,omitempty"`
	// Select the size of field descriptors. This option has to be defined
	// for the whole message, not per-field. Usually automatic selection is
	// ok, but if it results in compilation errors you can increase the field
	// size here.
	Descriptorsize *DescriptorSize `protobuf:"varint,20,opt,name=descriptorsize,enum=DescriptorSize,def=0" json:"descriptorsize,omitempty"`
	// Set default value for has_ fields.
	DefaultHas *bool `protobuf:"varint,23,opt,name=default_has,json=defaultHas,def=0" json:"default_has,omitempty"`
	// Extra files to include in generated `.pb.h`
	Include []string `protobuf:"bytes,24,rep,name=include" json:"include,omitempty"`
	// Automatic includes to exclude from generated `.pb.h`
	// Same as nanopb_generator.py command line flag -x.
	Exclude []string `protobuf:"bytes,26,rep,name=exclude" json:"exclude,omitempty"`
	// Package name that applies only for nanopb.
	Package *string `protobuf:"bytes,25,opt,name=package" json:"package,omitempty"`
	// Override type of the field in generated C code. Only to be used with related field types
	TypeOverride *descriptorpb.FieldDescriptorProto_Type `protobuf:"varint,27,opt,name=type_override,json=typeOverride,enum=google.protobuf.FieldDescriptorProto_Type" json:"type_override,omitempty"`
	// Due to historical reasons, nanopb orders fields in structs by their tag number
	// instead of the order in .proto. Set this to false to keep the .proto order.
	// The default value will probably change to false in nanopb-0.5.0.
	SortByTag *bool `protobuf:"varint,28,opt,name=sort_by_tag,json=sortByTag,def=1" json:"sort_by_tag,omitempty"`
	// Set the FT_DEFAULT field conversion strategy.
	// A field that can become a static member of a c struct (e.g. int, bool, etc)
	// will be a a static field.
	// Fields with dynamic length are converted to either a pointer or a callback.
	FallbackType  *FieldType `protobuf:"varint,29,opt,name=fallback_type,json=fallbackType,enum=FieldType,def=1" json:"fallback_type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

// Default values for NanoPBOptions fields.
const (
	Default_NanoPBOptions_IntSize            = IntSize_IS_DEFAULT
	Default_NanoPBOptions_Type               = FieldType_FT_DEFAULT
	Default_NanoPBOptions_LongNames          = bool(true)
	Default_NanoPBOptions_PackedStruct       = bool(false)
	Default_NanoPBOptions_PackedEnum         = bool(false)
	Default_NanoPBOptions_SkipMessage        = bool(false)
	Default_NanoPBOptions_NoUnions           = bool(false)
	Default_NanoPBOptions_AnonymousOneof     = bool(false)
	Default_NanoPBOptions_Proto3             = bool(false)
	Default_NanoPBOptions_Proto3SingularMsgs = bool(false)
	Default_NanoPBOptions_EnumToString       = bool(false)
	Default_NanoPBOptions_FixedLength        = bool(false)
	Default_NanoPBOptions_FixedCount         = bool(false)
	Default_NanoPBOptions_SubmsgCallback     = bool(false)
	Default_NanoPBOptions_MangleNames        = TypenameMangling_M_NONE
	Default_NanoPBOptions_CallbackDatatype   = string("pb_callback_t")
	Default_NanoPBOptions_CallbackFunction   = string("pb_default_field_callback")
	Default_NanoPBOptions_Descriptorsize     = DescriptorSize_DS_AUTO
	Default_NanoPBOptions_DefaultHas         = bool(false)
	Default_NanoPBOptions_SortByTag          = bool(true)
	Default_NanoPBOptions_FallbackType       = FieldType_FT_CALLBACK
)

func (x *NanoPBOptions) Reset() {
	*x = NanoPBOptions{}
	mi := &file_meshtastic_nanopb_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *NanoPBOptions) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*NanoPBOptions) ProtoMessage() {}

func (x *NanoPBOptions) ProtoReflect() protoreflect.Message {
	mi := &file_meshtastic_nanopb_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use NanoPBOptions.ProtoReflect.Descriptor instead.
func (*NanoPBOptions) Descriptor() ([]byte, []int) {
	return file_meshtastic_nanopb_proto_rawDescGZIP(), []int{0}
}

func (x *NanoPBOptions) GetMaxSize() int32 {
	if x != nil && x.MaxSize != nil {
		return *x.MaxSize
	}
	return 0
}

func (x *NanoPBOptions) GetMaxLength() int32 {
	if x != nil && x.MaxLength != nil {
		return *x.MaxLength
	}
	return 0
}

func (x *NanoPBOptions) GetMaxCount() int32 {
	if x != nil && x.MaxCount != nil {
		return *x.MaxCount
	}
	return 0
}

func (x *NanoPBOptions) GetIntSize() IntSize {
	if x != nil && x.IntSize != nil {
		return *x.IntSize
	}
	return Default_NanoPBOptions_IntSize
}

func (x *NanoPBOptions) GetType() FieldType {
	if x != nil && x.Type != nil {
		return *x.Type
	}
	return Default_NanoPBOptions_Type
}

func (x *NanoPBOptions) GetLongNames() bool {
	if x != nil && x.LongNames != nil {
		return *x.LongNames
	}
	return Default_NanoPBOptions_LongNames
}

func (x *NanoPBOptions) GetPackedStruct() bool {
	if x != nil && x.PackedStruct != nil {
		return *x.PackedStruct
	}
	return Default_NanoPBOptions_PackedStruct
}

func (x *NanoPBOptions) GetPackedEnum() bool {
	if x != nil && x.PackedEnum != nil {
		return *x.PackedEnum
	}
	return Default_NanoPBOptions_PackedEnum
}

func (x *NanoPBOptions) GetSkipMessage() bool {
	if x != nil && x.SkipMessage != nil {
		return *x.SkipMessage
	}
	return Default_NanoPBOptions_SkipMessage
}

func (x *NanoPBOptions) GetNoUnions() bool {
	if x != nil && x.NoUnions != nil {
		return *x.NoUnions
	}
	return Default_NanoPBOptions_NoUnions
}

func (x *NanoPBOptions) GetMsgid() uint32 {
	if x != nil && x.Msgid != nil {
		return *x.Msgid
	}
	return 0
}

func (x *NanoPBOptions) GetAnonymousOneof() bool {
	if x != nil && x.AnonymousOneof != nil {
		return *x.AnonymousOneof
	}
	return Default_NanoPBOptions_AnonymousOneof
}

func (x *NanoPBOptions) GetProto3() bool {
	if x != nil && x.Proto3 != nil {
		return *x.Proto3
	}
	return Default_NanoPBOptions_Proto3
}

func (x *NanoPBOptions) GetProto3SingularMsgs() bool {
	if x != nil && x.Proto3SingularMsgs != nil {
		return *x.Proto3SingularMsgs
	}
	return Default_NanoPBOptions_Proto3SingularMsgs
}

func (x *NanoPBOptions) GetEnumToString() bool {
	if x != nil && x.EnumToString != nil {
		return *x.EnumToString
	}
	return Default_NanoPBOptions_EnumToString
}

func (x *NanoPBOptions) GetFixedLength() bool {
	if x != nil && x.FixedLength != nil {
		return *x.FixedLength
	}
	return Default_NanoPBOptions_FixedLength
}

func (x *NanoPBOptions) GetFixedCount() bool {
	if x != nil && x.FixedCount != nil {
		return *x.FixedCount
	}
	return Default_NanoPBOptions_FixedCount
}

func (x *NanoPBOptions) GetSubmsgCallback() bool {
	if x != nil && x.SubmsgCallback != nil {
		return *x.SubmsgCallback
	}
	return Default_NanoPBOptions_SubmsgCallback
}

func (x *NanoPBOptions) GetMangleNames() TypenameMangling {
	if x != nil && x.MangleNames != nil {
		return *x.MangleNames
	}
	return Default_NanoPBOptions_MangleNames
}

func (x *NanoPBOptions) GetCallbackDatatype() string {
	if x != nil && x.CallbackDatatype != nil {
		return *x.CallbackDatatype
	}
	return Default_NanoPBOptions_CallbackDatatype
}

func (x *NanoPBOptions) GetCallbackFunction() string {
	if x != nil && x.CallbackFunction != nil {
		return *x.CallbackFunction
	}
	return Default_NanoPBOptions_CallbackFunction
}

func (x *NanoPBOptions) GetDescriptorsize() DescriptorSize {
	if x != nil && x.Descriptorsize != nil {
		return *x.Descriptorsize
	}
	return Default_NanoPBOptions_Descriptorsize
}

func (x *NanoPBOptions) GetDefaultHas() bool {
	if x != nil && x.DefaultHas != nil {
		return *x.DefaultHas
	}
	return Default_NanoPBOptions_DefaultHas
}

func (x *NanoPBOptions) GetInclude() []string {
	if x != nil {
		return x.Include
	}
	return nil
}

func (x *NanoPBOptions) GetExclude() []string {
	if x != nil {
		return x.Exclude
	}
	return nil
}

func (x *NanoPBOptions) GetPackage() string {
	if x != nil && x.Package != nil {
		return *x.Package
	}
	return ""
}

func (x *NanoPBOptions) GetTypeOverride() descriptorpb.FieldDescriptorProto_Type {
	if x != nil && x.TypeOverride != nil {
		return *x.TypeOverride
	}
	return descriptorpb.FieldDescriptorProto_Type(1)
}

func (x *NanoPBOptions) GetSortByTag() bool {
	if x != nil && x.SortByTag != nil {
		return *x.SortByTag
	}
	return Default_NanoPBOptions_SortByTag
}

func (x *NanoPBOptions) GetFallbackType() FieldType {
	if x != nil && x.FallbackType != nil {
		return *x.FallbackType
	}
	return Default_NanoPBOptions_FallbackType
}

var file_meshtastic_nanopb_proto_extTypes = []protoimpl.ExtensionInfo{
	{
		ExtendedType:  (*descriptorpb.FileOptions)(nil),
		ExtensionType: (*NanoPBOptions)(nil),
		Field:         1010,
		Name:          "nanopb_fileopt",
		Tag:           "bytes,1010,opt,name=nanopb_fileopt",
		Filename:      "meshtastic/nanopb.proto",
	},
	{
		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
		ExtensionType: (*NanoPBOptions)(nil),
		Field:         1010,
		Name:          "nanopb_msgopt",
		Tag:           "bytes,1010,opt,name=nanopb_msgopt",
		Filename:      "meshtastic/nanopb.proto",
	},
	{
		ExtendedType:  (*descriptorpb.EnumOptions)(nil),
		ExtensionType: (*NanoPBOptions)(nil),
		Field:         1010,
		Name:          "nanopb_enumopt",
		Tag:           "bytes,1010,opt,name=nanopb_enumopt",
		Filename:      "meshtastic/nanopb.proto",
	},
	{
		ExtendedType:  (*descriptorpb.FieldOptions)(nil),
		ExtensionType: (*NanoPBOptions)(nil),
		Field:         1010,
		Name:          "nanopb",
		Tag:           "bytes,1010,opt,name=nanopb",
		Filename:      "meshtastic/nanopb.proto",
	},
}

// Extension fields to descriptorpb.FileOptions.
var (
	// optional NanoPBOptions nanopb_fileopt = 1010;
	E_NanopbFileopt = &file_meshtastic_nanopb_proto_extTypes[0]
)

// Extension fields to descriptorpb.MessageOptions.
var (
	// optional NanoPBOptions nanopb_msgopt = 1010;
	E_NanopbMsgopt = &file_meshtastic_nanopb_proto_extTypes[1]
)

// Extension fields to descriptorpb.EnumOptions.
var (
	// optional NanoPBOptions nanopb_enumopt = 1010;
	E_NanopbEnumopt = &file_meshtastic_nanopb_proto_extTypes[2]
)

// Extension fields to descriptorpb.FieldOptions.
var (
	// optional NanoPBOptions nanopb = 1010;
	E_Nanopb = &file_meshtastic_nanopb_proto_extTypes[3]
)

var File_meshtastic_nanopb_proto protoreflect.FileDescriptor

const file_meshtastic_nanopb_proto_rawDesc = "" +
	"\n" +
	"\x17meshtastic/nanopb.proto\x1a google/protobuf/descriptor.proto\"\x86\n" +
	"\n" +
	"\rNanoPBOptions\x12\x19\n" +
	"\bmax_size\x18\x01 \x01(\x05R\amaxSize\x12\x1d\n" +
	"\n" +
	"max_length\x18\x0e \x01(\x05R\tmaxLength\x12\x1b\n" +
	"\tmax_count\x18\x02 \x01(\x05R\bmaxCount\x12/\n" +
	"\bint_size\x18\a \x01(\x0e2\b.IntSize:\n" +
	"IS_DEFAULTR\aintSize\x12*\n" +
	"\x04type\x18\x03 \x01(\x0e2\n" +
	".FieldType:\n" +
	"FT_DEFAULTR\x04type\x12#\n" +
	"\n" +
	"long_names\x18\x04 \x01(\b:\x04trueR\tlongNames\x12*\n" +
	"\rpacked_struct\x18\x05 \x01(\b:\x05falseR\fpackedStruct\x12&\n" +
	"\vpacked_enum\x18\n" +
	" \x01(\b:\x05falseR\n" +
	"packedEnum\x12(\n" +
	"\fskip_message\x18\x06 \x01(\b:\x05falseR\vskipMessage\x12\"\n" +
	"\tno_unions\x18\b \x01(\b:\x05falseR\bnoUnions\x12\x14\n" +
	"\x05msgid\x18\t \x01(\rR\x05msgid\x12.\n" +
	"\x0fanonymous_oneof\x18\v \x01(\b:\x05falseR\x0eanonymousOneof\x12\x1d\n" +
	"\x06proto3\x18\f \x01(\b:\x05falseR\x06proto3\x127\n" +
	"\x14proto3_singular_msgs\x18\x15 \x01(\b:\x05falseR\x12proto3SingularMsgs\x12+\n" +
	"\x0eenum_to_string\x18\r \x01(\b:\x05falseR\fenumToString\x12(\n" +
	"\ffixed_length\x18\x0f \x01(\b:\x05falseR\vfixedLength\x12&\n" +
	"\vfixed_count\x18\x10 \x01(\b:\x05falseR\n" +
	"fixedCount\x12.\n" +
	"\x0fsubmsg_callback\x18\x16 \x01(\b:\x05falseR\x0esubmsgCallback\x12<\n" +
	"\fmangle_names\x18\x11 \x01(\x0e2\x11.TypenameMangling:\x06M_NONER\vmangleNames\x12:\n" +
	"\x11callback_datatype\x18\x12 \x01(\t:\rpb_callback_tR\x10callbackDatatype\x12F\n" +
	"\x11callback_function\x18\x13 \x01(\t:\x19pb_default_field_callbackR\x10callbackFunction\x12@\n" +
	"\x0edescriptorsize\x18\x14 \x01(\x0e2\x0f.DescriptorSize:\aDS_AUTOR\x0edescriptorsize\x12&\n" +
	"\vdefault_has\x18\x17 \x01(\b:\x05falseR\n" +
	"defaultHas\x12\x18\n" +
	"\ainclude\x18\x18 \x03(\tR\ainclude\x12\x18\n" +
	"\aexclude\x18\x1a \x03(\tR\aexclude\x12\x18\n" +
	"\apackage\x18\x19 \x01(\tR\apackage\x12O\n" +
	"\rtype_override\x18\x1b \x01(\x0e2*.google.protobuf.FieldDescriptorProto.TypeR\ftypeOverride\x12$\n" +
	"\vsort_by_tag\x18\x1c \x01(\b:\x04trueR\tsortByTag\x12<\n" +
	"\rfallback_type\x18\x1d \x01(\x0e2\n" +
	".FieldType:\vFT_CALLBACKR\ffallbackType*i\n" +
	"\tFieldType\x12\x0e\n" +
	"\n" +
	"FT_DEFAULT\x10\x00\x12\x0f\n" +
	"\vFT_CALLBACK\x10\x01\x12\x0e\n" +
	"\n" +
	"FT_POINTER\x10\x04\x12\r\n" +
	"\tFT_STATIC\x10\x02\x12\r\n" +
	"\tFT_IGNORE\x10\x03\x12\r\n" +
	"\tFT_INLINE\x10\x05*D\n" +
	"\aIntSize\x12\x0e\n" +
	"\n" +
	"IS_DEFAULT\x10\x00\x12\b\n" +
	"\x04IS_8\x10\b\x12\t\n" +
	"\x05IS_16\x10\x10\x12\t\n" +
	"\x05IS_32\x10 \x12\t\n" +
	"\x05IS_64\x10@*Z\n" +
	"\x10TypenameMangling\x12\n" +
	"\n" +
	"\x06M_NONE\x10\x00\x12\x13\n" +
	"\x0fM_STRIP_PACKAGE\x10\x01\x12\r\n" +
	"\tM_FLATTEN\x10\x02\x12\x16\n" +
	"\x12M_PACKAGE_INITIALS\x10\x03*E\n" +
	"\x0eDescriptorSize\x12\v\n" +
	"\aDS_AUTO\x10\x00\x12\b\n" +
	"\x04DS_1\x10\x01\x12\b\n" +
	"\x04DS_2\x10\x02\x12\b\n" +
	"\x04DS_4\x10\x04\x12\b\n" +
	"\x04DS_8\x10\b:T\n" +
	"\x0enanopb_fileopt\x12\x1c.google.protobuf.FileOptions\x18\xf2\a \x01(\v2\x0e.NanoPBOptionsR\rnanopbFileopt:U\n" +
	"\rnanopb_msgopt\x12\x1f.google.protobuf.MessageOptions\x18\xf2\a \x01(\v2\x0e.NanoPBOptionsR\fnanopbMsgopt:T\n" +
	"\x0enanopb_enumopt\x12\x1c.google.protobuf.EnumOptions\x18\xf2\a \x01(\v2\x0e.NanoPBOptionsR\rnanopbEnumopt:F\n" +
	"\x06nanopb\x12\x1d.google.protobuf.FieldOptions\x18\xf2\a \x01(\v2\x0e.NanoPBOptionsR\x06nanopbB;\n" +
	"\x18fi.kapsi.koti.jpa.nanopbZ\x1fmeshstream/generated/meshtastic"

var (
	file_meshtastic_nanopb_proto_rawDescOnce sync.Once
	file_meshtastic_nanopb_proto_rawDescData []byte
)

func file_meshtastic_nanopb_proto_rawDescGZIP() []byte {
	file_meshtastic_nanopb_proto_rawDescOnce.Do(func() {
		file_meshtastic_nanopb_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_meshtastic_nanopb_proto_rawDesc), len(file_meshtastic_nanopb_proto_rawDesc)))
	})
	return file_meshtastic_nanopb_proto_rawDescData
}

var file_meshtastic_nanopb_proto_enumTypes = make([]protoimpl.EnumInfo, 4)
var file_meshtastic_nanopb_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
var file_meshtastic_nanopb_proto_goTypes = []any{
	(FieldType)(0),        // 0: FieldType
	(IntSize)(0),          // 1: IntSize
	(TypenameMangling)(0), // 2: TypenameMangling
	(DescriptorSize)(0),   // 3: DescriptorSize
	(*NanoPBOptions)(nil), // 4: NanoPBOptions
	(descriptorpb.FieldDescriptorProto_Type)(0), // 5: google.protobuf.FieldDescriptorProto.Type
	(*descriptorpb.FileOptions)(nil),            // 6: google.protobuf.FileOptions
	(*descriptorpb.MessageOptions)(nil),         // 7: google.protobuf.MessageOptions
	(*descriptorpb.EnumOptions)(nil),            // 8: google.protobuf.EnumOptions
	(*descriptorpb.FieldOptions)(nil),           // 9: google.protobuf.FieldOptions
}
var file_meshtastic_nanopb_proto_depIdxs = []int32{
	1,  // 0: NanoPBOptions.int_size:type_name -> IntSize
	0,  // 1: NanoPBOptions.type:type_name -> FieldType
	2,  // 2: NanoPBOptions.mangle_names:type_name -> TypenameMangling
	3,  // 3: NanoPBOptions.descriptorsize:type_name -> DescriptorSize
	5,  // 4: NanoPBOptions.type_override:type_name -> google.protobuf.FieldDescriptorProto.Type
	0,  // 5: NanoPBOptions.fallback_type:type_name -> FieldType
	6,  // 6: nanopb_fileopt:extendee -> google.protobuf.FileOptions
	7,  // 7: nanopb_msgopt:extendee -> google.protobuf.MessageOptions
	8,  // 8: nanopb_enumopt:extendee -> google.protobuf.EnumOptions
	9,  // 9: nanopb:extendee -> google.protobuf.FieldOptions
	4,  // 10: nanopb_fileopt:type_name -> NanoPBOptions
	4,  // 11: nanopb_msgopt:type_name -> NanoPBOptions
	4,  // 12: nanopb_enumopt:type_name -> NanoPBOptions
	4,  // 13: nanopb:type_name -> NanoPBOptions
	14, // [14:14] is the sub-list for method output_type
	14, // [14:14] is the sub-list for method input_type
	10, // [10:14] is the sub-list for extension type_name
	6,  // [6:10] is the sub-list for extension extendee
	0,  // [0:6] is the sub-list for field type_name
}

func init() { file_meshtastic_nanopb_proto_init() }
func file_meshtastic_nanopb_proto_init() {
	if File_meshtastic_nanopb_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_meshtastic_nanopb_proto_rawDesc), len(file_meshtastic_nanopb_proto_rawDesc)),
			NumEnums:      4,
			NumMessages:   1,
			NumExtensions: 4,
			NumServices:   0,
		},
		GoTypes:           file_meshtastic_nanopb_proto_goTypes,
		DependencyIndexes: file_meshtastic_nanopb_proto_depIdxs,
		EnumInfos:         file_meshtastic_nanopb_proto_enumTypes,
		MessageInfos:      file_meshtastic_nanopb_proto_msgTypes,
		ExtensionInfos:    file_meshtastic_nanopb_proto_extTypes,
	}.Build()
	File_meshtastic_nanopb_proto = out.File
	file_meshtastic_nanopb_proto_goTypes = nil
	file_meshtastic_nanopb_proto_depIdxs = nil
}
