config

type CatalogConfig struct {
	NoShell         *bool    `hcl:"no_shell,optional" cty:"no_shell"`
	NoHooks         *bool    `hcl:"no_hooks,optional" cty:"no_hooks"`
	DefaultTemplate string   `hcl:"default_template,optional" cty:"default_template"`
	URLs            []string `hcl:"urls,attr" cty:"urls"`
}

type ConflictingRunCmdCacheOptionsError struct{}

type CouldNotEvaluateAllLocalsError struct {
	Err error
}

type CouldNotResolveTerragruntConfigInFileError string

type CtyTerraformConfig struct {
	ExtraArgs             map[string]TerraformExtraArguments `cty:"extra_arguments"`
	Source                *string                            `cty:"source"`
	IncludeInCopy         *[]string                          `cty:"include_in_copy"`
	ExcludeFromCopy       *[]string                          `cty:"exclude_from_copy"`
	CopyTerraformLockFile *bool                              `cty:"copy_terraform_lock_file"`
	BeforeHooks           map[string]Hook                    `cty:"before_hook"`
	AfterHooks            map[string]Hook                    `cty:"after_hook"`
	ErrorHooks            map[string]ErrorHook               `cty:"error_hook"`
}

type DecodedBaseBlocks struct {
	TrackInclude *TrackInclude
	Locals       *cty.Value
	FeatureFlags *cty.Value
}

type Dependencies []Dependency

type Dependency struct {
	ConfigPath                          cty.Value  `hcl:"config_path,attr" cty:"config_path"`
	Enabled                             *bool      `hcl:"enabled,attr" cty:"enabled"`
	SkipOutputs                         *bool      `hcl:"skip_outputs,attr" cty:"skip"`
	MockOutputs                         *cty.Value `hcl:"mock_outputs,attr" cty:"mock_outputs"`
	MockOutputsAllowedTerraformCommands *[]string  `hcl:"mock_outputs_allowed_terraform_commands,attr" cty:"mock_outputs_allowed_terraform_commands"`

	// MockOutputsMergeWithState is deprecated. Use MockOutputsMergeStrategyWithState
	MockOutputsMergeWithState *bool `hcl:"mock_outputs_merge_with_state,attr" cty:"mock_outputs_merge_with_state"`

	MockOutputsMergeStrategyWithState *MergeStrategyType `hcl:"mock_outputs_merge_strategy_with_state" cty:"mock_outputs_merge_strategy_with_state"`

	// Used to store the rendered outputs for use when the config is imported or read with `read_terragrunt_config`
	RenderedOutputs *cty.Value `cty:"outputs"`

	Inputs *cty.Value `cty:"inputs"`
	Name   string     `hcl:",label" cty:"name"`
}

type DependencyConfigNotFound struct {
	Path string
}

type DependencyCycleError []string

type DependencyDirNotFoundError struct {
	Dir []string
}

type DependencyFileNotFoundError struct {
	Path string
}

type DependencyInvalidConfigPathError struct {
	DependencyName string
}

type DuplicatedGenerateBlocksError struct {
	BlockName []string
}

type EmptyStringNotAllowedError string

type EngineConfig struct {
	Version *string    `hcl:"version,attr" cty:"version"`
	Type    *string    `hcl:"type,attr" cty:"type"`
	Meta    *cty.Value `hcl:"meta,attr" cty:"meta"`
	Source  string     `hcl:"source,attr" cty:"source"`
}

type EnvVar struct {
	Name         string
	DefaultValue string
	IsRequired   bool
}

type EnvVarNotFoundError struct {
	EnvVar string
}

type ErrorHook struct {
	SuppressStdout *bool    `hcl:"suppress_stdout,attr" cty:"suppress_stdout"`
	WorkingDir     *string  `hcl:"working_dir,attr" cty:"working_dir"`
	Name           string   `hcl:"name,label" cty:"name"`
	Commands       []string `hcl:"commands,attr" cty:"commands"`
	Execute        []string `hcl:"execute,attr" cty:"execute"`
	OnErrors       []string `hcl:"on_errors,attr" cty:"on_errors"`
}

type ErrorsConfig struct {
	Retry  []*RetryBlock  `cty:"retry" hcl:"retry,block"`
	Ignore []*IgnoreBlock `cty:"ignore" hcl:"ignore,block"`
}

type ExcludeConfig struct {
	ExcludeDependencies *bool    `cty:"exclude_dependencies" hcl:"exclude_dependencies,attr" json:"exclude_dependencies"`
	NoRun               *bool    `cty:"no_run" hcl:"no_run,attr" json:"no_run"`
	Actions             []string `cty:"actions" hcl:"actions,attr" json:"actions"`
	If                  bool     `cty:"if" hcl:"if,attr" json:"if"`
}

type FeatureFlag struct {
	Default *cty.Value `cty:"default" hcl:"default,attr"`
	Name    string     `cty:"name"    hcl:",label"`
}

type FeatureFlags []*FeatureFlag

type Hook struct {
	If             *bool    `hcl:"if,attr" cty:"if"`
	RunOnError     *bool    `hcl:"run_on_error,attr" cty:"run_on_error"`
	SuppressStdout *bool    `hcl:"suppress_stdout,attr" cty:"suppress_stdout"`
	WorkingDir     *string  `hcl:"working_dir,attr" cty:"working_dir"`
	Name           string   `hcl:"name,label" cty:"name"`
	Commands       []string `hcl:"commands,attr" cty:"commands"`
	Execute        []string `hcl:"execute,attr" cty:"execute"`
}

type IgnoreBlock struct {
	Signals         map[string]cty.Value `cty:"signals" hcl:"signals,optional"`
	Label           string               `cty:"name" hcl:"name,label"`
	Message         string               `cty:"message" hcl:"message,optional"`
	IgnorableErrors []string             `cty:"ignorable_errors" hcl:"ignorable_errors"`
}

type IncludeConfig struct {
	Expose        *bool   `hcl:"expose,attr"`
	MergeStrategy *string `hcl:"merge_strategy,attr"`
	Name          string  `hcl:"name,label"`
	Path          string  `hcl:"path,attr"`
}

type IncludeConfigNotFoundError struct {
	IncludePath string
	SourcePath  string
}

type IncludeConfigs []IncludeConfig

type IncludeConfigsMap map[string]IncludeConfig

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

type IncludedConfigMissingPathError string

type InvalidArgError string

type InvalidEnvParamNameError struct {
	EnvName string
}

type InvalidGetEnvParamsError struct {
	Example         string
	ActualNumParams int
}

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

type InvalidMergeStrategyTypeError string

type InvalidParameterTypeError struct {
	Expected string
	Actual   string
}

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

type InvalidSopsFormatError struct {
	SourceFilePath string
}

type InvalidSourceURLError struct {
	ModulePath       string
	ModuleSourceURL  string
	TerragruntSource string
}

type InvalidSourceURLWithMapError struct {
	ModulePath      string
	ModuleSourceURL string
}

type MaxIterError struct{}

type MaxParseDepthError struct {
	Depth int
	Max   int
}

type MergeStrategyType string

type ModuleDependencies struct {
	Paths []string `hcl:"paths,attr" cty:"paths"`
}

type MultipleBareIncludeBlocksErr struct{}

type ParentFileNotFoundError struct {
	Path  string
	File  string
	Cause string
}

type ParsedVariable struct {
	Name                    string
	Description             string
	Type                    string
	DefaultValue            string
	DefaultValuePlaceholder string
}

type ParsingContext struct {
	TerragruntOptions *options.TerragruntOptions

	// TrackInclude represents contexts of included configurations.
	TrackInclude *TrackInclude

	// Locals are pre-evaluated variable bindings that can be used by reference in the code.
	Locals *cty.Value

	// Features are the feature flags that are enabled for the current terragrunt config.
	Features *cty.Value

	// Values of the unit.
	Values *cty.Value

	// DecodedDependencies are references of other terragrunt config. This contains the following attributes that map to
	// various fields related to that config:
	// - outputs: The map of outputs from the terraform state obtained by running `terragrunt output` on that target config.
	DecodedDependencies *cty.Value

	// These functions have the highest priority and will overwrite any others with the same name
	PredefinedFunctions map[string]function.Function

	// Set a custom converter to TerragruntConfig.
	// Used to read a "catalog" configuration where only certain blocks (`catalog`, `locals`) do not need to be converted, avoiding errors if any of the remaining blocks were not evaluated correctly.
	ConvertToTerragruntConfigFunc func(ctx context.Context, pctx *ParsingContext, configPath string, terragruntConfigFromFile *terragruntConfigFile) (cfg *TerragruntConfig, err error)

	// FilesRead tracks files that were read during parsing (absolute paths).
	// This is a pointer so that it's shared across all parsing context copies.
	FilesRead *[]string

	// PartialParseDecodeList is the list of sections that are being decoded in the current config. This can be used to
	// indicate/detect that the current parsing ctx is partial, meaning that not all configuration values are
	// expected to be available.
	PartialParseDecodeList []PartialDecodeSectionType

	// ParserOptions is used to configure hcl Parser.
	ParserOptions []hclparse.Option

	// SkipOutputsResolution is used to optionally opt-out of resolving outputs.
	SkipOutputsResolution bool

	// ParseDepth tracks the current parsing recursion depth.
	// This prevents stack overflow from deeply nested configs.
	ParseDepth int
}

type ParsingModulePathError struct {
	ModuleSourceURL string
}

type PartialDecodeSectionType int

type RetryBlock struct {
	Label            string   `cty:"name" hcl:"name,label"`
	RetryableErrors  []string `cty:"retryable_errors" hcl:"retryable_errors"`
	MaxAttempts      int      `cty:"max_attempts" hcl:"max_attempts"`
	SleepIntervalSec int      `cty:"sleep_interval_sec" hcl:"sleep_interval_sec"`
}

type Stack struct {
	NoStack      *bool      `hcl:"no_dot_terragrunt_stack,attr"`
	NoValidation *bool      `hcl:"no_validation,attr"`
	Values       *cty.Value `hcl:"values,attr"`
	Name         string     `hcl:",label"`
	Source       string     `hcl:"source,attr"`
	Path         string     `hcl:"path,attr"`
}

type StackConfig struct {
	Locals map[string]any
	Stacks []*Stack
	Units  []*Unit
}

type StackConfigFile struct {
	Locals *terragruntLocal `hcl:"locals,block"`
	Stacks []*Stack         `hcl:"stack,block"`
	Units  []*Unit          `hcl:"unit,block"`
}

type TFVarFileNotFoundError struct {
	File  string
	Cause string
}

type TerraformConfig struct {
	Source *string `hcl:"source,attr"`

	// Ideally we can avoid the pointer to list slice, but if it is not a pointer, Terraform requires the attribute to
	// be defined and we want to make this optional.
	IncludeInCopy   *[]string `hcl:"include_in_copy,attr"`
	ExcludeFromCopy *[]string `hcl:"exclude_from_copy,attr"`

	CopyTerraformLockFile *bool                     `hcl:"copy_terraform_lock_file,attr"`
	ExtraArgs             []TerraformExtraArguments `hcl:"extra_arguments,block"`
	BeforeHooks           []Hook                    `hcl:"before_hook,block"`
	AfterHooks            []Hook                    `hcl:"after_hook,block"`
	ErrorHooks            []ErrorHook               `hcl:"error_hook,block"`
}

type TerraformExtraArguments struct {
	Arguments        *[]string          `hcl:"arguments,attr" cty:"arguments"`
	RequiredVarFiles *[]string          `hcl:"required_var_files,attr" cty:"required_var_files"`
	OptionalVarFiles *[]string          `hcl:"optional_var_files,attr" cty:"optional_var_files"`
	EnvVars          *map[string]string `hcl:"env_vars,attr" cty:"env_vars"`
	Name             string             `hcl:"name,label" cty:"name"`
	Commands         []string           `hcl:"commands,attr" cty:"commands"`
}

type TerragruntConfig struct {
	Locals                      map[string]any
	ProcessedIncludes           IncludeConfigsMap
	FieldsMetadata              map[string]map[string]any
	Terraform                   *TerraformConfig
	Errors                      *ErrorsConfig
	RemoteState                 *remotestate.RemoteState
	Dependencies                *ModuleDependencies
	Exclude                     *ExcludeConfig
	PreventDestroy              *bool
	GenerateConfigs             map[string]codegen.GenerateConfig
	IamAssumeRoleDuration       *int64
	Inputs                      map[string]any
	Engine                      *EngineConfig
	Catalog                     *CatalogConfig
	IamWebIdentityToken         string
	IamAssumeRoleSessionName    string
	IamRole                     string
	DownloadDir                 string
	TerragruntVersionConstraint string
	TerraformVersionConstraint  string
	TerraformBinary             string
	TerragruntDependencies      Dependencies
	FeatureFlags                FeatureFlags
	DependentModulesPath        []*string
	IsPartial                   bool
}

type TerragruntConfigNotFoundError struct {
	Path string
}

type TerragruntDependency struct {
	Remain       hcl.Body     `hcl:",remain"`
	Dependencies Dependencies `hcl:"dependency,block"`
}

type TerragruntOutputEncodingError struct {
	Err  error
	Path string
}

type TerragruntOutputListEncodingError struct {
	Err   error
	Paths []string
}

type TerragruntOutputParsingError struct {
	Err  error
	Path string
}

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

type TooManyLevelsOfInheritanceError struct {
	ConfigPath             string
	FirstLevelIncludePath  string
	SecondLevelIncludePath string
}

type TrackInclude struct {
	// CurrentMap is the map version of CurrentList that maps the block labels to the included config.
	CurrentMap map[string]IncludeConfig
	// Original is used to track the original included config, and is used for resolving the include related
	// functions.
	Original *IncludeConfig
	// CurrentList is used to track the list of configs that should be imported and merged before the final
	// TerragruntConfig is returned. This preserves the order of the blocks as they appear in the config, so that we can
	// merge the included config in the right order.
	CurrentList IncludeConfigs
}

type Unit struct {
	NoStack      *bool      `hcl:"no_dot_terragrunt_stack,attr"`
	NoValidation *bool      `hcl:"no_validation,attr"`
	Values       *cty.Value `hcl:"values,attr"`
	Name         string     `hcl:",label"`
	Source       string     `hcl:"source,attr"`
	Path         string     `hcl:"path,attr"`
}

type ValueWithMetadata struct {
	Value    cty.Value         `json:"value" cty:"value"`
	Metadata map[string]string `json:"metadata" cty:"metadata"`
}

type WrongNumberOfParamsError struct {
	Func     string
	Expected string
	Actual   int
}