px

type Annotatable interface {
	Annotations(c Context) OrderedMap
}

type AnnotatedMember interface {
	Annotatable
	Equality
	CallableMember

	Name() string

	Label() string

	FeatureType() string

	Container() ObjectType

	Type() Type

	Override() bool

	Final() bool

	InitHash() OrderedMap

	Accept(v Visitor, g Guard)

	CallableType() Type
}

type AnnotatedType interface {
	// Type returns the reflect.Type
	Type() reflect.Type

	// Annotations returns a map of annotations where each key is an Annotation type and the
	// associated value is an instance of Init[<AnnotationType>].
	Annotations() OrderedMap

	// Tags returns a map, keyed by field names, containing values that are the
	// 'puppet' tag parsed into an OrderedMap. The map is merged with possible
	// overrides given when the AnnotatedType instance was created
	Tags() map[string]OrderedMap

	// Tags returns a map, keyed by field names, containing a map of all tags besides
	// the 'puppet' tag
	OtherTags() map[string]map[string]string
}

type Annotation interface {
	Validate(Context, Annotatable)
}

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

type Arrayable interface {
	AsArray() List
}

type Attribute interface {
	AnnotatedMember
	Kind() AttributeKind

	// Get returns this attributes value in the given instance
	Get(instance Value) Value

	// HasValue returns true if a value has been defined for this attribute.
	HasValue() bool

	// Default returns true if the given value equals the default value for this attribute
	Default(value Value) bool

	// Value returns the value of this attribute, or raises an error if no value has been defined.
	Value() Value

	// GoName Returns the name of the struct field that this attribute maps to when applicable or
	// an empty string.
	GoName() string

	// Tags returns the TagAnnotation for this attribute or nil if the attribute has no tags.
	Tags(Context) TagsAnnotation
}

type AttributeKind string

type AttributesInfo interface {
	NameToPos() map[string]int

	Attributes() []Attribute

	EqualityAttributeIndex() []int

	RequiredCount() int

	PositionalFromHash(hash OrderedMap) []Value
}

type BiConsumer func(v1 Value, v2 Value)

type BiMapper func(v1 Value, v2 Value) Value

type BiPredicate func(v1 Value, v2 Value) bool

type Boolean interface {
	Value
	Bool() bool
}

type CallableGoMember interface {
	// CallGo calls a member on a struct pointer with the given arguments
	CallGo(c Context, receiver interface{}, args ...interface{}) []interface{}

	// CallGoReflected is like Call but using reflected arguments and return value. The
	// first argument is the receiver
	CallGoReflected(c Context, args []reflect.Value) []reflect.Value
}

type CallableMember interface {
	Call(c Context, receiver Value, block Lambda, args []Value) Value
}

type CallableObject interface {
	Call(c Context, method ObjFunc, args []Value, block Lambda) (result Value, ok bool)
}

type Collector interface {
	ValueConsumer

	// PopLast pops the last value from the BasicCollector and returns it
	PopLast() Value

	// Value returns the created value. Must not be called until the consumption
	// of values is complete.
	Value() Value
}

type Comparator func(a, b Value) bool

type Consumer func(value Value)

type Context interface {
	context.Context

	// Delete deletes the given key from the context variable map
	Delete(key string)

	// DefiningLoader returns a Loader that can receive new definitions
	DefiningLoader() DefiningLoader

	// DoWithLoader assigns the given loader to the receiver and calls the doer. The original loader is
	// restored before this call returns.
	DoWithLoader(loader Loader, doer Doer)

	// Error creates a Reported with the given issue code, location, and arguments
	// Typical use is to panic with the returned value
	Error(location issue.Location, issueCode issue.Code, args issue.H) issue.Reported

	// Fail creates a Reported with the EVAL_FAILURE issue code, location from stack top,
	// and the given message
	// Typical use is to panic with the returned value
	Fail(message string) issue.Reported

	// Fork a new context from this context. The fork will have the same scope,
	// loaders, and logger as this context. The stack and the map of context variables will
	// be shallow copied
	Fork() Context

	// Get returns the context variable with the given key together with a bool to indicate
	// if the key was found
	Get(key string) (interface{}, bool)

	// ImplementationRegistry returns the registry that holds mappings between Type and reflect.Type
	ImplementationRegistry() ImplementationRegistry

	// Loader returns the loader of the receiver.
	Loader() Loader

	// Logger returns the logger of the receiver. This will be the same logger as the
	// logger of the evaluator.
	Logger() Logger

	// ParseTypeValue parses and evaluates the given Value into a Type. It will panic with
	// an issue.Reported unless the parsing was successful and the result is evaluates
	// to a Type
	ParseTypeValue(str Value) Type

	// ParseType parses and evaluates the given string into a Type. It will panic with
	// an issue.Reported unless the parsing was successful and the result is evaluates
	// to a Type
	ParseType(str string) Type

	// Reflector returns a Reflector capable of converting to and from reflected values
	// and types
	Reflector() Reflector

	// Scope returns an optional variable scope. This method is intended to be used when
	// the context is used as an evaluation context. The method returns an empty OrderedMap
	// by default.
	Scope() Keyed

	// Set adds or replaces the context variable for the given key with the given value
	Set(key string, value interface{})

	// Permanently change the loader of this context
	SetLoader(loader Loader)

	// Stack returns the full stack. The returned value must not be modified.
	Stack() []issue.Location

	// StackPop pops the last pushed location from the stack
	StackPop()

	// StackPush pushes a location onto the stack. The location is typically the
	// currently evaluated expression.
	StackPush(location issue.Location)

	// StackTop returns the top of the stack
	StackTop() issue.Location
}

type ContextDoer func(c Context)

type Creatable interface {
	Constructor(c Context) Function
}

type DefiningLoader interface {
	Loader

	SetEntry(name TypedName, entry LoaderEntry) LoaderEntry
}

type DependencyLoader interface {
	Loader

	LoaderFor(key string) ModuleLoader
}

type DetailedTypeValue interface {
	Value
	DetailedType() Type
}

type Dispatch interface {
	// Name returns the name of the owner function
	Name() string

	Param(typeString string)
	Param2(puppetType Type)

	OptionalParam(typeString string)
	OptionalParam2(puppetType Type)

	RepeatedParam(typeString string)
	RepeatedParam2(puppetType Type)

	RequiredRepeatedParam(typeString string)
	RequiredRepeatedParam2(puppetType Type)

	Block(typeString string)
	Block2(puppetType Type)

	OptionalBlock(typeString string)
	OptionalBlock2(puppetType Type)

	Returns(typeString string)
	Returns2(puppetType Type)

	Function(f DispatchFunction)
	Function2(f DispatchFunctionWithBlock)
}

type DispatchCreator func(db Dispatch)

type DispatchFunction func(c Context, args []Value) Value

type DispatchFunctionWithBlock func(c Context, args []Value, block Lambda) Value

type Doer func()

type EntryMapper func(value MapEntry) MapEntry

type Equality interface {
	// Returns true if the receiver is equal to the given value, false otherwise.
	Equals(value interface{}, guard Guard) bool
}

type Float interface {
	Number
	Abs() float64
}

type Format interface {
	Value
	HasStringFlags() bool
	ApplyStringFlags(b io.Writer, str string, quoted bool)
	Width() int
	Precision() int
	FormatChar() byte
	Plus() byte
	IsAlt() bool
	IsLeft() bool
	IsZeroPad() bool
	LeftDelimiter() byte
	ContainerFormats() FormatMap
	Separator(dflt string) string
	Separator2(dflt string) string
	OrigFormat() string
	ReplaceFormatChar(c byte) Format
	WithoutWidth() Format
}

type FormatContext interface {
	Indentation() Indentation
	FormatMap() FormatMap
	Property(key string) (string, bool)
	Properties() map[string]string
	SetProperty(key, value string)
	Subsequent() FormatContext
	UnsupportedFormat(t Type, supportedFormats string, actualFormat Format) error
	WithProperties(properties map[string]string) FormatContext
}

type FormatMap OrderedMap

type Function interface {
	InvokableValue

	Dispatchers() []Lambda

	Name() string
}

type Generalizable interface {
	ParameterizedType
	Generic() Type
}

type Guard map[visit]bool

type HashKey string

type HashKeyValue interface {
	ToKey() HashKey
}

type ImplementationRegistry interface {
	// RegisterType registers the mapping between the given Type and reflect.Type
	RegisterType(t Type, r reflect.Type)

	// TypeToReflected returns the reflect.Type for the given Type
	TypeToReflected(t Type) (reflect.Type, bool)

	// ReflectedToType returns the Type name for the given reflect.Type
	ReflectedToType(t reflect.Type) (Type, bool)

	// ReflectedNameToType returns the Type for the given Go Type name
	ReflectedNameToType(name string) (Type, bool)
}

type Indentation interface {
	Breaks() bool
	Increase(indenting bool) Indentation
	IsFirst() bool
	IsIndenting() bool
	Indenting(indenting bool) Indentation
	Level() int
	Padding() string
	Subsequent() Indentation
}

type Indexed interface {
	Sized
	At(index int) Value
	ElementType() Type
	IsHashStyle() bool
}

type IndexedConsumer func(value Value, index int)

type Integer interface {
	Number
	Abs() int64
}

type InterfaceValue interface {
	Value
	Interface() interface{}
}

type InvokableValue interface {
	Value

	Call(c Context, block Lambda, args ...Value) Value
}

type IteratorValue interface {
	Value
	Arrayable
	ElementType() Type
	Next() (Value, bool)
}

type Keyed interface {
	Get(key Value) (Value, bool)
}

type Lambda interface {
	InvokableValue

	Parameters() []Parameter

	Signature() Signature
}

type List interface {
	Indexed
	Add(Value) List
	AddAll(List) List
	All(predicate Predicate) bool
	Any(predicate Predicate) bool
	AppendTo(slice []Value) []Value
	Delete(Value) List
	DeleteAll(List) List
	Each(Consumer)
	EachSlice(int, SliceConsumer)
	EachWithIndex(consumer IndexedConsumer)
	Find(predicate Predicate) (Value, bool)
	Flatten() List
	Map(mapper Mapper) List
	Select(predicate Predicate) List
	Slice(i int, j int) List
	Reduce(redactor BiMapper) Value
	Reduce2(initialValue Value, redactor BiMapper) Value
	Reject(predicate Predicate) List
	Unique() List
}

type Loader interface {
	// GetEntry returns the requested entry from the internal cache of this loader
	// without consulting parent loaders, or nil if no such entry can be found
	GetEntry(name TypedName) LoaderEntry

	// LoadEntry returns the requested entry or nil if no such entry can be found
	LoadEntry(c Context, name TypedName) LoaderEntry

	// NameAuthority returns the name authority
	NameAuthority() URI

	// Discover iterates over all entries accessible to this loader and its parents
	// and returns a slice of all entries for which the provided function returns
	// true
	Discover(c Context, predicate func(tn TypedName) bool) []TypedName

	// HasEntry returns true if this loader has an entry that maps to the give name
	// The status of the entry is determined without actually loading it.
	HasEntry(name TypedName) bool
}

type LoaderEntry interface {
	Value() interface{}

	Origin() issue.Location
}

type LocalTypes interface {
	Type(name string, decl string)
	Type2(name string, tp Type)
}

type LocalTypesCreator func(lt LocalTypes)

type LogEntry interface {
	Level() LogLevel
	Message() string
}

type LogLevel string

type Logger interface {
	Log(level LogLevel, args ...Value)

	Logf(level LogLevel, format string, args ...interface{})

	LogIssue(issue issue.Reported)
}

type MapEntry interface {
	Value
	Key() Value
	Value() Value
}

type Mapper func(value Value) Value

type ModuleLoader interface {
	Loader

	Path() string

	ModuleName() string
}

type Namespace string

type Newable interface {
	New(c Context, args []Value) Value
}

type Number interface {
	Value
	Int() int64
	Float() float64
}

type ObjFunc interface {
	AnnotatedMember

	// GoName Returns the name of the struct field that this attribute maps to when applicable or
	// an empty string.
	GoName() string

	// ReturnsError returns true if the underlying method returns an error instance in case of
	// failure. Such errors must be converted to panics by the caller
	ReturnsError() bool

	// TakesContext returns true if the first argument of the actual Go function
	// is a context.Context
	TakesContext() bool
}

type Object interface {
	Value
	Initialize(c Context, arguments []Value)
	InitFromHash(c Context, hash OrderedMap)
}

type ObjectType interface {
	Annotatable
	ParameterizedType
	TypeWithCallableMembers
	Creatable

	HasHashConstructor() bool

	Functions(includeParent bool) []ObjFunc

	// Returns the Go reflect.Type that this type was reflected from, if any.
	//
	GoType() reflect.Type

	// InstanceHash returns the InitHash for the given instance. The instance must be of this type
	InstanceHash(o Value) OrderedMap

	// IsInterface returns true for non parameterized types that contains only methods
	IsInterface() bool

	IsMetaType() bool

	IsParameterized() bool

	// Implements returns true the receiver implements all methods of ObjectType
	Implements(ObjectType, Guard) bool

	AttributesInfo() AttributesInfo

	// FromReflectedValue creates a new instance of the receiver type
	// and initializes that instance from the given src
	FromReflectedValue(c Context, src reflect.Value) PuppetObject

	// Parent returns the type that this type inherits from or nil if
	// the type doesn't have a parent
	Parent() Type

	// ToReflectedValue copies values from src to dest. The src argument
	// must be an instance of the receiver. The dest argument must be
	// a reflected struct. The src must be able to deliver a value to
	// each of the exported fields in dest.
	//
	// Puppets name convention stipulates lower case names using
	// underscores to separate words. The Go conversion is to use
	// camel cased names. ReflectValueTo will convert camel cased names
	// into names with underscores.
	ToReflectedValue(c Context, src PuppetObject, dest reflect.Value)
}

type OrderedMap interface {
	List
	Keyed
	AllPairs(BiPredicate) bool
	AnyPair(BiPredicate) bool
	AllKeysAreStrings() bool
	Entries() List
	EachKey(Consumer)
	EachPair(BiConsumer)
	EachValue(Consumer)

	Get2(key Value, dflt Value) Value
	Get3(key Value, dflt Producer) Value
	Get4(key string) (Value, bool)
	Get5(key string, dflt Value) Value
	Get6(key string, dflt Producer) Value

	// GetEntry returns the entry that represents the mapping between
	// the given key and its value
	GetEntry(key string) (entry MapEntry, found bool)

	// GetEntryFold retuns the first entry that has a key which, in string form
	// equals the given key using case insensitive comparison
	GetEntryFold(key string) (entry MapEntry, found bool)

	IncludesKey(o Value) bool

	IncludesKey2(o string) bool

	Keys() List

	// MapEntries returns a new OrderedMap with both keys and values
	// converted using the given mapper function
	MapEntries(mapper EntryMapper) OrderedMap

	// MapValues returns a new OrderedMap with the exact same keys as
	// before but where each value has been converted using the given
	// mapper function
	MapValues(mapper Mapper) OrderedMap

	Merge(OrderedMap) OrderedMap

	// ToStringMap returns a copy of this map in the form of a Go map where all keys have been
	// converted into strings
	ToStringMap() map[string]Value

	Values() List
	SelectPairs(BiPredicate) OrderedMap
	RejectPairs(BiPredicate) OrderedMap
}

type Parameter interface {
	Value

	Name() string

	Type() Type

	HasValue() bool

	Value() Value

	CapturesRest() bool
}

type ParameterizedType interface {
	Type

	Default() Type

	// Parameters returns the parameters that is needed in order to recreate
	// an instance of the parameterized type.
	Parameters() []Value
}

type ParentedLoader interface {
	Loader

	// Parent returns the parent loader
	Parent() Loader
}

type PathType string

type Predicate func(value Value) bool

type Producer func() Value

type PuppetObject interface {
	Value
	ReadableObject

	InitHash() OrderedMap
}

type RDetect map[interface{}]bool

type ReadableObject interface {
	Get(key string) (value Value, ok bool)
}

type Reflected interface {
	Reflect(c Context) reflect.Value

	ReflectTo(c Context, value reflect.Value)
}

type ReflectedType interface {
	Type

	// ReflectType returns the reflect.Type that corresponds to the receiver
	// if possible
	ReflectType(c Context) (reflect.Type, bool)
}

type Reflector interface {
	// FieldName returns the puppet name for the given field. The puppet name is
	// either picked from the 'puppet' tag of the field or the result of
	// munging the field name through utils.FirstToLower
	FieldName(f *reflect.StructField) string

	// FunctionDeclFromReflect creates a function declaration suitable for inclusion in an ObjectType initialization
	// hash.
	FunctionDeclFromReflect(name string, mt reflect.Type, fromInterface bool) OrderedMap

	// Reflect returns the reflected value of the native value held
	// by the given src
	Reflect(src Value) reflect.Value

	// Reflect2 returns the reflected value of given type from the native value held
	// by the given src
	Reflect2(src Value, rt reflect.Type) reflect.Value

	// ReflectFieldTags reflects the name, type, and value from a reflect.StructField
	// using the field tags and the optionally given puppetTag
	ReflectFieldTags(f *reflect.StructField, puppetTag OrderedMap, otherTags map[string]string) (name string, decl OrderedMap)

	// ReflectTo assigns the native value of src to dest
	ReflectTo(src Value, dest reflect.Value)

	// ReflectType returns the reflected type of the given Type if possible. Only
	// PTypes that represent a value can be represented as a reflected type. Types
	// like Any, Default, Unit, or Variant have no reflected type representation
	ReflectType(src Type) (reflect.Type, bool)

	// InitializerFromTagged creates an Object initializer hash based on the given reflected type.
	InitializerFromTagged(typeName string, parent Type, rType AnnotatedType) OrderedMap

	// TypeFromReflect creates an ObjectType based on the given reflected type.
	// The new type is automatically added to the ImplementationRegistry registered to
	// the Context from where the Reflector was obtained.
	TypeFromReflect(typeName string, parent Type, rType reflect.Type) ObjectType

	// TypeFromTagged creates an Object type based on the given reflected type.
	// The new type is automatically added to the ImplementationRegistry registered to
	// the Context from where the Reflector was obtained.
	TypeFromTagged(typeName string, parent Type, rType AnnotatedType, rcFunc Doer) ObjectType

	// TypeSetFromReflect creates a TypeSet based on the given reflected types The new types are automatically
	// added to the ImplementationRegistry registered to the Context from where the Reflector was obtained.
	// The aliases map maps the names of the reflected types to the unqualified name of the created types.
	// The aliases map may be nil and if present, may map only a subset of the reflected type names
	TypeSetFromReflect(typeSetName string, version semver.Version, aliases map[string]string, rTypes ...reflect.Type) TypeSet

	// TagHash returns the parsed and evaluated hash from the 'puppet' tag
	TagHash(f *reflect.StructField) (OrderedMap, bool)

	// Fields returns all fields of the given reflected type or an empty slice if no fields exists.
	Fields(t reflect.Type) []reflect.StructField

	// Methods returns all methods of the given reflected type or an empty slice if no methods exists.
	Methods(ptr reflect.Type) []reflect.Method
}

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

type ResolvableFunction interface {
	Name() string
	Resolve(c Context) Function
}

type ResolvableType interface {
	Name() string

	Resolve(c Context) Type
}

type SerializeAsString interface {
	// CanSerializeAsString responds true if this instance and all its nested
	// instances can serialize as string
	CanSerializeAsString() bool

	// SerializationString returns the string that the type of the instance can use
	// to recreate the instance
	SerializationString() string
}

type Signature interface {
	Type

	CallableWith(args []Value, block Lambda) bool

	ParametersType() Type

	ReturnType() Type

	// BlockType returns a Callable, Optional[Callable], or nil to denote if a
	// block is required, optional, or invalid
	BlockType() Type

	// BlockName will typically return the string "block"
	BlockName() string

	// ParameterNames returns the names of the parameters. Will return the strings "1", "2", etc.
	// for unnamed parameters.
	ParameterNames() []string
}

type Sized interface {
	Value
	Len() int
	IsEmpty() bool
}

type SizedType interface {
	Type

	Size() Type
}

type SliceConsumer func(value List)

type SortableList interface {
	List
	Sort(comparator Comparator) List
}

type StreamHashKeyValue interface {
	ToKey(b *bytes.Buffer)
}

type StringType interface {
	SizedType

	Value() *string
}

type StringValue interface {
	List
	Split(pattern *regexp.Regexp) List
	ToLower() StringValue
	ToUpper() StringValue
	EqualsIgnoreCase(Value) bool
}

type TagsAnnotation interface {
	PuppetObject

	Tag(key string) string

	Tags() OrderedMap
}

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

type Type interface {
	Value

	IsInstance(o Value, g Guard) bool

	IsAssignable(t Type, g Guard) bool

	MetaType() ObjectType

	Name() string

	Accept(visitor Visitor, g Guard)
}

type TypeMapper func(value Type) Value

type TypeSet interface {
	ParameterizedType

	// GetType returns the given type from the receiver together with
	// a flag indicating success or failure
	GetType(typedName TypedName) (Type, bool)

	// GetType2 is like GetType but uses a string to identify the type
	GetType2(name string) (Type, bool)

	// Authority returns the name authority of the receiver
	NameAuthority() URI

	// TypedName returns the name of this type set as a TypedName
	TypedName() TypedName

	// Types returns a hash of all types contained in this set. The keys
	// in this hash are relative to the receiver name
	Types() OrderedMap

	// Version returns the version of the receiver
	Version() semver.Version
}

type TypeSetLoader interface {
	Loader

	TypeSet() Type
}

type TypeWithCallableMembers interface {
	// Member returns an attribute reader or other function and true, or nil and false if no such member exists
	Member(name string) (CallableMember, bool)
}

type TypeWithContainedType interface {
	Type

	ContainedType() Type
}

type TypedName interface {
	PuppetObject
	issue.Named

	IsParent(n TypedName) bool

	IsQualified() bool

	MapKey() string

	Authority() URI

	Namespace() Namespace

	Parts() []string

	// PartsList returns the parts as a List
	PartsList() List

	// Child returns the typed name with its leading segment stripped off, e.g.
	// A::B::C returns B::C
	Child() TypedName

	// Parent returns the typed name with its final segment stripped off, e.g.
	// A::B::C returns A::B
	Parent() TypedName

	RelativeTo(parent TypedName) (TypedName, bool)
}

type URI string

type Value interface {
	fmt.Stringer
	Equality
	ToString(bld io.Writer, format FormatContext, g RDetect)
	PType() Type
}

type ValueConsumer interface {
	// CanDoBinary returns true if the value can handle binary efficiently. This tells
	// the Serializer to pass BinaryValue verbatim to Add
	CanDoBinary() bool

	// CanComplexKeys() returns true if complex values can be used as keys. If this
	// method returns false, all keys must be strings
	CanDoComplexKeys() bool

	// StringDedupThreshold returns the preferred threshold for dedup of strings. Strings
	// shorter than this threshold will not be subjected to de-duplication.
	StringDedupThreshold() int

	// AddArray starts a new array, calls the doer function, and then ends the Array.
	//
	// The callers reference index is increased by one.
	AddArray(len int, doer Doer)

	// AddHash starts a new hash., calls the doer function, and then ends the Hash.
	//
	// The callers reference index is increased by one.
	AddHash(len int, doer Doer)

	// Add adds the next value.
	//
	// Calls following a StartArray will add elements to the Array
	//
	// Calls following a StartHash will first add a key, then a value. This
	// repeats until End or StartArray is called.
	//
	// The callers reference index is increased by one.
	Add(element Value)

	// Add a reference to a previously added afterElement, hash, or array.
	AddRef(ref int)
}

type VariableState int

type VariableStates interface {
	// State returns NotFound, Global, or Local for the given name.
	State(name string) VariableState
}

type Visitor func(t Type)