modelspec

type Assignment struct {
	Module string
	Path   string
}

type Attr struct {
	Name  string
	Value *Node
	Line  int
}

type Concept struct {
	Kind    Kind
	Name    string
	Line    int
	Attrs   []Attr
	Members []Member
}

type FS interface {
	// Open opens a file for reading. It is read only through ReadSource, which
	// refuses what is not a regular file and bounds how much is read.
	Open(name string) (fs.File, error)
	ReadDir(name string) ([]fs.DirEntry, error)
	// Stat follows symbolic links; Lstat does not.
	Stat(name string) (fs.FileInfo, error)
	Lstat(name string) (fs.FileInfo, error)
	// WriteFile replaces the file name with data, through a temporary file in the same
	// directory (created exclusively, removed on failure) and a rename, so that what is
	// at name is replaced and never followed, and a reader never sees half a file.
	WriteFile(name string, data []byte, perm fs.FileMode) error
	// Abs returns the absolute form of a path, cleaned, with symbolic links left
	// as they are: the path as the file was given or found. The SpecScore layout
	// is read from it.
	Abs(name string) (string, error)
	// SameFile reports whether two FileInfos from Stat describe one file, however
	// it was reached: by a relative or an absolute path, through a symbolic link,
	// under another spelling of the same name on a case-insensitive filesystem.
	SameFile(a, b fs.FileInfo) bool
}

type Field struct {
	Key   string
	Value *Node
	Line  int
}

type Finding struct {
	File     string   `json:"file"`
	Line     int      `json:"line,omitempty"` // 0 when the position is not known
	Rule     string   `json:"rule"`
	Severity Severity `json:"severity"`
	Message  string   `json:"message"`
	// contains filtered or unexported fields
}

type Form string

type Kind string

type LintOptions struct {
	Profile Profile
	// Modules assigns files to modules explicitly. The assigned files are linted
	// even when no path names them.
	Modules []Assignment
}

type Member struct {
	Name  string
	Line  int
	Attrs []Attr
}

type Model struct {
	File string // as given or found, used in findings
	Form Form
	// Name is the module short name used to resolve module-qualified
	// references. ParseHCL sets the file name without .modelspec.hcl; ParseJSON
	// sets module.name, or that same file-name stem when the JSON has none; Load
	// then applies the module rules (SpecScore layout, --module).
	Name string
	// Group identifies the module the file belongs to: files with the same Group
	// are one module. ParseHCL and ParseJSON set it to File (one file, one
	// module); Load groups the files of a module.
	Group string
	// Twin is set by Load on a JSON file that sits beside the HCL file of the same
	// name: it is the interchange copy of that module, not a second module, and
	// references into the module resolve to the HCL.
	Twin bool
	// TwinOf is the HCL model whose export a Twin is the copy of, when that is one
	// HCL file; Check compares the two.
	TwinOf *Model
	// Root is the parsed document of a JSON file (nil for HCL).
	Root *Node
	// Module is the identity from a JSON file; nil for HCL.
	Module *ModuleIdentity
	// ModuleLine is the line of the JSON module object (0 for HCL).
	ModuleLine int
	// Concepts are in source order.
	Concepts []*Concept
	// Unmapped lists HCL constructs the JSON form does not define.
	Unmapped []Unmapped
	// Projections and Migrations are carried through unchanged from a JSON
	// file; nil otherwise.
	Projections *Node
	Migrations  *Node
	// Broken is set when the source could not be read into a model; Check skips
	// it and does not report references into its module.
	Broken bool
	// Incomplete is set when a file of the model's module was found by a search
	// and not read (a link, a pipe, a device: rule skipped-file). Check does not
	// check an incomplete module: a partial load would report what is missing as
	// unresolved references.
	Incomplete bool
}

type ModuleIdentity struct {
	ID      string
	Name    string
	Version string
}

type Node struct {
	Type   NodeType
	Str    string  // NodeString: the value; NodeNumber: the number's text
	Bool   bool    // NodeBool
	Fields []Field // NodeObject, in order
	Items  []*Node // NodeArray
	Line   int     // 1-based source line; 0 when built in memory
	// Dups, set on the root returned by ParseNode only, lists every object key
	// that appears twice in the same object, anywhere in the document, at the
	// line of the repeat. Most JSON readers keep the last of the two, a few the
	// first, so a repeat is never harmless.
	Dups []Field
}

type NodeType int

type NotRegularError struct {
	File string
	What string // what it is: "a named pipe", "a symbolic link to a character device"
}

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

type Options struct {
	Profile Profile // "" means ProfileDefault
	// Unread names the modules that have a file which was found and not read (Lint's
	// skipped files). A module of that name that is not among the models is known and
	// cannot be checked, so a reference into it is not reported as an unknown module.
	Unread []string
}

type Profile string

type Result struct {
	Findings []Finding
	Files    int
	Models   []*Model
	// Skipped is every model-named file a search did not read, whole: the findings
	// are capped, this is not.
	Skipped []SkippedFile
	// Notes say what Lint did beyond the paths given: a module is the unit of
	// checking, so the files of a module that were not given were checked too.
	Notes []string
}

type Severity string

type SkippedFile struct {
	Finding  Finding  // the skipped-file finding for it
	Module   string   // the --module name it was found under, "" when it was not found through one
	Affected []*Model // the models of its module, which are marked Incomplete
	// contains filtered or unexported fields
}

type Source struct {
	Path string
	Abs  string
}

type TooLargeError struct {
	File    string
	Size    int64
	Partial bool
}

type Unmapped struct {
	What string // for example `entity "User" index "by_email"`
	Line int
}