CheckCoreVersionRequirements visits each of the modules in the given configuration tree and verifies that any given Core version constraints match with the version of Terraform Core that is being used.

CloseProviderEvalTree returns the evaluation tree for closing provider connections that aren't needed anymore.

ConfigTreeDependencies returns the dependencies of the tree of modules described by the given configuration and state.

connectionBlockSupersetSchema is a schema representing the superset of all possible arguments for "connection" blocks across all supported connection types.

DefaultVariableValues returns an InputValues map representing the default values specified for variables in the given configuration map.

Eval evaluates the given EvalNode with the given context, properly evaluating all args in the correct order.

EvalDataForInstanceKey constructs a suitable InstanceKeyEvalData for evaluating in a context that has the given instance key.

EvalFilter runs the filter on the given node and returns the final filtered value.

EvalNodeFilterOp returns a filter function that filters nodes that include themselves in specific operations.

EvalRaw is like Eval except that it returns all errors, even if they signal something normal such as EvalEarlyExitError.

GraphDot returns the dot formatting of a visual representation of the given Terraform graph.

GraphTransformIf is a helper function that conditionally returns a GraphTransformer given.

GraphTransformMulti combines multiple graph transformers into a single GraphTransformer that runs all the individual graph transformers.

InputValuesFromCaller turns the given map of naked values into an InputValues that attributes each value to "a caller", using the source type ValueFromCaller.

LoadSchemas searches the given configuration, state and plan (any of which may be nil) for constructs that have an associated schema, requests the necessary schemas from the given component factory (which must _not_ be nil), and returns a single object representing all of the necessary schemas.

MustShimLegacyState is a wrapper around ShimLegacyState that panics if the conversion does not succeed.

NewContext creates a new Context structure.

NewInstanceInfo constructs an InstanceInfo from an addrs.AbsResourceInstance.

NewInstanceStateShimmedFromValue is a shim method to lower a new-style object value representing the attributes of an instance object into the legacy InstanceState representation.

NewLegacyResourceAddress creates a ResourceAddress from a new-style addrs.AbsResource value.

NewLegacyResourceInstanceAddress creates a ResourceAddress from a new-style addrs.AbsResource value.

NewNodeAbstractResource creates an abstract resource graph node for the given absolute resource address.

NewNodeAbstractResourceInstance creates an abstract resource instance graph node for the given absolute resource instance address.

NewReferenceMap is used to create a new reference map for the given set of vertices.

NewResource constructs a legacy Resource object from an addrs.ResourceInstance value.

NewResourceConfigRaw constructs a ResourceConfig whose content is exactly the given value.

NewResourceConfigShimmed wraps a cty.Value of object type in a legacy ResourceConfig object, so that it can be passed to older APIs that expect this wrapping.

NewSemaphore creates a semaphore that allows up to a given limit of simultaneous acquisitions.

NewState is used to initialize a blank state.

ParseResourceAddressForInstanceDiff creates a ResourceAddress for a resource name as described in a module diff.

ParseResourceStateKey accepts a key in the format used by ModuleState.Resources and returns a resource name and resource index.

PathObjectCacheKey is like PathCacheKey but includes an additional name to be included in the key, for module-namespaced objects.

ProviderEvalTree returns the evaluation tree for initializing and configuring providers.

ReadPlan reads a plan structure out of a reader in the format that was written by WritePlan.

ReadState reads a state structure out of a reader in the format that was written by WriteState.

ReferencesFromConfig returns the references that a configuration has based on the interpolated variables in a configuration.

ResourceProviderFactoryFixed is a helper that creates a ResourceProviderFactory that just returns some fixed provider.

ResourceProviderResolverFixed returns a ResourceProviderResolver that has a fixed set of provider factories provided by the caller.

ShimLegacyState is a helper that takes the legacy state type and converts it to the new state type.

TestStateFile writes the given state to the path.

UpgradeResourceState will, if necessary, run the provider-defined upgrade logic against the given state object to make it compliant with the current schema version.

ValidateGraphBuilder creates the graph for the validate operation.

WritePlan writes a plan somewhere in a binary format.

WriteState writes a state somewhere in a binary format.

TODO: Actually use DiffRefresh in core too, for less confusion.

only visits in-memory elements such as variables, locals, and outputs.

HookActionContinue continues with processing as usual.

HookActionHalt halts immediately: no more hooks are processed and the action that Terraform was about to take is cancelled.

InputModeProvider asks for provider variables.

InputModeStd is the standard operating mode and asks for both variables and providers.

InputModeVar asks for all variables.

InputModeVarUnset asks for variables which are not set yet.

StateVersion is the current version for our state file.

ValueFromAutoFile indicates that a value came from a "values file", like a .tfvars file, that was implicitly loaded by naming convention.

ValueFromCaller indicates that the value was explicitly overridden by a caller to Context.SetVariable after the context was constructed.

ValueFromCLIArg indicates that the value was provided directly in a CLI argument.

ValueFromConfig indicates that a value came from a .tf or .tf.json file, e.g.

ValueFromEnvVar indicates that the value was provided via an environment variable.

ValueFromInput indicates that the value was provided at an interactive input prompt.

ValueFromNamedFile indicates that a value came from a named "values file", like a .tfvars file, that was passed explicitly on the command line (e.g.

ValueFromPlan indicates that the value was retrieved from a stored plan.

ValueFromUnknown is the zero value of ValueSourceType and is not valid.

ErrNoState is returned by ReadState when the io.Reader contains no data.

EvalDataForNoInstanceKey is a value of InstanceKeyData that sets no instance key values at all, suitable for use in contexts where no keyed instance is relevant.

GraphTypeMap is a mapping of human-readable string to GraphType.

ApplyGraphBuilder implements GraphBuilder and is responsible for building a graph for applying a Terraform diff.

AttachResourceConfigTransformer goes through the graph and attaches resource configuration structures to nodes that implement GraphNodeAttachManagedResourceConfig or GraphNodeAttachDataResourceConfig.

AttachSchemaTransformer finds nodes that implement GraphNodeAttachResourceSchema, GraphNodeAttachProviderConfigSchema, or GraphNodeAttachProvisionerSchema, looks up the needed schemas for each and then passes them to a method implemented by the node.

AttachStateTransformer goes through the graph and attaches state to nodes that implement the interfaces above.

BackendState stores the configuration to connect to a remote backend.

BasicGraphBuilder is a GraphBuilder that builds a graph out of a series of transforms and (optionally) validates the graph is a valid structure.

BuiltinEvalContext is an EvalContext implementation that is used by Terraform by default.

CBDEdgeTransformer modifies the edges of CBD nodes that went through the DestroyEdgeTransformer to have the right dependencies.

CloseProviderTransformer is a GraphTransformer that adds nodes to the graph that will close open provider connections that aren't needed anymore.

CloseProvisionerTransformer is a GraphTransformer that adds nodes to the graph that will close open provisioner connections that aren't needed anymore.

ConfigTransformer is a GraphTransformer that adds all the resources from the configuration to the graph.

Context represents all the context that Terraform needs in order to perform operations on infrastructure.

ContextGraphWalker is the GraphWalker implementation used with the Context struct to walk and evaluate the graph.

ContextMeta is metadata about the running context.

ContextOpts are the user-configurable options to create a context with NewContext.

CountBoundaryTransformer adds a node that depends on everything else so that it runs last in order to clean up the state for nodes that are on the "count boundary": "foo.0" when only one exists becomes "foo".

DataSource is a data source that a resource provider implements.

DestroyEdge is an edge that represents a standard "destroy" relationship: Target depends on Source because Source is destroying.

DestroyEdgeTransformer is a GraphTransformer that creates the proper references for destroy resources.

DestroyOutputTransformer is a GraphTransformer that adds nodes to delete outputs during destroy.

DestroyPlanGraphBuilder implements GraphBuilder and is responsible for planning a pure-destroy.

DestroyReferenceTransformer is a GraphTransformer that reverses the edges for locals and outputs that depend on other nodes which will be removed during destroy.

Diff tracks the changes that are necessary to apply a configuration to an existing infrastructure.

DiffTransformer is a GraphTransformer that adds graph nodes representing each of the resource changes described in the given Changes object.

EphemeralState is used for transient state that is only kept in-memory.

EvalApply is an EvalNode implementation that writes the diff to the full diff.

EvalApplyPost is an EvalNode implementation that does the post-Apply work.

EvalApplyPre is an EvalNode implementation that does the pre-Apply work.

EvalApplyProvisioners is an EvalNode implementation that executes the provisioners for a resource.

EvalCheckModuleRemoved is an EvalNode implementation that verifies that a module has been removed from the state as expected.

EvalCheckPlannedChange is an EvalNode implementation that produces errors if the _actual_ expected value is not compatible with what was recorded in the plan.

EvalPreventDestroy is an EvalNode implementation that returns an error if a resource has PreventDestroy configured and the diff would destroy the resource.

EvalCloseProvider is an EvalNode implementation that closes provider connections that aren't needed anymore.

EvalCloseProvisioner is an EvalNode implementation that closes provisioner connections that aren't needed anymore.

EvalConfigBlock is an EvalNode implementation that takes a raw configuration block and evaluates any expressions within it.

EvalConfigExpr is an EvalNode implementation that takes a raw configuration expression and evaluates it.

EvalConfigProvider is an EvalNode implementation that configures a provider that is already initialized and retrieved.

EvalCountFixZeroOneBoundaryGlobal is an EvalNode that fixes up the state when there is a resource count with zero/one boundary, i.e.

EvalDeleteLocal is an EvalNode implementation that deletes a Local value from the state.

EvalDeleteOutput is an EvalNode implementation that deletes an output from the state.

EvalDeposeState is an EvalNode implementation that moves the current object for the given instance to instead be a deposed object, leaving the instance with no current object.

EvalDiff is an EvalNode implementation that detects changes for a given resource instance.

EvalDiffDestroy is an EvalNode implementation that returns a plain destroy diff.

EvalEarlyExitError is a special error return value that can be returned by eval nodes that does an early exit.

EvalForgetResourceState is an EvalNode implementation that prunes out an empty resource-level state for a given resource address, or produces an error if it isn't empty after all.

EvalGetProvider is an EvalNode implementation that retrieves an already initialized provider instance for the given name.

EvalGetProvisioner is an EvalNode implementation that retrieves an already initialized provisioner instance for the given name.

EvalGraphBuilder implements GraphBuilder and constructs a graph suitable for evaluating in-memory values (input variables, local values, output values) in the state without any other side-effects.

EvalIf is an EvalNode that is a conditional.

EvalImportState is an EvalNode implementation that performs an ImportState operation on a provider.

EvalImportStateVerify verifies the state after ImportState and after the refresh to make sure it is non-nil and valid.

EvalInitProvider is an EvalNode implementation that initializes a provider and returns nothing.

EvalInitProvisioner is an EvalNode implementation that initializes a provisioner and returns nothing.

EvalLocal is an EvalNode implementation that evaluates the expression for a local value and writes it into a transient part of the state.

EvalMaybeRestoreDeposedObject is an EvalNode implementation that will restore a particular deposed object of the specified resource instance to be the "current" object if and only if the instance doesn't currently have a current object.

EvalMaybeTainted is an EvalNode that takes the planned change, new value, and possible error from an apply operation and produces a new instance object marked as tainted if it appears that a create operation has failed.

EvalModuleCallArgument is an EvalNode implementation that produces the value for a particular variable as will be used by a child module instance.

EvalNoop is an EvalNode that does nothing.

EvalOpFilter is an EvalNode implementation that is a proxy to another node but filters based on the operation.

EvalReadData is an EvalNode implementation that deals with the main part of the data resource lifecycle: either actually reading from the data source or generating a plan to do so.

EvalReadDataApply is an EvalNode implementation that executes a data resource's ReadDataApply method to read data from the data source.

EvalReadDiff is an EvalNode implementation that retrieves the planned change for a particular resource instance object.

EvalReadState is an EvalNode implementation that reads the current object for a specific instance in the state.

EvalReadStateDeposed is an EvalNode implementation that reads the deposed InstanceState for a specific resource out of the state.

EvalReduceDiff is an EvalNode implementation that takes a planned resource instance change as might be produced by EvalDiff or EvalDiffDestroy and "simplifies" it to a single atomic action to be performed by a specific graph node.

EvalRefresh is an EvalNode implementation that does a refresh for a resource.

EvalRequireState is an EvalNode implementation that exits early if the given object is null.

EvalReturnError is an EvalNode implementation that returns an error if it is present.

EvalSequence is an EvalNode that evaluates in sequence.

EvalSetModuleCallArguments is an EvalNode implementation that sets values for arguments of a child module call, for later retrieval during expression evaluation.

Evaluator provides the necessary contextual data for evaluating expressions for a particular walk operation.

EvalUpdateStateHook is an EvalNode implementation that calls the PostStateUpdate hook with the current state.

EvalValidateCount is an EvalNode implementation that validates the count of a resource.

EvalValidateProvider is an EvalNode implementation that validates a provider configuration.

EvalValidateProvisioner is an EvalNode implementation that validates the configuration of a provisioner belonging to a resource.

EvalValidateResource is an EvalNode implementation that validates the configuration of a resource.

EvalValidateSelfRef is an EvalNode implementation that checks to ensure that expressions within a particular referencable block do not reference that same block.

EvalWriteDiff is an EvalNode implementation that saves a planned change for an instance object into the set of global planned changes.

EvalWriteOutput is an EvalNode implementation that writes the output for the given name to the current state.

EvalWriteResourceState is an EvalNode implementation that ensures that a suitable resource-level state record is present in the state, if that's required for the "each mode" of that resource.

EvalWriteState is an EvalNode implementation that saves the given object as the current object for the selected resource instance.

EvalWriteStateDeposed is an EvalNode implementation that writes an InstanceState out to the Deposed list of a resource in the state.

ExpandTransform is a transformer that does a subgraph expansion at graph transform time (vs.

ForcedCBDTransformer detects when a particular CBD-able graph node has dependencies with another that has create_before_destroy set that require it to be forced on, and forces it on.

Graph represents the graph that Terraform uses to represent resources and their dependencies.

ImportGraphBuilder implements GraphBuilder and is responsible for building a graph for importing resources into Terraform.

ImportOpts are used as the configuration for Import.

ImportProviderValidateTransformer is a GraphTransformer that goes through the providers in the graph and validates that they only depend on variables.

ImportStateTransformer is a GraphTransformer that adds nodes to the graph to represent the imports we want to do for resources.

ImportTarget is a single resource to import.

InputOpts are options for asking for input.

InputValue represents a value for a variable in the root module, provided as part of the definition of an operation.

InstanceDiff is the diff of a resource from some state to another.

InstanceInfo is used to hold information about the instance and/or resource being modified.

InstanceKeyEvalData is used during evaluation to specify which values, if any, should be produced for count.index, each.key, and each.value.

InstanceState is used to track the unique state information belonging to a given instance.

LocalTransformer is a GraphTransformer that adds all the local values from the configuration to the graph.

MissingProviderTransformer is a GraphTransformer that adds to the graph a node for each default provider configuration that is referenced by another node but not already present in the graph.

MissingProvisionerTransformer is a GraphTransformer that adds nodes for missing provisioners into the graph.

MockEvalContext is a mock version of EvalContext that can be used for tests.

MockHook is an implementation of Hook that can be used for tests.

MockProvider implements providers.Interface but mocks out all the calls for testing purposes.

MockProvisioner implements provisioners.Interface but mocks out all the calls for testing purposes.

MockResourceProvider implements ResourceProvider but mocks out all the calls for testing purposes.

MockResourceProvisioner implements ResourceProvisioner but mocks out all the calls for testing purposes.

MockUIInput is an implementation of UIInput that can be used for tests.

MockUIOutput is an implementation of UIOutput that can be used for tests.

ModuleDiff tracks the differences between resources to apply within a single module.

ModuleState is used to track all the state relevant to a single module.

ModuleVariableTransformer is a GraphTransformer that adds all the variables in the configuration to the graph.

NilHook is a Hook implementation that does nothing.

NodeAbstractProvider represents a provider that has no associated operations.

NodeAbstractResource represents a resource that has no associated operations.

NodeAbstractResourceInstance represents a resource instance with no associated operations.

NodeApplyableModuleVariable represents a module variable input during the apply step.

NodeApplyableOutput represents an output that is "applyable": it is ready to be applied.

NodeApplyableProvider represents a provider during an apply.

NodeApplyableResource represents a resource that is "applyable": it may need to have its record in the state adjusted to match configuration.

NodeApplyableResourceInstance represents a resource instance that is "applyable": it is ready to be applied and is represented by a diff.

NodeCountBoundary fixes up any transitions between "each modes" in objects saved in state, such as switching from NoEach to EachInt.

NodeDestroyableDataResourceInstance represents a resource that is "destroyable": it is ready to be destroyed.

NodeDestroyableOutput represents an output that is "destroybale": its application will remove the output from the state.

NodeDestroyDeposedResourceInstanceObject represents deposed resource instance objects during apply.

NodeDestroyResourceInstance represents a resource that is to be destroyed.

NodeDestroyResourceInstance represents a resource instance that is to be destroyed.

NodeDisabledProvider represents a provider that is disabled.

NodeEvalableProvider represents a provider during an "eval" walk.

NodeLocal represents a named local value in a particular module.

NodeModuleRemoved represents a module that is no longer in the config.

NodeOutputOrphan represents an output that is an orphan.

NodePlanDeposedResourceInstanceObject represents deposed resource instance objects during plan.

NodePlanDestroyableResourceInstance represents a resource that is ready to be planned for destruction.

NodePlannableResource represents a resource that is "plannable": it is ready to be planned in order to create a diff.

NodePlannableResourceInstance represents a _single_ resource instance that is plannable.

NodePlannableResourceInstanceOrphan represents a resource that is "applyable": it is ready to be applied and is represented by a diff.

NodeProvisioner represents a provider that has no associated operations.

NodeRefreshableDataResource represents a resource that is "refreshable".

NodeRefreshableDataResourceInstance represents a single resource instance that is refreshable.

NodeRefreshableManagedResource represents a resource that is expanabled into NodeRefreshableManagedResourceInstance.

NodeRefreshableManagedResourceInstance represents a resource that is "applyable": it is ready to be applied and is represented by a diff.

NodeRootVariable represents a root variable input.

NodeValidatableResource represents a resource that is used for validation only.

NullGraphWalker is a GraphWalker implementation that does nothing.

OrphanOutputTransformer finds the outputs that aren't present in the given config that are in the state and adds them to the graph for deletion.

OrphanResourceCountTransformer is a GraphTransformer that adds orphans for an expanded count to the graph.

OrphanResourceInstanceTransformer is a GraphTransformer that adds orphaned resource instances to the graph.

OrphanResourceTransformer is a GraphTransformer that adds orphaned resources to the graph.

OutputState is used to track the state relevant to a single output.

OutputTransformer is a GraphTransformer that adds all the outputs in the configuration to the graph.

ParentProviderTransformer connects provider nodes to their parents.

Plan represents a single Terraform execution plan, which contains all the information necessary to make an infrastructure change.

PlanGraphBuilder implements GraphBuilder and is responsible for building a graph for planning (creating a Terraform Diff).

PrefixUIInput is an implementation of UIInput that prefixes the ID with a string, allowing queries to be namespaced.

ProviderConfigTransformer adds all provider nodes from the configuration and attaches the configs.

ProviderSchema represents the schema for a provider's own configuration and the configuration for some or all of its resources and data sources.

ProviderSchemaRequest is used to describe to a ResourceProvider which aspects of schema are required, when calling the GetSchema method.

ProviderTransformer is a GraphTransformer that maps resources to providers within the graph.

ProvisionerTransformer is a GraphTransformer that maps resources to provisioners within the graph.

ProvisionerUIOutput is an implementation of UIOutput that calls a hook for the output so that the hooks can handle it.

PruneProviderTransformer removes any providers that are not actually used by anything, and provider proxies.

PruneUnusedValuesTransformer is s GraphTransformer that removes local and output values which are not referenced in the graph.

ReferenceMap is a structure that can be used to efficiently check for references on a graph.

ReferenceTransformer is a GraphTransformer that connects all the nodes that reference each other in order to form the proper ordering.

RefreshGraphBuilder implements GraphBuilder and is responsible for building a graph for refreshing (updating the Terraform state).

RemoteState is used to track the information about a remote state store that we push/pull state to.

RemovedModuleTransformer implements GraphTransformer to add nodes indicating when a module was removed from the configuration.

Resource is a legacy way to identify a particular resource instance.

ResourceAddress is a way of identifying an individual resource (or, eventually, a subset of resources) within the state.

ResourceAttrDiff is the diff of a single attribute of a resource.

ResourceConfig is a legacy type that was formerly used to represent interpolatable configuration blocks.

ResourceCountTransformer is a GraphTransformer that expands the count out for a specific resource.

ResourceState holds the state of a resource that is used so that a provider can find and manage an existing resource as well as for storing attributes that are used to populate variables of child resources.

ResourceStateKey is a structured representation of the key used for the ModuleState.Resources mapping.

ResourceType is a type of resource that a resource provider can manage.

RootTransformer is a GraphTransformer that adds a root to the graph.

RootVariableTransformer is a GraphTransformer that adds all the root variables to the graph.

Schemas is a container for various kinds of schema that Terraform needs during processing.

State keeps track of a snapshot state-of-the-world that Terraform can use to keep track of what real world resources it is actually managing.

StateFilter is responsible for filtering and searching a state.

StateFilterResult is a single result from a filter operation.

StateTransformer is a GraphTransformer that adds the elements of the state to the graph.

TargetsTransformer is a GraphTransformer that, when the user specifies a list of resources to target, limits the graph to only those resources and their dependencies.

TransitiveReductionTransformer is a GraphTransformer that performs finds the transitive reduction of the graph.

VertexTransformer is a GraphTransformer that transforms vertices using the GraphVertexTransformers.

EvalContext is the interface that is given to eval nodes to execute.

EvalNode is the interface that must be implemented by graph nodes to evaluate/execute.

EvalNodeFilterable is an interface that can be implemented by EvalNodes to allow filtering of sub-elements.

EvalNodeOpFilterable is an interface that EvalNodes can implement to be filterable by the operation that is being run on Terraform.

GraphBuilder is an interface that can be implemented and used with Terraform to build the graph that Terraform walks.

GraphNodeAttachDestroyer is implemented by applyable nodes that have a companion destroy node.

GraphNodeAttachProvider is an interface that must be implemented by nodes that want provider configurations attached.

GraphNodeAttachProviderConfigSchema is an interface implemented by node types that need a provider configuration schema attached.

GraphNodeAttachProvisionerSchema is an interface implemented by node types that need one or more provisioner schemas attached.

GraphNodeAttachResourceConfig is an interface that must be implemented by nodes that want resource configurations attached.

GraphNodeAttachResourceSchema is an interface implemented by node types that need a resource schema attached.

GraphNodeAttachResourceState is an interface that can be implemented to request that a ResourceState is attached to the node.

GraphNodeCloseProvider is an interface that nodes that can be a close provider must implement.

GraphNodeCloseProvisioner is an interface that nodes that can be a close provisioner must implement.

GraphNodeCreator must be implemented by nodes that create OR update resources.

GraphNodeDeposer is an optional interface implemented by graph nodes that might create a single new deposed object for a specific associated resource instance, allowing a caller to optionally pre-allocate a DeposedKey for it.

GraphNodeDestroyer must be implemented by nodes that destroy resources.

GraphNodeDestroyerCBD must be implemented by nodes that might be create-before-destroy destroyers, or might plan a create-before-destroy action.

GraphNodeDynamicExpandable is an interface that nodes can implement to signal that they can be expanded at eval-time (hence dynamic).

GraphNodeEvalable is the interface that graph nodes must implement to enable valuation.

GraphNodeExapndable is an interface that nodes can implement to signal that they can be expanded.

GraphNodeProvider is an interface that nodes that can be a provider must implement.

GraphNodeProviderConsumer is an interface that nodes that require a provider must implement.

GraphNodeProvisioner is an interface that nodes that can be a provisioner must implement.

GraphNodeProvisionerConsumer is an interface that nodes that require a provisioner must implement.

GraphNodeReferenceable must be implemented by any node that represents a Terraform thing that can be referenced (resource, module, etc.).

GraphNodeReferenceOutside is an interface that can optionally be implemented.

GraphNodeReferencer must be implemented by nodes that reference other Terraform items and therefore depend on them.

GraphNodeResource is implemented by any nodes that represent a resource.

GraphNodeResourceInstance is implemented by any nodes that represent a resource instance.

GraphNodeSubgraph is an interface a node can implement if it has a larger subgraph that should be walked.

GraphNodeSubPath says that a node is part of a graph with a different path, and the context should be adjusted accordingly.

GraphNodeTargetable is an interface for graph nodes to implement when they need to be told about incoming targets.

GraphNodeTargetDownstream is an interface for graph nodes that need to be remain present under targeting if any of their dependencies are targeted.

GraphTransformer is the interface that transformers implement.

GraphVertexTransformer is an interface that transforms a single Vertex within with graph.

GraphWalker is an interface that can be implemented that when used with Graph.Walk will invoke the given callbacks under certain events.

Hook is the interface that must be implemented to hook into various parts of Terraform, allowing you to inspect or change behavior at runtime.

RemovableIfNotTargeted is a special interface for graph nodes that aren't directly addressable, but need to be removed from the graph when they are not targeted.

ResourceProvider is an interface that must be implemented by any resource provider: the thing that creates and manages the resources in a Terraform configuration.

ResourceProviderCloser is an interface that providers that can close connections that aren't needed anymore must implement.

ResourceProviderResolver is an interface implemented by objects that are able to resolve a given set of resource provider version constraints into ResourceProviderFactory callbacks.

ResourceProvisioner is an interface that must be implemented by any resource provisioner: the thing that initializes resources in a Terraform configuration.

ResourceProvisionerCloser is an interface that provisioners that can close connections that aren't needed anymore must implement.

UIInput is the interface that must be implemented to ask for input from this user.

UIOutput is the interface that must be implemented to output data to the end user.

ConcreteProviderNodeFunc is a callback type used to convert an abstract provider to a concrete one of some type.

ConcreteResourceInstanceDeposedNodeFunc is a callback type used to convert an abstract resource instance to a concrete one of some type that has an associated deposed object key.

ConcreteResourceInstanceNodeFunc is a callback type used to convert an abstract resource instance to a concrete one of some type.

ConcreteResourceNodeFunc is a callback type used to convert an abstract resource to a concrete one of some type.

DiffAttrType is an enum type that says whether a resource attribute diff is an input attribute (comes from the configuration) or an output attribute (comes as a result of applying the configuration).

DiffChangeType is an enum with the kind of changes a diff has planned.

EvalNodeFilterFunc is the callback used to replace a node with another to node.

GraphType is an enum of the type of graph to create with a Context.

HookAction is an enum of actions that can be taken as a result of a hook callback.

InputMode defines what sort of input will be asked for when Input is called on Context.

InputValues is a map of InputValue instances.

InstanceType is an enum of the various types of instances store in the State.

ProvisionerFactory is a function type that creates a new instance of a provisioners.Interface.

ResourceKind specifies what kind of instance we're working with, whether its a primary instance, a tainted instance, or an orphan.

ResourceMode is deprecated, use addrs.ResourceMode instead.

ResourceProviderFactory is a function type that creates a new instance of a resource provider.

ResourceProviderResolverFunc wraps a callback function and turns it into a ResourceProviderResolver implementation, for convenience in situations where a function and its associated closure are sufficient as a resolver implementation.

ResourceProvisionerFactory is a function type that creates a new instance of a resource provisioner.

StateFilterResultSlice is a slice of results that implements sort.Interface.

ValueSourceType describes what broad category of source location provided a particular value.