views

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

type Apply interface {
	ResourceCount(stateOutPath string)
	Outputs(outputValues map[string]*states.OutputValue)

	Operation() Operation
	Hooks() []tofu.Hook

	Diagnostics(diags tfdiags.Diagnostics)
	HelpPrompt()

	// Backend returns the non-command view that contains methods to provide
	// progress output for the backend operations.
	Backend() Backend
}

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

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

type ApplyMulti []Apply

type Backend interface {
	Basic
	InitializingBackend()
	InitializingCloudBackend()
	BackendTypeAlias(backendType, canonType string)
	MigratingFromCloudToLocal()
	UnconfiguringBackendType(backendType string)
	BackendTypeUnset(backendType string)
	BackendTypeSet(backendType string)
	CloudBackendUpdated()
	MigratingLocalTypeToCloud(fromBackendType string)
	MigratingCloudToLocalType(toBackendType string)
	BackendTypeChanged(oldBackendType string, newBackendType string)
	BackendReconfigured()
	MigrationCompleted(workspaces []string, currentWs string)

	StateLocker() StateLocker
}

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

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

type BackendMulti []Backend

type BackendRemote interface {
	Basic
	Output(msg string, color bool)
	RunWarning(msg string)
	RenderLog(log *jsonformat.JSONLog) error
	RenderHumanPlan(plan jsonformat.Plan, mode plans.Mode)
	OperationCancelled()
	OperationNotCancelled()
	PreRefresh()
	InitialRetryError(isRemote bool)
	RepeatedRetryError(elapsed time.Duration)
	UnavailableVersionInBackend(localVersion, usedVersion string)
	ApplySavedHeader()
	LockTimeoutError()
	RemoteWorkspaceInRelativeDirectory(wd string, configDir string)
	WaitingForCostEstimation(elapsedHint string)
	WaitingForOperationToStart(opType string, elapsed string)
	WaitingForTheManuallyLockedWorkspace(elapsedHint string)
	WaitingForRuns(noOfRuns int, elapsedHint string)
	WaitingForQueuedRuns(noOfRuns int, elapsedHint string)
	OperationHeader(isApply bool, isRemote bool)
}

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

type Basic interface {
	Diagnostics(diags tfdiags.Diagnostics)
}

type Console interface {
	Diagnostics(diags tfdiags.Diagnostics)

	UnsupportedLocalOp()
	Output(result string)

	// Backend returns the non-command view that contains methods to provide
	// progress output for the backend operations.
	Backend() Backend
}

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

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

type ConsoleMulti []Console

type DeprecationDiagnosticAllowedSeen map[any]any

type Fmt interface {
	Diagnostics(diags tfdiags.Diagnostics)
	UserOutputWriter() io.Writer
}

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

type Get interface {
	Diagnostics(diags tfdiags.Diagnostics)
	Hooks(showLocalDir bool) initwd.ModuleInstallHooks
}

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

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

type GetMulti []Get

type Graph interface {
	Diagnostics(diags tfdiags.Diagnostics)
	ErrorUnsupportedLocalOp()
	Output(graphStr string)

	// Backend returns the non-command view that contains methods to provide
	// progress output for the backend operations.
	Backend() Backend
}

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

type Import interface {
	Diagnostics(diags tfdiags.Diagnostics)
	Hooks() []tofu.Hook
	Operation() Operation

	InvalidAddressReference()
	MissingResourceConfiguration(addr addrs.AbsResourceInstance, modulePath string, resourceType string, resourceName string)
	Success()
	UnsupportedLocalOp()

	// Backend returns the non-command view that contains methods to provide
	// progress output for the backend operations.
	Backend() Backend
}

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

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

type ImportMulti []Import

type Init interface {
	CopyFromModule(src string)
	InitialisedFromEmptyDir()

	Diagnostics(diags tfdiags.Diagnostics)

	ConfigError()
	OutputNewline()
	InitSuccess(cloud bool)
	InitSuccessCLI(cloud bool)

	InitializingModules(upgrade bool)

	InitializingProviderPlugins()
	ProviderAlreadyInstalled(provider string, version string, inCache bool)
	BuiltInProviderAvailable(provider string)
	ReusingLockFileVersion(provider string)
	FindingProviderVersions(provider string, constraints string)
	FindingLatestProviderVersion(provider string)
	UsingProviderFromCache(provider string, version string)
	InstallingProvider(provider string, version string, toCache bool)
	ProviderInstalled(provider string, version string, authResult string, keyID string)
	ProviderInstalledSkippedSignature(provider string, version string)
	WaitingForCacheLock(cacheDir string)
	ProvidersSignedInfo()
	ProviderUpgradeLockfileConflict()
	ProviderInstallationInterrupted()
	LockFileCreated()
	LockFileChanged()
	Hooks(showLocalDir bool) initwd.ModuleInstallHooks

	// Backend returns the non-command view that contains methods to provide
	// progress output for the backend operations.
	Backend() Backend
}

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

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

type InitMulti []Init

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

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

type LiveCheck interface {
	Report(rep LiveCheckReport)
}

type LiveCheckCount struct {
	Label string
	Count int
}

type LiveCheckFinding struct {
	// Title is the refusal's one-line summary, and Layer which pass
	// produced it.
	Title string
	Layer string

	// SiteCount is how many places it fired, which may exceed the number of
	// Examples.
	SiteCount int

	// Types is the per-resource-type breakdown for a type-shaped rule, and
	// is empty for every other rule. When it is set it replaces Examples in
	// the output: a rule that fires on four hundred resources of nine types
	// is read as nine lines, not four hundred.
	Types []LiveCheckCount

	// Examples are the first few positions, as "file:line" and an address.
	Examples []LiveCheckSite

	// MoreSites is how many positions were not shown.
	MoreSites int

	// Remedy is what to do about it, and DocsRef the shipped document that
	// explains it. An empty DocsRef is printed as the gap it is rather than
	// omitted.
	Remedy  string
	DocsRef string

	// UnsetVarRefs are the valueless input variables this refusal's sites
	// read, and UnsetVarSites how many of its sites read one.
	UnsetVarRefs  []string
	UnsetVarSites int
}

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

type LiveCheckInstance struct {
	Address string `json:"address"`
	Type    string `json:"type,omitempty"`
	Rung    string `json:"rung,omitempty"`
	Refused bool   `json:"refused,omitempty"`
	Rule    string `json:"rule,omitempty"`
	Reason  string `json:"reason,omitempty"`
}

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

type LiveCheckModule struct {
	Path   string
	Source string
}

type LiveCheckReference struct {
	From    string   `json:"from"`
	Estate  string   `json:"estate"`
	Address string   `json:"address,omitempty"`
	ReadBy  []string `json:"read_by,omitempty"`
}

type LiveCheckReport struct {
	// Dir is the directory that was checked, as the user named it.
	Dir string

	// Blocked is whether anything refused the configuration.
	Blocked bool

	// Instances is how many managed resource instances resolved, and Sites
	// how many refused positions were found.
	Instances int
	Sites     int

	// Findings are the refusals, already ranked.
	Findings []LiveCheckFinding

	// Warnings are non-fatal diagnostics, as a title and a count each.
	Warnings []LiveCheckCount

	// Checked, Partial and Unchecked name the live-path stages behind this
	// verdict: the ones run in full, the ones run in part, and the ones
	// nobody looked at. All three are always printed: see
	// [LiveCheckHuman.Report].
	Checked   []string
	Partial   []string
	Unchecked []string

	// Schemas is whether provider schemas were available.
	Schemas bool

	// UnresolvedModules are module calls whose contents went unchecked.
	UnresolvedModules []LiveCheckModule

	// UnsetVariables are required input variables that had no value.
	UnsetVariables []string

	// VariableDependentFindings is how many refusals have at least one site
	// reading an unset variable, and FullyVariableDependent how many have
	// no other kind of site. The second is the number that would go away if
	// the variables were supplied; the first is the number that might
	// change. Issue #161.
	VariableDependentFindings int
	FullyVariableDependent    int

	// OnlyBackendRemains is true when the configuration is not blocked and
	// the only warning is the state-backend rule: the sole remaining
	// friction is a backend or cloud block, which choudoufu ignores rather
	// than reads. Deleting it is still the recommended edit - so the
	// configuration says what actually happens - though it is not required.
	//
	// Before #214 demoted state-backend from a fatal finding to a warning,
	// this named the "one edit from moving" case (#175): 11 of 145 real
	// published estates were blocked on exactly this rule and nothing else.
	// That case cannot occur anymore - state-backend never reaches
	// Findings, so it can no longer be what blocks a configuration - but the
	// clean verdict it now describes is still worth calling out by name
	// rather than folding into an unqualified "nothing is refused".
	OnlyBackendRemains bool

	// Estate is the name this configuration's own "live" block declares,
	// when it declares one and sets the argument - [check.Report.Estate]
	// passed straight through. Empty for most directories this command
	// runs against, since it runs with no live block by design. Printed
	// only by -json (see [LiveCheckJSON.Report]): the human report has
	// never named the estate, and #790 does not ask it to start.
	Estate string

	// InstanceRoster and References are GitHub issue #790's declared
	// roster: every instance this analysis named an address for
	// ([check.Report.Roster]), and every cross-estate data-source edge
	// live/OUTPUTS.md's pattern describes ([check.Report.References]).
	// Both are empty in the human report - [LiveCheckJSON.Report] is their
	// sole reader - because the text report already carries the same facts
	// one summarized count at a time (Instances above, and the Findings a
	// refused instance falls under) and #790 asks for a per-instance
	// restatement in JSON, not a new paragraph in the prose.
	InstanceRoster []LiveCheckInstance
	References     []LiveCheckReference
}

type LiveCheckSite struct {
	Location string
	Address  string
}

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

type LiveLs interface {
	Report(rep LiveLsReport)
}

type LiveLsGap struct {
	// Address is the declared instance's address, exactly as
	// [addrs.AbsResourceInstance.String] renders it.
	Address string

	// Type is the resource type.
	Type string

	// Rung is "record" for an instance whose identity lives in the estate's
	// record store rather than on a cloud object's tags (GitHub issue
	// #417's record-carried tier, and #73's RECORD_ADMITTED / #270's
	// located-identity types both land here), or "declaration-carried" for
	// one whose type carries no settable tags argument at all, so no marker
	// was ever written for it to be found by (#417's declaration-carried
	// tier). Never anything else: an instance on the marker-carried tier
	// that this listing still could not find is a genuine absence, not a
	// gap, and is left out of this list entirely - see the command
	// package's own classification.
	Rung string

	// Detail is one sentence explaining Rung, aimed at a reader who has
	// never read live/MARKERS.md's tier definitions.
	Detail string
}

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

type LiveLsItem struct {
	// ID is the resource's ARN, or another stable identity when the
	// discovery path that found it (today, only the IAM native path) has no
	// ARN in hand at the point of listing - which does not happen for IAM,
	// since a role's ListRoles entry always carries its own Arn, but is
	// stated here because Source names a second path this field's contract
	// has to hold for.
	ID string

	// Type is the resource's type: the resource type name decoded from its
	// own tofu-address marker when that marker parses, or, when it does
	// not, a coarse ARN-derived label ("service:resource-type" or bare
	// "service") - the same approximation
	// examples/live-mv-workbench/tlmig/govern.py's read_inventory (the
	// prior art GitHub issue #789 names) uses for every item, unconditionally.
	Type string

	// Address is the unescaped configuration address decoded from
	// tofu-address and its continuation tags, per live/MARKERS.md - empty
	// when the resource carries no readable tofu-address marker at all
	// (malformed, or genuinely absent despite carrying tofu-estate, which
	// live/MARKERS.md calls out as a possible, if unusual, state).
	Address string

	// Slot is the tofu-slot marker value, empty when absent.
	Slot string

	// Declared is whether Address matches a declared instance in ConfigDir,
	// meaningful only when ConfigDir is non-empty (always false otherwise -
	// nothing to compare against).
	Declared bool

	// Source names which pass found this item: "tagging" for the Resource
	// Groups Tagging API's estate-wide GetResources call, "iam" for the
	// second pass over iam:ListRoles/iam:ListRoleTags GitHub issue #789
	// asks for by name, because the tagging index does not serve IAM on a
	// real account, or "kubernetes" for the cluster-wide, label-selected
	// list per kind a Kubernetes provider configuration in DIR gets
	// (GitHub issue #1081). An item the tagging pass already found is
	// never reported a second time under "iam", even when the IAM pass
	// would have found it too - see the command package's own
	// dedup-by-ARN.
	Source string

	// Tags are every marker tag this resource carries, unmodified - the raw
	// material GitHub issue #789 asks for alongside the decoded fields
	// above. For a Kubernetes object they are its metadata.labels, all of
	// them, tofu-estate included.
	Tags map[string]string

	// Kind and APIVersion are set for a Kubernetes object only: the kind
	// the cluster serves it as and the group/version it was listed at
	// ("v1" for the core group). For such an item ID is the natural key,
	// NAMESPACE/NAME or NAME for a cluster-scoped kind, Type is the
	// provider type the object is filed under (the type a block in DIR
	// declares the kind through, else the provider's versioned name, else
	// the manifest type for a kind no built-in type manages), and Address
	// is the declaring block's address when one declares it - the join is
	// the kind and the natural key, since the Kubernetes marker carries
	// no address (live/MARKERS.md, "Kubernetes: one label") - or empty
	// when none does. Both empty for an AWS item.
	Kind       string
	APIVersion string
}

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

type LiveLsReport struct {
	// Estate is the tofu-estate value that was listed.
	Estate string

	// Region is the region the Tagging API and IAM calls were sent to, or
	// empty when the AWS SDK's own default resolution named none.
	Region string

	// RegionSource is where Region came from (GitHub issue #1044): "flag"
	// for an explicit -region, "provider" for the root's own provider block
	// (the region live-plan and live-check on the same DIR would use), "sdk"
	// for the AWS SDK's default chain. Empty when no AWS listing ran at all
	// - a Kubernetes-only DIR - and then no source line prints.
	RegionSource string

	// RegionNote is the source line's detail: for "provider", the block the
	// region came from (`provider "aws"`); for "sdk" with a DIR, why the
	// root did not supply one (the block sets no region, or sets one this
	// command could not resolve, said with its reason); empty otherwise.
	RegionNote string

	// Consistent is whether -consistent was passed, and Stabilized is
	// whether two consecutive reads agreed before Attempts ran out - see
	// [command.pollConsistent]. Stabilized is always true when Consistent is
	// false: a single read has nothing to disagree with itself about.
	Consistent bool
	Stabilized bool
	Attempts   int

	// ConfigDir is the configuration directory the listing was
	// cross-referenced against, or empty when none was given - see
	// LiveLs.ConfigDir's own doc comment in the arguments package.
	ConfigDir string

	// Items is every resource the listing found, in the order
	// [LiveLsReport] is built in - already sorted by type then address then
	// id.
	Items []LiveLsItem

	// Gaps are declared instances a configuration directory named that the
	// listing itself cannot see, each with the rung that explains why: the
	// tier definitions (#417)'s record-carried and declaration-carried
	// tiers name resources with no marker to find at all, ever, which this
	// listing's whole mechanism is reading markers. Empty when ConfigDir is
	// empty.
	//
	// An empty list is only meaningful alongside GapsSkipped and Schemas
	// below: see GitHub issue #966.
	Gaps []LiveLsGap

	// GapsSkipped is why the declared-instance comparison did not run,
	// empty when it ran to completion. GitHub issue #966: an empty Gaps
	// means two opposite things - the comparison ran and found nothing, or
	// it never ran - and the -json document made the second one look like
	// the first by omitting the key entirely.
	//
	// It carries the same sentence [command.LiveLsCommand.liveLsGaps]'
	// "Declared-instance comparison skipped" warning carries, so the
	// document and the warning cannot say different things, and it is also
	// set when no configuration directory was given at all - the case where
	// there is nothing to compare and an empty list would otherwise read as
	// a comparison that found nothing.
	GapsSkipped string

	// Schemas is whether the declared-instance comparison read the
	// provider's own resource schemas. Without them
	// [command.liveLsRung]'s [markers.Taggable] check cannot run, so the
	// declaration-carried rung - the larger half of what this comparison
	// exists to report - classifies nothing and every such instance drops
	// silently out of Gaps.
	//
	// False when no comparison ran at all, which GapsSkipped then explains.
	Schemas bool
}

type LivePlanAdoptable struct {
	// Addr is the declared instance the live resource matched.
	Addr string `json:"addr"`

	// TypeName and LiveID are the resource type and the identity the live
	// resource was found with - what "adopt with" below writes the two
	// markers onto.
	TypeName string `json:"type"`
	LiveID   string `json:"identity"`

	// Matched are the identity-bearing arguments the live resource and the
	// declared instance agreed on exactly, in the order the matcher
	// compared them - the "matched on:" line of the human render.
	Matched []LivePlanMatchedArgument `json:"matched"`

	// MarkerEstate and MarkerAddress are the tofu-estate and tofu-address
	// values that adopt the resource, the same pair [StatelessUnowned]
	// carries under the same names.
	MarkerEstate  string `json:"adopt_tofu_estate"`
	MarkerAddress string `json:"adopt_tofu_address"`

	// AdoptCommand is the one-line AWS CLI command that writes those two
	// tags, exactly as the human render prints it after "adopt with:",
	// empty for a type stateless mode has no command for. Informational: a
	// consumer that writes markers itself uses the two fields above.
	AdoptCommand string `json:"adopt_command,omitempty"`
}

type LivePlanBound struct {
	// Addr is the declared instance's own address.
	Addr string `json:"addr"`

	// TypeName is the resource type.
	TypeName string `json:"type"`

	// Identity is the live id this instance bound to - an ARN, a
	// server-assigned ID, or whatever join the type's own identity
	// convention produces (live/MARKERS.md and the identity table govern
	// the shape). It is whatever the projection actually matched on:
	// [projection.Result.BoundIdentity], not the pre-projection
	// [identity.Resolution.ImportID], which for three of the four
	// [LivePlanBoundSource] paths is empty at the moment the row is built.
	//
	// ALWAYS PRESENT on the wire since GitHub issue #967, including as ""
	// - no omitempty, deliberately. It used to be omitted whenever it was
	// empty, which made the one row shape that was FOUND by its live
	// identity (a marker-bound instance) the one shape that could not
	// state it, and left a reader joining on Addr instead. behold pairs a
	// bound row with the live-ls item carrying the same id, so a key that
	// comes and goes with the tag index's freshness is worse for it than
	// a key that is sometimes "".
	//
	// Empty for exactly one shape: a record-backed instance (GitHub issue
	// #73, identity.ClassRecordBacked), whose values live in the estate's
	// record store and which has no cloud object for an id to name. Never
	// invented for one - a row with no live id says so.
	Identity string `json:"identity"`

	// IdentityValues is the identity broken out one component at a time -
	// [identity.Resolution.IdentityValues] - when the resolver kept that
	// form; nil whenever it did not (a marker-bound instance carries only
	// the joined Identity string, never this map - see
	// [identity.Resolution.IdentityValues]'s own doc comment).
	IdentityValues map[string]string `json:"identity_values,omitempty"`

	// Source is which admission path supplied Identity.
	Source LivePlanBoundSource `json:"source"`
}

type LivePlanBoundSource string

type LivePlanDiagnostic struct {
	// Severity is "error" or "warning" (tfdiags.Diagnostic.Severity's own
	// String()).
	Severity string `json:"severity"`
	Summary  string `json:"summary"`
	Detail   string `json:"detail,omitempty"`
}

type LivePlanDocument struct {
	// Estate is this run's estate name, exactly as [LivePlanBound],
	// omissions and unowned were all computed against - empty only when
	// the run had none to search by, which every other section already
	// degrades gracefully for (see statelessEstateFor's own callers).
	Estate string `json:"estate"`

	// ChoudoufuVersion is this fork's own release tag (tfversion.Fork),
	// empty on a development build - the same value the version command's
	// human-readable output names "choudoufu %s" and its own "-json"
	// output does not carry at all (views/version.go's versionOutput has
	// no field for it). A snapshot naming what produced it needs this even
	// when the version command's own JSON does not yet.
	ChoudoufuVersion string `json:"choudoufu_version"`

	// UpstreamVersion is the pinned OpenTofu base version this build's
	// engine is (tfversion.String(), the same value the version command's
	// human output prints as "OpenTofu v%s" and its JSON output carries as
	// "terraform_version") - the other half of "what produced it": a
	// choudoufu release and the upstream OpenTofu release it forked its
	// engine from are two different version numbers, and a renderer
	// comparing behaviour across snapshots needs to know both.
	UpstreamVersion string `json:"upstream_version"`

	// Bound is every declared instance the plan admitted into prior state,
	// and how - see [LivePlanBound].
	Bound []LivePlanBound `json:"bound"`

	// Omissions is every declared instance the plan could not read from
	// the live system, and why - the same value the human-readable
	// "Omissions" section already renders as prose ([StatelessOmission]).
	Omissions []StatelessOmission `json:"omissions"`

	// Unowned is every live resource found at a declared identity without
	// this estate's marker - the same value the human-readable "Unowned"
	// section already renders as prose ([StatelessUnowned]).
	Unowned []StatelessUnowned `json:"unowned"`

	// Foreign is every live resource the estate-wide sweep found that nobody
	// claims - the machine-readable half of the "Not swept" / unclaimed prose
	// the human render already prints.
	//
	// It was absent from this document until #1197. The run computed it, the
	// human render showed it, and every machine reader - live-discover, and
	// INTENTIUS/chant's choudoufuLivePlan activity - had no way to ask "what
	// does nobody claim", even though the answer was in hand at the moment
	// this document was built. A category the document does not carry cannot
	// be selected on either, so this is the prerequisite for any account-side
	// filter.
	//
	// Empty on a run that did not ask the account-bounded question: the sweep
	// is only performed under -adoption-only or TOFU_LIVE_COLLECT_UNCLAIMED,
	// and an observation run has nothing to report here rather than a silent
	// zero meaning "nothing foreign exists". [LivePlanDocument.Swept] is what
	// says which types were actually listed, and it is the field to read
	// before concluding anything from an empty list.
	Foreign []LivePlanForeign `json:"foreign"`

	// Adoptable is every live resource the estate-wide sweep matched to a
	// declared instance BY CONTENT - the identity-bearing arguments agree
	// exactly, and the object carries no marker for this estate - the
	// same rows the human-readable "Adoptable" section renders
	// ([StatelessBindCandidate]). GitHub issue #962: a declared aws_vpc
	// whose identity the server assigns lands in Omissions as
	// NEEDS_DISCOVERY, and until this field existed the document had no
	// row for the live VPC the sweep had already matched to it, while the
	// -adoption-only human render did. The two sections are disjoint on
	// purpose: Unowned is a live object read at an identity the
	// configuration DECLARES; Adoptable is one the sweep FOUND for a
	// declaration that declares no identity at all.
	//
	// Empty on any run that did not ask the account-inventory question
	// (an ordinary plan without TOFU_LIVE_COLLECT_UNCLAIMED, see
	// collectUnclaimedSetting), which is why Swept below travels with it.
	Adoptable []LivePlanAdoptable `json:"adoptable"`

	// Swept is every resource type the estate-wide sweep listed in full
	// on this run - the same list the human-readable "Foreign resources"
	// section counts. A consumer reads an empty Adoptable against it: no
	// rows with the declared type in Swept means the sweep looked and
	// found no match; no rows with Swept empty means this run did not
	// look, and "choudoufu plan -adoption-only" or
	// TOFU_LIVE_COLLECT_UNCLAIMED=1 is how to ask.
	Swept []string `json:"swept"`

	// Diagnostics is every warning and error this run raised outside the
	// three sections above - a state file present but not consulted, a
	// provider version skew warning, and so on. It exists so that -json
	// can be the ONLY thing printed on a successful run without silently
	// dropping something [Run] would otherwise have told a human: see
	// [StatelessPlanJSON.Document]'s own caller
	// (LivePlanCommand.livePlan's jsonRequested branch) for why the
	// ordinary human-readable diagnostic rendering is skipped precisely
	// when this document exists to carry the same information instead.
	// Empty on the common run: most of this fork's own findings already
	// have a home in Omissions or Unowned above and never reach a bare
	// diagnostic at all.
	Diagnostics []LivePlanDiagnostic `json:"diagnostics,omitempty"`
}

type LivePlanForeign struct {
	// TypeName and LiveID are the resource type and the identity the live
	// resource was found with.
	TypeName string `json:"type"`
	LiveID   string `json:"identity"`

	// DisplayName is the human-facing name the render shows, when the type
	// has one distinct from its identity.
	DisplayName string `json:"display_name,omitempty"`

	// HeldBy is the tofu-estate marker the resource carries, empty when it
	// carries none - the same field [StatelessUnowned] uses under the same
	// name, read the same way. A foreign resource carries no marker for THIS
	// estate by construction; a non-empty value here means another estate
	// owns it, which is exactly what a reader chasing a mis-owned resource
	// is looking for.
	HeldBy string `json:"tofu_estate,omitempty"`

	// Why is the sweep's own one-line reason this resource counts as
	// unclaimed, carried verbatim rather than re-derived.
	Why string `json:"why,omitempty"`
}

type LivePlanMatchedArgument struct {
	Attribute string `json:"attribute"`
	Value     string `json:"value"`
}

type Login interface {
	Diagnostics(diags tfdiags.Diagnostics)

	UiSeparator()
	MOTDMessage(msg string)
	DefaultTFCLoginSuccess()
	DefaultTFELoginSuccess(dispHostname string)
	TokenObtainedConfirmation(dispHostname string)
	OpeningBrowserForOAuth(dispHostname, authCodeURL string)
	ManualBrowserLaunch(dispHostname, authCodeURL string)
	WaitingForHostSignal()
	PasswordRequestHeader()
	OpeningBrowserForTokens(dispHostname, tokensURL string)
	ManualBrowserLaunchForTokens(dispHostname, tokensURL string)
	GenerateTokenInstruction()
	TokenStorageInFile(localFilename string)
	TokenStorageInHelper(helperType string)
	RetrievedTokenForUser(username string)
	RequestAPITokenMessage(dispHostname, mechanism string)
	BrowserBasedLoginInstruction()
	StorageLocationConsentInHelper(helperType string)
	StorageLocationConsentInFile(localFilename string)
}

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

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

type LoginMulti []Login

type Logout interface {
	Diagnostics(diags tfdiags.Diagnostics)

	NoCredentialsStored(dispHostname string)
	RemovingCredentialsFromHelper(dispHostname, helperType string)
	RemovingCredentialsFromFile(dispHostname, localFilename string)
	LogoutSuccess(dispHostname string)
}

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

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

type LogoutMulti []Logout

type MetadataFunctions interface {
	Diagnostics(diags tfdiags.Diagnostics)
	// PrintFunctions returns true if it managed to print the functions and false otherwise.
	PrintFunctions() bool
}

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

type Operation interface {
	Interrupted()
	FatalInterrupt()
	Stopping()
	Cancelled(planMode plans.Mode)

	EmergencyDumpState(stateFile *statefile.File, enc encryption.StateEncryption) error

	PlannedChange(change *plans.ResourceInstanceChangeSrc)
	Plan(plan *plans.Plan, schemas *tofu.Schemas)
	PlanNextStep(planPath string, genConfigPath string)

	Diagnostics(diags tfdiags.Diagnostics)
}

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

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

type OperationMulti []Operation

type Output interface {
	Output(name string, outputs map[string]*states.OutputValue) tfdiags.Diagnostics
	Diagnostics(diags tfdiags.Diagnostics)
}

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

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

type OutputMulti []Output

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

type Plan interface {
	Operation() Operation
	Hooks() []tofu.Hook

	Diagnostics(diags tfdiags.Diagnostics)
	HelpPrompt()

	// Backend returns the non-command view that contains methods to provide
	// progress output for the backend operations.
	Backend() Backend
}

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

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