arguments

type Apply struct {
	// State, Operation, and Vars are the common extended flags
	State     *State
	Operation *Operation
	Vars      *Vars

	// AutoApprove skips the manual verification step for the apply operation.
	AutoApprove bool

	// PlanPath contains an optional path to a stored plan file
	PlanPath string

	// View represents the global view options
	View *View

	// SuppressForgetErrorsDuringDestroy suppresses the error that occurs when a
	// destroy operation completes successfully but leaves forgotten instances behind.
	SuppressForgetErrorsDuringDestroy bool

	// Verbose asks a command to print detail it would otherwise summarize.
	// See [Plan.Verbose] for what it is for and why it lives on Apply
	// directly rather than behind a shared, every-command flag: "-verbose"
	// already names an unrelated flag on "choudoufu test" and "choudoufu
	// graph" parsed ahead of a shared flag set's own turn.
	Verbose bool
}

type Argument struct {
	Name     string
	Optional bool
	Variadic bool
	// Process takes the current remaining os.Args entries and returns
	// the remainder after the given argument has been processed.
	Process func([]string) ([]string, error)
	Cli     cli.Argument
}

type Backend struct {
	// IgnoreRemoteVersion is used with commands which write state to allow users to write remote
	// state even if the remote and local OpenTofu versions don't match.
	IgnoreRemoteVersion bool
	// ForceInitCopy suppresses confirmation for copying state data during init.
	ForceInitCopy bool
	// Reconfigure forces init to ignore any stored configuration.
	Reconfigure bool
	// MigrateState confirms the user wishes to migrate from the prior backend configuration to a new configuration.
	MigrateState bool
}

type CommandLine struct {
	// Flags represents all flags available to the command line.
	Flags map[string]*Flag
	// FlagGroups defines the group headers for the Flags. These are
	// only used in a few specific commands for now and are typically
	// left empty.
	FlagGroups []FlagGroup

	// Args contains the positional arguments defined for a given command.
	// These are only allowed after all of the flag parsing is complete.
	Args []Argument
	// ArgsHelp is a field used to customize the argument error help text.
	// This is a legacy option and should not be used for any new commands.
	ArgHelp string

	// PreHooks contain the logic that should be run between os.Args
	// handling and the actual command logic.
	PreHooks Hooks
	// PostHooks contain the logic that should be run after the command
	// has completed and before os.Exit is called.
	// This is typically only used for the --json-into special case.
	PostHooks Hooks

	// This is a bit of a hack so we can correctly report diagnostics before actually executing the command
	View *View

	// These are hacks for the meta struct that should be removed as the meta struct is broken up and removed
	Backend   *Backend
	Operation *Operation
	State     *State
	Vars      *Vars
}

type Console struct {
	// View represents the global view options
	View *View
	// Vars holds and provides information for the flags related to variables that a user can give into the process
	Vars *Vars
	// State is used for the state related flags
	State *State
}

type DeprecationWarningLevel uint8

type Flag struct {
	// Name is the name of the flag.
	Name string
	// Usage is the usage text that will be formatted.  It may include
	// newlines, but it is discouraged.
	Usage string
	// GroupID is the group that this flag is nested under. This is
	// for formatting in the help/usage text.
	GroupID string
	// Display is a suffix for the Name during help text formatting. For example:
	// Display: "=value", would render as
	//   --flag-name=value
	Display string
	// Hidden determines if this flag be visible in help text.
	Hidden bool
	// Global determines if this flag is allowed to intermix with positional
	// arguments. This is a view holdover and should be considered for removal
	// at some future date.
	Global bool

	// Stdlib implementation of this flag. Will be removed once the new
	// CLI adoption is complete.
	Stdlib func(*flag.FlagSet)
	// Cli implementation of this flag (urfave/cli)
	Cli func() cli.Flag

	// IsSet is a workaround for -backend and -cloud. TODO consider
	// proper argument aliases as supported by the cli implementation.
	IsSet func() bool
}

type FlagGroup struct {
	// ID corresponds to flag's GroupID
	ID string
	// Title of the group
	Title string
	// Description present below the title
	Description string
	// Suffix text for after the group flags have
	// been rendered
	Suffix string
}

type Fmt struct {
	// Paths contains the file paths that the formatter will handle.
	// When no arguments given to the command, it will use the current directory.
	// If the first argument is -, it will read the content to format from [os.Stdin].
	Paths []string

	// List controls the output of the formatted list. If disabled, it will not print the
	// names of the formatted files.
	List bool
	// Write controls if the formatter should write the content back to the check file or not.
	Write bool
	// Diff tells to the formatter to print the diff between the before and after formatting
	// process.
	Diff bool
	// Check can be used to instruct the command to return a non-zero error code if it finds
	// any file that is not properly formatted.
	Check bool
	// Recursive indicates that the formatting should be done recursive through all the
	// subdirectories.
	Recursive bool

	// View represents the global view options
	View *View
}

type Get struct {
	// Update is the flag that can be used to upgrade the version of the modules.
	Update bool
	// TestsDirectory indicates the path where the tests are stored
	TestsDirectory string

	// Vars holds and provides information for the flags related to variables that a user can give into the process
	Vars *Vars
	// View represents the global view options
	View *View
}

type Graph struct {
	// DrawCycles highlights any cycles in the graph with colored edges.
	DrawCycles bool
	// GraphType specifies the type of graph to output (plan, plan-refresh-only, plan-destroy, or apply).
	GraphType string
	// ModuleDepth specifies the depth of modules to show in the output.
	ModuleDepth int
	// Verbose enables verbose output.
	Verbose bool
	// PlanPath specifies the path to a plan file to render the graph from.
	PlanPath string

	// View represents the global view options
	View *View

	// Vars holds and provides information for the flags related to variables that a user can give into the process
	Vars *Vars
}

type Hook func() tfdiags.Diagnostics

type Hooks []Hook

type Import struct {
	// ResourceAddress is the absolute resource address that the user is required to provide to indicate
	// on which configuration resource the state of the resource needs to be imported.
	ResourceAddress string
	// ResourceID is the platform provided ID of the resource to be imported.
	ResourceID string
	// ConfigPath is the path to the directory where the configuration containing the ResourceAddress is
	// accessible.
	ConfigPath string
	// Parallelism is the limit of concurrent operation as OpenTofu walks the graph
	Parallelism int

	// View represents the global view options
	View *View
	// State, Backend and Vars are the common extended flags
	State   *State
	Backend *Backend
	Vars    *Vars
}

type Init struct {
	// Copy the contents of the given module into the target directory before initialisation
	FlagFromModule string
	// Lockfile operation mode. Currently only "readonly" is valid.
	FlagLockfile string
	// Set the OpenTofu test directory. When set, the
	// test command will search for test files in the current directory and
	// in the one specified by the flag.
	TestsDirectory string
	// When set to false, disables modules downloading for the current configuration
	FlagGet bool
	// Install the latest module and provider versions allowed within configured constraints, overriding the
	// default behavior of selecting exactly the version recorded in the dependency lockfile.
	FlagUpgrade bool
	// Directory containing plugin binaries. This overrides all default search paths for plugins, and prevents the
	// automatic installation of plugins. This flag can be used multiple times.
	FlagPluginPath []string
	// Configuration to be merged with what is in the configuration file's 'backend' block. This can be
	// either a path to an HCL file with key/value assignments (same format as terraform.tfvars) or a
	// 'key=value' format, and can be specified multiple times. The backend type must be in the configuration itself.
	FlagConfigExtra flagspkg.RawFlags
	// Disable backend or cloud backend initialization for this configuration and use what was previously
	// initialized instead. This and the FlagCloud cannot be toggled in the same time.
	FlagBackend bool
	FlagCloud   bool

	// Bools indicating that the FlagBackend and FlagCloud have been found into the arguments list of the
	// process.
	BackendFlagSet bool
	CloudFlagSet   bool

	// View represents the global view options
	View *View

	// Vars holds and provides information for the flags related to variables that a user can give into the process
	Vars *Vars
	// Backend holds and providers information for the flags related to the backend operations, like locking
	// locking timeout, force migration, etc.
	Backend *Backend
	// State is used for the state related flags
	State *State
}

type LiveBucket struct {
	// Bucket names the bucket to report on. Empty means "the one this
	// directory's live block declares", which is how an operator checks the
	// bucket an estate actually uses; set, no configuration is read at all,
	// which is how the runnable bucket project checks the bucket it just
	// made before any estate exists.
	Bucket string

	// Region is where the bucket is. Empty defers to the record_store
	// block's own region, then to the AWS SDK's default resolution.
	Region string

	// BucketOwner is the AWS account that must own the bucket, as twelve
	// digits. Empty defers to the record_store block's own bucket_owner,
	// then to no check at all. Set, the three reads carry it as
	// ExpectedBucketOwner and a bucket of this name in another account is
	// refused rather than reported on (GitHub issue #1381).
	BucketOwner string

	// Estate scopes the lifecycle assertion to one estate's namespaces. Only
	// meaningful with Bucket; with a configuration the live block's own
	// estate is used.
	Estate string

	// JSON asks for one JSON document on stdout instead of the table.
	JSON bool
}

type LiveCheck struct {
	// Dir is the configuration directory to check. "." when none was given.
	Dir string

	// JSON asks for GitHub issue #790's declared roster instead of the prose
	// report.
	JSON bool
}

type LiveCluster struct {
	// Namespace names the records namespace to report on. Empty means "the
	// one this directory's configuration resolves to", which is how an
	// operator checks the namespace an estate actually uses.
	//
	// Set, it overrides the namespace and nothing else (GitHub issue
	// #1448). A record_store "kubernetes" block in this directory still
	// says which cluster is reached, because a report about some other
	// cluster's namespace of the same name is a report about nothing.
	// Outside a configuration directory there is no such block and the
	// ambient kubeconfig is reached, which is how a cluster admin checks a
	// namespace before any estate exists.
	Namespace string

	// Estate is the estate whose records live there. With -namespace it is
	// only reported; without one it is what the default namespace name is
	// derived from.
	Estate string

	// PlanIdentity asks the question a CI plan job's identity would ask:
	// does it have what a PLAN needs, which is get and list and not the
	// three write verbs. Without it the question is what an apply needs.
	PlanIdentity bool

	// JSON asks for one JSON document on stdout instead of the table.
	JSON bool
}

type LiveImport struct {
	// StatePath is the tfstate file to read, once, read-only. Required:
	// there is no default the way -state defaults to terraform.tfstate for
	// state-backed commands, because reading one by accident is exactly what
	// this command's whole design refuses to do.
	StatePath string

	// Estate names the estate this run would stamp. Required: unlike
	// live-plan and live-mv, there is no configuration for this command to
	// derive it from - the state file being imported may belong to a
	// configuration that has never heard of markers at all.
	Estate string

	// Approve turns the run from a read-only ratification into one that also
	// stamps: without it, the report prints and nothing is written; with it,
	// every VERIFIED or DRIFTED resource from that same report is stamped.
	Approve bool

	// Parallelism is how many resources -approve may stamp at once, spelled
	// and defaulted exactly as stock's apply spells and defaults it, because
	// it is the same budget over the same kind of work: one provider
	// plan+apply round trip per instance. It has no effect without -approve,
	// since a ratification only reads.
	//
	// GitHub issue #583. Stamping was sequential, and #566 measured it as the
	// dominant cost of migrating a terralith: 33.1s for 26 resources, 127.6s
	// for 89.
	Parallelism int
}

type LiveLs struct {
	// Estate is the tofu-estate value to list. Required: unlike live-plan,
	// there is no configuration this command must be run against at all, so
	// there is nothing to derive the name from the way live-mv falls back to
	// a live block's own estate setting.
	Estate string

	// Region narrows where the Tagging API and IAM calls go. Empty defers to
	// the AWS SDK's own default region resolution (AWS_REGION, the shared
	// config file, or an endpoint override's own region), the same as every
	// other AWS client this fork builds.
	Region string

	// Consistent asks the listing to re-read itself until two consecutive
	// reads agree, rather than returning the first read as-is. See
	// [command.pollConsistent] for why this exists at all: the Resource
	// Groups Tagging API's index lags a tag write by about a minute
	// (live-mv's own tag rewrite included), so a listing taken right after a
	// move can show a resource under both its old and new estate, or under
	// neither, and every caller of this command would otherwise reinvent the
	// same wait by hand.
	Consistent bool

	// ConfigDir is the configuration directory to cross-reference the
	// listing against, naming which declared instances the listing's own
	// mechanism structurally cannot see - the record rung and the
	// declaration-carried rung, see live/MARKERS.md's tier definitions
	// (#417) - so that a reader can tell a rung from a genuine absence.
	// Empty means no directory was given, and the listing prints with no
	// such cross-reference at all: this command's core promise (list what
	// the account holds under an estate) needs no configuration to keep.
	ConfigDir string

	// View carries -json. -json-into is deliberately NOT offered here - see
	// BindLiveLs's own comment.
	View *View
}

type LiveMv struct {
	// RawOldAddr is the address the live resource carries now, and
	// RawNewAddr is the one this run writes onto it. Both are unparsed here;
	// the command parses them as resource instance addresses, which is where
	// the diagnostic about a malformed one belongs.
	RawOldAddr string
	RawNewAddr string

	// Estate names the estate that owns the resource. Empty means the flag
	// was absent, and the name is derived from the configuration instead -
	// from a live block, or from the tofu-estate tags the configuration
	// itself stamps. Unlike live-plan, this command cannot run without one.
	Estate string

	// FromEstate, when set, makes the rename a cross-estate move: the live
	// resource is found under this estate's tag and rewritten to carry the
	// configuration's own. Empty is an ordinary rename within one estate.
	FromEstate string

	// DryRun makes every check and reports what would be rewritten, without
	// writing.
	DryRun bool

	// AllowMissingConfig permits a destination address the configuration does
	// not declare, for a rename whose configuration edit has not happened yet.
	AllowMissingConfig bool

	// JSON asks for the move as one document rather than the labelled-rows
	// report - GitHub issue #791. Everything the human report already says
	// is in it, plus what only this flag exposes: the followers that move
	// with no write of their own, a refusal's stable code alongside its
	// text, and (on a real write) whatever the provider handed back for a
	// receipt to match against. See internal/command/views/live_mv.go's
	// StatelessMvJSONReport.
	JSON bool
}

type LivePlan struct {
	// Plan is the stock plan argument set, embedded so that -target, -var,
	// -var-file, -refresh and the rest parse and behave identically. Anything
	// live-plan cannot honor is rejected by the command after parsing, rather
	// than removed from the flag set here, so that an operator who passes one
	// is told so instead of being ignored.
	*Plan

	// Estate names the estate whose ownership markers this run looks for. An
	// empty value means the flag was absent, which is not an error: the name
	// is then derived from the configuration, and a run that cannot derive it
	// degrades rather than fails. It is an error only when the configuration
	// has a live block, since the block names the estate itself; the command
	// makes that check, because it needs a loaded configuration to make it.
	Estate string
}

type Login struct {
	// Host represents the host that OpenTofu will try to login to
	Host string

	// View represents the global view options
	View *View
	// Vars and State are the common extended flags
	Vars  *Vars
	State *State
}

type Logout struct {
	// Host represents the host that OpenTofu will try to log out of
	Host string

	// View represents the global view options
	View *View
}

type MetadataFunctions struct {
	// View represents the global view options
	View *View
}

type Operation struct {
	// PlanMode selects one of the mutually-exclusive planning modes that
	// decides the overall goal of a plan operation. This field is relevant
	// only for an operation that produces a plan.
	PlanMode plans.Mode

	// Parallelism is the limit OpenTofu places on total parallel operations
	// as it walks the dependency graph.
	Parallelism int

	// Refresh controls whether or not the operation should refresh existing
	// state before proceeding. Default is true.
	Refresh bool

	// Targets allow limiting an operation to a set of resource addresses and
	// their dependencies.
	Targets []addrs.Targetable

	// Excludes allow limiting an operation to execute on all resources other
	// than a set of excluded resource addresses and resources dependent on them.
	Excludes []addrs.Targetable

	// ForceReplace addresses cause OpenTofu to force a particular set of
	// resource instances to generate "replace" actions in any plan where they
	// would normally have generated "no-op" or "update" actions.
	//
	// This is currently limited to specific instances because typical uses
	// of replace are associated with only specific remote objects that the
	// user has somehow learned to be malfunctioning, in which case it
	// would be unusual and potentially dangerous to replace everything under
	// a module all at once. We could potentially loosen this later if we
	// learn a use-case for broader matching.
	ForceReplace []addrs.AbsResourceInstance
}

type Output struct {
	// Name identifies which root module output to show.  If empty, show all
	// outputs.
	Name string

	// View represents the global view options
	View *View
	// Vars and State are the common extended flags
	Vars  *Vars
	State *State
}

type Plan struct {
	// State, Operation, and Vars are the common extended flags
	State     *State
	Operation *Operation
	Vars      *Vars

	// DetailedExitCode enables different exit codes for error, success with
	// changes, and success with no changes.
	DetailedExitCode bool

	// OutPath contains an optional path to store the plan file
	OutPath string

	// GenerateConfigPath tells OpenTofu that config should be generated for
	// unmatched import target paths and which path the generated file should
	// be written to.
	GenerateConfigPath string

	// View represents the global view options
	View *View

	// Verbose asks a command to print detail it would otherwise summarize.
	// Live resource markers is the first consumer: the "Not swept for
	// removal" section's full type-by-type breakdown, collapsed to a
	// one-line count by default (GitHub issue #78, "First plan drowns a
	// small estate in the not-swept type list"). It lives on Plan itself,
	// not added by [BindLivePlan] the way -estate is (see that
	// function's own comment), because -verbose does nothing to a stock
	// plan rather than naming a stateless-only concept, and because it also
	// needs to reach "choudoufu apply" against a live block
	// (arguments.Apply.Verbose), where -estate has no equivalent need
	// (arguments.Apply has none either).
	Verbose bool

	// AdoptionOnly asks for GitHub issue #587's adoption-only view: the plan
	// runs exactly as it would otherwise, and what it PRINTS is the adoption
	// ledger alone - what can be adopted, what cannot, and why - with the
	// resource diff and the other live-markers sections suppressed.
	//
	// It sits on Plan for -verbose's reason and not for -estate's. It has to
	// reach plain "choudoufu plan", because under a live block that is the
	// live-markers pipeline (LivePlanCommand.Execute delegates to PlanCommand),
	// and only [ParsePlan] parses that command's flags; -estate needs the
	// opposite, since a live block naming the estate is precisely when -estate
	// must be refused. Unlike -verbose it does name a stateless-only concept,
	// so a stock, state-backed plan refuses it outright rather than ignoring
	// it - see planRejectAdoptionOnly in the command package. Registering it
	// here and refusing it there is what makes "choudoufu plan
	// -adoption-only" against a state file say so, instead of "flag provided
	// but not defined".
	AdoptionOnly bool

	// Filter narrows the live-markers report to the named categories
	// (GitHub issue #1197): see [ReportFilter]. It sits on Plan for
	// -adoption-only's reason - under a live block plain "choudoufu plan" is
	// the live-markers pipeline, and only [ParsePlan] parses that command's
	// flags - and a stock, state-backed plan refuses it the same way
	// (planRejectReportFilter in the command package).
	Filter ReportFilter
}

type Providers struct {
	// TestsDirectory indicates the path where the tests are stored
	TestsDirectory string

	// Vars holds and provides information for the flags related to variables that a user can give into the process
	Vars *Vars
	// View represents the global view options
	View *View
}

type ProvidersLock struct {
	// Providers are the source addresses of the providers that are requested to be updated
	Providers []string
	// OptPlatforms contains the platforms that the user requested for the locks to be updated for.
	// Having this empty, only the checksum for the host platform will be updated, but the user
	// can use this to update the hashes for other platforms too.
	OptPlatforms []string
	// FsMirrorDir represents a path from where OpenTofu should check for providers instead to reach
	// out for the registry.
	FsMirrorDir string
	// NetMirrorURL represents a URL to a mirrored registry from where OpenTofu should check for
	// providers instead to reach out for the registry.
	NetMirrorURL string
	// OciMirrorTemplate represents a URI-style template string that evaluates to an OCI repository address
	// to use for the providers.
	OciMirrorTemplate string

	// View represents the global view options
	View *View
	// Vars holds and provides information for the flags related to variables that a user can give into the process
	Vars *Vars
}

type ProvidersMirror struct {
	// Directory is the directory where the copies of the providers will be stored
	Directory string
	// OptPlatforms contains the platforms that the user requested to have the providers
	// copy for
	OptPlatforms []string

	// View represents the global view options
	View *View
	// Vars holds and provides information for the flags related to variables that a user can give into the process
	Vars *Vars
}

type ProvidersSchema struct {
	// View represents the global view options
	View *View

	// Vars holds and provides information for the flags related to variables that a user can give into the process
	Vars *Vars
}

type Refresh struct {
	// State, Operation, and Vars are the common extended flags
	State     *State
	Operation *Operation
	Vars      *Vars

	// View represents the global view options
	View *View
}

type ReportFilter []string

type Show struct {
	// TargetType and TargetArg together describe the object that was
	// requested to be shown.
	//
	// The meaning of TargetArg varies depending on TargetType. Refer to
	// the documentation for each [ShowTargetType] constant for details.
	TargetType ShowTargetType
	TargetArg  string

	// View represents the global view options
	View *View

	Vars *Vars
}

type ShowTargetType int

type State struct {
	// Lock controls whether or not the state manager is used to lock state
	// during operations.
	Lock bool

	// LockTimeout allows setting a time limit on acquiring the state lock.
	// The default is 0, meaning no limit.
	LockTimeout time.Duration

	// StatePath specifies a non-default location for the state file. The
	// default value is blank, which is interpreted as "terraform.tfstate".
	// Represents the local path where state is read from.
	StatePath string

	// StateOutPath specifies a different path to write the final state file.
	// The default value is blank, which results in state being written back to
	// StatePath.
	StateOutPath string

	// BackupPath specifies the path where a backup copy of the state file will
	// be stored before the new state is written. The default value is blank,
	// which is interpreted as StateOutPath + ".backup" or, in some cases, the backup
	// is skipped altogether.
	BackupPath string
}

type StateList struct {
	// LookupId restricts output to paths with a resource having the specified ID.
	LookupId string
	// InstancesRawAddr is a list of raw addresses of the resources that are requested
	// to be listed.
	InstancesRawAddr []string

	// View represents the global view options
	View *View

	// Vars and State are the common extended flags
	Vars  *Vars
	State *State
}

type StateMv struct {
	// RawSrcAddr represents a resources address that is requested by the user to be moved
	RawSrcAddr string
	// RawDestAddr represents a resources address that is requested by the user to be used to move the
	// resource into
	RawDestAddr string
	// DryRun just validates that the arguments provided are valid and will output the possible outcome.
	// When running in this mode, the state will suffer no change.
	DryRun bool
	// BackupPathOut can be used by the user to configure where to save the backup file of the state file.
	BackupPathOut string

	// View represents the global view options
	View *View

	// Vars, Backend and State are the common extended flags
	Vars    *Vars
	Backend *Backend
	State   *State
}

type StatePull struct {
	// View represents the global view options
	View *View

	// Vars are the common extended flags
	Vars *Vars
}

type StatePush struct {
	// StateSrc represents the source of the state that wants to be pushed.
	// This can be a file name/file path, or it can be "-" when the state should be read from [os.Stdin].
	StateSrc string
	// Force will try to forcefully push the state remotely. This will happen only if the backend supports it.
	Force bool
	// View represents the global view options
	View *View

	// Vars, Backend and State are the common extended flags
	Vars    *Vars
	Backend *Backend
	State   *State
}

type StateReplaceProvider struct {
	// RawSrcAddr represents a provider address that is requested by the user to be moved
	RawSrcAddr string
	// RawDestAddr represents a provider address that is requested by the user to be used to move the
	// provider into
	RawDestAddr string
	// AutoApprove is an option that the user can configure to skip the confirmation step of the replacement
	// process.
	AutoApprove bool

	// View represents the global view options
	View *View

	// Vars, Backend and State are the common extended flags
	Vars    *Vars
	Backend *Backend
	State   *State
}

type StateRm struct {
	// TargetAddrs represents the raw resource addresses to be removed from the state
	TargetAddrs []string
	// DryRun just validates that the arguments provided are valid and will output the possible outcome.
	// When running in this mode, the state will suffer no change.
	DryRun bool

	// View represents the global view options
	View *View

	// Vars, Backend and State are the common extended flags
	Vars    *Vars
	Backend *Backend
	State   *State
}

type StateShow struct {
	// TargetRawAddr represents the raw resource address of the resource requested to have the state shown for.
	TargetRawAddr string

	// View represents the global view options
	View *View

	// Vars and State are the common extended flags
	Vars  *Vars
	State *State
}

type Taint struct {
	// TargetAddress is the resource address that is requested to be marked as tainted.
	TargetAddress addrs.AbsResourceInstance
	// AllowMissing can be set to "true" to write a warning instead of an error and to return exit code 0
	// when the TargetAddress points to a missing resource.
	AllowMissing bool

	// View represents the global view options
	View *View

	// Vars holds and provides information for the flags related to variables that a user can give into the process
	Vars *Vars

	// State is used for the state related flags
	State *State
	// Backend is used strictly for the ignore remote version flag
	Backend *Backend
}

type Test struct {
	// Filter contains a list of test files to execute. If empty, all test files
	// will be executed.
	Filter []string

	// TestDirectory allows the user to override the directory that the test
	// command will use to discover test files, defaults to "tests". Regardless
	// of the value here, test files within the configuration directory will
	// always be discovered.
	TestDirectory string

	// View represents the global view options
	View *View

	// You can specify common variables for all tests from the command line.
	Vars *Vars

	// Verbose tells the test command to print out the plan either in
	// human-readable format or JSON for each run step depending on the
	// ViewType.
	Verbose bool
}

type Unlock struct {
	// LockID is the ID of the lock that the user has to provide.
	LockID string
	// Force disables the confirmation prompt
	Force bool

	// Vars holds and provides information for the flags related to variables that a user can give into the process
	Vars *Vars
	// View represents the global view options
	View *View
}

type Validate struct {
	// Path is the directory containing the configuration to be validated. If
	// unspecified, validate will use the current directory.
	Path string

	// TestDirectory is the directory containing any test files that should be
	// validated alongside the main configuration. Should be relative to the
	// Path.
	TestDirectory string

	// NoTests indicates that OpenTofu should not validate any test files
	// included with the module.
	NoTests bool

	// View represents the global view options
	View *View

	Vars *Vars
}

type Vars []flags.RawFlag

type Version struct {
	// View represents the global view options
	View *View
}

type View struct {
	// NoColor is used to disable the use of terminal color codes in all
	// output.
	NoColor bool

	// CompactWarnings is used to coalesce duplicate warnings, to reduce the
	// level of noise when multiple instances of the same warning are raised
	// for a configuration.
	CompactWarnings     bool
	ConsolidateWarnings bool
	ConsolidateErrors   bool

	// LintInclude and LintExclude contains the linting rules that are used later
	// to determine if a specific diagnostic should be shown or not based on the
	// linting rule IDs (or/and groupIDs) that diagnostic is configured with.
	LintInclude, LintExclude collections.Set[linting.RuleAddr]

	// Concise is used to reduce the level of noise in the output and display
	// only the important details.
	Concise bool

	// ModuleDeprecationWarnLvl is used to filter out deprecation warnings for outputs and variables as requested by the user.
	ModuleDeprecationWarnLvl DeprecationWarningLevel

	// ShowSensitive is used to display the value of variables marked as sensitive.
	ShowSensitive bool

	// ViewType specifies which output format to use
	ViewType ViewType

	// InputEnabled is used to disable interactive input for unspecified
	// variable and backend config values. Default is true.
	InputEnabled bool

	// Optional stream to write json data to
	JSONInto *os.File
}

type ViewType rune

type Workspace struct {
	// View represents the global view options
	View *View
}

type WorkspaceDelete struct {
	// WorkspaceName represents the name of the workspace that the user wants to be selected.
	WorkspaceName string

	// Force allows the user to forcefully delete a workspace removing the still existing resources
	// from the OpenTofu's management.
	Force bool

	// View represents the global view options
	View *View

	// Vars and State are the common extended flags
	Vars  *Vars
	State *State
}

type WorkspaceList struct {
	// View represents the global view options
	View *View

	// Vars holds the information that might be needed to be given through `-var`/`-var-file`.
	Vars *Vars
}

type WorkspaceNew struct {
	// Workspace represents the name of the workspace that the user wants to be selected.
	WorkspaceName string

	// View represents the global view options
	View *View

	// Vars and State are the common extended flags
	Vars  *Vars
	State *State
}

type WorkspaceSelect struct {
	// Workspace represents the name of the workspace that the user wants to be selected.
	WorkspaceName string
	// CreateIfMissing is a flag that the user can set to "true" to force the creation of the workspace
	// in case it's missing from the current list of workspaces.
	CreateIfMissing bool

	// View represents the global view options
	View *View

	// Vars holds the information that might be needed to be given through `-var`/`-var-file`.
	Vars *Vars
}

type WorkspaceShow struct {
	// View represents the global view options
	View *View

	// Vars holds the information that might be needed to be given through `-var`/`-var-file`.
	Vars *Vars
}