api_collection.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: lavanet/lava/spec/api_collection.proto

package types

import (
	fmt "fmt"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

// 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type EXTENSION int32

const (
	EXTENSION_NONE    EXTENSION = 0
	EXTENSION_ARCHIVE EXTENSION = 1
)

var EXTENSION_name = map[int32]string{
	0: "NONE",
	1: "ARCHIVE",
}

var EXTENSION_value = map[string]int32{
	"NONE":    0,
	"ARCHIVE": 1,
}

func (x EXTENSION) String() string {
	return proto.EnumName(EXTENSION_name, int32(x))
}

func (EXTENSION) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c9f7567a181f534f, []int{0}
}

type FUNCTION_TAG int32

const (
	FUNCTION_TAG_DISABLED               FUNCTION_TAG = 0
	FUNCTION_TAG_GET_BLOCKNUM           FUNCTION_TAG = 1
	FUNCTION_TAG_GET_BLOCK_BY_NUM       FUNCTION_TAG = 2
	FUNCTION_TAG_SET_LATEST_IN_METADATA FUNCTION_TAG = 3
	FUNCTION_TAG_SET_LATEST_IN_BODY     FUNCTION_TAG = 4
	FUNCTION_TAG_VERIFICATION           FUNCTION_TAG = 5
	FUNCTION_TAG_GET_EARLIEST_BLOCK     FUNCTION_TAG = 6
)

var FUNCTION_TAG_name = map[int32]string{
	0: "DISABLED",
	1: "GET_BLOCKNUM",
	2: "GET_BLOCK_BY_NUM",
	3: "SET_LATEST_IN_METADATA",
	4: "SET_LATEST_IN_BODY",
	5: "VERIFICATION",
	6: "GET_EARLIEST_BLOCK",
}

var FUNCTION_TAG_value = map[string]int32{
	"DISABLED":               0,
	"GET_BLOCKNUM":           1,
	"GET_BLOCK_BY_NUM":       2,
	"SET_LATEST_IN_METADATA": 3,
	"SET_LATEST_IN_BODY":     4,
	"VERIFICATION":           5,
	"GET_EARLIEST_BLOCK":     6,
}

func (x FUNCTION_TAG) String() string {
	return proto.EnumName(FUNCTION_TAG_name, int32(x))
}

func (FUNCTION_TAG) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c9f7567a181f534f, []int{1}
}

type PARSER_FUNC int32

const (
	PARSER_FUNC_EMPTY                       PARSER_FUNC = 0
	PARSER_FUNC_PARSE_BY_ARG                PARSER_FUNC = 1
	PARSER_FUNC_PARSE_CANONICAL             PARSER_FUNC = 2
	PARSER_FUNC_PARSE_DICTIONARY            PARSER_FUNC = 3
	PARSER_FUNC_PARSE_DICTIONARY_OR_ORDERED PARSER_FUNC = 4
	// reserved
	PARSER_FUNC_DEFAULT PARSER_FUNC = 6
)

var PARSER_FUNC_name = map[int32]string{
	0: "EMPTY",
	1: "PARSE_BY_ARG",
	2: "PARSE_CANONICAL",
	3: "PARSE_DICTIONARY",
	4: "PARSE_DICTIONARY_OR_ORDERED",
	6: "DEFAULT",
}

var PARSER_FUNC_value = map[string]int32{
	"EMPTY":                       0,
	"PARSE_BY_ARG":                1,
	"PARSE_CANONICAL":             2,
	"PARSE_DICTIONARY":            3,
	"PARSE_DICTIONARY_OR_ORDERED": 4,
	"DEFAULT":                     6,
}

func (x PARSER_FUNC) String() string {
	return proto.EnumName(PARSER_FUNC_name, int32(x))
}

func (PARSER_FUNC) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c9f7567a181f534f, []int{2}
}

type ParseValue_VerificationSeverity int32

const (
	ParseValue_Fail    ParseValue_VerificationSeverity = 0
	ParseValue_Warning ParseValue_VerificationSeverity = 1
)

var ParseValue_VerificationSeverity_name = map[int32]string{
	0: "Fail",
	1: "Warning",
}

var ParseValue_VerificationSeverity_value = map[string]int32{
	"Fail":    0,
	"Warning": 1,
}

func (x ParseValue_VerificationSeverity) String() string {
	return proto.EnumName(ParseValue_VerificationSeverity_name, int32(x))
}

func (ParseValue_VerificationSeverity) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c9f7567a181f534f, []int{4, 0}
}

type Header_HeaderType int32

const (
	Header_pass_send   Header_HeaderType = 0
	Header_pass_reply  Header_HeaderType = 1
	Header_pass_both   Header_HeaderType = 2
	Header_pass_ignore Header_HeaderType = 3
)

var Header_HeaderType_name = map[int32]string{
	0: "pass_send",
	1: "pass_reply",
	2: "pass_both",
	3: "pass_ignore",
}

var Header_HeaderType_value = map[string]int32{
	"pass_send":   0,
	"pass_reply":  1,
	"pass_both":   2,
	"pass_ignore": 3,
}

func (x Header_HeaderType) String() string {
	return proto.EnumName(Header_HeaderType_name, int32(x))
}

func (Header_HeaderType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c9f7567a181f534f, []int{6, 0}
}

type ApiCollection struct {
	Enabled         bool              `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
	CollectionData  CollectionData    `protobuf:"bytes,2,opt,name=collection_data,json=collectionData,proto3" json:"collection_data"`
	Apis            []*Api            `protobuf:"bytes,3,rep,name=apis,proto3" json:"apis,omitempty"`
	Headers         []*Header         `protobuf:"bytes,4,rep,name=headers,proto3" json:"headers,omitempty"`
	InheritanceApis []*CollectionData `protobuf:"bytes,5,rep,name=inheritance_apis,json=inheritanceApis,proto3" json:"inheritance_apis,omitempty"`
	ParseDirectives []*ParseDirective `protobuf:"bytes,6,rep,name=parse_directives,json=parseDirectives,proto3" json:"parse_directives,omitempty"`
	Extensions      []*Extension      `protobuf:"bytes,7,rep,name=extensions,proto3" json:"extensions,omitempty"`
	Verifications   []*Verification   `protobuf:"bytes,8,rep,name=verifications,proto3" json:"verifications,omitempty"`
}

func (m *ApiCollection) Reset()         { *m = ApiCollection{} }
func (m *ApiCollection) String() string { return proto.CompactTextString(m) }
func (*ApiCollection) ProtoMessage()    {}
func (*ApiCollection) Descriptor() ([]byte, []int) {
	return fileDescriptor_c9f7567a181f534f, []int{0}
}
func (m *ApiCollection) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ApiCollection) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ApiCollection.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ApiCollection) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ApiCollection.Merge(m, src)
}
func (m *ApiCollection) XXX_Size() int {
	return m.Size()
}
func (m *ApiCollection) XXX_DiscardUnknown() {
	xxx_messageInfo_ApiCollection.DiscardUnknown(m)
}

var xxx_messageInfo_ApiCollection proto.InternalMessageInfo

func (m *ApiCollection) GetEnabled() bool {
	if m != nil {
		return m.Enabled
	}
	return false
}

func (m *ApiCollection) GetCollectionData() CollectionData {
	if m != nil {
		return m.CollectionData
	}
	return CollectionData{}
}

func (m *ApiCollection) GetApis() []*Api {
	if m != nil {
		return m.Apis
	}
	return nil
}

func (m *ApiCollection) GetHeaders() []*Header {
	if m != nil {
		return m.Headers
	}
	return nil
}

func (m *ApiCollection) GetInheritanceApis() []*CollectionData {
	if m != nil {
		return m.InheritanceApis
	}
	return nil
}

func (m *ApiCollection) GetParseDirectives() []*ParseDirective {
	if m != nil {
		return m.ParseDirectives
	}
	return nil
}

func (m *ApiCollection) GetExtensions() []*Extension {
	if m != nil {
		return m.Extensions
	}
	return nil
}

func (m *ApiCollection) GetVerifications() []*Verification {
	if m != nil {
		return m.Verifications
	}
	return nil
}

type Extension struct {
	Name         string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Rule         *Rule  `protobuf:"bytes,3,opt,name=rule,proto3" json:"rule,omitempty"`
	CuMultiplier uint64 `protobuf:"varint,4,opt,name=cu_multiplier,json=cuMultiplier,proto3" json:"cu_multiplier,omitempty"`
}

func (m *Extension) Reset()         { *m = Extension{} }
func (m *Extension) String() string { return proto.CompactTextString(m) }
func (*Extension) ProtoMessage()    {}
func (*Extension) Descriptor() ([]byte, []int) {
	return fileDescriptor_c9f7567a181f534f, []int{1}
}
func (m *Extension) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Extension) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Extension.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Extension) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Extension.Merge(m, src)
}
func (m *Extension) XXX_Size() int {
	return m.Size()
}
func (m *Extension) XXX_DiscardUnknown() {
	xxx_messageInfo_Extension.DiscardUnknown(m)
}

var xxx_messageInfo_Extension proto.InternalMessageInfo

func (m *Extension) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Extension) GetRule() *Rule {
	if m != nil {
		return m.Rule
	}
	return nil
}

func (m *Extension) GetCuMultiplier() uint64 {
	if m != nil {
		return m.CuMultiplier
	}
	return 0
}

type Rule struct {
	Block uint64 `protobuf:"varint,1,opt,name=block,proto3" json:"block,omitempty"`
}

func (m *Rule) Reset()         { *m = Rule{} }
func (m *Rule) String() string { return proto.CompactTextString(m) }
func (*Rule) ProtoMessage()    {}
func (*Rule) Descriptor() ([]byte, []int) {
	return fileDescriptor_c9f7567a181f534f, []int{2}
}
func (m *Rule) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Rule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Rule.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Rule) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Rule.Merge(m, src)
}
func (m *Rule) XXX_Size() int {
	return m.Size()
}
func (m *Rule) XXX_DiscardUnknown() {
	xxx_messageInfo_Rule.DiscardUnknown(m)
}

var xxx_messageInfo_Rule proto.InternalMessageInfo

func (m *Rule) GetBlock() uint64 {
	if m != nil {
		return m.Block
	}
	return 0
}

type Verification struct {
	Name           string          `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	ParseDirective *ParseDirective `protobuf:"bytes,2,opt,name=parse_directive,json=parseDirective,proto3" json:"parse_directive,omitempty"`
	Values         []*ParseValue   `protobuf:"bytes,3,rep,name=values,proto3" json:"values,omitempty"`
}

func (m *Verification) Reset()         { *m = Verification{} }
func (m *Verification) String() string { return proto.CompactTextString(m) }
func (*Verification) ProtoMessage()    {}
func (*Verification) Descriptor() ([]byte, []int) {
	return fileDescriptor_c9f7567a181f534f, []int{3}
}
func (m *Verification) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Verification) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Verification.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Verification) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Verification.Merge(m, src)
}
func (m *Verification) XXX_Size() int {
	return m.Size()
}
func (m *Verification) XXX_DiscardUnknown() {
	xxx_messageInfo_Verification.DiscardUnknown(m)
}

var xxx_messageInfo_Verification proto.InternalMessageInfo

func (m *Verification) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Verification) GetParseDirective() *ParseDirective {
	if m != nil {
		return m.ParseDirective
	}
	return nil
}

func (m *Verification) GetValues() []*ParseValue {
	if m != nil {
		return m.Values
	}
	return nil
}

type ParseValue struct {
	Extension      string                          `protobuf:"bytes,1,opt,name=extension,proto3" json:"extension,omitempty"`
	ExpectedValue  string                          `protobuf:"bytes,2,opt,name=expected_value,json=expectedValue,proto3" json:"expected_value,omitempty"`
	LatestDistance uint64                          `protobuf:"varint,3,opt,name=latest_distance,json=latestDistance,proto3" json:"latest_distance,omitempty"`
	Severity       ParseValue_VerificationSeverity `protobuf:"varint,4,opt,name=severity,proto3,enum=lavanet.lava.spec.ParseValue_VerificationSeverity" json:"severity,omitempty"`
}

func (m *ParseValue) Reset()         { *m = ParseValue{} }
func (m *ParseValue) String() string { return proto.CompactTextString(m) }
func (*ParseValue) ProtoMessage()    {}
func (*ParseValue) Descriptor() ([]byte, []int) {
	return fileDescriptor_c9f7567a181f534f, []int{4}
}
func (m *ParseValue) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ParseValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ParseValue.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ParseValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParseValue.Merge(m, src)
}
func (m *ParseValue) XXX_Size() int {
	return m.Size()
}
func (m *ParseValue) XXX_DiscardUnknown() {
	xxx_messageInfo_ParseValue.DiscardUnknown(m)
}

var xxx_messageInfo_ParseValue proto.InternalMessageInfo

func (m *ParseValue) GetExtension() string {
	if m != nil {
		return m.Extension
	}
	return ""
}

func (m *ParseValue) GetExpectedValue() string {
	if m != nil {
		return m.ExpectedValue
	}
	return ""
}

func (m *ParseValue) GetLatestDistance() uint64 {
	if m != nil {
		return m.LatestDistance
	}
	return 0
}

func (m *ParseValue) GetSeverity() ParseValue_VerificationSeverity {
	if m != nil {
		return m.Severity
	}
	return ParseValue_Fail
}

type CollectionData struct {
	ApiInterface string `protobuf:"bytes,1,opt,name=api_interface,json=apiInterface,proto3" json:"api_interface" mapstructure:"api_interface"`
	InternalPath string `protobuf:"bytes,2,opt,name=internal_path,json=internalPath,proto3" json:"internal_path" mapstructure:"internal_path"`
	Type         string `protobuf:"bytes,3,opt,name=type,proto3" json:"type" mapstructure:"type"`
	AddOn        string `protobuf:"bytes,4,opt,name=add_on,json=addOn,proto3" json:"add_on" mapstructure:"add_on"`
}

func (m *CollectionData) Reset()         { *m = CollectionData{} }
func (m *CollectionData) String() string { return proto.CompactTextString(m) }
func (*CollectionData) ProtoMessage()    {}
func (*CollectionData) Descriptor() ([]byte, []int) {
	return fileDescriptor_c9f7567a181f534f, []int{5}
}
func (m *CollectionData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CollectionData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CollectionData.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CollectionData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CollectionData.Merge(m, src)
}
func (m *CollectionData) XXX_Size() int {
	return m.Size()
}
func (m *CollectionData) XXX_DiscardUnknown() {
	xxx_messageInfo_CollectionData.DiscardUnknown(m)
}

var xxx_messageInfo_CollectionData proto.InternalMessageInfo

func (m *CollectionData) GetApiInterface() string {
	if m != nil {
		return m.ApiInterface
	}
	return ""
}

func (m *CollectionData) GetInternalPath() string {
	if m != nil {
		return m.InternalPath
	}
	return ""
}

func (m *CollectionData) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

func (m *CollectionData) GetAddOn() string {
	if m != nil {
		return m.AddOn
	}
	return ""
}

type Header struct {
	Name        string            `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Kind        Header_HeaderType `protobuf:"varint,2,opt,name=kind,proto3,enum=lavanet.lava.spec.Header_HeaderType" json:"kind,omitempty"`
	FunctionTag FUNCTION_TAG      `protobuf:"varint,3,opt,name=function_tag,json=functionTag,proto3,enum=lavanet.lava.spec.FUNCTION_TAG" json:"function_tag,omitempty"`
}

func (m *Header) Reset()         { *m = Header{} }
func (m *Header) String() string { return proto.CompactTextString(m) }
func (*Header) ProtoMessage()    {}
func (*Header) Descriptor() ([]byte, []int) {
	return fileDescriptor_c9f7567a181f534f, []int{6}
}
func (m *Header) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Header.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Header) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Header.Merge(m, src)
}
func (m *Header) XXX_Size() int {
	return m.Size()
}
func (m *Header) XXX_DiscardUnknown() {
	xxx_messageInfo_Header.DiscardUnknown(m)
}

var xxx_messageInfo_Header proto.InternalMessageInfo

func (m *Header) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Header) GetKind() Header_HeaderType {
	if m != nil {
		return m.Kind
	}
	return Header_pass_send
}

func (m *Header) GetFunctionTag() FUNCTION_TAG {
	if m != nil {
		return m.FunctionTag
	}
	return FUNCTION_TAG_DISABLED
}

type Api struct {
	Enabled           bool         `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
	Name              string       `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	ComputeUnits      uint64       `protobuf:"varint,3,opt,name=compute_units,json=computeUnits,proto3" json:"compute_units,omitempty"`
	ExtraComputeUnits uint64       `protobuf:"varint,4,opt,name=extra_compute_units,json=extraComputeUnits,proto3" json:"extra_compute_units,omitempty"`
	Category          SpecCategory `protobuf:"bytes,6,opt,name=category,proto3" json:"category"`
	BlockParsing      BlockParser  `protobuf:"bytes,7,opt,name=block_parsing,json=blockParsing,proto3" json:"block_parsing"`
	TimeoutMs         uint64       `protobuf:"varint,8,opt,name=timeout_ms,json=timeoutMs,proto3" json:"timeout_ms,omitempty"`
}

func (m *Api) Reset()         { *m = Api{} }
func (m *Api) String() string { return proto.CompactTextString(m) }
func (*Api) ProtoMessage()    {}
func (*Api) Descriptor() ([]byte, []int) {
	return fileDescriptor_c9f7567a181f534f, []int{7}
}
func (m *Api) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Api) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Api.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Api) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Api.Merge(m, src)
}
func (m *Api) XXX_Size() int {
	return m.Size()
}
func (m *Api) XXX_DiscardUnknown() {
	xxx_messageInfo_Api.DiscardUnknown(m)
}

var xxx_messageInfo_Api proto.InternalMessageInfo

func (m *Api) GetEnabled() bool {
	if m != nil {
		return m.Enabled
	}
	return false
}

func (m *Api) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Api) GetComputeUnits() uint64 {
	if m != nil {
		return m.ComputeUnits
	}
	return 0
}

func (m *Api) GetExtraComputeUnits() uint64 {
	if m != nil {
		return m.ExtraComputeUnits
	}
	return 0
}

func (m *Api) GetCategory() SpecCategory {
	if m != nil {
		return m.Category
	}
	return SpecCategory{}
}

func (m *Api) GetBlockParsing() BlockParser {
	if m != nil {
		return m.BlockParsing
	}
	return BlockParser{}
}

func (m *Api) GetTimeoutMs() uint64 {
	if m != nil {
		return m.TimeoutMs
	}
	return 0
}

type ParseDirective struct {
	FunctionTag      FUNCTION_TAG `protobuf:"varint,1,opt,name=function_tag,json=functionTag,proto3,enum=lavanet.lava.spec.FUNCTION_TAG" json:"function_tag,omitempty"`
	FunctionTemplate string       `protobuf:"bytes,2,opt,name=function_template,json=functionTemplate,proto3" json:"function_template,omitempty"`
	ResultParsing    BlockParser  `protobuf:"bytes,3,opt,name=result_parsing,json=resultParsing,proto3" json:"result_parsing"`
	ApiName          string       `protobuf:"bytes,4,opt,name=api_name,json=apiName,proto3" json:"api_name,omitempty"`
}

func (m *ParseDirective) Reset()         { *m = ParseDirective{} }
func (m *ParseDirective) String() string { return proto.CompactTextString(m) }
func (*ParseDirective) ProtoMessage()    {}
func (*ParseDirective) Descriptor() ([]byte, []int) {
	return fileDescriptor_c9f7567a181f534f, []int{8}
}
func (m *ParseDirective) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ParseDirective) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ParseDirective.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ParseDirective) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParseDirective.Merge(m, src)
}
func (m *ParseDirective) XXX_Size() int {
	return m.Size()
}
func (m *ParseDirective) XXX_DiscardUnknown() {
	xxx_messageInfo_ParseDirective.DiscardUnknown(m)
}

var xxx_messageInfo_ParseDirective proto.InternalMessageInfo

func (m *ParseDirective) GetFunctionTag() FUNCTION_TAG {
	if m != nil {
		return m.FunctionTag
	}
	return FUNCTION_TAG_DISABLED
}

func (m *ParseDirective) GetFunctionTemplate() string {
	if m != nil {
		return m.FunctionTemplate
	}
	return ""
}

func (m *ParseDirective) GetResultParsing() BlockParser {
	if m != nil {
		return m.ResultParsing
	}
	return BlockParser{}
}

func (m *ParseDirective) GetApiName() string {
	if m != nil {
		return m.ApiName
	}
	return ""
}

type BlockParser struct {
	ParserArg    []string    `protobuf:"bytes,1,rep,name=parser_arg,json=parserArg,proto3" json:"parser_arg,omitempty"`
	ParserFunc   PARSER_FUNC `protobuf:"varint,2,opt,name=parser_func,json=parserFunc,proto3,enum=lavanet.lava.spec.PARSER_FUNC" json:"parser_func,omitempty"`
	DefaultValue string      `protobuf:"bytes,3,opt,name=default_value,json=defaultValue,proto3" json:"default_value,omitempty"`
	Encoding     string      `protobuf:"bytes,4,opt,name=encoding,proto3" json:"encoding,omitempty"`
}

func (m *BlockParser) Reset()         { *m = BlockParser{} }
func (m *BlockParser) String() string { return proto.CompactTextString(m) }
func (*BlockParser) ProtoMessage()    {}
func (*BlockParser) Descriptor() ([]byte, []int) {
	return fileDescriptor_c9f7567a181f534f, []int{9}
}
func (m *BlockParser) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BlockParser) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BlockParser.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BlockParser) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockParser.Merge(m, src)
}
func (m *BlockParser) XXX_Size() int {
	return m.Size()
}
func (m *BlockParser) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockParser.DiscardUnknown(m)
}

var xxx_messageInfo_BlockParser proto.InternalMessageInfo

func (m *BlockParser) GetParserArg() []string {
	if m != nil {
		return m.ParserArg
	}
	return nil
}

func (m *BlockParser) GetParserFunc() PARSER_FUNC {
	if m != nil {
		return m.ParserFunc
	}
	return PARSER_FUNC_EMPTY
}

func (m *BlockParser) GetDefaultValue() string {
	if m != nil {
		return m.DefaultValue
	}
	return ""
}

func (m *BlockParser) GetEncoding() string {
	if m != nil {
		return m.Encoding
	}
	return ""
}

type SpecCategory struct {
	Deterministic bool   `protobuf:"varint,1,opt,name=deterministic,proto3" json:"deterministic,omitempty"`
	Local         bool   `protobuf:"varint,2,opt,name=local,proto3" json:"local,omitempty"`
	Subscription  bool   `protobuf:"varint,3,opt,name=subscription,proto3" json:"subscription,omitempty"`
	Stateful      uint32 `protobuf:"varint,4,opt,name=stateful,proto3" json:"stateful,omitempty"`
	HangingApi    bool   `protobuf:"varint,5,opt,name=hanging_api,json=hangingApi,proto3" json:"hanging_api,omitempty"`
}

func (m *SpecCategory) Reset()         { *m = SpecCategory{} }
func (m *SpecCategory) String() string { return proto.CompactTextString(m) }
func (*SpecCategory) ProtoMessage()    {}
func (*SpecCategory) Descriptor() ([]byte, []int) {
	return fileDescriptor_c9f7567a181f534f, []int{10}
}
func (m *SpecCategory) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SpecCategory) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SpecCategory.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SpecCategory) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SpecCategory.Merge(m, src)
}
func (m *SpecCategory) XXX_Size() int {
	return m.Size()
}
func (m *SpecCategory) XXX_DiscardUnknown() {
	xxx_messageInfo_SpecCategory.DiscardUnknown(m)
}

var xxx_messageInfo_SpecCategory proto.InternalMessageInfo

func (m *SpecCategory) GetDeterministic() bool {
	if m != nil {
		return m.Deterministic
	}
	return false
}

func (m *SpecCategory) GetLocal() bool {
	if m != nil {
		return m.Local
	}
	return false
}

func (m *SpecCategory) GetSubscription() bool {
	if m != nil {
		return m.Subscription
	}
	return false
}

func (m *SpecCategory) GetStateful() uint32 {
	if m != nil {
		return m.Stateful
	}
	return 0
}

func (m *SpecCategory) GetHangingApi() bool {
	if m != nil {
		return m.HangingApi
	}
	return false
}

func init() {
	proto.RegisterEnum("lavanet.lava.spec.EXTENSION", EXTENSION_name, EXTENSION_value)
	proto.RegisterEnum("lavanet.lava.spec.FUNCTION_TAG", FUNCTION_TAG_name, FUNCTION_TAG_value)
	proto.RegisterEnum("lavanet.lava.spec.PARSER_FUNC", PARSER_FUNC_name, PARSER_FUNC_value)
	proto.RegisterEnum("lavanet.lava.spec.ParseValue_VerificationSeverity", ParseValue_VerificationSeverity_name, ParseValue_VerificationSeverity_value)
	proto.RegisterEnum("lavanet.lava.spec.Header_HeaderType", Header_HeaderType_name, Header_HeaderType_value)
	proto.RegisterType((*ApiCollection)(nil), "lavanet.lava.spec.ApiCollection")
	proto.RegisterType((*Extension)(nil), "lavanet.lava.spec.Extension")
	proto.RegisterType((*Rule)(nil), "lavanet.lava.spec.Rule")
	proto.RegisterType((*Verification)(nil), "lavanet.lava.spec.Verification")
	proto.RegisterType((*ParseValue)(nil), "lavanet.lava.spec.ParseValue")
	proto.RegisterType((*CollectionData)(nil), "lavanet.lava.spec.CollectionData")
	proto.RegisterType((*Header)(nil), "lavanet.lava.spec.Header")
	proto.RegisterType((*Api)(nil), "lavanet.lava.spec.Api")
	proto.RegisterType((*ParseDirective)(nil), "lavanet.lava.spec.ParseDirective")
	proto.RegisterType((*BlockParser)(nil), "lavanet.lava.spec.BlockParser")
	proto.RegisterType((*SpecCategory)(nil), "lavanet.lava.spec.SpecCategory")
}

func init() {
	proto.RegisterFile("lavanet/lava/spec/api_collection.proto", fileDescriptor_c9f7567a181f534f)
}

var fileDescriptor_c9f7567a181f534f = []byte{
	// 1424 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x4f, 0x6f, 0xdb, 0xc6,
	0x12, 0x37, 0x25, 0x5a, 0x96, 0x46, 0x7f, 0xcc, 0x6c, 0xfc, 0xf2, 0x94, 0x3c, 0x47, 0xf2, 0x63,
	0xf2, 0x5e, 0x0d, 0x07, 0xb5, 0x51, 0x07, 0x05, 0x8a, 0xa0, 0x40, 0x41, 0x49, 0x74, 0xa2, 0x44,
	0x96, 0x8c, 0xb5, 0xec, 0xd6, 0xbd, 0x10, 0x6b, 0x6a, 0x2d, 0x2f, 0x42, 0x91, 0x04, 0xb9, 0x74,
	0xed, 0x73, 0xbf, 0x40, 0x3f, 0x43, 0x4f, 0x05, 0x0a, 0x14, 0xe8, 0xa1, 0xdf, 0x21, 0xc7, 0x1c,
	0x7b, 0x12, 0x0a, 0xe7, 0x50, 0x34, 0xc7, 0xdc, 0x7a, 0x28, 0x50, 0xec, 0x92, 0x92, 0x45, 0x47,
	0x49, 0x91, 0x93, 0x34, 0xbf, 0xf9, 0xcd, 0x8f, 0xb3, 0x33, 0xb3, 0x43, 0xc2, 0xff, 0x1d, 0x72,
	0x46, 0x5c, 0xca, 0xb7, 0xc4, 0xef, 0x56, 0xe8, 0x53, 0x7b, 0x8b, 0xf8, 0xcc, 0xb2, 0x3d, 0xc7,
	0xa1, 0x36, 0x67, 0x9e, 0xbb, 0xe9, 0x07, 0x1e, 0xf7, 0xd0, 0x8d, 0x84, 0xb7, 0x29, 0x7e, 0x37,
	0x05, 0xef, 0xce, 0xca, 0xd0, 0x1b, 0x7a, 0xd2, 0xbb, 0x25, 0xfe, 0xc5, 0x44, 0xfd, 0xaf, 0x2c,
	0x94, 0x0d, 0x9f, 0x35, 0xa7, 0x02, 0xa8, 0x0a, 0x4b, 0xd4, 0x25, 0xc7, 0x0e, 0x1d, 0x54, 0x95,
	0x35, 0x65, 0x3d, 0x8f, 0x27, 0x26, 0xda, 0x83, 0xe5, 0xab, 0x07, 0x59, 0x03, 0xc2, 0x49, 0x35,
	0xb3, 0xa6, 0xac, 0x17, 0xb7, 0xff, 0xbb, 0xf9, 0xd6, 0xe3, 0x36, 0xaf, 0x14, 0x5b, 0x84, 0x93,
	0x86, 0xfa, 0x62, 0x5c, 0x5f, 0xc0, 0x15, 0x3b, 0x85, 0xa2, 0x0d, 0x50, 0x89, 0xcf, 0xc2, 0x6a,
	0x76, 0x2d, 0xbb, 0x5e, 0xdc, 0xbe, 0x35, 0x47, 0xc6, 0xf0, 0x19, 0x96, 0x1c, 0xf4, 0x10, 0x96,
	0x4e, 0x29, 0x19, 0xd0, 0x20, 0xac, 0xaa, 0x92, 0x7e, 0x7b, 0x0e, 0xfd, 0x89, 0x64, 0xe0, 0x09,
	0x13, 0x75, 0x40, 0x63, 0xee, 0x29, 0x0d, 0x18, 0x27, 0xae, 0x4d, 0x2d, 0xf9, 0xb0, 0x45, 0x19,
	0xfd, 0xcf, 0x39, 0xe3, 0xe5, 0x99, 0x50, 0x43, 0xa4, 0xd0, 0x01, 0xcd, 0x27, 0x41, 0x48, 0xad,
	0x01, 0x0b, 0x04, 0xef, 0x8c, 0x86, 0xd5, 0xdc, 0x3b, 0xd5, 0xf6, 0x04, 0xb5, 0x35, 0x61, 0xe2,
	0x65, 0x3f, 0x65, 0x87, 0xe8, 0x73, 0x00, 0x7a, 0xce, 0xa9, 0x1b, 0x32, 0xcf, 0x0d, 0xab, 0x4b,
	0x52, 0x67, 0x75, 0x8e, 0x8e, 0x39, 0x21, 0xe1, 0x19, 0x3e, 0x32, 0xa1, 0x7c, 0x46, 0x03, 0x76,
	0xc2, 0x6c, 0xc2, 0xa5, 0x40, 0x5e, 0x0a, 0xd4, 0xe7, 0x08, 0x1c, 0xce, 0xf0, 0x70, 0x3a, 0x4a,
	0xff, 0x06, 0x0a, 0x53, 0x7d, 0x84, 0x40, 0x75, 0xc9, 0x88, 0xca, 0xbe, 0x17, 0xb0, 0xfc, 0x8f,
	0x1e, 0x80, 0x1a, 0x44, 0x0e, 0xad, 0x66, 0x65, 0xa7, 0xff, 0x3d, 0x47, 0x1e, 0x47, 0x0e, 0xc5,
	0x92, 0x84, 0xee, 0x41, 0xd9, 0x8e, 0xac, 0x51, 0xe4, 0x70, 0xe6, 0x3b, 0x8c, 0x06, 0x55, 0x75,
	0x4d, 0x59, 0x57, 0x71, 0xc9, 0x8e, 0x76, 0xa7, 0xd8, 0x53, 0x35, 0x9f, 0xd1, 0xb2, 0xfa, 0x2a,
	0xa8, 0x22, 0x10, 0xad, 0xc0, 0xe2, 0xb1, 0xe3, 0xd9, 0xcf, 0xe5, 0x43, 0x55, 0x1c, 0x1b, 0xfa,
	0x8f, 0x0a, 0x94, 0x66, 0xd3, 0x9e, 0x9b, 0xda, 0x53, 0x58, 0xbe, 0xd6, 0x8e, 0xf7, 0xcc, 0xe3,
	0xb5, 0x6e, 0x54, 0xd2, 0xdd, 0x40, 0x9f, 0x42, 0xee, 0x8c, 0x38, 0x11, 0x9d, 0xcc, 0xe2, 0xdd,
	0x77, 0x49, 0x1c, 0x0a, 0x16, 0x4e, 0xc8, 0x4f, 0xd5, 0xbc, 0xaa, 0x2d, 0xea, 0x7f, 0x2a, 0x00,
	0x57, 0x4e, 0xb4, 0x0a, 0x85, 0x69, 0xa3, 0x92, 0x84, 0xaf, 0x00, 0xf4, 0x3f, 0xa8, 0xd0, 0x73,
	0x9f, 0xda, 0x9c, 0x0e, 0x2c, 0xa9, 0x22, 0x93, 0x2e, 0xe0, 0xf2, 0x04, 0x8d, 0x45, 0x3e, 0x82,
	0x65, 0x87, 0x70, 0x1a, 0x72, 0x6b, 0xc0, 0x42, 0x39, 0x82, 0xb2, 0x05, 0x2a, 0xae, 0xc4, 0x70,
	0x2b, 0x41, 0x51, 0x17, 0xf2, 0x21, 0x15, 0x4d, 0xe5, 0x17, 0xb2, 0xdc, 0x95, 0xed, 0xed, 0xf7,
	0xe6, 0x9e, 0x1a, 0x87, 0xfd, 0x24, 0x12, 0x4f, 0x35, 0xf4, 0x8f, 0x61, 0x65, 0x1e, 0x03, 0xe5,
	0x41, 0xdd, 0x21, 0xcc, 0xd1, 0x16, 0x50, 0x11, 0x96, 0xbe, 0x24, 0x81, 0xcb, 0xdc, 0xa1, 0xa6,
	0xe8, 0x3f, 0x67, 0xa0, 0x92, 0xbe, 0x37, 0xe8, 0x10, 0xca, 0x62, 0x29, 0x31, 0x97, 0xd3, 0xe0,
	0x84, 0xd8, 0x49, 0xd3, 0x1a, 0x9f, 0xbc, 0x1e, 0xd7, 0xd3, 0x8e, 0x37, 0xe3, 0xfa, 0xea, 0x88,
	0xf8, 0x21, 0x0f, 0x22, 0x9b, 0x47, 0x01, 0x7d, 0xa4, 0xa7, 0xdc, 0x3a, 0x2e, 0x11, 0x9f, 0xb5,
	0x27, 0xa6, 0xd0, 0x95, 0x3e, 0x97, 0x38, 0x96, 0x4f, 0xf8, 0x69, 0x5c, 0xb8, 0x58, 0x37, 0xe5,
	0x78, 0x5b, 0x37, 0xe5, 0xd6, 0x71, 0x69, 0x62, 0xef, 0x11, 0x7e, 0x8a, 0x1e, 0x82, 0xca, 0x2f,
	0xfc, 0xb8, 0xbe, 0x85, 0x46, 0xfd, 0xf5, 0xb8, 0x2e, 0xed, 0x37, 0xe3, 0xfa, 0xcd, 0xb4, 0x8a,
	0x40, 0x75, 0x2c, 0x9d, 0xe8, 0x11, 0xe4, 0xc8, 0x60, 0x60, 0x79, 0xae, 0x2c, 0x7a, 0xa1, 0x71,
	0xef, 0xf5, 0xb8, 0x9e, 0x20, 0x6f, 0xc6, 0xf5, 0x7f, 0x5d, 0x3b, 0x96, 0xc4, 0x75, 0xbc, 0x48,
	0x06, 0x83, 0x9e, 0xab, 0xff, 0xae, 0x40, 0x2e, 0xde, 0x54, 0x73, 0xe7, 0xfa, 0x33, 0x50, 0x9f,
	0x33, 0x77, 0x20, 0x8f, 0x57, 0xd9, 0xbe, 0xff, 0xce, 0x35, 0x97, 0xfc, 0xf4, 0x2f, 0x7c, 0x8a,
	0x65, 0x04, 0x6a, 0x40, 0xe9, 0x24, 0x72, 0xe3, 0xfd, 0xcc, 0xc9, 0x50, 0x9e, 0xa8, 0x32, 0x77,
	0x27, 0xec, 0x1c, 0x74, 0x9b, 0xfd, 0x76, 0xaf, 0x6b, 0xf5, 0x8d, 0xc7, 0xb8, 0x38, 0x09, 0xea,
	0x93, 0xa1, 0xfe, 0x0c, 0xe0, 0x4a, 0x17, 0x95, 0xa1, 0xe0, 0x93, 0x30, 0xb4, 0x42, 0xea, 0x0e,
	0xb4, 0x05, 0x54, 0x01, 0x90, 0x66, 0x40, 0x7d, 0xe7, 0x42, 0x53, 0xa6, 0xee, 0x63, 0x8f, 0x9f,
	0x6a, 0x19, 0xb4, 0x0c, 0x45, 0x69, 0xb2, 0xa1, 0xeb, 0x05, 0x54, 0xcb, 0xea, 0xbf, 0x64, 0x20,
	0x6b, 0xf8, 0xec, 0x3d, 0x2f, 0x95, 0x49, 0x01, 0x32, 0x33, 0x05, 0x10, 0x6b, 0xc4, 0x1b, 0xf9,
	0x11, 0xa7, 0x56, 0xe4, 0x32, 0x1e, 0x26, 0x93, 0x5f, 0x4a, 0xc0, 0x03, 0x81, 0xa1, 0x4d, 0xb8,
	0x49, 0xcf, 0x79, 0x40, 0xac, 0x34, 0x35, 0xde, 0x38, 0x37, 0xa4, 0xab, 0x39, 0xcb, 0x37, 0x20,
	0x6f, 0x13, 0x4e, 0x87, 0x5e, 0x70, 0x51, 0xcd, 0xc9, 0x35, 0x31, 0xaf, 0x2e, 0xfb, 0x3e, 0xb5,
	0x9b, 0x09, 0x2d, 0x79, 0x69, 0x4d, 0xc3, 0x50, 0x1b, 0xca, 0x72, 0x3d, 0x59, 0x62, 0x79, 0x30,
	0x77, 0x58, 0x5d, 0x92, 0x3a, 0xb5, 0x39, 0x3a, 0x0d, 0xc1, 0x93, 0x97, 0x2e, 0x48, 0x64, 0x4a,
	0xc7, 0x13, 0x88, 0xb9, 0x43, 0x74, 0x17, 0x80, 0xb3, 0x11, 0xf5, 0x22, 0x6e, 0x8d, 0xc4, 0xee,
	0x16, 0x49, 0x17, 0x12, 0x64, 0x37, 0xd4, 0xff, 0x50, 0xa0, 0x92, 0xde, 0x58, 0x6f, 0xf5, 0x56,
	0xf9, 0xf0, 0xde, 0xa2, 0x07, 0x70, 0xe3, 0x4a, 0x83, 0x8e, 0x7c, 0xb1, 0x4a, 0x92, 0xca, 0x6b,
	0x53, 0x5e, 0x82, 0xa3, 0x67, 0x50, 0x09, 0x68, 0x18, 0x39, 0x7c, 0x7a, 0xdc, 0xec, 0x07, 0x1c,
	0xb7, 0x1c, 0xc7, 0x4e, 0xce, 0x7b, 0x1b, 0xf2, 0xe2, 0x6e, 0xcb, 0x56, 0xcb, 0x0b, 0x83, 0x97,
	0x88, 0xcf, 0xba, 0x64, 0x44, 0xf5, 0x9f, 0x14, 0x28, 0xce, 0xc4, 0x8b, 0xd2, 0xc8, 0xe5, 0x1c,
	0x58, 0x24, 0x10, 0xc7, 0xcc, 0x8a, 0xfd, 0x19, 0x23, 0x46, 0x30, 0x44, 0x5f, 0x88, 0x19, 0x93,
	0x6e, 0x91, 0x71, 0x72, 0x49, 0xe6, 0xe5, 0xb4, 0x67, 0xe0, 0x7d, 0x13, 0x5b, 0xa2, 0x1a, 0x38,
	0x51, 0xdc, 0x89, 0x5c, 0x5b, 0x4c, 0xd7, 0x80, 0x9e, 0x10, 0x71, 0xb0, 0x78, 0xff, 0xca, 0x7b,
	0x8f, 0x4b, 0x09, 0x18, 0xaf, 0xdf, 0x3b, 0x90, 0xa7, 0xae, 0xed, 0x0d, 0xc4, 0xb1, 0xe3, 0x7c,
	0xa7, 0xb6, 0x7c, 0x39, 0xcd, 0xce, 0x09, 0xba, 0x2f, 0x14, 0x39, 0x0d, 0x46, 0xcc, 0x65, 0x21,
	0x67, 0x76, 0x32, 0xe3, 0x69, 0x50, 0xbc, 0xe9, 0x1c, 0xcf, 0x26, 0x8e, 0x4c, 0x39, 0x8f, 0x63,
	0x03, 0xe9, 0x50, 0x0a, 0xa3, 0xe3, 0xd0, 0x0e, 0x98, 0x2f, 0xaa, 0x2f, 0x93, 0xc9, 0xe3, 0x14,
	0x26, 0x92, 0x09, 0x39, 0xe1, 0xf4, 0x24, 0x72, 0x64, 0x32, 0x65, 0x3c, 0xb5, 0x51, 0x1d, 0x8a,
	0xa7, 0xc4, 0x1d, 0x32, 0x77, 0x28, 0xbe, 0x6e, 0xaa, 0x8b, 0x32, 0x1c, 0x12, 0xc8, 0xf0, 0xd9,
	0x86, 0x0e, 0x05, 0xf3, 0xab, 0xbe, 0xd9, 0xdd, 0x6f, 0xf7, 0xba, 0x62, 0x89, 0x77, 0x7b, 0x5d,
	0x33, 0x5e, 0xe2, 0x06, 0x6e, 0x3e, 0x69, 0x1f, 0x9a, 0x9a, 0xb2, 0xf1, 0xbd, 0x02, 0xa5, 0xd9,
	0xa9, 0x41, 0x25, 0xc8, 0xb7, 0xda, 0xfb, 0x46, 0xa3, 0x63, 0xb6, 0xb4, 0x05, 0xa4, 0x41, 0xe9,
	0xb1, 0xd9, 0xb7, 0x1a, 0x9d, 0x5e, 0xf3, 0x59, 0xf7, 0x60, 0x57, 0x53, 0xd0, 0x0a, 0x68, 0x53,
	0xc4, 0x6a, 0x1c, 0x59, 0x02, 0xcd, 0xa0, 0x3b, 0x70, 0x6b, 0xdf, 0xec, 0x5b, 0x1d, 0xa3, 0x6f,
	0xee, 0xf7, 0xad, 0x76, 0xd7, 0xda, 0x35, 0xfb, 0x46, 0xcb, 0xe8, 0x1b, 0x5a, 0x16, 0xdd, 0x02,
	0x94, 0xf6, 0x35, 0x7a, 0xad, 0x23, 0x4d, 0x15, 0xda, 0x87, 0x26, 0x6e, 0xef, 0xb4, 0x9b, 0x86,
	0x78, 0xba, 0xb6, 0x28, 0x98, 0x42, 0xdb, 0x34, 0x70, 0xa7, 0x2d, 0xb8, 0xf2, 0x21, 0x5a, 0x6e,
	0xe3, 0x5b, 0x05, 0x8a, 0x33, 0x3d, 0x45, 0x05, 0x58, 0x34, 0x77, 0xf7, 0xfa, 0x47, 0x71, 0x82,
	0xd2, 0x23, 0x52, 0x31, 0xf0, 0x63, 0x4d, 0x41, 0x37, 0x61, 0x39, 0x46, 0x9a, 0x46, 0xb7, 0xd7,
	0x6d, 0x37, 0x8d, 0x8e, 0x96, 0x11, 0x59, 0xc7, 0x60, 0xab, 0x2d, 0x8f, 0x6a, 0xe0, 0x23, 0x2d,
	0x8b, 0xea, 0xf0, 0x9f, 0xeb, 0xa8, 0xd5, 0xc3, 0x56, 0x0f, 0xb7, 0x4c, 0x6c, 0xb6, 0x34, 0x55,
	0x94, 0xaa, 0x65, 0xee, 0x18, 0x07, 0x9d, 0xbe, 0x96, 0x6b, 0x34, 0x7e, 0xb8, 0xac, 0x29, 0x2f,
	0x2e, 0x6b, 0xca, 0xcb, 0xcb, 0x9a, 0xf2, 0xdb, 0x65, 0x4d, 0xf9, 0xee, 0x55, 0x6d, 0xe1, 0xe5,
	0xab, 0xda, 0xc2, 0xaf, 0xaf, 0x6a, 0x0b, 0x5f, 0xdf, 0x1f, 0x32, 0x7e, 0x1a, 0x1d, 0x6f, 0xda,
	0xde, 0x68, 0x2b, 0xf5, 0xa9, 0x7e, 0x1e, 0x7f, 0xac, 0x8b, 0x57, 0x47, 0x78, 0x9c, 0x93, 0xdf,
	0xde, 0x0f, 0xff, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x49, 0x68, 0xe8, 0x57, 0xce, 0x0b, 0x00, 0x00,
}

func (this *ApiCollection) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ApiCollection)
	if !ok {
		that2, ok := that.(ApiCollection)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Enabled != that1.Enabled {
		return false
	}
	if !this.CollectionData.Equal(&that1.CollectionData) {
		return false
	}
	if len(this.Apis) != len(that1.Apis) {
		return false
	}
	for i := range this.Apis {
		if !this.Apis[i].Equal(that1.Apis[i]) {
			return false
		}
	}
	if len(this.Headers) != len(that1.Headers) {
		return false
	}
	for i := range this.Headers {
		if !this.Headers[i].Equal(that1.Headers[i]) {
			return false
		}
	}
	if len(this.InheritanceApis) != len(that1.InheritanceApis) {
		return false
	}
	for i := range this.InheritanceApis {
		if !this.InheritanceApis[i].Equal(that1.InheritanceApis[i]) {
			return false
		}
	}
	if len(this.ParseDirectives) != len(that1.ParseDirectives) {
		return false
	}
	for i := range this.ParseDirectives {
		if !this.ParseDirectives[i].Equal(that1.ParseDirectives[i]) {
			return false
		}
	}
	if len(this.Extensions) != len(that1.Extensions) {
		return false
	}
	for i := range this.Extensions {
		if !this.Extensions[i].Equal(that1.Extensions[i]) {
			return false
		}
	}
	if len(this.Verifications) != len(that1.Verifications) {
		return false
	}
	for i := range this.Verifications {
		if !this.Verifications[i].Equal(that1.Verifications[i]) {
			return false
		}
	}
	return true
}
func (this *Extension) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Extension)
	if !ok {
		that2, ok := that.(Extension)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if !this.Rule.Equal(that1.Rule) {
		return false
	}
	if this.CuMultiplier != that1.CuMultiplier {
		return false
	}
	return true
}
func (this *Rule) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Rule)
	if !ok {
		that2, ok := that.(Rule)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Block != that1.Block {
		return false
	}
	return true
}
func (this *Verification) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Verification)
	if !ok {
		that2, ok := that.(Verification)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if !this.ParseDirective.Equal(that1.ParseDirective) {
		return false
	}
	if len(this.Values) != len(that1.Values) {
		return false
	}
	for i := range this.Values {
		if !this.Values[i].Equal(that1.Values[i]) {
			return false
		}
	}
	return true
}
func (this *ParseValue) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ParseValue)
	if !ok {
		that2, ok := that.(ParseValue)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Extension != that1.Extension {
		return false
	}
	if this.ExpectedValue != that1.ExpectedValue {
		return false
	}
	if this.LatestDistance != that1.LatestDistance {
		return false
	}
	if this.Severity != that1.Severity {
		return false
	}
	return true
}
func (this *CollectionData) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*CollectionData)
	if !ok {
		that2, ok := that.(CollectionData)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ApiInterface != that1.ApiInterface {
		return false
	}
	if this.InternalPath != that1.InternalPath {
		return false
	}
	if this.Type != that1.Type {
		return false
	}
	if this.AddOn != that1.AddOn {
		return false
	}
	return true
}
func (this *Header) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Header)
	if !ok {
		that2, ok := that.(Header)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Kind != that1.Kind {
		return false
	}
	if this.FunctionTag != that1.FunctionTag {
		return false
	}
	return true
}
func (this *Api) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Api)
	if !ok {
		that2, ok := that.(Api)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Enabled != that1.Enabled {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.ComputeUnits != that1.ComputeUnits {
		return false
	}
	if this.ExtraComputeUnits != that1.ExtraComputeUnits {
		return false
	}
	if !this.Category.Equal(&that1.Category) {
		return false
	}
	if !this.BlockParsing.Equal(&that1.BlockParsing) {
		return false
	}
	if this.TimeoutMs != that1.TimeoutMs {
		return false
	}
	return true
}
func (this *ParseDirective) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ParseDirective)
	if !ok {
		that2, ok := that.(ParseDirective)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.FunctionTag != that1.FunctionTag {
		return false
	}
	if this.FunctionTemplate != that1.FunctionTemplate {
		return false
	}
	if !this.ResultParsing.Equal(&that1.ResultParsing) {
		return false
	}
	if this.ApiName != that1.ApiName {
		return false
	}
	return true
}
func (this *BlockParser) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BlockParser)
	if !ok {
		that2, ok := that.(BlockParser)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.ParserArg) != len(that1.ParserArg) {
		return false
	}
	for i := range this.ParserArg {
		if this.ParserArg[i] != that1.ParserArg[i] {
			return false
		}
	}
	if this.ParserFunc != that1.ParserFunc {
		return false
	}
	if this.DefaultValue != that1.DefaultValue {
		return false
	}
	if this.Encoding != that1.Encoding {
		return false
	}
	return true
}
func (this *SpecCategory) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SpecCategory)
	if !ok {
		that2, ok := that.(SpecCategory)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Deterministic != that1.Deterministic {
		return false
	}
	if this.Local != that1.Local {
		return false
	}
	if this.Subscription != that1.Subscription {
		return false
	}
	if this.Stateful != that1.Stateful {
		return false
	}
	if this.HangingApi != that1.HangingApi {
		return false
	}
	return true
}
func (m *ApiCollection) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ApiCollection) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ApiCollection) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Verifications) > 0 {
		for iNdEx := len(m.Verifications) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Verifications[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintApiCollection(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.Extensions) > 0 {
		for iNdEx := len(m.Extensions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Extensions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintApiCollection(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.ParseDirectives) > 0 {
		for iNdEx := len(m.ParseDirectives) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ParseDirectives[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintApiCollection(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.InheritanceApis) > 0 {
		for iNdEx := len(m.InheritanceApis) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.InheritanceApis[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintApiCollection(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Headers) > 0 {
		for iNdEx := len(m.Headers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Headers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintApiCollection(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Apis) > 0 {
		for iNdEx := len(m.Apis) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Apis[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintApiCollection(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	{
		size, err := m.CollectionData.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintApiCollection(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.Enabled {
		i--
		if m.Enabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Extension) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Extension) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Extension) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CuMultiplier != 0 {
		i = encodeVarintApiCollection(dAtA, i, uint64(m.CuMultiplier))
		i--
		dAtA[i] = 0x20
	}
	if m.Rule != nil {
		{
			size, err := m.Rule.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApiCollection(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintApiCollection(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Rule) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Rule) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Rule) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Block != 0 {
		i = encodeVarintApiCollection(dAtA, i, uint64(m.Block))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Verification) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Verification) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Verification) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Values) > 0 {
		for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Values[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintApiCollection(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.ParseDirective != nil {
		{
			size, err := m.ParseDirective.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApiCollection(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintApiCollection(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ParseValue) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ParseValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ParseValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Severity != 0 {
		i = encodeVarintApiCollection(dAtA, i, uint64(m.Severity))
		i--
		dAtA[i] = 0x20
	}
	if m.LatestDistance != 0 {
		i = encodeVarintApiCollection(dAtA, i, uint64(m.LatestDistance))
		i--
		dAtA[i] = 0x18
	}
	if len(m.ExpectedValue) > 0 {
		i -= len(m.ExpectedValue)
		copy(dAtA[i:], m.ExpectedValue)
		i = encodeVarintApiCollection(dAtA, i, uint64(len(m.ExpectedValue)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Extension) > 0 {
		i -= len(m.Extension)
		copy(dAtA[i:], m.Extension)
		i = encodeVarintApiCollection(dAtA, i, uint64(len(m.Extension)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CollectionData) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CollectionData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CollectionData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AddOn) > 0 {
		i -= len(m.AddOn)
		copy(dAtA[i:], m.AddOn)
		i = encodeVarintApiCollection(dAtA, i, uint64(len(m.AddOn)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Type) > 0 {
		i -= len(m.Type)
		copy(dAtA[i:], m.Type)
		i = encodeVarintApiCollection(dAtA, i, uint64(len(m.Type)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.InternalPath) > 0 {
		i -= len(m.InternalPath)
		copy(dAtA[i:], m.InternalPath)
		i = encodeVarintApiCollection(dAtA, i, uint64(len(m.InternalPath)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ApiInterface) > 0 {
		i -= len(m.ApiInterface)
		copy(dAtA[i:], m.ApiInterface)
		i = encodeVarintApiCollection(dAtA, i, uint64(len(m.ApiInterface)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Header) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Header) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Header) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FunctionTag != 0 {
		i = encodeVarintApiCollection(dAtA, i, uint64(m.FunctionTag))
		i--
		dAtA[i] = 0x18
	}
	if m.Kind != 0 {
		i = encodeVarintApiCollection(dAtA, i, uint64(m.Kind))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintApiCollection(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Api) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Api) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Api) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TimeoutMs != 0 {
		i = encodeVarintApiCollection(dAtA, i, uint64(m.TimeoutMs))
		i--
		dAtA[i] = 0x40
	}
	{
		size, err := m.BlockParsing.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintApiCollection(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	{
		size, err := m.Category.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintApiCollection(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	if m.ExtraComputeUnits != 0 {
		i = encodeVarintApiCollection(dAtA, i, uint64(m.ExtraComputeUnits))
		i--
		dAtA[i] = 0x20
	}
	if m.ComputeUnits != 0 {
		i = encodeVarintApiCollection(dAtA, i, uint64(m.ComputeUnits))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintApiCollection(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if m.Enabled {
		i--
		if m.Enabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ParseDirective) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ParseDirective) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ParseDirective) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ApiName) > 0 {
		i -= len(m.ApiName)
		copy(dAtA[i:], m.ApiName)
		i = encodeVarintApiCollection(dAtA, i, uint64(len(m.ApiName)))
		i--
		dAtA[i] = 0x22
	}
	{
		size, err := m.ResultParsing.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintApiCollection(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.FunctionTemplate) > 0 {
		i -= len(m.FunctionTemplate)
		copy(dAtA[i:], m.FunctionTemplate)
		i = encodeVarintApiCollection(dAtA, i, uint64(len(m.FunctionTemplate)))
		i--
		dAtA[i] = 0x12
	}
	if m.FunctionTag != 0 {
		i = encodeVarintApiCollection(dAtA, i, uint64(m.FunctionTag))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BlockParser) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BlockParser) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockParser) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Encoding) > 0 {
		i -= len(m.Encoding)
		copy(dAtA[i:], m.Encoding)
		i = encodeVarintApiCollection(dAtA, i, uint64(len(m.Encoding)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.DefaultValue) > 0 {
		i -= len(m.DefaultValue)
		copy(dAtA[i:], m.DefaultValue)
		i = encodeVarintApiCollection(dAtA, i, uint64(len(m.DefaultValue)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ParserFunc != 0 {
		i = encodeVarintApiCollection(dAtA, i, uint64(m.ParserFunc))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ParserArg) > 0 {
		for iNdEx := len(m.ParserArg) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ParserArg[iNdEx])
			copy(dAtA[i:], m.ParserArg[iNdEx])
			i = encodeVarintApiCollection(dAtA, i, uint64(len(m.ParserArg[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *SpecCategory) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SpecCategory) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SpecCategory) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.HangingApi {
		i--
		if m.HangingApi {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.Stateful != 0 {
		i = encodeVarintApiCollection(dAtA, i, uint64(m.Stateful))
		i--
		dAtA[i] = 0x20
	}
	if m.Subscription {
		i--
		if m.Subscription {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.Local {
		i--
		if m.Local {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.Deterministic {
		i--
		if m.Deterministic {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintApiCollection(dAtA []byte, offset int, v uint64) int {
	offset -= sovApiCollection(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *ApiCollection) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Enabled {
		n += 2
	}
	l = m.CollectionData.Size()
	n += 1 + l + sovApiCollection(uint64(l))
	if len(m.Apis) > 0 {
		for _, e := range m.Apis {
			l = e.Size()
			n += 1 + l + sovApiCollection(uint64(l))
		}
	}
	if len(m.Headers) > 0 {
		for _, e := range m.Headers {
			l = e.Size()
			n += 1 + l + sovApiCollection(uint64(l))
		}
	}
	if len(m.InheritanceApis) > 0 {
		for _, e := range m.InheritanceApis {
			l = e.Size()
			n += 1 + l + sovApiCollection(uint64(l))
		}
	}
	if len(m.ParseDirectives) > 0 {
		for _, e := range m.ParseDirectives {
			l = e.Size()
			n += 1 + l + sovApiCollection(uint64(l))
		}
	}
	if len(m.Extensions) > 0 {
		for _, e := range m.Extensions {
			l = e.Size()
			n += 1 + l + sovApiCollection(uint64(l))
		}
	}
	if len(m.Verifications) > 0 {
		for _, e := range m.Verifications {
			l = e.Size()
			n += 1 + l + sovApiCollection(uint64(l))
		}
	}
	return n
}

func (m *Extension) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovApiCollection(uint64(l))
	}
	if m.Rule != nil {
		l = m.Rule.Size()
		n += 1 + l + sovApiCollection(uint64(l))
	}
	if m.CuMultiplier != 0 {
		n += 1 + sovApiCollection(uint64(m.CuMultiplier))
	}
	return n
}

func (m *Rule) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Block != 0 {
		n += 1 + sovApiCollection(uint64(m.Block))
	}
	return n
}

func (m *Verification) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovApiCollection(uint64(l))
	}
	if m.ParseDirective != nil {
		l = m.ParseDirective.Size()
		n += 1 + l + sovApiCollection(uint64(l))
	}
	if len(m.Values) > 0 {
		for _, e := range m.Values {
			l = e.Size()
			n += 1 + l + sovApiCollection(uint64(l))
		}
	}
	return n
}

func (m *ParseValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Extension)
	if l > 0 {
		n += 1 + l + sovApiCollection(uint64(l))
	}
	l = len(m.ExpectedValue)
	if l > 0 {
		n += 1 + l + sovApiCollection(uint64(l))
	}
	if m.LatestDistance != 0 {
		n += 1 + sovApiCollection(uint64(m.LatestDistance))
	}
	if m.Severity != 0 {
		n += 1 + sovApiCollection(uint64(m.Severity))
	}
	return n
}

func (m *CollectionData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ApiInterface)
	if l > 0 {
		n += 1 + l + sovApiCollection(uint64(l))
	}
	l = len(m.InternalPath)
	if l > 0 {
		n += 1 + l + sovApiCollection(uint64(l))
	}
	l = len(m.Type)
	if l > 0 {
		n += 1 + l + sovApiCollection(uint64(l))
	}
	l = len(m.AddOn)
	if l > 0 {
		n += 1 + l + sovApiCollection(uint64(l))
	}
	return n
}

func (m *Header) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovApiCollection(uint64(l))
	}
	if m.Kind != 0 {
		n += 1 + sovApiCollection(uint64(m.Kind))
	}
	if m.FunctionTag != 0 {
		n += 1 + sovApiCollection(uint64(m.FunctionTag))
	}
	return n
}

func (m *Api) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Enabled {
		n += 2
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovApiCollection(uint64(l))
	}
	if m.ComputeUnits != 0 {
		n += 1 + sovApiCollection(uint64(m.ComputeUnits))
	}
	if m.ExtraComputeUnits != 0 {
		n += 1 + sovApiCollection(uint64(m.ExtraComputeUnits))
	}
	l = m.Category.Size()
	n += 1 + l + sovApiCollection(uint64(l))
	l = m.BlockParsing.Size()
	n += 1 + l + sovApiCollection(uint64(l))
	if m.TimeoutMs != 0 {
		n += 1 + sovApiCollection(uint64(m.TimeoutMs))
	}
	return n
}

func (m *ParseDirective) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FunctionTag != 0 {
		n += 1 + sovApiCollection(uint64(m.FunctionTag))
	}
	l = len(m.FunctionTemplate)
	if l > 0 {
		n += 1 + l + sovApiCollection(uint64(l))
	}
	l = m.ResultParsing.Size()
	n += 1 + l + sovApiCollection(uint64(l))
	l = len(m.ApiName)
	if l > 0 {
		n += 1 + l + sovApiCollection(uint64(l))
	}
	return n
}

func (m *BlockParser) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ParserArg) > 0 {
		for _, s := range m.ParserArg {
			l = len(s)
			n += 1 + l + sovApiCollection(uint64(l))
		}
	}
	if m.ParserFunc != 0 {
		n += 1 + sovApiCollection(uint64(m.ParserFunc))
	}
	l = len(m.DefaultValue)
	if l > 0 {
		n += 1 + l + sovApiCollection(uint64(l))
	}
	l = len(m.Encoding)
	if l > 0 {
		n += 1 + l + sovApiCollection(uint64(l))
	}
	return n
}

func (m *SpecCategory) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Deterministic {
		n += 2
	}
	if m.Local {
		n += 2
	}
	if m.Subscription {
		n += 2
	}
	if m.Stateful != 0 {
		n += 1 + sovApiCollection(uint64(m.Stateful))
	}
	if m.HangingApi {
		n += 2
	}
	return n
}

func sovApiCollection(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozApiCollection(x uint64) (n int) {
	return sovApiCollection(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ApiCollection) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApiCollection
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ApiCollection: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ApiCollection: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Enabled = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CollectionData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CollectionData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Apis", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Apis = append(m.Apis, &Api{})
			if err := m.Apis[len(m.Apis)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Headers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Headers = append(m.Headers, &Header{})
			if err := m.Headers[len(m.Headers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InheritanceApis", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InheritanceApis = append(m.InheritanceApis, &CollectionData{})
			if err := m.InheritanceApis[len(m.InheritanceApis)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParseDirectives", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ParseDirectives = append(m.ParseDirectives, &ParseDirective{})
			if err := m.ParseDirectives[len(m.ParseDirectives)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Extensions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Extensions = append(m.Extensions, &Extension{})
			if err := m.Extensions[len(m.Extensions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Verifications", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Verifications = append(m.Verifications, &Verification{})
			if err := m.Verifications[len(m.Verifications)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApiCollection(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApiCollection
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Extension) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApiCollection
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Extension: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Extension: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Rule == nil {
				m.Rule = &Rule{}
			}
			if err := m.Rule.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CuMultiplier", wireType)
			}
			m.CuMultiplier = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CuMultiplier |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApiCollection(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApiCollection
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Rule) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApiCollection
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Rule: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Rule: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType)
			}
			m.Block = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Block |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApiCollection(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApiCollection
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Verification) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApiCollection
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Verification: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Verification: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParseDirective", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ParseDirective == nil {
				m.ParseDirective = &ParseDirective{}
			}
			if err := m.ParseDirective.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Values = append(m.Values, &ParseValue{})
			if err := m.Values[len(m.Values)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApiCollection(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApiCollection
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ParseValue) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApiCollection
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ParseValue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ParseValue: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Extension", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Extension = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpectedValue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExpectedValue = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LatestDistance", wireType)
			}
			m.LatestDistance = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LatestDistance |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Severity", wireType)
			}
			m.Severity = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Severity |= ParseValue_VerificationSeverity(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApiCollection(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApiCollection
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CollectionData) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApiCollection
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CollectionData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CollectionData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApiInterface", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ApiInterface = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InternalPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InternalPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AddOn", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AddOn = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApiCollection(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApiCollection
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Header) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApiCollection
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Header: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Header: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
			}
			m.Kind = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Kind |= Header_HeaderType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FunctionTag", wireType)
			}
			m.FunctionTag = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FunctionTag |= FUNCTION_TAG(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApiCollection(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApiCollection
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Api) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApiCollection
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Api: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Api: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Enabled = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ComputeUnits", wireType)
			}
			m.ComputeUnits = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ComputeUnits |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExtraComputeUnits", wireType)
			}
			m.ExtraComputeUnits = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExtraComputeUnits |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Category", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Category.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockParsing", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.BlockParsing.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeoutMs", wireType)
			}
			m.TimeoutMs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TimeoutMs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApiCollection(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApiCollection
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ParseDirective) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApiCollection
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ParseDirective: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ParseDirective: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FunctionTag", wireType)
			}
			m.FunctionTag = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FunctionTag |= FUNCTION_TAG(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FunctionTemplate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FunctionTemplate = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResultParsing", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ResultParsing.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApiName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ApiName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApiCollection(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApiCollection
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockParser) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApiCollection
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BlockParser: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockParser: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParserArg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ParserArg = append(m.ParserArg, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParserFunc", wireType)
			}
			m.ParserFunc = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ParserFunc |= PARSER_FUNC(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultValue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DefaultValue = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Encoding", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApiCollection
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApiCollection
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Encoding = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApiCollection(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApiCollection
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SpecCategory) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApiCollection
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SpecCategory: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SpecCategory: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Deterministic", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Deterministic = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Local", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Local = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subscription", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Subscription = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Stateful", wireType)
			}
			m.Stateful = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Stateful |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HangingApi", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.HangingApi = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipApiCollection(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApiCollection
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipApiCollection(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowApiCollection
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowApiCollection
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthApiCollection
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupApiCollection
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthApiCollection
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthApiCollection        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowApiCollection          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupApiCollection = fmt.Errorf("proto: unexpected end of group")
)