schema

type ActionFnType func(
	targetNode Node,
	parentNode *XNode,
	nodeToFind NodeSpec,
	path []string,
	param interface{},
) (done, success bool, retSlice []interface{})

type Binary interface {
	Type
	Length() *Length
	// contains filtered or unexported methods
}

type Bit struct {
	Name string
	Desc string
	Ref  string

	Pos int32
	// contains filtered or unexported fields
}

type BitWidth int

type Bits interface {
	Type
	Bits() []*Bit
	// contains filtered or unexported methods
}

type Boolean interface {
	Type
	// contains filtered or unexported methods
}

type Case interface {
	Node
	// contains filtered or unexported methods
}

type Choice interface {
	Node
	DefaultCase() string
	// contains filtered or unexported methods
}

type ConfigChecker func(sch Node) bool

type Container interface {
	Node
	Presence() bool
	// contains filtered or unexported methods
}

type Decimal64 interface {
	Number
	Fd() Fracdigit
	Rbs() DrbSlice
	// contains filtered or unexported methods
}

type Drb struct {
	Start, End float64
}

type DrbSlice []Drb

type Empty interface {
	Type
	// contains filtered or unexported methods
}

type Enum struct {
	Val  string
	Desc string
	Ref  string

	Value int
	// contains filtered or unexported fields
}

type Enumeration interface {
	Type
	Enums() []*Enum
	String() string
	// contains filtered or unexported methods
}

type Filter func(Node, datanode.DataNode, []datanode.DataNode) bool

type Fracdigit int

type Identity struct {
	Val  string
	Desc string
	Ref  string

	Value     string
	Module    string
	Namespace string
	// contains filtered or unexported fields
}

type Identityref interface {
	Type
	Identities() []*Identity
	String() string
	// contains filtered or unexported methods
}

type InstanceId interface {
	Type
	Require() bool
	// contains filtered or unexported methods
}

type Integer interface {
	Number
	Rbs() RbSlice
	// contains filtered or unexported methods
}

type Lb struct {
	Start, End uint64
	// contains filtered or unexported fields
}

type LbSlice []Lb

type Leaf interface {
	Node
	Default() (string, bool)
	// contains filtered or unexported methods
}

type LeafList interface {
	Node
	Limit() Limit
	// contains filtered or unexported methods
}

type LeafValue interface {
	Node
	IsLeafValue()
}

type Leafref interface {
	Type
	Mach() *xpath.Machine
	GetAbsPath(xutils.PathType) xutils.PathType
	// contains filtered or unexported methods
}

type Length struct {
	Lbs    LbSlice
	Msg    string
	AppTag string
	// contains filtered or unexported fields
}

type Limit struct {
	Min uint
	Max uint
}

type List interface {
	Node
	Limit() Limit
	Keys() []string
	Uniques() [][][]xml.Name
	// contains filtered or unexported methods
}

type ListEntry interface {
	Node
	Keys() []string
	// contains filtered or unexported methods
}

type Model interface {
	Tree
	EncodeXML(*xml.Encoder)
	Identifier() string
	Version() string
	Data() string
	Features() []string
	Rpcs() map[string]Rpc
	Notifications() map[string]Notification
	Deviations() []string
	// contains filtered or unexported methods
}

type ModelSet interface {
	Tree
	Modules() map[string]Model
	Submodules() map[string]Submodule
	Rpcs() map[string]map[string]Rpc
	Notifications() map[string]map[string]Notification

	FindOrWalk(
		nodeToFind NodeSpec,
		actionFn ActionFnType,
		param interface{}) (Node, bool, []interface{})
	// contains filtered or unexported methods
}

type MustContext struct {
	WhenAndMustContext

	// Used to evaluate paths in the configd:must extension
	ExtPathEvalMach *xpath.Machine
}

type Node interface {
	Child(string) Node

	Descendant([]string) Node
	Validate(ValidateCtx, []string, []string) error
	CheckCardinality(xutils.PathType, int) error
	Children() []Node
	OpdChildren() []Node
	Choices() []Node
	Name() string
	Namespace() string
	Module() string
	Submodule() string
	Paths(string) []string
	Whens() []WhenContext
	Musts() []MustContext
	Type() Type
	HasDefault() bool
	DefaultChild(name string) Node
	DefaultChildNames() []string
	DefaultChildren() []Node
	OrdBy() string
	HasPresence() bool
	Config() bool
	String() string
	Status() Status
	Description() string
	Repeatable() bool

	Parent() *node

	Arguments() []string
	Mandatory() bool
	// contains filtered or unexported methods
}

type NodeProperty struct {
	NodeProp  string
	NodeValue string
}

type NodeSpec struct {
	Path                  []string
	DefaultPropNotPresent bool // If true, we expect node to exist w/o property
	Statement             NodeSubSpec
	DataPropNotPresent    bool // If true, we expect node to exist w/o data
	Data                  NodeSubSpec
}

type NodeSubSpec struct {
	Type       string
	Properties []NodeProperty
}

type Notification interface {
	Schema() Tree
	// contains filtered or unexported methods
}

type Number interface {
	Type
	Ranges() RangeBoundarySlicer
	Msg() string
	AppTag() string
	BitWidth() BitWidth
}

type OpdArgument interface {
	Node
	Default() (string, bool)
	OnEnter() string
	Privileged() bool
	Local() bool
	Secret() bool
	PassOpcArgs() bool
	// contains filtered or unexported methods
}

type OpdCommand interface {
	Node
	OnEnter() string
	Privileged() bool
	Local() bool
	Secret() bool
	PassOpcArgs() bool
	// contains filtered or unexported methods
}

type OpdOption interface {
	Node
	Default() (string, bool)
	OnEnter() string
	Privileged() bool
	Local() bool
	Secret() bool
	PassOpcArgs() bool
	// contains filtered or unexported methods
}

type OpdOptionValue interface {
	Node
	IsOpdOptionValue()
}

type Pattern struct {
	Pattern string
	*regexp.Regexp
	Msg    string
	AppTag string
}

type RangeBoundarySlicer interface {
	// Return length of RangeBoundary
	Len() int

	// Pretty-print function for %s
	String(i int) string

	// Return start/end value at given position in the slice
	GetStart(i int) interface{}
	GetEnd(i int) interface{}

	// For ranges with discrete values (ie int/uint/string), if one range
	// ends at 'x' and the following one starts at 'x + 1', then the two
	// ranges may be deemed to be contiguous, and a derived type or
	// refined range may span the two.
	//
	// NB: decimal64 covers real rather than whole numbers and so no two
	// ranges can ever be considered contiguous.
	Contiguous(lower, higher interface{}) bool

	// Return a RangeBoundarySlicer object with given entries and capacity.
	Create(entries, capacity int) RangeBoundarySlicer

	// Parse the string to obtain the numeric values for the range(s)
	// specified.
	Parse(start string, base int, bitSize int) (interface{}, error)

	// Create a new slice element with start and end and append it to the
	// slice.
	Append(start, end interface{}) RangeBoundarySlicer

	// These two don't really belong here - a type switch function would
	// perhaps be more appropriate - as they only use the RangeBoundary to
	// implicitly tell what underlying type to use.
	LessThan(first, second interface{}) bool
	GreaterThan(first, second interface{}) bool
}

type Rb struct {
	Start, End int64
}

type RbSlice []Rb

type Restriction interface {
	// contains filtered or unexported methods
}

type Rpc interface {
	Input() Tree
	Output() Tree
	// contains filtered or unexported methods
}

type SchemaValidator struct {
	// contains filtered or unexported fields
}

type Status int

type String interface {
	Type
	Len() *Length
	Pats() [][]Pattern
	PatHelps() [][]string
	// contains filtered or unexported methods
}

type Submodule interface {
	EncodeXML(*xml.Encoder)
	Identifier() string
	Namespace() string
	Data() string
	// contains filtered or unexported methods
}

type Tree interface {
	Node
	// contains filtered or unexported methods
}

type Type interface {
	Validate(ctx ValidateCtx, path []string, s string) error
	Name() xml.Name

	// Strings (possibly other types) may have an empty string as the default.
	// So, we need to explicitly note the presence / absence of a default
	Default() (string, bool)
	AllowedValues(ctxNode xutils.XpathNode, debug bool) (
		allowedValues []string, err error)
	// contains filtered or unexported methods
}

type Uinteger interface {
	Number
	Rbs() UrbSlice
	// contains filtered or unexported methods
}

type Union interface {
	Type
	Typs() []Type
	MatchType(ctx ValidateCtx, path []string, s string) Type
	// contains filtered or unexported methods
}

type Urb struct {
	Start, End uint64
}

type UrbSlice []Urb

type ValidateCtx interface {
	ErrorHelpText() []string
	// For validating paths that could exist, eg when making a NETCONF request
	// for the tree under a non-presence container, we need to allow a path
	// that stops at a non-presence container to be considered valid.  Likewise
	// list names w/o entry name, leaves w/o values.
	AllowIncompletePaths() bool
}

type ValidationType int

type WhenAndMustContext struct {
	// Mach is the machine that evaulates the full XPATH logic.
	Mach *xpath.Machine

	// ErrMsg is the error message when the XPATH expression returns false.
	//
	// For 'must', this can be specified in YANG, or a default generated by
	// the compiler.  For 'when', it is always the latter.
	ErrMsg string

	// AppTag is used in the <rpc-error> error-app-tag field in errors sent
	// to NETCONF clients.
	AppTag string

	// PathEvalMach is the machine that checks paths in the XPATH expression.
	PathEvalMach *xpath.Machine
	Namespace    string
}

type WhenContext struct {
	WhenAndMustContext

	// RunAsParent indicates whether the machine is run on node or parent.
	//
	// 'when' statements can be added directly under an augment statement. In
	// this case we store the statement on each augmented child, but need to
	// run it using the context (current node) set to the parent node.
	RunAsParent bool
}

type XNode struct {
	Node
	// contains filtered or unexported fields
}

type YangDebugOption func(*yangValDebugContext)