schema

type Any struct{}

type AttributeSchema struct {
	Description lang.MarkupContent
	IsRequired  bool
	IsOptional  bool
	// Constraint represents expression constraint e.g. what types of
	// expressions are expected for the attribute
	//
	// Constraints are immutable after construction by convention. It is
	// particularly important not to mutate a constraint after it has been
	// added to an AttributeSchema.
	Constraint Constraint
	// 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 BasicBlockSchema struct {
	Description   lang.MarkupContent
	Labels        []*LabelSchema
	AllowMultiple bool
}

type BlockStack interface {
	Push(*hclsyntax.Block)
	Peek(n int) *hclsyntax.Block
	Pop()
	HasAncestorOfType(t string) bool
}

type BodySchema struct {
	Description  lang.MarkupContent
	Attributes   map[string]*AttributeSchema
	NestedBlocks map[string]*BasicBlockSchema
}

type Bool struct{}

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(nextPlaceholder int, nestingLevel int) CompletionData
	// contains filtered or unexported methods
}

type FunctionSignature struct {
	// Description is an optional human-readable description
	// of the function.
	Description string
	// Detail is additional detail that can be used in hover descriptions.
	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 LabelSchema struct {
	Name          string
	Description   lang.MarkupContent
	AllowedValues []string
}

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
}

type Lookup interface {
	// BodySchema returns the body schema at the current block position.
	BodySchema(bs BlockStack) *BodySchema
	// LabelSchema returns the label schema at the current block position.
	LabelSchema(bs BlockStack) []*LabelSchema
	// AttributeSchema returns the attribute schema at the current block and attribute position.
	AttributeSchema(bs BlockStack, attrName string) *AttributeSchema
	// Functions returns available function signatures keyed by function name.
	Functions() map[string]FunctionSignature
	// ImpliedAttributeSchema returns a computed schema implied by the attribute expression.
	// This is typically called when hovering over the name of an attribute.
	ImpliedAttributeSchema(bs BlockStack, attrName string) *AttributeSchema
}

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 Number struct{}

type Object struct {
	Name                  string             // overrides friendly name of the constraint
	Attributes            ObjectAttributes   // names and constraints of attributes within the object
	Description           lang.MarkupContent //  description of the whole object (affects hover)
	AllowInterpolatedKeys bool               // determines whether the attribute names can be interpolated
	AnyAttribute          Constraint         // determines if we allow unknown attributes of this type
	PrefillRequiredKeys   bool               // prefill any required keys for the object
}

type ObjectAttributes map[string]*AttributeSchema

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 String struct{}

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

type TypeDeclaration struct {
}

type Validatable interface {
	Validate() error
}