type Actionstring

type Actions []Action

func (Actions)Create¶

func (aActions) Create()bool

Create is true if this set of Actions denotes creation of a newresource.

func (Actions)CreateBeforeDestroy¶

func (aActions) CreateBeforeDestroy()bool

CreateBeforeDestroy is true if this set of Actions denotes acreate-before-destroy operation, usually the result of replacementto a resource that has the create_before_destroy lifecycle optionset.

func (Actions)Delete¶

func (aActions) Delete()bool

Delete is true if this set of Actions denotes resource removal.

func (Actions)DestroyBeforeCreate¶

func (aActions) DestroyBeforeCreate()bool

DestroyBeforeCreate is true if this set of Actions denotes adestroy-before-create operation. This is the standard resourcereplacement method.

func (Actions)Forget¶added inv0.23.0

func (aActions) Forget()bool

Forget is true if this set of Actions denotes a forget operation.

func (Actions)NoOp¶

func (aActions) NoOp()bool

NoOp is true if this set of Actions denotes a no-op.

func (Actions)Read¶

func (aActions) Read()bool

Read is true if this set of Actions denotes a read operation only.

func (Actions)Replace¶

func (aActions) Replace()bool

Replace is true if this set of Actions denotes a valid replacementoperation.

func (Actions)Update¶

func (aActions) Update()bool

Update is true if this set of Actions denotes an update operation.

type Change struct {// The action to be carried out by this change.ActionsActions `json:"actions,omitempty"`// Before and After are representations of the object value both// before and after the action. For create and delete actions,// either Before or After is unset (respectively). For no-op// actions, both values will be identical. After will be incomplete// if there are values within it that won't be known until after// apply.Before interface{} `json:"before,"`After  interface{} `json:"after,omitempty"`// A deep object of booleans that denotes any values that are// unknown in a resource. These values were previously referred to// as "computed" values.//// If the value cannot be found in this map, then its value should// be available within After, so long as the operation supports it.AfterUnknown interface{} `json:"after_unknown,omitempty"`// BeforeSensitive and AfterSensitive are object values with similar// structure to Before and After, but with all sensitive leaf values// replaced with true, and all non-sensitive leaf values omitted. These// objects should be combined with Before and After to prevent accidental// display of sensitive values in user interfaces.BeforeSensitive interface{} `json:"before_sensitive,omitempty"`AfterSensitive  interface{} `json:"after_sensitive,omitempty"`// Importing contains the import metadata about this operation. If importing// is present (ie. not null) then the change is an import operation in// addition to anything mentioned in the actions field. The actual contents// of the Importing struct is subject to change, so downstream consumers// should treat any values in here as strictly optional.Importing *Importing `json:"importing,omitempty"`// GeneratedConfig contains any HCL config generated for this resource// during planning as a string.//// If this is populated, then Importing should also be populated but this// might change in the future. However, not all Importing changes will// contain generated config.GeneratedConfigstring `json:"generated_config,omitempty"`// ReplacePaths contains a set of paths that point to attributes/elements// that are causing the overall resource to be replaced rather than simply// updated.//// This field is always a slice of indexes, where an index in this context// is either an integer pointing to a child of a set/list, or a string// pointing to the child of a map, object, or block.ReplacePaths []interface{} `json:"replace_paths,omitempty"`// BeforeIdentity and AfterIdentity are representations of the resource// identity value both before and after the action.BeforeIdentity interface{} `json:"before_identity,omitempty"`AfterIdentity  interface{} `json:"after_identity,omitempty"`}

type CheckDynamicAddress struct {// ToDisplay is a formatted and ready to display representation of the// full address, including the additional information from the relevant// CheckStaticAddress.ToDisplaystring `json:"to_display"`// Module is the module part of the address. This address will include the// instance key for any module expansions resulting from foreach or count// arguments. This field will be empty for any resources within the root// module.Modulestring `json:"module,omitempty"`// InstanceKey is the instance key for any instances of a given resource.//// InstanceKey will be empty if there was no foreach or count argument// defined on the containing object.InstanceKey interface{} `json:"instance_key,omitempty"`}

type CheckKindstring

type CheckResultDynamic struct {// Address is the relative address of this instance given the Address in the// parent object.AddressCheckDynamicAddress `json:"address"`// Status is the overall status for the checks within this dynamic object.StatusCheckStatus `json:"status"`// Problems describes any additional optional details about this check if// the check failed.//// This will not include the errors resulting from this check block, as they// will be exposed as diagnostics in the original terraform execution. It// may contain any failure messages even if the overall status is// CheckStatusError, however, as the instance could contain multiple checks// that returned a mix of error and failure statuses.Problems []CheckResultProblem `json:"problems,omitempty"`}

type CheckResultProblem struct {// Message is the condition error message provided by the original check// author.Messagestring `json:"message"`}

type CheckResultStatic struct {// Address is the absolute address of the "checkable object"AddressCheckStaticAddress `json:"address"`// Status is the overall status for all the checks within this object.StatusCheckStatus `json:"status"`// Instances contains the results for dynamic object that belongs to this// static object. For example, any instances created from an object using// the foreach or count meta arguments.//// Check blocks and outputs will only contain a single instance, while// resources can contain 1 to many.Instances []CheckResultDynamic `json:"instances,omitempty"`}

type CheckStaticAddress struct {// ToDisplay is a formatted and ready to display representation of the// address.ToDisplaystring `json:"to_display"`// Kind represents the CheckKind of this check.KindCheckKind `json:"kind"`// Module is the module part of the address. This will be empty for any// resources in the root module.Modulestring `json:"module,omitempty"`// Mode is the ResourceMode of the resource that contains this check. This// field is only set is Kind equals CheckKindResource.ModeResourceMode `json:"mode,omitempty"`// Type is the resource type for the resource that contains this check. This// field is only set if Kind equals CheckKindResource.Typestring `json:"type,omitempty"`// Name is the name of the resource, check block, or output that contains// this check.Namestring `json:"name,omitempty"`}

type CheckStatusstring

type Config struct {// A map of all provider instances across all modules in the// configuration.//// The index for this field is opaque and should not be parsed. Use// the individual fields in ProviderConfig to discern actual data// about the provider such as name, alias, or defined module.ProviderConfigs map[string]*ProviderConfig `json:"provider_config,omitempty"`// The root module in the configuration. Any child modules descend// off of here.RootModule *ConfigModule `json:"root_module,omitempty"`}

func (*Config)UnmarshalJSON¶added inv0.4.0

func (c *Config) UnmarshalJSON(b []byte)error

func (*Config)Validate¶

func (c *Config) Validate()error

Validate checks to ensure that the config is present.

type ConfigModule struct {// The outputs defined in the module.Outputs map[string]*ConfigOutput `json:"outputs,omitempty"`// The resources defined in the module.Resources []*ConfigResource `json:"resources,omitempty"`// Any "module" stanzas within the specific module.ModuleCalls map[string]*ModuleCall `json:"module_calls,omitempty"`// The variables defined in the module.Variables map[string]*ConfigVariable `json:"variables,omitempty"`}

type ConfigOutput struct {// Indicates whether or not the output was marked as sensitive.Sensitivebool `json:"sensitive,omitempty"`// The defined value of the output.Expression *Expression `json:"expression,omitempty"`// The defined description of this output.Descriptionstring `json:"description,omitempty"`// The defined dependencies tied to this output.DependsOn []string `json:"depends_on,omitempty"`}

type ConfigProvisioner struct {// The type of the provisioner, ie: "local-exec".Typestring `json:"type,omitempty"`// Any non-special configuration values in the provisioner, indexed by// key.Expressions map[string]*Expression `json:"expressions,omitempty"`}

type ConfigResource struct {// The address of the resource relative to the module that it is// in.Addressstring `json:"address,omitempty"`// The resource mode.ModeResourceMode `json:"mode,omitempty"`// The type of resource, ie: "null_resource" in// "null_resource.foo".Typestring `json:"type,omitempty"`// The name of the resource, ie: "foo" in "null_resource.foo".Namestring `json:"name,omitempty"`// An opaque key representing the provider configuration this// module uses. Note that there are more than one circumstance that// this key will not match what is found in the ProviderConfigs// field in the root Config structure, and as such should not be// relied on for that purpose.ProviderConfigKeystring `json:"provider_config_key,omitempty"`// The list of provisioner defined for this configuration. This// will be nil if no providers are defined.Provisioners []*ConfigProvisioner `json:"provisioners,omitempty"`// Any non-special configuration values in the resource, indexed by// key.Expressions map[string]*Expression `json:"expressions,omitempty"`// The resource's configuration schema version. With access to the// specific Terraform provider for this resource, this can be used// to determine the correct schema for the configuration data// supplied in Expressions.SchemaVersionuint64 `json:"schema_version"`// The expression data for the "count" value in the resource.CountExpression *Expression `json:"count_expression,omitempty"`// The expression data for the "for_each" value in the resource.ForEachExpression *Expression `json:"for_each_expression,omitempty"`// The contents of the "depends_on" config directive, which// declares explicit dependencies for this resource.DependsOn []string `json:"depends_on,omitempty"`}

type ConfigVariable struct {// The defined default value of the variable.Default interface{} `json:"default,omitempty"`// The defined text description of the variable.Descriptionstring `json:"description,omitempty"`// Whether the variable is marked as sensitiveSensitivebool `json:"sensitive,omitempty"`}

type DeferredResourceChange struct {// Reason is the reason why this resource change was deferred.Reasonstring `json:"reason,omitempty"`// Change contains any information we have about the deferred change.ResourceChange *ResourceChange `json:"resource_change,omitempty"`}

type Diagnostic struct {SeverityDiagnosticSeverity `json:"severity,omitempty"`Summarystring `json:"summary,omitempty"`Detailstring `json:"detail,omitempty"`Range   *Range `json:"range,omitempty"`Snippet *DiagnosticSnippet `json:"snippet,omitempty"`}

type DiagnosticExpressionValue struct {Traversalstring `json:"traversal"`Statementstring `json:"statement"`}

type DiagnosticSeveritystring

const (DiagnosticSeverityUnknownDiagnosticSeverity = "unknown"DiagnosticSeverityErrorDiagnosticSeverity = "error"DiagnosticSeverityWarningDiagnosticSeverity = "warning")

These severities map to the tfdiags.Severity values, plus an explicitunknown in case that enum grows without us noticing here.

type DiagnosticSnippet struct {// Context is derived from HCL's hcled.ContextString output. This gives a// high-level summary of the root context of the diagnostic: for example,// the resource block in which an expression causes an error.Context *string `json:"context"`// Code is a possibly-multi-line string of Terraform configuration, which// includes both the diagnostic source and any relevant context as defined// by the diagnostic.Codestring `json:"code"`// StartLine is the line number in the source file for the first line of// the snippet code block. This is not necessarily the same as the value of// Range.Start.Line, as it is possible to have zero or more lines of// context source code before the diagnostic range starts.StartLineint `json:"start_line"`// HighlightStartOffset is the character offset into Code at which the// diagnostic source range starts, which ought to be highlighted as such by// the consumer of this data.HighlightStartOffsetint `json:"highlight_start_offset"`// HighlightEndOffset is the character offset into Code at which the// diagnostic source range ends.HighlightEndOffsetint `json:"highlight_end_offset"`// Values is a sorted slice of expression values which may be useful in// understanding the source of an error in a complex expression.Values []DiagnosticExpressionValue `json:"values"`}

type Expression struct {*ExpressionData}

func (*Expression)MarshalJSON¶

func (e *Expression) MarshalJSON() ([]byte,error)

MarshalJSON implements json.Marshaler for Expression.

func (*Expression)UnmarshalJSON¶

func (e *Expression) UnmarshalJSON(b []byte)error

UnmarshalJSON implements json.Unmarshaler for Expression.

type ExpressionData struct {// If the *entire* expression is a constant-defined value, this// will contain the Go representation of the expression's data.//// Note that a nil here denotes and explicit null. When a value is// unknown on part of the value coming from an expression that// cannot be resolved at parse time, this field will contain// UnknownConstantValue.ConstantValue interface{} `json:"constant_value,omitempty"`// If any part of the expression contained values that were not// able to be resolved at parse-time, this will contain a list of// the referenced identifiers that caused the value to be unknown.References []string `json:"references,omitempty"`// A list of complex objects that were nested in this expression.// If this value is a nested block in configuration, sometimes// referred to as a "sub-resource", this field will contain those// values, and ConstantValue and References will be blank.NestedBlocks []map[string]*Expression `json:"-"`}

type FunctionParameter struct {// Name is an optional name for the argument.Namestring `json:"name,omitempty"`// Description is an optional human-readable description// of the argumentDescriptionstring `json:"description,omitempty"`// IsNullable is true if null is acceptable value for the argumentIsNullablebool `json:"is_nullable,omitempty"`// A type that any argument for this parameter must conform to.Typecty.Type `json:"type"`}

type FunctionSignature struct {// Description is an optional human-readable description// of the functionDescriptionstring `json:"description,omitempty"`// Summary is an optional shortened description of the functionSummarystring `json:"summary,omitempty"`// DeprecationMessage is an optional message that indicates that the// function should be considered deprecated and what actions should be// performed by the practitioner to handle the deprecation.DeprecationMessagestring `json:"deprecation_message,omitempty"`// ReturnType is the ctyjson representation of the function's// return types based on supplying all parameters using// dynamic types. Functions can have dynamic return types.ReturnTypecty.Type `json:"return_type"`// Parameters describes the function's fixed positional parameters.Parameters []*FunctionParameter `json:"parameters,omitempty"`// VariadicParameter describes the function's variadic// parameter if it is supported.VariadicParameter *FunctionParameter `json:"variadic_parameter,omitempty"`}

type IdentityAttribute struct {// The identity attribute typeIdentityTypecty.Type `json:"type,omitempty"`// The description of the identity attributeDescriptionstring `json:"description,omitempty"`// RequiredForImport when enabled signifies that this attribute must be// specified in the configuration during importRequiredForImportbool `json:"required_for_import,omitempty"`// OptionalForImport when enabled signifies that this attribute is not// required to be specified during import, because it can be supplied by the// providerOptionalForImportbool `json:"optional_for_import,omitempty"`}

type IdentitySchema struct {// The version of the particular resource identity schema.Versionuint64 `json:"version"`// Map of identity attributesAttributes map[string]*IdentityAttribute `json:"attributes,omitempty"`}

type Importing struct {// The original ID of this resource used to target it as part of planned// import operation.IDstring `json:"id,omitempty"`// Unknown indicates the ID or identity was unknown at the time of// planning. This would have led to the overall change being deferred, as// such this should only be true when processing changes from the deferred// changes list.Unknownbool `json:"unknown,omitempty"`// The identity can be used instead of the ID to target the resource as part// of the planned import operation.Identity interface{} `json:"identity,omitempty"`}

type MetadataFunctions struct {// The version of the format. This should always match the// MetadataFunctionsFormatVersionConstraints in this package, else// unmarshaling will fail.FormatVersionstring `json:"format_version"`// The signatures of the functions available in a Terraform version.Signatures map[string]*FunctionSignature `json:"function_signatures,omitempty"`}

func (*MetadataFunctions)UnmarshalJSON¶added inv0.15.0

func (f *MetadataFunctions) UnmarshalJSON(b []byte)error

func (*MetadataFunctions)Validate¶added inv0.15.0

func (f *MetadataFunctions) Validate()error

Validate checks to ensure that MetadataFunctions is present, and theversion matches the version supported by this library.

type ModuleCall struct {// The contents of the "source" field.Sourcestring `json:"source,omitempty"`// Any non-special configuration values in the module, indexed by// key.Expressions map[string]*Expression `json:"expressions,omitempty"`// The expression data for the "count" value in the module.CountExpression *Expression `json:"count_expression,omitempty"`// The expression data for the "for_each" value in the module.ForEachExpression *Expression `json:"for_each_expression,omitempty"`// The configuration data for the module itself.Module *ConfigModule `json:"module,omitempty"`// The version constraint for modules that come from the registry.VersionConstraintstring `json:"version_constraint,omitempty"`// The explicit resource dependencies for the "depends_on" value.// As it must be a slice of references, Expression is not used.DependsOn []string `json:"depends_on,omitempty"`}

type Plan struct {// The version of the plan format. This should always match the// PlanFormatVersion constant in this package, or else an unmarshal// will be unstable.FormatVersionstring `json:"format_version,omitempty"`// The version of Terraform used to make the plan.TerraformVersionstring `json:"terraform_version,omitempty"`// The variables set in the root module when creating the plan.Variables map[string]*PlanVariable `json:"variables,omitempty"`// The common state representation of resources within this plan.// This is a product of the existing state merged with the diff for// this plan.PlannedValues *StateValues `json:"planned_values,omitempty"`// The change operations for resources and data sources within this plan// resulting from resource drift.ResourceDrift []*ResourceChange `json:"resource_drift,omitempty"`// The change operations for resources and data sources within this// plan.ResourceChanges []*ResourceChange `json:"resource_changes,omitempty"`// DeferredChanges contains the change operations for resources that are deferred// for this plan.DeferredChanges []*DeferredResourceChange `json:"deferred_changes,omitempty"`// Complete indicates that all resources have successfully planned changes.// This will be false if there are DeferredChanges or if the -target flag is used.//// Complete was introduced in Terraform 1.8 and will be nil for all previous// Terraform versions.Complete *bool `json:"complete,omitempty"`// The change operations for outputs within this plan.OutputChanges map[string]*Change `json:"output_changes,omitempty"`// The Terraform state prior to the plan operation. This is the// same format as PlannedValues, without the current diff merged.PriorState *State `json:"prior_state,omitempty"`// The Terraform configuration used to make the plan.Config *Config `json:"configuration,omitempty"`// RelevantAttributes represents any resource instances and their// attributes which may have contributed to the planned changesRelevantAttributes []ResourceAttribute `json:"relevant_attributes,omitempty"`// Checks contains the results of any conditional checks executed, or// planned to be executed, during this plan.Checks []CheckResultStatic `json:"checks,omitempty"`// Timestamp contains the static timestamp that Terraform considers to be// the time this plan executed, in UTC.Timestampstring `json:"timestamp,omitempty"`// contains filtered or unexported fields}

func (*Plan)UnmarshalJSON¶added inv0.4.0

func (p *Plan) UnmarshalJSON(b []byte)error

func (*Plan)UseJSONNumber¶added inv0.19.0

func (p *Plan) UseJSONNumber(bbool)

UseJSONNumber controls whether the Plan will be decoded using thejson.Number behavior or the float64 behavior. When b is true, the Plan willrepresent numbers in PlanOutputs as json.Numbers. When b is false, thePlan will represent numbers in PlanOutputs as float64s.

func (*Plan)Validate¶

func (p *Plan) Validate()error

Validate checks to ensure that the plan is present, and theversion matches the version supported by this library.

type PlanVariable struct {// The value for this variable at plan time.Value interface{} `json:"value,omitempty"`}

type Pos struct {Lineint `json:"line"`Columnint `json:"column"`Byteint `json:"byte"`}

type ProviderConfig struct {// The name of the provider, ie: "aws".Namestring `json:"name,omitempty"`// The fully-specified name of the provider, ie: "registry.terraform.io/hashicorp/aws".FullNamestring `json:"full_name,omitempty"`// The alias of the provider, ie: "us-east-1".Aliasstring `json:"alias,omitempty"`// The address of the module the provider is declared in.ModuleAddressstring `json:"module_address,omitempty"`// Any non-special configuration values in the provider, indexed by// key.Expressions map[string]*Expression `json:"expressions,omitempty"`// The defined version constraint for this provider.VersionConstraintstring `json:"version_constraint,omitempty"`}

type ProviderSchema struct {// The schema for the provider's configuration.ConfigSchema *Schema `json:"provider,omitempty"`// The schemas for any resources in this provider.ResourceSchemas map[string]*Schema `json:"resource_schemas,omitempty"`// The schemas for any data sources in this provider.DataSourceSchemas map[string]*Schema `json:"data_source_schemas,omitempty"`// The schemas for any ephemeral resources in this provider.EphemeralResourceSchemas map[string]*Schema `json:"ephemeral_resource_schemas,omitempty"`// The definitions for any functions in this provider.Functions map[string]*FunctionSignature `json:"functions,omitempty"`// The schemas for resources identities in this provider.ResourceIdentitySchemas map[string]*IdentitySchema `json:"resource_identity_schemas,omitempty"`}

type ProviderSchemas struct {// The version of the plan format. This should always match one of// ProviderSchemasFormatVersions in this package, or else// an unmarshal will be unstable.FormatVersionstring `json:"format_version,omitempty"`// The schemas for the providers in this configuration, indexed by// provider type. Aliases are not included, and multiple instances// of a provider in configuration will be represented by a single// provider here.Schemas map[string]*ProviderSchema `json:"provider_schemas,omitempty"`}

func (*ProviderSchemas)UnmarshalJSON¶added inv0.4.0

func (p *ProviderSchemas) UnmarshalJSON(b []byte)error

func (*ProviderSchemas)Validate¶

func (p *ProviderSchemas) Validate()error

Validate checks to ensure that ProviderSchemas is present, and theversion matches the version supported by this library.

type Range struct {Filenamestring `json:"filename"`StartPos    `json:"start"`EndPos    `json:"end"`}

type ResourceAttribute struct {// Resource describes resource instance address (e.g. null_resource.foo)Resourcestring `json:"resource"`// Attribute describes the attribute path using a lossy representation// of cty.Path. (e.g. ["id"] or ["objects", 0, "val"]).Attribute []json.RawMessage `json:"attribute"`}

type ResourceChange struct {// The absolute resource address.Addressstring `json:"address,omitempty"`// The absolute address that this resource instance had// at the conclusion of a previous plan.PreviousAddressstring `json:"previous_address,omitempty"`// The module portion of the above address. Omitted if the instance// is in the root module.ModuleAddressstring `json:"module_address,omitempty"`// The resource mode.ModeResourceMode `json:"mode,omitempty"`// The resource type, example: "aws_instance" for aws_instance.foo.Typestring `json:"type,omitempty"`// The resource name, example: "foo" for aws_instance.foo.Namestring `json:"name,omitempty"`// The instance key for any resources that have been created using// "count" or "for_each". If neither of these apply the key will be// empty.//// This value can be either an integer (int) or a string.Index interface{} `json:"index,omitempty"`// The name of the provider this resource belongs to. This allows// the provider to be interpreted unambiguously in the unusual// situation where a provider offers a resource type whose name// does not start with its own name, such as the "googlebeta"// provider offering "google_compute_instance".ProviderNamestring `json:"provider_name,omitempty"`// An identifier used during replacement operations, and can be// used to identify the exact resource being replaced in state.DeposedKeystring `json:"deposed,omitempty"`// The data describing the change that will be made to this object.Change *Change `json:"change,omitempty"`}

type ResourceModestring

type Schema struct {// The version of the particular resource schema.Versionuint64 `json:"version"`// The root-level block of configuration values.Block *SchemaBlock `json:"block,omitempty"`}

type SchemaAttribute struct {// The attribute type// Either AttributeType or AttributeNestedType is set, never both.AttributeTypecty.Type `json:"type,omitempty"`// Details about a nested attribute type// Either AttributeType or AttributeNestedType is set, never both.AttributeNestedType *SchemaNestedAttributeType `json:"nested_type,omitempty"`// The description field for this attribute. If no kind is// provided, it can be assumed to be plain text.Descriptionstring                `json:"description,omitempty"`DescriptionKindSchemaDescriptionKind `json:"description_kind,omitempty"`// If true, this attribute is deprecated.Deprecatedbool `json:"deprecated,omitempty"`// If true, this attribute is required - it has to be entered in// configuration.Requiredbool `json:"required,omitempty"`// If true, this attribute is optional - it does not need to be// entered in configuration.Optionalbool `json:"optional,omitempty"`// If true, this attribute is computed - it can be set by the// provider. It may also be set by configuration if Optional is// true.Computedbool `json:"computed,omitempty"`// If true, this attribute is sensitive and will not be displayed// in logs. Future versions of Terraform may encrypt or otherwise// treat these values with greater care than non-sensitive fields.Sensitivebool `json:"sensitive,omitempty"`// If true, this attribute is write only and its value will not be// persisted in artifacts such as plan files or state.WriteOnlybool `json:"write_only,omitempty"`}

func (*SchemaAttribute)MarshalJSON¶added inv0.13.0

func (as *SchemaAttribute) MarshalJSON() ([]byte,error)

type SchemaBlock struct {// The attributes defined at the particular level of this block.Attributes map[string]*SchemaAttribute `json:"attributes,omitempty"`// Any nested blocks within this particular block.NestedBlocks map[string]*SchemaBlockType `json:"block_types,omitempty"`// The description for this block and format of the description. If// no kind is provided, it can be assumed to be plain text.Descriptionstring                `json:"description,omitempty"`DescriptionKindSchemaDescriptionKind `json:"description_kind,omitempty"`// If true, this block is deprecated.Deprecatedbool `json:"deprecated,omitempty"`}

type SchemaBlockType struct {// The nesting mode for this block.NestingModeSchemaNestingMode `json:"nesting_mode,omitempty"`// The block data for this block type, including attributes and// subsequent nested blocks.Block *SchemaBlock `json:"block,omitempty"`// The lower limit on items that can be declared of this block// type.MinItemsuint64 `json:"min_items,omitempty"`// The upper limit on items that can be declared of this block// type.MaxItemsuint64 `json:"max_items,omitempty"`}

type SchemaDescriptionKindstring

type SchemaNestedAttributeType struct {// A map of nested attributesAttributes map[string]*SchemaAttribute `json:"attributes,omitempty"`// The nesting mode for this attribute.NestingModeSchemaNestingMode `json:"nesting_mode,omitempty"`// The lower limit on number of items that can be declared// of this attribute type (not applicable to single nesting mode).MinItemsuint64 `json:"min_items,omitempty"`// The upper limit on number of items that can be declared// of this attribute type (not applicable to single nesting mode).MaxItemsuint64 `json:"max_items,omitempty"`}

type SchemaNestingModestring

type State struct {// The version of the state format. This should always match the// StateFormatVersion constant in this package, or else am// unmarshal will be unstable.FormatVersionstring `json:"format_version,omitempty"`// The Terraform version used to make the state.TerraformVersionstring `json:"terraform_version,omitempty"`// The values that make up the state.Values *StateValues `json:"values,omitempty"`// Checks contains the results of any conditional checks when Values was// last updated.Checks []CheckResultStatic `json:"checks,omitempty"`// contains filtered or unexported fields}

func (*State)UnmarshalJSON¶added inv0.4.0

func (s *State) UnmarshalJSON(b []byte)error

func (*State)UseJSONNumber¶added inv0.8.0

func (s *State) UseJSONNumber(bbool)

UseJSONNumber controls whether the State will be decoded using thejson.Number behavior or the float64 behavior. When b is true, the State willrepresent numbers in StateOutputs as json.Numbers. When b is false, theState will represent numbers in StateOutputs as float64s.

func (*State)Validate¶

func (s *State) Validate()error

Validate checks to ensure that the state is present, and theversion matches the version supported by this library.

type StateModule struct {// All resources or data sources within this module.Resources []*StateResource `json:"resources,omitempty"`// The absolute module address, omitted for the root module.Addressstring `json:"address,omitempty"`// Any child modules within this module.ChildModules []*StateModule `json:"child_modules,omitempty"`}

type StateOutput struct {// Whether or not the output was marked as sensitive.Sensitivebool `json:"sensitive"`// The value of the output.Value interface{} `json:"value,omitempty"`// The type of the output.Typecty.Type `json:"type,omitempty"`}

func (*StateOutput)MarshalJSON¶added inv0.14.0

func (so *StateOutput) MarshalJSON() ([]byte,error)

type StateResource struct {// The absolute resource address.Addressstring `json:"address,omitempty"`// The resource mode.ModeResourceMode `json:"mode,omitempty"`// The resource type, example: "aws_instance" for aws_instance.foo.Typestring `json:"type,omitempty"`// The resource name, example: "foo" for aws_instance.foo.Namestring `json:"name,omitempty"`// The instance key for any resources that have been created using// "count" or "for_each". If neither of these apply the key will be// empty.//// This value can be either an integer (int) or a string.Index interface{} `json:"index,omitempty"`// The name of the provider this resource belongs to. This allows// the provider to be interpreted unambiguously in the unusual// situation where a provider offers a resource type whose name// does not start with its own name, such as the "googlebeta"// provider offering "google_compute_instance".ProviderNamestring `json:"provider_name,omitempty"`// The version of the resource type schema the "values" property// conforms to.SchemaVersionuint64 `json:"schema_version,"`// The JSON representation of the attribute values of the resource,// whose structure depends on the resource type schema. Any unknown// values are omitted or set to null, making them indistinguishable// from absent values.AttributeValues map[string]interface{} `json:"values,omitempty"`// The JSON representation of the sensitivity of the resource's// attribute values. Only attributes which are sensitive// are included in this structure.SensitiveValuesjson.RawMessage `json:"sensitive_values,omitempty"`// The addresses of the resources that this resource depends on.DependsOn []string `json:"depends_on,omitempty"`// If true, the resource has been marked as tainted and will be// re-created on the next update.Taintedbool `json:"tainted,omitempty"`// DeposedKey is set if the resource instance has been marked Deposed and// will be destroyed on the next apply.DeposedKeystring `json:"deposed_key,omitempty"`// The version of the resource identity schema the "identity" property// conforms to.IdentitySchemaVersion *uint64 `json:"identity_schema_version,omitempty"`// The JSON representation of the resource identity, whose structure// depends on the resource identity schema.IdentityValues map[string]interface{} `json:"identity,omitempty"`}

type StateValues struct {// The Outputs for this common state representation.Outputs map[string]*StateOutput `json:"outputs,omitempty"`// The root module in this state representation.RootModule *StateModule `json:"root_module,omitempty"`}

type ValidateOutput struct {FormatVersionstring `json:"format_version"`Validbool         `json:"valid"`ErrorCountint          `json:"error_count"`WarningCountint          `json:"warning_count"`Diagnostics  []Diagnostic `json:"diagnostics"`}

func (*ValidateOutput)UnmarshalJSON¶added inv0.9.0

func (vo *ValidateOutput) UnmarshalJSON(b []byte)error

func (*ValidateOutput)Validate¶added inv0.9.0

func (vo *ValidateOutput) Validate()error

Validate checks to ensure that data is present, and theversion matches the version supported by this library.

type VersionOutput struct {Versionstring            `json:"terraform_version"`Revisionstring            `json:"terraform_revision"`Platformstring            `json:"platform,omitempty"`ProviderSelections map[string]string `json:"provider_selections"`Outdatedbool              `json:"terraform_outdated"`}