actionlint

type ActionCompositeStep struct {
	// Line is the line where the step starts in action.yaml.
	Line int `json:"line"`
	// Column is the column where the step starts in action.yaml.
	Column int `json:"column"`
	// IsMapping is whether the step is a mapping node. The runner requires every step to be a
	// mapping.
	IsMapping bool `json:"is_mapping"`
	// Keys is the key names of the step mapping in file order.
	Keys []string `json:"keys"`
	// If is the "if" key value when it is a string.
	If *ActionExprString `json:"if"`
	// Run is the "run" key value when it is a string. It is nil when the key is absent or its
	// value is not a string.
	Run *ActionExprString `json:"run"`
	// WorkingDirectory is the "working-directory" key value when it is a string.
	WorkingDirectory *ActionExprString `json:"working_directory"`
	// StepName is the "name" key value when it is a string.
	StepName *ActionExprString `json:"name"`
	// With holds each "with" input value that is a string.
	With []*ActionKeyValue `json:"with"`
	// Env holds each "env" variable value that is a string.
	Env []*ActionKeyValue `json:"env"`

	// Uses is the value of "uses" key in the step. It is nil when the key is absent or its value
	// is not a string.
	Uses *string `json:"uses"`
	// contains filtered or unexported fields
}

type ActionExprString struct {
	Value  string `json:"value"`
	Line   int    `json:"line"`
	Column int    `json:"column"`
}

type ActionKeyValue struct {
	Name  string           `json:"name"`
	Value ActionExprString `json:"value"`
}

type ActionMetadata struct {

	// Name is "name" field of action.yaml.
	Name string `yaml:"name" json:"name"`
	// Description is "description" field of action.yaml.
	Description string `yaml:"description" json:"-"`
	// Inputs is "inputs" field of action.yaml.
	Inputs ActionMetadataInputs `yaml:"inputs" json:"inputs"`
	// Outputs is "outputs" field of action.yaml. Key is name of output. Description is omitted
	// since actionlint does not use it.
	Outputs ActionMetadataOutputs `yaml:"outputs" json:"outputs"`
	// SkipInputs is flag to specify behavior of inputs check. When it is true, inputs for this
	// action will not be checked.
	SkipInputs bool `yaml:"-" json:"skip_inputs"`
	// SkipOutputs is flag to specify a bit loose typing to outputs object. If it is set to
	// true, the outputs object accepts any properties along with strictly typed props.
	SkipOutputs bool `yaml:"-" json:"skip_outputs"`
	// Runs is "runs" field of action.yaml.
	Runs ActionMetadataRuns `yaml:"runs" json:"runs"`
	// Branding is "branding" field of action.yaml.
	Branding ActionMetadataBranding `yaml:"branding" json:"-"`
	// InputDefaults holds each string input default and its position in the metadata file.
	InputDefaults []*ActionKeyValue `yaml:"-" json:"-"`
	// contains filtered or unexported fields
}

type ActionMetadataBranding struct {
	Icon  string `yaml:"icon"`
	Color string `yaml:"color"`
}

type ActionMetadataInput struct {
	// Name is a name of this input.
	Name string `json:"name"`
	// Required is true when this input is mandatory to run the action.
	Required bool `json:"required"`
	// Deprecated is true when this input is marked as deprecated.
	Deprecated bool `json:"deprecated"`
	// DeprecationMessage is a deprecation message for the deprecated input.
	DeprecationMessage string `json:"deprecation-message"`
}

type ActionMetadataInputs map[string]*ActionMetadataInput

type ActionMetadataOutput struct {
	Name string `json:"name"`
}

type ActionMetadataOutputs map[string]*ActionMetadataOutput

type ActionMetadataRuns struct {
	// Plugin is the runner-internal plugin action entrypoint.
	Plugin string `yaml:"plugin" json:"plugin,omitempty"`
	// Using is `using` configuration of action.yaml. It defines what runner is used for the action.
	Using string `yaml:"using" json:"using"`
	// Main is `main` configuration of action.yaml for JavaScript action.
	Main string `yaml:"main" json:"main"`
	// Pre is `pre` configuration of action.yaml for JavaScript action.
	Pre string `yaml:"pre" json:"pre"`
	// PreIf is `pre-if` configuration of action.yaml for JavaScript action.
	PreIf string `yaml:"pre-if" json:"pre-if"`
	// Post is `post` configuration of action.yaml for JavaScript action.
	Post string `yaml:"post" json:"post"`
	// PostIf is `post-if` configuration of action.yaml for JavaScript action.
	PostIf string `yaml:"post-if" json:"post-if"`
	// Steps is `steps` configuration of action.yaml for Composite action.
	Steps actionCompositeSteps `yaml:"steps" json:"steps"`
	// Image is `image` of action.yaml for Docker action.
	Image string `yaml:"image" json:"image"`
	// PreEntrypoint is `pre-entrypoint` of action.yaml for Docker action.
	PreEntrypoint string `yaml:"pre-entrypoint" json:"pre-entrypoint"`
	// Entrypoint is `entrypoint` of action.yaml for Docker action.
	Entrypoint string `yaml:"entrypoint" json:"entrypoint"`
	// PostEntrypoint is `post-entrypoint` of action.yaml for Docker action.
	PostEntrypoint string `yaml:"post-entrypoint" json:"post-entrypoint"`
	// Args is `args` of action.yaml for Docker action.
	Args []any `yaml:"args" json:"args"`
	// Env is `env` of action.yaml for Docker action.
	Env map[string]any `yaml:"env" json:"env"`
}

type ActionRuntime struct {
	Removed        bool
	Deprecated     bool
	DeprecationURL string
	RemovalDate    string
}

type AnyType struct{}

type ArrayDerefNode struct {
	// Receiver is an expression at receiver of array element dereference.
	Receiver ExprNode
}

type ArrayType struct {
	// Elem is type of element of the array.
	Elem ExprType
	// Deref is true when this type was derived from object filtering syntax (foo.*).
	Deref bool
}

type Bool struct {
	// Value is a raw value of the bool string.
	Value bool
	// Expression is a string when expression syntax ${{ }} is used for this section.
	Expression *String
	// Pos is a position in source.
	Pos *Pos
}

type BoolNode struct {
	// Value is value of the boolean literal.
	Value bool
	// contains filtered or unexported fields
}

type BoolType struct{}

type CacheMode struct {
	Kind CacheModeKind
	Pos  *Pos
}

type CacheModeKind uint8

type ColorOptionKind int

type Command struct {
	// Stdin is a reader to read input from stdin
	Stdin io.Reader
	// Stdout is a writer to write output to stdout
	Stdout io.Writer
	// Stderr is a writer to write output to stderr
	Stderr io.Writer
}

type CompareOpNode struct {
	// Kind is a kind of this expression to show which operator is used.
	Kind CompareOpNodeKind
	// Left is an expression for left hand side of the binary operator.
	Left ExprNode
	// Right is an expression for right hand side of the binary operator.
	Right ExprNode
}

type CompareOpNodeKind int

type Concurrency struct {
	// Expression supplies a group string or complete concurrency mapping.
	Expression *String
	// Group is name of the concurrency group.
	Group *String
	// CancelInProgress is a flag that shows if canceling this workflow cancels other jobs in progress.
	CancelInProgress *Bool
	// Queue is the queue strategy for pending workflow runs. Valid values are "single" (default) and "max".
	Queue *String
	// Pos is a position in source.
	Pos *Pos
}

type Config struct {
	// SelfHostedRunner configures extra labels accepted for self-hosted runners.
	//
	// Add your labels under `labels`, for example `{labels: [linux.2xlarge]}`.
	SelfHostedRunner SelfHostedRunnerConfig `yaml:"self-hosted-runner" jsonschema:"nullable"`
	// ConfigVariables lists configuration variable names available to the checked workflows through `vars`.
	//
	// Omit this key or use `null` to disable variable-name checking. Use `[]` to allow no variables.
	// A list such as `[DEFAULT_RUNNER, ENVIRONMENT_STAGE]` reports names outside that list as undefined.
	ConfigVariables []string `yaml:"config-variables" jsonschema:"nullable"`
	// ConfigSecrets lists secret names available to the checked workflows through `secrets`.
	//
	// Omit this key or use `null` to disable secret-name checking. Use `[]` to allow only built-in
	// secrets and secrets declared in `on.workflow_call.secrets`. A list such as `[DEPLOY_TOKEN, API_KEY]`
	// also allows those names; other names are reported as undefined. Matching is case-insensitive.
	//
	// `GITHUB_TOKEN`, `ACTIONS_STEP_DEBUG`, and `ACTIONS_RUNNER_DEBUG` are always allowed.
	// List names only, never secret values.
	ConfigSecrets []string `yaml:"config-secrets" jsonschema:"nullable"`
	// Paths applies configuration to workflow files matching a glob pattern.
	//
	// Keys are paths relative to the repository root, using `/` separators and doublestar glob syntax,
	// for example `.github/workflows/**/*.yaml`. All matching entries apply. Each entry can set `ignore`.
	Paths map[string]PathConfig `yaml:"paths" jsonschema:"nullable"`
	// AssumeDefaultPermissions selects the repository's assumed default token permissions when checking
	// reusable workflow calls whose calling job and workflow both omit `permissions:`.
	//
	// `restricted` (the default) grants read access to `contents` and `packages` only.
	// `permissive` assumes read/write access, except `id-token`, which still requires an explicit grant.
	// Omit this key or use `null` to assume `restricted`.
	AssumeDefaultPermissions DefaultPermissionsAssumption `yaml:"assume-default-permissions" jsonschema:"nullable"`
	// Policy configures cache safety checks and repository conventions, such as pinned actions and job timeouts.
	//
	// Cache policies default to true; other policies are opt-in. Set individual keys to override their
	// defaults. Omit the mapping or use `{}` or `null` to keep defaults. Syntax checks always run.
	Policy Policy `yaml:"policy" jsonschema:"nullable"`
}

type Container struct {
	// Expression supplies an image string or complete container mapping.
	Expression *String
	// Image is specification of Docker image.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idcontainerimage
	Image *String
	// Credentials is credentials configuration of the Docker container.
	Credentials *Credentials
	// Env is environment variables setup in the container.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idcontainerenv
	Env *Env
	// Ports is list of port number mappings of the container.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idcontainerports
	Ports []*String
	// PortsExpression supplies the complete ports sequence.
	PortsExpression *String
	// Volumes are list of volumes to be mounted to the container.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idcontainervolumes
	Volumes []*String
	// VolumesExpression supplies the complete volumes sequence.
	VolumesExpression *String
	// Options is options string to run the container.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idcontaineroptions
	Options *String
	// Command overrides Docker image's default command for service containers.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idservicesservice_idcommand
	Command *String
	// Entrypoint overrides Docker image's default entrypoint for service containers.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idservicesservice_identrypoint
	Entrypoint *String
	// Pos is a position in source.
	Pos *Pos
}

type Credentials struct {
	// Username is username for authentication.
	Username *String
	// Password is password for authentication.
	Password *String
	// Expression is a string when expression syntax ${{ }} is used for this section.
	Expression *String
	// Pos is a position in source.
	Pos *Pos
}

type DefaultPermissionsAssumption uint8

type Defaults struct {
	// Run is configuration of how to run shell.
	Run *DefaultsRun
	// Pos is a position in source.
	Pos *Pos
}

type DefaultsRun struct {
	// Expression supplies the complete run defaults mapping.
	Expression *String
	// Shell is shell name to be run.
	Shell *String
	// WorkingDirectory is a default working directory path.
	WorkingDirectory *String
	// Pos is a position in source.
	Pos *Pos
}

type DispatchInput struct {
	// Name is a name of input value specified on dispatching workflow manually.
	Name *String
	// Description is a description of input value specified on dispatching workflow manually.
	Description *String
	// Required is a flag to show if this input is mandatory or not on dispatching workflow manually.
	Required *Bool
	// Default is a default value of input value on dispatching workflow manually.
	Default *String
	// Type is a type of the input
	// https://docs.github.com/en/actions/learn-github-actions/events-that-trigger-workflows#workflow_dispatch
	Type WorkflowDispatchEventInputType
	// Options is list of options of choice type
	Options []*String
}

type Env struct {
	// Vars is mapping from env var name to env var value.
	Vars map[string]*EnvVar
	// Expression is an expression string which contains ${{ ... }}. When this value is not empty,
	// Vars should be nil.
	Expression *String
}

type EnvVar struct {
	// Name is name of the environment variable.
	Name *String
	// Value is string value of the environment variable.
	Value *String
}

type Environment struct {
	// Expression supplies an environment name or complete environment mapping.
	Expression *String
	// Name is a name of environment which the workflow uses.
	Name *String
	// URL is the URL mapped to 'environment_url' in the deployments API. Empty value means no value was specified.
	URL *String
	// Deployment is whether GitHub should create a deployment for this job. false skips auto-deployment while still applying environment protection rules and secrets.
	Deployment *Bool
	// Pos is a position in source.
	Pos *Pos
}

type Error struct {
	// Message is an error message.
	Message string
	// Filepath is a file path where the error occurred.
	Filepath string
	// Line is a line number where the error occurred. This value is 1-based.
	Line int
	// Column is a column number where the error occurred. This value is 1-based.
	Column int
	// Kind is a string to represent kind of the error. Usually rule name which found the error.
	Kind string
	// contains filtered or unexported fields
}

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

type ErrorTemplateFields struct {
	// Message is error message body.
	Message string `json:"message"`
	// Filepath is a canonical relative file path. This is empty when input was read from stdin.
	// When encoding into JSON, this field may be omitted when the file path is empty.
	Filepath string `json:"filepath,omitempty"`
	// Line is a line number of error position.
	Line int `json:"line"`
	// Column is a column number of error position.
	Column int `json:"column"`
	// Kind is a rule name the error belongs to.
	Kind string `json:"kind"`
	// Snippet is a code snippet and indicator to indicate where the error occurred.
	// When encoding into JSON, this field may be omitted when the snippet is empty.
	Snippet string `json:"snippet,omitempty"`
	// EndColumn is a column number where the error indicator (^~~~~~~) ends. When no indicator
	// can be shown, EndColumn is equal to Column.
	EndColumn int `json:"end_column"`
}

type Event interface {
	// EventName returns name of the event to trigger this workflow.
	EventName() string
}

type Exec interface {
	// Kind returns kind of the step execution.
	Kind() ExecKind
}

type ExecAction struct {
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idstepsuses
	// Uses is nil when its value could not be parsed as a nonempty string.
	Uses *String
	// Inputs represents inputs to the action to execute in 'with' section. Keys are in lower case since they are case-insensitive.
	Inputs map[string]*Input
	// InputsExpression supplies the complete action inputs mapping.
	InputsExpression *String
	// Entrypoint represents optional 'entrypoint' field in 'with' section. Nil field means nothing specified
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idstepswithentrypoint
	Entrypoint *String
	// Args represents optional 'args' field in 'with' section. Nil field means nothing specified
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idstepswithargs
	Args *String
}

type ExecCancel struct {
	// Name is the ID of the background step to cancel, given by the 'cancel' field. The 'cancel' step
	// targets a single background step by its ID.
	Name *String
}

type ExecKind uint8

type ExecParallel struct {
	// Steps is the group of steps to run in parallel, given by the 'parallel' field.
	Steps []*Step
}

type ExecRun struct {
	// Run is script to run.
	Run *String

	// Shell represents optional 'shell' field. Nil means nothing specified.
	Shell *String
	// WorkingDirectory represents optional 'working-directory' field. Nil means nothing specified.
	WorkingDirectory *String
	// RunPos is position of 'run' section
	RunPos *Pos
	// contains filtered or unexported fields
}

type ExecWait struct {
	// Names is the list of background step IDs to wait for, given by the 'wait' field. It is nil when
	// 'wait-all' is used instead.
	Names []*String
	// All is true when the step waits for all preceding background steps via the 'wait-all' field.
	All bool
	// AllPos is the position of the 'wait-all' field. It is nil when 'wait' is used instead.
	AllPos *Pos
}

type ExprError struct {
	// Message is an error message
	Message string
	// Offset is byte offset position which caused the error
	Offset int
	// Offset is line number position which caused the error. Note that this value is 1-based.
	Line int
	// Column is column number position which caused the error. Note that this value is 1-based.
	Column int
}

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

type ExprNode interface {
	// Token returns the first token of the node. This method is useful to get position of this node.
	Token() *Token
}

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

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

type ExprType interface {
	// String returns string representation of the type.
	String() string
	// Assignable returns if other type can be assignable to the type.
	Assignable(other ExprType) bool
	// Merge merges other type into this type. When other type conflicts with this type, the merged
	// result is any type as fallback.
	Merge(other ExprType) ExprType
	// DeepCopy duplicates itself. All its child types are copied recursively.
	DeepCopy() ExprType
}

type Float struct {
	// Value is a raw value of the float string.
	Value float64
	// Expression is a string when expression syntax ${{ }} is used for this section.
	Expression *String
	// Pos is a position in source.
	Pos *Pos
}

type FloatNode struct {
	// Value is value of the float literal.
	Value float64
	// contains filtered or unexported fields
}

type FuncCallNode struct {
	// Callee is a name of called function. This is string value because currently only built-in
	// functions can be called.
	Callee string
	// Args is arguments of the function call.
	Args []ExprNode
	// contains filtered or unexported fields
}

type FuncSignature struct {
	// Name is a name of the function.
	Name string
	// Ret is a return type of the function.
	Ret ExprType
	// Params is a list of parameter types of the function. The final element of this list might
	// be repeated as variable length arguments.
	Params []ExprType
	// VariableLengthParams is a flag to handle variable length parameters. When this flag is set to
	// true, it means that the last type of params might be specified multiple times (including zero
	// times). Setting true implies length of Params is more than 0.
	VariableLengthParams bool
	// IsConstFunc is true when the function returns a constant when all parameters are constants.
	IsConstFunc bool
}

type IgnorePatterns []*regexp.Regexp

type ImageVersionEvent struct {
	// Types filters image version activity to created, ready, or deleted events.
	Types []*String
	// Names is a list of names which match to the created image names.
	Names []*String
	// Versions is a list of names which match to the created image versions. Glob patterns are available.
	Versions []*String
	// Pos is a position in source.
	Pos *Pos
}

type IndexAccessNode struct {
	// Operand is an expression at operand of index access, which should be array or object.
	Operand ExprNode
	// Index is an expression at index, which should be integer or string.
	Index ExprNode
}

type Input struct {
	// Name is a name of the input.
	Name *String
	// Value is a value of the input.
	Value *String
}

type Int struct {
	// Value is a raw value of the integer string.
	Value int
	// Expression is a string when expression syntax ${{ }} is used for this section.
	Expression *String
	// Pos is a position in source.
	Pos *Pos
}

type IntNode struct {
	// Value is value of the integer literal.
	Value int
	// contains filtered or unexported fields
}

type InvalidGlobPatternError struct {
	// Message is a human readable error message.
	Message string
	// Column is a column number of the error in the glob pattern. This value is 1-based, but zero
	// is valid value. Zero means the error occurred before reading first character. This happens
	// when a given pattern is empty. When the given pattern include a newline and line number
	// increases (invalid pattern), the column number falls back into always 0.
	Column int
}

type Job struct {
	// ID is an ID of the job, which is key of job configuration objects.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_id
	ID *String
	// Name is a name of job that user can specify freely.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idname
	Name *String
	// Needs is list of job IDs which should be run before running this job.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idneeds
	Needs []*String
	// RunsOn is runner configuration which run the job.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idruns-on
	RunsOn *Runner
	// Permissions is permission configuration for running the job.
	Permissions *Permissions
	// CacheMode overrides the workflow's cache access for this job. Nil means inherit.
	CacheMode *CacheMode
	// Environment is environment specification where the job runs.
	Environment *Environment
	// Concurrency is concurrency configuration on running the job.
	Concurrency *Concurrency
	// Outputs is map from output name to output specifications.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idoutputs
	Outputs map[string]*Output
	// Env is environment variables setup while running the job.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idenv
	Env *Env
	// Defaults is default configurations of how to run scripts.
	Defaults *Defaults
	// If is a condition whether this job should be run.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idif
	If *String
	// Steps is list of steps to be run in the job.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idsteps
	Steps []*Step
	// TimeoutMinutes is timeout value of running the job in minutes.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idtimeout-minutes
	TimeoutMinutes *Float
	// CancelTimeoutMinutes is the time allowed for cancellation cleanup in minutes.
	CancelTimeoutMinutes *Float
	// Strategy is strategy configuration of running the job.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idstrategy
	Strategy *Strategy
	// ContinueOnError is a flag to show if execution should continue on error.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idcontinue-on-error
	ContinueOnError *Bool
	// Container is container configuration to run the job.
	Container *Container
	// Services is a services configurations.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_idservices
	Services *Services
	// WorkflowCall is a workflow call by 'uses:'.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#jobsjob_iduses
	WorkflowCall *WorkflowCall
	// Snapshot is a custom image snapshot.
	// https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idsnapshot
	Snapshot *Snapshot
	// Pos is a position in source.
	Pos *Pos
}

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

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

type LinterOptions struct {
	// Verbose is flag if verbose log output is enabled.
	Verbose bool
	// Debug is flag if debug log output is enabled.
	Debug bool
	// LogWriter is io.Writer object to use to print log outputs. Note that error outputs detected
	// by the linter are not included in the log outputs.
	LogWriter io.Writer
	// Color is option for colorizing error outputs. See ColorOptionKind document for each enum values.
	Color ColorOptionKind
	// Oneline is flag if one line output is enabled. When enabling it, one error is output per one
	// line. It is useful when reading outputs from programs.
	Oneline bool
	// Shellcheck is executable for running shellcheck external command. It can be command name like
	// "shellcheck" or file path like "/path/to/shellcheck", "path/to/shellcheck". When this value
	// is empty, shellcheck won't run to check scripts in workflow file.
	Shellcheck string
	// Pyflakes is executable for running pyflakes external command. It can be command name like "pyflakes"
	// or file path like "/path/to/pyflakes", "path/to/pyflakes". When this value is empty, pyflakes
	// won't run to check scripts in workflow file.
	Pyflakes string
	// IgnorePatterns is list of regular expression to filter errors. The pattern is applied to error
	// messages. When an error is matched, the error is ignored.
	IgnorePatterns []string
	// ConfigFile is a path to config file. Empty string means no config file path is given. In
	// the case, actionlint will try to read config from .github/actionlint.yaml.
	ConfigFile string
	// Format is a custom template to format error messages. It must follow Go Template format and
	// contain at least one {{ }} placeholder. https://pkg.go.dev/text/template
	Format string
	// StdinFileName is a file name when reading input from stdin. When this value is empty, "<stdin>"
	// is used as the default value.
	StdinFileName string
	// WorkingDir is a file path to the current working directory. When this value is empty, os.Getwd
	// will be used to get a working directory.
	WorkingDir string
	// OnRulesCreated is a hook to add or remove the check rules. This function is called on checking
	// every workflow files. Rules created by Linter instance are passed to the argument and the
	// function should return the modified rules.
	// Note that syntax errors may be reported even if this function returns nil or an empty slice.
	OnRulesCreated func([]Rule) []Rule
	// OnFilesSelected is called with the exact file set passed to LintFiles. The callback receives
	// a copy so modifying it does not affect linting.
	OnFilesSelected func([]string)
	// Context bounds the lifetime of the linting. Cancelling it kills the shellcheck and pyflakes
	// child processes which are running. When this value is nil, context.Background() is used.
	Context context.Context
}

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

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

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

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

type LogLevel int

type LogicalOpNode struct {
	// Kind is a kind to show which operator is used.
	Kind LogicalOpNodeKind
	// Left is an expression for left hand side of the binary operator.
	Left ExprNode
	// Right is an expression for right hand side of the binary operator.
	Right ExprNode
}

type LogicalOpNodeKind int

type Matrix struct {
	// Values stores mappings from name to values. Keys are in lower case since they are case-insensitive.
	Rows map[string]*MatrixRow
	// Include is list of combinations of matrix values and additional values on running matrix combinations.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#example-including-additional-values-into-combinations
	Include *MatrixCombinations
	// Exclude is list of combinations of matrix values which should not be run. Combinations in
	// this list will be removed from combinations of matrix to run.
	// https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#example-excluding-configurations-from-a-matrix
	Exclude *MatrixCombinations
	// Expression is a string when expression syntax ${{ }} is used for this section.
	Expression *String
	// Pos is a position in source.
	Pos *Pos
}

type MatrixAssign struct {
	// Key is a name of the matrix value.
	Key *String
	// Value is the value selected from values in row.
	Value RawYAMLValue
}

type MatrixCombination struct {
	Assigns map[string]*MatrixAssign
	// Expression is a string when expression syntax ${{ }} is used for this section.
	Expression *String
}

type MatrixCombinations struct {
	Combinations []*MatrixCombination
	// Expression is a string when expression syntax ${{ }} is used for this section.
	Expression *String
}

type MatrixRow struct {
	// Name is a name of matrix value.
	Name *String
	// Values is variations of values which the matrix value can take.
	Values []RawYAMLValue
	// Expression is a string when expression syntax ${{ }} is used for this section.
	Expression *String
}

type NotOpNode struct {
	// Operand is an expression at operand of ! operator.
	Operand ExprNode
	// contains filtered or unexported fields
}

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

type NullType struct{}

type NumberType struct{}

type ObjectDerefNode struct {
	// Receiver is an expression at receiver of property dereference.
	Receiver ExprNode
	// Property is a name of property to access.
	Property string
}

type ObjectType struct {
	// Props is map from properties name to their type.
	Props map[string]ExprType
	// Mapped is an element type of this object. This means all props have the type. For example,
	// The element type of env context is string.
	// AnyType means its property types can be any type so it shapes a loose object. Setting nil
	// means properties are mapped to no type so it shapes a strict object.
	//
	// Invariant: All types in Props field must be assignable to this type.
	Mapped ExprType
}

type Output struct {
	// Name is name of output.
	Name *String
	// Value is value of output.
	Value *String
}

type Pass interface {
	// VisitStep is callback when visiting Step node. It returns internal error when it cannot continue the process
	VisitStep(node *Step) error
	// VisitJobPre is callback when visiting Job node before visiting its children. It returns internal error when it cannot continue the process
	VisitJobPre(node *Job) error
	// VisitJobPost is callback when visiting Job node after visiting its children. It returns internal error when it cannot continue the process
	VisitJobPost(node *Job) error
	// VisitWorkflowPre is callback when visiting Workflow node before visiting its children. It returns internal error when it cannot continue the process
	VisitWorkflowPre(node *Workflow) error
	// VisitWorkflowPost is callback when visiting Workflow node after visiting its children. It returns internal error when it cannot continue the process
	VisitWorkflowPost(node *Workflow) error
}

type PathConfig struct {
	// Ignore suppresses diagnostics whose message matches any of these Go regular expressions.
	//
	// Applies only to workflow files matching the parent path glob. For example,
	// `["shellcheck reported issue in this script: SC2086"]` ignores that ShellCheck diagnostic.
	// Omit this key, use `null`, or use `[]` to suppress nothing. Like the `-ignore` CLI option.
	Ignore IgnorePatterns `yaml:"ignore" jsonschema:"nullable"`
}

type PermissionLevel int

type PermissionScope struct {
	// Name is name of the scope.
	Name *String
	// Value is permission value of the scope.
	Value *String
}

type PermissionScopeLevels map[string]PermissionLevel

type Permissions struct {
	// All represents a permission value for all the scopes at once.
	All *String
	// Scopes is mappings from scope name to its permission configuration
	Scopes map[string]*PermissionScope
	// Pos is a position in source.
	Pos *Pos
}

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

type Policy struct {
	// CacheCallUnrestricted requires explicit cache ceilings on low-trust reusable calls.
	// Enabled by default. Set false to disable it; null or omission keeps the default.
	CacheCallUnrestricted *bool `yaml:"cache-call-unrestricted" jsonschema:"nullable,default=true"`
	// CacheOperation reports official cache action steps disabled by an explicit cache mode.
	// Enabled by default. Set false to disable it; null or omission keeps the default.
	CacheOperation *bool `yaml:"cache-operation" jsonschema:"nullable,default=true"`
	// CacheWriteUntrusted reports write-capable cache modes on low-trust triggers.
	// Enabled by default. Set false to disable it; null or omission keeps the default.
	CacheWriteUntrusted *bool `yaml:"cache-write-untrusted" jsonschema:"nullable,default=true"`
	// DisallowSuppressions restricts inline cache policy exceptions. `true` or `{}` reports
	// each prohibited directive and retains its original violations. Omission, null, or false
	// permits exceptions. Both ignore and ignore-next-line are covered equally.
	//
	// Use `{rules: [cache-call-unrestricted], report: all}` to restrict selected rule IDs.
	// Omitted rules selects all suppressible rules; an explicit list must be nonempty.
	// Report accepts suppression (directive only), violation (original findings only), or all (both kinds of diagnostic).
	DisallowSuppressions *SuppressionsPolicy `yaml:"disallow-suppressions" jsonschema:"nullable"`
	// RequireCommitHash requires `uses:` references to be pinned to a full commit SHA, or an image digest
	// for Docker images, when set to `true`.
	//
	// Set `false` to disable the check. Omit this key or use `null` to leave it unset; the check is
	// disabled by default. Local references and references built with expressions are skipped.
	RequireCommitHash *bool `yaml:"require-commit-hash" jsonschema:"nullable"`
	// RequireJobTimeout requires jobs to declare `timeout-minutes` when set to `true`.
	//
	// Use `{min-minutes: 5, max-minutes: 60}` to require a timeout between 5 and 60 minutes.
	// Either bound may be omitted. Bounds must be finite and greater than zero, and the minimum
	// must not exceed the maximum. `{}` requires the key without bounds. Reusable workflow calls are skipped.
	//
	// Set `false` to disable the check. Omit this key or use `null` to leave it unset; the check is
	// disabled by default.
	RequireJobTimeout *JobTimeoutPolicy `yaml:"require-job-timeout" jsonschema:"nullable"`
	// RequirePermissions requires an explicit `permissions:` declaration.
	//
	// `true` or `{scope: workflow}` requires a workflow-level declaration, including `permissions: {}`.
	// `{scope: job}` requires a declaration on every job, including reusable workflow calls.
	// `{}` enables workflow scope. This checks presence only; it does not infer the scopes a job needs.
	//
	// Set `false` to disable the check. Omit this key or use `null` to leave it unset; it is disabled by default.
	RequirePermissions *PermissionsPolicy `yaml:"require-permissions" jsonschema:"nullable"`
	// RequiredActions lists actions that every workflow must use in its steps.
	//
	// Write entries like `uses:` values: `actions/checkout` accepts any ref, while
	// `actions/checkout@v4*` also matches the ref. Both halves support glob patterns; `*` does not
	// match `/`. Names are matched case-insensitively and refs case-sensitively.
	//
	// Use `[]` to disable the check. Omit this key or use `null` to leave it unset; no actions
	// are required by default. Actions inside composite actions or called workflows are not counted.
	RequiredActions []string `yaml:"required-actions" jsonschema:"nullable,minLength=1"`
}

type Pos struct {
	// Line is a line number of the position. This value is 1-based.
	Line int
	// Col is a column number of the position. This value is 1-based.
	Col int
}

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

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

type RawYAMLArray struct {
	// Elems is list of elements of the array value.
	Elems []RawYAMLValue
	// contains filtered or unexported fields
}

type RawYAMLObject struct {
	// Props is map from property names to their values. Keys are in lower case since they are case-insensitive.
	Props map[string]RawYAMLValue
	// contains filtered or unexported fields
}

type RawYAMLString struct {
	// Value is string representation of the scalar node.
	Value string
	// Tag is the YAML tag of the scalar node, such as "!!str" or "!!int". A tag the parser rejects
	// is recorded as "!!str".
	Tag string
	// contains filtered or unexported fields
}

type RawYAMLValue interface {
	// Kind returns kind of raw YAML value.
	Kind() RawYAMLValueKind
	// Equals returns if the other value is equal to the value.
	Equals(other RawYAMLValue) bool
	// Pos returns the start position of the value in the source file
	Pos() *Pos
	// String returns string representation of the value
	String() string
}

type RawYAMLValueKind int

type RepositoryDispatchEvent struct {
	// Types is list of types which can trigger workflow.
	Types []*String
	// Pos is a position in source.
	Pos *Pos
}

type ReusableWorkflowCacheAccess struct {
	// Mode is nil when the job inherits the calling workflow's access limit.
	Mode *CacheMode
	// Uses is the normalized local workflow reference, or empty for other jobs.
	Uses string
	// SourceUses preserves the local reference's source spelling for diagnostics.
	SourceUses string
	// Operations lists official cache action names used by this job's steps.
	Operations []string
}

type ReusableWorkflowMetadata struct {
	Inputs  ReusableWorkflowMetadataInputs  `yaml:"inputs"`
	Outputs ReusableWorkflowMetadataOutputs `yaml:"outputs"`
	Secrets ReusableWorkflowMetadataSecrets `yaml:"secrets"`
	// JobPermissions maps a job ID of the reusable workflow to the permission scopes that job requires.
	// A job which declares no "permissions:" of its own and inherits none from the workflow has no entry,
	// and neither has a job whose declaration requires nothing.
	JobPermissions map[string]PermissionScopeLevels `yaml:"-"`
	// JobCacheAccess records effective declarations and local workflow calls by job ID.
	JobCacheAccess map[string]ReusableWorkflowCacheAccess `yaml:"-"`
}

type ReusableWorkflowMetadataInput struct {
	// Name is a name of the input defined in the reusable workflow.
	Name string
	// Required is true when 'required' field of the input is set to true and no default value is set.
	Required bool
	// Type is a type of the input. When the input type is unknown, 'any' type is set.
	Type ExprType
}

type ReusableWorkflowMetadataInputs map[string]*ReusableWorkflowMetadataInput

type ReusableWorkflowMetadataOutput struct {
	// Name is a name of the output in the reusable workflow.
	Name string
}

type ReusableWorkflowMetadataOutputs map[string]*ReusableWorkflowMetadataOutput

type ReusableWorkflowMetadataSecret struct {
	// Name is a name of the secret in the reusable workflow.
	Name string
	// Required indicates whether the secret is required by its reusable workflow. When this value
	// is true, workflow calls must set this secret unless secrets are not inherited.
	Required bool `yaml:"required"`
}

type ReusableWorkflowMetadataSecrets map[string]*ReusableWorkflowMetadataSecret

type Rule interface {
	Pass
	Errs() []*Error
	Name() string
	Description() string
	EnableDebug(out io.Writer)
	SetConfig(cfg *Config)
	Config() *Config
}

type RuleAction struct {
	RuleBase
	// contains filtered or unexported fields
}

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

type RuleCacheCallUnrestricted struct {
	RuleBase
	// contains filtered or unexported fields
}

type RuleCacheOperation struct {
	RuleBase
	// contains filtered or unexported fields
}

type RuleCacheWriteUntrusted struct {
	RuleBase
	// contains filtered or unexported fields
}

type RuleCredentials struct {
	RuleBase
}

type RuleDeprecatedCommands struct {
	RuleBase
}

type RuleEnvVar struct {
	RuleBase
}

type RuleEvents struct {
	RuleBase
}

type RuleExpression struct {
	RuleBase
	// contains filtered or unexported fields
}

type RuleGlob struct {
	RuleBase
}

type RuleID struct {
	RuleBase
	// contains filtered or unexported fields
}

type RuleIfCond struct {
	RuleBase
}

type RuleJobNeeds struct {
	RuleBase
	// contains filtered or unexported fields
}

type RuleMatrix struct {
	RuleBase
}

type RuleParallelSteps struct {
	RuleBase
	// contains filtered or unexported fields
}

type RulePermissions struct {
	RuleBase
}

type RulePyflakes struct {
	RuleBase
	// contains filtered or unexported fields
}

type RuleRequireCommitHash struct {
	RuleBase
}

type RuleRequireJobTimeout struct {
	RuleBase
	// contains filtered or unexported fields
}

type RuleRequirePermissions struct {
	RuleBase
	// contains filtered or unexported fields
}

type RuleRequiredActions struct {
	RuleBase
	// contains filtered or unexported fields
}

type RuleRunnerLabel struct {
	RuleBase
	// contains filtered or unexported fields
}

type RuleShellName struct {
	RuleBase
	// contains filtered or unexported fields
}

type RuleShellcheck struct {
	RuleBase
	// contains filtered or unexported fields
}

type RuleWorkflowCall struct {
	RuleBase
	// contains filtered or unexported fields
}

type Runner struct {
	// Expression supplies labels or a complete runner selection mapping.
	Expression *String
	// Labels is list label names to select a runner to run a job. There are preset labels and user
	// defined labels. Runner matching to the labels is selected.
	Labels []*String
	// LabelsExpr is a string when expression syntax ${{ }} is used for this section. Related issue is #164.
	LabelsExpr *String
	// Group is a group of runners specified in runs-on: section. It is nil when no group is specified.
	// https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#choosing-runners-in-a-group
	Group *String
}