app

type App struct {
	BinName string

	Files     map[string]*hcl.File
	Config    *HCL2Config
	JobByName map[string]JobSpec

	Stdout, Stderr io.Writer

	Trace string
}

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

type Assert struct {
	Name string `hcl:"name,label"`

	Condition hcl.Expression `hcl:"condition,attr"`
}

type Case struct {
	Name string `hcl:"name,label"`

	Args map[string]hcl.Expression `hcl:",remain"`
}

type Collect struct {
	Condition hcl.Expression `hcl:"condition,attr"`
	Format    hcl.Expression `hcl:"format,attr"`
}

type Command struct {
	Name string
	Args []string
	Env  map[string]string
	Dir  string

	Interactive bool
}

type Config struct {
	Name string `hcl:"name,label"`

	Sources []Source `hcl:"source,block"`
}

type DependsOn struct {
	Name string `hcl:"name,label"`

	Items hcl.Expression `hcl:"items,attr"`
	Args  hcl.Expression `hcl:"args,attr"`
}

type DynamicRun struct {
	Job       string         `hcl:"job,attr"`
	Args      hcl.Expression `hcl:"with,attr"`
	Condition hcl.Expression `hcl:"condition,attr"`
}

type EnvSource struct {
	Name string `hcl:"name,label"`
}

type Event struct {
	Type string
	Time time.Time
	Run  *RunEvent
	Exec *ExecEvent
}

type EventLogger struct {
	Command    string
	Args, Opts map[string]interface{}

	Stream string

	Stderr io.Writer

	Events []Event
	// contains filtered or unexported fields
}

type Exec struct {
	Command hcl.Expression `hcl:"command,attr"`

	Args hcl.Expression `hcl:"args,attr"`
	Env  hcl.Expression `hcl:"env,attr"`
	Dir  hcl.Expression `hcl:"dir,attr"`

	Interactive *bool `hcl:"interactive,attr"`
}

type ExecEvent struct {
	Command string
	Args    []string
}

type Forward struct {
	Run *StaticRun `hcl:"run,block"`
}

type HCL2Config struct {
	Jobs    []JobSpec `hcl:"job,block"`
	Tests   []Test    `hcl:"test,block"`
	JobSpec `hcl:",remain"`
}

type Interface interface {
	Getenv(key string)
	Stat(file string)
	Open(file string)
	Chdir(dir string)
}

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

type JobSpec struct {
	//Type string `hcl:"type,label"`
	Name string `hcl:"name,label"`

	Version *string `hcl:"version,attr"`

	Module hcl.Expression `hcl:"module,attr"`

	Description *string      `hcl:"description,attr"`
	Parameters  []Parameter  `hcl:"parameter,block"`
	Options     []OptionSpec `hcl:"option,block"`
	Configs     []Config     `hcl:"config,block"`
	Secrets     []Config     `hcl:"secret,block"`
	Variables   []Variable   `hcl:"variable,block"`

	Concurrency hcl.Expression `hcl:"concurrency,attr"`

	SourceLocator hcl.Expression `hcl:"__source_locator,attr"`

	Deps   []DependsOn    `hcl:"depends_on,block"`
	Exec   *Exec          `hcl:"exec,block"`
	Assert []Assert       `hcl:"assert,block"`
	Fail   hcl.Expression `hcl:"fail,attr"`
	Import *string        `hcl:"import,attr"`

	// Private hides the job from `variant run -h` when set to true
	Private *bool `hcl:"private,attr"`

	Log *LogSpec `hcl:"log,block"`

	Steps []Step `hcl:"step,block"`

	Body hcl.Body `hcl:",remain"`
}

type LazyDynamicRun struct {
	Run []DynamicRun `hcl:"run,block"`
}

type LazyStaticRun struct {
	Run []StaticRun `hcl:"run,block"`
}

type Log struct {
	File string
}

type LogCollector struct {
	FilePath  string
	CollectFn func(Event) (*string, bool, error)
	ForwardFn func(log Log) error
	// contains filtered or unexported fields
}

type LogSpec struct {
	File     hcl.Expression `hcl:"file,attr"`
	Stream   hcl.Expression `hcl:"stream,attr"`
	Collects []Collect      `hcl:"collect,block"`
	Forwards []Forward      `hcl:"forward,block"`
}

type OptionSpec struct {
	Name string `hcl:"name,label"`

	Type        hcl.Expression `hcl:"type,attr"`
	Default     hcl.Expression `hcl:"default,attr"`
	Description *string        `hcl:"description,attr"`
	Short       *string        `hcl:"short,attr"`
}

type Parameter struct {
	Name string `hcl:"name,label"`

	Type    hcl.Expression `hcl:"type,attr"`
	Default hcl.Expression `hcl:"default,attr"`
	Envs    []EnvSource    `hcl:"env,block"`

	Description *string `hcl:"description,attr"`
}

type PendingInput struct {
	Name        string
	Description *string
	Type        cty.Type
}

type Result struct {
	Stdout     string
	Stderr     string
	Undefined  bool
	Skipped    bool
	ExitStatus int
}

type RunEvent struct {
	Job  string
	Args map[string]interface{}
}

type SetOptsFunc func(opts map[string]cty.Value, pendingOptions []PendingInput) error

type Source struct {
	Type string `hcl:"type,label"`

	Body hcl.Body `hcl:",remain"`
}

type SourceFile struct {
	Path    string  `hcl:"path,attr"`
	Default *string `hcl:"default,attr"`
	Key     *string `hcl:"key,attr"`
}

type SourceJob struct {
	Name string `hcl:"name,attr"`
	// This results in "no cty.Type for hcl.Expression" error
	//Arguments map[string]hcl2.Expression `hcl:"args,attr"`
	Args   hcl.Expression `hcl:"args,attr"`
	Format *string        `hcl:"format,attr"`
	Key    *string        `hcl:"key,attr"`
}

type StaticRun struct {
	Name string `hcl:"name,label"`

	Args map[string]hcl.Expression `hcl:",remain"`
}

type Step struct {
	Name string `hcl:"name,label"`

	Run StaticRun `hcl:"run,block"`

	Needs *[]string `hcl:"need,attr"`
}

type Test struct {
	Name string `hcl:"name,label"`

	Variables []Variable `hcl:"variable,block"`
	Cases     []Case     `hcl:"case,block"`
	Run       StaticRun  `hcl:"run,block"`
	Assert    []Assert   `hcl:"assert,block"`

	SourceLocator hcl.Expression `hcl:"__source_locator,attr"`
}

type TestDeps struct{}

type Variable struct {
	Name string `hcl:"name,label"`

	Type  hcl.Expression `hcl:"type,attr"`
	Value hcl.Expression `hcl:"value,attr"`
}