app

type App struct {
	BinName string

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

	Stdout, Stderr io.Writer

	Trace string

	Funcs map[string]function.Function

	JobLocalFuncs map[string]map[string]function.Function
	// contains filtered or unexported fields
}

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 {
	SourceLocator hcl.Expression `hcl:"__source_locator,attr"`

	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 []ConfigSource `hcl:"source,block"`
}

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

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

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 Expect struct {
	// Type must be `exec` for now
	Type string `hcl:"type,label"`

	Command hcl.Expression `hcl:"command,attr"`
	Args    hcl.Expression `hcl:"args,attr"`
	Dir     hcl.Expression `hcl:"dir,attr"`
}

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 Instance struct {
	Sources map[string][]byte
	Dir     string
}

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"`
	Imports *[]string      `hcl:"imports,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"`

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

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 Option func(options *Options)

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 Options struct {
	CacheDir string
}

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
	// Cancelled is set to true when and only when the original command execution has been scheduled concurrently,
	// but was cancelled before it was actually executed.
	Cancelled bool

	// Validated is set to true when and only when the command execution was successfully validated against the mock
	Validated bool

	ExitStatus int
}

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

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

type Setup func(*Options) (*Instance, error)

type Source struct {
	ID string `hcl:"id,label"`
	// Kind is the kind of source-controller source kind like "GitRepository" and "Bucket"
	Kind string `hcl:"kind,attr"`
	// Namespace is the K8s namespace of the source-controller source
	Namepsace string `hcl:"namespace,attr"`
	// Name defaults to ID
	Name string `hcl:"name,attr"`
}

type SourceFile struct {
	Path    *string  `hcl:"path,attr"`
	Paths   []string `hcl:"paths,optional"`
	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"`

	ExpectedExecs []Expect `hcl:"expect,block"`
}

type TestDeps struct{}

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

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