vdl

type Decoder interface {
	// StartValue must be called before decoding each value, for both scalar and
	// composite values.  The want type is the type of value being decoded into,
	// used to check compatibility with the value in the decoder; use AnyType if
	// you don't know, or want to decode any type of value.  Each call pushes the
	// type of the next value on to the stack.
	StartValue(want *Type) error
	// FinishValue must be called after decoding each value, for both scalar and
	// composite values.  Each call pops the type of the top value off of the
	// stack.
	FinishValue() error
	// SkipValue skips the next value; logically it behaves as if a full sequence
	// of StartValue / ...Decode*... / FinishValue were called.  It enables
	// optimizations when the caller doesn't care about the next value.
	SkipValue() error
	// IgnoreNextStartValue instructs the Decoder to ignore the next call to
	// StartValue.  It is used to simplify implementations of VDLRead; e.g. a
	// caller might call StartValue to check for nil values, and subsequently call
	// StartValue again to read non-nil values.  IgnoreNextStartValue is used to
	// ignore the second StartValue call.
	IgnoreNextStartValue()

	// NextEntry instructs the Decoder to move to the next element of an Array or
	// List, the next key of a Set, or the next (key,elem) pair of a Map.  Returns
	// done=true when there are no remaining entries.
	NextEntry() (done bool, _ error)
	// NextField instructs the Decoder to move to the next field of a Struct or
	// Union.  Returns the index of the next field, or -1 when there are no
	// remaining fields.  You may call Decoder.Type().Field(index).Name to
	// retrieve the name of the struct or union field.
	NextField() (index int, _ error)

	// Type returns the type of the top value on the stack.  Returns nil when the
	// stack is empty.  The returned type is only Any or Optional iff the value is
	// nil; non-nil values are "auto-dereferenced" to their underlying elem value.
	Type() *Type
	// IsAny returns true iff the type of the top value on the stack was Any,
	// despite the "auto-dereference" behavior of non-nil values.
	IsAny() bool
	// IsOptional returns true iff the type of the top value on the stack was
	// Optional, despite the "auto-dereference" behavior of non-nil values.
	IsOptional() bool
	// IsNil returns true iff the top value on the stack is nil.  It is equivalent
	// to Type() == AnyType || Type().Kind() == Optional.
	IsNil() bool
	// Index returns the index of the current entry or field of the top value on
	// the stack.  Returns -1 if the top value is a scalar, or if NextEntry /
	// NextField has not been called.
	Index() int
	// LenHint returns the length of the top value on the stack, if it is
	// available.  Returns -1 if the top value is a scalar, or if the length is
	// not available.
	LenHint() int

	// DecodeBool returns the top value on the stack as a bool.
	DecodeBool() (bool, error)
	// DecodeString returns the top value on the stack as a string.
	DecodeString() (string, error)
	// DecodeUint returns the top value on the stack as a uint, where the result
	// has bitlen bits.  Errors are returned on loss of precision.
	DecodeUint(bitlen int) (uint64, error)
	// DecodeInt returns the top value on the stack as an int, where the result
	// has bitlen bits.  Errors are returned on loss of precision.
	DecodeInt(bitlen int) (int64, error)
	// DecodeFloat returns the top value on the stack as a float, where the result
	// has bitlen bits.  Errors are returned on loss of precision.
	DecodeFloat(bitlen int) (float64, error)
	// DecodeTypeObject returns the top value on the stack as a type.
	DecodeTypeObject() (*Type, error)
	// DecodeBytes decodes the top value on the stack as bytes, into x.  If
	// fixedLen >= 0 the decoded bytes must be exactly that length, otherwise
	// there is no restriction on the number of decoded bytes.  If cap(*x) is not
	// large enough to fit the decoded bytes, a new byte slice is assigned to *x.
	DecodeBytes(fixedLen int, x *[]byte) error

	// ReadValueBool behaves as if StartValue, DecodeBool, FinishValue were
	// called in sequence.  Some decoders optimize this codepath.
	ReadValueBool() (bool, error)
	// ReadValueString behaves as if StartValue, DecodeString, FinishValue were
	// called in sequence.  Some decoders optimize this codepath.
	ReadValueString() (string, error)
	// ReadValueUint behaves as if StartValue, DecodeUint, FinishValue were called
	// in sequence.  Some decoders optimize this codepath.
	ReadValueUint(bitlen int) (uint64, error)
	// ReadValueInt behaves as if StartValue, DecodeInt, FinishValue were called
	// in sequence.  Some decoders optimize this codepath.
	ReadValueInt(bitlen int) (int64, error)
	// ReadValueFloat behaves as if StartValue, DecodeFloat, FinishValue were
	// called in sequence.  Some decoders optimize this codepath.
	ReadValueFloat(bitlen int) (float64, error)
	// ReadValueTypeObject behaves as if StartValue, DecodeTypeObject, FinishValue
	// were called in sequence.  Some decoders optimize this codepath.
	ReadValueTypeObject() (*Type, error)
	// ReadValueBytes behaves as if StartValue, DecodeBytes, FinishValue were
	// called in sequence.  Some decoders optimize this codepath.
	ReadValueBytes(fixedLen int, x *[]byte) error

	// NextEntryValueBool behaves as if NextEntry, StartValue, DecodeBool,
	// FinishValue were called in sequence.  Some decoders optimize this codepath.
	NextEntryValueBool() (done bool, _ bool, _ error)
	// NextEntryValueString behaves as if NextEntry, StartValue, DecodeString,
	// FinishValue were called in sequence.  Some decoders optimize this codepath.
	NextEntryValueString() (done bool, _ string, _ error)
	// NextEntryValueUint behaves as if NextEntry, StartValue, DecodeUint,
	// FinishValue were called in sequence.  Some decoders optimize this codepath.
	NextEntryValueUint(bitlen int) (done bool, _ uint64, _ error)
	// NextEntryValueInt behaves as if NextEntry, StartValue, DecodeInt,
	// FinishValue were called in sequence.  Some decoders optimize this codepath.
	NextEntryValueInt(bitlen int) (done bool, _ int64, _ error)
	// NextEntryValueFloat behaves as if NextEntry, StartValue, DecodeFloat,
	// FinishValue were called in sequence.  Some decoders optimize this codepath.
	NextEntryValueFloat(bitlen int) (done bool, _ float64, _ error)
	// NextEntryValueTypeObject behaves as if NextEntry, StartValue,
	// DecodeTypeObject, FinishValue were called in sequence.  Some decoders
	// optimize this codepath.
	NextEntryValueTypeObject() (done bool, _ *Type, _ error)
}

type Encoder interface {
	// StartValue must be called before encoding each non-nil value, for both
	// scalar and composite values.  The tt type cannot be Any or Optional; use
	// NilValue to encode nil values.
	StartValue(tt *Type) error
	// FinishValue must be called after encoding each non-nil value, for both
	// scalar and composite values.
	FinishValue() error
	// NilValue encodes a nil value.  The tt type must be Any or Optional.
	NilValue(tt *Type) error
	// SetNextStartValueIsOptional instructs the encoder that the next call to
	// StartValue represents a value with an Optional type.
	SetNextStartValueIsOptional()

	// NextEntry instructs the Encoder to move to the next element of an Array or
	// List, the next key of a Set, or the next (key,elem) pair of a Map.  Set
	// done=true when there are no remaining entries.
	NextEntry(done bool) error
	// NextField instructs the Encoder to move to the next field of a Struct or
	// Union.  Set index to the index of the next field, or -1 when there are no
	// remaining fields.
	NextField(index int) error

	// SetLenHint sets the length of the List, Set or Map value.  It may only be
	// called immediately after StartValue, before NextEntry has been called.  Do
	// not call this method if the length is not known.
	SetLenHint(lenHint int) error

	// EncodeBool encodes a bool value.
	EncodeBool(value bool) error
	// EncodeString encodes a string value.
	EncodeString(value string) error
	// EncodeUint encodes a uint value.
	EncodeUint(value uint64) error
	// EncodeInt encodes an int value.
	EncodeInt(value int64) error
	// EncodeFloat encodes a float value.
	EncodeFloat(value float64) error
	// EncodeTypeObject encodes a type.
	EncodeTypeObject(value *Type) error
	// EncodeBytes encodes a bytes value; either an array or list of bytes.
	EncodeBytes(value []byte) error

	// WriteValueBool behaves as if StartValue, EncodeBool, FinishValue were
	// called in sequence.  Some encoders optimize this codepath.
	WriteValueBool(tt *Type, value bool) error
	// WriteValueString behaves as if StartValue, EncodeString, FinishValue were
	// called in sequence.  Some encoders optimize this codepath.
	WriteValueString(tt *Type, value string) error
	// WriteValueUint behaves as if StartValue, EncodeUint, FinishValue were
	// called in sequence.  Some encoders optimize this codepath.
	WriteValueUint(tt *Type, value uint64) error
	// WriteValueInt behaves as if StartValue, EncodeInt, FinishValue were called
	// in sequence.  Some encoders optimize this codepath.
	WriteValueInt(tt *Type, value int64) error
	// WriteValueFloat behaves as if StartValue, EncodeFloat, FinishValue were
	// called in sequence.  Some encoders optimize this codepath.
	WriteValueFloat(tt *Type, value float64) error
	// WriteValueTypeObject behaves as if StartValue, EncodeTypeObject,
	// FinishValue were called in sequence.  Some encoders optimize this codepath.
	WriteValueTypeObject(value *Type) error
	// WriteValueBytes behaves as if StartValue, EncodeBytes, FinishValue were
	// called in sequence.  Some encoders optimize this codepath.
	WriteValueBytes(tt *Type, value []byte) error

	// NextEntryValueBool behaves as if NextEntry, StartValue, EncodeBool,
	// FinishValue were called in sequence.  Some encoders optimize this codepath.
	NextEntryValueBool(tt *Type, value bool) error
	// NextEntryValueString behaves as if NextEntry, StartValue, EncodeString,
	// FinishValue were called in sequence.  Some encoders optimize this codepath.
	NextEntryValueString(tt *Type, value string) error
	// NextEntryValueUint behaves as if NextEntry, StartValue, EncodeUint,
	// FinishValue were called in sequence.  Some encoders optimize this codepath.
	NextEntryValueUint(tt *Type, value uint64) error
	// NextEntryValueInt behaves as if NextEntry, StartValue, EncodeInt,
	// FinishValue were called in sequence.  Some encoders optimize this codepath.
	NextEntryValueInt(tt *Type, value int64) error
	// NextEntryValueFloat behaves as if NextEntry, StartValue, EncodeFloat,
	// FinishValue were called in sequence.  Some encoders optimize this codepath.
	NextEntryValueFloat(tt *Type, value float64) error
	// NextEntryValueTypeObject behaves as if NextEntry, StartValue,
	// EncodeTypeObject, FinishValue were called in sequence.  Some encoders
	// optimize this codepath.
	NextEntryValueTypeObject(value *Type) error
	// NextEntryValueBytes behaves as if NextEntry, StartValue, EncodeBytes,
	// FinishValue were called in sequence.  Some encoders optimize this codepath.
	NextEntryValueBytes(tt *Type, value []byte) error

	// NextFieldValueBool behaves as if NextEntry, StartValue, EncodeBool,
	// FinishValue were called in sequence.  Some encoders optimize this codepath.
	NextFieldValueBool(index int, tt *Type, value bool) error
	// NextFieldValueString behaves as if NextEntry, StartValue, EncodeString,
	// FinishValue were called in sequence.  Some encoders optimize this codepath.
	NextFieldValueString(index int, tt *Type, value string) error
	// NextFieldValueUint behaves as if NextEntry, StartValue, EncodeUint,
	// FinishValue were called in sequence.  Some encoders optimize this codepath.
	NextFieldValueUint(index int, tt *Type, value uint64) error
	// NextFieldValueInt behaves as if NextEntry, StartValue, EncodeInt,
	// FinishValue were called in sequence.  Some encoders optimize this codepath.
	NextFieldValueInt(index int, tt *Type, value int64) error
	// NextFieldValueFloat behaves as if NextEntry, StartValue, EncodeFloat,
	// FinishValue were called in sequence.  Some encoders optimize this codepath.
	NextFieldValueFloat(index int, tt *Type, value float64) error
	// NextFieldValueTypeObject behaves as if NextEntry, StartValue,
	// EncodeTypeObject, FinishValue were called in sequence.  Some encoders
	// optimize this codepath.
	NextFieldValueTypeObject(index int, value *Type) error
	// NextFieldValueBytes behaves as if NextEntry, StartValue, EncodeBytes,
	// FinishValue were called in sequence.  Some encoders optimize this codepath.
	NextFieldValueBytes(index int, tt *Type, value []byte) error
}

type Equaler interface {
	VDLEqual(v interface{}) bool
}

type Field struct {
	Name string
	Type *Type
}

type IsZeroer interface {
	VDLIsZero() bool
}

type Kind int

type NativeConverter interface {
	ToNative(wire, native interface{}) error
	FromNative(wire, native interface{}) error
}

type NativeIsZero interface {
	IsZero() bool
}

type PendingArray interface {
	PendingType
	// AssignLen assigns the Array length.
	AssignLen(len int) PendingArray
	// AssignElem assigns the Array element type.
	AssignElem(elem TypeOrPending) PendingArray
}

type PendingEnum interface {
	PendingType
	// AppendLabel appends an Enum label.  Every Enum must have at least one
	// label, and each label must not be empty.
	AppendLabel(label string) PendingEnum
}

type PendingList interface {
	PendingType
	// AssignElem assigns the List element type.
	AssignElem(elem TypeOrPending) PendingList
}

type PendingMap interface {
	PendingType
	// AssignKey assigns the Map key type.
	AssignKey(key TypeOrPending) PendingMap
	// AssignElem assigns the Map element type.
	AssignElem(elem TypeOrPending) PendingMap
}

type PendingNamed interface {
	PendingType
	// AssignBase assigns the base type of the named type.  The resulting built
	// type will have the same underlying structure as base, but with the given
	// name.
	AssignBase(base TypeOrPending) PendingNamed
}

type PendingOptional interface {
	PendingType
	// AssignElem assigns the Optional elem type.
	AssignElem(elem TypeOrPending) PendingOptional
}

type PendingSet interface {
	PendingType
	// AssignKey assigns the Set key type.
	AssignKey(key TypeOrPending) PendingSet
}

type PendingStruct interface {
	PendingType
	// AppendField appends the Struct field with the given name and t.  The name
	// must not be empty.  The ordering of fields is preserved; different
	// orderings create different types.
	AppendField(name string, t TypeOrPending) PendingStruct
	// NumField returns the number of fields appended so far.
	NumField() int
}

type PendingType interface {
	TypeOrPending
	// Built returns the final built and hash-consed type.  Build must be called
	// on the TypeBuilder before Built is called on any pending type.  If any
	// pending type has a build error, Built returns a nil type for all pending
	// types, and returns non-nil errors for at least one pending type.
	Built() (*Type, error)
}

type PendingUnion interface {
	PendingType
	// AppendField appends the Union field with the given name and t.  The name
	// must not be empty.  The ordering of fields is preserved; different
	// orderings create different types.
	AppendField(name string, t TypeOrPending) PendingUnion
	// NumField returns the number of fields appended so far.
	NumField() int
}

type ReadWriter interface {
	Reader
	Writer
}

type Reader interface {
	VDLRead(dec Decoder) error
}

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

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

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

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

type WalkMode int

type WireError struct {
	Id        string        // Error Id, used to uniquely identify each error.
	RetryCode WireRetryCode // Retry behavior suggested for the receiver.
	Msg       string        // Error message, may be empty.
	ParamList []*Value      // Variadic parameters contained in the error.
}

type WireRetryCode int

type Writer interface {
	VDLWrite(enc Encoder) error
}