exprparser

type Config struct {
	Run        *model.Run
	WorkingDir string
	Context    string

	OverrideSuccess   func() (bool, error)
	OverrideFailure   func() (bool, error)
	OverrideCancelled func() (bool, error)
}

type DefaultStatusCheck int

type EnvReferencedError struct {
	Key    string
	String string
}

type EnvWrapper struct {
	Env map[string]string
}

type ErrorMode int

type EvaluationEnvironment struct {
	Github    *model.GithubContext
	Env       map[string]string
	Job       *model.JobContext
	Jobs      *map[string]*model.WorkflowCallResult
	Steps     map[string]*model.StepResult
	Runner    map[string]any
	Secrets   map[string]string
	Vars      map[string]string
	Strategy  map[string]any
	Matrix    map[string]any
	Needs     map[string]Needs
	Inputs    map[string]any
	HashFiles func([]reflect.Value) (any, error)
	ErrorMode ErrorMode
}

type Interpreter interface {
	Evaluate(input string, defaultStatusCheck DefaultStatusCheck) (any, error)
}

type InvalidJobOutputReferencedError struct {
	JobID      string
	OutputName string
	String     string
}

type InvalidMatrixDimensionReferencedError struct {
	Dimension string
	String    string
}

type JobOutputsWrapper struct {
	JobID string
	Needs *Needs
}

type MatrixWrapper struct {
	Matrix map[string]any
}

type Mutation interface {
	// Given a single AST node, return either `nil` to allow the original node to be used, or a new `ExprNode` to
	// replace it in the AST.
	SingleNodeMutation(exprNode actionlint.ExprNode) (actionlint.ExprNode, error)
}

type Needs struct {
	Outputs map[string]string `json:"outputs"`
	Result  string            `json:"result"`
}

type NeedsWrapper struct {
	JobID   string
	Outputs map[string]string
}

type SecretsReferencedError struct {
	Key    string
	String string
}

type SecretsWrapper struct {
	Secrets map[string]string
}

type VariableAccessMutator struct {
	// Variable to trigger the mutator upon.  If set to `needs`, for example, then `needs.hello` will trigger
	// `Rewriter`.
	Variable string
	// Rewrite routine to use.  `property` will be an AST node representing the property accessed.  Typically you would
	// not want to inspect inside the contents of the `property` as it could be any type of AST from a simple string
	// literal to a function call.
	Rewriter func(property actionlint.ExprNode) actionlint.ExprNode
}