decoder

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

type AttributeSymbol struct {
	AttrName string
	ExprKind lang.SymbolExprKind
	// contains filtered or unexported fields
}

type BlockSymbol struct {
	Type   string
	Labels []string
	// contains filtered or unexported fields
}

type CanInferTypeExpression interface {
	InferType() (cty.Type, bool)
}

type Candidate struct {
	// Label represents a human-readable name of the candidate
	// if one exists (otherwise Value is used)
	Label string

	// Detail represents a human-readable string with additional
	// information about this candidate, like symbol information.
	Detail string

	Kind lang.CandidateKind

	// Description represents human-readable description
	// of the candidate
	Description lang.MarkupContent

	// IsDeprecated indicates whether the candidate is deprecated
	IsDeprecated bool

	// RawInsertText represents the final text which is used to build the
	// TextEdit for completion. It should contain quotes when completing
	// strings.
	RawInsertText string

	// ResolveHook represents a resolve hook to call
	// and any arguments to pass to it
	ResolveHook *lang.ResolveHook

	// SortText is an optional string that will be used when comparing this
	// candidate with other candidates
	SortText string
}

type CompletionFunc func(ctx context.Context, value cty.Value) ([]Candidate, error)

type CompletionFuncMap map[string]CompletionFunc

type CompletionResolveFunc func(ctx context.Context, unresolvedCandidate UnresolvedCandidate) (*ResolvedCandidate, error)

type CompletionResolveFuncMap map[string]CompletionResolveFunc

type ConstraintMismatch struct {
	Expr hcl.Expression
}

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

type DecoderContext struct {
	// UTM parameters for docs URLs
	// utm_source parameter, typically language server identification
	UtmSource string
	// utm_medium parameter, typically language client identification
	UtmMedium string
	// utm_content parameter, e.g. documentHover or documentLink
	UseUtmContent bool

	// CodeLenses represents a slice of executable lenses
	// which will be executed in the exact order they're declared
	CodeLenses []lang.CodeLensFunc

	// CompletionHooks represents a map of available hooks for completion.
	// One can register new hooks by adding an entry to this map. Inside the
	// attribute schema, one can refer to the hooks map key to enable the hook
	// execution on CompletionAtPos.
	CompletionHooks CompletionFuncMap

	// CompletionResolveHooks represents a map of available hooks for
	// completion candidate resolving. One can register new hooks by adding an
	// entry to this map. On completion candidate creation, one can specify a
	// resolve hook by using the map key string. If a completion candidate has
	// a resolve hook, ResolveCandidate will execute the hook and return
	// additional (resolved) data for the completion item.
	CompletionResolveHooks CompletionResolveFuncMap
}

type ExprSymbol struct {
	ExprName string
	ExprKind lang.SymbolExprKind
	// contains filtered or unexported fields
}

type Expression interface {
	CompletionAtPos(ctx context.Context, pos hcl.Pos) []lang.Candidate
	HoverAtPos(ctx context.Context, pos hcl.Pos) *lang.HoverData
	SemanticTokens(ctx context.Context) []lang.SemanticToken
}

type ExpressionCandidate struct {
	// Value represents the value to be inserted
	Value cty.Value

	// Detail represents a human-readable string with additional
	// information about this candidate, like symbol information.
	Detail string

	// Description represents human-readable description
	// of the candidate
	Description lang.MarkupContent

	// IsDeprecated indicates whether the candidate is deprecated
	IsDeprecated bool
}

type FileNotFoundError struct {
	Filename string
}

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

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

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

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

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

type NoSchemaError struct{}

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

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

type PathContext struct {
	Schema           *schema.BodySchema
	ReferenceOrigins reference.Origins
	ReferenceTargets reference.Targets
	Files            map[string]*hcl.File
	Functions        map[string]schema.FunctionSignature
	Validators       []validator.Validator
}

type PathDecoder struct {

	// PrefillRequiredFields enriches label-based completion candidates
	// with required attributes and blocks
	// TODO: Move under DecoderContext
	PrefillRequiredFields bool
	// contains filtered or unexported fields
}

type PathReader interface {
	Paths(ctx context.Context) []lang.Path
	PathContext(path lang.Path) (*PathContext, error)
}

type PosOutOfRangeError struct {
	Filename string
	Pos      hcl.Pos
	Range    hcl.Range
}

type PositionalError struct {
	Filename string
	Pos      hcl.Pos
	Msg      string
}

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

type ReferenceOrigin struct {
	Path  lang.Path
	Range hcl.Range
}

type ReferenceOrigins []ReferenceOrigin

type ReferenceOriginsExpression interface {
	ReferenceOrigins(ctx context.Context, allowSelfRefs bool) reference.Origins
}

type ReferenceTarget struct {
	OriginRange hcl.Range

	Path        lang.Path
	Range       hcl.Range
	DefRangePtr *hcl.Range
}

type ReferenceTargets []*ReferenceTarget

type ReferenceTargetsExpression interface {
	ReferenceTargets(ctx context.Context, targetCtx *TargetContext) reference.Targets
}

type ResolvedCandidate struct {
	Description         lang.MarkupContent
	Detail              string
	AdditionalTextEdits []lang.TextEdit
}

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

type Symbol interface {
	Path() lang.Path
	Name() string
	NestedSymbols() []Symbol
	Range() hcl.Range
	// contains filtered or unexported methods
}

type TargetContext struct {
	// FriendlyName is (optional) human-readable name of the expression
	// interpreted as reference target.
	FriendlyName string

	// ScopeId defines scope of a reference to allow for more granular
	// filtering in completion and accurate matching, which is especially
	// important for type-less reference targets (i.e. AsReference: true).
	ScopeId lang.ScopeId

	// AsExprType defines whether the value of the attribute
	// is addressable as a matching literal type constraint included
	// in attribute Expr.
	//
	// cty.DynamicPseudoType (also known as "any type") will create
	// reference of the real type if value is present else cty.DynamicPseudoType.
	AsExprType bool

	// AsReference defines whether the attribute
	// is addressable as a type-less reference
	AsReference bool

	// ParentAddress represents a resolved "parent" absolute address,
	// such as data.aws_instance.foo.attr_name.
	// This may be address of the attribute, or implied element/item address
	// for complex-type expressions such as object, list, map etc.
	ParentAddress lang.Address

	// ParentLocalAddress represents a resolved "parent" local address,
	// such as self.attr_name.
	// This may be address of the attribute, or implied element/item address
	// for complex-type expressions such as object, list, map etc.
	ParentLocalAddress lang.Address

	// TargetableFromRangePtr defines where the target is locally targetable
	// from via the ParentLocalAddress.
	TargetableFromRangePtr *hcl.Range

	// ParentRangePtr represents the range of the parent target being collected
	// e.g. whole object/map item
	ParentRangePtr *hcl.Range

	// ParentDefRangePtr represents the range of the parent target's definition
	// e.g. object attribute name or map key
	ParentDefRangePtr *hcl.Range
}

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

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

type UnknownFileFormatError struct {
	Filename string
}

type UnresolvedCandidate struct {
	ResolveHook *lang.ResolveHook
}