schema

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

type Address []AddrStep

type AnyExpression struct {
	// OfType defines the type which the outermost expression is constrained to
	OfType cty.Type

	// SkipLiteralComplexTypes avoids descending into complex literal types, such as {} and [].
	// It might be required when AnyExpression is used in OneOf to avoid duplicates.
	SkipLiteralComplexTypes bool
}

type AttrNameStep struct{}

type AttrValueStep struct {
	Name       string
	IsOptional bool
}

type AttributeAddrSchema struct {
	// Steps describes address steps used to describe the attribute as whole.
	// The last step would typically be AttrNameStep{}.
	Steps Address

	// FriendlyName is (optional) human-readable name of the *outermost*
	// expression interpreted as reference target.
	//
	// The name is used in completion item and in hover data.
	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
}

type AttributeDependent struct {
	Name string          `json:"name"`
	Expr ExpressionValue `json:"expr"`
}

type AttributeSchema struct {
	Description  lang.MarkupContent
	IsRequired   bool
	IsOptional   bool
	IsDeprecated bool
	IsComputed   bool
	IsSensitive  bool

	// Constraint represents expression constraint e.g. what types of
	// expressions are expected for the attribute
	Constraint Constraint

	// DefaultValue represents default value which applies
	// if the attribute is not declared (e.g. when looking up
	// attribute-dependent body).
	DefaultValue Default

	// IsDepKey describes whether to use this attribute (and its value)
	// as key when looking up dependent schema
	IsDepKey bool

	// Address describes whether and how the attribute itself is targetable
	Address *AttributeAddrSchema

	// OriginForTarget describes whether the attribute is treated
	// as an origin for another target (e.g. module inputs,
	// or tfvars entires in Terraform)
	OriginForTarget *PathTarget

	// SemanticTokenModifiers represents the semantic token modifiers
	// to report for the attribute name
	// (in addition to any modifiers of any parent blocks)
	SemanticTokenModifiers lang.SemanticTokenModifiers

	// CompletionHooks represent any hooks which provide
	// additional completion candidates for the attribute.
	// These are typically candidates which cannot be provided
	// via schema and come from external APIs or other sources.
	CompletionHooks lang.CompletionHooks
}

type BlockAddrSchema struct {
	// Steps describes address steps used to describe the attribute as whole.
	// The last step would typically be LabelStep{}.
	Steps Address

	// FriendlyName is (optional) human-readable name of the block as whole
	// interpreted as reference target.
	//
	// The name is used in completion item and in hover data.
	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

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

	// BodyAsData defines whether the data in the block body
	// is addressable as cty.Object or cty.List(cty.Object),
	// cty.Set(cty.Object) etc. depending on block type
	BodyAsData bool

	// InferBody defines whether (static) Body's
	// blocks and attributes are also walked
	// and their addresses inferred as data
	InferBody bool

	// BodySelfRef instructs collection of reference
	// targets with an additional self.* LocalAddr and
	// makes those targetable by origins within the block body
	// via reference.Target.TargetableFromRangePtr.
	//
	// The targetting (matching w/ origins) is further limited by
	// BodySchema.Extensions.SelfRef, where only self.* origins
	// within a body w/ SelfRef:true will be collected.
	BodySelfRef bool

	// AsTypeOf makes the block addressable based on type
	// of an attribute
	AsTypeOf *BlockAsTypeOf

	// DependentBodyAsData defines whether the data in
	// the dependent block body is addressable as cty.Object
	// or cty.List(cty.Object), cty.Set(cty.Object) etc.
	// depending on block type
	DependentBodyAsData bool

	// InferDependentBody defines whether DependentBody's
	// blocks and attributes are also walked
	// and their addresses inferred as data
	InferDependentBody bool

	// DependentBodySelfRef instructs collection of reference
	// targets with an additional self.* LocalAddr and
	// makes those targetable by origins within the block body
	// via reference.Target.TargetableFromRangePtr.
	//
	// The targetting (matching w/ origins) is further limited by
	// BodySchema.Extensions.SelfRef, where only self.* origins
	// within a body w/ SelfRef:true will be collected.
	DependentBodySelfRef bool
}

type BlockAsTypeOf struct {
	// AttributeExpr defines whether the block
	// is addressable as a particular type declared
	// directly as expression of the attribute
	AttributeExpr string
}

type BlockSchema struct {
	Labels []*LabelSchema
	Type   BlockType

	// SemanticTokenModifiers represents the semantic token modifiers
	// to report for the block's type and labels
	// (in addition to any modifiers of any parent blocks)
	SemanticTokenModifiers lang.SemanticTokenModifiers

	// Body represents the body within block
	// such as attributes and nested blocks
	Body *BodySchema

	// DependentBody represents any "dynamic parts" of the body
	// depending on SchemaKey (labels or attributes)
	DependentBody map[SchemaKey]*BodySchema

	Description  lang.MarkupContent
	IsDeprecated bool
	MinItems     uint64
	MaxItems     uint64

	Address *BlockAddrSchema
}

type BlockType uint

type BodyExtensions struct {
	Count         bool // count attribute + count.index refs
	ForEach       bool // for_each attribute + each.* refs
	DynamicBlocks bool // dynamic "block-name" w/ content & for_each inside
	SelfRefs      bool // self.* refs
}

type BodySchema struct {
	Blocks     map[string]*BlockSchema
	Attributes map[string]*AttributeSchema

	// AnyAttribute represents an attribute where a user can pick any arbitrary
	// name, but the attributes have the same schema
	// e.g. `required_providers` block in Terraform
	AnyAttribute *AttributeSchema
	IsDeprecated bool
	Detail       string
	Description  lang.MarkupContent

	// DocsLink represents a link to docs that will be exposed
	// as part of LinksInFile()
	DocsLink *DocsLink

	// HoverURL represents a URL that will be appended to the end
	// of hover data in HoverAtPos(). This can differ from DocsLink,
	// but often will match.
	HoverURL string

	// TargetableAs represents how else the body may be targeted
	// if not by its declarable attributes or blocks.
	TargetableAs Targetables

	// Targets represent a location targeted by the body; when used as a body
	// dependent on an attribute (e.g., Terraform module source)
	Targets *Target

	// ImpliedOrigins represent a list of origins we should revisit during
	// reference origin collection. For example, module outputs can be
	// referenced from still unknown locations during the build of the module
	// schema.
	ImpliedOrigins ImpliedOrigins

	// Extensions represents any HCL extensions supported in this body
	Extensions *BodyExtensions
}

type CompletionData struct {
	NewText string

	// Snippet represents text to be inserted via text edits,
	// with snippet placeholder identifiers such as ${1} (if any) starting
	// from given nextPlaceholder (provided as arg to EmptyCompletionData).
	Snippet string

	TriggerSuggest  bool
	NextPlaceholder int
}

type Constraint interface {
	FriendlyName() string
	Copy() Constraint

	// EmptyCompletionData provides completion data in context where
	// there is no corresponding configuration, such as when the Constraint
	// is part of another and it is desirable to complete
	// the parent constraint as whole.
	EmptyCompletionData(ctx context.Context, nextPlaceholder int, nestingLevel int) CompletionData
	// contains filtered or unexported methods
}

type ConstraintWithHoverData interface {
	// EmptyHoverData provides hover data in context where there is
	// no corresponding configuration, such as when the Constraint
	// is part of another and more detailed hover data is requested
	// for the parent.
	//
	// This enables e.g. rendering attributes under Object rather
	// than just "object".
	EmptyHoverData(nestingLevel int) *HoverData
}

type Constraints struct {
	ScopeId lang.ScopeId
	Type    cty.Type
}

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

type DefaultValue struct {
	Value cty.Value
}

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

type DependencyKeys struct {
	Labels     []LabelDependent     `json:"labels,omitempty"`
	Attributes []AttributeDependent `json:"attrs,omitempty"`
}

type DocsLink struct {
	URL     string
	Tooltip string
}

type ExpressionValue struct {
	Static  cty.Value
	Address lang.Address
}

type FunctionSignature struct {
	// Description is an optional human-readable description
	// of the function.
	Description string

	Detail string

	// ReturnType is the ctyjson representation of the function's
	// return types based on supplying all parameters using
	// dynamic types. Functions can have dynamic return types.
	ReturnType cty.Type

	// Params describes the function's fixed positional parameters.
	Params []function.Parameter

	// VarParam describes the function's variadic
	// parameter if it is supported.
	VarParam *function.Parameter
}

type HoverData struct {
	Content lang.MarkupContent
}

type ImpliedOrigin struct {
	OriginAddress lang.Address

	TargetAddress lang.Address
	Path          lang.Path
	Constraints   Constraints
}

type ImpliedOrigins []ImpliedOrigin

type Keyword struct {
	// Keyword defines the literal keyword
	Keyword string

	// Name overrides friendly name of the constraint
	Name string

	// Description defines description of the keyword
	Description lang.MarkupContent
}

type LabelDependent struct {
	Index int    `json:"index"`
	Value string `json:"value"`
}

type LabelSchema struct {
	Name        string
	Description lang.MarkupContent

	// SemanticTokenModifier represents the semantic token modifier
	// (if any) to report for the label (in addition to any block modifiers)
	SemanticTokenModifiers lang.SemanticTokenModifiers

	// IsDepKey describes whether to use this label as key
	// when looking up dependent schema
	IsDepKey bool

	// In cases where label's IsDepKey=true any DependentKey label values
	// within Blocks's DependentBody can be used for completion
	// This enables such behaviour.
	Completable bool
}

type LabelStep struct {
	Index uint
}

type List struct {
	// Elem defines constraint to apply to each item
	Elem Constraint

	// Description defines description of the whole list (affects hover)
	Description lang.MarkupContent

	// MinItems defines minimum number of items (affects completion)
	MinItems uint64

	// MaxItems defines maximum number of items (affects completion)
	MaxItems uint64
}

type LiteralType struct {
	Type cty.Type

	// SkipComplexTypes avoids descending into complex literal types, such as {} and [].
	// It might be required when LiteralType is used in OneOf to avoid duplicates.
	SkipComplexTypes bool
}

type LiteralValue struct {
	Value cty.Value

	// IsDeprecated defines whether the value is deprecated
	IsDeprecated bool

	// Description defines description of the value
	Description lang.MarkupContent
}

type Map struct {
	// Elem defines constraint to apply to each item of the map
	Elem Constraint

	// Name overrides friendly name of the constraint
	Name string

	// Description defines description of the whole map (affects hover)
	Description lang.MarkupContent

	// MinItems defines minimum number of items (affects completion)
	MinItems uint64

	// MaxItems defines maximum number of items (affects completion)
	MaxItems uint64

	// AllowInterpolatedKeys determines whether the key names can be
	// interpolated (true) or static (literal strings only).
	AllowInterpolatedKeys bool
}

type Object struct {
	// Attributes defines names and constraints of attributes within the object
	Attributes ObjectAttributes

	// Name overrides friendly name of the constraint
	Name string

	// Description defines description of the whole object (affects hover)
	Description lang.MarkupContent

	// AllowInterpolatedKeys determines whether the attribute names can be
	// interpolated (true) or static (literal strings only).
	AllowInterpolatedKeys bool
}

type ObjectAttributes map[string]*AttributeSchema

type OneOf []Constraint

type PathTarget struct {
	Address     Address
	Path        lang.Path
	Constraints Constraints
}

type Reference struct {
	// OfScopeId defines scope of a type-less reference
	OfScopeId lang.ScopeId

	// OfType defines the type of a type-aware reference
	OfType cty.Type

	// Name overrides friendly name of the constraint
	Name string

	// Address (if not nil) makes the reference
	// itself addressable and provides scope
	// for the decoded reference.
	//
	// Only one of Address or OfScopeId/OfType can be declared
	Address *ReferenceAddrSchema
}

type ReferenceAddrSchema struct {
	ScopeId lang.ScopeId
}

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

type SchemaKey string

type Set struct {
	// Elem defines constraint to apply to each item
	Elem Constraint

	// Description defines description of the whole list (affects hover)
	Description lang.MarkupContent

	// MinItems defines minimum number of items (affects completion)
	MinItems uint64

	// MaxItems defines maximum number of items (affects completion)
	MaxItems uint64
}

type StaticStep struct {
	Name string
}

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

type Targetable struct {
	Address      lang.Address
	ScopeId      lang.ScopeId
	AsType       cty.Type
	IsSensitive  bool
	FriendlyName string
	Description  lang.MarkupContent

	NestedTargetables Targetables
}

type Targetables []*Targetable

type Tuple struct {
	// Elems defines constraints to apply to each individual item
	// in the same order they would appear in the tuple
	Elems []Constraint

	// Description defines description of the whole tuple (affects hover)
	Description lang.MarkupContent
}

type TypeAwareConstraint interface {
	ConstraintType() (cty.Type, bool)
}

type TypeDeclaration struct {
}

type Validatable interface {
	Validate() error
}