84 files changed, 1453 insertions, 1093 deletions
diff --git a/vendor/github.com/hashicorp/go-getter/checksum.go b/vendor/github.com/hashicorp/go-getter/checksum.go
index bea7ed1..eeccfea 100644
--- a/vendor/github.com/hashicorp/go-getter/checksum.go
+++ b/vendor/github.com/hashicorp/go-getter/checksum.go
@@ -19,8 +19,8 @@ import (
        urlhelper "github.com/hashicorp/go-getter/helper/url"
 )
-// fileChecksum helps verifying the checksum for a file.
+// FileChecksum helps verifying the checksum for a file.
-type fileChecksum struct {
+type FileChecksum struct {
        Type     string
        Hash     hash.Hash
        Value    []byte
@@ -50,7 +50,7 @@ func (cerr *ChecksumError) Error() string {
 // checksum is a simple method to compute the checksum of a source file
 // and compare it to the given expected value.
-func (c *fileChecksum) checksum(source string) error {
+func (c *FileChecksum) checksum(source string) error {
        f, err := os.Open(source)
        if err != nil {
                return fmt.Errorf("Failed to open file for checksum: %s", err)
@@ -74,7 +74,7 @@ func (c *fileChecksum) checksum(source string) error {
        return nil
 }
-// extractChecksum will return a fileChecksum based on the 'checksum'
+// extractChecksum will return a FileChecksum based on the 'checksum'
 // parameter of u.
 // ex:
 //  http://hashicorp.com/terraform?checksum=<checksumValue>
@@ -93,7 +93,7 @@ func (c *fileChecksum) checksum(source string) error {
 //  <checksum> *file2
 //
 // see parseChecksumLine for more detail on checksum file parsing
-func (c *Client) extractChecksum(u *url.URL) (*fileChecksum, error) {
+func (c *Client) extractChecksum(u *url.URL) (*FileChecksum, error) {
        q := u.Query()
        v := q.Get("checksum")
@@ -115,14 +115,14 @@ func (c *Client) extractChecksum(u *url.URL) (*fileChecksum, error) {
        switch checksumType {
        case "file":
-                return c.checksumFromFile(checksumValue, u)
+                return c.ChecksumFromFile(checksumValue, u)
        default:
                return newChecksumFromType(checksumType, checksumValue, filepath.Base(u.EscapedPath()))
        }
 }
-func newChecksum(checksumValue, filename string) (*fileChecksum, error) {
+func newChecksum(checksumValue, filename string) (*FileChecksum, error) {
-        c := &fileChecksum{
+        c := &FileChecksum{
                Filename: filename,
        }
        var err error
@@ -133,7 +133,7 @@ func newChecksum(checksumValue, filename string) (*fileChecksum, error) {
        return c, nil
 }
-func newChecksumFromType(checksumType, checksumValue, filename string) (*fileChecksum, error) {
+func newChecksumFromType(checksumType, checksumValue, filename string) (*FileChecksum, error) {
        c, err := newChecksum(checksumValue, filename)
        if err != nil {
                return nil, err
@@ -157,7 +157,7 @@ func newChecksumFromType(checksumType, checksumValue, filename string) (*fileChe
        return c, nil
 }
-func newChecksumFromValue(checksumValue, filename string) (*fileChecksum, error) {
+func newChecksumFromValue(checksumValue, filename string) (*FileChecksum, error) {
        c, err := newChecksum(checksumValue, filename)
        if err != nil {
                return nil, err
@@ -183,14 +183,14 @@ func newChecksumFromValue(checksumValue, filename string) (*fileChecksum, error)
        return c, nil
 }
-// checksumsFromFile will return all the fileChecksums found in file
+// ChecksumFromFile will return all the FileChecksums found in file
 //
-// checksumsFromFile will try to guess the hashing algorithm based on content
+// ChecksumFromFile will try to guess the hashing algorithm based on content
 // of checksum file
 //
-// checksumsFromFile will only return checksums for files that match file
+// ChecksumFromFile will only return checksums for files that match file
 // behind src
-func (c *Client) checksumFromFile(checksumFile string, src *url.URL) (*fileChecksum, error) {
+func (c *Client) ChecksumFromFile(checksumFile string, src *url.URL) (*FileChecksum, error) {
        checksumFileURL, err := urlhelper.Parse(checksumFile)
        if err != nil {
                return nil, err
@@ -286,7 +286,7 @@ func (c *Client) checksumFromFile(checksumFile string, src *url.URL) (*fileCheck
 // of a line.
 // for BSD type sums parseChecksumLine guesses the hashing algorithm
 // by checking the length of the checksum.
-func parseChecksumLine(line string) (*fileChecksum, error) {
+func parseChecksumLine(line string) (*FileChecksum, error) {
        parts := strings.Fields(line)
        switch len(parts) {
diff --git a/vendor/github.com/hashicorp/go-getter/detect_bitbucket.go b/vendor/github.com/hashicorp/go-getter/detect_bitbucket.go
index a183a17..19047eb 100644
--- a/vendor/github.com/hashicorp/go-getter/detect_bitbucket.go
+++ b/vendor/github.com/hashicorp/go-getter/detect_bitbucket.go
@@ -35,7 +35,7 @@ func (d *BitBucketDetector) detectHTTP(src string) (string, bool, error) {
        var info struct {
                SCM string `json:"scm"`
        }
-        infoUrl := "https://api.bitbucket.org/1.0/repositories" + u.Path
+        infoUrl := "https://api.bitbucket.org/2.0/repositories" + u.Path
        resp, err := http.Get(infoUrl)
        if err != nil {
                return "", true, fmt.Errorf("error looking up BitBucket URL: %s", err)
diff --git a/vendor/github.com/hashicorp/go-plugin/client.go b/vendor/github.com/hashicorp/go-plugin/client.go
index 679e10a..bc56559 100644
--- a/vendor/github.com/hashicorp/go-plugin/client.go
+++ b/vendor/github.com/hashicorp/go-plugin/client.go
@@ -87,6 +87,10 @@ type Client struct {
        // goroutines.
        clientWaitGroup sync.WaitGroup
+        // stderrWaitGroup is used to prevent the command's Wait() function from
+        // being called before we've finished reading from the stderr pipe.
+        stderrWaitGroup sync.WaitGroup
        // processKilled is used for testing only, to flag when the process was
        // forcefully killed.
        processKilled bool
@@ -590,6 +594,12 @@ func (c *Client) Start() (addr net.Addr, err error) {
        // Create a context for when we kill
        c.doneCtx, c.ctxCancel = context.WithCancel(context.Background())
+        // Start goroutine that logs the stderr
+        c.clientWaitGroup.Add(1)
+        c.stderrWaitGroup.Add(1)
+        // logStderr calls Done()
+        go c.logStderr(cmdStderr)
        c.clientWaitGroup.Add(1)
        go func() {
                // ensure the context is cancelled when we're done
@@ -602,6 +612,10 @@ func (c *Client) Start() (addr net.Addr, err error) {
                pid := c.process.Pid
                path := cmd.Path
+                // wait to finish reading from stderr since the stderr pipe reader
+                // will be closed by the subsequent call to cmd.Wait().
+                c.stderrWaitGroup.Wait()
                // Wait for the command to end.
                err := cmd.Wait()
@@ -624,11 +638,6 @@ func (c *Client) Start() (addr net.Addr, err error) {
                c.exited = true
        }()
-        // Start goroutine that logs the stderr
-        c.clientWaitGroup.Add(1)
-        // logStderr calls Done()
-        go c.logStderr(cmdStderr)
        // Start a goroutine that is going to be reading the lines
        // out of stdout
        linesCh := make(chan string)
@@ -936,6 +945,7 @@ var stdErrBufferSize = 64 * 1024
 func (c *Client) logStderr(r io.Reader) {
        defer c.clientWaitGroup.Done()
+        defer c.stderrWaitGroup.Done()
        l := c.logger.Named(filepath.Base(c.config.Cmd.Path))
        reader := bufio.NewReaderSize(r, stdErrBufferSize)
diff --git a/vendor/github.com/hashicorp/go-plugin/server.go b/vendor/github.com/hashicorp/go-plugin/server.go
index fc9f05a..4c230e3 100644
--- a/vendor/github.com/hashicorp/go-plugin/server.go
+++ b/vendor/github.com/hashicorp/go-plugin/server.go
@@ -363,14 +363,34 @@ func serverListener() (net.Listener, error) {
 }
 func serverListener_tcp() (net.Listener, error) {
-        minPort, err := strconv.ParseInt(os.Getenv("PLUGIN_MIN_PORT"), 10, 32)
+        envMinPort := os.Getenv("PLUGIN_MIN_PORT")
-        if err != nil {
+        envMaxPort := os.Getenv("PLUGIN_MAX_PORT")
-                return nil, err
+        var minPort, maxPort int64
+        var err error
+        switch {
+        case len(envMinPort) == 0:
+                minPort = 0
+        default:
+                minPort, err = strconv.ParseInt(envMinPort, 10, 32)
+                if err != nil {
+                        return nil, fmt.Errorf("Couldn't get value from PLUGIN_MIN_PORT: %v", err)
+                }
        }
-        maxPort, err := strconv.ParseInt(os.Getenv("PLUGIN_MAX_PORT"), 10, 32)
+        switch {
-        if err != nil {
+        case len(envMaxPort) == 0:
-                return nil, err
+                maxPort = 0
+        default:
+                maxPort, err = strconv.ParseInt(envMaxPort, 10, 32)
+                if err != nil {
+                        return nil, fmt.Errorf("Couldn't get value from PLUGIN_MAX_PORT: %v", err)
+                }
+        }
+        if minPort > maxPort {
+                return nil, fmt.Errorf("ENV_MIN_PORT value of %d is greater than PLUGIN_MAX_PORT value of %d", minPort, maxPort)
        }
        for port := minPort; port <= maxPort; port++ {
diff --git a/vendor/github.com/hashicorp/hcl2/ext/dynblock/README.md b/vendor/github.com/hashicorp/hcl2/ext/dynblock/README.md
index 2b24fdb..f59ce92 100644
--- a/vendor/github.com/hashicorp/hcl2/ext/dynblock/README.md
+++ b/vendor/github.com/hashicorp/hcl2/ext/dynblock/README.md
@@ -95,7 +95,7 @@ schema model provides a description of only one level of nested blocks at
 a time, and thus a new schema must be provided for each additional level of
 nesting.
-To make this arduous process as convenient as possbile, this package provides
+To make this arduous process as convenient as possible, this package provides
 a helper function `WalkForEachVariables`, which returns a `WalkVariablesNode`
 instance that can be used to find variables directly in a given body and also
 determine which nested blocks require recursive calls. Using this mechanism
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression.go
index 26819a2..d3f7a74 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression.go
@@ -473,8 +473,35 @@ func (e *ConditionalExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostic
        falseResult, falseDiags := e.FalseResult.Value(ctx)
        var diags hcl.Diagnostics
-        // Try to find a type that both results can be converted to.
+        resultType := cty.DynamicPseudoType
-        resultType, convs := convert.UnifyUnsafe([]cty.Type{trueResult.Type(), falseResult.Type()})
+        convs := make([]convert.Conversion, 2)
+        switch {
+        // If either case is a dynamic null value (which would result from a
+        // literal null in the config), we know that it can convert to the expected
+        // type of the opposite case, and we don't need to speculatively reduce the
+        // final result type to DynamicPseudoType.
+        // If we know that either Type is a DynamicPseudoType, we can be certain
+        // that the other value can convert since it's a pass-through, and we don't
+        // need to unify the types. If the final evaluation results in the dynamic
+        // value being returned, there's no conversion we can do, so we return the
+        // value directly.
+        case trueResult.RawEquals(cty.NullVal(cty.DynamicPseudoType)):
+                resultType = falseResult.Type()
+                convs[0] = convert.GetConversionUnsafe(cty.DynamicPseudoType, resultType)
+        case falseResult.RawEquals(cty.NullVal(cty.DynamicPseudoType)):
+                resultType = trueResult.Type()
+                convs[1] = convert.GetConversionUnsafe(cty.DynamicPseudoType, resultType)
+        case trueResult.Type() == cty.DynamicPseudoType, falseResult.Type() == cty.DynamicPseudoType:
+                // the final resultType type is still unknown
+                // we don't need to get the conversion, because both are a noop.
+        default:
+                // Try to find a type that both results can be converted to.
+                resultType, convs = convert.UnifyUnsafe([]cty.Type{trueResult.Type(), falseResult.Type()})
+        }
        if resultType == cty.NilType {
                return cty.DynamicVal, hcl.Diagnostics{
                        {
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_template.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_template.go
index fa79e3d..ca3dae1 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_template.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_template.go
@@ -89,6 +89,26 @@ func (e *TemplateExpr) StartRange() hcl.Range {
        return e.Parts[0].StartRange()
 }
+// IsStringLiteral returns true if and only if the template consists only of
+// single string literal, as would be created for a simple quoted string like
+// "foo".
+//
+// If this function returns true, then calling Value on the same expression
+// with a nil EvalContext will return the literal value.
+//
+// Note that "${"foo"}", "${1}", etc aren't considered literal values for the
+// purposes of this method, because the intent of this method is to identify
+// situations where the user seems to be explicitly intending literal string
+// interpretation, not situations that result in literals as a technicality
+// of the template expression unwrapping behavior.
+func (e *TemplateExpr) IsStringLiteral() bool {
+        if len(e.Parts) != 1 {
+                return false
+        }
+        _, ok := e.Parts[0].(*LiteralValueExpr)
+        return ok
+}
 // TemplateJoinExpr is used to convert tuples of strings produced by template
 // constructs (i.e. for loops) into flat strings, by converting the values
 // tos strings and joining them. This AST node is not used directly; it's
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser.go
index 253ad50..772ebae 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser.go
@@ -853,6 +853,14 @@ Traversal:
                                                SrcRange: rng,
                                        }
                                        ret = makeRelativeTraversal(ret, step, rng)
+                                } else if tmpl, isTmpl := keyExpr.(*TemplateExpr); isTmpl && tmpl.IsStringLiteral() {
+                                        litKey, _ := tmpl.Value(nil)
+                                        rng := hcl.RangeBetween(open.Range, close.Range)
+                                        step := hcl.TraverseIndex{
+                                                Key:      litKey,
+                                                SrcRange: rng,
+                                        }
+                                        ret = makeRelativeTraversal(ret, step, rng)
                                } else {
                                        rng := hcl.RangeBetween(open.Range, close.Range)
                                        ret = &IndexExpr{
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/spec.md b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/spec.md
index 091c1c2..d7faeed 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/spec.md
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/spec.md
@@ -187,7 +187,7 @@ for later evaluation by the calling application.
 ### Blocks
 A _block_ creates a child body that is annotated with a block _type_ and
-zero or more block _labels_. Blocks create a structural hierachy which can be
+zero or more block _labels_. Blocks create a structural hierarchy which can be
 interpreted by the calling application.
 Block labels can either be quoted literal strings or naked identifiers.
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go b/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go
index bdc0e98..74847c7 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go
@@ -416,12 +416,14 @@ func (e *expression) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
        case *booleanVal:
                return cty.BoolVal(v.Value), nil
        case *arrayVal:
+                var diags hcl.Diagnostics
                vals := []cty.Value{}
                for _, jsonVal := range v.Values {
-                        val, _ := (&expression{src: jsonVal}).Value(ctx)
+                        val, valDiags := (&expression{src: jsonVal}).Value(ctx)
                        vals = append(vals, val)
+                        diags = append(diags, valDiags...)
                }
-                return cty.TupleVal(vals), nil
+                return cty.TupleVal(vals), diags
        case *objectVal:
                var diags hcl.Diagnostics
                attrs := map[string]cty.Value{}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/spec.md b/vendor/github.com/hashicorp/hcl2/hcl/spec.md
index 8bbaff8..97ef613 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/spec.md
+++ b/vendor/github.com/hashicorp/hcl2/hcl/spec.md
@@ -66,7 +66,7 @@ _block header schemata_:
 Within a schema, it is an error to request the same attribute name twice or
 to request a block type whose name is also an attribute name. While this can
 in principle be supported in some syntaxes, in other syntaxes the attribute
-and block namespaces are combined and so an an attribute cannot coexist with
+and block namespaces are combined and so an attribute cannot coexist with
 a block whose type name is identical to the attribute name.
 The result of applying a body schema to a body is _body content_, which
@@ -497,7 +497,7 @@ producing an unknown value of the target type.
 Conversion of any value _to_ the dynamic pseudo-type is a no-op. The result
 is the input value, verbatim. This is the only situation where the conversion
-result value is not of the the given target type.
+result value is not of the given target type.
 ### Primitive Type Conversions
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/structure.go b/vendor/github.com/hashicorp/hcl2/hcl/structure.go
index b336f30..aab0945 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/structure.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/structure.go
@@ -33,9 +33,9 @@ type Blocks []*Block
 type Attributes map[string]*Attribute
 // Body is a container for attributes and blocks. It serves as the primary
-// unit of heirarchical structure within configuration.
+// unit of hierarchical structure within configuration.
 //
-// The content of a body cannot be meaningfully intepreted without a schema,
+// The content of a body cannot be meaningfully interpreted without a schema,
 // so Body represents the raw body content and has methods that allow the
 // content to be extracted in terms of a given schema.
 type Body interface {
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/traversal_for_expr.go b/vendor/github.com/hashicorp/hcl2/hcl/traversal_for_expr.go
index d4a565a..f69d5fe 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/traversal_for_expr.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/traversal_for_expr.go
@@ -36,7 +36,7 @@ func AbsTraversalForExpr(expr Expression) (Traversal, Diagnostics) {
                &Diagnostic{
                        Severity: DiagError,
                        Summary:  "Invalid expression",
-                        Detail:   "A static variable reference is required.",
+                        Detail:   "A single static variable reference is required: only attribute access and indexing with constant keys. No calculations, function calls, template expressions, etc are allowed here.",
                        Subject:  expr.Range().Ptr(),
                },
        }
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/format.go b/vendor/github.com/hashicorp/hcl2/hclwrite/format.go
index f20ae23..ded7fb4 100644
--- a/vendor/github.com/hashicorp/hcl2/hclwrite/format.go
+++ b/vendor/github.com/hashicorp/hcl2/hclwrite/format.go
@@ -54,22 +54,12 @@ func formatIndent(lines []formatLine) {
        // which should be more than enough for reasonable HCL uses.
        indents := make([]int, 0, 10)
-        inHeredoc := false
        for i := range lines {
                line := &lines[i]
                if len(line.lead) == 0 {
                        continue
                }
-                if inHeredoc {
-                        for _, token := range line.lead {
-                                if token.Type == hclsyntax.TokenCHeredoc {
-                                        inHeredoc = false
-                                }
-                        }
-                        continue // don't touch indentation inside heredocs
-                }
                if line.lead[0].Type == hclsyntax.TokenNewline {
                        // Never place spaces before a newline
                        line.lead[0].SpacesBefore = 0
@@ -80,9 +70,10 @@ func formatIndent(lines []formatLine) {
                for _, token := range line.lead {
                        netBrackets += tokenBracketChange(token)
                        if token.Type == hclsyntax.TokenOHeredoc {
-                                inHeredoc = true
+                                break
                        }
                }
                for _, token := range line.assign {
                        netBrackets += tokenBracketChange(token)
                }
@@ -391,9 +382,9 @@ func linesForFormat(tokens Tokens) []formatLine {
        // Now we'll pick off any trailing comments and attribute assignments
        // to shuffle off into the "comment" and "assign" cells.
-        inHeredoc := false
        for i := range lines {
                line := &lines[i]
                if len(line.lead) == 0 {
                        // if the line is empty then there's nothing for us to do
                        // (this should happen only for the final line, because all other
@@ -401,26 +392,6 @@ func linesForFormat(tokens Tokens) []formatLine {
                        continue
                }
-                if inHeredoc {
-                        for _, tok := range line.lead {
-                                if tok.Type == hclsyntax.TokenCHeredoc {
-                                        inHeredoc = false
-                                        break
-                                }
-                        }
-                        // Inside a heredoc everything is "lead", even if there's a
-                        // template interpolation embedded in there that might otherwise
-                        // confuse our logic below.
-                        continue
-                }
-                for _, tok := range line.lead {
-                        if tok.Type == hclsyntax.TokenOHeredoc {
-                                inHeredoc = true
-                                break
-                        }
-                }
                if len(line.lead) > 1 && line.lead[len(line.lead)-1].Type == hclsyntax.TokenComment {
                        line.comment = line.lead[len(line.lead)-1:]
                        line.lead = line.lead[:len(line.lead)-1]
diff --git a/vendor/github.com/hashicorp/terraform/addrs/for_each_attr.go b/vendor/github.com/hashicorp/terraform/addrs/for_each_attr.go
new file mode 100644
index 0000000..7a63850
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/addrs/for_each_attr.go
@@ -0,0 +1,12 @@
+package addrs
+// ForEachAttr is the address of an attribute referencing the current "for_each" object in
+// the interpolation scope, addressed using the "each" keyword, ex. "each.key" and "each.value"
+type ForEachAttr struct {
+        referenceable
+        Name string
+}
+func (f ForEachAttr) String() string {
+        return "each." + f.Name
+}
diff --git a/vendor/github.com/hashicorp/terraform/addrs/parse_ref.go b/vendor/github.com/hashicorp/terraform/addrs/parse_ref.go
index 84fe8a0..a230d0c 100644
--- a/vendor/github.com/hashicorp/terraform/addrs/parse_ref.go
+++ b/vendor/github.com/hashicorp/terraform/addrs/parse_ref.go
@@ -85,6 +85,14 @@ func parseRef(traversal hcl.Traversal) (*Reference, tfdiags.Diagnostics) {
                        Remaining:   remain,
                }, diags
+        case "each":
+                name, rng, remain, diags := parseSingleAttrRef(traversal)
+                return &Reference{
+                        Subject:     ForEachAttr{Name: name},
+                        SourceRange: tfdiags.SourceRangeFromHCL(rng),
+                        Remaining:   remain,
+                }, diags
        case "data":
                if len(traversal) < 3 {
                        diags = diags.Append(&hcl.Diagnostic{
diff --git a/vendor/github.com/hashicorp/terraform/command/format/plan.go b/vendor/github.com/hashicorp/terraform/command/format/plan.go
index 098653f..ef129a9 100644
--- a/vendor/github.com/hashicorp/terraform/command/format/plan.go
+++ b/vendor/github.com/hashicorp/terraform/command/format/plan.go
@@ -83,6 +83,10 @@ func NewPlan(changes *plans.Changes) *Plan {
                        continue
                }
+                if rc.Action == plans.NoOp {
+                        continue
+                }
                // For now we'll shim this to work with our old types.
                // TODO: Update for the new plan types, ideally also switching over to
                // a structural diff renderer instead of a flat renderer.
diff --git a/vendor/github.com/hashicorp/terraform/command/format/state.go b/vendor/github.com/hashicorp/terraform/command/format/state.go
index f411ef9..be1ea24 100644
--- a/vendor/github.com/hashicorp/terraform/command/format/state.go
+++ b/vendor/github.com/hashicorp/terraform/command/format/state.go
@@ -75,11 +75,14 @@ func State(opts *StateOpts) string {
                        v := m.OutputValues[k]
                        p.buf.WriteString(fmt.Sprintf("%s = ", k))
                        p.writeValue(v.Value, plans.NoOp, 0)
-                        p.buf.WriteString("\n\n")
+                        p.buf.WriteString("\n")
                }
        }
-        return opts.Color.Color(strings.TrimSpace(p.buf.String()))
+        trimmedOutput := strings.TrimSpace(p.buf.String())
+        trimmedOutput += "[reset]"
+        return opts.Color.Color(trimmedOutput)
 }
@@ -95,81 +98,114 @@ func formatStateModule(p blockBodyDiffPrinter, m *states.Module, schemas *terraf
        // Go through each resource and begin building up the output.
        for _, key := range names {
                for k, v := range m.Resources[key].Instances {
+                        // keep these in order to keep the current object first, and
+                        // provide deterministic output for the deposed objects
+                        type obj struct {
+                                header   string
+                                instance *states.ResourceInstanceObjectSrc
+                        }
+                        instances := []obj{}
                        addr := m.Resources[key].Addr
                        taintStr := ""
-                        if v.Current.Status == 'T' {
+                        if v.Current != nil && v.Current.Status == 'T' {
-                                taintStr = "(tainted)"
+                                taintStr = " (tainted)"
                        }
-                        p.buf.WriteString(fmt.Sprintf("# %s: %s\n", addr.Absolute(m.Addr).Instance(k), taintStr))
+                        instances = append(instances,
-                        var schema *configschema.Block
+                                obj{fmt.Sprintf("# %s:%s\n", addr.Absolute(m.Addr).Instance(k), taintStr), v.Current})
-                        provider := m.Resources[key].ProviderConfig.ProviderConfig.StringCompact()
-                        if _, exists := schemas.Providers[provider]; !exists {
+                        for dk, v := range v.Deposed {
-                                // This should never happen in normal use because we should've
+                                instances = append(instances,
-                                // loaded all of the schemas and checked things prior to this
+                                        obj{fmt.Sprintf("# %s: (deposed object %s)\n", addr.Absolute(m.Addr).Instance(k), dk), v})
-                                // point. We can't return errors here, but since this is UI code
-                                // we will try to do _something_ reasonable.
-                                p.buf.WriteString(fmt.Sprintf("# missing schema for provider %q\n\n", provider))
-                                continue
                        }
-                        switch addr.Mode {
+                        // Sort the instances for consistent output.
-                        case addrs.ManagedResourceMode:
+                        // Starting the sort from the second index, so the current instance
-                                schema, _ = schemas.ResourceTypeConfig(
+                        // is always first.
-                                        provider,
+                        sort.Slice(instances[1:], func(i, j int) bool {
-                                        addr.Mode,
+                                return instances[i+1].header < instances[j+1].header
-                                        addr.Type,
+                        })
-                                )
-                                if schema == nil {
+                        for _, obj := range instances {
-                                        p.buf.WriteString(fmt.Sprintf(
+                                header := obj.header
-                                                "# missing schema for provider %q resource type %s\n\n", provider, addr.Type))
+                                instance := obj.instance
+                                p.buf.WriteString(header)
+                                if instance == nil {
+                                        // this shouldn't happen, but there's nothing to do here so
+                                        // don't panic below.
                                        continue
                                }
-                                p.buf.WriteString(fmt.Sprintf(
+                                var schema *configschema.Block
-                                        "resource %q %q {",
+                                provider := m.Resources[key].ProviderConfig.ProviderConfig.StringCompact()
-                                        addr.Type,
+                                if _, exists := schemas.Providers[provider]; !exists {
-                                        addr.Name,
+                                        // This should never happen in normal use because we should've
-                                ))
+                                        // loaded all of the schemas and checked things prior to this
-                        case addrs.DataResourceMode:
+                                        // point. We can't return errors here, but since this is UI code
-                                schema, _ = schemas.ResourceTypeConfig(
+                                        // we will try to do _something_ reasonable.
-                                        provider,
+                                        p.buf.WriteString(fmt.Sprintf("# missing schema for provider %q\n\n", provider))
-                                        addr.Mode,
-                                        addr.Type,
-                                )
-                                if schema == nil {
-                                        p.buf.WriteString(fmt.Sprintf(
-                                                "# missing schema for provider %q data source %s\n\n", provider, addr.Type))
                                        continue
                                }
-                                p.buf.WriteString(fmt.Sprintf(
+                                switch addr.Mode {
-                                        "data %q %q {",
+                                case addrs.ManagedResourceMode:
-                                        addr.Type,
+                                        schema, _ = schemas.ResourceTypeConfig(
-                                        addr.Name,
+                                                provider,
-                                ))
+                                                addr.Mode,
-                        default:
+                                                addr.Type,
-                                // should never happen, since the above is exhaustive
+                                        )
-                                p.buf.WriteString(addr.String())
+                                        if schema == nil {
-                        }
+                                                p.buf.WriteString(fmt.Sprintf(
+                                                        "# missing schema for provider %q resource type %s\n\n", provider, addr.Type))
+                                                continue
+                                        }
-                        val, err := v.Current.Decode(schema.ImpliedType())
+                                        p.buf.WriteString(fmt.Sprintf(
-                        if err != nil {
+                                                "resource %q %q {",
-                                fmt.Println(err.Error())
+                                                addr.Type,
-                                break
+                                                addr.Name,
-                        }
+                                        ))
+                                case addrs.DataResourceMode:
+                                        schema, _ = schemas.ResourceTypeConfig(
+                                                provider,
+                                                addr.Mode,
+                                                addr.Type,
+                                        )
+                                        if schema == nil {
+                                                p.buf.WriteString(fmt.Sprintf(
+                                                        "# missing schema for provider %q data source %s\n\n", provider, addr.Type))
+                                                continue
+                                        }
-                        path := make(cty.Path, 0, 3)
+                                        p.buf.WriteString(fmt.Sprintf(
-                        bodyWritten := p.writeBlockBodyDiff(schema, val.Value, val.Value, 2, path)
+                                                "data %q %q {",
-                        if bodyWritten {
+                                                addr.Type,
-                                p.buf.WriteString("\n")
+                                                addr.Name,
-                        }
+                                        ))
+                                default:
+                                        // should never happen, since the above is exhaustive
+                                        p.buf.WriteString(addr.String())
+                                }
-                        p.buf.WriteString("}\n\n")
+                                val, err := instance.Decode(schema.ImpliedType())
+                                if err != nil {
+                                        fmt.Println(err.Error())
+                                        break
+                                }
+                                path := make(cty.Path, 0, 3)
+                                bodyWritten := p.writeBlockBodyDiff(schema, val.Value, val.Value, 2, path)
+                                if bodyWritten {
+                                        p.buf.WriteString("\n")
+                                }
+                                p.buf.WriteString("}\n\n")
+                        }
                }
        }
-        p.buf.WriteString("[reset]\n")
+        p.buf.WriteString("\n")
 }
 func formatNestedList(indent string, outputList []interface{}) string {
@@ -231,7 +267,7 @@ func formatListOutput(indent, outputName string, outputList []interface{}) strin
 func formatNestedMap(indent string, outputMap map[string]interface{}) string {
        ks := make([]string, 0, len(outputMap))
-        for k, _ := range outputMap {
+        for k := range outputMap {
                ks = append(ks, k)
        }
        sort.Strings(ks)
@@ -256,7 +292,7 @@ func formatNestedMap(indent string, outputMap map[string]interface{}) string {
 func formatMapOutput(indent, outputName string, outputMap map[string]interface{}) string {
        ks := make([]string, 0, len(outputMap))
-        for k, _ := range outputMap {
+        for k := range outputMap {
                ks = append(ks, k)
        }
        sort.Strings(ks)
diff --git a/vendor/github.com/hashicorp/terraform/config/config.go b/vendor/github.com/hashicorp/terraform/config/config.go
index 1772fd7..f13a046 100644
--- a/vendor/github.com/hashicorp/terraform/config/config.go
+++ b/vendor/github.com/hashicorp/terraform/config/config.go
@@ -252,35 +252,6 @@ func (r *Resource) Id() string {
        }
 }
-// ProviderFullName returns the full name of the provider for this resource,
-// which may either be specified explicitly using the "provider" meta-argument
-// or implied by the prefix on the resource type name.
-func (r *Resource) ProviderFullName() string {
-        return ResourceProviderFullName(r.Type, r.Provider)
-}
-// ResourceProviderFullName returns the full (dependable) name of the
-// provider for a hypothetical resource with the given resource type and
-// explicit provider string. If the explicit provider string is empty then
-// the provider name is inferred from the resource type name.
-func ResourceProviderFullName(resourceType, explicitProvider string) string {
-        if explicitProvider != "" {
-                // check for an explicit provider name, or return the original
-                parts := strings.SplitAfter(explicitProvider, "provider.")
-                return parts[len(parts)-1]
-        }
-        idx := strings.IndexRune(resourceType, '_')
-        if idx == -1 {
-                // If no underscores, the resource name is assumed to be
-                // also the provider name, e.g. if the provider exposes
-                // only a single resource of each type.
-                return resourceType
-        }
-        return resourceType[:idx]
-}
 // Validate does some basic semantic checking of the configuration.
 func (c *Config) Validate() tfdiags.Diagnostics {
        if c == nil {
diff --git a/vendor/github.com/hashicorp/terraform/config/interpolate_walk.go b/vendor/github.com/hashicorp/terraform/config/interpolate_walk.go
index 66a677d..ce33ab1 100644
--- a/vendor/github.com/hashicorp/terraform/config/interpolate_walk.go
+++ b/vendor/github.com/hashicorp/terraform/config/interpolate_walk.go
@@ -7,6 +7,7 @@ import (
        "github.com/hashicorp/hil"
        "github.com/hashicorp/hil/ast"
+        "github.com/hashicorp/terraform/config/hcl2shim"
        "github.com/mitchellh/reflectwalk"
 )
@@ -160,7 +161,7 @@ func (w *interpolationWalker) Primitive(v reflect.Value) error {
                if w.loc == reflectwalk.SliceElem {
                        switch typedReplaceVal := replaceVal.(type) {
                        case string:
-                                if typedReplaceVal == UnknownVariableValue {
+                                if typedReplaceVal == hcl2shim.UnknownVariableValue {
                                        remove = true
                                }
                        case []interface{}:
@@ -168,7 +169,7 @@ func (w *interpolationWalker) Primitive(v reflect.Value) error {
                                        remove = true
                                }
                        }
-                } else if replaceVal == UnknownVariableValue {
+                } else if replaceVal == hcl2shim.UnknownVariableValue {
                        remove = true
                }
@@ -224,7 +225,7 @@ func (w *interpolationWalker) replaceCurrent(v reflect.Value) {
 func hasUnknownValue(variable []interface{}) bool {
        for _, value := range variable {
                if strVal, ok := value.(string); ok {
-                        if strVal == UnknownVariableValue {
+                        if strVal == hcl2shim.UnknownVariableValue {
                                return true
                        }
                }
diff --git a/vendor/github.com/hashicorp/terraform/config/loader.go b/vendor/github.com/hashicorp/terraform/config/loader.go
index 6e34781..612e25b 100644
--- a/vendor/github.com/hashicorp/terraform/config/loader.go
+++ b/vendor/github.com/hashicorp/terraform/config/loader.go
@@ -135,21 +135,6 @@ func LoadDir(root string) (*Config, error) {
        return result, nil
 }
-// IsEmptyDir returns true if the directory given has no Terraform
-// configuration files.
-func IsEmptyDir(root string) (bool, error) {
-        if _, err := os.Stat(root); err != nil && os.IsNotExist(err) {
-                return true, nil
-        }
-        fs, os, err := dirFiles(root)
-        if err != nil {
-                return false, err
-        }
-        return len(fs) == 0 && len(os) == 0, nil
-}
 // Ext returns the Terraform configuration extension of the given
 // path, or a blank string if it is an invalid function.
 func ext(path string) string {
diff --git a/vendor/github.com/hashicorp/terraform/config/module/versions.go b/vendor/github.com/hashicorp/terraform/config/module/versions.go
index 8348d4b..29701b9 100644
--- a/vendor/github.com/hashicorp/terraform/config/module/versions.go
+++ b/vendor/github.com/hashicorp/terraform/config/module/versions.go
@@ -3,7 +3,9 @@ package module
 import (
        "errors"
        "fmt"
+        "regexp"
        "sort"
+        "strings"
        version "github.com/hashicorp/go-version"
        "github.com/hashicorp/terraform/registry/response"
@@ -11,6 +13,8 @@ import (
 const anyVersion = ">=0.0.0"
+var explicitEqualityConstraint = regexp.MustCompile("^=[0-9]")
 // return the newest version that satisfies the provided constraint
 func newest(versions []string, constraint string) (string, error) {
        if constraint == "" {
@@ -21,6 +25,30 @@ func newest(versions []string, constraint string) (string, error) {
                return "", err
        }
+        // Find any build metadata in the constraints, and
+        // store whether the constraint is an explicit equality that
+        // contains a build metadata requirement, so we can return a specific,
+        // if requested, build metadata version
+        var constraintMetas []string
+        var equalsConstraint bool
+        for i := range cs {
+                constraintMeta := strings.SplitAfterN(cs[i].String(), "+", 2)
+                if len(constraintMeta) > 1 {
+                        constraintMetas = append(constraintMetas, constraintMeta[1])
+                }
+        }
+        if len(cs) == 1 {
+                equalsConstraint = explicitEqualityConstraint.MatchString(cs.String())
+        }
+        // If the version string includes metadata, this is valid in go-version,
+        // However, it's confusing as to what expected behavior should be,
+        // so give an error so the user can do something more logical
+        if (len(cs) > 1 || !equalsConstraint) && len(constraintMetas) > 0 {
+                return "", fmt.Errorf("Constraints including build metadata must have explicit equality, or are otherwise too ambiguous: %s", cs.String())
+        }
        switch len(versions) {
        case 0:
                return "", errors.New("no versions found")
@@ -58,6 +86,12 @@ func newest(versions []string, constraint string) (string, error) {
                        continue
                }
                if cs.Check(v) {
+                        // Constraint has metadata and is explicit equality
+                        if equalsConstraint && len(constraintMetas) > 0 {
+                                if constraintMetas[0] != v.Metadata() {
+                                        continue
+                                }
+                        }
                        return versions[i], nil
                }
        }
diff --git a/vendor/github.com/hashicorp/terraform/config/providers.go b/vendor/github.com/hashicorp/terraform/config/providers.go
index 7a50782..eeddabc 100644
--- a/vendor/github.com/hashicorp/terraform/config/providers.go
+++ b/vendor/github.com/hashicorp/terraform/config/providers.go
@@ -13,48 +13,6 @@ type ProviderVersionConstraint struct {
 // ProviderVersionConstraint, as produced by Config.RequiredProviders.
 type ProviderVersionConstraints map[string]ProviderVersionConstraint
-// RequiredProviders returns the ProviderVersionConstraints for this
-// module.
-//
-// This includes both providers that are explicitly requested by provider
-// blocks and those that are used implicitly by instantiating one of their
-// resource types. In the latter case, the returned semver Range will
-// accept any version of the provider.
-func (c *Config) RequiredProviders() ProviderVersionConstraints {
-        ret := make(ProviderVersionConstraints, len(c.ProviderConfigs))
-        configs := c.ProviderConfigsByFullName()
-        // In order to find the *implied* dependencies (those without explicit
-        // "provider" blocks) we need to walk over all of the resources and
-        // cross-reference with the provider configs.
-        for _, rc := range c.Resources {
-                providerName := rc.ProviderFullName()
-                var providerType string
-                // Default to (effectively) no constraint whatsoever, but we might
-                // override if there's an explicit constraint in config.
-                constraint := ">=0.0.0"
-                config, ok := configs[providerName]
-                if ok {
-                        if config.Version != "" {
-                                constraint = config.Version
-                        }
-                        providerType = config.Name
-                } else {
-                        providerType = providerName
-                }
-                ret[providerName] = ProviderVersionConstraint{
-                        ProviderType: providerType,
-                        Constraint:   constraint,
-                }
-        }
-        return ret
-}
 // RequiredRanges returns a semver.Range for each distinct provider type in
 // the constraint map. If the same provider type appears more than once
 // (e.g. because aliases are in use) then their respective constraints are
diff --git a/vendor/github.com/hashicorp/terraform/config/raw_config.go b/vendor/github.com/hashicorp/terraform/config/raw_config.go
index 1854a8b..c5ac86d 100644
--- a/vendor/github.com/hashicorp/terraform/config/raw_config.go
+++ b/vendor/github.com/hashicorp/terraform/config/raw_config.go
@@ -17,12 +17,6 @@ import (
        "github.com/mitchellh/reflectwalk"
 )
-// UnknownVariableValue is a sentinel value that can be used
-// to denote that the value of a variable is unknown at this time.
-// RawConfig uses this information to build up data about
-// unknown keys.
-const UnknownVariableValue = "74D93920-ED26-11E3-AC10-0800200C9A66"
 // RawConfig is a structure that holds a piece of configuration
 // where the overall structure is unknown since it will be used
 // to configure a plugin or some other similar external component.
diff --git a/vendor/github.com/hashicorp/terraform/configs/config_build.go b/vendor/github.com/hashicorp/terraform/configs/config_build.go
index 948b2c8..1ca1d77 100644
--- a/vendor/github.com/hashicorp/terraform/configs/config_build.go
+++ b/vendor/github.com/hashicorp/terraform/configs/config_build.go
@@ -76,6 +76,7 @@ func buildChildModules(parent *Config, walker ModuleWalker) (map[string]*Config,
                }
                child.Children, modDiags = buildChildModules(child, walker)
+                diags = append(diags, modDiags...)
                ret[call.Name] = child
        }
diff --git a/vendor/github.com/hashicorp/terraform/configs/configload/getter.go b/vendor/github.com/hashicorp/terraform/configs/configload/getter.go
index 4a3dace..75c7ef1 100644
--- a/vendor/github.com/hashicorp/terraform/configs/configload/getter.go
+++ b/vendor/github.com/hashicorp/terraform/configs/configload/getter.go
@@ -20,6 +20,7 @@ import (
 var goGetterDetectors = []getter.Detector{
        new(getter.GitHubDetector),
        new(getter.BitBucketDetector),
+        new(getter.GCSDetector),
        new(getter.S3Detector),
        new(getter.FileDetector),
 }
@@ -44,6 +45,7 @@ var goGetterDecompressors = map[string]getter.Decompressor{
 var goGetterGetters = map[string]getter.Getter{
        "file":  new(getter.FileGetter),
+        "gcs":   new(getter.GCSGetter),
        "git":   new(getter.GitGetter),
        "hg":    new(getter.HgGetter),
        "s3":    new(getter.S3Getter),
diff --git a/vendor/github.com/hashicorp/terraform/configs/configload/loader_load.go b/vendor/github.com/hashicorp/terraform/configs/configload/loader_load.go
index 93a9420..0e6cba9 100644
--- a/vendor/github.com/hashicorp/terraform/configs/configload/loader_load.go
+++ b/vendor/github.com/hashicorp/terraform/configs/configload/loader_load.go
@@ -64,7 +64,15 @@ func (l *Loader) moduleWalkerLoad(req *configs.ModuleRequest) (*configs.Module,
                        Subject:  &req.SourceAddrRange,
                })
        }
-        if !req.VersionConstraint.Required.Check(record.Version) {
+        if len(req.VersionConstraint.Required) > 0 && record.Version == nil {
+                diags = append(diags, &hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Module version requirements have changed",
+                        Detail:   "The version requirements have changed since this module was installed and the installed version is no longer acceptable. Run \"terraform init\" to install all modules required by this configuration.",
+                        Subject:  &req.SourceAddrRange,
+                })
+        }
+        if record.Version != nil && !req.VersionConstraint.Required.Check(record.Version) {
                diags = append(diags, &hcl.Diagnostic{
                        Severity: hcl.DiagError,
                        Summary:  "Module version requirements have changed",
diff --git a/vendor/github.com/hashicorp/terraform/configs/configschema/coerce_value.go b/vendor/github.com/hashicorp/terraform/configs/configschema/coerce_value.go
index e59f58d..7996c38 100644
--- a/vendor/github.com/hashicorp/terraform/configs/configschema/coerce_value.go
+++ b/vendor/github.com/hashicorp/terraform/configs/configschema/coerce_value.go
@@ -113,7 +113,10 @@ func (b *Block) coerceValue(in cty.Value, path cty.Path) (cty.Value, error) {
                                        return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("must be a list")
                                }
                                l := coll.LengthInt()
-                                if l < blockS.MinItems {
+                                // Assume that if there are unknowns this could have come from
+                                // a dynamic block, and we can't validate MinItems yet.
+                                if l < blockS.MinItems && coll.IsWhollyKnown() {
                                        return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("insufficient items for attribute %q; must have at least %d", typeName, blockS.MinItems)
                                }
                                if l > blockS.MaxItems && blockS.MaxItems > 0 {
@@ -161,7 +164,10 @@ func (b *Block) coerceValue(in cty.Value, path cty.Path) (cty.Value, error) {
                                        return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("must be a set")
                                }
                                l := coll.LengthInt()
-                                if l < blockS.MinItems {
+                                // Assume that if there are unknowns this could have come from
+                                // a dynamic block, and we can't validate MinItems yet.
+                                if l < blockS.MinItems && coll.IsWhollyKnown() {
                                        return cty.UnknownVal(b.ImpliedType()), path.NewErrorf("insufficient items for attribute %q; must have at least %d", typeName, blockS.MinItems)
                                }
                                if l > blockS.MaxItems && blockS.MaxItems > 0 {
diff --git a/vendor/github.com/hashicorp/terraform/configs/configschema/decoder_spec.go b/vendor/github.com/hashicorp/terraform/configs/configschema/decoder_spec.go
index d8f41ea..e748dd2 100644
--- a/vendor/github.com/hashicorp/terraform/configs/configschema/decoder_spec.go
+++ b/vendor/github.com/hashicorp/terraform/configs/configschema/decoder_spec.go
@@ -33,6 +33,14 @@ func (b *Block) DecoderSpec() hcldec.Spec {
                childSpec := blockS.Block.DecoderSpec()
+                // We can only validate 0 or 1 for MinItems, because a dynamic block
+                // may satisfy any number of min items while only having a single
+                // block in the config.
+                minItems := 0
+                if blockS.MinItems > 1 {
+                        minItems = 1
+                }
                switch blockS.Nesting {
                case NestingSingle, NestingGroup:
                        ret[name] = &hcldec.BlockSpec{
@@ -57,14 +65,14 @@ func (b *Block) DecoderSpec() hcldec.Spec {
                                ret[name] = &hcldec.BlockTupleSpec{
                                        TypeName: name,
                                        Nested:   childSpec,
-                                        MinItems: blockS.MinItems,
+                                        MinItems: minItems,
                                        MaxItems: blockS.MaxItems,
                                }
                        } else {
                                ret[name] = &hcldec.BlockListSpec{
                                        TypeName: name,
                                        Nested:   childSpec,
-                                        MinItems: blockS.MinItems,
+                                        MinItems: minItems,
                                        MaxItems: blockS.MaxItems,
                                }
                        }
@@ -77,7 +85,7 @@ func (b *Block) DecoderSpec() hcldec.Spec {
                        ret[name] = &hcldec.BlockSetSpec{
                                TypeName: name,
                                Nested:   childSpec,
-                                MinItems: blockS.MinItems,
+                                MinItems: minItems,
                                MaxItems: blockS.MaxItems,
                        }
                case NestingMap:
diff --git a/vendor/github.com/hashicorp/terraform/configs/parser_config_dir.go b/vendor/github.com/hashicorp/terraform/configs/parser_config_dir.go
index 3014cb4..752d6d9 100644
--- a/vendor/github.com/hashicorp/terraform/configs/parser_config_dir.go
+++ b/vendor/github.com/hashicorp/terraform/configs/parser_config_dir.go
@@ -2,6 +2,7 @@ package configs
 import (
        "fmt"
+        "os"
        "path/filepath"
        "strings"
@@ -140,3 +141,23 @@ func IsIgnoredFile(name string) bool {
                strings.HasSuffix(name, "~") || // vim
                strings.HasPrefix(name, "#") && strings.HasSuffix(name, "#") // emacs
 }
+// IsEmptyDir returns true if the given filesystem path contains no Terraform
+// configuration files.
+//
+// Unlike the methods of the Parser type, this function always consults the
+// real filesystem, and thus it isn't appropriate to use when working with
+// configuration loaded from a plan file.
+func IsEmptyDir(path string) (bool, error) {
+        if _, err := os.Stat(path); err != nil && os.IsNotExist(err) {
+                return true, nil
+        }
+        p := NewParser(nil)
+        fs, os, err := p.dirFiles(path)
+        if err != nil {
+                return false, err
+        }
+        return len(fs) == 0 && len(os) == 0, nil
+}
diff --git a/vendor/github.com/hashicorp/terraform/configs/resource.go b/vendor/github.com/hashicorp/terraform/configs/resource.go
index de1a343..edf822c 100644
--- a/vendor/github.com/hashicorp/terraform/configs/resource.go
+++ b/vendor/github.com/hashicorp/terraform/configs/resource.go
@@ -111,13 +111,15 @@ func decodeResourceBlock(block *hcl.Block) (*Resource, hcl.Diagnostics) {
        if attr, exists := content.Attributes["for_each"]; exists {
                r.ForEach = attr.Expr
-                // We currently parse this, but don't yet do anything with it.
+                // Cannot have count and for_each on the same resource block
-                diags = append(diags, &hcl.Diagnostic{
+                if r.Count != nil {
-                        Severity: hcl.DiagError,
+                        diags = append(diags, &hcl.Diagnostic{
-                        Summary:  "Reserved argument name in resource block",
+                                Severity: hcl.DiagError,
-                        Detail:   fmt.Sprintf("The name %q is reserved for use in a future version of Terraform.", attr.Name),
+                                Summary:  `Invalid combination of "count" and "for_each"`,
-                        Subject:  &attr.NameRange,
+                                Detail:   `The "count" and "for_each" meta-arguments are mutually-exclusive, only one should be used to be explicit about the number of resources to be created.`,
-                })
+                                Subject:  &attr.NameRange,
+                        })
+                }
        }
        if attr, exists := content.Attributes["provider"]; exists {
@@ -300,13 +302,15 @@ func decodeDataBlock(block *hcl.Block) (*Resource, hcl.Diagnostics) {
        if attr, exists := content.Attributes["for_each"]; exists {
                r.ForEach = attr.Expr
-                // We currently parse this, but don't yet do anything with it.
+                // Cannot have count and for_each on the same data block
-                diags = append(diags, &hcl.Diagnostic{
+                if r.Count != nil {
-                        Severity: hcl.DiagError,
+                        diags = append(diags, &hcl.Diagnostic{
-                        Summary:  "Reserved argument name in module block",
+                                Severity: hcl.DiagError,
-                        Detail:   fmt.Sprintf("The name %q is reserved for use in a future version of Terraform.", attr.Name),
+                                Summary:  `Invalid combination of "count" and "for_each"`,
-                        Subject:  &attr.NameRange,
+                                Detail:   `The "count" and "for_each" meta-arguments are mutually-exclusive, only one should be used to be explicit about the number of resources to be created.`,
-                })
+                                Subject:  &attr.NameRange,
+                        })
+                }
        }
        if attr, exists := content.Attributes["provider"]; exists {
diff --git a/vendor/github.com/hashicorp/terraform/configs/version_constraint.go b/vendor/github.com/hashicorp/terraform/configs/version_constraint.go
index 7aa19ef..e40ce16 100644
--- a/vendor/github.com/hashicorp/terraform/configs/version_constraint.go
+++ b/vendor/github.com/hashicorp/terraform/configs/version_constraint.go
@@ -45,6 +45,13 @@ func decodeVersionConstraint(attr *hcl.Attribute) (VersionConstraint, hcl.Diagno
                return ret, diags
        }
+        if !val.IsWhollyKnown() {
+                // If there is a syntax error, HCL sets the value of the given attribute
+                // to cty.DynamicVal. A diagnostic for the syntax error will already
+                // bubble up, so we will move forward gracefully here.
+                return ret, diags
+        }
        constraintStr := val.AsString()
        constraints, err := version.NewConstraint(constraintStr)
        if err != nil {
diff --git a/vendor/github.com/hashicorp/terraform/helper/plugin/grpc_provider.go b/vendor/github.com/hashicorp/terraform/helper/plugin/grpc_provider.go
index 510f47f..104c8f5 100644
--- a/vendor/github.com/hashicorp/terraform/helper/plugin/grpc_provider.go
+++ b/vendor/github.com/hashicorp/terraform/helper/plugin/grpc_provider.go
@@ -2,7 +2,6 @@ package plugin
 import (
        "encoding/json"
-        "errors"
        "fmt"
        "log"
        "strconv"
@@ -16,6 +15,7 @@ import (
        "github.com/hashicorp/terraform/configs/configschema"
        "github.com/hashicorp/terraform/helper/schema"
        proto "github.com/hashicorp/terraform/internal/tfplugin5"
+        "github.com/hashicorp/terraform/plans/objchange"
        "github.com/hashicorp/terraform/plugin/convert"
        "github.com/hashicorp/terraform/terraform"
 )
@@ -284,6 +284,17 @@ func (s *GRPCProviderServer) UpgradeResourceState(_ context.Context, req *proto.
                return resp, nil
        }
+        // Now we need to make sure blocks are represented correctly, which means
+        // that missing blocks are empty collections, rather than null.
+        // First we need to CoerceValue to ensure that all object types match.
+        val, err = schemaBlock.CoerceValue(val)
+        if err != nil {
+                resp.Diagnostics = convert.AppendProtoDiag(resp.Diagnostics, err)
+                return resp, nil
+        }
+        // Normalize the value and fill in any missing blocks.
+        val = objchange.NormalizeObjectFromLegacySDK(val, schemaBlock)
        // encode the final state to the expected msgpack format
        newStateMP, err := msgpack.Marshal(val, schemaBlock.ImpliedType())
        if err != nil {
@@ -316,11 +327,15 @@ func (s *GRPCProviderServer) upgradeFlatmapState(version int, m map[string]strin
                requiresMigrate = version < res.StateUpgraders[0].Version
        }
-        if requiresMigrate {
+        if requiresMigrate && res.MigrateState == nil {
-                if res.MigrateState == nil {
+                // Providers were previously allowed to bump the version
-                        return nil, 0, errors.New("cannot upgrade state, missing MigrateState function")
+                // without declaring MigrateState.
+                // If there are further upgraders, then we've only updated that far.
+                if len(res.StateUpgraders) > 0 {
+                        schemaType = res.StateUpgraders[0].Type
+                        upgradedVersion = res.StateUpgraders[0].Version
                }
+        } else if requiresMigrate {
                is := &terraform.InstanceState{
                        ID:         m["id"],
                        Attributes: m,
@@ -476,7 +491,12 @@ func (s *GRPCProviderServer) Configure(_ context.Context, req *proto.Configure_R
 }
 func (s *GRPCProviderServer) ReadResource(_ context.Context, req *proto.ReadResource_Request) (*proto.ReadResource_Response, error) {
-        resp := &proto.ReadResource_Response{}
+        resp := &proto.ReadResource_Response{
+                // helper/schema did previously handle private data during refresh, but
+                // core is now going to expect this to be maintained in order to
+                // persist it in the state.
+                Private: req.Private,
+        }
        res := s.provider.ResourcesMap[req.TypeName]
        schemaBlock := s.getResourceSchemaBlock(req.TypeName)
@@ -493,6 +513,15 @@ func (s *GRPCProviderServer) ReadResource(_ context.Context, req *proto.ReadReso
                return resp, nil
        }
+        private := make(map[string]interface{})
+        if len(req.Private) > 0 {
+                if err := json.Unmarshal(req.Private, &private); err != nil {
+                        resp.Diagnostics = convert.AppendProtoDiag(resp.Diagnostics, err)
+                        return resp, nil
+                }
+        }
+        instanceState.Meta = private
        newInstanceState, err := res.RefreshWithoutUpgrade(instanceState, s.provider.Meta())
        if err != nil {
                resp.Diagnostics = convert.AppendProtoDiag(resp.Diagnostics, err)
@@ -569,6 +598,7 @@ func (s *GRPCProviderServer) PlanResourceChange(_ context.Context, req *proto.Pl
        // We don't usually plan destroys, but this can return early in any case.
        if proposedNewStateVal.IsNull() {
                resp.PlannedState = req.ProposedNewState
+                resp.PlannedPrivate = req.PriorPrivate
                return resp, nil
        }
@@ -623,6 +653,7 @@ func (s *GRPCProviderServer) PlanResourceChange(_ context.Context, req *proto.Pl
                // description that _shows_ there are no changes. This is always the
                // prior state, because we force a diff above if this is a new instance.
                resp.PlannedState = req.PriorState
+                resp.PlannedPrivate = req.PriorPrivate
                return resp, nil
        }
@@ -683,6 +714,18 @@ func (s *GRPCProviderServer) PlanResourceChange(_ context.Context, req *proto.Pl
                Msgpack: plannedMP,
        }
+        // encode any timeouts into the diff Meta
+        t := &schema.ResourceTimeout{}
+        if err := t.ConfigDecode(res, cfg); err != nil {
+                resp.Diagnostics = convert.AppendProtoDiag(resp.Diagnostics, err)
+                return resp, nil
+        }
+        if err := t.DiffEncode(diff); err != nil {
+                resp.Diagnostics = convert.AppendProtoDiag(resp.Diagnostics, err)
+                return resp, nil
+        }
        // Now we need to store any NewExtra values, which are where any actual
        // StateFunc modified config fields are hidden.
        privateMap := diff.Meta
@@ -929,6 +972,9 @@ func (s *GRPCProviderServer) ImportResourceState(_ context.Context, req *proto.I
                        return resp, nil
                }
+                // Normalize the value and fill in any missing blocks.
+                newStateVal = objchange.NormalizeObjectFromLegacySDK(newStateVal, schemaBlock)
                newStateMP, err := msgpack.Marshal(newStateVal, schemaBlock.ImpliedType())
                if err != nil {
                        resp.Diagnostics = convert.AppendProtoDiag(resp.Diagnostics, err)
@@ -1160,6 +1206,8 @@ func normalizeNullValues(dst, src cty.Value, apply bool) cty.Value {
                }
        }
+        // check the invariants that we need below, to ensure we are working with
+        // non-null and known values.
        if src.IsNull() || !src.IsKnown() || !dst.IsKnown() {
                return dst
        }
@@ -1278,8 +1326,12 @@ func normalizeNullValues(dst, src cty.Value, apply bool) cty.Value {
                        return cty.ListVal(dsts)
                }
-        case ty.IsPrimitiveType():
+        case ty == cty.String:
-                if dst.IsNull() && src.IsWhollyKnown() && apply {
+                // The legacy SDK should not be able to remove a value during plan or
+                // apply, however we are only going to overwrite this if the source was
+                // an empty string, since that is what is often equated with unset and
+                // lost in the diff process.
+                if dst.IsNull() && src.AsString() == "" {
                        return src
                }
        }
@@ -1305,11 +1357,19 @@ func validateConfigNulls(v cty.Value, path cty.Path) []*proto.Diagnostic {
                for it.Next() {
                        kv, ev := it.Element()
                        if ev.IsNull() {
+                                // if this is a set, the kv is also going to be null which
+                                // isn't a valid path element, so we can't append it to the
+                                // diagnostic.
+                                p := path
+                                if !kv.IsNull() {
+                                        p = append(p, cty.IndexStep{Key: kv})
+                                }
                                diags = append(diags, &proto.Diagnostic{
                                        Severity:  proto.Diagnostic_ERROR,
                                        Summary:   "Null value found in list",
                                        Detail:    "Null values are not allowed for this attribute value.",
-                                        Attribute: convert.PathToAttributePath(append(path, cty.IndexStep{Key: kv})),
+                                        Attribute: convert.PathToAttributePath(p),
                                })
                                continue
                        }
diff --git a/vendor/github.com/hashicorp/terraform/helper/resource/state_shim.go b/vendor/github.com/hashicorp/terraform/helper/resource/state_shim.go
index b2aff99..f488207 100644
--- a/vendor/github.com/hashicorp/terraform/helper/resource/state_shim.go
+++ b/vendor/github.com/hashicorp/terraform/helper/resource/state_shim.go
@@ -1,6 +1,7 @@
 package resource
 import (
+        "encoding/json"
        "fmt"
        "github.com/hashicorp/terraform/addrs"
@@ -52,43 +53,57 @@ func shimNewState(newState *states.State, providers map[string]terraform.Resourc
                        resource := getResource(providers, providerType, res.Addr)
                        for key, i := range res.Instances {
-                                flatmap, err := shimmedAttributes(i.Current, resource)
+                                resState := &terraform.ResourceState{
-                                if err != nil {
+                                        Type:     resType,
-                                        return nil, fmt.Errorf("error decoding state for %q: %s", resType, err)
+                                        Provider: res.ProviderConfig.String(),
                                }
-                                resState := &terraform.ResourceState{
+                                // We should always have a Current instance here, but be safe about checking.
-                                        Type: resType,
+                                if i.Current != nil {
-                                        Primary: &terraform.InstanceState{
+                                        flatmap, err := shimmedAttributes(i.Current, resource)
+                                        if err != nil {
+                                                return nil, fmt.Errorf("error decoding state for %q: %s", resType, err)
+                                        }
+                                        var meta map[string]interface{}
+                                        if i.Current.Private != nil {
+                                                err := json.Unmarshal(i.Current.Private, &meta)
+                                                if err != nil {
+                                                        return nil, err
+                                                }
+                                        }
+                                        resState.Primary = &terraform.InstanceState{
                                                ID:         flatmap["id"],
                                                Attributes: flatmap,
                                                Tainted:    i.Current.Status == states.ObjectTainted,
-                                        },
+                                                Meta:       meta,
-                                        Provider: res.ProviderConfig.String(),
-                                }
-                                if i.Current.SchemaVersion != 0 {
-                                        resState.Primary.Meta = map[string]interface{}{
-                                                "schema_version": i.Current.SchemaVersion,
                                        }
-                                }
-                                for _, dep := range i.Current.Dependencies {
+                                        if i.Current.SchemaVersion != 0 {
-                                        resState.Dependencies = append(resState.Dependencies, dep.String())
+                                                resState.Primary.Meta = map[string]interface{}{
-                                }
+                                                        "schema_version": i.Current.SchemaVersion,
+                                                }
+                                        }
-                                // convert the indexes to the old style flapmap indexes
+                                        for _, dep := range i.Current.Dependencies {
-                                idx := ""
+                                                resState.Dependencies = append(resState.Dependencies, dep.String())
-                                switch key.(type) {
-                                case addrs.IntKey:
-                                        // don't add numeric index values to resources with a count of 0
-                                        if len(res.Instances) > 1 {
-                                                idx = fmt.Sprintf(".%d", key)
                                        }
-                                case addrs.StringKey:
-                                        idx = "." + key.String()
-                                }
-                                mod.Resources[res.Addr.String()+idx] = resState
+                                        // convert the indexes to the old style flapmap indexes
+                                        idx := ""
+                                        switch key.(type) {
+                                        case addrs.IntKey:
+                                                // don't add numeric index values to resources with a count of 0
+                                                if len(res.Instances) > 1 {
+                                                        idx = fmt.Sprintf(".%d", key)
+                                                }
+                                        case addrs.StringKey:
+                                                idx = "." + key.String()
+                                        }
+                                        mod.Resources[res.Addr.String()+idx] = resState
+                                }
                                // add any deposed instances
                                for _, dep := range i.Deposed {
@@ -97,10 +112,19 @@ func shimNewState(newState *states.State, providers map[string]terraform.Resourc
                                                return nil, fmt.Errorf("error decoding deposed state for %q: %s", resType, err)
                                        }
+                                        var meta map[string]interface{}
+                                        if dep.Private != nil {
+                                                err := json.Unmarshal(dep.Private, &meta)
+                                                if err != nil {
+                                                        return nil, err
+                                                }
+                                        }
                                        deposed := &terraform.InstanceState{
                                                ID:         flatmap["id"],
                                                Attributes: flatmap,
                                                Tainted:    dep.Status == states.ObjectTainted,
+                                                Meta:       meta,
                                        }
                                        if dep.SchemaVersion != 0 {
                                                deposed.Meta = map[string]interface{}{
diff --git a/vendor/github.com/hashicorp/terraform/helper/resource/testing_config.go b/vendor/github.com/hashicorp/terraform/helper/resource/testing_config.go
index 311fdb6..f34e17a 100644
--- a/vendor/github.com/hashicorp/terraform/helper/resource/testing_config.go
+++ b/vendor/github.com/hashicorp/terraform/helper/resource/testing_config.go
@@ -10,7 +10,6 @@ import (
        "strings"
        "github.com/hashicorp/terraform/addrs"
-        "github.com/hashicorp/terraform/config"
        "github.com/hashicorp/terraform/config/hcl2shim"
        "github.com/hashicorp/terraform/states"
@@ -341,7 +340,7 @@ func legacyDiffComparisonString(changes *plans.Changes) string {
                                v := newAttrs[attrK]
                                u := oldAttrs[attrK]
-                                if v == config.UnknownVariableValue {
+                                if v == hcl2shim.UnknownVariableValue {
                                        v = "<computed>"
                                }
                                // NOTE: we don't support <sensitive> here because we would
diff --git a/vendor/github.com/hashicorp/terraform/helper/schema/field_reader_config.go b/vendor/github.com/hashicorp/terraform/helper/schema/field_reader_config.go
index 808375c..6ad3f13 100644
--- a/vendor/github.com/hashicorp/terraform/helper/schema/field_reader_config.go
+++ b/vendor/github.com/hashicorp/terraform/helper/schema/field_reader_config.go
@@ -219,6 +219,9 @@ func (r *ConfigFieldReader) readMap(k string, schema *Schema) (FieldReadResult,
                        v, _ := r.Config.Get(key)
                        result[ik] = v
                }
+        case nil:
+                // the map may have been empty on the configuration, so we leave the
+                // empty result
        default:
                panic(fmt.Sprintf("unknown type: %#v", mraw))
        }
diff --git a/vendor/github.com/hashicorp/terraform/helper/schema/field_reader_diff.go b/vendor/github.com/hashicorp/terraform/helper/schema/field_reader_diff.go
index ae35b4a..3e70acf 100644
--- a/vendor/github.com/hashicorp/terraform/helper/schema/field_reader_diff.go
+++ b/vendor/github.com/hashicorp/terraform/helper/schema/field_reader_diff.go
@@ -95,7 +95,9 @@ func (r *DiffFieldReader) readMap(
                return FieldReadResult{}, err
        }
        if source.Exists {
-                result = source.Value.(map[string]interface{})
+                // readMap may return a nil value, or an unknown value placeholder in
+                // some cases, causing the type assertion to panic if we don't assign the ok value
+                result, _ = source.Value.(map[string]interface{})
                resultSet = true
        }
diff --git a/vendor/github.com/hashicorp/terraform/helper/schema/resource.go b/vendor/github.com/hashicorp/terraform/helper/schema/resource.go
index b5e3065..b59e4e8 100644
--- a/vendor/github.com/hashicorp/terraform/helper/schema/resource.go
+++ b/vendor/github.com/hashicorp/terraform/helper/schema/resource.go
@@ -95,9 +95,10 @@ type Resource struct {
        //
        // Exists is a function that is called to check if a resource still
        // exists. If this returns false, then this will affect the diff
-        // accordingly. If this function isn't set, it will not be called. It
+        // accordingly. If this function isn't set, it will not be called. You
-        // is highly recommended to set it. The *ResourceData passed to Exists
+        // can also signal existence in the Read method by calling d.SetId("")
-        // should _not_ be modified.
+        // if the Resource is no longer present and should be removed from state.
+        // The *ResourceData passed to Exists should _not_ be modified.
        Create CreateFunc
        Read   ReadFunc
        Update UpdateFunc
@@ -329,21 +330,13 @@ func (r *Resource) simpleDiff(
        c *terraform.ResourceConfig,
        meta interface{}) (*terraform.InstanceDiff, error) {
-        t := &ResourceTimeout{}
-        err := t.ConfigDecode(r, c)
-        if err != nil {
-                return nil, fmt.Errorf("[ERR] Error decoding timeout: %s", err)
-        }
        instanceDiff, err := schemaMap(r.Schema).Diff(s, c, r.CustomizeDiff, meta, false)
        if err != nil {
                return instanceDiff, err
        }
        if instanceDiff == nil {
-                log.Printf("[DEBUG] Instance Diff is nil in SimpleDiff()")
+                instanceDiff = terraform.NewInstanceDiff()
-                return nil, err
        }
        // Make sure the old value is set in each of the instance diffs.
@@ -357,10 +350,7 @@ func (r *Resource) simpleDiff(
                }
        }
-        if err := t.DiffEncode(instanceDiff); err != nil {
+        return instanceDiff, nil
-                log.Printf("[ERR] Error encoding timeout to instance diff: %s", err)
-        }
-        return instanceDiff, err
 }
 // Validate validates the resource configuration against the schema.
diff --git a/vendor/github.com/hashicorp/terraform/helper/schema/resource_timeout.go b/vendor/github.com/hashicorp/terraform/helper/schema/resource_timeout.go
index 9e422c1..222b2cc 100644
--- a/vendor/github.com/hashicorp/terraform/helper/schema/resource_timeout.go
+++ b/vendor/github.com/hashicorp/terraform/helper/schema/resource_timeout.go
@@ -5,7 +5,7 @@ import (
        "log"
        "time"
-        "github.com/hashicorp/terraform/config"
+        "github.com/hashicorp/terraform/config/hcl2shim"
        "github.com/hashicorp/terraform/terraform"
        "github.com/mitchellh/copystructure"
 )
@@ -70,7 +70,7 @@ func (t *ResourceTimeout) ConfigDecode(s *Resource, c *terraform.ResourceConfig)
                case []map[string]interface{}:
                        rawTimeouts = raw
                case string:
-                        if raw == config.UnknownVariableValue {
+                        if raw == hcl2shim.UnknownVariableValue {
                                // Timeout is not defined in the config
                                // Defaults will be used instead
                                return nil
diff --git a/vendor/github.com/hashicorp/terraform/helper/schema/schema.go b/vendor/github.com/hashicorp/terraform/helper/schema/schema.go
index 6a3c15a..bcc8e4b 100644
--- a/vendor/github.com/hashicorp/terraform/helper/schema/schema.go
+++ b/vendor/github.com/hashicorp/terraform/helper/schema/schema.go
@@ -22,7 +22,7 @@ import (
        "strings"
        "sync"
-        "github.com/hashicorp/terraform/config"
+        "github.com/hashicorp/terraform/config/hcl2shim"
        "github.com/hashicorp/terraform/terraform"
        "github.com/mitchellh/copystructure"
        "github.com/mitchellh/mapstructure"
@@ -1365,10 +1365,15 @@ func (m schemaMap) validate(
                        "%q: this field cannot be set", k)}
        }
-        if raw == config.UnknownVariableValue {
+        // If the value is unknown then we can't validate it yet.
-                // If the value is unknown then we can't validate it yet.
+        // In particular, this avoids spurious type errors where downstream
-                // In particular, this avoids spurious type errors where downstream
+        // validation code sees UnknownVariableValue as being just a string.
-                // validation code sees UnknownVariableValue as being just a string.
+        // The SDK has to allow the unknown value through initially, so that
+        // Required fields set via an interpolated value are accepted.
+        if !isWhollyKnown(raw) {
+                if schema.Deprecated != "" {
+                        return []string{fmt.Sprintf("%q: [DEPRECATED] %s", k, schema.Deprecated)}, nil
+                }
                return nil, nil
        }
@@ -1380,6 +1385,28 @@ func (m schemaMap) validate(
        return m.validateType(k, raw, schema, c)
 }
+// isWhollyKnown returns false if the argument contains an UnknownVariableValue
+func isWhollyKnown(raw interface{}) bool {
+        switch raw := raw.(type) {
+        case string:
+                if raw == hcl2shim.UnknownVariableValue {
+                        return false
+                }
+        case []interface{}:
+                for _, v := range raw {
+                        if !isWhollyKnown(v) {
+                                return false
+                        }
+                }
+        case map[string]interface{}:
+                for _, v := range raw {
+                        if !isWhollyKnown(v) {
+                                return false
+                        }
+                }
+        }
+        return true
+}
 func (m schemaMap) validateConflictingAttributes(
        k string,
        schema *Schema,
@@ -1391,7 +1418,7 @@ func (m schemaMap) validateConflictingAttributes(
        for _, conflictingKey := range schema.ConflictsWith {
                if raw, ok := c.Get(conflictingKey); ok {
-                        if raw == config.UnknownVariableValue {
+                        if raw == hcl2shim.UnknownVariableValue {
                                // An unknown value might become unset (null) once known, so
                                // we must defer validation until it's known.
                                continue
@@ -1411,11 +1438,16 @@ func (m schemaMap) validateList(
        c *terraform.ResourceConfig) ([]string, []error) {
        // first check if the list is wholly unknown
        if s, ok := raw.(string); ok {
-                if s == config.UnknownVariableValue {
+                if s == hcl2shim.UnknownVariableValue {
                        return nil, nil
                }
        }
+        // schemaMap can't validate nil
+        if raw == nil {
+                return nil, nil
+        }
        // We use reflection to verify the slice because you can't
        // case to []interface{} unless the slice is exactly that type.
        rawV := reflect.ValueOf(raw)
@@ -1432,6 +1464,15 @@ func (m schemaMap) validateList(
                        "%s: should be a list", k)}
        }
+        // We can't validate list length if this came from a dynamic block.
+        // Since there's no way to determine if something was from a dynamic block
+        // at this point, we're going to skip validation in the new protocol if
+        // there are any unknowns. Validate will eventually be called again once
+        // all values are known.
+        if isProto5() && !isWhollyKnown(raw) {
+                return nil, nil
+        }
        // Validate length
        if schema.MaxItems > 0 && rawV.Len() > schema.MaxItems {
                return nil, []error{fmt.Errorf(
@@ -1489,11 +1530,15 @@ func (m schemaMap) validateMap(
        c *terraform.ResourceConfig) ([]string, []error) {
        // first check if the list is wholly unknown
        if s, ok := raw.(string); ok {
-                if s == config.UnknownVariableValue {
+                if s == hcl2shim.UnknownVariableValue {
                        return nil, nil
                }
        }
+        // schemaMap can't validate nil
+        if raw == nil {
+                return nil, nil
+        }
        // We use reflection to verify the slice because you can't
        // case to []interface{} unless the slice is exactly that type.
        rawV := reflect.ValueOf(raw)
@@ -1620,6 +1665,12 @@ func (m schemaMap) validateObject(
        schema map[string]*Schema,
        c *terraform.ResourceConfig) ([]string, []error) {
        raw, _ := c.Get(k)
+        // schemaMap can't validate nil
+        if raw == nil {
+                return nil, nil
+        }
        if _, ok := raw.(map[string]interface{}); !ok && !c.IsComputed(k) {
                return nil, []error{fmt.Errorf(
                        "%s: expected object, got %s",
@@ -1664,6 +1715,14 @@ func (m schemaMap) validatePrimitive(
        raw interface{},
        schema *Schema,
        c *terraform.ResourceConfig) ([]string, []error) {
+        // a nil value shouldn't happen in the old protocol, and in the new
+        // protocol the types have already been validated. Either way, we can't
+        // reflect on nil, so don't panic.
+        if raw == nil {
+                return nil, nil
+        }
        // Catch if the user gave a complex type where a primitive was
        // expected, so we can return a friendly error message that
        // doesn't contain Go type system terminology.
diff --git a/vendor/github.com/hashicorp/terraform/helper/schema/shims.go b/vendor/github.com/hashicorp/terraform/helper/schema/shims.go
index 203d017..988573e 100644
--- a/vendor/github.com/hashicorp/terraform/helper/schema/shims.go
+++ b/vendor/github.com/hashicorp/terraform/helper/schema/shims.go
@@ -6,7 +6,7 @@ import (
        "github.com/zclconf/go-cty/cty"
        ctyjson "github.com/zclconf/go-cty/cty/json"
-        "github.com/hashicorp/terraform/config"
+        "github.com/hashicorp/terraform/config/hcl2shim"
        "github.com/hashicorp/terraform/configs/configschema"
        "github.com/hashicorp/terraform/terraform"
 )
@@ -50,7 +50,7 @@ func removeConfigUnknowns(cfg map[string]interface{}) {
        for k, v := range cfg {
                switch v := v.(type) {
                case string:
-                        if v == config.UnknownVariableValue {
+                        if v == hcl2shim.UnknownVariableValue {
                                delete(cfg, k)
                        }
                case []interface{}:
diff --git a/vendor/github.com/hashicorp/terraform/internal/initwd/getter.go b/vendor/github.com/hashicorp/terraform/internal/initwd/getter.go
index 50e2572..2f306be 100644
--- a/vendor/github.com/hashicorp/terraform/internal/initwd/getter.go
+++ b/vendor/github.com/hashicorp/terraform/internal/initwd/getter.go
@@ -22,6 +22,7 @@ import (
 var goGetterDetectors = []getter.Detector{
        new(getter.GitHubDetector),
        new(getter.BitBucketDetector),
+        new(getter.GCSDetector),
        new(getter.S3Detector),
        new(getter.FileDetector),
 }
@@ -46,6 +47,7 @@ var goGetterDecompressors = map[string]getter.Decompressor{
 var goGetterGetters = map[string]getter.Getter{
        "file":  new(getter.FileGetter),
+        "gcs":   new(getter.GCSGetter),
        "git":   new(getter.GitGetter),
        "hg":    new(getter.HgGetter),
        "s3":    new(getter.S3Getter),
diff --git a/vendor/github.com/hashicorp/terraform/internal/tfplugin5/tfplugin5.pb.go b/vendor/github.com/hashicorp/terraform/internal/tfplugin5/tfplugin5.pb.go
index 87a6bec..b2bdf88 100644
--- a/vendor/github.com/hashicorp/terraform/internal/tfplugin5/tfplugin5.pb.go
+++ b/vendor/github.com/hashicorp/terraform/internal/tfplugin5/tfplugin5.pb.go
@@ -3,13 +3,12 @@
 package tfplugin5
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
 import (
+        fmt "fmt"
+        proto "github.com/golang/protobuf/proto"
        context "golang.org/x/net/context"
        grpc "google.golang.org/grpc"
+        math "math"
 )
 // Reference imports to suppress errors if they are not otherwise used.
@@ -36,6 +35,7 @@ var Diagnostic_Severity_name = map[int32]string{
        1: "ERROR",
        2: "WARNING",
 }
 var Diagnostic_Severity_value = map[string]int32{
        "INVALID": 0,
        "ERROR":   1,
@@ -45,8 +45,9 @@ var Diagnostic_Severity_value = map[string]int32{
 func (x Diagnostic_Severity) String() string {
        return proto.EnumName(Diagnostic_Severity_name, int32(x))
 }
 func (Diagnostic_Severity) EnumDescriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{1, 0}
+        return fileDescriptor_17ae6090ff270234, []int{1, 0}
 }
 type Schema_NestedBlock_NestingMode int32
@@ -68,6 +69,7 @@ var Schema_NestedBlock_NestingMode_name = map[int32]string{
        4: "MAP",
        5: "GROUP",
 }
 var Schema_NestedBlock_NestingMode_value = map[string]int32{
        "INVALID": 0,
        "SINGLE":  1,
@@ -80,8 +82,9 @@ var Schema_NestedBlock_NestingMode_value = map[string]int32{
 func (x Schema_NestedBlock_NestingMode) String() string {
        return proto.EnumName(Schema_NestedBlock_NestingMode_name, int32(x))
 }
 func (Schema_NestedBlock_NestingMode) EnumDescriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{5, 2, 0}
+        return fileDescriptor_17ae6090ff270234, []int{5, 2, 0}
 }
 // DynamicValue is an opaque encoding of terraform data, with the field name
@@ -98,16 +101,17 @@ func (m *DynamicValue) Reset()         { *m = DynamicValue{} }
 func (m *DynamicValue) String() string { return proto.CompactTextString(m) }
 func (*DynamicValue) ProtoMessage()    {}
 func (*DynamicValue) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{0}
+        return fileDescriptor_17ae6090ff270234, []int{0}
 }
 func (m *DynamicValue) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_DynamicValue.Unmarshal(m, b)
 }
 func (m *DynamicValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_DynamicValue.Marshal(b, m, deterministic)
 }
-func (dst *DynamicValue) XXX_Merge(src proto.Message) {
+func (m *DynamicValue) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_DynamicValue.Merge(dst, src)
+        xxx_messageInfo_DynamicValue.Merge(m, src)
 }
 func (m *DynamicValue) XXX_Size() int {
        return xxx_messageInfo_DynamicValue.Size(m)
@@ -146,16 +150,17 @@ func (m *Diagnostic) Reset()         { *m = Diagnostic{} }
 func (m *Diagnostic) String() string { return proto.CompactTextString(m) }
 func (*Diagnostic) ProtoMessage()    {}
 func (*Diagnostic) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{1}
+        return fileDescriptor_17ae6090ff270234, []int{1}
 }
 func (m *Diagnostic) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_Diagnostic.Unmarshal(m, b)
 }
 func (m *Diagnostic) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_Diagnostic.Marshal(b, m, deterministic)
 }
-func (dst *Diagnostic) XXX_Merge(src proto.Message) {
+func (m *Diagnostic) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_Diagnostic.Merge(dst, src)
+        xxx_messageInfo_Diagnostic.Merge(m, src)
 }
 func (m *Diagnostic) XXX_Size() int {
        return xxx_messageInfo_Diagnostic.Size(m)
@@ -205,16 +210,17 @@ func (m *AttributePath) Reset()         { *m = AttributePath{} }
 func (m *AttributePath) String() string { return proto.CompactTextString(m) }
 func (*AttributePath) ProtoMessage()    {}
 func (*AttributePath) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{2}
+        return fileDescriptor_17ae6090ff270234, []int{2}
 }
 func (m *AttributePath) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_AttributePath.Unmarshal(m, b)
 }
 func (m *AttributePath) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_AttributePath.Marshal(b, m, deterministic)
 }
-func (dst *AttributePath) XXX_Merge(src proto.Message) {
+func (m *AttributePath) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_AttributePath.Merge(dst, src)
+        xxx_messageInfo_AttributePath.Merge(m, src)
 }
 func (m *AttributePath) XXX_Size() int {
        return xxx_messageInfo_AttributePath.Size(m)
@@ -247,16 +253,17 @@ func (m *AttributePath_Step) Reset()         { *m = AttributePath_Step{} }
 func (m *AttributePath_Step) String() string { return proto.CompactTextString(m) }
 func (*AttributePath_Step) ProtoMessage()    {}
 func (*AttributePath_Step) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{2, 0}
+        return fileDescriptor_17ae6090ff270234, []int{2, 0}
 }
 func (m *AttributePath_Step) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_AttributePath_Step.Unmarshal(m, b)
 }
 func (m *AttributePath_Step) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_AttributePath_Step.Marshal(b, m, deterministic)
 }
-func (dst *AttributePath_Step) XXX_Merge(src proto.Message) {
+func (m *AttributePath_Step) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_AttributePath_Step.Merge(dst, src)
+        xxx_messageInfo_AttributePath_Step.Merge(m, src)
 }
 func (m *AttributePath_Step) XXX_Size() int {
        return xxx_messageInfo_AttributePath_Step.Size(m)
@@ -407,16 +414,17 @@ func (m *Stop) Reset()         { *m = Stop{} }
 func (m *Stop) String() string { return proto.CompactTextString(m) }
 func (*Stop) ProtoMessage()    {}
 func (*Stop) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{3}
+        return fileDescriptor_17ae6090ff270234, []int{3}
 }
 func (m *Stop) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_Stop.Unmarshal(m, b)
 }
 func (m *Stop) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_Stop.Marshal(b, m, deterministic)
 }
-func (dst *Stop) XXX_Merge(src proto.Message) {
+func (m *Stop) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_Stop.Merge(dst, src)
+        xxx_messageInfo_Stop.Merge(m, src)
 }
 func (m *Stop) XXX_Size() int {
        return xxx_messageInfo_Stop.Size(m)
@@ -437,16 +445,17 @@ func (m *Stop_Request) Reset()         { *m = Stop_Request{} }
 func (m *Stop_Request) String() string { return proto.CompactTextString(m) }
 func (*Stop_Request) ProtoMessage()    {}
 func (*Stop_Request) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{3, 0}
+        return fileDescriptor_17ae6090ff270234, []int{3, 0}
 }
 func (m *Stop_Request) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_Stop_Request.Unmarshal(m, b)
 }
 func (m *Stop_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_Stop_Request.Marshal(b, m, deterministic)
 }
-func (dst *Stop_Request) XXX_Merge(src proto.Message) {
+func (m *Stop_Request) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_Stop_Request.Merge(dst, src)
+        xxx_messageInfo_Stop_Request.Merge(m, src)
 }
 func (m *Stop_Request) XXX_Size() int {
        return xxx_messageInfo_Stop_Request.Size(m)
@@ -468,16 +477,17 @@ func (m *Stop_Response) Reset()         { *m = Stop_Response{} }
 func (m *Stop_Response) String() string { return proto.CompactTextString(m) }
 func (*Stop_Response) ProtoMessage()    {}
 func (*Stop_Response) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{3, 1}
+        return fileDescriptor_17ae6090ff270234, []int{3, 1}
 }
 func (m *Stop_Response) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_Stop_Response.Unmarshal(m, b)
 }
 func (m *Stop_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_Stop_Response.Marshal(b, m, deterministic)
 }
-func (dst *Stop_Response) XXX_Merge(src proto.Message) {
+func (m *Stop_Response) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_Stop_Response.Merge(dst, src)
+        xxx_messageInfo_Stop_Response.Merge(m, src)
 }
 func (m *Stop_Response) XXX_Size() int {
        return xxx_messageInfo_Stop_Response.Size(m)
@@ -510,16 +520,17 @@ func (m *RawState) Reset()         { *m = RawState{} }
 func (m *RawState) String() string { return proto.CompactTextString(m) }
 func (*RawState) ProtoMessage()    {}
 func (*RawState) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{4}
+        return fileDescriptor_17ae6090ff270234, []int{4}
 }
 func (m *RawState) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_RawState.Unmarshal(m, b)
 }
 func (m *RawState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_RawState.Marshal(b, m, deterministic)
 }
-func (dst *RawState) XXX_Merge(src proto.Message) {
+func (m *RawState) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_RawState.Merge(dst, src)
+        xxx_messageInfo_RawState.Merge(m, src)
 }
 func (m *RawState) XXX_Size() int {
        return xxx_messageInfo_RawState.Size(m)
@@ -561,16 +572,17 @@ func (m *Schema) Reset()         { *m = Schema{} }
 func (m *Schema) String() string { return proto.CompactTextString(m) }
 func (*Schema) ProtoMessage()    {}
 func (*Schema) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{5}
+        return fileDescriptor_17ae6090ff270234, []int{5}
 }
 func (m *Schema) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_Schema.Unmarshal(m, b)
 }
 func (m *Schema) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_Schema.Marshal(b, m, deterministic)
 }
-func (dst *Schema) XXX_Merge(src proto.Message) {
+func (m *Schema) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_Schema.Merge(dst, src)
+        xxx_messageInfo_Schema.Merge(m, src)
 }
 func (m *Schema) XXX_Size() int {
        return xxx_messageInfo_Schema.Size(m)
@@ -608,16 +620,17 @@ func (m *Schema_Block) Reset()         { *m = Schema_Block{} }
 func (m *Schema_Block) String() string { return proto.CompactTextString(m) }
 func (*Schema_Block) ProtoMessage()    {}
 func (*Schema_Block) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{5, 0}
+        return fileDescriptor_17ae6090ff270234, []int{5, 0}
 }
 func (m *Schema_Block) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_Schema_Block.Unmarshal(m, b)
 }
 func (m *Schema_Block) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_Schema_Block.Marshal(b, m, deterministic)
 }
-func (dst *Schema_Block) XXX_Merge(src proto.Message) {
+func (m *Schema_Block) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_Schema_Block.Merge(dst, src)
+        xxx_messageInfo_Schema_Block.Merge(m, src)
 }
 func (m *Schema_Block) XXX_Size() int {
        return xxx_messageInfo_Schema_Block.Size(m)
@@ -666,16 +679,17 @@ func (m *Schema_Attribute) Reset()         { *m = Schema_Attribute{} }
 func (m *Schema_Attribute) String() string { return proto.CompactTextString(m) }
 func (*Schema_Attribute) ProtoMessage()    {}
 func (*Schema_Attribute) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{5, 1}
+        return fileDescriptor_17ae6090ff270234, []int{5, 1}
 }
 func (m *Schema_Attribute) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_Schema_Attribute.Unmarshal(m, b)
 }
 func (m *Schema_Attribute) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_Schema_Attribute.Marshal(b, m, deterministic)
 }
-func (dst *Schema_Attribute) XXX_Merge(src proto.Message) {
+func (m *Schema_Attribute) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_Schema_Attribute.Merge(dst, src)
+        xxx_messageInfo_Schema_Attribute.Merge(m, src)
 }
 func (m *Schema_Attribute) XXX_Size() int {
        return xxx_messageInfo_Schema_Attribute.Size(m)
@@ -750,16 +764,17 @@ func (m *Schema_NestedBlock) Reset()         { *m = Schema_NestedBlock{} }
 func (m *Schema_NestedBlock) String() string { return proto.CompactTextString(m) }
 func (*Schema_NestedBlock) ProtoMessage()    {}
 func (*Schema_NestedBlock) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{5, 2}
+        return fileDescriptor_17ae6090ff270234, []int{5, 2}
 }
 func (m *Schema_NestedBlock) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_Schema_NestedBlock.Unmarshal(m, b)
 }
 func (m *Schema_NestedBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_Schema_NestedBlock.Marshal(b, m, deterministic)
 }
-func (dst *Schema_NestedBlock) XXX_Merge(src proto.Message) {
+func (m *Schema_NestedBlock) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_Schema_NestedBlock.Merge(dst, src)
+        xxx_messageInfo_Schema_NestedBlock.Merge(m, src)
 }
 func (m *Schema_NestedBlock) XXX_Size() int {
        return xxx_messageInfo_Schema_NestedBlock.Size(m)
@@ -815,16 +830,17 @@ func (m *GetProviderSchema) Reset()         { *m = GetProviderSchema{} }
 func (m *GetProviderSchema) String() string { return proto.CompactTextString(m) }
 func (*GetProviderSchema) ProtoMessage()    {}
 func (*GetProviderSchema) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{6}
+        return fileDescriptor_17ae6090ff270234, []int{6}
 }
 func (m *GetProviderSchema) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_GetProviderSchema.Unmarshal(m, b)
 }
 func (m *GetProviderSchema) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_GetProviderSchema.Marshal(b, m, deterministic)
 }
-func (dst *GetProviderSchema) XXX_Merge(src proto.Message) {
+func (m *GetProviderSchema) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_GetProviderSchema.Merge(dst, src)
+        xxx_messageInfo_GetProviderSchema.Merge(m, src)
 }
 func (m *GetProviderSchema) XXX_Size() int {
        return xxx_messageInfo_GetProviderSchema.Size(m)
@@ -845,16 +861,17 @@ func (m *GetProviderSchema_Request) Reset()         { *m = GetProviderSchema_Req
 func (m *GetProviderSchema_Request) String() string { return proto.CompactTextString(m) }
 func (*GetProviderSchema_Request) ProtoMessage()    {}
 func (*GetProviderSchema_Request) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{6, 0}
+        return fileDescriptor_17ae6090ff270234, []int{6, 0}
 }
 func (m *GetProviderSchema_Request) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_GetProviderSchema_Request.Unmarshal(m, b)
 }
 func (m *GetProviderSchema_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_GetProviderSchema_Request.Marshal(b, m, deterministic)
 }
-func (dst *GetProviderSchema_Request) XXX_Merge(src proto.Message) {
+func (m *GetProviderSchema_Request) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_GetProviderSchema_Request.Merge(dst, src)
+        xxx_messageInfo_GetProviderSchema_Request.Merge(m, src)
 }
 func (m *GetProviderSchema_Request) XXX_Size() int {
        return xxx_messageInfo_GetProviderSchema_Request.Size(m)
@@ -879,16 +896,17 @@ func (m *GetProviderSchema_Response) Reset()         { *m = GetProviderSchema_Re
 func (m *GetProviderSchema_Response) String() string { return proto.CompactTextString(m) }
 func (*GetProviderSchema_Response) ProtoMessage()    {}
 func (*GetProviderSchema_Response) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{6, 1}
+        return fileDescriptor_17ae6090ff270234, []int{6, 1}
 }
 func (m *GetProviderSchema_Response) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_GetProviderSchema_Response.Unmarshal(m, b)
 }
 func (m *GetProviderSchema_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_GetProviderSchema_Response.Marshal(b, m, deterministic)
 }
-func (dst *GetProviderSchema_Response) XXX_Merge(src proto.Message) {
+func (m *GetProviderSchema_Response) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_GetProviderSchema_Response.Merge(dst, src)
+        xxx_messageInfo_GetProviderSchema_Response.Merge(m, src)
 }
 func (m *GetProviderSchema_Response) XXX_Size() int {
        return xxx_messageInfo_GetProviderSchema_Response.Size(m)
@@ -937,16 +955,17 @@ func (m *PrepareProviderConfig) Reset()         { *m = PrepareProviderConfig{} }
 func (m *PrepareProviderConfig) String() string { return proto.CompactTextString(m) }
 func (*PrepareProviderConfig) ProtoMessage()    {}
 func (*PrepareProviderConfig) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{7}
+        return fileDescriptor_17ae6090ff270234, []int{7}
 }
 func (m *PrepareProviderConfig) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_PrepareProviderConfig.Unmarshal(m, b)
 }
 func (m *PrepareProviderConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_PrepareProviderConfig.Marshal(b, m, deterministic)
 }
-func (dst *PrepareProviderConfig) XXX_Merge(src proto.Message) {
+func (m *PrepareProviderConfig) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_PrepareProviderConfig.Merge(dst, src)
+        xxx_messageInfo_PrepareProviderConfig.Merge(m, src)
 }
 func (m *PrepareProviderConfig) XXX_Size() int {
        return xxx_messageInfo_PrepareProviderConfig.Size(m)
@@ -968,16 +987,17 @@ func (m *PrepareProviderConfig_Request) Reset()         { *m = PrepareProviderCo
 func (m *PrepareProviderConfig_Request) String() string { return proto.CompactTextString(m) }
 func (*PrepareProviderConfig_Request) ProtoMessage()    {}
 func (*PrepareProviderConfig_Request) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{7, 0}
+        return fileDescriptor_17ae6090ff270234, []int{7, 0}
 }
 func (m *PrepareProviderConfig_Request) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_PrepareProviderConfig_Request.Unmarshal(m, b)
 }
 func (m *PrepareProviderConfig_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_PrepareProviderConfig_Request.Marshal(b, m, deterministic)
 }
-func (dst *PrepareProviderConfig_Request) XXX_Merge(src proto.Message) {
+func (m *PrepareProviderConfig_Request) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_PrepareProviderConfig_Request.Merge(dst, src)
+        xxx_messageInfo_PrepareProviderConfig_Request.Merge(m, src)
 }
 func (m *PrepareProviderConfig_Request) XXX_Size() int {
        return xxx_messageInfo_PrepareProviderConfig_Request.Size(m)
@@ -1007,16 +1027,17 @@ func (m *PrepareProviderConfig_Response) Reset()         { *m = PrepareProviderC
 func (m *PrepareProviderConfig_Response) String() string { return proto.CompactTextString(m) }
 func (*PrepareProviderConfig_Response) ProtoMessage()    {}
 func (*PrepareProviderConfig_Response) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{7, 1}
+        return fileDescriptor_17ae6090ff270234, []int{7, 1}
 }
 func (m *PrepareProviderConfig_Response) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_PrepareProviderConfig_Response.Unmarshal(m, b)
 }
 func (m *PrepareProviderConfig_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_PrepareProviderConfig_Response.Marshal(b, m, deterministic)
 }
-func (dst *PrepareProviderConfig_Response) XXX_Merge(src proto.Message) {
+func (m *PrepareProviderConfig_Response) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_PrepareProviderConfig_Response.Merge(dst, src)
+        xxx_messageInfo_PrepareProviderConfig_Response.Merge(m, src)
 }
 func (m *PrepareProviderConfig_Response) XXX_Size() int {
        return xxx_messageInfo_PrepareProviderConfig_Response.Size(m)
@@ -1051,16 +1072,17 @@ func (m *UpgradeResourceState) Reset()         { *m = UpgradeResourceState{} }
 func (m *UpgradeResourceState) String() string { return proto.CompactTextString(m) }
 func (*UpgradeResourceState) ProtoMessage()    {}
 func (*UpgradeResourceState) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{8}
+        return fileDescriptor_17ae6090ff270234, []int{8}
 }
 func (m *UpgradeResourceState) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_UpgradeResourceState.Unmarshal(m, b)
 }
 func (m *UpgradeResourceState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_UpgradeResourceState.Marshal(b, m, deterministic)
 }
-func (dst *UpgradeResourceState) XXX_Merge(src proto.Message) {
+func (m *UpgradeResourceState) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_UpgradeResourceState.Merge(dst, src)
+        xxx_messageInfo_UpgradeResourceState.Merge(m, src)
 }
 func (m *UpgradeResourceState) XXX_Size() int {
        return xxx_messageInfo_UpgradeResourceState.Size(m)
@@ -1090,16 +1112,17 @@ func (m *UpgradeResourceState_Request) Reset()         { *m = UpgradeResourceSta
 func (m *UpgradeResourceState_Request) String() string { return proto.CompactTextString(m) }
 func (*UpgradeResourceState_Request) ProtoMessage()    {}
 func (*UpgradeResourceState_Request) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{8, 0}
+        return fileDescriptor_17ae6090ff270234, []int{8, 0}
 }
 func (m *UpgradeResourceState_Request) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_UpgradeResourceState_Request.Unmarshal(m, b)
 }
 func (m *UpgradeResourceState_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_UpgradeResourceState_Request.Marshal(b, m, deterministic)
 }
-func (dst *UpgradeResourceState_Request) XXX_Merge(src proto.Message) {
+func (m *UpgradeResourceState_Request) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_UpgradeResourceState_Request.Merge(dst, src)
+        xxx_messageInfo_UpgradeResourceState_Request.Merge(m, src)
 }
 func (m *UpgradeResourceState_Request) XXX_Size() int {
        return xxx_messageInfo_UpgradeResourceState_Request.Size(m)
@@ -1149,16 +1172,17 @@ func (m *UpgradeResourceState_Response) Reset()         { *m = UpgradeResourceSt
 func (m *UpgradeResourceState_Response) String() string { return proto.CompactTextString(m) }
 func (*UpgradeResourceState_Response) ProtoMessage()    {}
 func (*UpgradeResourceState_Response) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{8, 1}
+        return fileDescriptor_17ae6090ff270234, []int{8, 1}
 }
 func (m *UpgradeResourceState_Response) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_UpgradeResourceState_Response.Unmarshal(m, b)
 }
 func (m *UpgradeResourceState_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_UpgradeResourceState_Response.Marshal(b, m, deterministic)
 }
-func (dst *UpgradeResourceState_Response) XXX_Merge(src proto.Message) {
+func (m *UpgradeResourceState_Response) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_UpgradeResourceState_Response.Merge(dst, src)
+        xxx_messageInfo_UpgradeResourceState_Response.Merge(m, src)
 }
 func (m *UpgradeResourceState_Response) XXX_Size() int {
        return xxx_messageInfo_UpgradeResourceState_Response.Size(m)
@@ -1193,16 +1217,17 @@ func (m *ValidateResourceTypeConfig) Reset()         { *m = ValidateResourceType
 func (m *ValidateResourceTypeConfig) String() string { return proto.CompactTextString(m) }
 func (*ValidateResourceTypeConfig) ProtoMessage()    {}
 func (*ValidateResourceTypeConfig) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{9}
+        return fileDescriptor_17ae6090ff270234, []int{9}
 }
 func (m *ValidateResourceTypeConfig) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ValidateResourceTypeConfig.Unmarshal(m, b)
 }
 func (m *ValidateResourceTypeConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ValidateResourceTypeConfig.Marshal(b, m, deterministic)
 }
-func (dst *ValidateResourceTypeConfig) XXX_Merge(src proto.Message) {
+func (m *ValidateResourceTypeConfig) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ValidateResourceTypeConfig.Merge(dst, src)
+        xxx_messageInfo_ValidateResourceTypeConfig.Merge(m, src)
 }
 func (m *ValidateResourceTypeConfig) XXX_Size() int {
        return xxx_messageInfo_ValidateResourceTypeConfig.Size(m)
@@ -1225,16 +1250,17 @@ func (m *ValidateResourceTypeConfig_Request) Reset()         { *m = ValidateReso
 func (m *ValidateResourceTypeConfig_Request) String() string { return proto.CompactTextString(m) }
 func (*ValidateResourceTypeConfig_Request) ProtoMessage()    {}
 func (*ValidateResourceTypeConfig_Request) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{9, 0}
+        return fileDescriptor_17ae6090ff270234, []int{9, 0}
 }
 func (m *ValidateResourceTypeConfig_Request) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ValidateResourceTypeConfig_Request.Unmarshal(m, b)
 }
 func (m *ValidateResourceTypeConfig_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ValidateResourceTypeConfig_Request.Marshal(b, m, deterministic)
 }
-func (dst *ValidateResourceTypeConfig_Request) XXX_Merge(src proto.Message) {
+func (m *ValidateResourceTypeConfig_Request) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ValidateResourceTypeConfig_Request.Merge(dst, src)
+        xxx_messageInfo_ValidateResourceTypeConfig_Request.Merge(m, src)
 }
 func (m *ValidateResourceTypeConfig_Request) XXX_Size() int {
        return xxx_messageInfo_ValidateResourceTypeConfig_Request.Size(m)
@@ -1270,16 +1296,17 @@ func (m *ValidateResourceTypeConfig_Response) Reset()         { *m = ValidateRes
 func (m *ValidateResourceTypeConfig_Response) String() string { return proto.CompactTextString(m) }
 func (*ValidateResourceTypeConfig_Response) ProtoMessage()    {}
 func (*ValidateResourceTypeConfig_Response) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{9, 1}
+        return fileDescriptor_17ae6090ff270234, []int{9, 1}
 }
 func (m *ValidateResourceTypeConfig_Response) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ValidateResourceTypeConfig_Response.Unmarshal(m, b)
 }
 func (m *ValidateResourceTypeConfig_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ValidateResourceTypeConfig_Response.Marshal(b, m, deterministic)
 }
-func (dst *ValidateResourceTypeConfig_Response) XXX_Merge(src proto.Message) {
+func (m *ValidateResourceTypeConfig_Response) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ValidateResourceTypeConfig_Response.Merge(dst, src)
+        xxx_messageInfo_ValidateResourceTypeConfig_Response.Merge(m, src)
 }
 func (m *ValidateResourceTypeConfig_Response) XXX_Size() int {
        return xxx_messageInfo_ValidateResourceTypeConfig_Response.Size(m)
@@ -1307,16 +1334,17 @@ func (m *ValidateDataSourceConfig) Reset()         { *m = ValidateDataSourceConf
 func (m *ValidateDataSourceConfig) String() string { return proto.CompactTextString(m) }
 func (*ValidateDataSourceConfig) ProtoMessage()    {}
 func (*ValidateDataSourceConfig) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{10}
+        return fileDescriptor_17ae6090ff270234, []int{10}
 }
 func (m *ValidateDataSourceConfig) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ValidateDataSourceConfig.Unmarshal(m, b)
 }
 func (m *ValidateDataSourceConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ValidateDataSourceConfig.Marshal(b, m, deterministic)
 }
-func (dst *ValidateDataSourceConfig) XXX_Merge(src proto.Message) {
+func (m *ValidateDataSourceConfig) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ValidateDataSourceConfig.Merge(dst, src)
+        xxx_messageInfo_ValidateDataSourceConfig.Merge(m, src)
 }
 func (m *ValidateDataSourceConfig) XXX_Size() int {
        return xxx_messageInfo_ValidateDataSourceConfig.Size(m)
@@ -1339,16 +1367,17 @@ func (m *ValidateDataSourceConfig_Request) Reset()         { *m = ValidateDataSo
 func (m *ValidateDataSourceConfig_Request) String() string { return proto.CompactTextString(m) }
 func (*ValidateDataSourceConfig_Request) ProtoMessage()    {}
 func (*ValidateDataSourceConfig_Request) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{10, 0}
+        return fileDescriptor_17ae6090ff270234, []int{10, 0}
 }
 func (m *ValidateDataSourceConfig_Request) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ValidateDataSourceConfig_Request.Unmarshal(m, b)
 }
 func (m *ValidateDataSourceConfig_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ValidateDataSourceConfig_Request.Marshal(b, m, deterministic)
 }
-func (dst *ValidateDataSourceConfig_Request) XXX_Merge(src proto.Message) {
+func (m *ValidateDataSourceConfig_Request) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ValidateDataSourceConfig_Request.Merge(dst, src)
+        xxx_messageInfo_ValidateDataSourceConfig_Request.Merge(m, src)
 }
 func (m *ValidateDataSourceConfig_Request) XXX_Size() int {
        return xxx_messageInfo_ValidateDataSourceConfig_Request.Size(m)
@@ -1384,16 +1413,17 @@ func (m *ValidateDataSourceConfig_Response) Reset()         { *m = ValidateDataS
 func (m *ValidateDataSourceConfig_Response) String() string { return proto.CompactTextString(m) }
 func (*ValidateDataSourceConfig_Response) ProtoMessage()    {}
 func (*ValidateDataSourceConfig_Response) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{10, 1}
+        return fileDescriptor_17ae6090ff270234, []int{10, 1}
 }
 func (m *ValidateDataSourceConfig_Response) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ValidateDataSourceConfig_Response.Unmarshal(m, b)
 }
 func (m *ValidateDataSourceConfig_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ValidateDataSourceConfig_Response.Marshal(b, m, deterministic)
 }
-func (dst *ValidateDataSourceConfig_Response) XXX_Merge(src proto.Message) {
+func (m *ValidateDataSourceConfig_Response) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ValidateDataSourceConfig_Response.Merge(dst, src)
+        xxx_messageInfo_ValidateDataSourceConfig_Response.Merge(m, src)
 }
 func (m *ValidateDataSourceConfig_Response) XXX_Size() int {
        return xxx_messageInfo_ValidateDataSourceConfig_Response.Size(m)
@@ -1421,16 +1451,17 @@ func (m *Configure) Reset()         { *m = Configure{} }
 func (m *Configure) String() string { return proto.CompactTextString(m) }
 func (*Configure) ProtoMessage()    {}
 func (*Configure) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{11}
+        return fileDescriptor_17ae6090ff270234, []int{11}
 }
 func (m *Configure) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_Configure.Unmarshal(m, b)
 }
 func (m *Configure) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_Configure.Marshal(b, m, deterministic)
 }
-func (dst *Configure) XXX_Merge(src proto.Message) {
+func (m *Configure) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_Configure.Merge(dst, src)
+        xxx_messageInfo_Configure.Merge(m, src)
 }
 func (m *Configure) XXX_Size() int {
        return xxx_messageInfo_Configure.Size(m)
@@ -1453,16 +1484,17 @@ func (m *Configure_Request) Reset()         { *m = Configure_Request{} }
 func (m *Configure_Request) String() string { return proto.CompactTextString(m) }
 func (*Configure_Request) ProtoMessage()    {}
 func (*Configure_Request) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{11, 0}
+        return fileDescriptor_17ae6090ff270234, []int{11, 0}
 }
 func (m *Configure_Request) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_Configure_Request.Unmarshal(m, b)
 }
 func (m *Configure_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_Configure_Request.Marshal(b, m, deterministic)
 }
-func (dst *Configure_Request) XXX_Merge(src proto.Message) {
+func (m *Configure_Request) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_Configure_Request.Merge(dst, src)
+        xxx_messageInfo_Configure_Request.Merge(m, src)
 }
 func (m *Configure_Request) XXX_Size() int {
        return xxx_messageInfo_Configure_Request.Size(m)
@@ -1498,16 +1530,17 @@ func (m *Configure_Response) Reset()         { *m = Configure_Response{} }
 func (m *Configure_Response) String() string { return proto.CompactTextString(m) }
 func (*Configure_Response) ProtoMessage()    {}
 func (*Configure_Response) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{11, 1}
+        return fileDescriptor_17ae6090ff270234, []int{11, 1}
 }
 func (m *Configure_Response) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_Configure_Response.Unmarshal(m, b)
 }
 func (m *Configure_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_Configure_Response.Marshal(b, m, deterministic)
 }
-func (dst *Configure_Response) XXX_Merge(src proto.Message) {
+func (m *Configure_Response) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_Configure_Response.Merge(dst, src)
+        xxx_messageInfo_Configure_Response.Merge(m, src)
 }
 func (m *Configure_Response) XXX_Size() int {
        return xxx_messageInfo_Configure_Response.Size(m)
@@ -1535,16 +1568,17 @@ func (m *ReadResource) Reset()         { *m = ReadResource{} }
 func (m *ReadResource) String() string { return proto.CompactTextString(m) }
 func (*ReadResource) ProtoMessage()    {}
 func (*ReadResource) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{12}
+        return fileDescriptor_17ae6090ff270234, []int{12}
 }
 func (m *ReadResource) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ReadResource.Unmarshal(m, b)
 }
 func (m *ReadResource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ReadResource.Marshal(b, m, deterministic)
 }
-func (dst *ReadResource) XXX_Merge(src proto.Message) {
+func (m *ReadResource) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ReadResource.Merge(dst, src)
+        xxx_messageInfo_ReadResource.Merge(m, src)
 }
 func (m *ReadResource) XXX_Size() int {
        return xxx_messageInfo_ReadResource.Size(m)
@@ -1558,6 +1592,7 @@ var xxx_messageInfo_ReadResource proto.InternalMessageInfo
 type ReadResource_Request struct {
        TypeName             string        `protobuf:"bytes,1,opt,name=type_name,json=typeName,proto3" json:"type_name,omitempty"`
        CurrentState         *DynamicValue `protobuf:"bytes,2,opt,name=current_state,json=currentState,proto3" json:"current_state,omitempty"`
+        Private              []byte        `protobuf:"bytes,3,opt,name=private,proto3" json:"private,omitempty"`
        XXX_NoUnkeyedLiteral struct{}      `json:"-"`
        XXX_unrecognized     []byte        `json:"-"`
        XXX_sizecache        int32         `json:"-"`
@@ -1567,16 +1602,17 @@ func (m *ReadResource_Request) Reset()         { *m = ReadResource_Request{} }
 func (m *ReadResource_Request) String() string { return proto.CompactTextString(m) }
 func (*ReadResource_Request) ProtoMessage()    {}
 func (*ReadResource_Request) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{12, 0}
+        return fileDescriptor_17ae6090ff270234, []int{12, 0}
 }
 func (m *ReadResource_Request) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ReadResource_Request.Unmarshal(m, b)
 }
 func (m *ReadResource_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ReadResource_Request.Marshal(b, m, deterministic)
 }
-func (dst *ReadResource_Request) XXX_Merge(src proto.Message) {
+func (m *ReadResource_Request) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ReadResource_Request.Merge(dst, src)
+        xxx_messageInfo_ReadResource_Request.Merge(m, src)
 }
 func (m *ReadResource_Request) XXX_Size() int {
        return xxx_messageInfo_ReadResource_Request.Size(m)
@@ -1601,9 +1637,17 @@ func (m *ReadResource_Request) GetCurrentState() *DynamicValue {
        return nil
 }
+func (m *ReadResource_Request) GetPrivate() []byte {
+        if m != nil {
+                return m.Private
+        }
+        return nil
+}
 type ReadResource_Response struct {
        NewState             *DynamicValue `protobuf:"bytes,1,opt,name=new_state,json=newState,proto3" json:"new_state,omitempty"`
        Diagnostics          []*Diagnostic `protobuf:"bytes,2,rep,name=diagnostics,proto3" json:"diagnostics,omitempty"`
+        Private              []byte        `protobuf:"bytes,3,opt,name=private,proto3" json:"private,omitempty"`
        XXX_NoUnkeyedLiteral struct{}      `json:"-"`
        XXX_unrecognized     []byte        `json:"-"`
        XXX_sizecache        int32         `json:"-"`
@@ -1613,16 +1657,17 @@ func (m *ReadResource_Response) Reset()         { *m = ReadResource_Response{} }
 func (m *ReadResource_Response) String() string { return proto.CompactTextString(m) }
 func (*ReadResource_Response) ProtoMessage()    {}
 func (*ReadResource_Response) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{12, 1}
+        return fileDescriptor_17ae6090ff270234, []int{12, 1}
 }
 func (m *ReadResource_Response) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ReadResource_Response.Unmarshal(m, b)
 }
 func (m *ReadResource_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ReadResource_Response.Marshal(b, m, deterministic)
 }
-func (dst *ReadResource_Response) XXX_Merge(src proto.Message) {
+func (m *ReadResource_Response) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ReadResource_Response.Merge(dst, src)
+        xxx_messageInfo_ReadResource_Response.Merge(m, src)
 }
 func (m *ReadResource_Response) XXX_Size() int {
        return xxx_messageInfo_ReadResource_Response.Size(m)
@@ -1647,6 +1692,13 @@ func (m *ReadResource_Response) GetDiagnostics() []*Diagnostic {
        return nil
 }
+func (m *ReadResource_Response) GetPrivate() []byte {
+        if m != nil {
+                return m.Private
+        }
+        return nil
+}
 type PlanResourceChange struct {
        XXX_NoUnkeyedLiteral struct{} `json:"-"`
        XXX_unrecognized     []byte   `json:"-"`
@@ -1657,16 +1709,17 @@ func (m *PlanResourceChange) Reset()         { *m = PlanResourceChange{} }
 func (m *PlanResourceChange) String() string { return proto.CompactTextString(m) }
 func (*PlanResourceChange) ProtoMessage()    {}
 func (*PlanResourceChange) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{13}
+        return fileDescriptor_17ae6090ff270234, []int{13}
 }
 func (m *PlanResourceChange) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_PlanResourceChange.Unmarshal(m, b)
 }
 func (m *PlanResourceChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_PlanResourceChange.Marshal(b, m, deterministic)
 }
-func (dst *PlanResourceChange) XXX_Merge(src proto.Message) {
+func (m *PlanResourceChange) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_PlanResourceChange.Merge(dst, src)
+        xxx_messageInfo_PlanResourceChange.Merge(m, src)
 }
 func (m *PlanResourceChange) XXX_Size() int {
        return xxx_messageInfo_PlanResourceChange.Size(m)
@@ -1692,16 +1745,17 @@ func (m *PlanResourceChange_Request) Reset()         { *m = PlanResourceChange_R
 func (m *PlanResourceChange_Request) String() string { return proto.CompactTextString(m) }
 func (*PlanResourceChange_Request) ProtoMessage()    {}
 func (*PlanResourceChange_Request) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{13, 0}
+        return fileDescriptor_17ae6090ff270234, []int{13, 0}
 }
 func (m *PlanResourceChange_Request) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_PlanResourceChange_Request.Unmarshal(m, b)
 }
 func (m *PlanResourceChange_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_PlanResourceChange_Request.Marshal(b, m, deterministic)
 }
-func (dst *PlanResourceChange_Request) XXX_Merge(src proto.Message) {
+func (m *PlanResourceChange_Request) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_PlanResourceChange_Request.Merge(dst, src)
+        xxx_messageInfo_PlanResourceChange_Request.Merge(m, src)
 }
 func (m *PlanResourceChange_Request) XXX_Size() int {
        return xxx_messageInfo_PlanResourceChange_Request.Size(m)
@@ -1773,16 +1827,17 @@ func (m *PlanResourceChange_Response) Reset()         { *m = PlanResourceChange_
 func (m *PlanResourceChange_Response) String() string { return proto.CompactTextString(m) }
 func (*PlanResourceChange_Response) ProtoMessage()    {}
 func (*PlanResourceChange_Response) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{13, 1}
+        return fileDescriptor_17ae6090ff270234, []int{13, 1}
 }
 func (m *PlanResourceChange_Response) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_PlanResourceChange_Response.Unmarshal(m, b)
 }
 func (m *PlanResourceChange_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_PlanResourceChange_Response.Marshal(b, m, deterministic)
 }
-func (dst *PlanResourceChange_Response) XXX_Merge(src proto.Message) {
+func (m *PlanResourceChange_Response) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_PlanResourceChange_Response.Merge(dst, src)
+        xxx_messageInfo_PlanResourceChange_Response.Merge(m, src)
 }
 func (m *PlanResourceChange_Response) XXX_Size() int {
        return xxx_messageInfo_PlanResourceChange_Response.Size(m)
@@ -1838,16 +1893,17 @@ func (m *ApplyResourceChange) Reset()         { *m = ApplyResourceChange{} }
 func (m *ApplyResourceChange) String() string { return proto.CompactTextString(m) }
 func (*ApplyResourceChange) ProtoMessage()    {}
 func (*ApplyResourceChange) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{14}
+        return fileDescriptor_17ae6090ff270234, []int{14}
 }
 func (m *ApplyResourceChange) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ApplyResourceChange.Unmarshal(m, b)
 }
 func (m *ApplyResourceChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ApplyResourceChange.Marshal(b, m, deterministic)
 }
-func (dst *ApplyResourceChange) XXX_Merge(src proto.Message) {
+func (m *ApplyResourceChange) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ApplyResourceChange.Merge(dst, src)
+        xxx_messageInfo_ApplyResourceChange.Merge(m, src)
 }
 func (m *ApplyResourceChange) XXX_Size() int {
        return xxx_messageInfo_ApplyResourceChange.Size(m)
@@ -1873,16 +1929,17 @@ func (m *ApplyResourceChange_Request) Reset()         { *m = ApplyResourceChange
 func (m *ApplyResourceChange_Request) String() string { return proto.CompactTextString(m) }
 func (*ApplyResourceChange_Request) ProtoMessage()    {}
 func (*ApplyResourceChange_Request) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{14, 0}
+        return fileDescriptor_17ae6090ff270234, []int{14, 0}
 }
 func (m *ApplyResourceChange_Request) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ApplyResourceChange_Request.Unmarshal(m, b)
 }
 func (m *ApplyResourceChange_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ApplyResourceChange_Request.Marshal(b, m, deterministic)
 }
-func (dst *ApplyResourceChange_Request) XXX_Merge(src proto.Message) {
+func (m *ApplyResourceChange_Request) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ApplyResourceChange_Request.Merge(dst, src)
+        xxx_messageInfo_ApplyResourceChange_Request.Merge(m, src)
 }
 func (m *ApplyResourceChange_Request) XXX_Size() int {
        return xxx_messageInfo_ApplyResourceChange_Request.Size(m)
@@ -1953,16 +2010,17 @@ func (m *ApplyResourceChange_Response) Reset()         { *m = ApplyResourceChang
 func (m *ApplyResourceChange_Response) String() string { return proto.CompactTextString(m) }
 func (*ApplyResourceChange_Response) ProtoMessage()    {}
 func (*ApplyResourceChange_Response) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{14, 1}
+        return fileDescriptor_17ae6090ff270234, []int{14, 1}
 }
 func (m *ApplyResourceChange_Response) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ApplyResourceChange_Response.Unmarshal(m, b)
 }
 func (m *ApplyResourceChange_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ApplyResourceChange_Response.Marshal(b, m, deterministic)
 }
-func (dst *ApplyResourceChange_Response) XXX_Merge(src proto.Message) {
+func (m *ApplyResourceChange_Response) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ApplyResourceChange_Response.Merge(dst, src)
+        xxx_messageInfo_ApplyResourceChange_Response.Merge(m, src)
 }
 func (m *ApplyResourceChange_Response) XXX_Size() int {
        return xxx_messageInfo_ApplyResourceChange_Response.Size(m)
@@ -2011,16 +2069,17 @@ func (m *ImportResourceState) Reset()         { *m = ImportResourceState{} }
 func (m *ImportResourceState) String() string { return proto.CompactTextString(m) }
 func (*ImportResourceState) ProtoMessage()    {}
 func (*ImportResourceState) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{15}
+        return fileDescriptor_17ae6090ff270234, []int{15}
 }
 func (m *ImportResourceState) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ImportResourceState.Unmarshal(m, b)
 }
 func (m *ImportResourceState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ImportResourceState.Marshal(b, m, deterministic)
 }
-func (dst *ImportResourceState) XXX_Merge(src proto.Message) {
+func (m *ImportResourceState) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ImportResourceState.Merge(dst, src)
+        xxx_messageInfo_ImportResourceState.Merge(m, src)
 }
 func (m *ImportResourceState) XXX_Size() int {
        return xxx_messageInfo_ImportResourceState.Size(m)
@@ -2043,16 +2102,17 @@ func (m *ImportResourceState_Request) Reset()         { *m = ImportResourceState
 func (m *ImportResourceState_Request) String() string { return proto.CompactTextString(m) }
 func (*ImportResourceState_Request) ProtoMessage()    {}
 func (*ImportResourceState_Request) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{15, 0}
+        return fileDescriptor_17ae6090ff270234, []int{15, 0}
 }
 func (m *ImportResourceState_Request) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ImportResourceState_Request.Unmarshal(m, b)
 }
 func (m *ImportResourceState_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ImportResourceState_Request.Marshal(b, m, deterministic)
 }
-func (dst *ImportResourceState_Request) XXX_Merge(src proto.Message) {
+func (m *ImportResourceState_Request) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ImportResourceState_Request.Merge(dst, src)
+        xxx_messageInfo_ImportResourceState_Request.Merge(m, src)
 }
 func (m *ImportResourceState_Request) XXX_Size() int {
        return xxx_messageInfo_ImportResourceState_Request.Size(m)
@@ -2090,16 +2150,17 @@ func (m *ImportResourceState_ImportedResource) Reset()         { *m = ImportReso
 func (m *ImportResourceState_ImportedResource) String() string { return proto.CompactTextString(m) }
 func (*ImportResourceState_ImportedResource) ProtoMessage()    {}
 func (*ImportResourceState_ImportedResource) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{15, 1}
+        return fileDescriptor_17ae6090ff270234, []int{15, 1}
 }
 func (m *ImportResourceState_ImportedResource) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ImportResourceState_ImportedResource.Unmarshal(m, b)
 }
 func (m *ImportResourceState_ImportedResource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ImportResourceState_ImportedResource.Marshal(b, m, deterministic)
 }
-func (dst *ImportResourceState_ImportedResource) XXX_Merge(src proto.Message) {
+func (m *ImportResourceState_ImportedResource) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ImportResourceState_ImportedResource.Merge(dst, src)
+        xxx_messageInfo_ImportResourceState_ImportedResource.Merge(m, src)
 }
 func (m *ImportResourceState_ImportedResource) XXX_Size() int {
        return xxx_messageInfo_ImportResourceState_ImportedResource.Size(m)
@@ -2143,16 +2204,17 @@ func (m *ImportResourceState_Response) Reset()         { *m = ImportResourceStat
 func (m *ImportResourceState_Response) String() string { return proto.CompactTextString(m) }
 func (*ImportResourceState_Response) ProtoMessage()    {}
 func (*ImportResourceState_Response) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{15, 2}
+        return fileDescriptor_17ae6090ff270234, []int{15, 2}
 }
 func (m *ImportResourceState_Response) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ImportResourceState_Response.Unmarshal(m, b)
 }
 func (m *ImportResourceState_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ImportResourceState_Response.Marshal(b, m, deterministic)
 }
-func (dst *ImportResourceState_Response) XXX_Merge(src proto.Message) {
+func (m *ImportResourceState_Response) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ImportResourceState_Response.Merge(dst, src)
+        xxx_messageInfo_ImportResourceState_Response.Merge(m, src)
 }
 func (m *ImportResourceState_Response) XXX_Size() int {
        return xxx_messageInfo_ImportResourceState_Response.Size(m)
@@ -2187,16 +2249,17 @@ func (m *ReadDataSource) Reset()         { *m = ReadDataSource{} }
 func (m *ReadDataSource) String() string { return proto.CompactTextString(m) }
 func (*ReadDataSource) ProtoMessage()    {}
 func (*ReadDataSource) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{16}
+        return fileDescriptor_17ae6090ff270234, []int{16}
 }
 func (m *ReadDataSource) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ReadDataSource.Unmarshal(m, b)
 }
 func (m *ReadDataSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ReadDataSource.Marshal(b, m, deterministic)
 }
-func (dst *ReadDataSource) XXX_Merge(src proto.Message) {
+func (m *ReadDataSource) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ReadDataSource.Merge(dst, src)
+        xxx_messageInfo_ReadDataSource.Merge(m, src)
 }
 func (m *ReadDataSource) XXX_Size() int {
        return xxx_messageInfo_ReadDataSource.Size(m)
@@ -2219,16 +2282,17 @@ func (m *ReadDataSource_Request) Reset()         { *m = ReadDataSource_Request{}
 func (m *ReadDataSource_Request) String() string { return proto.CompactTextString(m) }
 func (*ReadDataSource_Request) ProtoMessage()    {}
 func (*ReadDataSource_Request) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{16, 0}
+        return fileDescriptor_17ae6090ff270234, []int{16, 0}
 }
 func (m *ReadDataSource_Request) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ReadDataSource_Request.Unmarshal(m, b)
 }
 func (m *ReadDataSource_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ReadDataSource_Request.Marshal(b, m, deterministic)
 }
-func (dst *ReadDataSource_Request) XXX_Merge(src proto.Message) {
+func (m *ReadDataSource_Request) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ReadDataSource_Request.Merge(dst, src)
+        xxx_messageInfo_ReadDataSource_Request.Merge(m, src)
 }
 func (m *ReadDataSource_Request) XXX_Size() int {
        return xxx_messageInfo_ReadDataSource_Request.Size(m)
@@ -2265,16 +2329,17 @@ func (m *ReadDataSource_Response) Reset()         { *m = ReadDataSource_Response
 func (m *ReadDataSource_Response) String() string { return proto.CompactTextString(m) }
 func (*ReadDataSource_Response) ProtoMessage()    {}
 func (*ReadDataSource_Response) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{16, 1}
+        return fileDescriptor_17ae6090ff270234, []int{16, 1}
 }
 func (m *ReadDataSource_Response) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ReadDataSource_Response.Unmarshal(m, b)
 }
 func (m *ReadDataSource_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ReadDataSource_Response.Marshal(b, m, deterministic)
 }
-func (dst *ReadDataSource_Response) XXX_Merge(src proto.Message) {
+func (m *ReadDataSource_Response) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ReadDataSource_Response.Merge(dst, src)
+        xxx_messageInfo_ReadDataSource_Response.Merge(m, src)
 }
 func (m *ReadDataSource_Response) XXX_Size() int {
        return xxx_messageInfo_ReadDataSource_Response.Size(m)
@@ -2309,16 +2374,17 @@ func (m *GetProvisionerSchema) Reset()         { *m = GetProvisionerSchema{} }
 func (m *GetProvisionerSchema) String() string { return proto.CompactTextString(m) }
 func (*GetProvisionerSchema) ProtoMessage()    {}
 func (*GetProvisionerSchema) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{17}
+        return fileDescriptor_17ae6090ff270234, []int{17}
 }
 func (m *GetProvisionerSchema) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_GetProvisionerSchema.Unmarshal(m, b)
 }
 func (m *GetProvisionerSchema) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_GetProvisionerSchema.Marshal(b, m, deterministic)
 }
-func (dst *GetProvisionerSchema) XXX_Merge(src proto.Message) {
+func (m *GetProvisionerSchema) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_GetProvisionerSchema.Merge(dst, src)
+        xxx_messageInfo_GetProvisionerSchema.Merge(m, src)
 }
 func (m *GetProvisionerSchema) XXX_Size() int {
        return xxx_messageInfo_GetProvisionerSchema.Size(m)
@@ -2339,16 +2405,17 @@ func (m *GetProvisionerSchema_Request) Reset()         { *m = GetProvisionerSche
 func (m *GetProvisionerSchema_Request) String() string { return proto.CompactTextString(m) }
 func (*GetProvisionerSchema_Request) ProtoMessage()    {}
 func (*GetProvisionerSchema_Request) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{17, 0}
+        return fileDescriptor_17ae6090ff270234, []int{17, 0}
 }
 func (m *GetProvisionerSchema_Request) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_GetProvisionerSchema_Request.Unmarshal(m, b)
 }
 func (m *GetProvisionerSchema_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_GetProvisionerSchema_Request.Marshal(b, m, deterministic)
 }
-func (dst *GetProvisionerSchema_Request) XXX_Merge(src proto.Message) {
+func (m *GetProvisionerSchema_Request) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_GetProvisionerSchema_Request.Merge(dst, src)
+        xxx_messageInfo_GetProvisionerSchema_Request.Merge(m, src)
 }
 func (m *GetProvisionerSchema_Request) XXX_Size() int {
        return xxx_messageInfo_GetProvisionerSchema_Request.Size(m)
@@ -2371,16 +2438,17 @@ func (m *GetProvisionerSchema_Response) Reset()         { *m = GetProvisionerSch
 func (m *GetProvisionerSchema_Response) String() string { return proto.CompactTextString(m) }
 func (*GetProvisionerSchema_Response) ProtoMessage()    {}
 func (*GetProvisionerSchema_Response) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{17, 1}
+        return fileDescriptor_17ae6090ff270234, []int{17, 1}
 }
 func (m *GetProvisionerSchema_Response) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_GetProvisionerSchema_Response.Unmarshal(m, b)
 }
 func (m *GetProvisionerSchema_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_GetProvisionerSchema_Response.Marshal(b, m, deterministic)
 }
-func (dst *GetProvisionerSchema_Response) XXX_Merge(src proto.Message) {
+func (m *GetProvisionerSchema_Response) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_GetProvisionerSchema_Response.Merge(dst, src)
+        xxx_messageInfo_GetProvisionerSchema_Response.Merge(m, src)
 }
 func (m *GetProvisionerSchema_Response) XXX_Size() int {
        return xxx_messageInfo_GetProvisionerSchema_Response.Size(m)
@@ -2415,16 +2483,17 @@ func (m *ValidateProvisionerConfig) Reset()         { *m = ValidateProvisionerCo
 func (m *ValidateProvisionerConfig) String() string { return proto.CompactTextString(m) }
 func (*ValidateProvisionerConfig) ProtoMessage()    {}
 func (*ValidateProvisionerConfig) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{18}
+        return fileDescriptor_17ae6090ff270234, []int{18}
 }
 func (m *ValidateProvisionerConfig) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ValidateProvisionerConfig.Unmarshal(m, b)
 }
 func (m *ValidateProvisionerConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ValidateProvisionerConfig.Marshal(b, m, deterministic)
 }
-func (dst *ValidateProvisionerConfig) XXX_Merge(src proto.Message) {
+func (m *ValidateProvisionerConfig) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ValidateProvisionerConfig.Merge(dst, src)
+        xxx_messageInfo_ValidateProvisionerConfig.Merge(m, src)
 }
 func (m *ValidateProvisionerConfig) XXX_Size() int {
        return xxx_messageInfo_ValidateProvisionerConfig.Size(m)
@@ -2446,16 +2515,17 @@ func (m *ValidateProvisionerConfig_Request) Reset()         { *m = ValidateProvi
 func (m *ValidateProvisionerConfig_Request) String() string { return proto.CompactTextString(m) }
 func (*ValidateProvisionerConfig_Request) ProtoMessage()    {}
 func (*ValidateProvisionerConfig_Request) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{18, 0}
+        return fileDescriptor_17ae6090ff270234, []int{18, 0}
 }
 func (m *ValidateProvisionerConfig_Request) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ValidateProvisionerConfig_Request.Unmarshal(m, b)
 }
 func (m *ValidateProvisionerConfig_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ValidateProvisionerConfig_Request.Marshal(b, m, deterministic)
 }
-func (dst *ValidateProvisionerConfig_Request) XXX_Merge(src proto.Message) {
+func (m *ValidateProvisionerConfig_Request) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ValidateProvisionerConfig_Request.Merge(dst, src)
+        xxx_messageInfo_ValidateProvisionerConfig_Request.Merge(m, src)
 }
 func (m *ValidateProvisionerConfig_Request) XXX_Size() int {
        return xxx_messageInfo_ValidateProvisionerConfig_Request.Size(m)
@@ -2484,16 +2554,17 @@ func (m *ValidateProvisionerConfig_Response) Reset()         { *m = ValidateProv
 func (m *ValidateProvisionerConfig_Response) String() string { return proto.CompactTextString(m) }
 func (*ValidateProvisionerConfig_Response) ProtoMessage()    {}
 func (*ValidateProvisionerConfig_Response) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{18, 1}
+        return fileDescriptor_17ae6090ff270234, []int{18, 1}
 }
 func (m *ValidateProvisionerConfig_Response) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ValidateProvisionerConfig_Response.Unmarshal(m, b)
 }
 func (m *ValidateProvisionerConfig_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ValidateProvisionerConfig_Response.Marshal(b, m, deterministic)
 }
-func (dst *ValidateProvisionerConfig_Response) XXX_Merge(src proto.Message) {
+func (m *ValidateProvisionerConfig_Response) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ValidateProvisionerConfig_Response.Merge(dst, src)
+        xxx_messageInfo_ValidateProvisionerConfig_Response.Merge(m, src)
 }
 func (m *ValidateProvisionerConfig_Response) XXX_Size() int {
        return xxx_messageInfo_ValidateProvisionerConfig_Response.Size(m)
@@ -2521,16 +2592,17 @@ func (m *ProvisionResource) Reset()         { *m = ProvisionResource{} }
 func (m *ProvisionResource) String() string { return proto.CompactTextString(m) }
 func (*ProvisionResource) ProtoMessage()    {}
 func (*ProvisionResource) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{19}
+        return fileDescriptor_17ae6090ff270234, []int{19}
 }
 func (m *ProvisionResource) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ProvisionResource.Unmarshal(m, b)
 }
 func (m *ProvisionResource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ProvisionResource.Marshal(b, m, deterministic)
 }
-func (dst *ProvisionResource) XXX_Merge(src proto.Message) {
+func (m *ProvisionResource) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ProvisionResource.Merge(dst, src)
+        xxx_messageInfo_ProvisionResource.Merge(m, src)
 }
 func (m *ProvisionResource) XXX_Size() int {
        return xxx_messageInfo_ProvisionResource.Size(m)
@@ -2553,16 +2625,17 @@ func (m *ProvisionResource_Request) Reset()         { *m = ProvisionResource_Req
 func (m *ProvisionResource_Request) String() string { return proto.CompactTextString(m) }
 func (*ProvisionResource_Request) ProtoMessage()    {}
 func (*ProvisionResource_Request) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{19, 0}
+        return fileDescriptor_17ae6090ff270234, []int{19, 0}
 }
 func (m *ProvisionResource_Request) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ProvisionResource_Request.Unmarshal(m, b)
 }
 func (m *ProvisionResource_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ProvisionResource_Request.Marshal(b, m, deterministic)
 }
-func (dst *ProvisionResource_Request) XXX_Merge(src proto.Message) {
+func (m *ProvisionResource_Request) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ProvisionResource_Request.Merge(dst, src)
+        xxx_messageInfo_ProvisionResource_Request.Merge(m, src)
 }
 func (m *ProvisionResource_Request) XXX_Size() int {
        return xxx_messageInfo_ProvisionResource_Request.Size(m)
@@ -2599,16 +2672,17 @@ func (m *ProvisionResource_Response) Reset()         { *m = ProvisionResource_Re
 func (m *ProvisionResource_Response) String() string { return proto.CompactTextString(m) }
 func (*ProvisionResource_Response) ProtoMessage()    {}
 func (*ProvisionResource_Response) Descriptor() ([]byte, []int) {
-        return fileDescriptor_tfplugin5_56820f4fb67360c5, []int{19, 1}
+        return fileDescriptor_17ae6090ff270234, []int{19, 1}
 }
 func (m *ProvisionResource_Response) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ProvisionResource_Response.Unmarshal(m, b)
 }
 func (m *ProvisionResource_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ProvisionResource_Response.Marshal(b, m, deterministic)
 }
-func (dst *ProvisionResource_Response) XXX_Merge(src proto.Message) {
+func (m *ProvisionResource_Response) XXX_Merge(src proto.Message) {
-        xxx_messageInfo_ProvisionResource_Response.Merge(dst, src)
+        xxx_messageInfo_ProvisionResource_Response.Merge(m, src)
 }
 func (m *ProvisionResource_Response) XXX_Size() int {
        return xxx_messageInfo_ProvisionResource_Response.Size(m)
@@ -2634,6 +2708,8 @@ func (m *ProvisionResource_Response) GetDiagnostics() []*Diagnostic {
 }
 func init() {
+        proto.RegisterEnum("tfplugin5.Diagnostic_Severity", Diagnostic_Severity_name, Diagnostic_Severity_value)
+        proto.RegisterEnum("tfplugin5.Schema_NestedBlock_NestingMode", Schema_NestedBlock_NestingMode_name, Schema_NestedBlock_NestingMode_value)
        proto.RegisterType((*DynamicValue)(nil), "tfplugin5.DynamicValue")
        proto.RegisterType((*Diagnostic)(nil), "tfplugin5.Diagnostic")
        proto.RegisterType((*AttributePath)(nil), "tfplugin5.AttributePath")
@@ -2692,8 +2768,130 @@ func init() {
        proto.RegisterType((*ProvisionResource)(nil), "tfplugin5.ProvisionResource")
        proto.RegisterType((*ProvisionResource_Request)(nil), "tfplugin5.ProvisionResource.Request")
        proto.RegisterType((*ProvisionResource_Response)(nil), "tfplugin5.ProvisionResource.Response")
-        proto.RegisterEnum("tfplugin5.Diagnostic_Severity", Diagnostic_Severity_name, Diagnostic_Severity_value)
+}
-        proto.RegisterEnum("tfplugin5.Schema_NestedBlock_NestingMode", Schema_NestedBlock_NestingMode_name, Schema_NestedBlock_NestingMode_value)
+func init() { proto.RegisterFile("tfplugin5.proto", fileDescriptor_17ae6090ff270234) }
+var fileDescriptor_17ae6090ff270234 = []byte{
+        // 1880 bytes of a gzipped FileDescriptorProto
+        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xcb, 0x6f, 0x23, 0x49,
+        0x19, 0x9f, 0xf6, 0x23, 0xb1, 0x3f, 0xe7, 0xe1, 0xd4, 0xcc, 0x0e, 0xa6, 0x77, 0x17, 0x82, 0x79,
+        0x24, 0xab, 0xdd, 0xf1, 0xac, 0x32, 0xb0, 0xbb, 0x84, 0xd1, 0x8a, 0x6c, 0x26, 0x64, 0x22, 0x66,
+        0xb2, 0xa1, 0x3c, 0x0f, 0x24, 0xa4, 0xb5, 0x6a, 0xdc, 0x15, 0x4f, 0x33, 0x76, 0x77, 0x6f, 0x75,
+        0x39, 0x89, 0x85, 0xc4, 0x05, 0xc1, 0x19, 0x09, 0xf1, 0x90, 0x78, 0x5c, 0x40, 0xe2, 0x1f, 0xe0,
+        0x00, 0xdc, 0x38, 0xf1, 0x0f, 0x70, 0x03, 0x4e, 0x08, 0x6e, 0x9c, 0xe1, 0x82, 0x84, 0xea, 0xd5,
+        0x5d, 0xb6, 0xdb, 0x4e, 0x4f, 0xb2, 0x23, 0xc4, 0xad, 0xab, 0xbe, 0x5f, 0x7d, 0xdf, 0x57, 0xdf,
+        0xab, 0xbe, 0xcf, 0x86, 0x55, 0x7e, 0x1c, 0xf5, 0x87, 0x3d, 0x3f, 0xf8, 0x42, 0x2b, 0x62, 0x21,
+        0x0f, 0x51, 0x35, 0xd9, 0x68, 0xde, 0x86, 0xa5, 0x3b, 0xa3, 0x80, 0x0c, 0xfc, 0xee, 0x23, 0xd2,
+        0x1f, 0x52, 0xd4, 0x80, 0xc5, 0x41, 0xdc, 0x8b, 0x48, 0xf7, 0x59, 0xc3, 0x59, 0x77, 0x36, 0x97,
+        0xb0, 0x59, 0x22, 0x04, 0xa5, 0x6f, 0xc6, 0x61, 0xd0, 0x28, 0xc8, 0x6d, 0xf9, 0xdd, 0xfc, 0x9b,
+        0x03, 0x70, 0xc7, 0x27, 0xbd, 0x20, 0x8c, 0xb9, 0xdf, 0x45, 0xdb, 0x50, 0x89, 0xe9, 0x09, 0x65,
+        0x3e, 0x1f, 0xc9, 0xd3, 0x2b, 0x5b, 0x9f, 0x68, 0xa5, 0xb2, 0x53, 0x60, 0xab, 0xad, 0x51, 0x38,
+        0xc1, 0x0b, 0xc1, 0xf1, 0x70, 0x30, 0x20, 0x6c, 0x24, 0x25, 0x54, 0xb1, 0x59, 0xa2, 0xeb, 0xb0,
+        0xe0, 0x51, 0x4e, 0xfc, 0x7e, 0xa3, 0x28, 0x09, 0x7a, 0x85, 0xde, 0x82, 0x2a, 0xe1, 0x9c, 0xf9,
+        0x4f, 0x86, 0x9c, 0x36, 0x4a, 0xeb, 0xce, 0x66, 0x6d, 0xab, 0x61, 0x89, 0xdb, 0x31, 0xb4, 0x23,
+        0xc2, 0x9f, 0xe2, 0x14, 0xda, 0xbc, 0x09, 0x15, 0x23, 0x1f, 0xd5, 0x60, 0xf1, 0xe0, 0xf0, 0xd1,
+        0xce, 0xbd, 0x83, 0x3b, 0xf5, 0x2b, 0xa8, 0x0a, 0xe5, 0x3d, 0x8c, 0xdf, 0xc7, 0x75, 0x47, 0xec,
+        0x3f, 0xde, 0xc1, 0x87, 0x07, 0x87, 0xfb, 0xf5, 0x42, 0xf3, 0x2f, 0x0e, 0x2c, 0x8f, 0x71, 0x43,
+        0xb7, 0xa0, 0x1c, 0x73, 0x1a, 0xc5, 0x0d, 0x67, 0xbd, 0xb8, 0x59, 0xdb, 0x7a, 0x75, 0x96, 0xd8,
+        0x56, 0x9b, 0xd3, 0x08, 0x2b, 0xac, 0xfb, 0x43, 0x07, 0x4a, 0x62, 0x8d, 0x36, 0x60, 0x25, 0xd1,
+        0xa6, 0x13, 0x90, 0x01, 0x95, 0xc6, 0xaa, 0xde, 0xbd, 0x82, 0x97, 0x93, 0xfd, 0x43, 0x32, 0xa0,
+        0xa8, 0x05, 0x88, 0xf6, 0xe9, 0x80, 0x06, 0xbc, 0xf3, 0x8c, 0x8e, 0x3a, 0x31, 0x67, 0x7e, 0xd0,
+        0x53, 0xe6, 0xb9, 0x7b, 0x05, 0xd7, 0x35, 0xed, 0xab, 0x74, 0xd4, 0x96, 0x14, 0xb4, 0x09, 0xab,
+        0x36, 0xde, 0x0f, 0xb8, 0x34, 0x59, 0x51, 0x70, 0x4e, 0xc1, 0x07, 0x01, 0x7f, 0x0f, 0x84, 0xa7,
+        0xfa, 0xb4, 0xcb, 0x43, 0xd6, 0xbc, 0x25, 0xd4, 0x0a, 0x23, 0xb7, 0x0a, 0x8b, 0x98, 0x7e, 0x38,
+        0xa4, 0x31, 0x77, 0xd7, 0xa1, 0x82, 0x69, 0x1c, 0x85, 0x41, 0x4c, 0xd1, 0x35, 0x28, 0xef, 0x31,
+        0x16, 0x32, 0xa5, 0x24, 0x56, 0x8b, 0xe6, 0x8f, 0x1c, 0xa8, 0x60, 0x72, 0xda, 0xe6, 0x84, 0xd3,
+        0x24, 0x34, 0x9c, 0x34, 0x34, 0xd0, 0x36, 0x2c, 0x1e, 0xf7, 0x09, 0x1f, 0x90, 0xa8, 0x51, 0x90,
+        0x46, 0x5a, 0xb7, 0x8c, 0x64, 0x4e, 0xb6, 0xbe, 0xa2, 0x20, 0x7b, 0x01, 0x67, 0x23, 0x6c, 0x0e,
+        0xb8, 0xdb, 0xb0, 0x64, 0x13, 0x50, 0x1d, 0x8a, 0xcf, 0xe8, 0x48, 0x2b, 0x20, 0x3e, 0x85, 0x52,
+        0x27, 0x22, 0x5e, 0x75, 0xac, 0xa8, 0xc5, 0x76, 0xe1, 0x1d, 0xa7, 0xf9, 0x8f, 0x32, 0x2c, 0xb4,
+        0xbb, 0x4f, 0xe9, 0x80, 0x88, 0x90, 0x3a, 0xa1, 0x2c, 0xf6, 0xb5, 0x66, 0x45, 0x6c, 0x96, 0xe8,
+        0x06, 0x94, 0x9f, 0xf4, 0xc3, 0xee, 0x33, 0x79, 0xbc, 0xb6, 0xf5, 0x31, 0x4b, 0x35, 0x75, 0xb6,
+        0xf5, 0x9e, 0x20, 0x63, 0x85, 0x72, 0x7f, 0xe1, 0x40, 0x59, 0x6e, 0xcc, 0x61, 0xf9, 0x25, 0x80,
+        0xc4, 0x79, 0xb1, 0xbe, 0xf2, 0xcb, 0xd3, 0x7c, 0x93, 0xf0, 0xc0, 0x16, 0x1c, 0xbd, 0x0b, 0x35,
+        0x29, 0xa9, 0xc3, 0x47, 0x11, 0x8d, 0x1b, 0xc5, 0xa9, 0xa8, 0xd2, 0xa7, 0x0f, 0x69, 0xcc, 0xa9,
+        0xa7, 0x74, 0x03, 0x79, 0xe2, 0x81, 0x38, 0xe0, 0xfe, 0xd1, 0x81, 0x6a, 0xc2, 0x59, 0xb8, 0x23,
+        0x8d, 0x2a, 0x2c, 0xbf, 0xc5, 0x9e, 0xe0, 0x6d, 0xb2, 0x57, 0x7c, 0xa3, 0x75, 0xa8, 0x79, 0x34,
+        0xee, 0x32, 0x3f, 0xe2, 0xe2, 0x42, 0x2a, 0xbb, 0xec, 0x2d, 0xe4, 0x42, 0x85, 0xd1, 0x0f, 0x87,
+        0x3e, 0xa3, 0x9e, 0xcc, 0xb0, 0x0a, 0x4e, 0xd6, 0x82, 0x16, 0x4a, 0x14, 0xe9, 0x37, 0xca, 0x8a,
+        0x66, 0xd6, 0x82, 0xd6, 0x0d, 0x07, 0xd1, 0x90, 0x53, 0xaf, 0xb1, 0xa0, 0x68, 0x66, 0x8d, 0x5e,
+        0x81, 0x6a, 0x4c, 0x83, 0xd8, 0xe7, 0xfe, 0x09, 0x6d, 0x2c, 0x4a, 0x62, 0xba, 0xe1, 0xfe, 0xba,
+        0x00, 0x35, 0xeb, 0x96, 0xe8, 0x65, 0xa8, 0x0a, 0x5d, 0xad, 0x34, 0xc1, 0x15, 0xb1, 0x21, 0xf3,
+        0xe3, 0xf9, 0xdc, 0x88, 0x76, 0x61, 0x31, 0xa0, 0x31, 0x17, 0x39, 0x54, 0x94, 0xd5, 0xe9, 0xb5,
+        0xb9, 0x16, 0x96, 0xdf, 0x7e, 0xd0, 0xbb, 0x1f, 0x7a, 0x14, 0x9b, 0x93, 0x42, 0xa1, 0x81, 0x1f,
+        0x74, 0x7c, 0x4e, 0x07, 0xb1, 0xb4, 0x49, 0x11, 0x57, 0x06, 0x7e, 0x70, 0x20, 0xd6, 0x92, 0x48,
+        0xce, 0x34, 0xb1, 0xac, 0x89, 0xe4, 0x4c, 0x12, 0x9b, 0xf7, 0xd5, 0xcd, 0x34, 0xc7, 0xf1, 0xd2,
+        0x03, 0xb0, 0xd0, 0x3e, 0x38, 0xdc, 0xbf, 0xb7, 0x57, 0x77, 0x50, 0x05, 0x4a, 0xf7, 0x0e, 0xda,
+        0x0f, 0xea, 0x05, 0xb4, 0x08, 0xc5, 0xf6, 0xde, 0x83, 0x7a, 0x51, 0x7c, 0xdc, 0xdf, 0x39, 0xaa,
+        0x97, 0x44, 0x89, 0xda, 0xc7, 0xef, 0x3f, 0x3c, 0xaa, 0x97, 0x9b, 0x3f, 0x29, 0xc1, 0xda, 0x3e,
+        0xe5, 0x47, 0x2c, 0x3c, 0xf1, 0x3d, 0xca, 0x94, 0xfe, 0x76, 0x12, 0xff, 0xab, 0x68, 0x65, 0xf1,
+        0x0d, 0xa8, 0x44, 0x1a, 0x29, 0xcd, 0x58, 0xdb, 0x5a, 0x9b, 0xba, 0x3c, 0x4e, 0x20, 0x88, 0x42,
+        0x9d, 0xd1, 0x38, 0x1c, 0xb2, 0x2e, 0xed, 0xc4, 0x92, 0x68, 0x62, 0x7a, 0xdb, 0x3a, 0x36, 0x25,
+        0xbe, 0x65, 0xe4, 0x89, 0x0f, 0x79, 0x5a, 0xed, 0xc7, 0x2a, 0xc1, 0x57, 0xd9, 0xf8, 0x2e, 0xea,
+        0xc3, 0x55, 0x8f, 0x70, 0xd2, 0x99, 0x90, 0xa4, 0xe2, 0xff, 0x76, 0x3e, 0x49, 0x77, 0x08, 0x27,
+        0xed, 0x69, 0x59, 0x6b, 0xde, 0xe4, 0x3e, 0x7a, 0x1b, 0x6a, 0x5e, 0xf2, 0x06, 0x09, 0xe7, 0x09,
+        0x29, 0x2f, 0x65, 0xbe, 0x50, 0xd8, 0x46, 0xba, 0x0f, 0xe1, 0x5a, 0xd6, 0x7d, 0x32, 0xea, 0xd2,
+        0x86, 0x5d, 0x97, 0x32, 0x6d, 0x9c, 0x96, 0x2a, 0xf7, 0x31, 0x5c, 0xcf, 0x56, 0xfe, 0x92, 0x8c,
+        0x9b, 0x7f, 0x76, 0xe0, 0xa5, 0x23, 0x46, 0x23, 0xc2, 0xa8, 0xb1, 0xda, 0x6e, 0x18, 0x1c, 0xfb,
+        0x3d, 0x77, 0x3b, 0x09, 0x0f, 0x74, 0x13, 0x16, 0xba, 0x72, 0x53, 0xc7, 0x83, 0x9d, 0x3d, 0x76,
+        0x4b, 0x80, 0x35, 0xcc, 0xfd, 0xae, 0x63, 0xc5, 0xd3, 0x97, 0x61, 0x35, 0x52, 0x12, 0xbc, 0x4e,
+        0x3e, 0x36, 0x2b, 0x06, 0xaf, 0x54, 0x99, 0xf4, 0x46, 0x21, 0xaf, 0x37, 0x9a, 0xdf, 0x2f, 0xc0,
+        0xb5, 0x87, 0x51, 0x8f, 0x11, 0x8f, 0x26, 0x5e, 0x11, 0x8f, 0x89, 0xcb, 0xd2, 0xcb, 0xcd, 0x2d,
+        0x1b, 0x56, 0x11, 0x2f, 0x8c, 0x17, 0xf1, 0x37, 0xa1, 0xca, 0xc8, 0x69, 0x27, 0x16, 0xec, 0x64,
+        0x8d, 0xa8, 0x6d, 0x5d, 0xcd, 0x78, 0xb6, 0x70, 0x85, 0xe9, 0x2f, 0xf7, 0x3b, 0xb6, 0x51, 0xde,
+        0x85, 0x95, 0xa1, 0x52, 0xcc, 0xd3, 0x3c, 0xce, 0xb1, 0xc9, 0xb2, 0x81, 0xab, 0x77, 0xf4, 0xc2,
+        0x26, 0xf9, 0xbd, 0x03, 0xee, 0x23, 0xd2, 0xf7, 0x3d, 0xa1, 0x9c, 0xb6, 0x89, 0x78, 0x19, 0xb4,
+        0xd7, 0x1f, 0xe7, 0x34, 0x4c, 0x1a, 0x12, 0x85, 0x7c, 0x21, 0xb1, 0x6b, 0x5d, 0x7e, 0x42, 0x79,
+        0x27, 0xb7, 0xf2, 0xbf, 0x75, 0xa0, 0x61, 0x94, 0x4f, 0xf3, 0xe1, 0xff, 0x42, 0xf5, 0xdf, 0x39,
+        0x50, 0x55, 0x8a, 0x0e, 0x19, 0x75, 0x7b, 0xa9, 0xae, 0xaf, 0xc3, 0x1a, 0xa7, 0x8c, 0x91, 0xe3,
+        0x90, 0x0d, 0x3a, 0x76, 0xc7, 0x50, 0xc5, 0xf5, 0x84, 0xf0, 0x48, 0x47, 0xdd, 0xff, 0x46, 0xf7,
+        0x5f, 0x15, 0x60, 0x09, 0x53, 0xe2, 0x99, 0x78, 0x71, 0xbf, 0x9d, 0xd3, 0xd4, 0xb7, 0x61, 0xb9,
+        0x3b, 0x64, 0x4c, 0x74, 0x99, 0x2a, 0xc8, 0xcf, 0xd1, 0x7a, 0x49, 0xa3, 0x55, 0x8c, 0x37, 0x60,
+        0x31, 0x62, 0xfe, 0x89, 0x49, 0xb0, 0x25, 0x6c, 0x96, 0xee, 0x0f, 0xec, 0x54, 0xfa, 0x3c, 0x54,
+        0x03, 0x7a, 0x9a, 0x2f, 0x8b, 0x2a, 0x01, 0x3d, 0xbd, 0x5c, 0x02, 0xcd, 0xd6, 0xaa, 0xf9, 0x9b,
+        0x12, 0xa0, 0xa3, 0x3e, 0x09, 0x8c, 0x99, 0x76, 0x9f, 0x92, 0xa0, 0x47, 0xdd, 0xff, 0x38, 0x39,
+        0xad, 0xf5, 0x0e, 0xd4, 0x22, 0xe6, 0x87, 0x2c, 0x9f, 0xad, 0x40, 0x62, 0xd5, 0x65, 0xf6, 0x00,
+        0x45, 0x2c, 0x8c, 0xc2, 0x98, 0x7a, 0x9d, 0xd4, 0x16, 0xc5, 0xf9, 0x0c, 0xea, 0xe6, 0xc8, 0xa1,
+        0xb1, 0x49, 0x1a, 0x5d, 0xa5, 0x5c, 0xd1, 0x85, 0x3e, 0x0d, 0xcb, 0x4a, 0x63, 0x63, 0x91, 0xb2,
+        0xb4, 0xc8, 0x92, 0xdc, 0x3c, 0xd2, 0xce, 0xfa, 0x79, 0xc1, 0x72, 0xd6, 0x6d, 0x58, 0x8e, 0xfa,
+        0x24, 0x08, 0xf2, 0x96, 0xbd, 0x25, 0x8d, 0x56, 0x0a, 0xee, 0x8a, 0x5e, 0x43, 0x36, 0x95, 0x71,
+        0x87, 0xd1, 0xa8, 0x4f, 0xba, 0x54, 0x7b, 0x6e, 0xf6, 0x38, 0xb7, 0x6a, 0x4e, 0x60, 0x75, 0x00,
+        0x6d, 0xc0, 0xaa, 0x51, 0x61, 0xdc, 0x91, 0x2b, 0x7a, 0x5b, 0x2b, 0x7e, 0xe1, 0x26, 0x00, 0xbd,
+        0x01, 0xa8, 0x4f, 0x7b, 0xa4, 0x3b, 0x92, 0x4d, 0x7a, 0x27, 0x1e, 0xc5, 0x9c, 0x0e, 0x74, 0xe7,
+        0x5b, 0x57, 0x14, 0x51, 0x72, 0xdb, 0x72, 0xbf, 0xf9, 0xa7, 0x22, 0x5c, 0xdd, 0x89, 0xa2, 0xfe,
+        0x68, 0x22, 0x6e, 0xfe, 0xfd, 0xe2, 0xe3, 0x66, 0xca, 0x1b, 0xc5, 0xe7, 0xf1, 0xc6, 0x73, 0x87,
+        0x4b, 0x86, 0xe5, 0xcb, 0x59, 0x96, 0x77, 0xff, 0x70, 0xf9, 0xfc, 0xb6, 0xd2, 0xb4, 0x30, 0x96,
+        0xa6, 0x93, 0x6e, 0x2d, 0x5e, 0xd2, 0xad, 0xa5, 0x19, 0x6e, 0xfd, 0x67, 0x01, 0xae, 0x1e, 0x0c,
+        0xa2, 0x90, 0xf1, 0xf1, 0xd6, 0xe3, 0xad, 0x9c, 0x5e, 0x5d, 0x81, 0x82, 0xef, 0xe9, 0xa1, 0xb5,
+        0xe0, 0x7b, 0xee, 0x19, 0xd4, 0x15, 0x3b, 0x9a, 0xd4, 0xe1, 0x73, 0x47, 0x9e, 0x5c, 0x01, 0xa1,
+        0x50, 0x73, 0xaa, 0xed, 0x2f, 0x6d, 0x6f, 0x7c, 0x00, 0xc8, 0xd7, 0x6a, 0x74, 0x4c, 0x8f, 0x6e,
+        0xde, 0x92, 0x9b, 0x96, 0x88, 0x8c, 0xab, 0xb7, 0x26, 0xf5, 0xc7, 0x6b, 0xfe, 0xc4, 0x4e, 0x7c,
+        0xf1, 0xc6, 0xe6, 0xaf, 0x0e, 0xac, 0x88, 0x47, 0x2a, 0xed, 0x0b, 0x5e, 0x5c, 0x47, 0xc0, 0xc6,
+        0xc6, 0xa5, 0x72, 0xae, 0xd0, 0xd4, 0x66, 0xbe, 0xf0, 0xfd, 0x7e, 0xea, 0xc0, 0x35, 0x33, 0xdb,
+        0x88, 0x5e, 0x20, 0x6b, 0x8e, 0x3b, 0xb3, 0xf4, 0xba, 0x25, 0xaa, 0x42, 0x82, 0x9d, 0x3d, 0xc9,
+        0xd9, 0xa8, 0x8b, 0x6b, 0xf7, 0x33, 0x07, 0x3e, 0x6e, 0x3a, 0x33, 0x4b, 0xc5, 0x8f, 0x60, 0x96,
+        0xf8, 0x48, 0x3a, 0x98, 0xbf, 0x3b, 0xb0, 0x96, 0xa8, 0x95, 0xb4, 0x31, 0xf1, 0xc5, 0xd5, 0x42,
+        0x6f, 0x03, 0x74, 0xc3, 0x20, 0xa0, 0x5d, 0x6e, 0x86, 0x83, 0x79, 0x35, 0x37, 0x85, 0xba, 0xdf,
+        0xb0, 0xee, 0x73, 0x1d, 0x16, 0xc2, 0x21, 0x8f, 0x86, 0x5c, 0x87, 0xa4, 0x5e, 0x5d, 0xd8, 0x0d,
+        0x5b, 0x3f, 0xae, 0x42, 0xc5, 0xcc, 0x71, 0xe8, 0xeb, 0x50, 0xdd, 0xa7, 0x5c, 0xff, 0xc2, 0xf5,
+        0x99, 0x73, 0x46, 0x64, 0x15, 0x40, 0x9f, 0xcd, 0x35, 0x48, 0xa3, 0xfe, 0x8c, 0xa1, 0x11, 0x6d,
+        0x5a, 0xe7, 0x33, 0x11, 0x89, 0xa4, 0xd7, 0x72, 0x20, 0xb5, 0xb4, 0x6f, 0xcd, 0x9b, 0x58, 0xd0,
+        0x0d, 0x8b, 0xd1, 0x6c, 0x58, 0x22, 0xb7, 0x95, 0x17, 0xae, 0x85, 0x0f, 0x67, 0x4f, 0x1c, 0xe8,
+        0xf5, 0x0c, 0x5e, 0x93, 0xa0, 0x44, 0xf0, 0x1b, 0xf9, 0xc0, 0x5a, 0xac, 0x9f, 0x3d, 0xb8, 0xa2,
+        0x0d, 0x8b, 0x4b, 0x16, 0x20, 0x11, 0xb7, 0x79, 0x3e, 0x50, 0x8b, 0xba, 0x6b, 0x0d, 0x26, 0xe8,
+        0x15, 0xeb, 0x58, 0xb2, 0x9b, 0x30, 0x7d, 0x75, 0x06, 0x55, 0x73, 0xfa, 0xda, 0xf8, 0x98, 0x80,
+        0x3e, 0x69, 0x0f, 0xc4, 0x16, 0x21, 0xe1, 0xb7, 0x3e, 0x1b, 0xa0, 0x59, 0x76, 0xb3, 0x5a, 0x6a,
+        0x64, 0x87, 0xe9, 0x34, 0x39, 0x61, 0xff, 0xb9, 0xf3, 0x60, 0x5a, 0xc8, 0x71, 0x66, 0x03, 0x86,
+        0xec, 0xe3, 0x19, 0xf4, 0x44, 0xcc, 0xc6, 0xb9, 0xb8, 0x54, 0x4e, 0xc6, 0xb3, 0x38, 0x26, 0x27,
+        0xeb, 0xd9, 0xcc, 0x92, 0x93, 0x8d, 0xd3, 0x72, 0x1e, 0x4f, 0xbe, 0x84, 0xe8, 0x53, 0x13, 0x86,
+        0x4e, 0x49, 0x09, 0xf7, 0xe6, 0x3c, 0x88, 0x66, 0xfc, 0x45, 0xf5, 0xfb, 0x3f, 0x1a, 0xfb, 0xf9,
+        0x94, 0x87, 0x51, 0xc2, 0xa4, 0x31, 0x4d, 0x50, 0x47, 0xb7, 0xbe, 0x57, 0x84, 0x9a, 0xf5, 0x30,
+        0xa0, 0x0f, 0xec, 0xe2, 0xb4, 0x91, 0x51, 0x76, 0xec, 0x37, 0x2e, 0x33, 0xaa, 0x67, 0x00, 0xb5,
+        0xaa, 0x67, 0x73, 0xde, 0x23, 0x94, 0x95, 0x8b, 0x53, 0xa8, 0x44, 0xe8, 0x8d, 0x9c, 0x68, 0x2d,
+        0xf9, 0x49, 0xc6, 0x53, 0x33, 0x56, 0x7e, 0xa7, 0xa8, 0x99, 0xe5, 0x37, 0x0b, 0xa5, 0x24, 0xbc,
+        0xe9, 0x5c, 0xc2, 0x11, 0x4f, 0x16, 0xe4, 0x1f, 0x7b, 0xb7, 0xfe, 0x1b, 0x00, 0x00, 0xff, 0xff,
+        0x8a, 0x61, 0xfa, 0xcc, 0xeb, 0x1b, 0x00, 0x00,
 }
 // Reference imports to suppress errors if they are not otherwise used.
@@ -3329,127 +3527,3 @@ var _Provisioner_serviceDesc = grpc.ServiceDesc{
        },
        Metadata: "tfplugin5.proto",
 }
-func init() { proto.RegisterFile("tfplugin5.proto", fileDescriptor_tfplugin5_56820f4fb67360c5) }
-var fileDescriptor_tfplugin5_56820f4fb67360c5 = []byte{
-        // 1876 bytes of a gzipped FileDescriptorProto
-        0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xcd, 0x6f, 0x23, 0x49,
-        0x15, 0x9f, 0x76, 0xdb, 0x89, 0xfd, 0x9c, 0x0f, 0xa7, 0x66, 0x76, 0x30, 0xbd, 0xbb, 0x10, 0xcc,
-        0x47, 0xb2, 0xda, 0x1d, 0xcf, 0x2a, 0x03, 0xbb, 0x4b, 0x18, 0xad, 0xc8, 0x66, 0x42, 0x26, 0x62,
-        0x26, 0x1b, 0xca, 0xf3, 0x81, 0x84, 0xb4, 0x56, 0x8d, 0xbb, 0xe2, 0x69, 0xc6, 0xee, 0xee, 0xad,
-        0x2e, 0x67, 0x62, 0x71, 0x44, 0x70, 0xe6, 0xc2, 0x87, 0xc4, 0xc7, 0x85, 0x03, 0xff, 0x00, 0x07,
-        0xe0, 0xc6, 0x89, 0x7f, 0x80, 0x1b, 0x70, 0x42, 0x70, 0x43, 0x1c, 0xe1, 0x82, 0x84, 0xea, 0xab,
-        0xbb, 0x6c, 0xb7, 0x93, 0x9e, 0x64, 0x57, 0x88, 0x5b, 0x57, 0xbd, 0x5f, 0xbd, 0xf7, 0xab, 0xf7,
-        0x5e, 0xbd, 0x57, 0x65, 0xc3, 0x2a, 0x3f, 0x8e, 0x07, 0xa3, 0x7e, 0x10, 0x7e, 0xa9, 0x1d, 0xb3,
-        0x88, 0x47, 0xa8, 0x96, 0x4e, 0xb4, 0x6e, 0xc3, 0xd2, 0x9d, 0x71, 0x48, 0x86, 0x41, 0xef, 0x11,
-        0x19, 0x8c, 0x28, 0x6a, 0xc2, 0xe2, 0x30, 0xe9, 0xc7, 0xa4, 0xf7, 0xac, 0xe9, 0xac, 0x3b, 0x9b,
-        0x4b, 0xd8, 0x0c, 0x11, 0x82, 0xf2, 0xb7, 0x93, 0x28, 0x6c, 0x96, 0xe4, 0xb4, 0xfc, 0x6e, 0xfd,
-        0xd5, 0x01, 0xb8, 0x13, 0x90, 0x7e, 0x18, 0x25, 0x3c, 0xe8, 0xa1, 0x6d, 0xa8, 0x26, 0xf4, 0x84,
-        0xb2, 0x80, 0x8f, 0xe5, 0xea, 0x95, 0xad, 0x4f, 0xb5, 0x33, 0xdb, 0x19, 0xb0, 0xdd, 0xd1, 0x28,
-        0x9c, 0xe2, 0x85, 0xe1, 0x64, 0x34, 0x1c, 0x12, 0x36, 0x96, 0x16, 0x6a, 0xd8, 0x0c, 0xd1, 0x75,
-        0x58, 0xf0, 0x29, 0x27, 0xc1, 0xa0, 0xe9, 0x4a, 0x81, 0x1e, 0xa1, 0xb7, 0xa0, 0x46, 0x38, 0x67,
-        0xc1, 0x93, 0x11, 0xa7, 0xcd, 0xf2, 0xba, 0xb3, 0x59, 0xdf, 0x6a, 0x5a, 0xe6, 0x76, 0x8c, 0xec,
-        0x88, 0xf0, 0xa7, 0x38, 0x83, 0xb6, 0x6e, 0x42, 0xd5, 0xd8, 0x47, 0x75, 0x58, 0x3c, 0x38, 0x7c,
-        0xb4, 0x73, 0xef, 0xe0, 0x4e, 0xe3, 0x0a, 0xaa, 0x41, 0x65, 0x0f, 0xe3, 0xf7, 0x71, 0xc3, 0x11,
-        0xf3, 0x8f, 0x77, 0xf0, 0xe1, 0xc1, 0xe1, 0x7e, 0xa3, 0xd4, 0xfa, 0xb3, 0x03, 0xcb, 0x13, 0xda,
-        0xd0, 0x2d, 0xa8, 0x24, 0x9c, 0xc6, 0x49, 0xd3, 0x59, 0x77, 0x37, 0xeb, 0x5b, 0xaf, 0xce, 0x33,
-        0xdb, 0xee, 0x70, 0x1a, 0x63, 0x85, 0xf5, 0x7e, 0xe8, 0x40, 0x59, 0x8c, 0xd1, 0x06, 0xac, 0xa4,
-        0x6c, 0xba, 0x21, 0x19, 0x52, 0xe9, 0xac, 0xda, 0xdd, 0x2b, 0x78, 0x39, 0x9d, 0x3f, 0x24, 0x43,
-        0x8a, 0xda, 0x80, 0xe8, 0x80, 0x0e, 0x69, 0xc8, 0xbb, 0xcf, 0xe8, 0xb8, 0x9b, 0x70, 0x16, 0x84,
-        0x7d, 0xe5, 0x9e, 0xbb, 0x57, 0x70, 0x43, 0xcb, 0xbe, 0x4e, 0xc7, 0x1d, 0x29, 0x41, 0x9b, 0xb0,
-        0x6a, 0xe3, 0x83, 0x90, 0x4b, 0x97, 0xb9, 0x42, 0x73, 0x06, 0x3e, 0x08, 0xf9, 0x7b, 0x20, 0x22,
-        0x35, 0xa0, 0x3d, 0x1e, 0xb1, 0xd6, 0x2d, 0x41, 0x2b, 0x8a, 0xbd, 0x1a, 0x2c, 0x62, 0xfa, 0xe1,
-        0x88, 0x26, 0xdc, 0x5b, 0x87, 0x2a, 0xa6, 0x49, 0x1c, 0x85, 0x09, 0x45, 0xd7, 0xa0, 0xb2, 0xc7,
-        0x58, 0xc4, 0x14, 0x49, 0xac, 0x06, 0xad, 0x1f, 0x39, 0x50, 0xc5, 0xe4, 0x79, 0x87, 0x13, 0x4e,
-        0xd3, 0xd4, 0x70, 0xb2, 0xd4, 0x40, 0xdb, 0xb0, 0x78, 0x3c, 0x20, 0x7c, 0x48, 0xe2, 0x66, 0x49,
-        0x3a, 0x69, 0xdd, 0x72, 0x92, 0x59, 0xd9, 0xfe, 0x9a, 0x82, 0xec, 0x85, 0x9c, 0x8d, 0xb1, 0x59,
-        0xe0, 0x6d, 0xc3, 0x92, 0x2d, 0x40, 0x0d, 0x70, 0x9f, 0xd1, 0xb1, 0x26, 0x20, 0x3e, 0x05, 0xa9,
-        0x13, 0x91, 0xaf, 0x3a, 0x57, 0xd4, 0x60, 0xbb, 0xf4, 0x8e, 0xd3, 0xfa, 0x7b, 0x05, 0x16, 0x3a,
-        0xbd, 0xa7, 0x74, 0x48, 0x44, 0x4a, 0x9d, 0x50, 0x96, 0x04, 0x9a, 0x99, 0x8b, 0xcd, 0x10, 0xdd,
-        0x80, 0xca, 0x93, 0x41, 0xd4, 0x7b, 0x26, 0x97, 0xd7, 0xb7, 0x3e, 0x61, 0x51, 0x53, 0x6b, 0xdb,
-        0xef, 0x09, 0x31, 0x56, 0x28, 0xef, 0x17, 0x0e, 0x54, 0xe4, 0xc4, 0x19, 0x2a, 0xbf, 0x02, 0x90,
-        0x06, 0x2f, 0xd1, 0x5b, 0x7e, 0x79, 0x56, 0x6f, 0x9a, 0x1e, 0xd8, 0x82, 0xa3, 0x77, 0xa1, 0x2e,
-        0x2d, 0x75, 0xf9, 0x38, 0xa6, 0x49, 0xd3, 0x9d, 0xc9, 0x2a, 0xbd, 0xfa, 0x90, 0x26, 0x9c, 0xfa,
-        0x8a, 0x1b, 0xc8, 0x15, 0x0f, 0xc4, 0x02, 0xef, 0x0f, 0x0e, 0xd4, 0x52, 0xcd, 0x22, 0x1c, 0x59,
-        0x56, 0x61, 0xf9, 0x2d, 0xe6, 0x84, 0x6e, 0x73, 0x7a, 0xc5, 0x37, 0x5a, 0x87, 0xba, 0x4f, 0x93,
-        0x1e, 0x0b, 0x62, 0x2e, 0x36, 0xa4, 0x4e, 0x97, 0x3d, 0x85, 0x3c, 0xa8, 0x32, 0xfa, 0xe1, 0x28,
-        0x60, 0xd4, 0x97, 0x27, 0xac, 0x8a, 0xd3, 0xb1, 0x90, 0x45, 0x12, 0x45, 0x06, 0xcd, 0x8a, 0x92,
-        0x99, 0xb1, 0x90, 0xf5, 0xa2, 0x61, 0x3c, 0xe2, 0xd4, 0x6f, 0x2e, 0x28, 0x99, 0x19, 0xa3, 0x57,
-        0xa0, 0x96, 0xd0, 0x30, 0x09, 0x78, 0x70, 0x42, 0x9b, 0x8b, 0x52, 0x98, 0x4d, 0x78, 0xbf, 0x2a,
-        0x41, 0xdd, 0xda, 0x25, 0x7a, 0x19, 0x6a, 0x82, 0xab, 0x75, 0x4c, 0x70, 0x55, 0x4c, 0xc8, 0xf3,
-        0xf1, 0x62, 0x61, 0x44, 0xbb, 0xb0, 0x18, 0xd2, 0x84, 0x8b, 0x33, 0xe4, 0xca, 0xea, 0xf4, 0xda,
-        0x99, 0x1e, 0x96, 0xdf, 0x41, 0xd8, 0xbf, 0x1f, 0xf9, 0x14, 0x9b, 0x95, 0x82, 0xd0, 0x30, 0x08,
-        0xbb, 0x01, 0xa7, 0xc3, 0x44, 0xfa, 0xc4, 0xc5, 0xd5, 0x61, 0x10, 0x1e, 0x88, 0xb1, 0x14, 0x92,
-        0x53, 0x2d, 0xac, 0x68, 0x21, 0x39, 0x95, 0xc2, 0xd6, 0x7d, 0xb5, 0x33, 0xad, 0x71, 0xb2, 0xf4,
-        0x00, 0x2c, 0x74, 0x0e, 0x0e, 0xf7, 0xef, 0xed, 0x35, 0x1c, 0x54, 0x85, 0xf2, 0xbd, 0x83, 0xce,
-        0x83, 0x46, 0x09, 0x2d, 0x82, 0xdb, 0xd9, 0x7b, 0xd0, 0x70, 0xc5, 0xc7, 0xfd, 0x9d, 0xa3, 0x46,
-        0x59, 0x94, 0xa8, 0x7d, 0xfc, 0xfe, 0xc3, 0xa3, 0x46, 0xa5, 0xf5, 0x93, 0x32, 0xac, 0xed, 0x53,
-        0x7e, 0xc4, 0xa2, 0x93, 0xc0, 0xa7, 0x4c, 0xf1, 0xb7, 0x0f, 0xf1, 0xbf, 0x5c, 0xeb, 0x14, 0xdf,
-        0x80, 0x6a, 0xac, 0x91, 0xd2, 0x8d, 0xf5, 0xad, 0xb5, 0x99, 0xcd, 0xe3, 0x14, 0x82, 0x28, 0x34,
-        0x18, 0x4d, 0xa2, 0x11, 0xeb, 0xd1, 0x6e, 0x22, 0x85, 0x26, 0xa7, 0xb7, 0xad, 0x65, 0x33, 0xe6,
-        0xdb, 0xc6, 0x9e, 0xf8, 0x90, 0xab, 0xd5, 0x7c, 0xa2, 0x0e, 0xf8, 0x2a, 0x9b, 0x9c, 0x45, 0x03,
-        0xb8, 0xea, 0x13, 0x4e, 0xba, 0x53, 0x96, 0x54, 0xfe, 0xdf, 0x2e, 0x66, 0xe9, 0x0e, 0xe1, 0xa4,
-        0x33, 0x6b, 0x6b, 0xcd, 0x9f, 0x9e, 0x47, 0x6f, 0x43, 0xdd, 0x4f, 0x7b, 0x90, 0x08, 0x9e, 0xb0,
-        0xf2, 0x52, 0x6e, 0x87, 0xc2, 0x36, 0xd2, 0x7b, 0x08, 0xd7, 0xf2, 0xf6, 0x93, 0x53, 0x97, 0x36,
-        0xec, 0xba, 0x94, 0xeb, 0xe3, 0xac, 0x54, 0x79, 0x8f, 0xe1, 0x7a, 0x3e, 0xf9, 0x4b, 0x2a, 0x6e,
-        0xfd, 0xc9, 0x81, 0x97, 0x8e, 0x18, 0x8d, 0x09, 0xa3, 0xc6, 0x6b, 0xbb, 0x51, 0x78, 0x1c, 0xf4,
-        0xbd, 0xed, 0x34, 0x3d, 0xd0, 0x4d, 0x58, 0xe8, 0xc9, 0x49, 0x9d, 0x0f, 0xf6, 0xe9, 0xb1, 0xaf,
-        0x04, 0x58, 0xc3, 0xbc, 0xef, 0x39, 0x56, 0x3e, 0x7d, 0x15, 0x56, 0x63, 0x65, 0xc1, 0xef, 0x16,
-        0x53, 0xb3, 0x62, 0xf0, 0x8a, 0xca, 0x74, 0x34, 0x4a, 0x45, 0xa3, 0xd1, 0xfa, 0x41, 0x09, 0xae,
-        0x3d, 0x8c, 0xfb, 0x8c, 0xf8, 0x34, 0x8d, 0x8a, 0x68, 0x26, 0x1e, 0xcb, 0x36, 0x77, 0x66, 0xd9,
-        0xb0, 0x8a, 0x78, 0x69, 0xb2, 0x88, 0xbf, 0x09, 0x35, 0x46, 0x9e, 0x77, 0x13, 0xa1, 0x4e, 0xd6,
-        0x88, 0xfa, 0xd6, 0xd5, 0x9c, 0xb6, 0x85, 0xab, 0x4c, 0x7f, 0x79, 0xdf, 0xb5, 0x9d, 0xf2, 0x2e,
-        0xac, 0x8c, 0x14, 0x31, 0x5f, 0xeb, 0x38, 0xc7, 0x27, 0xcb, 0x06, 0xae, 0xfa, 0xe8, 0x85, 0x5d,
-        0xf2, 0x3b, 0x07, 0xbc, 0x47, 0x64, 0x10, 0xf8, 0x82, 0x9c, 0xf6, 0x89, 0xe8, 0x0c, 0x3a, 0xea,
-        0x8f, 0x0b, 0x3a, 0x26, 0x4b, 0x89, 0x52, 0xb1, 0x94, 0xd8, 0xb5, 0x36, 0x3f, 0x45, 0xde, 0x29,
-        0x4c, 0xfe, 0x37, 0x0e, 0x34, 0x0d, 0xf9, 0xec, 0x3c, 0xfc, 0x5f, 0x50, 0xff, 0xad, 0x03, 0x35,
-        0x45, 0x74, 0xc4, 0xa8, 0xd7, 0xcf, 0xb8, 0xbe, 0x0e, 0x6b, 0x9c, 0x32, 0x46, 0x8e, 0x23, 0x36,
-        0xec, 0xda, 0x37, 0x86, 0x1a, 0x6e, 0xa4, 0x82, 0x47, 0x3a, 0xeb, 0xfe, 0x37, 0xdc, 0xff, 0xe9,
-        0xc0, 0x12, 0xa6, 0xc4, 0x37, 0xf9, 0xe2, 0xf9, 0x05, 0x5d, 0x7d, 0x1b, 0x96, 0x7b, 0x23, 0xc6,
-        0xc4, 0x2d, 0x53, 0x25, 0xf9, 0x39, 0xac, 0x97, 0x34, 0x5a, 0x1d, 0x98, 0xb1, 0xc5, 0xfd, 0x8b,
-        0x50, 0x0b, 0xe9, 0xf3, 0x62, 0x47, 0xa5, 0x1a, 0xd2, 0xe7, 0x97, 0x3c, 0x25, 0xbf, 0x2e, 0x03,
-        0x3a, 0x1a, 0x90, 0xd0, 0xec, 0x78, 0xf7, 0x29, 0x09, 0xfb, 0xd4, 0xfb, 0x8f, 0x53, 0x70, 0xe3,
-        0xef, 0x40, 0x3d, 0x66, 0x41, 0xc4, 0x8a, 0x6d, 0x1b, 0x24, 0x56, 0x51, 0xde, 0x03, 0x14, 0xb3,
-        0x28, 0x8e, 0x12, 0xea, 0x77, 0xb3, 0x1d, 0xbb, 0x67, 0x2b, 0x68, 0x98, 0x25, 0x87, 0x66, 0xe7,
-        0x59, 0xa2, 0x94, 0x0b, 0x25, 0x0a, 0xfa, 0x2c, 0x2c, 0x2b, 0xc6, 0x31, 0x0b, 0x4e, 0x84, 0xc9,
-        0x8a, 0xbc, 0xfe, 0x2d, 0xc9, 0xc9, 0x23, 0x35, 0xe7, 0xfd, 0xbc, 0x64, 0x85, 0xe4, 0x36, 0x2c,
-        0xc7, 0x03, 0x12, 0x86, 0x45, 0x2b, 0xd8, 0x92, 0x46, 0x2b, 0x82, 0xbb, 0xe2, 0xda, 0x20, 0xef,
-        0x87, 0x49, 0x97, 0xd1, 0x78, 0x40, 0x7a, 0x54, 0xc7, 0x67, 0xfe, 0xcb, 0x6c, 0xd5, 0xac, 0xc0,
-        0x6a, 0x01, 0xda, 0x80, 0x55, 0x43, 0xc1, 0xd0, 0x76, 0x25, 0xed, 0x15, 0x3d, 0xad, 0x89, 0x5f,
-        0xb8, 0x9f, 0xa3, 0x37, 0x00, 0x0d, 0x68, 0x9f, 0xf4, 0xc6, 0xf2, 0xbe, 0xdd, 0x4d, 0xc6, 0x09,
-        0xa7, 0x43, 0x7d, 0x89, 0x6d, 0x28, 0x89, 0xa8, 0x9e, 0x1d, 0x39, 0xdf, 0xfa, 0xa3, 0x0b, 0x57,
-        0x77, 0xe2, 0x78, 0x30, 0x9e, 0xca, 0x9b, 0x7f, 0x7f, 0xfc, 0x79, 0x33, 0x13, 0x0d, 0xf7, 0x45,
-        0xa2, 0xf1, 0xc2, 0xe9, 0x92, 0xe3, 0xf9, 0x4a, 0x9e, 0xe7, 0xbd, 0xdf, 0x3b, 0x97, 0x3e, 0xc5,
-        0x4d, 0x58, 0x34, 0x36, 0xd4, 0x9b, 0xc4, 0x0c, 0xa7, 0xc3, 0xea, 0x5e, 0x32, 0xac, 0xe5, 0x39,
-        0x61, 0xfd, 0x47, 0x09, 0xae, 0x1e, 0x0c, 0xe3, 0x88, 0xf1, 0xc9, 0x5b, 0xc4, 0x5b, 0x05, 0xa3,
-        0xba, 0x02, 0xa5, 0xc0, 0xd7, 0xef, 0xcf, 0x52, 0xe0, 0x7b, 0xa7, 0xd0, 0x50, 0xea, 0x68, 0x5a,
-        0x52, 0xcf, 0x7d, 0xbd, 0x14, 0x4a, 0x08, 0x85, 0xb2, 0x1d, 0xe6, 0x4e, 0x38, 0xcc, 0xfb, 0xa5,
-        0x1d, 0x8d, 0x0f, 0x00, 0x05, 0x9a, 0x46, 0xd7, 0x5c, 0xb7, 0x4d, 0x5b, 0xb8, 0x69, 0x99, 0xc8,
-        0xd9, 0x7a, 0x7b, 0x9a, 0x3f, 0x5e, 0x0b, 0xa6, 0x66, 0x92, 0x8b, 0x57, 0xdf, 0xbf, 0x38, 0xb0,
-        0x22, 0xfa, 0x4d, 0xd6, 0xe2, 0x3f, 0xbe, 0xe6, 0xce, 0x26, 0x5e, 0x3e, 0x95, 0x42, 0xa9, 0xa9,
-        0xdd, 0x7c, 0xe1, 0xfd, 0xfd, 0xd4, 0x81, 0x6b, 0xe6, 0x99, 0x22, 0xda, 0x7a, 0xde, 0x93, 0xec,
-        0xd4, 0xe2, 0x75, 0x4b, 0x54, 0x85, 0x14, 0x3b, 0xff, 0x51, 0x66, 0xa3, 0x2e, 0xce, 0xee, 0x67,
-        0x0e, 0x7c, 0xd2, 0x5c, 0xb2, 0x2c, 0x8a, 0x1f, 0xc1, 0xb3, 0xe0, 0x23, 0xb9, 0x8c, 0xfc, 0xcd,
-        0x81, 0xb5, 0x94, 0x56, 0x7a, 0x23, 0x49, 0x2e, 0x4e, 0x0b, 0xbd, 0x0d, 0xd0, 0x8b, 0xc2, 0x90,
-        0xf6, 0xb8, 0xb9, 0xe7, 0x9f, 0x55, 0x73, 0x33, 0xa8, 0xf7, 0x2d, 0x6b, 0x3f, 0xd7, 0x61, 0x21,
-        0x1a, 0xf1, 0x78, 0xc4, 0x75, 0x4a, 0xea, 0xd1, 0x85, 0xc3, 0xb0, 0xf5, 0xe3, 0x1a, 0x54, 0xcd,
-        0x93, 0x0c, 0x7d, 0x13, 0x6a, 0xfb, 0x94, 0xeb, 0x1f, 0xab, 0x3e, 0x77, 0xce, 0x6b, 0x57, 0x25,
-        0xd0, 0xe7, 0x0b, 0xbd, 0x89, 0xd1, 0x60, 0xce, 0xfb, 0x0f, 0x6d, 0x5a, 0xeb, 0x73, 0x11, 0xa9,
-        0xa5, 0xd7, 0x0a, 0x20, 0xb5, 0xb5, 0xef, 0x9c, 0xf5, 0xf8, 0x40, 0x37, 0x2c, 0x45, 0xf3, 0x61,
-        0xa9, 0xdd, 0x76, 0x51, 0xb8, 0x36, 0x3e, 0x9a, 0xff, 0x78, 0x40, 0xaf, 0xe7, 0xe8, 0x9a, 0x06,
-        0xa5, 0x86, 0xdf, 0x28, 0x06, 0xd6, 0x66, 0x83, 0xfc, 0x37, 0x28, 0xda, 0xb0, 0xb4, 0xe4, 0x01,
-        0x52, 0x73, 0x9b, 0xe7, 0x03, 0xb5, 0xa9, 0xbb, 0xd6, 0x1b, 0x03, 0xbd, 0x62, 0x2d, 0x4b, 0x67,
-        0x53, 0xa5, 0xaf, 0xce, 0x91, 0x6a, 0x4d, 0xdf, 0x98, 0xbc, 0xf1, 0xa3, 0x4f, 0xdb, 0x6f, 0x5b,
-        0x4b, 0x90, 0xea, 0x5b, 0x9f, 0x0f, 0xd0, 0x2a, 0x7b, 0x79, 0x57, 0x6a, 0x64, 0xa7, 0xe9, 0xac,
-        0x38, 0x55, 0xff, 0x85, 0xf3, 0x60, 0xda, 0xc8, 0x71, 0xee, 0x05, 0x0c, 0xd9, 0xcb, 0x73, 0xe4,
-        0xa9, 0x99, 0x8d, 0x73, 0x71, 0x99, 0x9d, 0x9c, 0xb6, 0x38, 0x61, 0x27, 0xaf, 0x6d, 0xe6, 0xd9,
-        0xc9, 0xc7, 0x69, 0x3b, 0x8f, 0xa7, 0x3b, 0x21, 0xfa, 0xcc, 0x94, 0xa3, 0x33, 0x51, 0xaa, 0xbd,
-        0x75, 0x16, 0x44, 0x2b, 0xfe, 0xb2, 0xfa, 0x29, 0x1f, 0x4d, 0xfc, 0x12, 0xca, 0xa3, 0x38, 0x55,
-        0xd2, 0x9c, 0x15, 0xa8, 0xa5, 0x5b, 0xdf, 0x77, 0xa1, 0x6e, 0x35, 0x06, 0xf4, 0x81, 0x5d, 0x9c,
-        0x36, 0x72, 0xca, 0x8e, 0xdd, 0xe3, 0x72, 0xb3, 0x7a, 0x0e, 0x50, 0x53, 0x3d, 0x3d, 0xa3, 0x1f,
-        0xa1, 0xbc, 0xb3, 0x38, 0x83, 0x4a, 0x8d, 0xde, 0x28, 0x88, 0xd6, 0x96, 0x9f, 0xe4, 0xb4, 0x9a,
-        0x89, 0xf2, 0x3b, 0x23, 0xcd, 0x2d, 0xbf, 0x79, 0x28, 0x65, 0xe1, 0x4d, 0xe7, 0x12, 0x81, 0x78,
-        0xb2, 0x20, 0xff, 0xa3, 0xbb, 0xf5, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xc8, 0x16, 0x0b, 0x32,
-        0xb6, 0x1b, 0x00, 0x00,
-}
diff --git a/vendor/github.com/hashicorp/terraform/internal/tfplugin5/tfplugin5.proto b/vendor/github.com/hashicorp/terraform/internal/tfplugin5/tfplugin5.proto
deleted file mode 100644
index 370faf7..0000000
--- a/vendor/github.com/hashicorp/terraform/internal/tfplugin5/tfplugin5.proto
+++ /dev/null
@@ -1,351 +0,0 @@
-// Terraform Plugin RPC protocol version 5.0
-//
-// This file defines version 5.0 of the RPC protocol. To implement a plugin
-// against this protocol, copy this definition into your own codebase and
-// use protoc to generate stubs for your target language.
-//
-// This file will be updated in-place in the source Terraform repository for
-// any minor versions of protocol 5, but later minor versions will always be
-// backwards compatible. Breaking changes, if any are required, will come
-// in a subsequent major version with its own separate proto definition.
-//
-// Note that only the proto files included in a release tag of Terraform are
-// official protocol releases. Proto files taken from other commits may include
-// incomplete changes or features that did not make it into a final release.
-// In all reasonable cases, plugin developers should take the proto file from
-// the tag of the most recent release of Terraform, and not from the master
-// branch or any other development branch.
-//
-syntax = "proto3";
-package tfplugin5;
-// DynamicValue is an opaque encoding of terraform data, with the field name
-// indicating the encoding scheme used.
-message DynamicValue {
-    bytes msgpack = 1;
-    bytes json = 2;
-}
-message Diagnostic {
-    enum Severity {
-        INVALID = 0;
-        ERROR = 1;
-        WARNING = 2;
-    }
-    Severity severity = 1;
-    string summary = 2;
-    string detail = 3;
-    AttributePath attribute = 4;
-}
-message AttributePath {
-    message Step {
-        oneof selector {
-            // Set "attribute_name" to represent looking up an attribute
-            // in the current object value.
-            string attribute_name = 1;
-            // Set "element_key_*" to represent looking up an element in
-            // an indexable collection type.
-            string element_key_string = 2;
-            int64 element_key_int = 3;
-        }
-    }
-    repeated Step steps = 1;
-}
-message Stop {
-    message Request {
-    }
-    message Response {
-                string Error = 1;
-    }
-}
-// RawState holds the stored state for a resource to be upgraded by the
-// provider. It can be in one of two formats, the current json encoded format
-// in bytes, or the legacy flatmap format as a map of strings.
-message RawState {
-    bytes json = 1;
-    map<string, string> flatmap = 2;
-}
-// Schema is the configuration schema for a Resource, Provider, or Provisioner.
-message Schema {
-    message Block {
-        int64 version = 1;
-        repeated Attribute attributes = 2;
-        repeated NestedBlock block_types = 3;
-    }
-    message Attribute {
-        string name = 1;
-        bytes type = 2;
-        string description = 3;
-        bool required = 4;
-        bool optional = 5;
-        bool computed = 6;
-        bool sensitive = 7;
-    }
-    message NestedBlock {
-        enum NestingMode {
-            INVALID = 0;
-            SINGLE = 1;
-            LIST = 2;
-            SET = 3;
-            MAP = 4;
-            GROUP = 5;
-        }
-        string type_name = 1;
-        Block block = 2;
-        NestingMode nesting = 3;
-        int64 min_items = 4;
-        int64 max_items = 5;
-    }
-    // The version of the schema.
-    // Schemas are versioned, so that providers can upgrade a saved resource
-    // state when the schema is changed. 
-    int64 version = 1;
-    // Block is the top level configuration block for this schema.
-    Block block = 2;
-}
-service Provider {
-    //////// Information about what a provider supports/expects
-    rpc GetSchema(GetProviderSchema.Request) returns (GetProviderSchema.Response);
-    rpc PrepareProviderConfig(PrepareProviderConfig.Request) returns (PrepareProviderConfig.Response);
-    rpc ValidateResourceTypeConfig(ValidateResourceTypeConfig.Request) returns (ValidateResourceTypeConfig.Response);
-    rpc ValidateDataSourceConfig(ValidateDataSourceConfig.Request) returns (ValidateDataSourceConfig.Response);
-    rpc UpgradeResourceState(UpgradeResourceState.Request) returns (UpgradeResourceState.Response);
-    //////// One-time initialization, called before other functions below
-    rpc Configure(Configure.Request) returns (Configure.Response);
-    //////// Managed Resource Lifecycle
-    rpc ReadResource(ReadResource.Request) returns (ReadResource.Response);
-    rpc PlanResourceChange(PlanResourceChange.Request) returns (PlanResourceChange.Response);
-    rpc ApplyResourceChange(ApplyResourceChange.Request) returns (ApplyResourceChange.Response);
-    rpc ImportResourceState(ImportResourceState.Request) returns (ImportResourceState.Response);
-    rpc ReadDataSource(ReadDataSource.Request) returns (ReadDataSource.Response);
-    //////// Graceful Shutdown
-    rpc Stop(Stop.Request) returns (Stop.Response);
-}
-message GetProviderSchema {
-    message Request {
-    }
-    message Response {
-        Schema provider = 1;
-        map<string, Schema> resource_schemas = 2;
-        map<string, Schema> data_source_schemas = 3;
-        repeated Diagnostic diagnostics = 4;
-    }
-}
-message PrepareProviderConfig {
-    message Request {
-        DynamicValue config = 1;
-    }
-    message Response {
-        DynamicValue prepared_config = 1;
-        repeated Diagnostic diagnostics = 2;
-    }
-}
-message UpgradeResourceState {
-    message Request {
-        string type_name = 1;
-        // version is the schema_version number recorded in the state file
-        int64 version = 2;
-        // raw_state is the raw states as stored for the resource.  Core does
-        // not have access to the schema of prior_version, so it's the
-        // provider's responsibility to interpret this value using the
-        // appropriate older schema. The raw_state will be the json encoded
-        // state, or a legacy flat-mapped format.
-        RawState raw_state = 3;
-    }
-    message Response {
-        // new_state is a msgpack-encoded data structure that, when interpreted with
-        // the _current_ schema for this resource type, is functionally equivalent to
-        // that which was given in prior_state_raw.
-        DynamicValue upgraded_state = 1;
-        // diagnostics describes any errors encountered during migration that could not
-        // be safely resolved, and warnings about any possibly-risky assumptions made
-        // in the upgrade process.
-        repeated Diagnostic diagnostics = 2;
-    }
-}
-message ValidateResourceTypeConfig {
-    message Request {
-        string type_name = 1;
-        DynamicValue config = 2;
-    }
-    message Response {
-        repeated Diagnostic diagnostics = 1;
-    }
-}
-message ValidateDataSourceConfig {
-    message Request {
-        string type_name = 1;
-        DynamicValue config = 2;
-    }
-    message Response {
-        repeated Diagnostic diagnostics = 1;
-    }
-}
-message Configure {
-    message Request {
-        string terraform_version = 1;
-        DynamicValue config = 2;
-    }
-    message Response {
-        repeated Diagnostic diagnostics = 1;
-    }
-}
-message ReadResource {
-    message Request {
-        string type_name = 1;
-        DynamicValue current_state = 2;
-    }
-    message Response {
-        DynamicValue new_state = 1;
-        repeated Diagnostic diagnostics = 2;
-    }
-}
-message PlanResourceChange {
-    message Request {
-        string type_name = 1;
-        DynamicValue prior_state = 2;
-        DynamicValue proposed_new_state = 3;
-        DynamicValue config = 4;
-        bytes prior_private = 5; 
-    }
-    message Response {
-        DynamicValue planned_state = 1;
-        repeated AttributePath requires_replace = 2;
-        bytes planned_private = 3; 
-        repeated Diagnostic diagnostics = 4;
-        // This may be set only by the helper/schema "SDK" in the main Terraform
-        // repository, to request that Terraform Core >=0.12 permit additional
-        // inconsistencies that can result from the legacy SDK type system
-        // and its imprecise mapping to the >=0.12 type system.
-        // The change in behavior implied by this flag makes sense only for the
-        // specific details of the legacy SDK type system, and are not a general
-        // mechanism to avoid proper type handling in providers.
-        //
-        //     ====              DO NOT USE THIS              ====
-        //     ==== THIS MUST BE LEFT UNSET IN ALL OTHER SDKS ====
-        //     ====              DO NOT USE THIS              ====
-        bool legacy_type_system = 5;
-    }
-}
-message ApplyResourceChange {
-    message Request {
-        string type_name = 1;
-        DynamicValue prior_state = 2;
-        DynamicValue planned_state = 3;
-        DynamicValue config = 4;
-        bytes planned_private = 5; 
-    }
-    message Response {
-        DynamicValue new_state = 1;
-        bytes private = 2; 
-        repeated Diagnostic diagnostics = 3;
-        // This may be set only by the helper/schema "SDK" in the main Terraform
-        // repository, to request that Terraform Core >=0.12 permit additional
-        // inconsistencies that can result from the legacy SDK type system
-        // and its imprecise mapping to the >=0.12 type system.
-        // The change in behavior implied by this flag makes sense only for the
-        // specific details of the legacy SDK type system, and are not a general
-        // mechanism to avoid proper type handling in providers.
-        //
-        //     ====              DO NOT USE THIS              ====
-        //     ==== THIS MUST BE LEFT UNSET IN ALL OTHER SDKS ====
-        //     ====              DO NOT USE THIS              ====
-        bool legacy_type_system = 4;
-    }
-}
-message ImportResourceState {
-    message Request {
-        string type_name = 1;
-        string id = 2;
-    }
-    message ImportedResource {
-        string type_name = 1;
-        DynamicValue state = 2;
-        bytes private = 3;
-    }
-    message Response {
-        repeated ImportedResource imported_resources = 1;
-        repeated Diagnostic diagnostics = 2;
-    }
-}
-message ReadDataSource {
-    message Request {
-        string type_name = 1;
-        DynamicValue config = 2;
-    }
-    message Response {
-        DynamicValue state = 1;
-        repeated Diagnostic diagnostics = 2;
-    }
-}
-service Provisioner {
-    rpc GetSchema(GetProvisionerSchema.Request) returns (GetProvisionerSchema.Response);
-    rpc ValidateProvisionerConfig(ValidateProvisionerConfig.Request) returns (ValidateProvisionerConfig.Response);
-    rpc ProvisionResource(ProvisionResource.Request) returns (stream ProvisionResource.Response);
-    rpc Stop(Stop.Request) returns (Stop.Response);
-}
-message GetProvisionerSchema {
-    message Request {
-    }
-    message Response {
-        Schema provisioner = 1;
-        repeated Diagnostic diagnostics = 2;
-    }
-}
-message ValidateProvisionerConfig {
-    message Request {
-        DynamicValue config = 1;
-    }
-    message Response {
-        repeated Diagnostic diagnostics = 1;
-    }
-}
-message ProvisionResource {
-    message Request {
-        DynamicValue config = 1;
-        DynamicValue connection = 2;
-    }
-    message Response {
-        string output  = 1;
-        repeated Diagnostic diagnostics = 2;
-    }   
-}
diff --git a/vendor/github.com/hashicorp/terraform/lang/blocktoattr/schema.go b/vendor/github.com/hashicorp/terraform/lang/blocktoattr/schema.go
index 2f2463a..47a0256 100644
--- a/vendor/github.com/hashicorp/terraform/lang/blocktoattr/schema.go
+++ b/vendor/github.com/hashicorp/terraform/lang/blocktoattr/schema.go
@@ -55,10 +55,11 @@ func effectiveSchema(given *hcl.BodySchema, body hcl.Body, ambiguousNames map[st
                                },
                        }
                        content, _, _ = body.PartialContent(&probeSchema)
-                        if len(content.Blocks) > 0 {
+                        if len(content.Blocks) > 0 || dynamicExpanded {
-                                // No attribute present and at least one block present, so
+                                // A dynamic block with an empty iterator returns nothing.
-                                // we'll need to rewrite this one as a block for a successful
+                                // If there's no attribute and we have either a block or a
-                                // result.
+                                // dynamic expansion, we need to rewrite this one as a
+                                // block for a successful result.
                                appearsAsBlock[name] = struct{}{}
                        }
                }
diff --git a/vendor/github.com/hashicorp/terraform/lang/blocktoattr/variables.go b/vendor/github.com/hashicorp/terraform/lang/blocktoattr/variables.go
index e123b8a..b172805 100644
--- a/vendor/github.com/hashicorp/terraform/lang/blocktoattr/variables.go
+++ b/vendor/github.com/hashicorp/terraform/lang/blocktoattr/variables.go
@@ -33,7 +33,7 @@ func walkVariables(node dynblock.WalkVariablesNode, body hcl.Body, schema *confi
        for _, child := range children {
                if blockS, exists := schema.BlockTypes[child.BlockTypeName]; exists {
                        vars = append(vars, walkVariables(child.Node, child.Body(), &blockS.Block)...)
-                } else if attrS, exists := schema.Attributes[child.BlockTypeName]; exists {
+                } else if attrS, exists := schema.Attributes[child.BlockTypeName]; exists && attrS.Type.ElementType().IsObjectType() {
                        synthSchema := SchemaForCtyElementType(attrS.Type.ElementType())
                        vars = append(vars, walkVariables(child.Node, child.Body(), synthSchema)...)
                }
diff --git a/vendor/github.com/hashicorp/terraform/lang/data.go b/vendor/github.com/hashicorp/terraform/lang/data.go
index 80313d6..eca588e 100644
--- a/vendor/github.com/hashicorp/terraform/lang/data.go
+++ b/vendor/github.com/hashicorp/terraform/lang/data.go
@@ -23,6 +23,7 @@ type Data interface {
        StaticValidateReferences(refs []*addrs.Reference, self addrs.Referenceable) tfdiags.Diagnostics
        GetCountAttr(addrs.CountAttr, tfdiags.SourceRange) (cty.Value, tfdiags.Diagnostics)
+        GetForEachAttr(addrs.ForEachAttr, tfdiags.SourceRange) (cty.Value, tfdiags.Diagnostics)
        GetResourceInstance(addrs.ResourceInstance, tfdiags.SourceRange) (cty.Value, tfdiags.Diagnostics)
        GetLocalValue(addrs.LocalValue, tfdiags.SourceRange) (cty.Value, tfdiags.Diagnostics)
        GetModuleInstance(addrs.ModuleCallInstance, tfdiags.SourceRange) (cty.Value, tfdiags.Diagnostics)
diff --git a/vendor/github.com/hashicorp/terraform/lang/eval.go b/vendor/github.com/hashicorp/terraform/lang/eval.go
index a3fb363..a8fe8b6 100644
--- a/vendor/github.com/hashicorp/terraform/lang/eval.go
+++ b/vendor/github.com/hashicorp/terraform/lang/eval.go
@@ -203,6 +203,7 @@ func (s *Scope) evalContext(refs []*addrs.Reference, selfAddr addrs.Referenceabl
        pathAttrs := map[string]cty.Value{}
        terraformAttrs := map[string]cty.Value{}
        countAttrs := map[string]cty.Value{}
+        forEachAttrs := map[string]cty.Value{}
        var self cty.Value
        for _, ref := range refs {
@@ -334,6 +335,14 @@ func (s *Scope) evalContext(refs []*addrs.Reference, selfAddr addrs.Referenceabl
                                self = val
                        }
+                case addrs.ForEachAttr:
+                        val, valDiags := normalizeRefValue(s.Data.GetForEachAttr(subj, rng))
+                        diags = diags.Append(valDiags)
+                        forEachAttrs[subj.Name] = val
+                        if isSelf {
+                                self = val
+                        }
                default:
                        // Should never happen
                        panic(fmt.Errorf("Scope.buildEvalContext cannot handle address type %T", rawSubj))
@@ -350,6 +359,7 @@ func (s *Scope) evalContext(refs []*addrs.Reference, selfAddr addrs.Referenceabl
        vals["path"] = cty.ObjectVal(pathAttrs)
        vals["terraform"] = cty.ObjectVal(terraformAttrs)
        vals["count"] = cty.ObjectVal(countAttrs)
+        vals["each"] = cty.ObjectVal(forEachAttrs)
        if self != cty.NilVal {
                vals["self"] = self
        }
diff --git a/vendor/github.com/hashicorp/terraform/lang/funcs/collection.go b/vendor/github.com/hashicorp/terraform/lang/funcs/collection.go
index 71b7a84..bcccc1f 100644
--- a/vendor/github.com/hashicorp/terraform/lang/funcs/collection.go
+++ b/vendor/github.com/hashicorp/terraform/lang/funcs/collection.go
@@ -246,7 +246,7 @@ var CompactFunc = function.New(&function.Spec{
                for it := listVal.ElementIterator(); it.Next(); {
                        _, v := it.Element()
-                        if v.AsString() == "" {
+                        if v.IsNull() || v.AsString() == "" {
                                continue
                        }
                        outputList = append(outputList, v)
@@ -363,6 +363,9 @@ var DistinctFunc = function.New(&function.Spec{
                        }
                }
+                if len(list) == 0 {
+                        return cty.ListValEmpty(retType.ElementType()), nil
+                }
                return cty.ListVal(list), nil
        },
 })
@@ -389,6 +392,10 @@ var ChunklistFunc = function.New(&function.Spec{
                        return cty.UnknownVal(retType), nil
                }
+                if listVal.LengthInt() == 0 {
+                        return cty.ListValEmpty(listVal.Type()), nil
+                }
                var size int
                err = gocty.FromCtyValue(args[1], &size)
                if err != nil {
@@ -686,8 +693,10 @@ var LookupFunc = function.New(&function.Spec{
                                        return cty.StringVal(v.AsString()), nil
                                case ty.Equals(cty.Number):
                                        return cty.NumberVal(v.AsBigFloat()), nil
+                                case ty.Equals(cty.Bool):
+                                        return cty.BoolVal(v.True()), nil
                                default:
-                                        return cty.NilVal, errors.New("lookup() can only be used with flat lists")
+                                        return cty.NilVal, errors.New("lookup() can only be used with maps of primitive types")
                                }
                        }
                }
@@ -797,10 +806,12 @@ var MatchkeysFunc = function.New(&function.Spec{
                },
        },
        Type: func(args []cty.Value) (cty.Type, error) {
-                if !args[1].Type().Equals(args[2].Type()) {
+                ty, _ := convert.UnifyUnsafe([]cty.Type{args[1].Type(), args[2].Type()})
-                        return cty.NilType, errors.New("lists must be of the same type")
+                if ty == cty.NilType {
+                        return cty.NilType, errors.New("keys and searchset must be of the same type")
                }
+                // the return type is based on args[0] (values)
                return args[0].Type(), nil
        },
        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
@@ -813,10 +824,14 @@ var MatchkeysFunc = function.New(&function.Spec{
                }
                output := make([]cty.Value, 0)
                values := args[0]
-                keys := args[1]
-                searchset := args[2]
+                // Keys and searchset must be the same type.
+                // We can skip error checking here because we've already verified that
+                // they can be unified in the Type function
+                ty, _ := convert.UnifyUnsafe([]cty.Type{args[1].Type(), args[2].Type()})
+                keys, _ := convert.Convert(args[1], ty)
+                searchset, _ := convert.Convert(args[2], ty)
                // if searchset is empty, return an empty list.
                if searchset.LengthInt() == 0 {
@@ -867,7 +882,6 @@ var MergeFunc = function.New(&function.Spec{
                Name:             "maps",
                Type:             cty.DynamicPseudoType,
                AllowDynamicType: true,
-                AllowNull:        true,
        },
        Type: function.StaticReturnType(cty.DynamicPseudoType),
        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
diff --git a/vendor/github.com/hashicorp/terraform/lang/funcs/crypto.go b/vendor/github.com/hashicorp/terraform/lang/funcs/crypto.go
index 5cb4bc5..be006f8 100644
--- a/vendor/github.com/hashicorp/terraform/lang/funcs/crypto.go
+++ b/vendor/github.com/hashicorp/terraform/lang/funcs/crypto.go
@@ -14,6 +14,7 @@ import (
        "hash"
        uuid "github.com/hashicorp/go-uuid"
+        uuidv5 "github.com/satori/go.uuid"
        "github.com/zclconf/go-cty/cty"
        "github.com/zclconf/go-cty/cty/function"
        "github.com/zclconf/go-cty/cty/gocty"
@@ -32,6 +33,39 @@ var UUIDFunc = function.New(&function.Spec{
        },
 })
+var UUIDV5Func = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name: "namespace",
+                        Type: cty.String,
+                },
+                {
+                        Name: "name",
+                        Type: cty.String,
+                },
+        },
+        Type: function.StaticReturnType(cty.String),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                var namespace uuidv5.UUID
+                switch {
+                case args[0].AsString() == "dns":
+                        namespace = uuidv5.NamespaceDNS
+                case args[0].AsString() == "url":
+                        namespace = uuidv5.NamespaceURL
+                case args[0].AsString() == "oid":
+                        namespace = uuidv5.NamespaceOID
+                case args[0].AsString() == "x500":
+                        namespace = uuidv5.NamespaceX500
+                default:
+                        if namespace, err = uuidv5.FromString(args[0].AsString()); err != nil {
+                                return cty.UnknownVal(cty.String), fmt.Errorf("uuidv5() doesn't support namespace %s (%v)", args[0].AsString(), err)
+                        }
+                }
+                val := args[1].AsString()
+                return cty.StringVal(uuidv5.NewV5(namespace, val).String()), nil
+        },
+})
 // Base64Sha256Func constructs a function that computes the SHA256 hash of a given string
 // and encodes it with Base64.
 var Base64Sha256Func = makeStringHashFunction(sha256.New, base64.StdEncoding.EncodeToString)
@@ -228,6 +262,12 @@ func UUID() (cty.Value, error) {
        return UUIDFunc.Call(nil)
 }
+// UUIDV5 generates and returns a Type-5 UUID in the standard hexadecimal string
+// format.
+func UUIDV5(namespace cty.Value, name cty.Value) (cty.Value, error) {
+        return UUIDV5Func.Call([]cty.Value{namespace, name})
+}
 // Base64Sha256 computes the SHA256 hash of a given string and encodes it with
 // Base64.
 //
diff --git a/vendor/github.com/hashicorp/terraform/lang/funcs/filesystem.go b/vendor/github.com/hashicorp/terraform/lang/funcs/filesystem.go
index 7dfc905..016b102 100644
--- a/vendor/github.com/hashicorp/terraform/lang/funcs/filesystem.go
+++ b/vendor/github.com/hashicorp/terraform/lang/funcs/filesystem.go
@@ -237,6 +237,21 @@ var DirnameFunc = function.New(&function.Spec{
        },
 })
+// AbsPathFunc constructs a function that converts a filesystem path to an absolute path
+var AbsPathFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name: "path",
+                        Type: cty.String,
+                },
+        },
+        Type: function.StaticReturnType(cty.String),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                absPath, err := filepath.Abs(args[0].AsString())
+                return cty.StringVal(filepath.ToSlash(absPath)), err
+        },
+})
 // PathExpandFunc constructs a function that expands a leading ~ character to the current user's home directory.
 var PathExpandFunc = function.New(&function.Spec{
        Params: []function.Parameter{
diff --git a/vendor/github.com/hashicorp/terraform/lang/functions.go b/vendor/github.com/hashicorp/terraform/lang/functions.go
index 2c7b548..b77a55f 100644
--- a/vendor/github.com/hashicorp/terraform/lang/functions.go
+++ b/vendor/github.com/hashicorp/terraform/lang/functions.go
@@ -3,6 +3,7 @@ package lang
 import (
        "fmt"
+        ctyyaml "github.com/zclconf/go-cty-yaml"
        "github.com/zclconf/go-cty/cty"
        "github.com/zclconf/go-cty/cty/function"
        "github.com/zclconf/go-cty/cty/function/stdlib"
@@ -30,6 +31,7 @@ func (s *Scope) Functions() map[string]function.Function {
                s.funcs = map[string]function.Function{
                        "abs":              stdlib.AbsoluteFunc,
+                        "abspath":          funcs.AbsPathFunc,
                        "basename":         funcs.BasenameFunc,
                        "base64decode":     funcs.Base64DecodeFunc,
                        "base64encode":     funcs.Base64EncodeFunc,
@@ -85,6 +87,7 @@ func (s *Scope) Functions() map[string]function.Function {
                        "min":              stdlib.MinFunc,
                        "pathexpand":       funcs.PathExpandFunc,
                        "pow":              funcs.PowFunc,
+                        "range":            stdlib.RangeFunc,
                        "replace":          funcs.ReplaceFunc,
                        "reverse":          funcs.ReverseFunc,
                        "rsadecrypt":       funcs.RsaDecryptFunc,
@@ -114,7 +117,10 @@ func (s *Scope) Functions() map[string]function.Function {
                        "upper":            stdlib.UpperFunc,
                        "urlencode":        funcs.URLEncodeFunc,
                        "uuid":             funcs.UUIDFunc,
+                        "uuidv5":           funcs.UUIDV5Func,
                        "values":           funcs.ValuesFunc,
+                        "yamldecode":       ctyyaml.YAMLDecodeFunc,
+                        "yamlencode":       ctyyaml.YAMLEncodeFunc,
                        "zipmap":           funcs.ZipmapFunc,
                }
diff --git a/vendor/github.com/hashicorp/terraform/plans/objchange/compatible.go b/vendor/github.com/hashicorp/terraform/plans/objchange/compatible.go
index 8b7ef43..d85086c 100644
--- a/vendor/github.com/hashicorp/terraform/plans/objchange/compatible.go
+++ b/vendor/github.com/hashicorp/terraform/plans/objchange/compatible.go
@@ -84,7 +84,7 @@ func assertObjectCompatible(schema *configschema.Block, planned, actual cty.Valu
                        // whether there are dynamically-typed attributes inside. However,
                        // both support a similar-enough API that we can treat them the
                        // same for our purposes here.
-                        if !plannedV.IsKnown() || plannedV.IsNull() || actualV.IsNull() {
+                        if !plannedV.IsKnown() || !actualV.IsKnown() || plannedV.IsNull() || actualV.IsNull() {
                                continue
                        }
@@ -169,6 +169,16 @@ func assertObjectCompatible(schema *configschema.Block, planned, actual cty.Valu
                        })
                        errs = append(errs, setErrs...)
+                        if maybeUnknownBlocks {
+                                // When unknown blocks are present the final number of blocks
+                                // may be different, either because the unknown set values
+                                // become equal and are collapsed, or the count is unknown due
+                                // a dynamic block. Unfortunately this means we can't do our
+                                // usual checks in this case without generating false
+                                // negatives.
+                                continue
+                        }
                        // There can be fewer elements in a set after its elements are all
                        // known (values that turn out to be equal will coalesce) but the
                        // number of elements must never get larger.
diff --git a/vendor/github.com/hashicorp/terraform/plugin/discovery/get.go b/vendor/github.com/hashicorp/terraform/plugin/discovery/get.go
index b1d01fb..c1d9e3b 100644
--- a/vendor/github.com/hashicorp/terraform/plugin/discovery/get.go
+++ b/vendor/github.com/hashicorp/terraform/plugin/discovery/get.go
@@ -204,6 +204,9 @@ func (i *ProviderInstaller) Get(provider string, req Constraints) (PluginMeta, t
        }
        downloadURLs, err := i.listProviderDownloadURLs(providerSource, versionMeta.Version)
+        if err != nil {
+                return PluginMeta{}, diags, err
+        }
        providerURL := downloadURLs.DownloadURL
        if !i.SkipVerify {
diff --git a/vendor/github.com/hashicorp/terraform/plugin/grpc_provider.go b/vendor/github.com/hashicorp/terraform/plugin/grpc_provider.go
index ae9a400..5b190e2 100644
--- a/vendor/github.com/hashicorp/terraform/plugin/grpc_provider.go
+++ b/vendor/github.com/hashicorp/terraform/plugin/grpc_provider.go
@@ -330,6 +330,7 @@ func (p *GRPCProvider) ReadResource(r providers.ReadResourceRequest) (resp provi
        protoReq := &proto.ReadResource_Request{
                TypeName:     r.TypeName,
                CurrentState: &proto.DynamicValue{Msgpack: mp},
+                Private:      r.Private,
        }
        protoResp, err := p.client.ReadResource(p.ctx, protoReq)
@@ -348,6 +349,7 @@ func (p *GRPCProvider) ReadResource(r providers.ReadResourceRequest) (resp provi
                }
        }
        resp.NewState = state
+        resp.Private = protoResp.Private
        return resp
 }
diff --git a/vendor/github.com/hashicorp/terraform/providers/provider.go b/vendor/github.com/hashicorp/terraform/providers/provider.go
index 1aa08c2..7e0a74c 100644
--- a/vendor/github.com/hashicorp/terraform/providers/provider.go
+++ b/vendor/github.com/hashicorp/terraform/providers/provider.go
@@ -176,6 +176,10 @@ type ReadResourceRequest struct {
        // PriorState contains the previously saved state value for this resource.
        PriorState cty.Value
+        // Private is an opaque blob that will be stored in state along with the
+        // resource. It is intended only for interpretation by the provider itself.
+        Private []byte
 }
 type ReadResourceResponse struct {
@@ -184,6 +188,10 @@ type ReadResourceResponse struct {
        // Diagnostics contains any warnings or errors from the method call.
        Diagnostics tfdiags.Diagnostics
+        // Private is an opaque blob that will be stored in state along with the
+        // resource. It is intended only for interpretation by the provider itself.
+        Private []byte
 }
 type PlanResourceChangeRequest struct {
diff --git a/vendor/github.com/hashicorp/terraform/states/state_deepcopy.go b/vendor/github.com/hashicorp/terraform/states/state_deepcopy.go
index ea717d0..8664f3b 100644
--- a/vendor/github.com/hashicorp/terraform/states/state_deepcopy.go
+++ b/vendor/github.com/hashicorp/terraform/states/state_deepcopy.go
@@ -147,7 +147,7 @@ func (obj *ResourceInstanceObjectSrc) DeepCopy() *ResourceInstanceObjectSrc {
        var private []byte
        if obj.Private != nil {
-                private := make([]byte, len(obj.Private))
+                private = make([]byte, len(obj.Private))
                copy(private, obj.Private)
        }
@@ -181,14 +181,17 @@ func (obj *ResourceInstanceObject) DeepCopy() *ResourceInstanceObject {
        var private []byte
        if obj.Private != nil {
-                private := make([]byte, len(obj.Private))
+                private = make([]byte, len(obj.Private))
                copy(private, obj.Private)
        }
-        // Some addrs.Referencable implementations are technically mutable, but
+        // Some addrs.Referenceable implementations are technically mutable, but
        // we treat them as immutable by convention and so we don't deep-copy here.
-        dependencies := make([]addrs.Referenceable, len(obj.Dependencies))
+        var dependencies []addrs.Referenceable
-        copy(dependencies, obj.Dependencies)
+        if obj.Dependencies != nil {
+                dependencies = make([]addrs.Referenceable, len(obj.Dependencies))
+                copy(dependencies, obj.Dependencies)
+        }
        return &ResourceInstanceObject{
                Value:        obj.Value,
diff --git a/vendor/github.com/hashicorp/terraform/states/statefile/version2.go b/vendor/github.com/hashicorp/terraform/states/statefile/version2.go
index 6fe2ab8..be93924 100644
--- a/vendor/github.com/hashicorp/terraform/states/statefile/version2.go
+++ b/vendor/github.com/hashicorp/terraform/states/statefile/version2.go
@@ -205,5 +205,5 @@ type instanceStateV2 struct {
 type backendStateV2 struct {
        Type      string          `json:"type"`   // Backend type
        ConfigRaw json.RawMessage `json:"config"` // Backend raw config
-        Hash      int             `json:"hash"`   // Hash of portion of configuration from config files
+        Hash      uint64          `json:"hash"`   // Hash of portion of configuration from config files
 }
diff --git a/vendor/github.com/hashicorp/terraform/states/statefile/version3_upgrade.go b/vendor/github.com/hashicorp/terraform/states/statefile/version3_upgrade.go
index 2cbe8a5..fbec547 100644
--- a/vendor/github.com/hashicorp/terraform/states/statefile/version3_upgrade.go
+++ b/vendor/github.com/hashicorp/terraform/states/statefile/version3_upgrade.go
@@ -79,7 +79,7 @@ func upgradeStateV3ToV4(old *stateV3) (*stateV4, error) {
                                case addrs.DataResourceMode:
                                        modeStr = "data"
                                default:
-                                        return nil, fmt.Errorf("state contains resource %s with an unsupported resource mode", resAddr)
+                                        return nil, fmt.Errorf("state contains resource %s with an unsupported resource mode %#v", resAddr, resAddr.Mode)
                                }
                                // In state versions prior to 4 we allowed each instance of a
@@ -98,7 +98,7 @@ func upgradeStateV3ToV4(old *stateV3) (*stateV4, error) {
                                        var diags tfdiags.Diagnostics
                                        providerAddr, diags = addrs.ParseAbsProviderConfigStr(oldProviderAddr)
                                        if diags.HasErrors() {
-                                                return nil, diags.Err()
+                                                return nil, fmt.Errorf("invalid provider config reference %q for %s: %s", oldProviderAddr, instAddr, diags.Err())
                                        }
                                } else {
                                        // Smells like an old-style module-local provider address,
@@ -109,7 +109,7 @@ func upgradeStateV3ToV4(old *stateV3) (*stateV4, error) {
                                        if oldProviderAddr != "" {
                                                localAddr, diags := addrs.ParseProviderConfigCompactStr(oldProviderAddr)
                                                if diags.HasErrors() {
-                                                        return nil, diags.Err()
+                                                        return nil, fmt.Errorf("invalid legacy provider config reference %q for %s: %s", oldProviderAddr, instAddr, diags.Err())
                                                }
                                                providerAddr = localAddr.Absolute(moduleAddr)
                                        } else {
@@ -272,7 +272,7 @@ func upgradeInstanceObjectV3ToV4(rsOld *resourceStateV2, isOld *instanceStateV2,
                instKeyRaw = string(tk)
        default:
                if instKeyRaw != nil {
-                        return nil, fmt.Errorf("insupported instance key: %#v", instKey)
+                        return nil, fmt.Errorf("unsupported instance key: %#v", instKey)
                }
        }
@@ -301,7 +301,11 @@ func upgradeInstanceObjectV3ToV4(rsOld *resourceStateV2, isOld *instanceStateV2,
        dependencies := make([]string, len(rsOld.Dependencies))
        for i, v := range rsOld.Dependencies {
-                dependencies[i] = parseLegacyDependency(v)
+                depStr, err := parseLegacyDependency(v)
+                if err != nil {
+                        return nil, fmt.Errorf("invalid dependency reference %q: %s", v, err)
+                }
+                dependencies[i] = depStr
        }
        return &instanceObjectStateV4{
@@ -414,7 +418,7 @@ func simplifyImpliedValueType(ty cty.Type) cty.Type {
        }
 }
-func parseLegacyDependency(s string) string {
+func parseLegacyDependency(s string) (string, error) {
        parts := strings.Split(s, ".")
        ret := parts[0]
        for _, part := range parts[1:] {
@@ -427,5 +431,14 @@ func parseLegacyDependency(s string) string {
                }
                ret = ret + "." + part
        }
-        return ret
+        // The result must parse as a reference, or else we'll create an invalid
+        // state file.
+        var diags tfdiags.Diagnostics
+        _, diags = addrs.ParseRefStr(ret)
+        if diags.HasErrors() {
+                return "", diags.Err()
+        }
+        return ret, nil
 }
diff --git a/vendor/github.com/hashicorp/terraform/terraform/diff.go b/vendor/github.com/hashicorp/terraform/terraform/diff.go
index 7a6ef3d..323462f 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/diff.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/diff.go
@@ -13,7 +13,6 @@ import (
        "sync"
        "github.com/hashicorp/terraform/addrs"
-        "github.com/hashicorp/terraform/config"
        "github.com/hashicorp/terraform/config/hcl2shim"
        "github.com/hashicorp/terraform/configs/configschema"
        "github.com/zclconf/go-cty/cty"
@@ -665,7 +664,7 @@ func (d *InstanceDiff) applySingleAttrDiff(path []string, attrs map[string]strin
        old, exists := attrs[currentKey]
        if diff != nil && diff.NewComputed {
-                result[attr] = config.UnknownVariableValue
+                result[attr] = hcl2shim.UnknownVariableValue
                return result, nil
        }
@@ -673,7 +672,7 @@ func (d *InstanceDiff) applySingleAttrDiff(path []string, attrs map[string]strin
        // This only applied to top-level "id" fields.
        if attr == "id" && len(path) == 1 {
                if old == "" {
-                        result[attr] = config.UnknownVariableValue
+                        result[attr] = hcl2shim.UnknownVariableValue
                } else {
                        result[attr] = old
                }
@@ -704,8 +703,8 @@ func (d *InstanceDiff) applySingleAttrDiff(path []string, attrs map[string]strin
        // check for missmatched diff values
        if exists &&
                old != diff.Old &&
-                old != config.UnknownVariableValue &&
+                old != hcl2shim.UnknownVariableValue &&
-                diff.Old != config.UnknownVariableValue {
+                diff.Old != hcl2shim.UnknownVariableValue {
                return result, fmt.Errorf("diff apply conflict for %s: diff expects %q, but prior value has %q", attr, diff.Old, old)
        }
@@ -723,7 +722,7 @@ func (d *InstanceDiff) applySingleAttrDiff(path []string, attrs map[string]strin
        }
        if attrSchema.Computed && diff.NewComputed {
-                result[attr] = config.UnknownVariableValue
+                result[attr] = hcl2shim.UnknownVariableValue
                return result, nil
        }
@@ -756,7 +755,7 @@ func (d *InstanceDiff) applyCollectionDiff(path []string, attrs map[string]strin
                        }
                        if diff.NewComputed {
-                                result[k[len(prefix):]] = config.UnknownVariableValue
+                                result[k[len(prefix):]] = hcl2shim.UnknownVariableValue
                                return result, nil
                        }
diff --git a/vendor/github.com/hashicorp/terraform/terraform/eval_apply.go b/vendor/github.com/hashicorp/terraform/terraform/eval_apply.go
index 09313f7..422f372 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/eval_apply.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/eval_apply.go
@@ -61,7 +61,8 @@ func (n *EvalApply) Eval(ctx EvalContext) (interface{}, error) {
        configVal := cty.NullVal(cty.DynamicPseudoType)
        if n.Config != nil {
                var configDiags tfdiags.Diagnostics
-                keyData := EvalDataForInstanceKey(n.Addr.Key)
+                forEach, _ := evaluateResourceForEachExpression(n.Config.ForEach, ctx)
+                keyData := EvalDataForInstanceKey(n.Addr.Key, forEach)
                configVal, _, configDiags = ctx.EvaluateBlock(n.Config.Config, schema, nil, keyData)
                diags = diags.Append(configDiags)
                if configDiags.HasErrors() {
@@ -548,7 +549,8 @@ func (n *EvalApplyProvisioners) apply(ctx EvalContext, provs []*configs.Provisio
                provisioner := ctx.Provisioner(prov.Type)
                schema := ctx.ProvisionerSchema(prov.Type)
-                keyData := EvalDataForInstanceKey(instanceAddr.Key)
+                // TODO the for_each val is not added here, which might causes issues with provisioners
+                keyData := EvalDataForInstanceKey(instanceAddr.Key, nil)
                // Evaluate the main provisioner configuration.
                config, _, configDiags := ctx.EvaluateBlock(prov.Config, schema, instanceAddr, keyData)
diff --git a/vendor/github.com/hashicorp/terraform/terraform/eval_diff.go b/vendor/github.com/hashicorp/terraform/terraform/eval_diff.go
index b7acfb0..695b5fe 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/eval_diff.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/eval_diff.go
@@ -4,7 +4,6 @@ import (
        "bytes"
        "fmt"
        "log"
-        "reflect"
        "strings"
        "github.com/hashicorp/hcl2/hcl"
@@ -134,7 +133,8 @@ func (n *EvalDiff) Eval(ctx EvalContext) (interface{}, error) {
                // Should be caught during validation, so we don't bother with a pretty error here
                return nil, fmt.Errorf("provider does not support resource type %q", n.Addr.Resource.Type)
        }
-        keyData := EvalDataForInstanceKey(n.Addr.Key)
+        forEach, _ := evaluateResourceForEachExpression(n.Config.ForEach, ctx)
+        keyData := EvalDataForInstanceKey(n.Addr.Key, forEach)
        configVal, _, configDiags := ctx.EvaluateBlock(config.Config, schema, nil, keyData)
        diags = diags.Append(configDiags)
        if configDiags.HasErrors() {
@@ -174,6 +174,20 @@ func (n *EvalDiff) Eval(ctx EvalContext) (interface{}, error) {
                }
        }
+        log.Printf("[TRACE] Re-validating config for %q", n.Addr.Absolute(ctx.Path()))
+        // Allow the provider to validate the final set of values.
+        // The config was statically validated early on, but there may have been
+        // unknown values which the provider could not validate at the time.
+        validateResp := provider.ValidateResourceTypeConfig(
+                providers.ValidateResourceTypeConfigRequest{
+                        TypeName: n.Addr.Resource.Type,
+                        Config:   configVal,
+                },
+        )
+        if validateResp.Diagnostics.HasErrors() {
+                return nil, validateResp.Diagnostics.InConfigBody(config.Config).Err()
+        }
        // The provider gets an opportunity to customize the proposed new value,
        // which in turn produces the _planned_ new value.
        resp := provider.PlanResourceChange(providers.PlanResourceChangeRequest{
@@ -448,8 +462,9 @@ func (n *EvalDiff) Eval(ctx EvalContext) (interface{}, error) {
                        // must _also_ record the returned change in the active plan,
                        // which the expression evaluator will use in preference to this
                        // incomplete value recorded in the state.
-                        Status: states.ObjectPlanned,
+                        Status:  states.ObjectPlanned,
-                        Value:  plannedNewVal,
+                        Value:   plannedNewVal,
+                        Private: plannedPrivate,
                }
        }
@@ -517,7 +532,7 @@ func processIgnoreChangesIndividual(prior, proposed cty.Value, ignoreChanges []h
                // away any deeper values we already produced at that point.
                var ignoreTraversal hcl.Traversal
                for i, candidate := range ignoreChangesPath {
-                        if reflect.DeepEqual(path, candidate) {
+                        if path.Equals(candidate) {
                                ignoreTraversal = ignoreChanges[i]
                        }
                }
@@ -790,6 +805,7 @@ func (n *EvalDiffDestroy) Eval(ctx EvalContext) (interface{}, error) {
                        Before: state.Value,
                        After:  cty.NullVal(cty.DynamicPseudoType),
                },
+                Private:      state.Private,
                ProviderAddr: n.ProviderAddr,
        }
diff --git a/vendor/github.com/hashicorp/terraform/terraform/eval_for_each.go b/vendor/github.com/hashicorp/terraform/terraform/eval_for_each.go
new file mode 100644
index 0000000..b86bf37
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/terraform/eval_for_each.go
@@ -0,0 +1,85 @@
+package terraform
+import (
+        "fmt"
+        "github.com/hashicorp/hcl2/hcl"
+        "github.com/hashicorp/terraform/tfdiags"
+        "github.com/zclconf/go-cty/cty"
+)
+// evaluateResourceForEachExpression interprets a "for_each" argument on a resource.
+//
+// Returns a cty.Value map, and diagnostics if necessary. It will return nil if
+// the expression is nil, and is used to distinguish between an unset for_each and an
+// empty map
+func evaluateResourceForEachExpression(expr hcl.Expression, ctx EvalContext) (forEach map[string]cty.Value, diags tfdiags.Diagnostics) {
+        forEachMap, known, diags := evaluateResourceForEachExpressionKnown(expr, ctx)
+        if !known {
+                // Attach a diag as we do with count, with the same downsides
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid forEach argument",
+                        Detail:   `The "for_each" value depends on resource attributes that cannot be determined until apply, so Terraform cannot predict how many instances will be created. To work around this, use the -target argument to first apply only the resources that the for_each depends on.`,
+                })
+        }
+        return forEachMap, diags
+}
+// evaluateResourceForEachExpressionKnown is like evaluateResourceForEachExpression
+// except that it handles an unknown result by returning an empty map and
+// a known = false, rather than by reporting the unknown value as an error
+// diagnostic.
+func evaluateResourceForEachExpressionKnown(expr hcl.Expression, ctx EvalContext) (forEach map[string]cty.Value, known bool, diags tfdiags.Diagnostics) {
+        if expr == nil {
+                return nil, true, nil
+        }
+        forEachVal, forEachDiags := ctx.EvaluateExpr(expr, cty.DynamicPseudoType, nil)
+        diags = diags.Append(forEachDiags)
+        if diags.HasErrors() {
+                return nil, true, diags
+        }
+        switch {
+        case forEachVal.IsNull():
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid for_each argument",
+                        Detail:   `The given "for_each" argument value is unsuitable: the given "for_each" argument value is null. A map, or set of strings is allowed.`,
+                        Subject:  expr.Range().Ptr(),
+                })
+                return nil, true, diags
+        case !forEachVal.IsKnown():
+                return map[string]cty.Value{}, false, diags
+        }
+        if !forEachVal.CanIterateElements() || forEachVal.Type().IsListType() {
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  "Invalid for_each argument",
+                        Detail:   fmt.Sprintf(`The given "for_each" argument value is unsuitable: the "for_each" argument must be a map, or set of strings, and you have provided a value of type %s.`, forEachVal.Type().FriendlyName()),
+                        Subject:  expr.Range().Ptr(),
+                })
+                return nil, true, diags
+        }
+        if forEachVal.Type().IsSetType() {
+                if forEachVal.Type().ElementType() != cty.String {
+                        diags = diags.Append(&hcl.Diagnostic{
+                                Severity: hcl.DiagError,
+                                Summary:  "Invalid for_each set argument",
+                                Detail:   fmt.Sprintf(`The given "for_each" argument value is unsuitable: "for_each" supports maps and sets of strings, but you have provided a set containing type %s.`, forEachVal.Type().ElementType().FriendlyName()),
+                                Subject:  expr.Range().Ptr(),
+                        })
+                        return nil, true, diags
+                }
+        }
+        // If the map is empty ({}), return an empty map, because cty will return nil when representing {} AsValueMap
+        if forEachVal.LengthInt() == 0 {
+                return map[string]cty.Value{}, true, diags
+        }
+        return forEachVal.AsValueMap(), true, nil
+}
diff --git a/vendor/github.com/hashicorp/terraform/terraform/eval_read_data.go b/vendor/github.com/hashicorp/terraform/terraform/eval_read_data.go
index 34f2d60..4999480 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/eval_read_data.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/eval_read_data.go
@@ -95,7 +95,8 @@ func (n *EvalReadData) Eval(ctx EvalContext) (interface{}, error) {
        objTy := schema.ImpliedType()
        priorVal := cty.NullVal(objTy) // for data resources, prior is always null because we start fresh every time
-        keyData := EvalDataForInstanceKey(n.Addr.Key)
+        forEach, _ := evaluateResourceForEachExpression(n.Config.ForEach, ctx)
+        keyData := EvalDataForInstanceKey(n.Addr.Key, forEach)
        var configDiags tfdiags.Diagnostics
        configVal, _, configDiags = ctx.EvaluateBlock(config.Config, schema, nil, keyData)
@@ -179,6 +180,17 @@ func (n *EvalReadData) Eval(ctx EvalContext) (interface{}, error) {
                )
        }
+        log.Printf("[TRACE] Re-validating config for %s", absAddr)
+        validateResp := provider.ValidateDataSourceConfig(
+                providers.ValidateDataSourceConfigRequest{
+                        TypeName: n.Addr.Resource.Type,
+                        Config:   configVal,
+                },
+        )
+        if validateResp.Diagnostics.HasErrors() {
+                return nil, validateResp.Diagnostics.InConfigBody(n.Config.Config).Err()
+        }
        // If we get down here then our configuration is complete and we're read
        // to actually call the provider to read the data.
        log.Printf("[TRACE] EvalReadData: %s configuration is complete, so reading from provider", absAddr)
diff --git a/vendor/github.com/hashicorp/terraform/terraform/eval_refresh.go b/vendor/github.com/hashicorp/terraform/terraform/eval_refresh.go
index 03bc948..4dfb5b4 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/eval_refresh.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/eval_refresh.go
@@ -55,6 +55,7 @@ func (n *EvalRefresh) Eval(ctx EvalContext) (interface{}, error) {
        req := providers.ReadResourceRequest{
                TypeName:   n.Addr.Resource.Type,
                PriorState: priorVal,
+                Private:    state.Private,
        }
        provider := *n.Provider
@@ -87,6 +88,7 @@ func (n *EvalRefresh) Eval(ctx EvalContext) (interface{}, error) {
        newState := state.DeepCopy()
        newState.Value = resp.NewState
+        newState.Private = resp.Private
        // Call post-refresh hook
        err = ctx.Hook(func(h Hook) (HookAction, error) {
diff --git a/vendor/github.com/hashicorp/terraform/terraform/eval_state.go b/vendor/github.com/hashicorp/terraform/terraform/eval_state.go
index d506ce3..b611113 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/eval_state.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/eval_state.go
@@ -424,15 +424,21 @@ func (n *EvalWriteResourceState) Eval(ctx EvalContext) (interface{}, error) {
                return nil, diags.Err()
        }
-        // Currently we ony support NoEach and EachList, because for_each support
-        // is not fully wired up across Terraform. Once for_each support is added,
-        // we'll need to handle that here too, setting states.EachMap if the
-        // assigned expression is a map.
        eachMode := states.NoEach
        if count >= 0 { // -1 signals "count not set"
                eachMode = states.EachList
        }
+        forEach, forEachDiags := evaluateResourceForEachExpression(n.Config.ForEach, ctx)
+        diags = diags.Append(forEachDiags)
+        if forEachDiags.HasErrors() {
+                return nil, diags.Err()
+        }
+        if forEach != nil {
+                eachMode = states.EachMap
+        }
        // This method takes care of all of the business logic of updating this
        // while ensuring that any existing instances are preserved, etc.
        state.SetResourceMeta(absAddr, eachMode, n.ProviderAddr)
diff --git a/vendor/github.com/hashicorp/terraform/terraform/eval_validate.go b/vendor/github.com/hashicorp/terraform/terraform/eval_validate.go
index 0033e01..6b809a2 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/eval_validate.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/eval_validate.go
@@ -112,11 +112,12 @@ func (n *EvalValidateProvider) Eval(ctx EvalContext) (interface{}, error) {
 // the configuration of a provisioner belonging to a resource. The provisioner
 // config is expected to contain the merged connection configurations.
 type EvalValidateProvisioner struct {
-        ResourceAddr     addrs.Resource
+        ResourceAddr       addrs.Resource
-        Provisioner      *provisioners.Interface
+        Provisioner        *provisioners.Interface
-        Schema           **configschema.Block
+        Schema             **configschema.Block
-        Config           *configs.Provisioner
+        Config             *configs.Provisioner
-        ResourceHasCount bool
+        ResourceHasCount   bool
+        ResourceHasForEach bool
 }
 func (n *EvalValidateProvisioner) Eval(ctx EvalContext) (interface{}, error) {
@@ -198,6 +199,19 @@ func (n *EvalValidateProvisioner) evaluateBlock(ctx EvalContext, body hcl.Body,
                // expected type since none of these elements are known at this
                // point anyway.
                selfAddr = n.ResourceAddr.Instance(addrs.IntKey(0))
+        } else if n.ResourceHasForEach {
+                // For a resource that has for_each, we allow each.value and each.key
+                // but don't know at this stage what it will return.
+                keyData = InstanceKeyEvalData{
+                        EachKey:   cty.UnknownVal(cty.String),
+                        EachValue: cty.DynamicVal,
+                }
+                // "self" can't point to an unknown key, but we'll force it to be
+                // key "" here, which should return an unknown value of the
+                // expected type since none of these elements are known at
+                // this point anyway.
+                selfAddr = n.ResourceAddr.Instance(addrs.StringKey(""))
        }
        return ctx.EvaluateBlock(body, schema, selfAddr, keyData)
@@ -370,10 +384,21 @@ func (n *EvalValidateResource) Eval(ctx EvalContext) (interface{}, error) {
                diags = diags.Append(countDiags)
        }
+        if n.Config.ForEach != nil {
+                keyData = InstanceKeyEvalData{
+                        EachKey:   cty.UnknownVal(cty.String),
+                        EachValue: cty.UnknownVal(cty.DynamicPseudoType),
+                }
+                // Evaluate the for_each expression here so we can expose the diagnostics
+                forEachDiags := n.validateForEach(ctx, n.Config.ForEach)
+                diags = diags.Append(forEachDiags)
+        }
        for _, traversal := range n.Config.DependsOn {
                ref, refDiags := addrs.ParseRef(traversal)
                diags = diags.Append(refDiags)
-                if len(ref.Remaining) != 0 {
+                if !refDiags.HasErrors() && len(ref.Remaining) != 0 {
                        diags = diags.Append(&hcl.Diagnostic{
                                Severity: hcl.DiagError,
                                Summary:  "Invalid depends_on reference",
@@ -542,3 +567,18 @@ func (n *EvalValidateResource) validateCount(ctx EvalContext, expr hcl.Expressio
        return diags
 }
+func (n *EvalValidateResource) validateForEach(ctx EvalContext, expr hcl.Expression) (diags tfdiags.Diagnostics) {
+        _, known, forEachDiags := evaluateResourceForEachExpressionKnown(expr, ctx)
+        // If the value isn't known then that's the best we can do for now, but
+        // we'll check more thoroughly during the plan walk
+        if !known {
+                return diags
+        }
+        if forEachDiags.HasErrors() {
+                diags = diags.Append(forEachDiags)
+        }
+        return diags
+}
diff --git a/vendor/github.com/hashicorp/terraform/terraform/eval_variable.go b/vendor/github.com/hashicorp/terraform/terraform/eval_variable.go
index 68adf76..ea46973 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/eval_variable.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/eval_variable.go
@@ -12,6 +12,7 @@ import (
        "github.com/hashicorp/terraform/addrs"
        "github.com/hashicorp/terraform/config"
+        "github.com/hashicorp/terraform/config/hcl2shim"
        "github.com/hashicorp/terraform/config/module"
        "github.com/zclconf/go-cty/cty"
        "github.com/zclconf/go-cty/cty/convert"
@@ -60,7 +61,7 @@ func (n *EvalTypeCheckVariable) Eval(ctx EvalContext) (interface{}, error) {
                        continue
                }
-                if proposedValue == config.UnknownVariableValue {
+                if proposedValue == hcl2shim.UnknownVariableValue {
                        continue
                }
diff --git a/vendor/github.com/hashicorp/terraform/terraform/evaluate.go b/vendor/github.com/hashicorp/terraform/terraform/evaluate.go
index ab65d47..9bb6009 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/evaluate.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/evaluate.go
@@ -120,20 +120,24 @@ type InstanceKeyEvalData struct {
 // EvalDataForInstanceKey constructs a suitable InstanceKeyEvalData for
 // evaluating in a context that has the given instance key.
-func EvalDataForInstanceKey(key addrs.InstanceKey) InstanceKeyEvalData {
+func EvalDataForInstanceKey(key addrs.InstanceKey, forEachMap map[string]cty.Value) InstanceKeyEvalData {
-        // At the moment we don't actually implement for_each, so we only
-        // ever populate CountIndex.
-        // (When we implement for_each later we may need to reorganize this some,
-        // so that we can resolve the ambiguity that an int key may either be
-        // a count.index or an each.key where for_each is over a list.)
        var countIdx cty.Value
+        var eachKey cty.Value
+        var eachVal cty.Value
        if intKey, ok := key.(addrs.IntKey); ok {
                countIdx = cty.NumberIntVal(int64(intKey))
        }
+        if stringKey, ok := key.(addrs.StringKey); ok {
+                eachKey = cty.StringVal(string(stringKey))
+                eachVal = forEachMap[string(stringKey)]
+        }
        return InstanceKeyEvalData{
                CountIndex: countIdx,
+                EachKey:    eachKey,
+                EachValue:  eachVal,
        }
 }
@@ -173,6 +177,37 @@ func (d *evaluationStateData) GetCountAttr(addr addrs.CountAttr, rng tfdiags.Sou
        }
 }
+func (d *evaluationStateData) GetForEachAttr(addr addrs.ForEachAttr, rng tfdiags.SourceRange) (cty.Value, tfdiags.Diagnostics) {
+        var diags tfdiags.Diagnostics
+        var returnVal cty.Value
+        switch addr.Name {
+        case "key":
+                returnVal = d.InstanceKeyData.EachKey
+        case "value":
+                returnVal = d.InstanceKeyData.EachValue
+        default:
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  `Invalid "each" attribute`,
+                        Detail:   fmt.Sprintf(`The "each" object does not have an attribute named %q. The supported attributes are each.key and each.value, the current key and value pair of the "for_each" attribute set.`, addr.Name),
+                        Subject:  rng.ToHCL().Ptr(),
+                })
+                return cty.DynamicVal, diags
+        }
+        if returnVal == cty.NilVal {
+                diags = diags.Append(&hcl.Diagnostic{
+                        Severity: hcl.DiagError,
+                        Summary:  `Reference to "each" in context without for_each`,
+                        Detail:   fmt.Sprintf(`The "each" object can be used only in "resource" blocks, and only when the "for_each" argument is set.`),
+                        Subject:  rng.ToHCL().Ptr(),
+                })
+                return cty.UnknownVal(cty.DynamicPseudoType), diags
+        }
+        return returnVal, diags
+}
 func (d *evaluationStateData) GetInputVariable(addr addrs.InputVariable, rng tfdiags.SourceRange) (cty.Value, tfdiags.Diagnostics) {
        var diags tfdiags.Diagnostics
@@ -569,7 +604,7 @@ func (d *evaluationStateData) GetResourceInstance(addr addrs.ResourceInstance, r
                }
        case states.EachMap:
                multi = key == addrs.NoKey
-                if _, ok := addr.Key.(addrs.IntKey); !multi && !ok {
+                if _, ok := addr.Key.(addrs.StringKey); !multi && !ok {
                        diags = diags.Append(&hcl.Diagnostic{
                                Severity: hcl.DiagError,
                                Summary:  "Invalid resource index",
@@ -696,7 +731,7 @@ func (d *evaluationStateData) getResourceInstancesAll(addr addrs.Resource, rng t
                        ty := schema.ImpliedType()
                        key := addrs.IntKey(i)
                        is, exists := rs.Instances[key]
-                        if exists {
+                        if exists && is.Current != nil {
                                instAddr := addr.Instance(key).Absolute(d.ModulePath)
                                // Prefer pending value in plan if present. See getResourceInstanceSingle
diff --git a/vendor/github.com/hashicorp/terraform/terraform/interpolate.go b/vendor/github.com/hashicorp/terraform/terraform/interpolate.go
index 26c1857..97bb1f6 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/interpolate.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/interpolate.go
@@ -11,16 +11,11 @@ import (
        "github.com/hashicorp/hil"
        "github.com/hashicorp/hil/ast"
        "github.com/hashicorp/terraform/config"
+        "github.com/hashicorp/terraform/config/hcl2shim"
        "github.com/hashicorp/terraform/config/module"
        "github.com/hashicorp/terraform/flatmap"
 )
-const (
-        // VarEnvPrefix is the prefix of variables that are read from
-        // the environment to set variables here.
-        VarEnvPrefix = "TF_VAR_"
-)
 // Interpolater is the structure responsible for determining the values
 // for interpolations such as `aws_instance.foo.bar`.
 type Interpolater struct {
@@ -71,7 +66,7 @@ func (i *Interpolater) valueCountVar(
 func unknownVariable() ast.Variable {
        return ast.Variable{
                Type:  ast.TypeUnknown,
-                Value: config.UnknownVariableValue,
+                Value: hcl2shim.UnknownVariableValue,
        }
 }
@@ -659,7 +654,7 @@ func (i *Interpolater) interpolateComplexTypeAttribute(
                // ".#" count field is marked as unknown to indicate "this whole list is
                // unknown". We must honor that meaning here so computed references can be
                // treated properly during the plan phase.
-                if lengthAttr == config.UnknownVariableValue {
+                if lengthAttr == hcl2shim.UnknownVariableValue {
                        return unknownVariable(), nil
                }
@@ -675,7 +670,7 @@ func (i *Interpolater) interpolateComplexTypeAttribute(
                // ".%" count field is marked as unknown to indicate "this whole list is
                // unknown". We must honor that meaning here so computed references can be
                // treated properly during the plan phase.
-                if lengthAttr == config.UnknownVariableValue {
+                if lengthAttr == hcl2shim.UnknownVariableValue {
                        return unknownVariable(), nil
                }
diff --git a/vendor/github.com/hashicorp/terraform/terraform/node_data_refresh.go b/vendor/github.com/hashicorp/terraform/terraform/node_data_refresh.go
index ab82163..dd92866 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/node_data_refresh.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/node_data_refresh.go
@@ -38,6 +38,16 @@ func (n *NodeRefreshableDataResource) DynamicExpand(ctx EvalContext) (*Graph, er
                return nil, nil
        }
+        forEachMap, forEachKnown, forEachDiags := evaluateResourceForEachExpressionKnown(n.Config.ForEach, ctx)
+        if forEachDiags.HasErrors() {
+                return nil, diags.Err()
+        }
+        if !forEachKnown {
+                // If the for_each isn't known yet, we'll skip refreshing and try expansion
+                // again during the plan walk.
+                return nil, nil
+        }
        // Next we need to potentially rename an instance address in the state
        // if we're transitioning whether "count" is set at all.
        fixResourceCountSetTransition(ctx, n.ResourceAddr(), count != -1)
@@ -77,6 +87,7 @@ func (n *NodeRefreshableDataResource) DynamicExpand(ctx EvalContext) (*Graph, er
                        Concrete: concreteResource,
                        Schema:   n.Schema,
                        Count:    count,
+                        ForEach:  forEachMap,
                        Addr:     n.ResourceAddr(),
                },
@@ -85,6 +96,7 @@ func (n *NodeRefreshableDataResource) DynamicExpand(ctx EvalContext) (*Graph, er
                &OrphanResourceCountTransformer{
                        Concrete: concreteResourceDestroyable,
                        Count:    count,
+                        ForEach:  forEachMap,
                        Addr:     n.ResourceAddr(),
                        State:    state,
                },
diff --git a/vendor/github.com/hashicorp/terraform/terraform/node_resource_abstract.go b/vendor/github.com/hashicorp/terraform/terraform/node_resource_abstract.go
index 3a0570c..d147b42 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/node_resource_abstract.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/node_resource_abstract.go
@@ -187,6 +187,8 @@ func (n *NodeAbstractResource) References() []*addrs.Reference {
                refs, _ := lang.ReferencesInExpr(c.Count)
                result = append(result, refs...)
+                refs, _ = lang.ReferencesInExpr(c.ForEach)
+                result = append(result, refs...)
                refs, _ = lang.ReferencesInBlock(c.Config, n.Schema)
                result = append(result, refs...)
                if c.Managed != nil {
@@ -238,21 +240,31 @@ func (n *NodeAbstractResourceInstance) References() []*addrs.Reference {
                        // need to do a little work here to massage this to the form we now
                        // want.
                        var result []*addrs.Reference
-                        for _, addr := range s.Current.Dependencies {
-                                if addr == nil {
-                                        // Should never happen; indicates a bug in the state loader
-                                        panic(fmt.Sprintf("dependencies for current object on %s contains nil address", n.ResourceInstanceAddr()))
-                                }
-                                // This is a little weird: we need to manufacture an addrs.Reference
+                        // It is (apparently) possible for s.Current to be nil. This proved
-                                // with a fake range here because the state isn't something we can
+                        // difficult to reproduce, so we will fix the symptom here and hope
-                                // make source references into.
+                        // to find the root cause another time.
-                                result = append(result, &addrs.Reference{
+                        //
-                                        Subject: addr,
+                        // https://github.com/hashicorp/terraform/issues/21407
-                                        SourceRange: tfdiags.SourceRange{
+                        if s.Current == nil {
-                                                Filename: "(state file)",
+                                log.Printf("[WARN] no current state found for %s", n.Name())
-                                        },
+                        } else {
-                                })
+                                for _, addr := range s.Current.Dependencies {
+                                        if addr == nil {
+                                                // Should never happen; indicates a bug in the state loader
+                                                panic(fmt.Sprintf("dependencies for current object on %s contains nil address", n.ResourceInstanceAddr()))
+                                        }
+                                        // This is a little weird: we need to manufacture an addrs.Reference
+                                        // with a fake range here because the state isn't something we can
+                                        // make source references into.
+                                        result = append(result, &addrs.Reference{
+                                                Subject: addr,
+                                                SourceRange: tfdiags.SourceRange{
+                                                        Filename: "(state file)",
+                                                },
+                                        })
+                                }
                        }
                        return result
                }
diff --git a/vendor/github.com/hashicorp/terraform/terraform/node_resource_apply_instance.go b/vendor/github.com/hashicorp/terraform/terraform/node_resource_apply_instance.go
index dad7bfc..d795324 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/node_resource_apply_instance.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/node_resource_apply_instance.go
@@ -101,13 +101,6 @@ func (n *NodeApplyableResourceInstance) References() []*addrs.Reference {
 func (n *NodeApplyableResourceInstance) EvalTree() EvalNode {
        addr := n.ResourceInstanceAddr()
-        // State still uses legacy-style internal ids, so we need to shim to get
-        // a suitable key to use.
-        stateId := NewLegacyResourceInstanceAddress(addr).stateId()
-        // Determine the dependencies for the state.
-        stateDeps := n.StateReferences()
        if n.Config == nil {
                // This should not be possible, but we've got here in at least one
                // case as discussed in the following issue:
@@ -132,15 +125,15 @@ func (n *NodeApplyableResourceInstance) EvalTree() EvalNode {
        // Eval info is different depending on what kind of resource this is
        switch n.Config.Mode {
        case addrs.ManagedResourceMode:
-                return n.evalTreeManagedResource(addr, stateId, stateDeps)
+                return n.evalTreeManagedResource(addr)
        case addrs.DataResourceMode:
-                return n.evalTreeDataResource(addr, stateId, stateDeps)
+                return n.evalTreeDataResource(addr)
        default:
                panic(fmt.Errorf("unsupported resource mode %s", n.Config.Mode))
        }
 }
-func (n *NodeApplyableResourceInstance) evalTreeDataResource(addr addrs.AbsResourceInstance, stateId string, stateDeps []addrs.Referenceable) EvalNode {
+func (n *NodeApplyableResourceInstance) evalTreeDataResource(addr addrs.AbsResourceInstance) EvalNode {
        var provider providers.Interface
        var providerSchema *ProviderSchema
        var change *plans.ResourceInstanceChange
@@ -206,7 +199,7 @@ func (n *NodeApplyableResourceInstance) evalTreeDataResource(addr addrs.AbsResou
        }
 }
-func (n *NodeApplyableResourceInstance) evalTreeManagedResource(addr addrs.AbsResourceInstance, stateId string, stateDeps []addrs.Referenceable) EvalNode {
+func (n *NodeApplyableResourceInstance) evalTreeManagedResource(addr addrs.AbsResourceInstance) EvalNode {
        // Declare a bunch of variables that are used for state during
        // evaluation. Most of this are written to by-address below.
        var provider providers.Interface
diff --git a/vendor/github.com/hashicorp/terraform/terraform/node_resource_plan.go b/vendor/github.com/hashicorp/terraform/terraform/node_resource_plan.go
index 633c1c4..ec4aa93 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/node_resource_plan.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/node_resource_plan.go
@@ -77,6 +77,11 @@ func (n *NodePlannableResource) DynamicExpand(ctx EvalContext) (*Graph, error) {
                return nil, diags.Err()
        }
+        forEachMap, forEachDiags := evaluateResourceForEachExpression(n.Config.ForEach, ctx)
+        if forEachDiags.HasErrors() {
+                return nil, diags.Err()
+        }
        // Next we need to potentially rename an instance address in the state
        // if we're transitioning whether "count" is set at all.
        fixResourceCountSetTransition(ctx, n.ResourceAddr(), count != -1)
@@ -119,18 +124,20 @@ func (n *NodePlannableResource) DynamicExpand(ctx EvalContext) (*Graph, error) {
        // Start creating the steps
        steps := []GraphTransformer{
-                // Expand the count.
+                // Expand the count or for_each (if present)
                &ResourceCountTransformer{
                        Concrete: concreteResource,
                        Schema:   n.Schema,
                        Count:    count,
+                        ForEach:  forEachMap,
                        Addr:     n.ResourceAddr(),
                },
-                // Add the count orphans
+                // Add the count/for_each orphans
                &OrphanResourceCountTransformer{
                        Concrete: concreteResourceOrphan,
                        Count:    count,
+                        ForEach:  forEachMap,
                        Addr:     n.ResourceAddr(),
                        State:    state,
                },
diff --git a/vendor/github.com/hashicorp/terraform/terraform/node_resource_plan_instance.go b/vendor/github.com/hashicorp/terraform/terraform/node_resource_plan_instance.go
index 75e0bcd..0f74bbe 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/node_resource_plan_instance.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/node_resource_plan_instance.go
@@ -34,25 +34,18 @@ var (
 func (n *NodePlannableResourceInstance) EvalTree() EvalNode {
        addr := n.ResourceInstanceAddr()
-        // State still uses legacy-style internal ids, so we need to shim to get
-        // a suitable key to use.
-        stateId := NewLegacyResourceInstanceAddress(addr).stateId()
-        // Determine the dependencies for the state.
-        stateDeps := n.StateReferences()
        // Eval info is different depending on what kind of resource this is
        switch addr.Resource.Resource.Mode {
        case addrs.ManagedResourceMode:
-                return n.evalTreeManagedResource(addr, stateId, stateDeps)
+                return n.evalTreeManagedResource(addr)
        case addrs.DataResourceMode:
-                return n.evalTreeDataResource(addr, stateId, stateDeps)
+                return n.evalTreeDataResource(addr)
        default:
                panic(fmt.Errorf("unsupported resource mode %s", n.Config.Mode))
        }
 }
-func (n *NodePlannableResourceInstance) evalTreeDataResource(addr addrs.AbsResourceInstance, stateId string, stateDeps []addrs.Referenceable) EvalNode {
+func (n *NodePlannableResourceInstance) evalTreeDataResource(addr addrs.AbsResourceInstance) EvalNode {
        config := n.Config
        var provider providers.Interface
        var providerSchema *ProviderSchema
@@ -147,7 +140,7 @@ func (n *NodePlannableResourceInstance) evalTreeDataResource(addr addrs.AbsResou
        }
 }
-func (n *NodePlannableResourceInstance) evalTreeManagedResource(addr addrs.AbsResourceInstance, stateId string, stateDeps []addrs.Referenceable) EvalNode {
+func (n *NodePlannableResourceInstance) evalTreeManagedResource(addr addrs.AbsResourceInstance) EvalNode {
        config := n.Config
        var provider providers.Interface
        var providerSchema *ProviderSchema
diff --git a/vendor/github.com/hashicorp/terraform/terraform/node_resource_refresh.go b/vendor/github.com/hashicorp/terraform/terraform/node_resource_refresh.go
index 9506023..9daeabf 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/node_resource_refresh.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/node_resource_refresh.go
@@ -39,6 +39,11 @@ func (n *NodeRefreshableManagedResource) DynamicExpand(ctx EvalContext) (*Graph,
                return nil, diags.Err()
        }
+        forEachMap, forEachDiags := evaluateResourceForEachExpression(n.Config.ForEach, ctx)
+        if forEachDiags.HasErrors() {
+                return nil, diags.Err()
+        }
        // Next we need to potentially rename an instance address in the state
        // if we're transitioning whether "count" is set at all.
        fixResourceCountSetTransition(ctx, n.ResourceAddr(), count != -1)
@@ -66,6 +71,7 @@ func (n *NodeRefreshableManagedResource) DynamicExpand(ctx EvalContext) (*Graph,
                        Concrete: concreteResource,
                        Schema:   n.Schema,
                        Count:    count,
+                        ForEach:  forEachMap,
                        Addr:     n.ResourceAddr(),
                },
@@ -74,6 +80,7 @@ func (n *NodeRefreshableManagedResource) DynamicExpand(ctx EvalContext) (*Graph,
                &OrphanResourceCountTransformer{
                        Concrete: concreteResource,
                        Count:    count,
+                        ForEach:  forEachMap,
                        Addr:     n.ResourceAddr(),
                        State:    state,
                },
diff --git a/vendor/github.com/hashicorp/terraform/terraform/node_resource_validate.go b/vendor/github.com/hashicorp/terraform/terraform/node_resource_validate.go
index 734ec9e..efa657b 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/node_resource_validate.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/node_resource_validate.go
@@ -54,6 +54,7 @@ func (n *NodeValidatableResource) EvalTree() EvalNode {
        if managed := n.Config.Managed; managed != nil {
                hasCount := n.Config.Count != nil
+                hasForEach := n.Config.ForEach != nil
                // Validate all the provisioners
                for _, p := range managed.Provisioners {
@@ -74,11 +75,12 @@ func (n *NodeValidatableResource) EvalTree() EvalNode {
                                        Schema: &provisionerSchema,
                                },
                                &EvalValidateProvisioner{
-                                        ResourceAddr:     addr.Resource,
+                                        ResourceAddr:       addr.Resource,
-                                        Provisioner:      &provisioner,
+                                        Provisioner:        &provisioner,
-                                        Schema:           &provisionerSchema,
+                                        Schema:             &provisionerSchema,
-                                        Config:           p,
+                                        Config:             p,
-                                        ResourceHasCount: hasCount,
+                                        ResourceHasCount:   hasCount,
+                                        ResourceHasForEach: hasForEach,
                                },
                        )
                }
diff --git a/vendor/github.com/hashicorp/terraform/terraform/provider_mock.go b/vendor/github.com/hashicorp/terraform/terraform/provider_mock.go
index 4ae346d..8eede48 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/provider_mock.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/provider_mock.go
@@ -8,7 +8,6 @@ import (
        "github.com/zclconf/go-cty/cty"
        ctyjson "github.com/zclconf/go-cty/cty/json"
-        "github.com/hashicorp/terraform/config"
        "github.com/hashicorp/terraform/config/hcl2shim"
        "github.com/hashicorp/terraform/providers"
        "github.com/hashicorp/terraform/tfdiags"
@@ -391,7 +390,7 @@ func (p *MockProvider) ApplyResourceChange(r providers.ApplyResourceChangeReques
                        for k, new := range plannedMap {
                                old := priorMap[k]
                                newComputed := false
-                                if new == config.UnknownVariableValue {
+                                if new == hcl2shim.UnknownVariableValue {
                                        new = ""
                                        newComputed = true
                                }
diff --git a/vendor/github.com/hashicorp/terraform/terraform/resource_address.go b/vendor/github.com/hashicorp/terraform/terraform/resource_address.go
index 156ecf5..5d8261a 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/resource_address.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/resource_address.go
@@ -365,6 +365,8 @@ func NewLegacyResourceInstanceAddress(addr addrs.AbsResourceInstance) *ResourceA
                ret.Index = -1
        } else if ik, ok := addr.Resource.Key.(addrs.IntKey); ok {
                ret.Index = int(ik)
+        } else if _, ok := addr.Resource.Key.(addrs.StringKey); ok {
+                ret.Index = -1
        } else {
                panic(fmt.Errorf("cannot shim resource instance with key %#v to legacy ResourceAddress.Index", addr.Resource.Key))
        }
diff --git a/vendor/github.com/hashicorp/terraform/terraform/state.go b/vendor/github.com/hashicorp/terraform/terraform/state.go
index 092b690..6280fb0 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/state.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/state.go
@@ -1201,7 +1201,7 @@ func (m *ModuleState) prune() {
        }
        for k, v := range m.Outputs {
-                if v.Value == config.UnknownVariableValue {
+                if v.Value == hcl2shim.UnknownVariableValue {
                        delete(m.Outputs, k)
                }
        }
@@ -1827,7 +1827,7 @@ func (s *InstanceState) MergeDiff(d *InstanceDiff) *InstanceState {
                                continue
                        }
                        if diff.NewComputed {
-                                result.Attributes[k] = config.UnknownVariableValue
+                                result.Attributes[k] = hcl2shim.UnknownVariableValue
                                continue
                        }
diff --git a/vendor/github.com/hashicorp/terraform/terraform/transform_orphan_count.go b/vendor/github.com/hashicorp/terraform/terraform/transform_orphan_count.go
index eec762e..4f323a7 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/transform_orphan_count.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/transform_orphan_count.go
@@ -6,6 +6,7 @@ import (
        "github.com/hashicorp/terraform/addrs"
        "github.com/hashicorp/terraform/dag"
        "github.com/hashicorp/terraform/states"
+        "github.com/zclconf/go-cty/cty"
 )
 // OrphanResourceCountTransformer is a GraphTransformer that adds orphans
@@ -18,9 +19,10 @@ import (
 type OrphanResourceCountTransformer struct {
        Concrete ConcreteResourceInstanceNodeFunc
-        Count int               // Actual count of the resource, or -1 if count is not set at all
+        Count   int                  // Actual count of the resource, or -1 if count is not set at all
-        Addr  addrs.AbsResource // Addr of the resource to look for orphans
+        ForEach map[string]cty.Value // The ForEach map on the resource
-        State *states.State     // Full global state
+        Addr    addrs.AbsResource    // Addr of the resource to look for orphans
+        State   *states.State        // Full global state
 }
 func (t *OrphanResourceCountTransformer) Transform(g *Graph) error {
@@ -34,6 +36,10 @@ func (t *OrphanResourceCountTransformer) Transform(g *Graph) error {
                haveKeys[key] = struct{}{}
        }
+        // if for_each is set, use that transformer
+        if t.ForEach != nil {
+                return t.transformForEach(haveKeys, g)
+        }
        if t.Count < 0 {
                return t.transformNoCount(haveKeys, g)
        }
@@ -43,6 +49,25 @@ func (t *OrphanResourceCountTransformer) Transform(g *Graph) error {
        return t.transformCount(haveKeys, g)
 }
+func (t *OrphanResourceCountTransformer) transformForEach(haveKeys map[addrs.InstanceKey]struct{}, g *Graph) error {
+        for key := range haveKeys {
+                s, _ := key.(addrs.StringKey)
+                // If the key is present in our current for_each, carry on
+                if _, ok := t.ForEach[string(s)]; ok {
+                        continue
+                }
+                abstract := NewNodeAbstractResourceInstance(t.Addr.Instance(key))
+                var node dag.Vertex = abstract
+                if f := t.Concrete; f != nil {
+                        node = f(abstract)
+                }
+                log.Printf("[TRACE] OrphanResourceCount(non-zero): adding %s as %T", t.Addr, node)
+                g.Add(node)
+        }
+        return nil
+}
 func (t *OrphanResourceCountTransformer) transformCount(haveKeys map[addrs.InstanceKey]struct{}, g *Graph) error {
        // Due to the logic in Transform, we only get in here if our count is
        // at least one.
diff --git a/vendor/github.com/hashicorp/terraform/terraform/transform_resource_count.go b/vendor/github.com/hashicorp/terraform/terraform/transform_resource_count.go
index 1123790..c70a3c1 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/transform_resource_count.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/transform_resource_count.go
@@ -4,6 +4,7 @@ import (
        "github.com/hashicorp/terraform/addrs"
        "github.com/hashicorp/terraform/configs/configschema"
        "github.com/hashicorp/terraform/dag"
+        "github.com/zclconf/go-cty/cty"
 )
 // ResourceCountTransformer is a GraphTransformer that expands the count
@@ -17,12 +18,13 @@ type ResourceCountTransformer struct {
        // Count is either the number of indexed instances to create, or -1 to
        // indicate that count is not set at all and thus a no-key instance should
        // be created.
-        Count int
+        Count   int
-        Addr  addrs.AbsResource
+        ForEach map[string]cty.Value
+        Addr    addrs.AbsResource
 }
 func (t *ResourceCountTransformer) Transform(g *Graph) error {
-        if t.Count < 0 {
+        if t.Count < 0 && t.ForEach == nil {
                // Negative count indicates that count is not set at all.
                addr := t.Addr.Instance(addrs.NoKey)
@@ -37,6 +39,19 @@ func (t *ResourceCountTransformer) Transform(g *Graph) error {
                return nil
        }
+        // Add nodes related to the for_each expression
+        for key := range t.ForEach {
+                addr := t.Addr.Instance(addrs.StringKey(key))
+                abstract := NewNodeAbstractResourceInstance(addr)
+                abstract.Schema = t.Schema
+                var node dag.Vertex = abstract
+                if f := t.Concrete; f != nil {
+                        node = f(abstract)
+                }
+                g.Add(node)
+        }
        // For each count, build and add the node
        for i := 0; i < t.Count; i++ {
                key := addrs.IntKey(i)
diff --git a/vendor/github.com/hashicorp/terraform/terraform/util.go b/vendor/github.com/hashicorp/terraform/terraform/util.go
index 752241a..5428cd5 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/util.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/util.go
@@ -2,8 +2,6 @@ package terraform
 import (
        "sort"
-        "github.com/hashicorp/terraform/config"
 )
 // Semaphore is a wrapper around a channel to provide
@@ -48,10 +46,6 @@ func (s Semaphore) Release() {
        }
 }
-func resourceProvider(resourceType, explicitProvider string) string {
-        return config.ResourceProviderFullName(resourceType, explicitProvider)
-}
 // strSliceContains checks if a given string is contained in a slice
 // When anybody asks why Go needs generics, here you go.
 func strSliceContains(haystack []string, needle string) bool {
diff --git a/vendor/github.com/hashicorp/terraform/version/version.go b/vendor/github.com/hashicorp/terraform/version/version.go
index 30d7284..c30595c 100644
--- a/vendor/github.com/hashicorp/terraform/version/version.go
+++ b/vendor/github.com/hashicorp/terraform/version/version.go
@@ -11,7 +11,7 @@ import (
 )
 // The main version number that is being run at the moment.
-var Version = "0.12.0"
+var Version = "0.12.6"
 // A pre-release marker for the version. If this is "" (empty string)
 // then it means that it is a final release. Otherwise, this is a pre-release