ntypes.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: github.com/piotrkowalczuk/ntypes/ntypes.proto

package ntypes // import "github.com/piotrkowalczuk/ntypes"

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

// Bytes represents a byte slice that may be nil.
type Bytes struct {
	Bytes                []byte   `protobuf:"bytes,1,opt,name=bytes,proto3" json:"bytes,omitempty"`
	Valid                bool     `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Bytes) Reset()         { *m = Bytes{} }
func (m *Bytes) String() string { return proto.CompactTextString(m) }
func (*Bytes) ProtoMessage()    {}
func (*Bytes) Descriptor() ([]byte, []int) {
	return fileDescriptor_ntypes_8ed30f89a2fd17fa, []int{0}
}
func (m *Bytes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Bytes.Unmarshal(m, b)
}
func (m *Bytes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Bytes.Marshal(b, m, deterministic)
}
func (dst *Bytes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Bytes.Merge(dst, src)
}
func (m *Bytes) XXX_Size() int {
	return xxx_messageInfo_Bytes.Size(m)
}
func (m *Bytes) XXX_DiscardUnknown() {
	xxx_messageInfo_Bytes.DiscardUnknown(m)
}

var xxx_messageInfo_Bytes proto.InternalMessageInfo

func (m *Bytes) GetBytes() []byte {
	if m != nil {
		return m.Bytes
	}
	return nil
}

func (m *Bytes) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

// BytesArray represents an array of byte slices that may be nil.
type BytesArray struct {
	BytesArray           [][]byte `protobuf:"bytes,1,rep,name=bytes_array,json=bytesArray,proto3" json:"bytes_array,omitempty"`
	Valid                bool     `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BytesArray) Reset()         { *m = BytesArray{} }
func (m *BytesArray) String() string { return proto.CompactTextString(m) }
func (*BytesArray) ProtoMessage()    {}
func (*BytesArray) Descriptor() ([]byte, []int) {
	return fileDescriptor_ntypes_8ed30f89a2fd17fa, []int{1}
}
func (m *BytesArray) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BytesArray.Unmarshal(m, b)
}
func (m *BytesArray) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BytesArray.Marshal(b, m, deterministic)
}
func (dst *BytesArray) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BytesArray.Merge(dst, src)
}
func (m *BytesArray) XXX_Size() int {
	return xxx_messageInfo_BytesArray.Size(m)
}
func (m *BytesArray) XXX_DiscardUnknown() {
	xxx_messageInfo_BytesArray.DiscardUnknown(m)
}

var xxx_messageInfo_BytesArray proto.InternalMessageInfo

func (m *BytesArray) GetBytesArray() [][]byte {
	if m != nil {
		return m.BytesArray
	}
	return nil
}

func (m *BytesArray) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

// String represents a string that may be nil.
type String struct {
	Chars                string   `protobuf:"bytes,1,opt,name=chars,proto3" json:"chars,omitempty"`
	Valid                bool     `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *String) Reset()         { *m = String{} }
func (m *String) String() string { return proto.CompactTextString(m) }
func (*String) ProtoMessage()    {}
func (*String) Descriptor() ([]byte, []int) {
	return fileDescriptor_ntypes_8ed30f89a2fd17fa, []int{2}
}
func (m *String) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_String.Unmarshal(m, b)
}
func (m *String) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_String.Marshal(b, m, deterministic)
}
func (dst *String) XXX_Merge(src proto.Message) {
	xxx_messageInfo_String.Merge(dst, src)
}
func (m *String) XXX_Size() int {
	return xxx_messageInfo_String.Size(m)
}
func (m *String) XXX_DiscardUnknown() {
	xxx_messageInfo_String.DiscardUnknown(m)
}

var xxx_messageInfo_String proto.InternalMessageInfo

func (m *String) GetChars() string {
	if m != nil {
		return m.Chars
	}
	return ""
}

func (m *String) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

// StringArray represents an array of strings that may be nil.
type StringArray struct {
	StringArray          []string `protobuf:"bytes,1,rep,name=string_array,json=stringArray,proto3" json:"string_array,omitempty"`
	Valid                bool     `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StringArray) Reset()         { *m = StringArray{} }
func (m *StringArray) String() string { return proto.CompactTextString(m) }
func (*StringArray) ProtoMessage()    {}
func (*StringArray) Descriptor() ([]byte, []int) {
	return fileDescriptor_ntypes_8ed30f89a2fd17fa, []int{3}
}
func (m *StringArray) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StringArray.Unmarshal(m, b)
}
func (m *StringArray) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StringArray.Marshal(b, m, deterministic)
}
func (dst *StringArray) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StringArray.Merge(dst, src)
}
func (m *StringArray) XXX_Size() int {
	return xxx_messageInfo_StringArray.Size(m)
}
func (m *StringArray) XXX_DiscardUnknown() {
	xxx_messageInfo_StringArray.DiscardUnknown(m)
}

var xxx_messageInfo_StringArray proto.InternalMessageInfo

func (m *StringArray) GetStringArray() []string {
	if m != nil {
		return m.StringArray
	}
	return nil
}

func (m *StringArray) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

// Int32 represents a int32 that may be nil.
type Int32 struct {
	Int32                int32    `protobuf:"varint,1,opt,name=int32,proto3" json:"int32,omitempty"`
	Valid                bool     `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Int32) Reset()         { *m = Int32{} }
func (m *Int32) String() string { return proto.CompactTextString(m) }
func (*Int32) ProtoMessage()    {}
func (*Int32) Descriptor() ([]byte, []int) {
	return fileDescriptor_ntypes_8ed30f89a2fd17fa, []int{4}
}
func (m *Int32) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Int32.Unmarshal(m, b)
}
func (m *Int32) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Int32.Marshal(b, m, deterministic)
}
func (dst *Int32) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Int32.Merge(dst, src)
}
func (m *Int32) XXX_Size() int {
	return xxx_messageInfo_Int32.Size(m)
}
func (m *Int32) XXX_DiscardUnknown() {
	xxx_messageInfo_Int32.DiscardUnknown(m)
}

var xxx_messageInfo_Int32 proto.InternalMessageInfo

func (m *Int32) GetInt32() int32 {
	if m != nil {
		return m.Int32
	}
	return 0
}

func (m *Int32) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

// Int32Array represents an array of int32s that may be nil.
type Int32Array struct {
	Int32Array           []int32  `protobuf:"varint,1,rep,packed,name=int32_array,json=int32Array,proto3" json:"int32_array,omitempty"`
	Valid                bool     `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Int32Array) Reset()         { *m = Int32Array{} }
func (m *Int32Array) String() string { return proto.CompactTextString(m) }
func (*Int32Array) ProtoMessage()    {}
func (*Int32Array) Descriptor() ([]byte, []int) {
	return fileDescriptor_ntypes_8ed30f89a2fd17fa, []int{5}
}
func (m *Int32Array) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Int32Array.Unmarshal(m, b)
}
func (m *Int32Array) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Int32Array.Marshal(b, m, deterministic)
}
func (dst *Int32Array) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Int32Array.Merge(dst, src)
}
func (m *Int32Array) XXX_Size() int {
	return xxx_messageInfo_Int32Array.Size(m)
}
func (m *Int32Array) XXX_DiscardUnknown() {
	xxx_messageInfo_Int32Array.DiscardUnknown(m)
}

var xxx_messageInfo_Int32Array proto.InternalMessageInfo

func (m *Int32Array) GetInt32Array() []int32 {
	if m != nil {
		return m.Int32Array
	}
	return nil
}

func (m *Int32Array) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

// Int64 represents a int64 that may be nil.
type Int64 struct {
	Int64                int64    `protobuf:"varint,1,opt,name=int64,proto3" json:"int64,omitempty"`
	Valid                bool     `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Int64) Reset()         { *m = Int64{} }
func (m *Int64) String() string { return proto.CompactTextString(m) }
func (*Int64) ProtoMessage()    {}
func (*Int64) Descriptor() ([]byte, []int) {
	return fileDescriptor_ntypes_8ed30f89a2fd17fa, []int{6}
}
func (m *Int64) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Int64.Unmarshal(m, b)
}
func (m *Int64) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Int64.Marshal(b, m, deterministic)
}
func (dst *Int64) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Int64.Merge(dst, src)
}
func (m *Int64) XXX_Size() int {
	return xxx_messageInfo_Int64.Size(m)
}
func (m *Int64) XXX_DiscardUnknown() {
	xxx_messageInfo_Int64.DiscardUnknown(m)
}

var xxx_messageInfo_Int64 proto.InternalMessageInfo

func (m *Int64) GetInt64() int64 {
	if m != nil {
		return m.Int64
	}
	return 0
}

func (m *Int64) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

// Int64Array represents an array of int64s that may be nil.
type Int64Array struct {
	Int64Array           []int64  `protobuf:"varint,1,rep,packed,name=int64_array,json=int64Array,proto3" json:"int64_array,omitempty"`
	Valid                bool     `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Int64Array) Reset()         { *m = Int64Array{} }
func (m *Int64Array) String() string { return proto.CompactTextString(m) }
func (*Int64Array) ProtoMessage()    {}
func (*Int64Array) Descriptor() ([]byte, []int) {
	return fileDescriptor_ntypes_8ed30f89a2fd17fa, []int{7}
}
func (m *Int64Array) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Int64Array.Unmarshal(m, b)
}
func (m *Int64Array) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Int64Array.Marshal(b, m, deterministic)
}
func (dst *Int64Array) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Int64Array.Merge(dst, src)
}
func (m *Int64Array) XXX_Size() int {
	return xxx_messageInfo_Int64Array.Size(m)
}
func (m *Int64Array) XXX_DiscardUnknown() {
	xxx_messageInfo_Int64Array.DiscardUnknown(m)
}

var xxx_messageInfo_Int64Array proto.InternalMessageInfo

func (m *Int64Array) GetInt64Array() []int64 {
	if m != nil {
		return m.Int64Array
	}
	return nil
}

func (m *Int64Array) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

// Uint32 represents a Uint32 that may be nil.
type Uint32 struct {
	Uint32               uint32   `protobuf:"varint,1,opt,name=uint32,proto3" json:"uint32,omitempty"`
	Valid                bool     `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Uint32) Reset()         { *m = Uint32{} }
func (m *Uint32) String() string { return proto.CompactTextString(m) }
func (*Uint32) ProtoMessage()    {}
func (*Uint32) Descriptor() ([]byte, []int) {
	return fileDescriptor_ntypes_8ed30f89a2fd17fa, []int{8}
}
func (m *Uint32) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Uint32.Unmarshal(m, b)
}
func (m *Uint32) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Uint32.Marshal(b, m, deterministic)
}
func (dst *Uint32) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Uint32.Merge(dst, src)
}
func (m *Uint32) XXX_Size() int {
	return xxx_messageInfo_Uint32.Size(m)
}
func (m *Uint32) XXX_DiscardUnknown() {
	xxx_messageInfo_Uint32.DiscardUnknown(m)
}

var xxx_messageInfo_Uint32 proto.InternalMessageInfo

func (m *Uint32) GetUint32() uint32 {
	if m != nil {
		return m.Uint32
	}
	return 0
}

func (m *Uint32) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

// Uint32Array represents an array of uint32s that may be nil.
type Uint32Array struct {
	Uint32Array          []uint32 `protobuf:"varint,1,rep,packed,name=uint32_array,json=uint32Array,proto3" json:"uint32_array,omitempty"`
	Valid                bool     `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Uint32Array) Reset()         { *m = Uint32Array{} }
func (m *Uint32Array) String() string { return proto.CompactTextString(m) }
func (*Uint32Array) ProtoMessage()    {}
func (*Uint32Array) Descriptor() ([]byte, []int) {
	return fileDescriptor_ntypes_8ed30f89a2fd17fa, []int{9}
}
func (m *Uint32Array) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Uint32Array.Unmarshal(m, b)
}
func (m *Uint32Array) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Uint32Array.Marshal(b, m, deterministic)
}
func (dst *Uint32Array) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Uint32Array.Merge(dst, src)
}
func (m *Uint32Array) XXX_Size() int {
	return xxx_messageInfo_Uint32Array.Size(m)
}
func (m *Uint32Array) XXX_DiscardUnknown() {
	xxx_messageInfo_Uint32Array.DiscardUnknown(m)
}

var xxx_messageInfo_Uint32Array proto.InternalMessageInfo

func (m *Uint32Array) GetUint32Array() []uint32 {
	if m != nil {
		return m.Uint32Array
	}
	return nil
}

func (m *Uint32Array) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

// Uint64 represents a Uint64 that may be nil.
type Uint64 struct {
	Uint64               uint64   `protobuf:"varint,1,opt,name=uint64,proto3" json:"uint64,omitempty"`
	Valid                bool     `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Uint64) Reset()         { *m = Uint64{} }
func (m *Uint64) String() string { return proto.CompactTextString(m) }
func (*Uint64) ProtoMessage()    {}
func (*Uint64) Descriptor() ([]byte, []int) {
	return fileDescriptor_ntypes_8ed30f89a2fd17fa, []int{10}
}
func (m *Uint64) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Uint64.Unmarshal(m, b)
}
func (m *Uint64) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Uint64.Marshal(b, m, deterministic)
}
func (dst *Uint64) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Uint64.Merge(dst, src)
}
func (m *Uint64) XXX_Size() int {
	return xxx_messageInfo_Uint64.Size(m)
}
func (m *Uint64) XXX_DiscardUnknown() {
	xxx_messageInfo_Uint64.DiscardUnknown(m)
}

var xxx_messageInfo_Uint64 proto.InternalMessageInfo

func (m *Uint64) GetUint64() uint64 {
	if m != nil {
		return m.Uint64
	}
	return 0
}

func (m *Uint64) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

// Uint64Array represents an array of uint64s that may be nil.
type Uint64Array struct {
	Uint64Array          []uint64 `protobuf:"varint,1,rep,packed,name=uint64_array,json=uint64Array,proto3" json:"uint64_array,omitempty"`
	Valid                bool     `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Uint64Array) Reset()         { *m = Uint64Array{} }
func (m *Uint64Array) String() string { return proto.CompactTextString(m) }
func (*Uint64Array) ProtoMessage()    {}
func (*Uint64Array) Descriptor() ([]byte, []int) {
	return fileDescriptor_ntypes_8ed30f89a2fd17fa, []int{11}
}
func (m *Uint64Array) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Uint64Array.Unmarshal(m, b)
}
func (m *Uint64Array) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Uint64Array.Marshal(b, m, deterministic)
}
func (dst *Uint64Array) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Uint64Array.Merge(dst, src)
}
func (m *Uint64Array) XXX_Size() int {
	return xxx_messageInfo_Uint64Array.Size(m)
}
func (m *Uint64Array) XXX_DiscardUnknown() {
	xxx_messageInfo_Uint64Array.DiscardUnknown(m)
}

var xxx_messageInfo_Uint64Array proto.InternalMessageInfo

func (m *Uint64Array) GetUint64Array() []uint64 {
	if m != nil {
		return m.Uint64Array
	}
	return nil
}

func (m *Uint64Array) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

// Float32 represents a Float32 that may be nil.
type Float32 struct {
	Float32              float32  `protobuf:"fixed32,1,opt,name=float32,proto3" json:"float32,omitempty"`
	Valid                bool     `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Float32) Reset()         { *m = Float32{} }
func (m *Float32) String() string { return proto.CompactTextString(m) }
func (*Float32) ProtoMessage()    {}
func (*Float32) Descriptor() ([]byte, []int) {
	return fileDescriptor_ntypes_8ed30f89a2fd17fa, []int{12}
}
func (m *Float32) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Float32.Unmarshal(m, b)
}
func (m *Float32) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Float32.Marshal(b, m, deterministic)
}
func (dst *Float32) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Float32.Merge(dst, src)
}
func (m *Float32) XXX_Size() int {
	return xxx_messageInfo_Float32.Size(m)
}
func (m *Float32) XXX_DiscardUnknown() {
	xxx_messageInfo_Float32.DiscardUnknown(m)
}

var xxx_messageInfo_Float32 proto.InternalMessageInfo

func (m *Float32) GetFloat32() float32 {
	if m != nil {
		return m.Float32
	}
	return 0
}

func (m *Float32) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

// Float32Array represents an array of float32s that may be nil.
type Float32Array struct {
	Float32Array         []float32 `protobuf:"fixed32,1,rep,packed,name=float32_array,json=float32Array,proto3" json:"float32_array,omitempty"`
	Valid                bool      `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *Float32Array) Reset()         { *m = Float32Array{} }
func (m *Float32Array) String() string { return proto.CompactTextString(m) }
func (*Float32Array) ProtoMessage()    {}
func (*Float32Array) Descriptor() ([]byte, []int) {
	return fileDescriptor_ntypes_8ed30f89a2fd17fa, []int{13}
}
func (m *Float32Array) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Float32Array.Unmarshal(m, b)
}
func (m *Float32Array) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Float32Array.Marshal(b, m, deterministic)
}
func (dst *Float32Array) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Float32Array.Merge(dst, src)
}
func (m *Float32Array) XXX_Size() int {
	return xxx_messageInfo_Float32Array.Size(m)
}
func (m *Float32Array) XXX_DiscardUnknown() {
	xxx_messageInfo_Float32Array.DiscardUnknown(m)
}

var xxx_messageInfo_Float32Array proto.InternalMessageInfo

func (m *Float32Array) GetFloat32Array() []float32 {
	if m != nil {
		return m.Float32Array
	}
	return nil
}

func (m *Float32Array) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

// Float64 represents a Float64 that may be nil.
type Float64 struct {
	Float64              float64  `protobuf:"fixed64,1,opt,name=float64,proto3" json:"float64,omitempty"`
	Valid                bool     `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Float64) Reset()         { *m = Float64{} }
func (m *Float64) String() string { return proto.CompactTextString(m) }
func (*Float64) ProtoMessage()    {}
func (*Float64) Descriptor() ([]byte, []int) {
	return fileDescriptor_ntypes_8ed30f89a2fd17fa, []int{14}
}
func (m *Float64) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Float64.Unmarshal(m, b)
}
func (m *Float64) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Float64.Marshal(b, m, deterministic)
}
func (dst *Float64) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Float64.Merge(dst, src)
}
func (m *Float64) XXX_Size() int {
	return xxx_messageInfo_Float64.Size(m)
}
func (m *Float64) XXX_DiscardUnknown() {
	xxx_messageInfo_Float64.DiscardUnknown(m)
}

var xxx_messageInfo_Float64 proto.InternalMessageInfo

func (m *Float64) GetFloat64() float64 {
	if m != nil {
		return m.Float64
	}
	return 0
}

func (m *Float64) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

// Float64Array represents an array of float64s that may be nil.
type Float64Array struct {
	Float64Array         []float64 `protobuf:"fixed64,1,rep,packed,name=float64_array,json=float64Array,proto3" json:"float64_array,omitempty"`
	Valid                bool      `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *Float64Array) Reset()         { *m = Float64Array{} }
func (m *Float64Array) String() string { return proto.CompactTextString(m) }
func (*Float64Array) ProtoMessage()    {}
func (*Float64Array) Descriptor() ([]byte, []int) {
	return fileDescriptor_ntypes_8ed30f89a2fd17fa, []int{15}
}
func (m *Float64Array) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Float64Array.Unmarshal(m, b)
}
func (m *Float64Array) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Float64Array.Marshal(b, m, deterministic)
}
func (dst *Float64Array) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Float64Array.Merge(dst, src)
}
func (m *Float64Array) XXX_Size() int {
	return xxx_messageInfo_Float64Array.Size(m)
}
func (m *Float64Array) XXX_DiscardUnknown() {
	xxx_messageInfo_Float64Array.DiscardUnknown(m)
}

var xxx_messageInfo_Float64Array proto.InternalMessageInfo

func (m *Float64Array) GetFloat64Array() []float64 {
	if m != nil {
		return m.Float64Array
	}
	return nil
}

func (m *Float64Array) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

// Bool represents a bool that may be nil.
type Bool struct {
	Bool                 bool     `protobuf:"varint,1,opt,name=bool,proto3" json:"bool,omitempty"`
	Valid                bool     `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Bool) Reset()         { *m = Bool{} }
func (m *Bool) String() string { return proto.CompactTextString(m) }
func (*Bool) ProtoMessage()    {}
func (*Bool) Descriptor() ([]byte, []int) {
	return fileDescriptor_ntypes_8ed30f89a2fd17fa, []int{16}
}
func (m *Bool) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Bool.Unmarshal(m, b)
}
func (m *Bool) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Bool.Marshal(b, m, deterministic)
}
func (dst *Bool) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Bool.Merge(dst, src)
}
func (m *Bool) XXX_Size() int {
	return xxx_messageInfo_Bool.Size(m)
}
func (m *Bool) XXX_DiscardUnknown() {
	xxx_messageInfo_Bool.DiscardUnknown(m)
}

var xxx_messageInfo_Bool proto.InternalMessageInfo

func (m *Bool) GetBool() bool {
	if m != nil {
		return m.Bool
	}
	return false
}

func (m *Bool) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

// BoolArray represents an array of booleans that may be nil.
type BoolArray struct {
	BoolArray            []bool   `protobuf:"varint,1,rep,packed,name=bool_array,json=boolArray,proto3" json:"bool_array,omitempty"`
	Valid                bool     `protobuf:"varint,2,opt,name=valid,proto3" json:"valid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BoolArray) Reset()         { *m = BoolArray{} }
func (m *BoolArray) String() string { return proto.CompactTextString(m) }
func (*BoolArray) ProtoMessage()    {}
func (*BoolArray) Descriptor() ([]byte, []int) {
	return fileDescriptor_ntypes_8ed30f89a2fd17fa, []int{17}
}
func (m *BoolArray) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BoolArray.Unmarshal(m, b)
}
func (m *BoolArray) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BoolArray.Marshal(b, m, deterministic)
}
func (dst *BoolArray) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BoolArray.Merge(dst, src)
}
func (m *BoolArray) XXX_Size() int {
	return xxx_messageInfo_BoolArray.Size(m)
}
func (m *BoolArray) XXX_DiscardUnknown() {
	xxx_messageInfo_BoolArray.DiscardUnknown(m)
}

var xxx_messageInfo_BoolArray proto.InternalMessageInfo

func (m *BoolArray) GetBoolArray() []bool {
	if m != nil {
		return m.BoolArray
	}
	return nil
}

func (m *BoolArray) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

func init() {
	proto.RegisterType((*Bytes)(nil), "ntypes.Bytes")
	proto.RegisterType((*BytesArray)(nil), "ntypes.BytesArray")
	proto.RegisterType((*String)(nil), "ntypes.String")
	proto.RegisterType((*StringArray)(nil), "ntypes.StringArray")
	proto.RegisterType((*Int32)(nil), "ntypes.Int32")
	proto.RegisterType((*Int32Array)(nil), "ntypes.Int32Array")
	proto.RegisterType((*Int64)(nil), "ntypes.Int64")
	proto.RegisterType((*Int64Array)(nil), "ntypes.Int64Array")
	proto.RegisterType((*Uint32)(nil), "ntypes.Uint32")
	proto.RegisterType((*Uint32Array)(nil), "ntypes.Uint32Array")
	proto.RegisterType((*Uint64)(nil), "ntypes.Uint64")
	proto.RegisterType((*Uint64Array)(nil), "ntypes.Uint64Array")
	proto.RegisterType((*Float32)(nil), "ntypes.Float32")
	proto.RegisterType((*Float32Array)(nil), "ntypes.Float32Array")
	proto.RegisterType((*Float64)(nil), "ntypes.Float64")
	proto.RegisterType((*Float64Array)(nil), "ntypes.Float64Array")
	proto.RegisterType((*Bool)(nil), "ntypes.Bool")
	proto.RegisterType((*BoolArray)(nil), "ntypes.BoolArray")
}

func init() {
	proto.RegisterFile("github.com/piotrkowalczuk/ntypes/ntypes.proto", fileDescriptor_ntypes_8ed30f89a2fd17fa)
}

var fileDescriptor_ntypes_8ed30f89a2fd17fa = []byte{
	// 433 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x94, 0xcb, 0x8f, 0x9a, 0x50,
	0x14, 0xc6, 0x83, 0x02, 0xca, 0x01, 0x37, 0xa4, 0x69, 0xe8, 0xa2, 0x29, 0xda, 0x8d, 0x9b, 0x6a,
	0x53, 0x08, 0x49, 0x57, 0xed, 0x38, 0x89, 0x89, 0xbb, 0xc9, 0x99, 0xb8, 0x99, 0xcd, 0x04, 0x18,
	0x1f, 0x44, 0xf4, 0x1a, 0x1e, 0x33, 0x71, 0xfe, 0xfa, 0xc9, 0x7d, 0xa0, 0xd7, 0x09, 0xe0, 0x8a,
	0xfb, 0x71, 0xcf, 0x77, 0x7e, 0xe7, 0xbb, 0x8b, 0x03, 0xbf, 0x36, 0x49, 0xb1, 0x2d, 0xa3, 0x49,
	0x4c, 0xf6, 0xd3, 0x63, 0x42, 0x8a, 0x6c, 0x47, 0xde, 0xc2, 0x34, 0x7e, 0x2f, 0x77, 0xd3, 0x43,
	0x71, 0x3a, 0xae, 0x72, 0xf1, 0x99, 0x1c, 0x33, 0x52, 0x10, 0x5b, 0xe7, 0x6a, 0xe4, 0x81, 0x36,
	0x3b, 0x15, 0xab, 0xdc, 0xfe, 0x02, 0x5a, 0x44, 0x0f, 0x8e, 0xe2, 0x2a, 0x63, 0x0b, 0xb9, 0xa0,
	0x7f, 0x5f, 0xc3, 0x34, 0x79, 0x71, 0x3a, 0xae, 0x32, 0xee, 0x23, 0x17, 0xa3, 0x7b, 0x00, 0x66,
	0xba, 0xcb, 0xb2, 0xf0, 0x64, 0xff, 0x00, 0x93, 0x15, 0x3f, 0x87, 0x54, 0x3a, 0x8a, 0xdb, 0x1d,
	0x5b, 0x08, 0xd1, 0xa5, 0xa0, 0xbe, 0x89, 0x0f, 0xfa, 0x63, 0x91, 0x25, 0x87, 0x0d, 0xbd, 0x8f,
	0xb7, 0x61, 0xc6, 0xd1, 0x06, 0x72, 0xd1, 0xe0, 0x9a, 0x83, 0xc9, 0x5d, 0xbc, 0xf5, 0x10, 0xac,
	0x9c, 0x49, 0x09, 0x6e, 0xa0, 0x99, 0x4b, 0x25, 0xf5, 0x7d, 0x3c, 0xd0, 0x16, 0x87, 0xc2, 0xfb,
	0x43, 0xaf, 0x13, 0x7a, 0x60, 0x70, 0x0d, 0xb9, 0x68, 0xce, 0xcd, 0x4c, 0xe7, 0xdc, 0xac, 0x58,
	0x42, 0x6b, 0x08, 0xc9, 0xa5, 0xa0, 0x8d, 0x1c, 0xf8, 0x82, 0x1c, 0xf8, 0x8c, 0xdc, 0x45, 0x2e,
	0x5a, 0xc9, 0x81, 0x2f, 0x93, 0x03, 0x5f, 0x22, 0x77, 0x19, 0xb9, 0x2a, 0xa8, 0x6f, 0x12, 0x80,
	0xbe, 0xe4, 0xf1, 0xbe, 0x82, 0x5e, 0x5e, 0x52, 0x0f, 0x50, 0xa8, 0xe6, 0x37, 0x5f, 0x4a, 0xb1,
	0x86, 0x60, 0x95, 0x9f, 0x83, 0x0f, 0xd0, 0x2c, 0x6f, 0x26, 0x17, 0xfc, 0xc0, 0xaf, 0xf8, 0x22,
	0xbb, 0x8a, 0x42, 0xb5, 0xf3, 0xab, 0x70, 0x82, 0x7f, 0x15, 0x5f, 0xe5, 0xfc, 0xf6, 0xfc, 0x7f,
	0xa1, 0x37, 0x4f, 0x49, 0x48, 0x83, 0x3a, 0xd0, 0x5b, 0xf3, 0x23, 0x9b, 0xa0, 0x83, 0x95, 0x6c,
	0xb0, 0x2e, 0xc0, 0x12, 0x56, 0x0e, 0xf8, 0x09, 0x03, 0x61, 0x90, 0x86, 0xe8, 0xa0, 0xb5, 0x96,
	0x8b, 0xda, 0xa7, 0x08, 0xfc, 0xf3, 0x14, 0xe2, 0x1d, 0x14, 0xac, 0xe4, 0x8d, 0x29, 0xaa, 0x98,
	0xd5, 0x14, 0x57, 0x4f, 0xa1, 0x88, 0x29, 0xda, 0xdf, 0xe2, 0x37, 0xa8, 0x33, 0x42, 0x52, 0xdb,
	0x06, 0x35, 0x22, 0x24, 0x65, 0xfc, 0x3e, 0xb2, 0x73, 0x83, 0xe3, 0x3f, 0x18, 0xd4, 0xc1, 0x9b,
	0x7e, 0x07, 0xa0, 0xa5, 0x12, 0xb6, 0x8f, 0x46, 0x74, 0xbe, 0xae, 0xed, 0x30, 0xfb, 0x07, 0xdf,
	0x62, 0xb2, 0x9f, 0x88, 0x45, 0x75, 0xbd, 0xa4, 0x1e, 0x94, 0x27, 0xf7, 0xd6, 0x06, 0x8b, 0x74,
	0xb6, 0xbb, 0xbc, 0x8f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xdc, 0xd5, 0x9a, 0xe6, 0xec, 0x04, 0x00,
	0x00,
}