deps: github.com/hashicorp/terraform@sdk-v0.11-with-go-modules

Updated via: go get github.com/hashicorp/terraform@sdk-v0.11-with-go-modules and go mod tidy

71 files changed, 10475 insertions, 0 deletions

diff --git a/vendor/github.com/zclconf/go-cty/cty/capsule.go b/vendor/github.com/zclconf/go-cty/cty/capsule.go
new file mode 100644
index 0000000..4fce92a
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/capsule.go
@@ -0,0 +1,89 @@
+package cty
+
+import (
+        "fmt"
+        "reflect"
+)
+
+type capsuleType struct {
+        typeImplSigil
+        Name   string
+        GoType reflect.Type
+}
+
+func (t *capsuleType) Equals(other Type) bool {
+        if otherP, ok := other.typeImpl.(*capsuleType); ok {
+                // capsule types compare by pointer identity
+                return otherP == t
+        }
+        return false
+}
+
+func (t *capsuleType) FriendlyName() string {
+        return t.Name
+}
+
+func (t *capsuleType) GoString() string {
+        // To get a useful representation of our native type requires some
+        // shenanigans.
+        victimVal := reflect.Zero(t.GoType)
+        return fmt.Sprintf("cty.Capsule(%q, reflect.TypeOf(%#v))", t.Name, victimVal.Interface())
+}
+
+// Capsule creates a new Capsule type.
+//
+// A Capsule type is a special type that can be used to transport arbitrary
+// Go native values of a given type through the cty type system. A language
+// that uses cty as its type system might, for example, provide functions
+// that return capsule-typed values and then other functions that operate
+// on those values.
+//
+// From cty's perspective, Capsule types have a few interesting characteristics,
+// described in the following paragraphs.
+//
+// Each capsule type has an associated Go native type that it is able to
+// transport. Capsule types compare by identity, so each call to the
+// Capsule function creates an entirely-distinct cty Type, even if two calls
+// use the same native type.
+//
+// Each capsule-typed value contains a pointer to a value of the given native
+// type. A capsule-typed value supports no operations except equality, and
+// equality is implemented by pointer identity of the encapsulated pointer.
+//
+// The given name is used as the new type's "friendly name". This can be any
+// string in principle, but will usually be a short, all-lowercase name aimed
+// at users of the embedding language (i.e. not mention Go-specific details)
+// and will ideally not create ambiguity with any predefined cty type.
+//
+// Capsule types are never introduced by any standard cty operation, so a
+// calling application opts in to including them within its own type system
+// by creating them and introducing them via its own functions. At that point,
+// the application is responsible for dealing with any capsule-typed values
+// that might be returned.
+func Capsule(name string, nativeType reflect.Type) Type {
+        return Type{
+                &capsuleType{
+                        Name:   name,
+                        GoType: nativeType,
+                },
+        }
+}
+
+// IsCapsuleType returns true if this type is a capsule type, as created
+// by cty.Capsule .
+func (t Type) IsCapsuleType() bool {
+        _, ok := t.typeImpl.(*capsuleType)
+        return ok
+}
+
+// EncapsulatedType returns the encapsulated native type of a capsule type,
+// or panics if the receiver is not a Capsule type.
+//
+// Is IsCapsuleType to determine if this method is safe to call.
+func (t Type) EncapsulatedType() reflect.Type {
+        impl, ok := t.typeImpl.(*capsuleType)
+        if !ok {
+                panic("not a capsule type")
+        }
+        return impl.GoType
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/collection.go b/vendor/github.com/zclconf/go-cty/cty/collection.go
new file mode 100644
index 0000000..ab3919b
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/collection.go
@@ -0,0 +1,34 @@
+package cty
+
+import (
+        "errors"
+)
+
+type collectionTypeImpl interface {
+        ElementType() Type
+}
+
+// IsCollectionType returns true if the given type supports the operations
+// that are defined for all collection types.
+func (t Type) IsCollectionType() bool {
+        _, ok := t.typeImpl.(collectionTypeImpl)
+        return ok
+}
+
+// ElementType returns the element type of the receiver if it is a collection
+// type, or panics if it is not. Use IsCollectionType first to test whether
+// this method will succeed.
+func (t Type) ElementType() Type {
+        if ct, ok := t.typeImpl.(collectionTypeImpl); ok {
+                return ct.ElementType()
+        }
+        panic(errors.New("not a collection type"))
+}
+
+// ElementCallback is a callback type used for iterating over elements of
+// collections and attributes of objects.
+//
+// The types of key and value depend on what type is being iterated over.
+// Return true to stop iterating after the current element, or false to
+// continue iterating.
+type ElementCallback func(key Value, val Value) (stop bool)
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/compare_types.go b/vendor/github.com/zclconf/go-cty/cty/convert/compare_types.go
new file mode 100644
index 0000000..d84f6ac
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/compare_types.go
@@ -0,0 +1,165 @@
+package convert
+
+import (
+        "github.com/zclconf/go-cty/cty"
+)
+
+// compareTypes implements a preference order for unification.
+//
+// The result of this method is not useful for anything other than unification
+// preferences, since it assumes that the caller will verify that any suggested
+// conversion is actually possible and it is thus able to to make certain
+// optimistic assumptions.
+func compareTypes(a cty.Type, b cty.Type) int {
+
+        // DynamicPseudoType always has lowest preference, because anything can
+        // convert to it (it acts as a placeholder for "any type") and we want
+        // to optimistically assume that any dynamics will converge on matching
+        // their neighbors.
+        if a == cty.DynamicPseudoType || b == cty.DynamicPseudoType {
+                if a != cty.DynamicPseudoType {
+                        return -1
+                }
+                if b != cty.DynamicPseudoType {
+                        return 1
+                }
+                return 0
+        }
+
+        if a.IsPrimitiveType() && b.IsPrimitiveType() {
+                // String is a supertype of all primitive types, because we can
+                // represent all primitive values as specially-formatted strings.
+                if a == cty.String || b == cty.String {
+                        if a != cty.String {
+                                return 1
+                        }
+                        if b != cty.String {
+                                return -1
+                        }
+                        return 0
+                }
+        }
+
+        if a.IsListType() && b.IsListType() {
+                return compareTypes(a.ElementType(), b.ElementType())
+        }
+        if a.IsSetType() && b.IsSetType() {
+                return compareTypes(a.ElementType(), b.ElementType())
+        }
+        if a.IsMapType() && b.IsMapType() {
+                return compareTypes(a.ElementType(), b.ElementType())
+        }
+
+        // From this point on we may have swapped the two items in order to
+        // simplify our cases. Therefore any non-zero return after this point
+        // must be multiplied by "swap" to potentially invert the return value
+        // if needed.
+        swap := 1
+        switch {
+        case a.IsTupleType() && b.IsListType():
+                fallthrough
+        case a.IsObjectType() && b.IsMapType():
+                fallthrough
+        case a.IsSetType() && b.IsTupleType():
+                fallthrough
+        case a.IsSetType() && b.IsListType():
+                a, b = b, a
+                swap = -1
+        }
+
+        if b.IsSetType() && (a.IsTupleType() || a.IsListType()) {
+                // We'll just optimistically assume that the element types are
+                // unifyable/convertible, and let a second recursive pass
+                // figure out how to make that so.
+                return -1 * swap
+        }
+
+        if a.IsListType() && b.IsTupleType() {
+                // We'll just optimistically assume that the tuple's element types
+                // can be unified into something compatible with the list's element
+                // type.
+                return -1 * swap
+        }
+
+        if a.IsMapType() && b.IsObjectType() {
+                // We'll just optimistically assume that the object's attribute types
+                // can be unified into something compatible with the map's element
+                // type.
+                return -1 * swap
+        }
+
+        // For object and tuple types, comparing two types doesn't really tell
+        // the whole story because it may be possible to construct a new type C
+        // that is the supertype of both A and B by unifying each attribute/element
+        // separately. That possibility is handled by Unify as a follow-up if
+        // type sorting is insufficient to produce a valid result.
+        //
+        // Here we will take care of the simple possibilities where no new type
+        // is needed.
+        if a.IsObjectType() && b.IsObjectType() {
+                atysA := a.AttributeTypes()
+                atysB := b.AttributeTypes()
+
+                if len(atysA) != len(atysB) {
+                        return 0
+                }
+
+                hasASuper := false
+                hasBSuper := false
+                for k := range atysA {
+                        if _, has := atysB[k]; !has {
+                                return 0
+                        }
+
+                        cmp := compareTypes(atysA[k], atysB[k])
+                        if cmp < 0 {
+                                hasASuper = true
+                        } else if cmp > 0 {
+                                hasBSuper = true
+                        }
+                }
+
+                switch {
+                case hasASuper && hasBSuper:
+                        return 0
+                case hasASuper:
+                        return -1 * swap
+                case hasBSuper:
+                        return 1 * swap
+                default:
+                        return 0
+                }
+        }
+        if a.IsTupleType() && b.IsTupleType() {
+                etysA := a.TupleElementTypes()
+                etysB := b.TupleElementTypes()
+
+                if len(etysA) != len(etysB) {
+                        return 0
+                }
+
+                hasASuper := false
+                hasBSuper := false
+                for i := range etysA {
+                        cmp := compareTypes(etysA[i], etysB[i])
+                        if cmp < 0 {
+                                hasASuper = true
+                        } else if cmp > 0 {
+                                hasBSuper = true
+                        }
+                }
+
+                switch {
+                case hasASuper && hasBSuper:
+                        return 0
+                case hasASuper:
+                        return -1 * swap
+                case hasBSuper:
+                        return 1 * swap
+                default:
+                        return 0
+                }
+        }
+
+        return 0
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion.go
new file mode 100644
index 0000000..7bfcc08
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion.go
@@ -0,0 +1,120 @@
+package convert
+
+import (
+        "github.com/zclconf/go-cty/cty"
+)
+
+// conversion is an internal variant of Conversion that carries around
+// a cty.Path to be used in error responses.
+type conversion func(cty.Value, cty.Path) (cty.Value, error)
+
+func getConversion(in cty.Type, out cty.Type, unsafe bool) conversion {
+        conv := getConversionKnown(in, out, unsafe)
+        if conv == nil {
+                return nil
+        }
+
+        // Wrap the conversion in some standard checks that we don't want to
+        // have to repeat in every conversion function.
+        return func(in cty.Value, path cty.Path) (cty.Value, error) {
+                if !in.IsKnown() {
+                        return cty.UnknownVal(out), nil
+                }
+                if in.IsNull() {
+                        // We'll pass through nulls, albeit type converted, and let
+                        // the caller deal with whatever handling they want to do in
+                        // case null values are considered valid in some applications.
+                        return cty.NullVal(out), nil
+                }
+
+                return conv(in, path)
+        }
+}
+
+func getConversionKnown(in cty.Type, out cty.Type, unsafe bool) conversion {
+        switch {
+
+        case out == cty.DynamicPseudoType:
+                // Conversion *to* DynamicPseudoType means that the caller wishes
+                // to allow any type in this position, so we'll produce a do-nothing
+                // conversion that just passes through the value as-is.
+                return dynamicPassthrough
+
+        case unsafe && in == cty.DynamicPseudoType:
+                // Conversion *from* DynamicPseudoType means that we have a value
+                // whose type isn't yet known during type checking. For these we will
+                // assume that conversion will succeed and deal with any errors that
+                // result (which is why we can only do this when "unsafe" is set).
+                return dynamicFixup(out)
+
+        case in.IsPrimitiveType() && out.IsPrimitiveType():
+                conv := primitiveConversionsSafe[in][out]
+                if conv != nil {
+                        return conv
+                }
+                if unsafe {
+                        return primitiveConversionsUnsafe[in][out]
+                }
+                return nil
+
+        case out.IsListType() && (in.IsListType() || in.IsSetType()):
+                inEty := in.ElementType()
+                outEty := out.ElementType()
+                if inEty.Equals(outEty) {
+                        // This indicates that we're converting from list to set with
+                        // the same element type, so we don't need an element converter.
+                        return conversionCollectionToList(outEty, nil)
+                }
+
+                convEty := getConversion(inEty, outEty, unsafe)
+                if convEty == nil {
+                        return nil
+                }
+                return conversionCollectionToList(outEty, convEty)
+
+        case out.IsSetType() && (in.IsListType() || in.IsSetType()):
+                if in.IsListType() && !unsafe {
+                        // Conversion from list to map is unsafe because it will lose
+                        // information: the ordering will not be preserved, and any
+                        // duplicate elements will be conflated.
+                        return nil
+                }
+                inEty := in.ElementType()
+                outEty := out.ElementType()
+                convEty := getConversion(inEty, outEty, unsafe)
+                if inEty.Equals(outEty) {
+                        // This indicates that we're converting from set to list with
+                        // the same element type, so we don't need an element converter.
+                        return conversionCollectionToSet(outEty, nil)
+                }
+
+                if convEty == nil {
+                        return nil
+                }
+                return conversionCollectionToSet(outEty, convEty)
+
+        case out.IsListType() && in.IsTupleType():
+                outEty := out.ElementType()
+                return conversionTupleToList(in, outEty, unsafe)
+
+        case out.IsMapType() && in.IsObjectType():
+                outEty := out.ElementType()
+                return conversionObjectToMap(in, outEty, unsafe)
+
+        default:
+                return nil
+
+        }
+}
+
+// retConversion wraps a conversion (internal type) so it can be returned
+// as a Conversion (public type).
+func retConversion(conv conversion) Conversion {
+        if conv == nil {
+                return nil
+        }
+
+        return func(in cty.Value) (cty.Value, error) {
+                return conv(in, cty.Path(nil))
+        }
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_collection.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_collection.go
new file mode 100644
index 0000000..eace85d
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_collection.go
@@ -0,0 +1,226 @@
+package convert
+
+import (
+        "github.com/zclconf/go-cty/cty"
+)
+
+// conversionCollectionToList returns a conversion that will apply the given
+// conversion to all of the elements of a collection (something that supports
+// ForEachElement and LengthInt) and then returns the result as a list.
+//
+// "conv" can be nil if the elements are expected to already be of the
+// correct type and just need to be re-wrapped into a list. (For example,
+// if we're converting from a set into a list of the same element type.)
+func conversionCollectionToList(ety cty.Type, conv conversion) conversion {
+        return func(val cty.Value, path cty.Path) (cty.Value, error) {
+                elems := make([]cty.Value, 0, val.LengthInt())
+                i := int64(0)
+                path = append(path, nil)
+                it := val.ElementIterator()
+                for it.Next() {
+                        _, val := it.Element()
+                        var err error
+
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: cty.NumberIntVal(i),
+                        }
+
+                        if conv != nil {
+                                val, err = conv(val, path)
+                                if err != nil {
+                                        return cty.NilVal, err
+                                }
+                        }
+                        elems = append(elems, val)
+
+                        i++
+                }
+
+                if len(elems) == 0 {
+                        return cty.ListValEmpty(ety), nil
+                }
+
+                return cty.ListVal(elems), nil
+        }
+}
+
+// conversionCollectionToSet returns a conversion that will apply the given
+// conversion to all of the elements of a collection (something that supports
+// ForEachElement and LengthInt) and then returns the result as a set.
+//
+// "conv" can be nil if the elements are expected to already be of the
+// correct type and just need to be re-wrapped into a set. (For example,
+// if we're converting from a list into a set of the same element type.)
+func conversionCollectionToSet(ety cty.Type, conv conversion) conversion {
+        return func(val cty.Value, path cty.Path) (cty.Value, error) {
+                elems := make([]cty.Value, 0, val.LengthInt())
+                i := int64(0)
+                path = append(path, nil)
+                it := val.ElementIterator()
+                for it.Next() {
+                        _, val := it.Element()
+                        var err error
+
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: cty.NumberIntVal(i),
+                        }
+
+                        if conv != nil {
+                                val, err = conv(val, path)
+                                if err != nil {
+                                        return cty.NilVal, err
+                                }
+                        }
+                        elems = append(elems, val)
+
+                        i++
+                }
+
+                if len(elems) == 0 {
+                        return cty.SetValEmpty(ety), nil
+                }
+
+                return cty.SetVal(elems), nil
+        }
+}
+
+// conversionTupleToList returns a conversion that will take a value of the
+// given tuple type and return a list of the given element type.
+//
+// Will panic if the given tupleType isn't actually a tuple type.
+func conversionTupleToList(tupleType cty.Type, listEty cty.Type, unsafe bool) conversion {
+        tupleEtys := tupleType.TupleElementTypes()
+
+        if len(tupleEtys) == 0 {
+                // Empty tuple short-circuit
+                return func(val cty.Value, path cty.Path) (cty.Value, error) {
+                        return cty.ListValEmpty(listEty), nil
+                }
+        }
+
+        if listEty == cty.DynamicPseudoType {
+                // This is a special case where the caller wants us to find
+                // a suitable single type that all elements can convert to, if
+                // possible.
+                listEty, _ = unify(tupleEtys, unsafe)
+                if listEty == cty.NilType {
+                        return nil
+                }
+        }
+
+        elemConvs := make([]conversion, len(tupleEtys))
+        for i, tupleEty := range tupleEtys {
+                if tupleEty.Equals(listEty) {
+                        // no conversion required
+                        continue
+                }
+
+                elemConvs[i] = getConversion(tupleEty, listEty, unsafe)
+                if elemConvs[i] == nil {
+                        // If any of our element conversions are impossible, then the our
+                        // whole conversion is impossible.
+                        return nil
+                }
+        }
+
+        // If we fall out here then a conversion is possible, using the
+        // element conversions in elemConvs
+        return func(val cty.Value, path cty.Path) (cty.Value, error) {
+                elems := make([]cty.Value, 0, len(elemConvs))
+                path = append(path, nil)
+                i := int64(0)
+                it := val.ElementIterator()
+                for it.Next() {
+                        _, val := it.Element()
+                        var err error
+
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: cty.NumberIntVal(i),
+                        }
+
+                        conv := elemConvs[i]
+                        if conv != nil {
+                                val, err = conv(val, path)
+                                if err != nil {
+                                        return cty.NilVal, err
+                                }
+                        }
+                        elems = append(elems, val)
+
+                        i++
+                }
+
+                return cty.ListVal(elems), nil
+        }
+}
+
+// conversionObjectToMap returns a conversion that will take a value of the
+// given object type and return a map of the given element type.
+//
+// Will panic if the given objectType isn't actually an object type.
+func conversionObjectToMap(objectType cty.Type, mapEty cty.Type, unsafe bool) conversion {
+        objectAtys := objectType.AttributeTypes()
+
+        if len(objectAtys) == 0 {
+                // Empty object short-circuit
+                return func(val cty.Value, path cty.Path) (cty.Value, error) {
+                        return cty.MapValEmpty(mapEty), nil
+                }
+        }
+
+        if mapEty == cty.DynamicPseudoType {
+                // This is a special case where the caller wants us to find
+                // a suitable single type that all elements can convert to, if
+                // possible.
+                objectAtysList := make([]cty.Type, 0, len(objectAtys))
+                for _, aty := range objectAtys {
+                        objectAtysList = append(objectAtysList, aty)
+                }
+                mapEty, _ = unify(objectAtysList, unsafe)
+                if mapEty == cty.NilType {
+                        return nil
+                }
+        }
+
+        elemConvs := make(map[string]conversion, len(objectAtys))
+        for name, objectAty := range objectAtys {
+                if objectAty.Equals(mapEty) {
+                        // no conversion required
+                        continue
+                }
+
+                elemConvs[name] = getConversion(objectAty, mapEty, unsafe)
+                if elemConvs[name] == nil {
+                        // If any of our element conversions are impossible, then the our
+                        // whole conversion is impossible.
+                        return nil
+                }
+        }
+
+        // If we fall out here then a conversion is possible, using the
+        // element conversions in elemConvs
+        return func(val cty.Value, path cty.Path) (cty.Value, error) {
+                elems := make(map[string]cty.Value, len(elemConvs))
+                path = append(path, nil)
+                it := val.ElementIterator()
+                for it.Next() {
+                        name, val := it.Element()
+                        var err error
+
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: name,
+                        }
+
+                        conv := elemConvs[name.AsString()]
+                        if conv != nil {
+                                val, err = conv(val, path)
+                                if err != nil {
+                                        return cty.NilVal, err
+                                }
+                        }
+                        elems[name.AsString()] = val
+                }
+
+                return cty.MapVal(elems), nil
+        }
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_dynamic.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_dynamic.go
new file mode 100644
index 0000000..4d19cf6
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_dynamic.go
@@ -0,0 +1,33 @@
+package convert
+
+import (
+        "github.com/zclconf/go-cty/cty"
+)
+
+// dynamicFixup deals with just-in-time conversions of values that were
+// input-typed as cty.DynamicPseudoType during analysis, ensuring that
+// we end up with the desired output type once the value is known, or
+// failing with an error if that is not possible.
+//
+// This is in the spirit of the cty philosophy of optimistically assuming that
+// DynamicPseudoType values will become the intended value eventually, and
+// dealing with any inconsistencies during final evaluation.
+func dynamicFixup(wantType cty.Type) conversion {
+        return func(in cty.Value, path cty.Path) (cty.Value, error) {
+                ret, err := Convert(in, wantType)
+                if err != nil {
+                        // Re-wrap this error so that the returned path is relative
+                        // to the caller's original value, rather than relative to our
+                        // conversion value here.
+                        return cty.NilVal, path.NewError(err)
+                }
+                return ret, nil
+        }
+}
+
+// dynamicPassthrough is an identity conversion that is used when the
+// target type is DynamicPseudoType, indicating that the caller doesn't care
+// which type is returned.
+func dynamicPassthrough(in cty.Value, path cty.Path) (cty.Value, error) {
+        return in, nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_primitive.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_primitive.go
new file mode 100644
index 0000000..e563ee3
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_primitive.go
@@ -0,0 +1,50 @@
+package convert
+
+import (
+        "math/big"
+
+        "github.com/zclconf/go-cty/cty"
+)
+
+var stringTrue = cty.StringVal("true")
+var stringFalse = cty.StringVal("false")
+
+var primitiveConversionsSafe = map[cty.Type]map[cty.Type]conversion{
+        cty.Number: {
+                cty.String: func(val cty.Value, path cty.Path) (cty.Value, error) {
+                        f := val.AsBigFloat()
+                        return cty.StringVal(f.Text('f', -1)), nil
+                },
+        },
+        cty.Bool: {
+                cty.String: func(val cty.Value, path cty.Path) (cty.Value, error) {
+                        if val.True() {
+                                return stringTrue, nil
+                        } else {
+                                return stringFalse, nil
+                        }
+                },
+        },
+}
+
+var primitiveConversionsUnsafe = map[cty.Type]map[cty.Type]conversion{
+        cty.String: {
+                cty.Number: func(val cty.Value, path cty.Path) (cty.Value, error) {
+                        f, _, err := big.ParseFloat(val.AsString(), 10, 512, big.ToNearestEven)
+                        if err != nil {
+                                return cty.NilVal, path.NewErrorf("a number is required")
+                        }
+                        return cty.NumberVal(f), nil
+                },
+                cty.Bool: func(val cty.Value, path cty.Path) (cty.Value, error) {
+                        switch val.AsString() {
+                        case "true", "1":
+                                return cty.True, nil
+                        case "false", "0":
+                                return cty.False, nil
+                        default:
+                                return cty.NilVal, path.NewErrorf("a bool is required")
+                        }
+                },
+        },
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/doc.go b/vendor/github.com/zclconf/go-cty/cty/convert/doc.go
new file mode 100644
index 0000000..2037299
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/doc.go
@@ -0,0 +1,15 @@
+// Package convert contains some routines for converting between cty types.
+// The intent of providing this package is to encourage applications using
+// cty to have consistent type conversion behavior for maximal interoperability
+// when Values pass from one application to another.
+//
+// The conversions are categorized into two categories. "Safe" conversions are
+// ones that are guaranteed to succeed if given a non-null value of the
+// appropriate source type. "Unsafe" conversions, on the other hand, are valid
+// for only a subset of input values, and thus may fail with an error when
+// called for values outside of that valid subset.
+//
+// The functions whose names end in Unsafe support all of the conversions that
+// are supported by the corresponding functions whose names do not have that
+// suffix, and then additional unsafe conversions as well.
+package convert
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/public.go b/vendor/github.com/zclconf/go-cty/cty/convert/public.go
new file mode 100644
index 0000000..55f44ae
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/public.go
@@ -0,0 +1,83 @@
+package convert
+
+import (
+        "fmt"
+
+        "github.com/zclconf/go-cty/cty"
+)
+
+// This file contains the public interface of this package, which is intended
+// to be a small, convenient interface designed for easy integration into
+// a hypothetical language type checker and interpreter.
+
+// Conversion is a named function type representing a conversion from a
+// value of one type to a value of another type.
+//
+// The source type for a conversion is always the source type given to
+// the function that returned the Conversion, but there is no way to recover
+// that from a Conversion value itself. If a Conversion is given a value
+// that is not of its expected type (with the exception of DynamicPseudoType,
+// which is always supported) then the function may panic or produce undefined
+// results.
+type Conversion func(in cty.Value) (out cty.Value, err error)
+
+// GetConversion returns a Conversion between the given in and out Types if
+// a safe one is available, or returns nil otherwise.
+func GetConversion(in cty.Type, out cty.Type) Conversion {
+        return retConversion(getConversion(in, out, false))
+}
+
+// GetConversionUnsafe returns a Conversion between the given in and out Types
+// if either a safe or unsafe one is available, or returns nil otherwise.
+func GetConversionUnsafe(in cty.Type, out cty.Type) Conversion {
+        return retConversion(getConversion(in, out, true))
+}
+
+// Convert returns the result of converting the given value to the given type
+// if an safe or unsafe conversion is available, or returns an error if such a
+// conversion is impossible.
+//
+// This is a convenience wrapper around calling GetConversionUnsafe and then
+// immediately passing the given value to the resulting function.
+func Convert(in cty.Value, want cty.Type) (cty.Value, error) {
+        if in.Type().Equals(want) {
+                return in, nil
+        }
+
+        conv := GetConversionUnsafe(in.Type(), want)
+        if conv == nil {
+                return cty.NilVal, fmt.Errorf("incorrect type; %s required", want.FriendlyName())
+        }
+        return conv(in)
+}
+
+// Unify attempts to find the most general type that can be converted from
+// all of the given types. If this is possible, that type is returned along
+// with a slice of necessary conversions for some of the given types.
+//
+// If no common supertype can be found, this function returns cty.NilType and
+// a nil slice.
+//
+// If a common supertype *can* be found, the returned slice will always be
+// non-nil and will contain a non-nil conversion for each given type that
+// needs to be converted, with indices corresponding to the input slice.
+// Any given type that does *not* need conversion (because it is already of
+// the appropriate type) will have a nil Conversion.
+//
+// cty.DynamicPseudoType is, as usual, a special case. If the given type list
+// contains a mixture of dynamic and non-dynamic types, the dynamic types are
+// disregarded for type selection and a conversion is returned for them that
+// will attempt a late conversion of the given value to the target type,
+// failing with a conversion error if the eventual concrete type is not
+// compatible. If *all* given types are DynamicPseudoType, or in the
+// degenerate case of an empty slice of types, the returned type is itself
+// cty.DynamicPseudoType and no conversions are attempted.
+func Unify(types []cty.Type) (cty.Type, []Conversion) {
+        return unify(types, false)
+}
+
+// UnifyUnsafe is the same as Unify except that it may return unsafe
+// conversions in situations where a safe conversion isn't also available.
+func UnifyUnsafe(types []cty.Type) (cty.Type, []Conversion) {
+        return unify(types, true)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/sort_types.go b/vendor/github.com/zclconf/go-cty/cty/convert/sort_types.go
new file mode 100644
index 0000000..b776910
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/sort_types.go
@@ -0,0 +1,69 @@
+package convert
+
+import (
+        "github.com/zclconf/go-cty/cty"
+)
+
+// sortTypes produces an ordering of the given types that serves as a
+// preference order for the result of unification of the given types.
+// The return value is a slice of indices into the given slice, and will
+// thus always be the same length as the given slice.
+//
+// The goal is that the most general of the given types will appear first
+// in the ordering. If there are uncomparable pairs of types in the list
+// then they will appear in an undefined order, and the unification pass
+// will presumably then fail.
+func sortTypes(tys []cty.Type) []int {
+        l := len(tys)
+
+        // First we build a graph whose edges represent "more general than",
+        // which we will then do a topological sort of.
+        edges := make([][]int, l)
+        for i := 0; i < (l - 1); i++ {
+                for j := i + 1; j < l; j++ {
+                        cmp := compareTypes(tys[i], tys[j])
+                        switch {
+                        case cmp < 0:
+                                edges[i] = append(edges[i], j)
+                        case cmp > 0:
+                                edges[j] = append(edges[j], i)
+                        }
+                }
+        }
+
+        // Compute the in-degree of each node
+        inDegree := make([]int, l)
+        for _, outs := range edges {
+                for _, j := range outs {
+                        inDegree[j]++
+                }
+        }
+
+        // The array backing our result will double as our queue for visiting
+        // the nodes, with the queue slice moving along this array until it
+        // is empty and positioned at the end of the array. Thus our visiting
+        // order is also our result order.
+        result := make([]int, l)
+        queue := result[0:0]
+
+        // Initialize the queue with any item of in-degree 0, preserving
+        // their relative order.
+        for i, n := range inDegree {
+                if n == 0 {
+                        queue = append(queue, i)
+                }
+        }
+
+        for len(queue) != 0 {
+                i := queue[0]
+                queue = queue[1:]
+                for _, j := range edges[i] {
+                        inDegree[j]--
+                        if inDegree[j] == 0 {
+                                queue = append(queue, j)
+                        }
+                }
+        }
+
+        return result
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/unify.go b/vendor/github.com/zclconf/go-cty/cty/convert/unify.go
new file mode 100644
index 0000000..bd6736b
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/unify.go
@@ -0,0 +1,66 @@
+package convert
+
+import (
+        "github.com/zclconf/go-cty/cty"
+)
+
+// The current unify implementation is somewhat inefficient, but we accept this
+// under the assumption that it will generally be used with small numbers of
+// types and with types of reasonable complexity. However, it does have a
+// "happy path" where all of the given types are equal.
+//
+// This function is likely to have poor performance in cases where any given
+// types are very complex (lots of deeply-nested structures) or if the list
+// of types itself is very large. In particular, it will walk the nested type
+// structure under the given types several times, especially when given a
+// list of types for which unification is not possible, since each permutation
+// will be tried to determine that result.
+func unify(types []cty.Type, unsafe bool) (cty.Type, []Conversion) {
+        if len(types) == 0 {
+                // Degenerate case
+                return cty.NilType, nil
+        }
+
+        prefOrder := sortTypes(types)
+
+        // sortTypes gives us an order where earlier items are preferable as
+        // our result type. We'll now walk through these and choose the first
+        // one we encounter for which conversions exist for all source types.
+        conversions := make([]Conversion, len(types))
+Preferences:
+        for _, wantTypeIdx := range prefOrder {
+                wantType := types[wantTypeIdx]
+                for i, tryType := range types {
+                        if i == wantTypeIdx {
+                                // Don't need to convert our wanted type to itself
+                                conversions[i] = nil
+                                continue
+                        }
+
+                        if tryType.Equals(wantType) {
+                                conversions[i] = nil
+                                continue
+                        }
+
+                        if unsafe {
+                                conversions[i] = GetConversionUnsafe(tryType, wantType)
+                        } else {
+                                conversions[i] = GetConversion(tryType, wantType)
+                        }
+
+                        if conversions[i] == nil {
+                                // wantType is not a suitable unification type, so we'll
+                                // try the next one in our preference order.
+                                continue Preferences
+                        }
+                }
+
+                return wantType, conversions
+        }
+
+        // TODO: For structural types, try to invent a new type that they
+        // can all be unified to, by unifying their respective attributes.
+
+        // If we fall out here, no unification is possible
+        return cty.NilType, nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/doc.go b/vendor/github.com/zclconf/go-cty/cty/doc.go
new file mode 100644
index 0000000..d31f054
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/doc.go
@@ -0,0 +1,18 @@
+// Package cty (pronounced see-tie) provides some infrastructure for a type
+// system that might be useful for applications that need to represent
+// configuration values provided by the user whose types are not known
+// at compile time, particularly if the calling application also allows
+// such values to be used in expressions.
+//
+// The type system consists of primitive types Number, String and Bool, as
+// well as List and Map collection types and Object types that can have
+// arbitrarily-typed sets of attributes.
+//
+// A set of operations is defined on these types, which is accessible via
+// the wrapper struct Value, which annotates the raw, internal representation
+// of a value with its corresponding type.
+//
+// This package is oriented towards being a building block for configuration
+// languages used to bootstrap an application. It is not optimized for use
+// in tight loops where CPU time or memory pressure are a concern.
+package cty
diff --git a/vendor/github.com/zclconf/go-cty/cty/element_iterator.go b/vendor/github.com/zclconf/go-cty/cty/element_iterator.go
new file mode 100644
index 0000000..0bf84c7
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/element_iterator.go
@@ -0,0 +1,191 @@
+package cty
+
+import (
+        "sort"
+
+        "github.com/zclconf/go-cty/cty/set"
+)
+
+// ElementIterator is the interface type returned by Value.ElementIterator to
+// allow the caller to iterate over elements of a collection-typed value.
+//
+// Its usage pattern is as follows:
+//
+//     it := val.ElementIterator()
+//     for it.Next() {
+//         key, val := it.Element()
+//         // ...
+//     }
+type ElementIterator interface {
+        Next() bool
+        Element() (key Value, value Value)
+}
+
+func canElementIterator(val Value) bool {
+        switch {
+        case val.ty.IsListType():
+                return true
+        case val.ty.IsMapType():
+                return true
+        case val.ty.IsSetType():
+                return true
+        case val.ty.IsTupleType():
+                return true
+        case val.ty.IsObjectType():
+                return true
+        default:
+                return false
+        }
+}
+
+func elementIterator(val Value) ElementIterator {
+        switch {
+        case val.ty.IsListType():
+                return &listElementIterator{
+                        ety:  val.ty.ElementType(),
+                        vals: val.v.([]interface{}),
+                        idx:  -1,
+                }
+        case val.ty.IsMapType():
+                // We iterate the keys in a predictable lexicographical order so
+                // that results will always be stable given the same input map.
+                rawMap := val.v.(map[string]interface{})
+                keys := make([]string, 0, len(rawMap))
+                for key := range rawMap {
+                        keys = append(keys, key)
+                }
+                sort.Strings(keys)
+
+                return &mapElementIterator{
+                        ety:  val.ty.ElementType(),
+                        vals: rawMap,
+                        keys: keys,
+                        idx:  -1,
+                }
+        case val.ty.IsSetType():
+                rawSet := val.v.(set.Set)
+                return &setElementIterator{
+                        ety:   val.ty.ElementType(),
+                        setIt: rawSet.Iterator(),
+                }
+        case val.ty.IsTupleType():
+                return &tupleElementIterator{
+                        etys: val.ty.TupleElementTypes(),
+                        vals: val.v.([]interface{}),
+                        idx:  -1,
+                }
+        case val.ty.IsObjectType():
+                // We iterate the keys in a predictable lexicographical order so
+                // that results will always be stable given the same object type.
+                atys := val.ty.AttributeTypes()
+                keys := make([]string, 0, len(atys))
+                for key := range atys {
+                        keys = append(keys, key)
+                }
+                sort.Strings(keys)
+
+                return &objectElementIterator{
+                        atys:      atys,
+                        vals:      val.v.(map[string]interface{}),
+                        attrNames: keys,
+                        idx:       -1,
+                }
+        default:
+                panic("attempt to iterate on non-collection, non-tuple type")
+        }
+}
+
+type listElementIterator struct {
+        ety  Type
+        vals []interface{}
+        idx  int
+}
+
+func (it *listElementIterator) Element() (Value, Value) {
+        i := it.idx
+        return NumberIntVal(int64(i)), Value{
+                ty: it.ety,
+                v:  it.vals[i],
+        }
+}
+
+func (it *listElementIterator) Next() bool {
+        it.idx++
+        return it.idx < len(it.vals)
+}
+
+type mapElementIterator struct {
+        ety  Type
+        vals map[string]interface{}
+        keys []string
+        idx  int
+}
+
+func (it *mapElementIterator) Element() (Value, Value) {
+        key := it.keys[it.idx]
+        return StringVal(key), Value{
+                ty: it.ety,
+                v:  it.vals[key],
+        }
+}
+
+func (it *mapElementIterator) Next() bool {
+        it.idx++
+        return it.idx < len(it.keys)
+}
+
+type setElementIterator struct {
+        ety   Type
+        setIt *set.Iterator
+}
+
+func (it *setElementIterator) Element() (Value, Value) {
+        val := Value{
+                ty: it.ety,
+                v:  it.setIt.Value(),
+        }
+        return val, val
+}
+
+func (it *setElementIterator) Next() bool {
+        return it.setIt.Next()
+}
+
+type tupleElementIterator struct {
+        etys []Type
+        vals []interface{}
+        idx  int
+}
+
+func (it *tupleElementIterator) Element() (Value, Value) {
+        i := it.idx
+        return NumberIntVal(int64(i)), Value{
+                ty: it.etys[i],
+                v:  it.vals[i],
+        }
+}
+
+func (it *tupleElementIterator) Next() bool {
+        it.idx++
+        return it.idx < len(it.vals)
+}
+
+type objectElementIterator struct {
+        atys      map[string]Type
+        vals      map[string]interface{}
+        attrNames []string
+        idx       int
+}
+
+func (it *objectElementIterator) Element() (Value, Value) {
+        key := it.attrNames[it.idx]
+        return StringVal(key), Value{
+                ty: it.atys[key],
+                v:  it.vals[key],
+        }
+}
+
+func (it *objectElementIterator) Next() bool {
+        it.idx++
+        return it.idx < len(it.attrNames)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/error.go b/vendor/github.com/zclconf/go-cty/cty/error.go
new file mode 100644
index 0000000..dd139f7
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/error.go
@@ -0,0 +1,55 @@
+package cty
+
+import (
+        "fmt"
+)
+
+// PathError is a specialization of error that represents where in a
+// potentially-deep data structure an error occured, using a Path.
+type PathError struct {
+        error
+        Path Path
+}
+
+func errorf(path Path, f string, args ...interface{}) error {
+        // We need to copy the Path because often our caller builds it by
+        // continually mutating the same underlying buffer.
+        sPath := make(Path, len(path))
+        copy(sPath, path)
+        return PathError{
+                error: fmt.Errorf(f, args...),
+                Path:  sPath,
+        }
+}
+
+// NewErrorf creates a new PathError for the current path by passing the
+// given format and arguments to fmt.Errorf and then wrapping the result
+// similarly to NewError.
+func (p Path) NewErrorf(f string, args ...interface{}) error {
+        return errorf(p, f, args...)
+}
+
+// NewError creates a new PathError for the current path, wrapping the given
+// error.
+func (p Path) NewError(err error) error {
+        // if we're being asked to wrap an existing PathError then our new
+        // PathError will be the concatenation of the two paths, ensuring
+        // that we still get a single flat PathError that's thus easier for
+        // callers to deal with.
+        perr, wrappingPath := err.(PathError)
+        pathLen := len(p)
+        if wrappingPath {
+                pathLen = pathLen + len(perr.Path)
+        }
+
+        sPath := make(Path, pathLen)
+        copy(sPath, p)
+        if wrappingPath {
+                copy(sPath[len(p):], perr.Path)
+        }
+
+        return PathError{
+                error: err,
+                Path:  sPath,
+        }
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/argument.go b/vendor/github.com/zclconf/go-cty/cty/function/argument.go
new file mode 100644
index 0000000..bfd3015
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/argument.go
@@ -0,0 +1,50 @@
+package function
+
+import (
+        "github.com/zclconf/go-cty/cty"
+)
+
+// Parameter represents a parameter to a function.
+type Parameter struct {
+        // Name is an optional name for the argument. This package ignores this
+        // value, but callers may use it for documentation, etc.
+        Name string
+
+        // A type that any argument for this parameter must conform to.
+        // cty.DynamicPseudoType can be used, either at top-level or nested
+        // in a parameterized type, to indicate that any type should be
+        // permitted, to allow the definition of type-generic functions.
+        Type cty.Type
+
+        // If AllowNull is set then null values may be passed into this
+        // argument's slot in both the type-check function and the implementation
+        // function. If not set, such values are rejected by the built-in
+        // checking rules.
+        AllowNull bool
+
+        // If AllowUnknown is set then unknown values may be passed into this
+        // argument's slot in the implementation function. If not set, any
+        // unknown values will cause the function to immediately return
+        // an unkonwn value without calling the implementation function, thus
+        // freeing the function implementer from dealing with this case.
+        AllowUnknown bool
+
+        // If AllowDynamicType is set then DynamicVal may be passed into this
+        // argument's slot in the implementation function. If not set, any
+        // dynamic values will cause the function to immediately return
+        // DynamicVal value without calling the implementation function, thus
+        // freeing the function implementer from dealing with this case.
+        //
+        // Note that DynamicVal is also unknown, so in order to receive dynamic
+        // *values* it is also necessary to set AllowUnknown.
+        //
+        // However, it is valid to set AllowDynamicType without AllowUnknown, in
+        // which case a dynamic value may be passed to the type checking function
+        // but will not make it to the *implementation* function. Instead, an
+        // unknown value of the type returned by the type-check function will be
+        // returned. This is suggested for functions that have a static return
+        // type since it allows the return value to be typed even if the input
+        // values are not, thus improving the type-check accuracy of derived
+        // values.
+        AllowDynamicType bool
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/doc.go b/vendor/github.com/zclconf/go-cty/cty/function/doc.go
new file mode 100644
index 0000000..393b311
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/doc.go
@@ -0,0 +1,6 @@
+// Package function builds on the functionality of cty by modeling functions
+// that operate on cty Values.
+//
+// Functions are, at their core, Go anonymous functions. However, this package
+// wraps around them utility functions for parameter type checking, etc.
+package function
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/error.go b/vendor/github.com/zclconf/go-cty/cty/function/error.go
new file mode 100644
index 0000000..2b56779
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/error.go
@@ -0,0 +1,50 @@
+package function
+
+import (
+        "fmt"
+        "runtime/debug"
+)
+
+// ArgError represents an error with one of the arguments in a call. The
+// attribute Index represents the zero-based index of the argument in question.
+//
+// Its error *may* be a cty.PathError, in which case the error actually
+// pertains to a nested value within the data structure passed as the argument.
+type ArgError struct {
+        error
+        Index int
+}
+
+func NewArgErrorf(i int, f string, args ...interface{}) error {
+        return ArgError{
+                error: fmt.Errorf(f, args...),
+                Index: i,
+        }
+}
+
+func NewArgError(i int, err error) error {
+        return ArgError{
+                error: err,
+                Index: i,
+        }
+}
+
+// PanicError indicates that a panic occurred while executing either a
+// function's type or implementation function. This is captured and wrapped
+// into a normal error so that callers (expected to be language runtimes)
+// are freed from having to deal with panics in buggy functions.
+type PanicError struct {
+        Value interface{}
+        Stack []byte
+}
+
+func errorForPanic(val interface{}) error {
+        return PanicError{
+                Value: val,
+                Stack: debug.Stack(),
+        }
+}
+
+func (e PanicError) Error() string {
+        return fmt.Sprintf("panic in function implementation: %s\n%s", e.Value, e.Stack)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/function.go b/vendor/github.com/zclconf/go-cty/cty/function/function.go
new file mode 100644
index 0000000..162f7bf
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/function.go
@@ -0,0 +1,291 @@
+package function
+
+import (
+        "fmt"
+
+        "github.com/zclconf/go-cty/cty"
+)
+
+// Function represents a function. This is the main type in this package.
+type Function struct {
+        spec *Spec
+}
+
+// Spec is the specification of a function, used to instantiate
+// a new Function.
+type Spec struct {
+        // Params is a description of the positional parameters for the function.
+        // The standard checking logic rejects any calls that do not provide
+        // arguments conforming to this definition, freeing the function
+        // implementer from dealing with such inconsistencies.
+        Params []Parameter
+
+        // VarParam is an optional specification of additional "varargs" the
+        // function accepts. If this is non-nil then callers may provide an
+        // arbitrary number of additional arguments (after those matching with
+        // the fixed parameters in Params) that conform to the given specification,
+        // which will appear as additional values in the slices of values
+        // provided to the type and implementation functions.
+        VarParam *Parameter
+
+        // Type is the TypeFunc that decides the return type of the function
+        // given its arguments, which may be Unknown. See the documentation
+        // of TypeFunc for more information.
+        //
+        // Use StaticReturnType if the function's return type does not vary
+        // depending on its arguments.
+        Type TypeFunc
+
+        // Impl is the ImplFunc that implements the function's behavior.
+        //
+        // Functions are expected to behave as pure functions, and not create
+        // any visible side-effects.
+        //
+        // If a TypeFunc is also provided, the value returned from Impl *must*
+        // conform to the type it returns, or a call to the function will panic.
+        Impl ImplFunc
+}
+
+// New creates a new function with the given specification.
+//
+// After passing a Spec to this function, the caller must no longer read from
+// or mutate it.
+func New(spec *Spec) Function {
+        f := Function{
+                spec: spec,
+        }
+        return f
+}
+
+// TypeFunc is a callback type for determining the return type of a function
+// given its arguments.
+//
+// Any of the values passed to this function may be unknown, even if the
+// parameters are not configured to accept unknowns.
+//
+// If any of the given values are *not* unknown, the TypeFunc may use the
+// values for pre-validation and for choosing the return type. For example,
+// a hypothetical JSON-unmarshalling function could return
+// cty.DynamicPseudoType if the given JSON string is unknown, but return
+// a concrete type based on the JSON structure if the JSON string is already
+// known.
+type TypeFunc func(args []cty.Value) (cty.Type, error)
+
+// ImplFunc is a callback type for the main implementation of a function.
+//
+// "args" are the values for the arguments, and this slice will always be at
+// least as long as the argument definition slice for the function.
+//
+// "retType" is the type returned from the Type callback, included as a
+// convenience to avoid the need to re-compute the return type for generic
+// functions whose return type is a function of the arguments.
+type ImplFunc func(args []cty.Value, retType cty.Type) (cty.Value, error)
+
+// StaticReturnType returns a TypeFunc that always returns the given type.
+//
+// This is provided as a convenience for defining a function whose return
+// type does not depend on the argument types.
+func StaticReturnType(ty cty.Type) TypeFunc {
+        return func([]cty.Value) (cty.Type, error) {
+                return ty, nil
+        }
+}
+
+// ReturnType returns the return type of a function given a set of candidate
+// argument types, or returns an error if the given types are unacceptable.
+//
+// If the caller already knows values for at least some of the arguments
+// it can be better to call ReturnTypeForValues, since certain functions may
+// determine their return types from their values and return DynamicVal if
+// the values are unknown.
+func (f Function) ReturnType(argTypes []cty.Type) (cty.Type, error) {
+        vals := make([]cty.Value, len(argTypes))
+        for i, ty := range argTypes {
+                vals[i] = cty.UnknownVal(ty)
+        }
+        return f.ReturnTypeForValues(vals)
+}
+
+// ReturnTypeForValues is similar to ReturnType but can be used if the caller
+// already knows the values of some or all of the arguments, in which case
+// the function may be able to determine a more definite result if its
+// return type depends on the argument *values*.
+//
+// For any arguments whose values are not known, pass an Unknown value of
+// the appropriate type.
+func (f Function) ReturnTypeForValues(args []cty.Value) (ty cty.Type, err error) {
+        var posArgs []cty.Value
+        var varArgs []cty.Value
+
+        if f.spec.VarParam == nil {
+                if len(args) != len(f.spec.Params) {
+                        return cty.Type{}, fmt.Errorf(
+                                "wrong number of arguments (%d required; %d given)",
+                                len(f.spec.Params), len(args),
+                        )
+                }
+
+                posArgs = args
+                varArgs = nil
+        } else {
+                if len(args) < len(f.spec.Params) {
+                        return cty.Type{}, fmt.Errorf(
+                                "wrong number of arguments (at least %d required; %d given)",
+                                len(f.spec.Params), len(args),
+                        )
+                }
+
+                posArgs = args[0:len(f.spec.Params)]
+                varArgs = args[len(f.spec.Params):]
+        }
+
+        for i, spec := range f.spec.Params {
+                val := posArgs[i]
+
+                if val.IsNull() && !spec.AllowNull {
+                        return cty.Type{}, NewArgErrorf(i, "must not be null")
+                }
+
+                // AllowUnknown is ignored for type-checking, since we expect to be
+                // able to type check with unknown values. We *do* still need to deal
+                // with DynamicPseudoType here though, since the Type function might
+                // not be ready to deal with that.
+
+                if val.Type() == cty.DynamicPseudoType {
+                        if !spec.AllowDynamicType {
+                                return cty.DynamicPseudoType, nil
+                        }
+                } else if errs := val.Type().TestConformance(spec.Type); errs != nil {
+                        // For now we'll just return the first error in the set, since
+                        // we don't have a good way to return the whole list here.
+                        // Would be good to do something better at some point...
+                        return cty.Type{}, NewArgError(i, errs[0])
+                }
+        }
+
+        if varArgs != nil {
+                spec := f.spec.VarParam
+                for i, val := range varArgs {
+                        realI := i + len(posArgs)
+
+                        if val.IsNull() && !spec.AllowNull {
+                                return cty.Type{}, NewArgErrorf(realI, "must not be null")
+                        }
+
+                        if val.Type() == cty.DynamicPseudoType {
+                                if !spec.AllowDynamicType {
+                                        return cty.DynamicPseudoType, nil
+                                }
+                        } else if errs := val.Type().TestConformance(spec.Type); errs != nil {
+                                // For now we'll just return the first error in the set, since
+                                // we don't have a good way to return the whole list here.
+                                // Would be good to do something better at some point...
+                                return cty.Type{}, NewArgError(i, errs[0])
+                        }
+                }
+        }
+
+        // Intercept any panics from the function and return them as normal errors,
+        // so a calling language runtime doesn't need to deal with panics.
+        defer func() {
+                if r := recover(); r != nil {
+                        ty = cty.NilType
+                        err = errorForPanic(r)
+                }
+        }()
+
+        return f.spec.Type(args)
+}
+
+// Call actually calls the function with the given arguments, which must
+// conform to the function's parameter specification or an error will be
+// returned.
+func (f Function) Call(args []cty.Value) (val cty.Value, err error) {
+        expectedType, err := f.ReturnTypeForValues(args)
+        if err != nil {
+                return cty.NilVal, err
+        }
+
+        // Type checking already dealt with most situations relating to our
+        // parameter specification, but we still need to deal with unknown
+        // values.
+        posArgs := args[:len(f.spec.Params)]
+        varArgs := args[len(f.spec.Params):]
+
+        for i, spec := range f.spec.Params {
+                val := posArgs[i]
+
+                if !val.IsKnown() && !spec.AllowUnknown {
+                        return cty.UnknownVal(expectedType), nil
+                }
+        }
+
+        if f.spec.VarParam != nil {
+                spec := f.spec.VarParam
+                for _, val := range varArgs {
+                        if !val.IsKnown() && !spec.AllowUnknown {
+                                return cty.UnknownVal(expectedType), nil
+                        }
+                }
+        }
+
+        var retVal cty.Value
+        {
+                // Intercept any panics from the function and return them as normal errors,
+                // so a calling language runtime doesn't need to deal with panics.
+                defer func() {
+                        if r := recover(); r != nil {
+                                val = cty.NilVal
+                                err = errorForPanic(r)
+                        }
+                }()
+
+                retVal, err = f.spec.Impl(args, expectedType)
+                if err != nil {
+                        return cty.NilVal, err
+                }
+        }
+
+        // Returned value must conform to what the Type function expected, to
+        // protect callers from having to deal with inconsistencies.
+        if errs := retVal.Type().TestConformance(expectedType); errs != nil {
+                panic(fmt.Errorf(
+                        "returned value %#v does not conform to expected return type %#v: %s",
+                        retVal, expectedType, errs[0],
+                ))
+        }
+
+        return retVal, nil
+}
+
+// ProxyFunc the type returned by the method Function.Proxy.
+type ProxyFunc func(args ...cty.Value) (cty.Value, error)
+
+// Proxy returns a function that can be called with cty.Value arguments
+// to run the function. This is provided as a convenience for when using
+// a function directly within Go code.
+func (f Function) Proxy() ProxyFunc {
+        return func(args ...cty.Value) (cty.Value, error) {
+                return f.Call(args)
+        }
+}
+
+// Params returns information about the function's fixed positional parameters.
+// This does not include information about any variadic arguments accepted;
+// for that, call VarParam.
+func (f Function) Params() []Parameter {
+        new := make([]Parameter, len(f.spec.Params))
+        copy(new, f.spec.Params)
+        return new
+}
+
+// VarParam returns information about the variadic arguments the function
+// expects, or nil if the function is not variadic.
+func (f Function) VarParam() *Parameter {
+        if f.spec.VarParam == nil {
+                return nil
+        }
+
+        ret := *f.spec.VarParam
+        return &ret
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bool.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bool.go
new file mode 100644
index 0000000..a473d0e
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bool.go
@@ -0,0 +1,73 @@
+package stdlib
+
+import (
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+)
+
+var NotFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "val",
+                        Type:             cty.Bool,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Bool),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                return args[0].Not(), nil
+        },
+})
+
+var AndFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Bool,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Bool,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Bool),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                return args[0].And(args[1]), nil
+        },
+})
+
+var OrFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Bool,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Bool,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Bool),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                return args[0].Or(args[1]), nil
+        },
+})
+
+// Not returns the logical complement of the given boolean value.
+func Not(num cty.Value) (cty.Value, error) {
+        return NotFunc.Call([]cty.Value{num})
+}
+
+// And returns true if and only if both of the given boolean values are true.
+func And(a, b cty.Value) (cty.Value, error) {
+        return AndFunc.Call([]cty.Value{a, b})
+}
+
+// Or returns true if either of the given boolean values are true.
+func Or(a, b cty.Value) (cty.Value, error) {
+        return OrFunc.Call([]cty.Value{a, b})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bytes.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bytes.go
new file mode 100644
index 0000000..a132e0c
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bytes.go
@@ -0,0 +1,112 @@
+package stdlib
+
+import (
+        "fmt"
+        "reflect"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+        "github.com/zclconf/go-cty/cty/gocty"
+)
+
+// Bytes is a capsule type that can be used with the binary functions to
+// support applications that need to support raw buffers in addition to
+// UTF-8 strings.
+var Bytes = cty.Capsule("bytes", reflect.TypeOf([]byte(nil)))
+
+// BytesVal creates a new Bytes value from the given buffer, which must be
+// non-nil or this function will panic.
+//
+// Once a byte slice has been wrapped in a Bytes capsule, its underlying array
+// must be considered immutable.
+func BytesVal(buf []byte) cty.Value {
+        if buf == nil {
+                panic("can't make Bytes value from nil slice")
+        }
+
+        return cty.CapsuleVal(Bytes, &buf)
+}
+
+// BytesLen is a Function that returns the length of the buffer encapsulated
+// in a Bytes value.
+var BytesLenFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "buf",
+                        Type:             Bytes,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                bufPtr := args[0].EncapsulatedValue().(*[]byte)
+                return cty.NumberIntVal(int64(len(*bufPtr))), nil
+        },
+})
+
+// BytesSlice is a Function that returns a slice of the given Bytes value.
+var BytesSliceFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "buf",
+                        Type:             Bytes,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "offset",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "length",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(Bytes),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                bufPtr := args[0].EncapsulatedValue().(*[]byte)
+
+                var offset, length int
+
+                var err error
+                err = gocty.FromCtyValue(args[1], &offset)
+                if err != nil {
+                        return cty.NilVal, err
+                }
+                err = gocty.FromCtyValue(args[2], &length)
+                if err != nil {
+                        return cty.NilVal, err
+                }
+
+                if offset < 0 || length < 0 {
+                        return cty.NilVal, fmt.Errorf("offset and length must be non-negative")
+                }
+
+                if offset > len(*bufPtr) {
+                        return cty.NilVal, fmt.Errorf(
+                                "offset %d is greater than total buffer length %d",
+                                offset, len(*bufPtr),
+                        )
+                }
+
+                end := offset + length
+
+                if end > len(*bufPtr) {
+                        return cty.NilVal, fmt.Errorf(
+                                "offset %d + length %d is greater than total buffer length %d",
+                                offset, length, len(*bufPtr),
+                        )
+                }
+
+                return BytesVal((*bufPtr)[offset:end]), nil
+        },
+})
+
+func BytesLen(buf cty.Value) (cty.Value, error) {
+        return BytesLenFunc.Call([]cty.Value{buf})
+}
+
+func BytesSlice(buf cty.Value, offset cty.Value, length cty.Value) (cty.Value, error) {
+        return BytesSliceFunc.Call([]cty.Value{buf, offset, length})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/collection.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/collection.go
new file mode 100644
index 0000000..967ba03
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/collection.go
@@ -0,0 +1,140 @@
+package stdlib
+
+import (
+        "fmt"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+        "github.com/zclconf/go-cty/cty/gocty"
+)
+
+var HasIndexFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "collection",
+                        Type:             cty.DynamicPseudoType,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "key",
+                        Type:             cty.DynamicPseudoType,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: func(args []cty.Value) (ret cty.Type, err error) {
+                collTy := args[0].Type()
+                if !(collTy.IsTupleType() || collTy.IsListType() || collTy.IsMapType() || collTy == cty.DynamicPseudoType) {
+                        return cty.NilType, fmt.Errorf("collection must be a list, a map or a tuple")
+                }
+                return cty.Bool, nil
+        },
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                return args[0].HasIndex(args[1]), nil
+        },
+})
+
+var IndexFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name: "collection",
+                        Type: cty.DynamicPseudoType,
+                },
+                {
+                        Name:             "key",
+                        Type:             cty.DynamicPseudoType,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: func(args []cty.Value) (ret cty.Type, err error) {
+                collTy := args[0].Type()
+                key := args[1]
+                keyTy := key.Type()
+                switch {
+                case collTy.IsTupleType():
+                        if keyTy != cty.Number && keyTy != cty.DynamicPseudoType {
+                                return cty.NilType, fmt.Errorf("key for tuple must be number")
+                        }
+                        if !key.IsKnown() {
+                                return cty.DynamicPseudoType, nil
+                        }
+                        var idx int
+                        err := gocty.FromCtyValue(key, &idx)
+                        if err != nil {
+                                return cty.NilType, fmt.Errorf("invalid key for tuple: %s", err)
+                        }
+
+                        etys := collTy.TupleElementTypes()
+
+                        if idx >= len(etys) || idx < 0 {
+                                return cty.NilType, fmt.Errorf("key must be between 0 and %d inclusive", len(etys))
+                        }
+
+                        return etys[idx], nil
+
+                case collTy.IsListType():
+                        if keyTy != cty.Number && keyTy != cty.DynamicPseudoType {
+                                return cty.NilType, fmt.Errorf("key for list must be number")
+                        }
+
+                        return collTy.ElementType(), nil
+
+                case collTy.IsMapType():
+                        if keyTy != cty.String && keyTy != cty.DynamicPseudoType {
+                                return cty.NilType, fmt.Errorf("key for map must be string")
+                        }
+
+                        return collTy.ElementType(), nil
+
+                default:
+                        return cty.NilType, fmt.Errorf("collection must be a list, a map or a tuple")
+                }
+        },
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                has, err := HasIndex(args[0], args[1])
+                if err != nil {
+                        return cty.NilVal, err
+                }
+                if has.False() { // safe because collection and key are guaranteed known here
+                        return cty.NilVal, fmt.Errorf("invalid index")
+                }
+
+                return args[0].Index(args[1]), nil
+        },
+})
+
+var LengthFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "collection",
+                        Type:             cty.DynamicPseudoType,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: func(args []cty.Value) (ret cty.Type, err error) {
+                collTy := args[0].Type()
+                if !(collTy.IsTupleType() || collTy.IsListType() || collTy.IsMapType() || collTy.IsSetType() || collTy == cty.DynamicPseudoType) {
+                        return cty.NilType, fmt.Errorf("collection must be a list, a map or a tuple")
+                }
+                return cty.Number, nil
+        },
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                return args[0].Length(), nil
+        },
+})
+
+// HasIndex determines whether the given collection can be indexed with the
+// given key.
+func HasIndex(collection cty.Value, key cty.Value) (cty.Value, error) {
+        return HasIndexFunc.Call([]cty.Value{collection, key})
+}
+
+// Index returns an element from the given collection using the given key,
+// or returns an error if there is no element for the given key.
+func Index(collection cty.Value, key cty.Value) (cty.Value, error) {
+        return IndexFunc.Call([]cty.Value{collection, key})
+}
+
+// Length returns the number of elements in the given collection.
+func Length(collection cty.Value) (cty.Value, error) {
+        return LengthFunc.Call([]cty.Value{collection})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/csv.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/csv.go
new file mode 100644
index 0000000..5070a5a
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/csv.go
@@ -0,0 +1,93 @@
+package stdlib
+
+import (
+        "encoding/csv"
+        "fmt"
+        "io"
+        "strings"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+)
+
+var CSVDecodeFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name: "str",
+                        Type: cty.String,
+                },
+        },
+        Type: func(args []cty.Value) (cty.Type, error) {
+                str := args[0]
+                if !str.IsKnown() {
+                        return cty.DynamicPseudoType, nil
+                }
+
+                r := strings.NewReader(str.AsString())
+                cr := csv.NewReader(r)
+                headers, err := cr.Read()
+                if err == io.EOF {
+                        return cty.DynamicPseudoType, fmt.Errorf("missing header line")
+                }
+                if err != nil {
+                        return cty.DynamicPseudoType, err
+                }
+
+                atys := make(map[string]cty.Type, len(headers))
+                for _, name := range headers {
+                        if _, exists := atys[name]; exists {
+                                return cty.DynamicPseudoType, fmt.Errorf("duplicate column name %q", name)
+                        }
+                        atys[name] = cty.String
+                }
+                return cty.List(cty.Object(atys)), nil
+        },
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                ety := retType.ElementType()
+                atys := ety.AttributeTypes()
+                str := args[0]
+                r := strings.NewReader(str.AsString())
+                cr := csv.NewReader(r)
+                cr.FieldsPerRecord = len(atys)
+
+                // Read the header row first, since that'll tell us which indices
+                // map to which attribute names.
+                headers, err := cr.Read()
+                if err != nil {
+                        return cty.DynamicVal, err
+                }
+
+                var rows []cty.Value
+                for {
+                        cols, err := cr.Read()
+                        if err == io.EOF {
+                                break
+                        }
+                        if err != nil {
+                                return cty.DynamicVal, err
+                        }
+
+                        vals := make(map[string]cty.Value, len(cols))
+                        for i, str := range cols {
+                                name := headers[i]
+                                vals[name] = cty.StringVal(str)
+                        }
+                        rows = append(rows, cty.ObjectVal(vals))
+                }
+
+                if len(rows) == 0 {
+                        return cty.ListValEmpty(ety), nil
+                }
+                return cty.ListVal(rows), nil
+        },
+})
+
+// CSVDecode parses the given CSV (RFC 4180) string and, if it is valid,
+// returns a list of objects representing the rows.
+//
+// The result is always a list of some object type. The first row of the
+// input is used to determine the object attributes, and subsequent rows
+// determine the values of those attributes.
+func CSVDecode(str cty.Value) (cty.Value, error) {
+        return CSVDecodeFunc.Call([]cty.Value{str})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/doc.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/doc.go
new file mode 100644
index 0000000..cfb613e
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/doc.go
@@ -0,0 +1,13 @@
+// Package stdlib is a collection of cty functions that are expected to be
+// generally useful, and are thus factored out into this shared library in
+// the hope that cty-using applications will have consistent behavior when
+// using these functions.
+//
+// See the parent package "function" for more information on the purpose
+// and usage of cty functions.
+//
+// This package contains both Go functions, which provide convenient access
+// to call the functions from Go code, and the Function objects themselves.
+// The latter follow the naming scheme of appending "Func" to the end of
+// the function name.
+package stdlib
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go
new file mode 100644
index 0000000..fb24f20
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go
@@ -0,0 +1,496 @@
+package stdlib
+
+import (
+        "bytes"
+        "fmt"
+        "math/big"
+        "strings"
+
+        "github.com/apparentlymart/go-textseg/textseg"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/convert"
+        "github.com/zclconf/go-cty/cty/function"
+        "github.com/zclconf/go-cty/cty/json"
+)
+
+//go:generate ragel -Z format_fsm.rl
+//go:generate gofmt -w format_fsm.go
+
+var FormatFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name: "format",
+                        Type: cty.String,
+                },
+        },
+        VarParam: &function.Parameter{
+                Name:      "args",
+                Type:      cty.DynamicPseudoType,
+                AllowNull: true,
+        },
+        Type: function.StaticReturnType(cty.String),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                for _, arg := range args[1:] {
+                        if !arg.IsWhollyKnown() {
+                                // We require all nested values to be known because the only
+                                // thing we can do for a collection/structural type is print
+                                // it as JSON and that requires it to be wholly known.
+                                return cty.UnknownVal(cty.String), nil
+                        }
+                }
+                str, err := formatFSM(args[0].AsString(), args[1:])
+                return cty.StringVal(str), err
+        },
+})
+
+var FormatListFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name: "format",
+                        Type: cty.String,
+                },
+        },
+        VarParam: &function.Parameter{
+                Name:         "args",
+                Type:         cty.DynamicPseudoType,
+                AllowNull:    true,
+                AllowUnknown: true,
+        },
+        Type: function.StaticReturnType(cty.List(cty.String)),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                fmtVal := args[0]
+                args = args[1:]
+
+                if len(args) == 0 {
+                        // With no arguments, this function is equivalent to Format, but
+                        // returning a single-element list result.
+                        result, err := Format(fmtVal, args...)
+                        return cty.ListVal([]cty.Value{result}), err
+                }
+
+                fmtStr := fmtVal.AsString()
+
+                // Each of our arguments will be dealt with either as an iterator
+                // or as a single value. Iterators are used for sequence-type values
+                // (lists, sets, tuples) while everything else is treated as a
+                // single value. The sequences we iterate over are required to be
+                // all the same length.
+                iterLen := -1
+                lenChooser := -1
+                iterators := make([]cty.ElementIterator, len(args))
+                singleVals := make([]cty.Value, len(args))
+                for i, arg := range args {
+                        argTy := arg.Type()
+                        switch {
+                        case (argTy.IsListType() || argTy.IsSetType() || argTy.IsTupleType()) && !arg.IsNull():
+                                thisLen := arg.LengthInt()
+                                if iterLen == -1 {
+                                        iterLen = thisLen
+                                        lenChooser = i
+                                } else {
+                                        if thisLen != iterLen {
+                                                return cty.NullVal(cty.List(cty.String)), function.NewArgErrorf(
+                                                        i+1,
+                                                        "argument %d has length %d, which is inconsistent with argument %d of length %d",
+                                                        i+1, thisLen,
+                                                        lenChooser+1, iterLen,
+                                                )
+                                        }
+                                }
+                                iterators[i] = arg.ElementIterator()
+                        default:
+                                singleVals[i] = arg
+                        }
+                }
+
+                if iterLen == 0 {
+                        // If our sequences are all empty then our result must be empty.
+                        return cty.ListValEmpty(cty.String), nil
+                }
+
+                if iterLen == -1 {
+                        // If we didn't encounter any iterables at all then we're going
+                        // to just do one iteration with items from singleVals.
+                        iterLen = 1
+                }
+
+                ret := make([]cty.Value, 0, iterLen)
+                fmtArgs := make([]cty.Value, len(iterators))
+        Results:
+                for iterIdx := 0; iterIdx < iterLen; iterIdx++ {
+
+                        // Construct our arguments for a single format call
+                        for i := range fmtArgs {
+                                switch {
+                                case iterators[i] != nil:
+                                        iterator := iterators[i]
+                                        iterator.Next()
+                                        _, val := iterator.Element()
+                                        fmtArgs[i] = val
+                                default:
+                                        fmtArgs[i] = singleVals[i]
+                                }
+
+                                // If any of the arguments to this call would be unknown then
+                                // this particular result is unknown, but we'll keep going
+                                // to see if any other iterations can produce known values.
+                                if !fmtArgs[i].IsWhollyKnown() {
+                                        // We require all nested values to be known because the only
+                                        // thing we can do for a collection/structural type is print
+                                        // it as JSON and that requires it to be wholly known.
+                                        ret = append(ret, cty.UnknownVal(cty.String))
+                                        continue Results
+                                }
+                        }
+
+                        str, err := formatFSM(fmtStr, fmtArgs)
+                        if err != nil {
+                                return cty.NullVal(cty.List(cty.String)), fmt.Errorf(
+                                        "error on format iteration %d: %s", iterIdx, err,
+                                )
+                        }
+
+                        ret = append(ret, cty.StringVal(str))
+                }
+
+                return cty.ListVal(ret), nil
+        },
+})
+
+// Format produces a string representation of zero or more values using a
+// format string similar to the "printf" function in C.
+//
+// It supports the following "verbs":
+//
+//     %%      Literal percent sign, consuming no value
+//     %v      A default formatting of the value based on type, as described below.
+//     %#v     JSON serialization of the value
+//     %t      Converts to boolean and then produces "true" or "false"
+//     %b      Converts to number, requires integer, produces binary representation
+//     %d      Converts to number, requires integer, produces decimal representation
+//     %o      Converts to number, requires integer, produces octal representation
+//     %x      Converts to number, requires integer, produces hexadecimal representation
+//             with lowercase letters
+//     %X      Like %x but with uppercase letters
+//     %e      Converts to number, produces scientific notation like -1.234456e+78
+//     %E      Like %e but with an uppercase "E" representing the exponent
+//     %f      Converts to number, produces decimal representation with fractional
+//             part but no exponent, like 123.456
+//     %g      %e for large exponents or %f otherwise
+//     %G      %E for large exponents or %f otherwise
+//     %s      Converts to string and produces the string's characters
+//     %q      Converts to string and produces JSON-quoted string representation,
+//             like %v.
+//
+// The default format selections made by %v are:
+//
+//     string  %s
+//     number  %g
+//     bool    %t
+//     other   %#v
+//
+// Null values produce the literal keyword "null" for %v and %#v, and produce
+// an error otherwise.
+//
+// Width is specified by an optional decimal number immediately preceding the
+// verb letter. If absent, the width is whatever is necessary to represent the
+// value. Precision is specified after the (optional) width by a period
+// followed by a decimal number. If no period is present, a default precision
+// is used. A period with no following number is invalid.
+// For examples:
+//
+//     %f     default width, default precision
+//     %9f    width 9, default precision
+//     %.2f   default width, precision 2
+//     %9.2f  width 9, precision 2
+//
+// Width and precision are measured in unicode characters (grapheme clusters).
+//
+// For most values, width is the minimum number of characters to output,
+// padding the formatted form with spaces if necessary.
+//
+// For strings, precision limits the length of the input to be formatted (not
+// the size of the output), truncating if necessary.
+//
+// For numbers, width sets the minimum width of the field and precision sets
+// the number of places after the decimal, if appropriate, except that for
+// %g/%G precision sets the total number of significant digits.
+//
+// The following additional symbols can be used immediately after the percent
+// introducer as flags:
+//
+//           (a space) leave a space where the sign would be if number is positive
+//     +     Include a sign for a number even if it is positive (numeric only)
+//     -     Pad with spaces on the left rather than the right
+//     0     Pad with zeros rather than spaces.
+//
+// Flag characters are ignored for verbs that do not support them.
+//
+// By default, % sequences consume successive arguments starting with the first.
+// Introducing a [n] sequence immediately before the verb letter, where n is a
+// decimal integer, explicitly chooses a particular value argument by its
+// one-based index. Subsequent calls without an explicit index will then
+// proceed with n+1, n+2, etc.
+//
+// An error is produced if the format string calls for an impossible conversion
+// or accesses more values than are given. An error is produced also for
+// an unsupported format verb.
+func Format(format cty.Value, vals ...cty.Value) (cty.Value, error) {
+        args := make([]cty.Value, 0, len(vals)+1)
+        args = append(args, format)
+        args = append(args, vals...)
+        return FormatFunc.Call(args)
+}
+
+// FormatList applies the same formatting behavior as Format, but accepts
+// a mixture of list and non-list values as arguments. Any list arguments
+// passed must have the same length, which dictates the length of the
+// resulting list.
+//
+// Any non-list arguments are used repeatedly for each iteration over the
+// list arguments. The list arguments are iterated in order by key, so
+// corresponding items are formatted together.
+func FormatList(format cty.Value, vals ...cty.Value) (cty.Value, error) {
+        args := make([]cty.Value, 0, len(vals)+1)
+        args = append(args, format)
+        args = append(args, vals...)
+        return FormatListFunc.Call(args)
+}
+
+type formatVerb struct {
+        Raw    string
+        Offset int
+
+        ArgNum int
+        Mode   rune
+
+        Zero  bool
+        Sharp bool
+        Plus  bool
+        Minus bool
+        Space bool
+
+        HasPrec bool
+        Prec    int
+
+        HasWidth bool
+        Width    int
+}
+
+// formatAppend is called by formatFSM (generated by format_fsm.rl) for each
+// formatting sequence that is encountered.
+func formatAppend(verb *formatVerb, buf *bytes.Buffer, args []cty.Value) error {
+        argIdx := verb.ArgNum - 1
+        if argIdx >= len(args) {
+                return fmt.Errorf(
+                        "not enough arguments for %q at %d: need index %d but have %d total",
+                        verb.Raw, verb.Offset,
+                        verb.ArgNum, len(args),
+                )
+        }
+        arg := args[argIdx]
+
+        if verb.Mode != 'v' && arg.IsNull() {
+                return fmt.Errorf("unsupported value for %q at %d: null value cannot be formatted", verb.Raw, verb.Offset)
+        }
+
+        // Normalize to make some things easier for downstream formatters
+        if !verb.HasWidth {
+                verb.Width = -1
+        }
+        if !verb.HasPrec {
+                verb.Prec = -1
+        }
+
+        // For our first pass we'll ensure the verb is supported and then fan
+        // out to other functions based on what conversion is needed.
+        switch verb.Mode {
+
+        case 'v':
+                return formatAppendAsIs(verb, buf, arg)
+
+        case 't':
+                return formatAppendBool(verb, buf, arg)
+
+        case 'b', 'd', 'o', 'x', 'X', 'e', 'E', 'f', 'g', 'G':
+                return formatAppendNumber(verb, buf, arg)
+
+        case 's', 'q':
+                return formatAppendString(verb, buf, arg)
+
+        default:
+                return fmt.Errorf("unsupported format verb %q in %q at offset %d", verb.Mode, verb.Raw, verb.Offset)
+        }
+}
+
+func formatAppendAsIs(verb *formatVerb, buf *bytes.Buffer, arg cty.Value) error {
+
+        if !verb.Sharp && !arg.IsNull() {
+                // Unless the caller overrode it with the sharp flag, we'll try some
+                // specialized formats before we fall back on JSON.
+                switch arg.Type() {
+                case cty.String:
+                        fmted := arg.AsString()
+                        fmted = formatPadWidth(verb, fmted)
+                        buf.WriteString(fmted)
+                        return nil
+                case cty.Number:
+                        bf := arg.AsBigFloat()
+                        fmted := bf.Text('g', -1)
+                        fmted = formatPadWidth(verb, fmted)
+                        buf.WriteString(fmted)
+                        return nil
+                }
+        }
+
+        jb, err := json.Marshal(arg, arg.Type())
+        if err != nil {
+                return fmt.Errorf("unsupported value for %q at %d: %s", verb.Raw, verb.Offset, err)
+        }
+        fmted := formatPadWidth(verb, string(jb))
+        buf.WriteString(fmted)
+
+        return nil
+}
+
+func formatAppendBool(verb *formatVerb, buf *bytes.Buffer, arg cty.Value) error {
+        var err error
+        arg, err = convert.Convert(arg, cty.Bool)
+        if err != nil {
+                return fmt.Errorf("unsupported value for %q at %d: %s", verb.Raw, verb.Offset, err)
+        }
+
+        if arg.True() {
+                buf.WriteString("true")
+        } else {
+                buf.WriteString("false")
+        }
+        return nil
+}
+
+func formatAppendNumber(verb *formatVerb, buf *bytes.Buffer, arg cty.Value) error {
+        var err error
+        arg, err = convert.Convert(arg, cty.Number)
+        if err != nil {
+                return fmt.Errorf("unsupported value for %q at %d: %s", verb.Raw, verb.Offset, err)
+        }
+
+        switch verb.Mode {
+        case 'b', 'd', 'o', 'x', 'X':
+                return formatAppendInteger(verb, buf, arg)
+        default:
+                bf := arg.AsBigFloat()
+
+                // For floats our format syntax is a subset of Go's, so it's
+                // safe for us to just lean on the existing Go implementation.
+                fmtstr := formatStripIndexSegment(verb.Raw)
+                fmted := fmt.Sprintf(fmtstr, bf)
+                buf.WriteString(fmted)
+                return nil
+        }
+}
+
+func formatAppendInteger(verb *formatVerb, buf *bytes.Buffer, arg cty.Value) error {
+        bf := arg.AsBigFloat()
+        bi, acc := bf.Int(nil)
+        if acc != big.Exact {
+                return fmt.Errorf("unsupported value for %q at %d: an integer is required", verb.Raw, verb.Offset)
+        }
+
+        // For integers our format syntax is a subset of Go's, so it's
+        // safe for us to just lean on the existing Go implementation.
+        fmtstr := formatStripIndexSegment(verb.Raw)
+        fmted := fmt.Sprintf(fmtstr, bi)
+        buf.WriteString(fmted)
+        return nil
+}
+
+func formatAppendString(verb *formatVerb, buf *bytes.Buffer, arg cty.Value) error {
+        var err error
+        arg, err = convert.Convert(arg, cty.String)
+        if err != nil {
+                return fmt.Errorf("unsupported value for %q at %d: %s", verb.Raw, verb.Offset, err)
+        }
+
+        // We _cannot_ directly use the Go fmt.Sprintf implementation for strings
+        // because it measures widths and precisions in runes rather than grapheme
+        // clusters.
+
+        str := arg.AsString()
+        if verb.Prec > 0 {
+                strB := []byte(str)
+                pos := 0
+                wanted := verb.Prec
+                for i := 0; i < wanted; i++ {
+                        next := strB[pos:]
+                        if len(next) == 0 {
+                                // ran out of characters before we hit our max width
+                                break
+                        }
+                        d, _, _ := textseg.ScanGraphemeClusters(strB[pos:], true)
+                        pos += d
+                }
+                str = str[:pos]
+        }
+
+        switch verb.Mode {
+        case 's':
+                fmted := formatPadWidth(verb, str)
+                buf.WriteString(fmted)
+        case 'q':
+                jb, err := json.Marshal(cty.StringVal(str), cty.String)
+                if err != nil {
+                        // Should never happen, since we know this is a known, non-null string
+                        panic(fmt.Errorf("failed to marshal %#v as JSON: %s", arg, err))
+                }
+                fmted := formatPadWidth(verb, string(jb))
+                buf.WriteString(fmted)
+        default:
+                // Should never happen because formatAppend should've already validated
+                panic(fmt.Errorf("invalid string formatting mode %q", verb.Mode))
+        }
+        return nil
+}
+
+func formatPadWidth(verb *formatVerb, fmted string) string {
+        if verb.Width < 0 {
+                return fmted
+        }
+
+        // Safe to ignore errors because ScanGraphemeClusters cannot produce errors
+        givenLen, _ := textseg.TokenCount([]byte(fmted), textseg.ScanGraphemeClusters)
+        wantLen := verb.Width
+        if givenLen >= wantLen {
+                return fmted
+        }
+
+        padLen := wantLen - givenLen
+        padChar := " "
+        if verb.Zero {
+                padChar = "0"
+        }
+        pads := strings.Repeat(padChar, padLen)
+
+        if verb.Minus {
+                return fmted + pads
+        }
+        return pads + fmted
+}
+
+// formatStripIndexSegment strips out any [nnn] segment present in a verb
+// string so that we can pass it through to Go's fmt.Sprintf with a single
+// argument. This is used in cases where we're just leaning on Go's formatter
+// because it's a superset of ours.
+func formatStripIndexSegment(rawVerb string) string {
+        // We assume the string has already been validated here, since we should
+        // only be using this function with strings that were accepted by our
+        // scanner in formatFSM.
+        start := strings.Index(rawVerb, "[")
+        end := strings.Index(rawVerb, "]")
+        if start == -1 || end == -1 {
+                return rawVerb
+        }
+
+        return rawVerb[:start] + rawVerb[end+1:]
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go
new file mode 100644
index 0000000..86876ba
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go
@@ -0,0 +1,358 @@
+// line 1 "format_fsm.rl"
+// This file is generated from format_fsm.rl. DO NOT EDIT.
+
+// line 5 "format_fsm.rl"
+
+package stdlib
+
+import (
+        "bytes"
+        "fmt"
+        "unicode/utf8"
+
+        "github.com/zclconf/go-cty/cty"
+)
+
+// line 20 "format_fsm.go"
+var _formatfsm_actions []byte = []byte{
+        0, 1, 0, 1, 1, 1, 2, 1, 4,
+        1, 5, 1, 6, 1, 7, 1, 8,
+        1, 9, 1, 10, 1, 11, 1, 14,
+        1, 16, 1, 17, 1, 18, 2, 3,
+        4, 2, 12, 10, 2, 12, 16, 2,
+        12, 18, 2, 13, 14, 2, 15, 10,
+        2, 15, 18,
+}
+
+var _formatfsm_key_offsets []byte = []byte{
+        0, 0, 14, 27, 34, 36, 39, 43,
+        51,
+}
+
+var _formatfsm_trans_keys []byte = []byte{
+        32, 35, 37, 43, 45, 46, 48, 91,
+        49, 57, 65, 90, 97, 122, 32, 35,
+        43, 45, 46, 48, 91, 49, 57, 65,
+        90, 97, 122, 91, 48, 57, 65, 90,
+        97, 122, 49, 57, 93, 48, 57, 65,
+        90, 97, 122, 46, 91, 48, 57, 65,
+        90, 97, 122, 37,
+}
+
+var _formatfsm_single_lengths []byte = []byte{
+        0, 8, 7, 1, 0, 1, 0, 2,
+        1,
+}
+
+var _formatfsm_range_lengths []byte = []byte{
+        0, 3, 3, 3, 1, 1, 2, 3,
+        0,
+}
+
+var _formatfsm_index_offsets []byte = []byte{
+        0, 0, 12, 23, 28, 30, 33, 36,
+        42,
+}
+
+var _formatfsm_indicies []byte = []byte{
+        1, 2, 3, 4, 5, 6, 7, 10,
+        8, 9, 9, 0, 1, 2, 4, 5,
+        6, 7, 10, 8, 9, 9, 0, 13,
+        11, 12, 12, 0, 14, 0, 15, 14,
+        0, 9, 9, 0, 16, 19, 17, 18,
+        18, 0, 20, 3,
+}
+
+var _formatfsm_trans_targs []byte = []byte{
+        0, 2, 2, 8, 2, 2, 3, 2,
+        7, 8, 4, 3, 8, 4, 5, 6,
+        3, 7, 8, 4, 1,
+}
+
+var _formatfsm_trans_actions []byte = []byte{
+        7, 17, 9, 3, 15, 13, 25, 11,
+        43, 29, 19, 27, 49, 46, 21, 0,
+        37, 23, 40, 34, 1,
+}
+
+var _formatfsm_eof_actions []byte = []byte{
+        0, 31, 31, 31, 31, 31, 31, 31,
+        5,
+}
+
+const formatfsm_start int = 8
+const formatfsm_first_final int = 8
+const formatfsm_error int = 0
+
+const formatfsm_en_main int = 8
+
+// line 19 "format_fsm.rl"
+
+func formatFSM(format string, a []cty.Value) (string, error) {
+        var buf bytes.Buffer
+        data := format
+        nextArg := 1 // arg numbers are 1-based
+        var verb formatVerb
+
+        // line 153 "format_fsm.rl"
+
+        // Ragel state
+        p := 0          // "Pointer" into data
+        pe := len(data) // End-of-data "pointer"
+        cs := 0         // current state (will be initialized by ragel-generated code)
+        ts := 0
+        te := 0
+        eof := pe
+
+        // Keep Go compiler happy even if generated code doesn't use these
+        _ = ts
+        _ = te
+        _ = eof
+
+        // line 121 "format_fsm.go"
+        {
+                cs = formatfsm_start
+        }
+
+        // line 126 "format_fsm.go"
+        {
+                var _klen int
+                var _trans int
+                var _acts int
+                var _nacts uint
+                var _keys int
+                if p == pe {
+                        goto _test_eof
+                }
+                if cs == 0 {
+                        goto _out
+                }
+        _resume:
+                _keys = int(_formatfsm_key_offsets[cs])
+                _trans = int(_formatfsm_index_offsets[cs])
+
+                _klen = int(_formatfsm_single_lengths[cs])
+                if _klen > 0 {
+                        _lower := int(_keys)
+                        var _mid int
+                        _upper := int(_keys + _klen - 1)
+                        for {
+                                if _upper < _lower {
+                                        break
+                                }
+
+                                _mid = _lower + ((_upper - _lower) >> 1)
+                                switch {
+                                case data[p] < _formatfsm_trans_keys[_mid]:
+                                        _upper = _mid - 1
+                                case data[p] > _formatfsm_trans_keys[_mid]:
+                                        _lower = _mid + 1
+                                default:
+                                        _trans += int(_mid - int(_keys))
+                                        goto _match
+                                }
+                        }
+                        _keys += _klen
+                        _trans += _klen
+                }
+
+                _klen = int(_formatfsm_range_lengths[cs])
+                if _klen > 0 {
+                        _lower := int(_keys)
+                        var _mid int
+                        _upper := int(_keys + (_klen << 1) - 2)
+                        for {
+                                if _upper < _lower {
+                                        break
+                                }
+
+                                _mid = _lower + (((_upper - _lower) >> 1) & ^1)
+                                switch {
+                                case data[p] < _formatfsm_trans_keys[_mid]:
+                                        _upper = _mid - 2
+                                case data[p] > _formatfsm_trans_keys[_mid+1]:
+                                        _lower = _mid + 2
+                                default:
+                                        _trans += int((_mid - int(_keys)) >> 1)
+                                        goto _match
+                                }
+                        }
+                        _trans += _klen
+                }
+
+        _match:
+                _trans = int(_formatfsm_indicies[_trans])
+                cs = int(_formatfsm_trans_targs[_trans])
+
+                if _formatfsm_trans_actions[_trans] == 0 {
+                        goto _again
+                }
+
+                _acts = int(_formatfsm_trans_actions[_trans])
+                _nacts = uint(_formatfsm_actions[_acts])
+                _acts++
+                for ; _nacts > 0; _nacts-- {
+                        _acts++
+                        switch _formatfsm_actions[_acts-1] {
+                        case 0:
+                                // line 29 "format_fsm.rl"
+
+                                verb = formatVerb{
+                                        ArgNum: nextArg,
+                                        Prec:   -1,
+                                        Width:  -1,
+                                }
+                                ts = p
+
+                        case 1:
+                                // line 38 "format_fsm.rl"
+
+                                buf.WriteByte(data[p])
+
+                        case 4:
+                                // line 49 "format_fsm.rl"
+
+                                // We'll try to slurp a whole UTF-8 sequence here, to give the user
+                                // better feedback.
+                                r, _ := utf8.DecodeRuneInString(data[p:])
+                                return buf.String(), fmt.Errorf("unrecognized format character %q at offset %d", r, p)
+
+                        case 5:
+                                // line 56 "format_fsm.rl"
+
+                                verb.Sharp = true
+
+                        case 6:
+                                // line 59 "format_fsm.rl"
+
+                                verb.Zero = true
+
+                        case 7:
+                                // line 62 "format_fsm.rl"
+
+                                verb.Minus = true
+
+                        case 8:
+                                // line 65 "format_fsm.rl"
+
+                                verb.Plus = true
+
+                        case 9:
+                                // line 68 "format_fsm.rl"
+
+                                verb.Space = true
+
+                        case 10:
+                                // line 72 "format_fsm.rl"
+
+                                verb.ArgNum = 0
+
+                        case 11:
+                                // line 75 "format_fsm.rl"
+
+                                verb.ArgNum = (10 * verb.ArgNum) + (int(data[p]) - '0')
+
+                        case 12:
+                                // line 79 "format_fsm.rl"
+
+                                verb.HasWidth = true
+
+                        case 13:
+                                // line 82 "format_fsm.rl"
+
+                                verb.Width = 0
+
+                        case 14:
+                                // line 85 "format_fsm.rl"
+
+                                verb.Width = (10 * verb.Width) + (int(data[p]) - '0')
+
+                        case 15:
+                                // line 89 "format_fsm.rl"
+
+                                verb.HasPrec = true
+
+                        case 16:
+                                // line 92 "format_fsm.rl"
+
+                                verb.Prec = 0
+
+                        case 17:
+                                // line 95 "format_fsm.rl"
+
+                                verb.Prec = (10 * verb.Prec) + (int(data[p]) - '0')
+
+                        case 18:
+                                // line 99 "format_fsm.rl"
+
+                                verb.Mode = rune(data[p])
+                                te = p + 1
+                                verb.Raw = data[ts:te]
+                                verb.Offset = ts
+
+                                err := formatAppend(&verb, &buf, a)
+                                if err != nil {
+                                        return buf.String(), err
+                                }
+                                nextArg = verb.ArgNum + 1
+
+                                // line 324 "format_fsm.go"
+                        }
+                }
+
+        _again:
+                if cs == 0 {
+                        goto _out
+                }
+                p++
+                if p != pe {
+                        goto _resume
+                }
+        _test_eof:
+                {
+                }
+                if p == eof {
+                        __acts := _formatfsm_eof_actions[cs]
+                        __nacts := uint(_formatfsm_actions[__acts])
+                        __acts++
+                        for ; __nacts > 0; __nacts-- {
+                                __acts++
+                                switch _formatfsm_actions[__acts-1] {
+                                case 2:
+                                        // line 42 "format_fsm.rl"
+
+                                case 3:
+                                        // line 45 "format_fsm.rl"
+
+                                        return buf.String(), fmt.Errorf("invalid format string starting at offset %d", p)
+
+                                case 4:
+                                        // line 49 "format_fsm.rl"
+
+                                        // We'll try to slurp a whole UTF-8 sequence here, to give the user
+                                        // better feedback.
+                                        r, _ := utf8.DecodeRuneInString(data[p:])
+                                        return buf.String(), fmt.Errorf("unrecognized format character %q at offset %d", r, p)
+
+                                        // line 363 "format_fsm.go"
+                                }
+                        }
+                }
+
+        _out:
+                {
+                }
+        }
+
+        // line 171 "format_fsm.rl"
+
+        // If we fall out here without being in a final state then we've
+        // encountered something that the scanner can't match, which should
+        // be impossible (the scanner matches all bytes _somehow_) but we'll
+        // flag it anyway rather than just losing data from the end.
+        if cs < formatfsm_first_final {
+                return buf.String(), fmt.Errorf("extraneous characters beginning at offset %i", p)
+        }
+
+        return buf.String(), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl
new file mode 100644
index 0000000..85d43bb
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl
@@ -0,0 +1,182 @@
+// This file is generated from format_fsm.rl. DO NOT EDIT.
+%%{
+        # (except you are actually in scan_tokens.rl here, so edit away!)
+        machine formatfsm;
+}%%
+
+package stdlib
+
+import (
+        "bytes"
+        "fmt"
+        "unicode/utf8"
+
+        "github.com/zclconf/go-cty/cty"
+)
+
+%%{
+        write data;
+}%%
+
+func formatFSM(format string, a []cty.Value) (string, error) {
+        var buf bytes.Buffer
+        data := format
+        nextArg := 1 // arg numbers are 1-based
+        var verb formatVerb
+
+        %%{
+
+        action begin {
+                verb = formatVerb{
+                        ArgNum: nextArg,
+                        Prec:   -1,
+                        Width:  -1,
+                }
+                ts = p
+        }
+
+        action emit {
+                buf.WriteByte(fc);
+        }
+
+        action finish_ok {
+        }
+
+        action finish_err {
+                return buf.String(), fmt.Errorf("invalid format string starting at offset %d", p)
+        }
+
+        action err_char {
+                // We'll try to slurp a whole UTF-8 sequence here, to give the user
+                // better feedback.
+                r, _ := utf8.DecodeRuneInString(data[p:])
+                return buf.String(), fmt.Errorf("unrecognized format character %q at offset %d", r, p)
+        }
+
+        action flag_sharp {
+                verb.Sharp = true
+        }
+        action flag_zero {
+                verb.Zero = true
+        }
+        action flag_minus {
+                verb.Minus = true
+        }
+        action flag_plus {
+                verb.Plus = true
+        }
+        action flag_space {
+                verb.Space = true
+        }
+
+        action argidx_reset {
+                verb.ArgNum = 0
+        }
+        action argidx_num {
+                verb.ArgNum = (10 * verb.ArgNum) + (int(fc) - '0')
+        }
+
+        action has_width {
+                verb.HasWidth = true
+        }
+        action width_reset {
+                verb.Width = 0
+        }
+        action width_num {
+                verb.Width = (10 * verb.Width) + (int(fc) - '0')
+        }
+
+        action has_prec {
+                verb.HasPrec = true
+        }
+        action prec_reset {
+                verb.Prec = 0
+        }
+        action prec_num {
+                verb.Prec = (10 * verb.Prec) + (int(fc) - '0')
+        }
+
+        action mode {
+                verb.Mode = rune(fc)
+                te = p+1
+                verb.Raw = data[ts:te]
+                verb.Offset = ts
+
+                err := formatAppend(&verb, &buf, a)
+                if err != nil {
+                        return buf.String(), err
+                }
+                nextArg = verb.ArgNum + 1
+        }
+
+        # a number that isn't zero and doesn't have a leading zero
+        num = [1-9] [0-9]*;
+
+        flags = (
+                '0' @flag_zero |
+                '#' @flag_sharp |
+                '-' @flag_minus |
+                '+' @flag_plus |
+                ' ' @flag_space
+        )*;
+
+        argidx = ((
+                '[' (num $argidx_num) ']'
+        ) >argidx_reset)?;
+
+        width = (
+                ( num $width_num ) >width_reset %has_width
+        )?;
+
+        precision = (
+                ('.' ( digit* $prec_num )) >prec_reset %has_prec
+        )?;
+
+        # We accept any letter here, but will be more picky in formatAppend
+        mode = ('a'..'z' | 'A'..'Z') @mode;
+
+        fmt_verb = (
+                '%' @begin
+                flags
+                width
+                precision
+                argidx
+                mode
+        );
+
+        main := (
+                [^%] @emit |
+                '%%' @emit |
+                fmt_verb
+        )* @/finish_err %/finish_ok $!err_char;
+
+        }%%
+
+        // Ragel state
+        p := 0  // "Pointer" into data
+        pe := len(data) // End-of-data "pointer"
+        cs := 0 // current state (will be initialized by ragel-generated code)
+        ts := 0
+        te := 0
+        eof := pe
+
+        // Keep Go compiler happy even if generated code doesn't use these
+        _ = ts
+        _ = te
+        _ = eof
+
+        %%{
+                write init;
+                write exec;
+        }%%
+
+        // If we fall out here without being in a final state then we've
+        // encountered something that the scanner can't match, which should
+        // be impossible (the scanner matches all bytes _somehow_) but we'll
+        // flag it anyway rather than just losing data from the end.
+        if cs < formatfsm_first_final {
+                return buf.String(), fmt.Errorf("extraneous characters beginning at offset %i", p)
+        }
+
+        return buf.String(), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/general.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/general.go
new file mode 100644
index 0000000..6b31f26
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/general.go
@@ -0,0 +1,107 @@
+package stdlib
+
+import (
+        "fmt"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/convert"
+        "github.com/zclconf/go-cty/cty/function"
+)
+
+var EqualFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.DynamicPseudoType,
+                        AllowUnknown:     true,
+                        AllowDynamicType: true,
+                        AllowNull:        true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.DynamicPseudoType,
+                        AllowUnknown:     true,
+                        AllowDynamicType: true,
+                        AllowNull:        true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Bool),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                return args[0].Equals(args[1]), nil
+        },
+})
+
+var NotEqualFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.DynamicPseudoType,
+                        AllowUnknown:     true,
+                        AllowDynamicType: true,
+                        AllowNull:        true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.DynamicPseudoType,
+                        AllowUnknown:     true,
+                        AllowDynamicType: true,
+                        AllowNull:        true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Bool),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                return args[0].Equals(args[1]).Not(), nil
+        },
+})
+
+var CoalesceFunc = function.New(&function.Spec{
+        Params: []function.Parameter{},
+        VarParam: &function.Parameter{
+                Name:             "vals",
+                Type:             cty.DynamicPseudoType,
+                AllowUnknown:     true,
+                AllowDynamicType: true,
+                AllowNull:        true,
+        },
+        Type: func(args []cty.Value) (ret cty.Type, err error) {
+                argTypes := make([]cty.Type, len(args))
+                for i, val := range args {
+                        argTypes[i] = val.Type()
+                }
+                retType, _ := convert.UnifyUnsafe(argTypes)
+                if retType == cty.NilType {
+                        return cty.NilType, fmt.Errorf("all arguments must have the same type")
+                }
+                return retType, nil
+        },
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                for _, argVal := range args {
+                        if !argVal.IsKnown() {
+                                return cty.UnknownVal(retType), nil
+                        }
+                        if argVal.IsNull() {
+                                continue
+                        }
+
+                        return convert.Convert(argVal, retType)
+                }
+                return cty.NilVal, fmt.Errorf("no non-null arguments")
+        },
+})
+
+// Equal determines whether the two given values are equal, returning a
+// bool value.
+func Equal(a cty.Value, b cty.Value) (cty.Value, error) {
+        return EqualFunc.Call([]cty.Value{a, b})
+}
+
+// NotEqual is the opposite of Equal.
+func NotEqual(a cty.Value, b cty.Value) (cty.Value, error) {
+        return NotEqualFunc.Call([]cty.Value{a, b})
+}
+
+// Coalesce returns the first of the given arguments that is not null. If
+// all arguments are null, an error is produced.
+func Coalesce(vals ...cty.Value) (cty.Value, error) {
+        return CoalesceFunc.Call(vals)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/json.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/json.go
new file mode 100644
index 0000000..07901c6
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/json.go
@@ -0,0 +1,72 @@
+package stdlib
+
+import (
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+        "github.com/zclconf/go-cty/cty/json"
+)
+
+var JSONEncodeFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "val",
+                        Type:             cty.DynamicPseudoType,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.String),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                val := args[0]
+                if !val.IsWhollyKnown() {
+                        // We can't serialize unknowns, so if the value is unknown or
+                        // contains any _nested_ unknowns then our result must be
+                        // unknown.
+                        return cty.UnknownVal(retType), nil
+                }
+
+                buf, err := json.Marshal(val, val.Type())
+                if err != nil {
+                        return cty.NilVal, err
+                }
+
+                return cty.StringVal(string(buf)), nil
+        },
+})
+
+var JSONDecodeFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name: "str",
+                        Type: cty.String,
+                },
+        },
+        Type: func(args []cty.Value) (cty.Type, error) {
+                str := args[0]
+                if !str.IsKnown() {
+                        return cty.DynamicPseudoType, nil
+                }
+
+                buf := []byte(str.AsString())
+                return json.ImpliedType(buf)
+        },
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                buf := []byte(args[0].AsString())
+                return json.Unmarshal(buf, retType)
+        },
+})
+
+// JSONEncode returns a JSON serialization of the given value.
+func JSONEncode(val cty.Value) (cty.Value, error) {
+        return JSONEncodeFunc.Call([]cty.Value{val})
+}
+
+// JSONDecode parses the given JSON string and, if it is valid, returns the
+// value it represents.
+//
+// Note that applying JSONDecode to the result of JSONEncode may not produce
+// an identically-typed result, since JSON encoding is lossy for cty Types.
+// The resulting value will consist only of primitive types, object types, and
+// tuple types.
+func JSONDecode(str cty.Value) (cty.Value, error) {
+        return JSONDecodeFunc.Call([]cty.Value{str})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/number.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/number.go
new file mode 100644
index 0000000..bd9b2e5
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/number.go
@@ -0,0 +1,428 @@
+package stdlib
+
+import (
+        "fmt"
+        "math/big"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+)
+
+var AbsoluteFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "num",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                return args[0].Absolute(), nil
+        },
+})
+
+var AddFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                // big.Float.Add can panic if the input values are opposing infinities,
+                // so we must catch that here in order to remain within
+                // the cty Function abstraction.
+                defer func() {
+                        if r := recover(); r != nil {
+                                if _, ok := r.(big.ErrNaN); ok {
+                                        ret = cty.NilVal
+                                        err = fmt.Errorf("can't compute sum of opposing infinities")
+                                } else {
+                                        // not a panic we recognize
+                                        panic(r)
+                                }
+                        }
+                }()
+                return args[0].Add(args[1]), nil
+        },
+})
+
+var SubtractFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                // big.Float.Sub can panic if the input values are infinities,
+                // so we must catch that here in order to remain within
+                // the cty Function abstraction.
+                defer func() {
+                        if r := recover(); r != nil {
+                                if _, ok := r.(big.ErrNaN); ok {
+                                        ret = cty.NilVal
+                                        err = fmt.Errorf("can't subtract infinity from itself")
+                                } else {
+                                        // not a panic we recognize
+                                        panic(r)
+                                }
+                        }
+                }()
+                return args[0].Subtract(args[1]), nil
+        },
+})
+
+var MultiplyFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                // big.Float.Mul can panic if the input values are both zero or both
+                // infinity, so we must catch that here in order to remain within
+                // the cty Function abstraction.
+                defer func() {
+                        if r := recover(); r != nil {
+                                if _, ok := r.(big.ErrNaN); ok {
+                                        ret = cty.NilVal
+                                        err = fmt.Errorf("can't multiply zero by infinity")
+                                } else {
+                                        // not a panic we recognize
+                                        panic(r)
+                                }
+                        }
+                }()
+
+                return args[0].Multiply(args[1]), nil
+        },
+})
+
+var DivideFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                // big.Float.Quo can panic if the input values are both zero or both
+                // infinity, so we must catch that here in order to remain within
+                // the cty Function abstraction.
+                defer func() {
+                        if r := recover(); r != nil {
+                                if _, ok := r.(big.ErrNaN); ok {
+                                        ret = cty.NilVal
+                                        err = fmt.Errorf("can't divide zero by zero or infinity by infinity")
+                                } else {
+                                        // not a panic we recognize
+                                        panic(r)
+                                }
+                        }
+                }()
+
+                return args[0].Divide(args[1]), nil
+        },
+})
+
+var ModuloFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                // big.Float.Mul can panic if the input values are both zero or both
+                // infinity, so we must catch that here in order to remain within
+                // the cty Function abstraction.
+                defer func() {
+                        if r := recover(); r != nil {
+                                if _, ok := r.(big.ErrNaN); ok {
+                                        ret = cty.NilVal
+                                        err = fmt.Errorf("can't use modulo with zero and infinity")
+                                } else {
+                                        // not a panic we recognize
+                                        panic(r)
+                                }
+                        }
+                }()
+
+                return args[0].Modulo(args[1]), nil
+        },
+})
+
+var GreaterThanFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Bool),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                return args[0].GreaterThan(args[1]), nil
+        },
+})
+
+var GreaterThanOrEqualToFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Bool),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                return args[0].GreaterThanOrEqualTo(args[1]), nil
+        },
+})
+
+var LessThanFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Bool),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                return args[0].LessThan(args[1]), nil
+        },
+})
+
+var LessThanOrEqualToFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Bool),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                return args[0].LessThanOrEqualTo(args[1]), nil
+        },
+})
+
+var NegateFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "num",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                return args[0].Negate(), nil
+        },
+})
+
+var MinFunc = function.New(&function.Spec{
+        Params: []function.Parameter{},
+        VarParam: &function.Parameter{
+                Name:             "numbers",
+                Type:             cty.Number,
+                AllowDynamicType: true,
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                if len(args) == 0 {
+                        return cty.NilVal, fmt.Errorf("must pass at least one number")
+                }
+
+                min := cty.PositiveInfinity
+                for _, num := range args {
+                        if num.LessThan(min).True() {
+                                min = num
+                        }
+                }
+
+                return min, nil
+        },
+})
+
+var MaxFunc = function.New(&function.Spec{
+        Params: []function.Parameter{},
+        VarParam: &function.Parameter{
+                Name:             "numbers",
+                Type:             cty.Number,
+                AllowDynamicType: true,
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                if len(args) == 0 {
+                        return cty.NilVal, fmt.Errorf("must pass at least one number")
+                }
+
+                max := cty.NegativeInfinity
+                for _, num := range args {
+                        if num.GreaterThan(max).True() {
+                                max = num
+                        }
+                }
+
+                return max, nil
+        },
+})
+
+var IntFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "num",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                bf := args[0].AsBigFloat()
+                if bf.IsInt() {
+                        return args[0], nil
+                }
+                bi, _ := bf.Int(nil)
+                bf = (&big.Float{}).SetInt(bi)
+                return cty.NumberVal(bf), nil
+        },
+})
+
+// Absolute returns the magnitude of the given number, without its sign.
+// That is, it turns negative values into positive values.
+func Absolute(num cty.Value) (cty.Value, error) {
+        return AbsoluteFunc.Call([]cty.Value{num})
+}
+
+// Add returns the sum of the two given numbers.
+func Add(a cty.Value, b cty.Value) (cty.Value, error) {
+        return AddFunc.Call([]cty.Value{a, b})
+}
+
+// Subtract returns the difference between the two given numbers.
+func Subtract(a cty.Value, b cty.Value) (cty.Value, error) {
+        return SubtractFunc.Call([]cty.Value{a, b})
+}
+
+// Multiply returns the product of the two given numbers.
+func Multiply(a cty.Value, b cty.Value) (cty.Value, error) {
+        return MultiplyFunc.Call([]cty.Value{a, b})
+}
+
+// Divide returns a divided by b, where both a and b are numbers.
+func Divide(a cty.Value, b cty.Value) (cty.Value, error) {
+        return DivideFunc.Call([]cty.Value{a, b})
+}
+
+// Negate returns the given number multipled by -1.
+func Negate(num cty.Value) (cty.Value, error) {
+        return NegateFunc.Call([]cty.Value{num})
+}
+
+// LessThan returns true if a is less than b.
+func LessThan(a cty.Value, b cty.Value) (cty.Value, error) {
+        return LessThanFunc.Call([]cty.Value{a, b})
+}
+
+// LessThanOrEqualTo returns true if a is less than b.
+func LessThanOrEqualTo(a cty.Value, b cty.Value) (cty.Value, error) {
+        return LessThanOrEqualToFunc.Call([]cty.Value{a, b})
+}
+
+// GreaterThan returns true if a is less than b.
+func GreaterThan(a cty.Value, b cty.Value) (cty.Value, error) {
+        return GreaterThanFunc.Call([]cty.Value{a, b})
+}
+
+// GreaterThanOrEqualTo returns true if a is less than b.
+func GreaterThanOrEqualTo(a cty.Value, b cty.Value) (cty.Value, error) {
+        return GreaterThanOrEqualToFunc.Call([]cty.Value{a, b})
+}
+
+// Modulo returns the remainder of a divided by b under integer division,
+// where both a and b are numbers.
+func Modulo(a cty.Value, b cty.Value) (cty.Value, error) {
+        return ModuloFunc.Call([]cty.Value{a, b})
+}
+
+// Min returns the minimum number from the given numbers.
+func Min(numbers ...cty.Value) (cty.Value, error) {
+        return MinFunc.Call(numbers)
+}
+
+// Max returns the maximum number from the given numbers.
+func Max(numbers ...cty.Value) (cty.Value, error) {
+        return MaxFunc.Call(numbers)
+}
+
+// Int removes the fractional component of the given number returning an
+// integer representing the whole number component, rounding towards zero.
+// For example, -1.5 becomes -1.
+//
+// If an infinity is passed to Int, an error is returned.
+func Int(num cty.Value) (cty.Value, error) {
+        if num == cty.PositiveInfinity || num == cty.NegativeInfinity {
+                return cty.NilVal, fmt.Errorf("can't truncate infinity to an integer")
+        }
+        return IntFunc.Call([]cty.Value{num})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go
new file mode 100644
index 0000000..e2c77c5
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go
@@ -0,0 +1,130 @@
+package stdlib
+
+import (
+        "fmt"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/convert"
+        "github.com/zclconf/go-cty/cty/function"
+)
+
+var ConcatFunc = function.New(&function.Spec{
+        Params: []function.Parameter{},
+        VarParam: &function.Parameter{
+                Name: "seqs",
+                Type: cty.DynamicPseudoType,
+        },
+        Type: func(args []cty.Value) (ret cty.Type, err error) {
+                if len(args) == 0 {
+                        return cty.NilType, fmt.Errorf("at least one argument is required")
+                }
+
+                if args[0].Type().IsListType() {
+                        // Possibly we're going to return a list, if all of our other
+                        // args are also lists and we can find a common element type.
+                        tys := make([]cty.Type, len(args))
+                        for i, val := range args {
+                                ty := val.Type()
+                                if !ty.IsListType() {
+                                        tys = nil
+                                        break
+                                }
+                                tys[i] = ty
+                        }
+
+                        if tys != nil {
+                                commonType, _ := convert.UnifyUnsafe(tys)
+                                if commonType != cty.NilType {
+                                        return commonType, nil
+                                }
+                        }
+                }
+
+                etys := make([]cty.Type, 0, len(args))
+                for i, val := range args {
+                        ety := val.Type()
+                        switch {
+                        case ety.IsTupleType():
+                                etys = append(etys, ety.TupleElementTypes()...)
+                        case ety.IsListType():
+                                if !val.IsKnown() {
+                                        // We need to know the list to count its elements to
+                                        // build our tuple type, so any concat of an unknown
+                                        // list can't be typed yet.
+                                        return cty.DynamicPseudoType, nil
+                                }
+
+                                l := val.LengthInt()
+                                subEty := ety.ElementType()
+                                for j := 0; j < l; j++ {
+                                        etys = append(etys, subEty)
+                                }
+                        default:
+                                return cty.NilType, function.NewArgErrorf(
+                                        i, "all arguments must be lists or tuples; got %s",
+                                        ety.FriendlyName(),
+                                )
+                        }
+                }
+                return cty.Tuple(etys), nil
+        },
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                switch {
+                case retType.IsListType():
+                        // If retType is a list type then we know that all of the
+                        // given values will be lists and that they will either be of
+                        // retType or of something we can convert to retType.
+                        vals := make([]cty.Value, 0, len(args))
+                        for i, list := range args {
+                                list, err = convert.Convert(list, retType)
+                                if err != nil {
+                                        // Conversion might fail because we used UnifyUnsafe
+                                        // to choose our return type.
+                                        return cty.NilVal, function.NewArgError(i, err)
+                                }
+
+                                it := list.ElementIterator()
+                                for it.Next() {
+                                        _, v := it.Element()
+                                        vals = append(vals, v)
+                                }
+                        }
+                        if len(vals) == 0 {
+                                return cty.ListValEmpty(retType.ElementType()), nil
+                        }
+
+                        return cty.ListVal(vals), nil
+                case retType.IsTupleType():
+                        // If retType is a tuple type then we could have a mixture of
+                        // lists and tuples but we know they all have known values
+                        // (because our params don't AllowUnknown) and we know that
+                        // concatenating them all together will produce a tuple of
+                        // retType because of the work we did in the Type function above.
+                        vals := make([]cty.Value, 0, len(args))
+
+                        for _, seq := range args {
+                                // Both lists and tuples support ElementIterator, so this is easy.
+                                it := seq.ElementIterator()
+                                for it.Next() {
+                                        _, v := it.Element()
+                                        vals = append(vals, v)
+                                }
+                        }
+
+                        return cty.TupleVal(vals), nil
+                default:
+                        // should never happen if Type is working correctly above
+                        panic("unsupported return type")
+                }
+        },
+})
+
+// Concat takes one or more sequences (lists or tuples) and returns the single
+// sequence that results from concatenating them together in order.
+//
+// If all of the given sequences are lists of the same element type then the
+// result is a list of that type. Otherwise, the result is a of a tuple type
+// constructed from the given sequence types.
+func Concat(seqs ...cty.Value) (cty.Value, error) {
+        return ConcatFunc.Call(seqs)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/set.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/set.go
new file mode 100644
index 0000000..100078f
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/set.go
@@ -0,0 +1,195 @@
+package stdlib
+
+import (
+        "fmt"
+
+        "github.com/zclconf/go-cty/cty/convert"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+)
+
+var SetHasElementFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "set",
+                        Type:             cty.Set(cty.DynamicPseudoType),
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "elem",
+                        Type:             cty.DynamicPseudoType,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Bool),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                return args[0].HasElement(args[1]), nil
+        },
+})
+
+var SetUnionFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "first_set",
+                        Type:             cty.Set(cty.DynamicPseudoType),
+                        AllowDynamicType: true,
+                },
+        },
+        VarParam: &function.Parameter{
+                Name:             "other_sets",
+                Type:             cty.Set(cty.DynamicPseudoType),
+                AllowDynamicType: true,
+        },
+        Type: setOperationReturnType,
+        Impl: setOperationImpl(func(s1, s2 cty.ValueSet) cty.ValueSet {
+                return s1.Union(s2)
+        }),
+})
+
+var SetIntersectionFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "first_set",
+                        Type:             cty.Set(cty.DynamicPseudoType),
+                        AllowDynamicType: true,
+                },
+        },
+        VarParam: &function.Parameter{
+                Name:             "other_sets",
+                Type:             cty.Set(cty.DynamicPseudoType),
+                AllowDynamicType: true,
+        },
+        Type: setOperationReturnType,
+        Impl: setOperationImpl(func(s1, s2 cty.ValueSet) cty.ValueSet {
+                return s1.Intersection(s2)
+        }),
+})
+
+var SetSubtractFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Set(cty.DynamicPseudoType),
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Set(cty.DynamicPseudoType),
+                        AllowDynamicType: true,
+                },
+        },
+        Type: setOperationReturnType,
+        Impl: setOperationImpl(func(s1, s2 cty.ValueSet) cty.ValueSet {
+                return s1.Subtract(s2)
+        }),
+})
+
+var SetSymmetricDifferenceFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "first_set",
+                        Type:             cty.Set(cty.DynamicPseudoType),
+                        AllowDynamicType: true,
+                },
+        },
+        VarParam: &function.Parameter{
+                Name:             "other_sets",
+                Type:             cty.Set(cty.DynamicPseudoType),
+                AllowDynamicType: true,
+        },
+        Type: setOperationReturnType,
+        Impl: setOperationImpl(func(s1, s2 cty.ValueSet) cty.ValueSet {
+                return s1.Subtract(s2)
+        }),
+})
+
+// SetHasElement determines whether the given set contains the given value as an
+// element.
+func SetHasElement(set cty.Value, elem cty.Value) (cty.Value, error) {
+        return SetHasElementFunc.Call([]cty.Value{set, elem})
+}
+
+// SetUnion returns a new set containing all of the elements from the given
+// sets, which must have element types that can all be converted to some
+// common type using the standard type unification rules. If conversion
+// is not possible, an error is returned.
+//
+// The union operation is performed after type conversion, which may result
+// in some previously-distinct values being conflated.
+//
+// At least one set must be provided.
+func SetUnion(sets ...cty.Value) (cty.Value, error) {
+        return SetUnionFunc.Call(sets)
+}
+
+// Intersection returns a new set containing the elements that exist
+// in all of the given sets, which must have element types that can all be
+// converted to some common type using the standard type unification rules.
+// If conversion is not possible, an error is returned.
+//
+// The intersection operation is performed after type conversion, which may
+// result in some previously-distinct values being conflated.
+//
+// At least one set must be provided.
+func SetIntersection(sets ...cty.Value) (cty.Value, error) {
+        return SetIntersectionFunc.Call(sets)
+}
+
+// SetSubtract returns a new set containing the elements from the
+// first set that are not present in the second set. The sets must have
+// element types that can both be converted to some common type using the
+// standard type unification rules. If conversion is not possible, an error
+// is returned.
+//
+// The subtract operation is performed after type conversion, which may
+// result in some previously-distinct values being conflated.
+func SetSubtract(a, b cty.Value) (cty.Value, error) {
+        return SetSubtractFunc.Call([]cty.Value{a, b})
+}
+
+// SetSymmetricDifference returns a new set containing elements that appear
+// in any of the given sets but not multiple. The sets must have
+// element types that can all be converted to some common type using the
+// standard type unification rules. If conversion is not possible, an error
+// is returned.
+//
+// The difference operation is performed after type conversion, which may
+// result in some previously-distinct values being conflated.
+func SetSymmetricDifference(sets ...cty.Value) (cty.Value, error) {
+        return SetSymmetricDifferenceFunc.Call(sets)
+}
+
+func setOperationReturnType(args []cty.Value) (ret cty.Type, err error) {
+        var etys []cty.Type
+        for _, arg := range args {
+                etys = append(etys, arg.Type().ElementType())
+        }
+        newEty, _ := convert.UnifyUnsafe(etys)
+        if newEty == cty.NilType {
+                return cty.NilType, fmt.Errorf("given sets must all have compatible element types")
+        }
+        return cty.Set(newEty), nil
+}
+
+func setOperationImpl(f func(s1, s2 cty.ValueSet) cty.ValueSet) function.ImplFunc {
+        return func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                first := args[0]
+                first, err = convert.Convert(first, retType)
+                if err != nil {
+                        return cty.NilVal, function.NewArgError(0, err)
+                }
+
+                set := first.AsValueSet()
+                for i, arg := range args[1:] {
+                        arg, err := convert.Convert(arg, retType)
+                        if err != nil {
+                                return cty.NilVal, function.NewArgError(i+1, err)
+                        }
+
+                        argSet := arg.AsValueSet()
+                        set = f(set, argSet)
+                }
+                return cty.SetValFromValueSet(set), nil
+        }
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string.go
new file mode 100644
index 0000000..d7c89fa
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string.go
@@ -0,0 +1,234 @@
+package stdlib
+
+import (
+        "strings"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+        "github.com/zclconf/go-cty/cty/gocty"
+        "github.com/apparentlymart/go-textseg/textseg"
+)
+
+var UpperFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "str",
+                        Type:             cty.String,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.String),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                in := args[0].AsString()
+                out := strings.ToUpper(in)
+                return cty.StringVal(out), nil
+        },
+})
+
+var LowerFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "str",
+                        Type:             cty.String,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.String),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                in := args[0].AsString()
+                out := strings.ToLower(in)
+                return cty.StringVal(out), nil
+        },
+})
+
+var ReverseFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "str",
+                        Type:             cty.String,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.String),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                in := []byte(args[0].AsString())
+                out := make([]byte, len(in))
+                pos := len(out)
+
+                inB := []byte(in)
+                for i := 0; i < len(in); {
+                        d, _, _ := textseg.ScanGraphemeClusters(inB[i:], true)
+                        cluster := in[i : i+d]
+                        pos -= len(cluster)
+                        copy(out[pos:], cluster)
+                        i += d
+                }
+
+                return cty.StringVal(string(out)), nil
+        },
+})
+
+var StrlenFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "str",
+                        Type:             cty.String,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                in := args[0].AsString()
+                l := 0
+
+                inB := []byte(in)
+                for i := 0; i < len(in); {
+                        d, _, _ := textseg.ScanGraphemeClusters(inB[i:], true)
+                        l++
+                        i += d
+                }
+
+                return cty.NumberIntVal(int64(l)), nil
+        },
+})
+
+var SubstrFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "str",
+                        Type:             cty.String,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "offset",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "length",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.String),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                in := []byte(args[0].AsString())
+                var offset, length int
+
+                var err error
+                err = gocty.FromCtyValue(args[1], &offset)
+                if err != nil {
+                        return cty.NilVal, err
+                }
+                err = gocty.FromCtyValue(args[2], &length)
+                if err != nil {
+                        return cty.NilVal, err
+                }
+
+                if offset < 0 {
+                        totalLenNum, err := Strlen(args[0])
+                        if err != nil {
+                                // should never happen
+                                panic("Stdlen returned an error")
+                        }
+
+                        var totalLen int
+                        err = gocty.FromCtyValue(totalLenNum, &totalLen)
+                        if err != nil {
+                                // should never happen
+                                panic("Stdlen returned a non-int number")
+                        }
+
+                        offset += totalLen
+                }
+
+                sub := in
+                pos := 0
+                var i int
+
+                // First we'll seek forward to our offset
+                if offset > 0 {
+                        for i = 0; i < len(sub); {
+                                d, _, _ := textseg.ScanGraphemeClusters(sub[i:], true)
+                                i += d
+                                pos++
+                                if pos == offset {
+                                        break
+                                }
+                                if i >= len(in) {
+                                        return cty.StringVal(""), nil
+                                }
+                        }
+
+                        sub = sub[i:]
+                }
+
+                if length < 0 {
+                        // Taking the remainder of the string is a fast path since
+                        // we can just return the rest of the buffer verbatim.
+                        return cty.StringVal(string(sub)), nil
+                }
+
+                // Otherwise we need to start seeking forward again until we
+                // reach the length we want.
+                pos = 0
+                for i = 0; i < len(sub); {
+                        d, _, _ := textseg.ScanGraphemeClusters(sub[i:], true)
+                        i += d
+                        pos++
+                        if pos == length {
+                                break
+                        }
+                }
+
+                sub = sub[:i]
+
+                return cty.StringVal(string(sub)), nil
+        },
+})
+
+// Upper is a Function that converts a given string to uppercase.
+func Upper(str cty.Value) (cty.Value, error) {
+        return UpperFunc.Call([]cty.Value{str})
+}
+
+// Lower is a Function that converts a given string to lowercase.
+func Lower(str cty.Value) (cty.Value, error) {
+        return LowerFunc.Call([]cty.Value{str})
+}
+
+// Reverse is a Function that reverses the order of the characters in the
+// given string.
+//
+// As usual, "character" for the sake of this function is a grapheme cluster,
+// so combining diacritics (for example) will be considered together as a
+// single character.
+func Reverse(str cty.Value) (cty.Value, error) {
+        return ReverseFunc.Call([]cty.Value{str})
+}
+
+// Strlen is a Function that returns the length of the given string in
+// characters.
+//
+// As usual, "character" for the sake of this function is a grapheme cluster,
+// so combining diacritics (for example) will be considered together as a
+// single character.
+func Strlen(str cty.Value) (cty.Value, error) {
+        return StrlenFunc.Call([]cty.Value{str})
+}
+
+// Substr is a Function that extracts a sequence of characters from another
+// string and creates a new string.
+//
+// As usual, "character" for the sake of this function is a grapheme cluster,
+// so combining diacritics (for example) will be considered together as a
+// single character.
+//
+// The "offset" index may be negative, in which case it is relative to the
+// end of the given string.
+//
+// The "length" may be -1, in which case the remainder of the string after
+// the given offset will be returned.
+func Substr(str cty.Value, offset cty.Value, length cty.Value) (cty.Value, error) {
+        return SubstrFunc.Call([]cty.Value{str, offset, length})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/unpredictable.go b/vendor/github.com/zclconf/go-cty/cty/function/unpredictable.go
new file mode 100644
index 0000000..3495550
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/unpredictable.go
@@ -0,0 +1,31 @@
+package function
+
+import (
+        "github.com/zclconf/go-cty/cty"
+)
+
+// Unpredictable wraps a given function such that it retains the same arguments
+// and type checking behavior but will return an unknown value when called.
+//
+// It is recommended that most functions be "pure", which is to say that they
+// will always produce the same value given particular input. However,
+// sometimes it is necessary to offer functions whose behavior depends on
+// some external state, such as reading a file or determining the current time.
+// In such cases, an unpredictable wrapper might be used to stand in for
+// the function during some sort of prior "checking" phase in order to delay
+// the actual effect until later.
+//
+// While Unpredictable can support a function that isn't pure in its
+// implementation, it still expects a function to be pure in its type checking
+// behavior, except for the special case of returning cty.DynamicPseudoType
+// if it is not yet able to predict its return value based on current argument
+// information.
+func Unpredictable(f Function) Function {
+        newSpec := *f.spec // shallow copy
+        newSpec.Impl = unpredictableImpl
+        return New(&newSpec)
+}
+
+func unpredictableImpl(args []cty.Value, retType cty.Type) (cty.Value, error) {
+        return cty.UnknownVal(retType), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/gob.go b/vendor/github.com/zclconf/go-cty/cty/gob.go
new file mode 100644
index 0000000..3d73199
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gob.go
@@ -0,0 +1,125 @@
+package cty
+
+import (
+        "bytes"
+        "encoding/gob"
+        "fmt"
+        "math/big"
+)
+
+// GobEncode is an implementation of the gob.GobEncoder interface, which
+// allows Values to be included in structures encoded with encoding/gob.
+//
+// Currently it is not possible to represent values of capsule types in gob,
+// because the types themselves cannot be represented.
+func (val Value) GobEncode() ([]byte, error) {
+        buf := &bytes.Buffer{}
+        enc := gob.NewEncoder(buf)
+
+        gv := gobValue{
+                Version: 0,
+                Ty:      val.ty,
+                V:       val.v,
+        }
+
+        err := enc.Encode(gv)
+        if err != nil {
+                return nil, fmt.Errorf("error encoding cty.Value: %s", err)
+        }
+
+        return buf.Bytes(), nil
+}
+
+// GobDecode is an implementation of the gob.GobDecoder interface, which
+// inverts the operation performed by GobEncode. See the documentation of
+// GobEncode for considerations when using cty.Value instances with gob.
+func (val *Value) GobDecode(buf []byte) error {
+        r := bytes.NewReader(buf)
+        dec := gob.NewDecoder(r)
+
+        var gv gobValue
+        err := dec.Decode(&gv)
+        if err != nil {
+                return fmt.Errorf("error decoding cty.Value: %s", err)
+        }
+        if gv.Version != 0 {
+                return fmt.Errorf("unsupported cty.Value encoding version %d; only 0 is supported", gv.Version)
+        }
+
+        // big.Float seems to, for some reason, lose its "pointerness" when we
+        // round-trip it, so we'll fix that here.
+        if bf, ok := gv.V.(big.Float); ok {
+                gv.V = &bf
+        }
+
+        val.ty = gv.Ty
+        val.v = gv.V
+
+        return nil
+}
+
+// GobEncode is an implementation of the gob.GobEncoder interface, which
+// allows Types to be included in structures encoded with encoding/gob.
+//
+// Currently it is not possible to represent capsule types in gob.
+func (t Type) GobEncode() ([]byte, error) {
+        buf := &bytes.Buffer{}
+        enc := gob.NewEncoder(buf)
+
+        gt := gobType{
+                Version: 0,
+                Impl:    t.typeImpl,
+        }
+
+        err := enc.Encode(gt)
+        if err != nil {
+                return nil, fmt.Errorf("error encoding cty.Type: %s", err)
+        }
+
+        return buf.Bytes(), nil
+}
+
+// GobDecode is an implementatino of the gob.GobDecoder interface, which
+// reverses the encoding performed by GobEncode to allow types to be recovered
+// from gob buffers.
+func (t *Type) GobDecode(buf []byte) error {
+        r := bytes.NewReader(buf)
+        dec := gob.NewDecoder(r)
+
+        var gt gobType
+        err := dec.Decode(&gt)
+        if err != nil {
+                return fmt.Errorf("error decoding cty.Type: %s", err)
+        }
+        if gt.Version != 0 {
+                return fmt.Errorf("unsupported cty.Type encoding version %d; only 0 is supported", gt.Version)
+        }
+
+        t.typeImpl = gt.Impl
+
+        return nil
+}
+
+// Capsule types cannot currently be gob-encoded, because they rely on pointer
+// equality and we have no way to recover the original pointer on decode.
+func (t *capsuleType) GobEncode() ([]byte, error) {
+        return nil, fmt.Errorf("cannot gob-encode capsule type %q", t.FriendlyName())
+}
+
+func (t *capsuleType) GobDecode() ([]byte, error) {
+        return nil, fmt.Errorf("cannot gob-decode capsule type %q", t.FriendlyName())
+}
+
+type gobValue struct {
+        Version int
+        Ty      Type
+        V       interface{}
+}
+
+type gobType struct {
+        Version int
+        Impl    typeImpl
+}
+
+type gobCapsuleTypeImpl struct {
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/doc.go b/vendor/github.com/zclconf/go-cty/cty/gocty/doc.go
new file mode 100644
index 0000000..a5177d2
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/doc.go
@@ -0,0 +1,7 @@
+// Package gocty deals with converting between cty Values and native go
+// values.
+//
+// It operates under a similar principle to the encoding/json and
+// encoding/xml packages in the standard library, using reflection to
+// populate native Go data structures from cty values and vice-versa.
+package gocty
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/helpers.go b/vendor/github.com/zclconf/go-cty/cty/gocty/helpers.go
new file mode 100644
index 0000000..94ffd2f
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/helpers.go
@@ -0,0 +1,43 @@
+package gocty
+
+import (
+        "math/big"
+        "reflect"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/set"
+)
+
+var valueType = reflect.TypeOf(cty.Value{})
+var typeType = reflect.TypeOf(cty.Type{})
+
+var setType = reflect.TypeOf(set.Set{})
+
+var bigFloatType = reflect.TypeOf(big.Float{})
+var bigIntType = reflect.TypeOf(big.Int{})
+
+var emptyInterfaceType = reflect.TypeOf(interface{}(nil))
+
+var stringType = reflect.TypeOf("")
+
+// structTagIndices interrogates the fields of the given type (which must
+// be a struct type, or we'll panic) and returns a map from the cty
+// attribute names declared via struct tags to the indices of the
+// fields holding those tags.
+//
+// This function will panic if two fields within the struct are tagged with
+// the same cty attribute name.
+func structTagIndices(st reflect.Type) map[string]int {
+        ct := st.NumField()
+        ret := make(map[string]int, ct)
+
+        for i := 0; i < ct; i++ {
+                field := st.Field(i)
+                attrName := field.Tag.Get("cty")
+                if attrName != "" {
+                        ret[attrName] = i
+                }
+        }
+
+        return ret
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/in.go b/vendor/github.com/zclconf/go-cty/cty/gocty/in.go
new file mode 100644
index 0000000..642501b
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/in.go
@@ -0,0 +1,528 @@
+package gocty
+
+import (
+        "math/big"
+        "reflect"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/set"
+)
+
+// ToCtyValue produces a cty.Value from a Go value. The result will conform
+// to the given type, or an error will be returned if this is not possible.
+//
+// The target type serves as a hint to resolve ambiguities in the mapping.
+// For example, the Go type set.Set tells us that the value is a set but
+// does not describe the set's element type. This also allows for convenient
+// conversions, such as populating a set from a slice rather than having to
+// first explicitly instantiate a set.Set.
+//
+// The audience of this function is assumed to be the developers of Go code
+// that is integrating with cty, and thus the error messages it returns are
+// presented from Go's perspective. These messages are thus not appropriate
+// for display to end-users. An error returned from ToCtyValue represents a
+// bug in the calling program, not user error.
+func ToCtyValue(val interface{}, ty cty.Type) (cty.Value, error) {
+        // 'path' starts off as empty but will grow for each level of recursive
+        // call we make, so by the time toCtyValue returns it is likely to have
+        // unused capacity on the end of it, depending on how deeply-recursive
+        // the given Type is.
+        path := make(cty.Path, 0)
+        return toCtyValue(reflect.ValueOf(val), ty, path)
+}
+
+func toCtyValue(val reflect.Value, ty cty.Type, path cty.Path) (cty.Value, error) {
+
+        switch ty {
+        case cty.Bool:
+                return toCtyBool(val, path)
+        case cty.Number:
+                return toCtyNumber(val, path)
+        case cty.String:
+                return toCtyString(val, path)
+        case cty.DynamicPseudoType:
+                return toCtyDynamic(val, path)
+        }
+
+        switch {
+        case ty.IsListType():
+                return toCtyList(val, ty.ElementType(), path)
+        case ty.IsMapType():
+                return toCtyMap(val, ty.ElementType(), path)
+        case ty.IsSetType():
+                return toCtySet(val, ty.ElementType(), path)
+        case ty.IsObjectType():
+                return toCtyObject(val, ty.AttributeTypes(), path)
+        case ty.IsTupleType():
+                return toCtyTuple(val, ty.TupleElementTypes(), path)
+        case ty.IsCapsuleType():
+                return toCtyCapsule(val, ty, path)
+        }
+
+        // We should never fall out here
+        return cty.NilVal, path.NewErrorf("unsupported target type %#v", ty)
+}
+
+func toCtyBool(val reflect.Value, path cty.Path) (cty.Value, error) {
+        if val = toCtyUnwrapPointer(val); !val.IsValid() {
+                return cty.NullVal(cty.Bool), nil
+        }
+
+        switch val.Kind() {
+
+        case reflect.Bool:
+                return cty.BoolVal(val.Bool()), nil
+
+        default:
+                return cty.NilVal, path.NewErrorf("can't convert Go %s to bool", val.Kind())
+
+        }
+
+}
+
+func toCtyNumber(val reflect.Value, path cty.Path) (cty.Value, error) {
+        if val = toCtyUnwrapPointer(val); !val.IsValid() {
+                return cty.NullVal(cty.Number), nil
+        }
+
+        switch val.Kind() {
+
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                return cty.NumberIntVal(val.Int()), nil
+
+        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+                return cty.NumberUIntVal(val.Uint()), nil
+
+        case reflect.Float32, reflect.Float64:
+                return cty.NumberFloatVal(val.Float()), nil
+
+        case reflect.Struct:
+                if val.Type().AssignableTo(bigIntType) {
+                        bigInt := val.Interface().(big.Int)
+                        bigFloat := (&big.Float{}).SetInt(&bigInt)
+                        val = reflect.ValueOf(*bigFloat)
+                }
+
+                if val.Type().AssignableTo(bigFloatType) {
+                        bigFloat := val.Interface().(big.Float)
+                        return cty.NumberVal(&bigFloat), nil
+                }
+
+                fallthrough
+        default:
+                return cty.NilVal, path.NewErrorf("can't convert Go %s to number", val.Kind())
+
+        }
+
+}
+
+func toCtyString(val reflect.Value, path cty.Path) (cty.Value, error) {
+        if val = toCtyUnwrapPointer(val); !val.IsValid() {
+                return cty.NullVal(cty.String), nil
+        }
+
+        switch val.Kind() {
+
+        case reflect.String:
+                return cty.StringVal(val.String()), nil
+
+        default:
+                return cty.NilVal, path.NewErrorf("can't convert Go %s to string", val.Kind())
+
+        }
+
+}
+
+func toCtyList(val reflect.Value, ety cty.Type, path cty.Path) (cty.Value, error) {
+        if val = toCtyUnwrapPointer(val); !val.IsValid() {
+                return cty.NullVal(cty.List(ety)), nil
+        }
+
+        switch val.Kind() {
+
+        case reflect.Slice:
+                if val.IsNil() {
+                        return cty.NullVal(cty.List(ety)), nil
+                }
+                fallthrough
+        case reflect.Array:
+                if val.Len() == 0 {
+                        return cty.ListValEmpty(ety), nil
+                }
+
+                // While we work on our elements we'll temporarily grow
+                // path to give us a place to put our index step.
+                path = append(path, cty.PathStep(nil))
+
+                vals := make([]cty.Value, val.Len())
+                for i := range vals {
+                        var err error
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: cty.NumberIntVal(int64(i)),
+                        }
+                        vals[i], err = toCtyValue(val.Index(i), ety, path)
+                        if err != nil {
+                                return cty.NilVal, err
+                        }
+                }
+
+                // Discard our extra path segment, retaining it as extra capacity
+                // for future appending to the path.
+                path = path[:len(path)-1]
+
+                return cty.ListVal(vals), nil
+
+        default:
+                return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.List(ety))
+
+        }
+}
+
+func toCtyMap(val reflect.Value, ety cty.Type, path cty.Path) (cty.Value, error) {
+        if val = toCtyUnwrapPointer(val); !val.IsValid() {
+                return cty.NullVal(cty.Map(ety)), nil
+        }
+
+        switch val.Kind() {
+
+        case reflect.Map:
+                if val.IsNil() {
+                        return cty.NullVal(cty.Map(ety)), nil
+                }
+
+                if val.Len() == 0 {
+                        return cty.MapValEmpty(ety), nil
+                }
+
+                keyType := val.Type().Key()
+                if keyType.Kind() != reflect.String {
+                        return cty.NilVal, path.NewErrorf("can't convert Go map with key type %s; key type must be string", keyType)
+                }
+
+                // While we work on our elements we'll temporarily grow
+                // path to give us a place to put our index step.
+                path = append(path, cty.PathStep(nil))
+
+                vals := make(map[string]cty.Value, val.Len())
+                for _, kv := range val.MapKeys() {
+                        k := kv.String()
+                        var err error
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: cty.StringVal(k),
+                        }
+                        vals[k], err = toCtyValue(val.MapIndex(reflect.ValueOf(k)), ety, path)
+                        if err != nil {
+                                return cty.NilVal, err
+                        }
+                }
+
+                // Discard our extra path segment, retaining it as extra capacity
+                // for future appending to the path.
+                path = path[:len(path)-1]
+
+                return cty.MapVal(vals), nil
+
+        default:
+                return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.Map(ety))
+
+        }
+}
+
+func toCtySet(val reflect.Value, ety cty.Type, path cty.Path) (cty.Value, error) {
+        if val = toCtyUnwrapPointer(val); !val.IsValid() {
+                return cty.NullVal(cty.Set(ety)), nil
+        }
+
+        var vals []cty.Value
+
+        switch val.Kind() {
+
+        case reflect.Slice:
+                if val.IsNil() {
+                        return cty.NullVal(cty.Set(ety)), nil
+                }
+                fallthrough
+        case reflect.Array:
+                if val.Len() == 0 {
+                        return cty.SetValEmpty(ety), nil
+                }
+
+                vals = make([]cty.Value, val.Len())
+                for i := range vals {
+                        var err error
+                        vals[i], err = toCtyValue(val.Index(i), ety, path)
+                        if err != nil {
+                                return cty.NilVal, err
+                        }
+                }
+
+        case reflect.Struct:
+
+                if !val.Type().AssignableTo(setType) {
+                        return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Type(), cty.Set(ety))
+                }
+
+                rawSet := val.Interface().(set.Set)
+                inVals := rawSet.Values()
+
+                if len(inVals) == 0 {
+                        return cty.SetValEmpty(ety), nil
+                }
+
+                vals = make([]cty.Value, len(inVals))
+                for i := range inVals {
+                        var err error
+                        vals[i], err = toCtyValue(reflect.ValueOf(inVals[i]), ety, path)
+                        if err != nil {
+                                return cty.NilVal, err
+                        }
+                }
+
+        default:
+                return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.Set(ety))
+
+        }
+
+        return cty.SetVal(vals), nil
+}
+
+func toCtyObject(val reflect.Value, attrTypes map[string]cty.Type, path cty.Path) (cty.Value, error) {
+        if val = toCtyUnwrapPointer(val); !val.IsValid() {
+                return cty.NullVal(cty.Object(attrTypes)), nil
+        }
+
+        switch val.Kind() {
+
+        case reflect.Map:
+                if val.IsNil() {
+                        return cty.NullVal(cty.Object(attrTypes)), nil
+                }
+
+                keyType := val.Type().Key()
+                if keyType.Kind() != reflect.String {
+                        return cty.NilVal, path.NewErrorf("can't convert Go map with key type %s; key type must be string", keyType)
+                }
+
+                if len(attrTypes) == 0 {
+                        return cty.EmptyObjectVal, nil
+                }
+
+                // While we work on our elements we'll temporarily grow
+                // path to give us a place to put our GetAttr step.
+                path = append(path, cty.PathStep(nil))
+
+                haveKeys := make(map[string]struct{}, val.Len())
+                for _, kv := range val.MapKeys() {
+                        haveKeys[kv.String()] = struct{}{}
+                }
+
+                vals := make(map[string]cty.Value, len(attrTypes))
+                for k, at := range attrTypes {
+                        var err error
+                        path[len(path)-1] = cty.GetAttrStep{
+                                Name: k,
+                        }
+
+                        if _, have := haveKeys[k]; !have {
+                                vals[k] = cty.NullVal(at)
+                                continue
+                        }
+
+                        vals[k], err = toCtyValue(val.MapIndex(reflect.ValueOf(k)), at, path)
+                        if err != nil {
+                                return cty.NilVal, err
+                        }
+                }
+
+                // Discard our extra path segment, retaining it as extra capacity
+                // for future appending to the path.
+                path = path[:len(path)-1]
+
+                return cty.ObjectVal(vals), nil
+
+        case reflect.Struct:
+                if len(attrTypes) == 0 {
+                        return cty.EmptyObjectVal, nil
+                }
+
+                // While we work on our elements we'll temporarily grow
+                // path to give us a place to put our GetAttr step.
+                path = append(path, cty.PathStep(nil))
+
+                attrFields := structTagIndices(val.Type())
+
+                vals := make(map[string]cty.Value, len(attrTypes))
+                for k, at := range attrTypes {
+                        path[len(path)-1] = cty.GetAttrStep{
+                                Name: k,
+                        }
+
+                        if fieldIdx, have := attrFields[k]; have {
+                                var err error
+                                vals[k], err = toCtyValue(val.Field(fieldIdx), at, path)
+                                if err != nil {
+                                        return cty.NilVal, err
+                                }
+                        } else {
+                                vals[k] = cty.NullVal(at)
+                        }
+                }
+
+                // Discard our extra path segment, retaining it as extra capacity
+                // for future appending to the path.
+                path = path[:len(path)-1]
+
+                return cty.ObjectVal(vals), nil
+
+        default:
+                return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.Object(attrTypes))
+
+        }
+}
+
+func toCtyTuple(val reflect.Value, elemTypes []cty.Type, path cty.Path) (cty.Value, error) {
+        if val = toCtyUnwrapPointer(val); !val.IsValid() {
+                return cty.NullVal(cty.Tuple(elemTypes)), nil
+        }
+
+        switch val.Kind() {
+
+        case reflect.Slice:
+                if val.IsNil() {
+                        return cty.NullVal(cty.Tuple(elemTypes)), nil
+                }
+
+                if val.Len() != len(elemTypes) {
+                        return cty.NilVal, path.NewErrorf("wrong number of elements %d; need %d", val.Len(), len(elemTypes))
+                }
+
+                if len(elemTypes) == 0 {
+                        return cty.EmptyTupleVal, nil
+                }
+
+                // While we work on our elements we'll temporarily grow
+                // path to give us a place to put our Index step.
+                path = append(path, cty.PathStep(nil))
+
+                vals := make([]cty.Value, len(elemTypes))
+                for i, ety := range elemTypes {
+                        var err error
+
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: cty.NumberIntVal(int64(i)),
+                        }
+
+                        vals[i], err = toCtyValue(val.Index(i), ety, path)
+                        if err != nil {
+                                return cty.NilVal, err
+                        }
+                }
+
+                // Discard our extra path segment, retaining it as extra capacity
+                // for future appending to the path.
+                path = path[:len(path)-1]
+
+                return cty.TupleVal(vals), nil
+
+        case reflect.Struct:
+                fieldCount := val.Type().NumField()
+                if fieldCount != len(elemTypes) {
+                        return cty.NilVal, path.NewErrorf("wrong number of struct fields %d; need %d", fieldCount, len(elemTypes))
+                }
+
+                if len(elemTypes) == 0 {
+                        return cty.EmptyTupleVal, nil
+                }
+
+                // While we work on our elements we'll temporarily grow
+                // path to give us a place to put our Index step.
+                path = append(path, cty.PathStep(nil))
+
+                vals := make([]cty.Value, len(elemTypes))
+                for i, ety := range elemTypes {
+                        var err error
+
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: cty.NumberIntVal(int64(i)),
+                        }
+
+                        vals[i], err = toCtyValue(val.Field(i), ety, path)
+                        if err != nil {
+                                return cty.NilVal, err
+                        }
+                }
+
+                // Discard our extra path segment, retaining it as extra capacity
+                // for future appending to the path.
+                path = path[:len(path)-1]
+
+                return cty.TupleVal(vals), nil
+
+        default:
+                return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.Tuple(elemTypes))
+
+        }
+}
+
+func toCtyCapsule(val reflect.Value, capsuleType cty.Type, path cty.Path) (cty.Value, error) {
+        if val = toCtyUnwrapPointer(val); !val.IsValid() {
+                return cty.NullVal(capsuleType), nil
+        }
+
+        if val.Kind() != reflect.Ptr {
+                if !val.CanAddr() {
+                        return cty.NilVal, path.NewErrorf("source value for capsule %#v must be addressable", capsuleType)
+                }
+
+                val = val.Addr()
+        }
+
+        if !val.Type().Elem().AssignableTo(capsuleType.EncapsulatedType()) {
+                return cty.NilVal, path.NewErrorf("value of type %T not compatible with capsule %#v", val.Interface(), capsuleType)
+        }
+
+        return cty.CapsuleVal(capsuleType, val.Interface()), nil
+}
+
+func toCtyDynamic(val reflect.Value, path cty.Path) (cty.Value, error) {
+        if val = toCtyUnwrapPointer(val); !val.IsValid() {
+                return cty.NullVal(cty.DynamicPseudoType), nil
+        }
+
+        switch val.Kind() {
+
+        case reflect.Struct:
+                if !val.Type().AssignableTo(valueType) {
+                        return cty.NilVal, path.NewErrorf("can't convert Go %s dynamically; only cty.Value allowed", val.Type())
+                }
+
+                return val.Interface().(cty.Value), nil
+
+        default:
+                return cty.NilVal, path.NewErrorf("can't convert Go %s dynamically; only cty.Value allowed", val.Kind())
+
+        }
+
+}
+
+// toCtyUnwrapPointer is a helper for dealing with Go pointers. It has three
+// possible outcomes:
+//
+// - Given value isn't a pointer, so it's just returned as-is.
+// - Given value is a non-nil pointer, in which case it is dereferenced
+//   and the result returned.
+// - Given value is a nil pointer, in which case an invalid value is returned.
+//
+// For nested pointer types, like **int, they are all dereferenced in turn
+// until a non-pointer value is found, or until a nil pointer is encountered.
+func toCtyUnwrapPointer(val reflect.Value) reflect.Value {
+        for val.Kind() == reflect.Ptr || val.Kind() == reflect.Interface {
+                if val.IsNil() {
+                        return reflect.Value{}
+                }
+
+                val = val.Elem()
+        }
+
+        return val
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/out.go b/vendor/github.com/zclconf/go-cty/cty/gocty/out.go
new file mode 100644
index 0000000..99b65a7
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/out.go
@@ -0,0 +1,705 @@
+package gocty
+
+import (
+        "math/big"
+        "reflect"
+
+        "math"
+
+        "github.com/zclconf/go-cty/cty"
+)
+
+// FromCtyValue assigns a cty.Value to a reflect.Value, which must be a pointer,
+// using a fixed set of conversion rules.
+//
+// This function considers its audience to be the creator of the cty Value
+// given, and thus the error messages it generates are (unlike with ToCtyValue)
+// presented in cty terminology that is generally appropriate to return to
+// end-users in applications where cty data structures are built from
+// user-provided configuration. In particular this means that if incorrect
+// target types are provided by the calling application the resulting error
+// messages are likely to be confusing, since we assume that the given target
+// type is correct and the cty.Value is where the error lies.
+//
+// If an error is returned, the target data structure may have been partially
+// populated, but the degree to which this is true is an implementation
+// detail that the calling application should not rely on.
+//
+// The function will panic if given a non-pointer as the Go value target,
+// since that is considered to be a bug in the calling program.
+func FromCtyValue(val cty.Value, target interface{}) error {
+        tVal := reflect.ValueOf(target)
+        if tVal.Kind() != reflect.Ptr {
+                panic("target value is not a pointer")
+        }
+        if tVal.IsNil() {
+                panic("target value is nil pointer")
+        }
+
+        // 'path' starts off as empty but will grow for each level of recursive
+        // call we make, so by the time fromCtyValue returns it is likely to have
+        // unused capacity on the end of it, depending on how deeply-recursive
+        // the given cty.Value is.
+        path := make(cty.Path, 0)
+        return fromCtyValue(val, tVal, path)
+}
+
+func fromCtyValue(val cty.Value, target reflect.Value, path cty.Path) error {
+        ty := val.Type()
+
+        deepTarget := fromCtyPopulatePtr(target, false)
+
+        // If we're decoding into a cty.Value then we just pass through the
+        // value as-is, to enable partial decoding. This is the only situation
+        // where unknown values are permitted.
+        if deepTarget.Kind() == reflect.Struct && deepTarget.Type().AssignableTo(valueType) {
+                deepTarget.Set(reflect.ValueOf(val))
+                return nil
+        }
+
+        // Lists and maps can be nil without indirection, but everything else
+        // requires a pointer and we set it immediately to nil.
+        // We also make an exception for capsule types because we want to handle
+        // pointers specially for these.
+        // (fromCtyList and fromCtyMap must therefore deal with val.IsNull, while
+        // other types can assume no nulls after this point.)
+        if val.IsNull() && !val.Type().IsListType() && !val.Type().IsMapType() && !val.Type().IsCapsuleType() {
+                target = fromCtyPopulatePtr(target, true)
+                if target.Kind() != reflect.Ptr {
+                        return path.NewErrorf("null value is not allowed")
+                }
+
+                target.Set(reflect.Zero(target.Type()))
+                return nil
+        }
+
+        target = deepTarget
+
+        if !val.IsKnown() {
+                return path.NewErrorf("value must be known")
+        }
+
+        switch ty {
+        case cty.Bool:
+                return fromCtyBool(val, target, path)
+        case cty.Number:
+                return fromCtyNumber(val, target, path)
+        case cty.String:
+                return fromCtyString(val, target, path)
+        }
+
+        switch {
+        case ty.IsListType():
+                return fromCtyList(val, target, path)
+        case ty.IsMapType():
+                return fromCtyMap(val, target, path)
+        case ty.IsSetType():
+                return fromCtySet(val, target, path)
+        case ty.IsObjectType():
+                return fromCtyObject(val, target, path)
+        case ty.IsTupleType():
+                return fromCtyTuple(val, target, path)
+        case ty.IsCapsuleType():
+                return fromCtyCapsule(val, target, path)
+        }
+
+        // We should never fall out here; reaching here indicates a bug in this
+        // function.
+        return path.NewErrorf("unsupported source type %#v", ty)
+}
+
+func fromCtyBool(val cty.Value, target reflect.Value, path cty.Path) error {
+        switch target.Kind() {
+
+        case reflect.Bool:
+                if val.True() {
+                        target.Set(reflect.ValueOf(true))
+                } else {
+                        target.Set(reflect.ValueOf(false))
+                }
+                return nil
+
+        default:
+                return likelyRequiredTypesError(path, target)
+
+        }
+}
+
+func fromCtyNumber(val cty.Value, target reflect.Value, path cty.Path) error {
+        bf := val.AsBigFloat()
+
+        switch target.Kind() {
+
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                return fromCtyNumberInt(bf, target, path)
+
+        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+                return fromCtyNumberUInt(bf, target, path)
+
+        case reflect.Float32, reflect.Float64:
+                return fromCtyNumberFloat(bf, target, path)
+
+        case reflect.Struct:
+                return fromCtyNumberBig(bf, target, path)
+
+        default:
+                return likelyRequiredTypesError(path, target)
+
+        }
+}
+
+func fromCtyNumberInt(bf *big.Float, target reflect.Value, path cty.Path) error {
+        // Doing this with switch rather than << arithmetic because << with
+        // result >32-bits is not portable to 32-bit systems.
+        var min int64
+        var max int64
+        switch target.Type().Bits() {
+        case 8:
+                min = math.MinInt8
+                max = math.MaxInt8
+        case 16:
+                min = math.MinInt16
+                max = math.MaxInt16
+        case 32:
+                min = math.MinInt32
+                max = math.MaxInt32
+        case 64:
+                min = math.MinInt64
+                max = math.MaxInt64
+        default:
+                panic("weird number of bits in target int")
+        }
+
+        iv, accuracy := bf.Int64()
+        if accuracy != big.Exact || iv < min || iv > max {
+                return path.NewErrorf("value must be a whole number, between %d and %d", min, max)
+        }
+
+        target.Set(reflect.ValueOf(iv).Convert(target.Type()))
+
+        return nil
+}
+
+func fromCtyNumberUInt(bf *big.Float, target reflect.Value, path cty.Path) error {
+        // Doing this with switch rather than << arithmetic because << with
+        // result >32-bits is not portable to 32-bit systems.
+        var max uint64
+        switch target.Type().Bits() {
+        case 8:
+                max = math.MaxUint8
+        case 16:
+                max = math.MaxUint16
+        case 32:
+                max = math.MaxUint32
+        case 64:
+                max = math.MaxUint64
+        default:
+                panic("weird number of bits in target uint")
+        }
+
+        iv, accuracy := bf.Uint64()
+        if accuracy != big.Exact || iv > max {
+                return path.NewErrorf("value must be a whole number, between 0 and %d inclusive", max)
+        }
+
+        target.Set(reflect.ValueOf(iv).Convert(target.Type()))
+
+        return nil
+}
+
+func fromCtyNumberFloat(bf *big.Float, target reflect.Value, path cty.Path) error {
+        switch target.Kind() {
+        case reflect.Float32:
+                fv, accuracy := bf.Float32()
+                if accuracy != big.Exact {
+                        // We allow the precision to be truncated as part of our conversion,
+                        // but we don't want to silently introduce infinities.
+                        if math.IsInf(float64(fv), 0) {
+                                return path.NewErrorf("value must be between %f and %f inclusive", -math.MaxFloat32, math.MaxFloat32)
+                        }
+                }
+                target.Set(reflect.ValueOf(fv))
+                return nil
+        case reflect.Float64:
+                fv, accuracy := bf.Float64()
+                if accuracy != big.Exact {
+                        // We allow the precision to be truncated as part of our conversion,
+                        // but we don't want to silently introduce infinities.
+                        if math.IsInf(fv, 0) {
+                                return path.NewErrorf("value must be between %f and %f inclusive", -math.MaxFloat64, math.MaxFloat64)
+                        }
+                }
+                target.Set(reflect.ValueOf(fv))
+                return nil
+        default:
+                panic("unsupported kind of float")
+        }
+}
+
+func fromCtyNumberBig(bf *big.Float, target reflect.Value, path cty.Path) error {
+        switch {
+
+        case bigFloatType.AssignableTo(target.Type()):
+                // Easy!
+                target.Set(reflect.ValueOf(bf).Elem())
+                return nil
+
+        case bigIntType.AssignableTo(target.Type()):
+                bi, accuracy := bf.Int(nil)
+                if accuracy != big.Exact {
+                        return path.NewErrorf("value must be a whole number")
+                }
+                target.Set(reflect.ValueOf(bi).Elem())
+                return nil
+
+        default:
+                return likelyRequiredTypesError(path, target)
+        }
+}
+
+func fromCtyString(val cty.Value, target reflect.Value, path cty.Path) error {
+        switch target.Kind() {
+
+        case reflect.String:
+                target.Set(reflect.ValueOf(val.AsString()))
+                return nil
+
+        default:
+                return likelyRequiredTypesError(path, target)
+
+        }
+}
+
+func fromCtyList(val cty.Value, target reflect.Value, path cty.Path) error {
+        switch target.Kind() {
+
+        case reflect.Slice:
+                if val.IsNull() {
+                        target.Set(reflect.Zero(target.Type()))
+                        return nil
+                }
+
+                length := val.LengthInt()
+                tv := reflect.MakeSlice(target.Type(), length, length)
+
+                path = append(path, nil)
+
+                i := 0
+                var err error
+                val.ForEachElement(func(key cty.Value, val cty.Value) bool {
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: cty.NumberIntVal(int64(i)),
+                        }
+
+                        targetElem := tv.Index(i)
+                        err = fromCtyValue(val, targetElem, path)
+                        if err != nil {
+                                return true
+                        }
+
+                        i++
+                        return false
+                })
+                if err != nil {
+                        return err
+                }
+
+                path = path[:len(path)-1]
+
+                target.Set(tv)
+                return nil
+
+        case reflect.Array:
+                if val.IsNull() {
+                        return path.NewErrorf("null value is not allowed")
+                }
+
+                length := val.LengthInt()
+                if length != target.Len() {
+                        return path.NewErrorf("must be a list of length %d", target.Len())
+                }
+
+                path = append(path, nil)
+
+                i := 0
+                var err error
+                val.ForEachElement(func(key cty.Value, val cty.Value) bool {
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: cty.NumberIntVal(int64(i)),
+                        }
+
+                        targetElem := target.Index(i)
+                        err = fromCtyValue(val, targetElem, path)
+                        if err != nil {
+                                return true
+                        }
+
+                        i++
+                        return false
+                })
+                if err != nil {
+                        return err
+                }
+
+                path = path[:len(path)-1]
+
+                return nil
+
+        default:
+                return likelyRequiredTypesError(path, target)
+
+        }
+}
+
+func fromCtyMap(val cty.Value, target reflect.Value, path cty.Path) error {
+
+        switch target.Kind() {
+
+        case reflect.Map:
+                if val.IsNull() {
+                        target.Set(reflect.Zero(target.Type()))
+                        return nil
+                }
+
+                tv := reflect.MakeMap(target.Type())
+                et := target.Type().Elem()
+
+                path = append(path, nil)
+
+                var err error
+                val.ForEachElement(func(key cty.Value, val cty.Value) bool {
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: key,
+                        }
+
+                        ks := key.AsString()
+
+                        targetElem := reflect.New(et)
+                        err = fromCtyValue(val, targetElem, path)
+
+                        tv.SetMapIndex(reflect.ValueOf(ks), targetElem.Elem())
+
+                        return err != nil
+                })
+                if err != nil {
+                        return err
+                }
+
+                path = path[:len(path)-1]
+
+                target.Set(tv)
+                return nil
+
+        default:
+                return likelyRequiredTypesError(path, target)
+
+        }
+}
+
+func fromCtySet(val cty.Value, target reflect.Value, path cty.Path) error {
+        switch target.Kind() {
+
+        case reflect.Slice:
+                if val.IsNull() {
+                        target.Set(reflect.Zero(target.Type()))
+                        return nil
+                }
+
+                length := val.LengthInt()
+                tv := reflect.MakeSlice(target.Type(), length, length)
+
+                i := 0
+                var err error
+                val.ForEachElement(func(key cty.Value, val cty.Value) bool {
+                        targetElem := tv.Index(i)
+                        err = fromCtyValue(val, targetElem, path)
+                        if err != nil {
+                                return true
+                        }
+
+                        i++
+                        return false
+                })
+                if err != nil {
+                        return err
+                }
+
+                target.Set(tv)
+                return nil
+
+        case reflect.Array:
+                if val.IsNull() {
+                        return path.NewErrorf("null value is not allowed")
+                }
+
+                length := val.LengthInt()
+                if length != target.Len() {
+                        return path.NewErrorf("must be a set of length %d", target.Len())
+                }
+
+                i := 0
+                var err error
+                val.ForEachElement(func(key cty.Value, val cty.Value) bool {
+                        targetElem := target.Index(i)
+                        err = fromCtyValue(val, targetElem, path)
+                        if err != nil {
+                                return true
+                        }
+
+                        i++
+                        return false
+                })
+                if err != nil {
+                        return err
+                }
+
+                return nil
+
+        // TODO: decode into set.Set instance
+
+        default:
+                return likelyRequiredTypesError(path, target)
+
+        }
+}
+
+func fromCtyObject(val cty.Value, target reflect.Value, path cty.Path) error {
+
+        switch target.Kind() {
+
+        case reflect.Struct:
+
+                attrTypes := val.Type().AttributeTypes()
+                targetFields := structTagIndices(target.Type())
+
+                path = append(path, nil)
+
+                for k, i := range targetFields {
+                        if _, exists := attrTypes[k]; !exists {
+                                // If the field in question isn't able to represent nil,
+                                // that's an error.
+                                fk := target.Field(i).Kind()
+                                switch fk {
+                                case reflect.Ptr, reflect.Slice, reflect.Map, reflect.Interface:
+                                        // okay
+                                default:
+                                        return path.NewErrorf("missing required attribute %q", k)
+                                }
+                        }
+                }
+
+                for k := range attrTypes {
+                        path[len(path)-1] = cty.GetAttrStep{
+                                Name: k,
+                        }
+
+                        fieldIdx, exists := targetFields[k]
+                        if !exists {
+                                return path.NewErrorf("unsupported attribute %q", k)
+                        }
+
+                        ev := val.GetAttr(k)
+
+                        targetField := target.Field(fieldIdx)
+                        err := fromCtyValue(ev, targetField, path)
+                        if err != nil {
+                                return err
+                        }
+                }
+
+                path = path[:len(path)-1]
+
+                return nil
+
+        default:
+                return likelyRequiredTypesError(path, target)
+
+        }
+}
+
+func fromCtyTuple(val cty.Value, target reflect.Value, path cty.Path) error {
+
+        switch target.Kind() {
+
+        case reflect.Struct:
+
+                elemTypes := val.Type().TupleElementTypes()
+                fieldCount := target.Type().NumField()
+
+                if fieldCount != len(elemTypes) {
+                        return path.NewErrorf("a tuple of %d elements is required", fieldCount)
+                }
+
+                path = append(path, nil)
+
+                for i := range elemTypes {
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: cty.NumberIntVal(int64(i)),
+                        }
+
+                        ev := val.Index(cty.NumberIntVal(int64(i)))
+
+                        targetField := target.Field(i)
+                        err := fromCtyValue(ev, targetField, path)
+                        if err != nil {
+                                return err
+                        }
+                }
+
+                path = path[:len(path)-1]
+
+                return nil
+
+        default:
+                return likelyRequiredTypesError(path, target)
+
+        }
+}
+
+func fromCtyCapsule(val cty.Value, target reflect.Value, path cty.Path) error {
+
+        if target.Kind() == reflect.Ptr {
+                // Walk through indirection until we get to the last pointer,
+                // which we might set to null below.
+                target = fromCtyPopulatePtr(target, true)
+
+                if val.IsNull() {
+                        target.Set(reflect.Zero(target.Type()))
+                        return nil
+                }
+
+                // Since a capsule contains a pointer to an object, we'll preserve
+                // that pointer on the way out and thus allow the caller to recover
+                // the original object, rather than a copy of it.
+
+                eType := val.Type().EncapsulatedType()
+
+                if !eType.AssignableTo(target.Elem().Type()) {
+                        // Our interface contract promises that we won't expose Go
+                        // implementation details in error messages, so we need to keep
+                        // this vague. This can only arise if a calling application has
+                        // more than one capsule type in play and a user mixes them up.
+                        return path.NewErrorf("incorrect type %s", val.Type().FriendlyName())
+                }
+
+                target.Set(reflect.ValueOf(val.EncapsulatedValue()))
+
+                return nil
+        } else {
+                if val.IsNull() {
+                        return path.NewErrorf("null value is not allowed")
+                }
+
+                // If our target isn't a pointer then we will attempt to copy
+                // the encapsulated value into it.
+
+                eType := val.Type().EncapsulatedType()
+
+                if !eType.AssignableTo(target.Type()) {
+                        // Our interface contract promises that we won't expose Go
+                        // implementation details in error messages, so we need to keep
+                        // this vague. This can only arise if a calling application has
+                        // more than one capsule type in play and a user mixes them up.
+                        return path.NewErrorf("incorrect type %s", val.Type().FriendlyName())
+                }
+
+                // We know that EncapsulatedValue is always a pointer, so we
+                // can safely call .Elem on its reflect.Value.
+                target.Set(reflect.ValueOf(val.EncapsulatedValue()).Elem())
+
+                return nil
+        }
+
+}
+
+// fromCtyPopulatePtr recognizes when target is a pointer type and allocates
+// a value to assign to that pointer, which it returns.
+//
+// If the given value has multiple levels of indirection, like **int, these
+// will be processed in turn so that the return value is guaranteed to be
+// a non-pointer.
+//
+// As an exception, if decodingNull is true then the returned value will be
+// the final level of pointer, if any, so that the caller can assign it
+// as nil to represent a null value. If the given target value is not a pointer
+// at all then the returned value will be just the given target, so the caller
+// must test if the returned value is a pointer before trying to assign nil
+// to it.
+func fromCtyPopulatePtr(target reflect.Value, decodingNull bool) reflect.Value {
+        for {
+                if target.Kind() == reflect.Interface && !target.IsNil() {
+                        e := target.Elem()
+                        if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) {
+                                target = e
+                        }
+                }
+
+                if target.Kind() != reflect.Ptr {
+                        break
+                }
+
+                // Stop early if we're decodingNull and we've found our last indirection
+                if target.Elem().Kind() != reflect.Ptr && decodingNull && target.CanSet() {
+                        break
+                }
+
+                if target.IsNil() {
+                        target.Set(reflect.New(target.Type().Elem()))
+                }
+
+                target = target.Elem()
+        }
+        return target
+}
+
+// likelyRequiredTypesError returns an error that states which types are
+// acceptable by making some assumptions about what types we support for
+// each target Go kind. It's not a precise science but it allows us to return
+// an error message that is cty-user-oriented rather than Go-oriented.
+//
+// Generally these error messages should be a matter of last resort, since
+// the calling application should be validating user-provided value types
+// before decoding anyway.
+func likelyRequiredTypesError(path cty.Path, target reflect.Value) error {
+        switch target.Kind() {
+
+        case reflect.Bool:
+                return path.NewErrorf("bool value is required")
+
+        case reflect.String:
+                return path.NewErrorf("string value is required")
+
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                fallthrough
+        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+                fallthrough
+        case reflect.Float32, reflect.Float64:
+                return path.NewErrorf("number value is required")
+
+        case reflect.Slice, reflect.Array:
+                return path.NewErrorf("list or set value is required")
+
+        case reflect.Map:
+                return path.NewErrorf("map or object value is required")
+
+        case reflect.Struct:
+                switch {
+
+                case target.Type().AssignableTo(bigFloatType) || target.Type().AssignableTo(bigIntType):
+                        return path.NewErrorf("number value is required")
+
+                case target.Type().AssignableTo(setType):
+                        return path.NewErrorf("set or list value is required")
+
+                default:
+                        return path.NewErrorf("object or tuple value is required")
+
+                }
+
+        default:
+                // We should avoid getting into this path, since this error
+                // message is rather useless.
+                return path.NewErrorf("incorrect type")
+
+        }
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/type_implied.go b/vendor/github.com/zclconf/go-cty/cty/gocty/type_implied.go
new file mode 100644
index 0000000..ce4c8f1
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/type_implied.go
@@ -0,0 +1,108 @@
+package gocty
+
+import (
+        "reflect"
+
+        "github.com/zclconf/go-cty/cty"
+)
+
+// ImpliedType takes an arbitrary Go value (as an interface{}) and attempts
+// to find a suitable cty.Type instance that could be used for a conversion
+// with ToCtyValue.
+//
+// This allows -- for simple situations at least -- types to be defined just
+// once in Go and the cty types derived from the Go types, but in the process
+// it makes some assumptions that may be undesirable so applications are
+// encouraged to build their cty types directly if exacting control is
+// required.
+//
+// Not all Go types can be represented as cty types, so an error may be
+// returned which is usually considered to be a bug in the calling program.
+// In particular, ImpliedType will never use capsule types in its returned
+// type, because it cannot know the capsule types supported by the calling
+// program.
+func ImpliedType(gv interface{}) (cty.Type, error) {
+        rt := reflect.TypeOf(gv)
+        var path cty.Path
+        return impliedType(rt, path)
+}
+
+func impliedType(rt reflect.Type, path cty.Path) (cty.Type, error) {
+        switch rt.Kind() {
+
+        case reflect.Ptr:
+                return impliedType(rt.Elem(), path)
+
+        // Primitive types
+        case reflect.Bool:
+                return cty.Bool, nil
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                return cty.Number, nil
+        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+                return cty.Number, nil
+        case reflect.Float32, reflect.Float64:
+                return cty.Number, nil
+        case reflect.String:
+                return cty.String, nil
+
+        // Collection types
+        case reflect.Slice:
+                path := append(path, cty.IndexStep{Key: cty.UnknownVal(cty.Number)})
+                ety, err := impliedType(rt.Elem(), path)
+                if err != nil {
+                        return cty.NilType, err
+                }
+                return cty.List(ety), nil
+        case reflect.Map:
+                if !stringType.AssignableTo(rt.Key()) {
+                        return cty.NilType, path.NewErrorf("no cty.Type for %s (must have string keys)", rt)
+                }
+                path := append(path, cty.IndexStep{Key: cty.UnknownVal(cty.String)})
+                ety, err := impliedType(rt.Elem(), path)
+                if err != nil {
+                        return cty.NilType, err
+                }
+                return cty.Map(ety), nil
+
+        // Structural types
+        case reflect.Struct:
+                return impliedStructType(rt, path)
+
+        default:
+                return cty.NilType, path.NewErrorf("no cty.Type for %s", rt)
+        }
+}
+
+func impliedStructType(rt reflect.Type, path cty.Path) (cty.Type, error) {
+        if valueType.AssignableTo(rt) {
+                // Special case: cty.Value represents cty.DynamicPseudoType, for
+                // type conformance checking.
+                return cty.DynamicPseudoType, nil
+        }
+
+        fieldIdxs := structTagIndices(rt)
+        if len(fieldIdxs) == 0 {
+                return cty.NilType, path.NewErrorf("no cty.Type for %s (no cty field tags)", rt)
+        }
+
+        atys := make(map[string]cty.Type, len(fieldIdxs))
+
+        {
+                // Temporary extension of path for attributes
+                path := append(path, nil)
+
+                for k, fi := range fieldIdxs {
+                        path[len(path)-1] = cty.GetAttrStep{Name: k}
+
+                        ft := rt.Field(fi).Type
+                        aty, err := impliedType(ft, path)
+                        if err != nil {
+                                return cty.NilType, err
+                        }
+
+                        atys[k] = aty
+                }
+        }
+
+        return cty.Object(atys), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/helper.go b/vendor/github.com/zclconf/go-cty/cty/helper.go
new file mode 100644
index 0000000..1b88e9f
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/helper.go
@@ -0,0 +1,99 @@
+package cty
+
+import (
+        "fmt"
+)
+
+// anyUnknown is a helper to easily check if a set of values contains any
+// unknowns, for operations that short-circuit to return unknown in that case.
+func anyUnknown(values ...Value) bool {
+        for _, val := range values {
+                if val.v == unknown {
+                        return true
+                }
+        }
+        return false
+}
+
+// typeCheck tests whether all of the given values belong to the given type.
+// If the given types are a mixture of the given type and the dynamic
+// pseudo-type then a short-circuit dynamic value is returned. If the given
+// values are all of the correct type but at least one is unknown then
+// a short-circuit unknown value is returned. If any other types appear then
+// an error is returned. Otherwise (finally!) the result is nil, nil.
+func typeCheck(required Type, ret Type, values ...Value) (shortCircuit *Value, err error) {
+        hasDynamic := false
+        hasUnknown := false
+
+        for i, val := range values {
+                if val.ty == DynamicPseudoType {
+                        hasDynamic = true
+                        continue
+                }
+
+                if !val.Type().Equals(required) {
+                        return nil, fmt.Errorf(
+                                "type mismatch: want %s but value %d is %s",
+                                required.FriendlyName(),
+                                i, val.ty.FriendlyName(),
+                        )
+                }
+
+                if val.v == unknown {
+                        hasUnknown = true
+                }
+        }
+
+        if hasDynamic {
+                return &DynamicVal, nil
+        }
+
+        if hasUnknown {
+                ret := UnknownVal(ret)
+                return &ret, nil
+        }
+
+        return nil, nil
+}
+
+// mustTypeCheck is a wrapper around typeCheck that immediately panics if
+// any error is returned.
+func mustTypeCheck(required Type, ret Type, values ...Value) *Value {
+        shortCircuit, err := typeCheck(required, ret, values...)
+        if err != nil {
+                panic(err)
+        }
+        return shortCircuit
+}
+
+// shortCircuitForceType takes the return value from mustTypeCheck and
+// replaces it with an unknown of the given type if the original value was
+// DynamicVal.
+//
+// This is useful for operations that are specified to always return a
+// particular type, since then a dynamic result can safely be "upgrade" to
+// a strongly-typed unknown, which then allows subsequent operations to
+// be actually type-checked.
+//
+// It is safe to use this only if the operation in question is defined as
+// returning either a value of the given type or panicking, since we know
+// then that subsequent operations won't run if the operation panics.
+//
+// If the given short-circuit value is *not* DynamicVal then it must be
+// of the given type, or this function will panic.
+func forceShortCircuitType(shortCircuit *Value, ty Type) *Value {
+        if shortCircuit == nil {
+                return nil
+        }
+
+        if shortCircuit.ty == DynamicPseudoType {
+                ret := UnknownVal(ty)
+                return &ret
+        }
+
+        if !shortCircuit.ty.Equals(ty) {
+                panic("forceShortCircuitType got value of wrong type")
+        }
+
+        return shortCircuit
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json.go b/vendor/github.com/zclconf/go-cty/cty/json.go
new file mode 100644
index 0000000..c421a62
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json.go
@@ -0,0 +1,176 @@
+package cty
+
+import (
+        "bytes"
+        "encoding/json"
+        "fmt"
+)
+
+// MarshalJSON is an implementation of json.Marshaler that allows Type
+// instances to be serialized as JSON.
+//
+// All standard types can be serialized, but capsule types cannot since there
+// is no way to automatically recover the original pointer and capsule types
+// compare by equality.
+func (t Type) MarshalJSON() ([]byte, error) {
+        switch impl := t.typeImpl.(type) {
+        case primitiveType:
+                switch impl.Kind {
+                case primitiveTypeBool:
+                        return []byte{'"', 'b', 'o', 'o', 'l', '"'}, nil
+                case primitiveTypeNumber:
+                        return []byte{'"', 'n', 'u', 'm', 'b', 'e', 'r', '"'}, nil
+                case primitiveTypeString:
+                        return []byte{'"', 's', 't', 'r', 'i', 'n', 'g', '"'}, nil
+                default:
+                        panic("unknown primitive type kind")
+                }
+        case typeList, typeMap, typeSet:
+                buf := &bytes.Buffer{}
+                etyJSON, err := t.ElementType().MarshalJSON()
+                if err != nil {
+                        return nil, err
+                }
+                buf.WriteRune('[')
+                switch impl.(type) {
+                case typeList:
+                        buf.WriteString(`"list"`)
+                case typeMap:
+                        buf.WriteString(`"map"`)
+                case typeSet:
+                        buf.WriteString(`"set"`)
+                }
+                buf.WriteRune(',')
+                buf.Write(etyJSON)
+                buf.WriteRune(']')
+                return buf.Bytes(), nil
+        case typeObject:
+                buf := &bytes.Buffer{}
+                atysJSON, err := json.Marshal(t.AttributeTypes())
+                if err != nil {
+                        return nil, err
+                }
+                buf.WriteString(`["object",`)
+                buf.Write(atysJSON)
+                buf.WriteRune(']')
+                return buf.Bytes(), nil
+        case typeTuple:
+                buf := &bytes.Buffer{}
+                etysJSON, err := json.Marshal(t.TupleElementTypes())
+                if err != nil {
+                        return nil, err
+                }
+                buf.WriteString(`["tuple",`)
+                buf.Write(etysJSON)
+                buf.WriteRune(']')
+                return buf.Bytes(), nil
+        case pseudoTypeDynamic:
+                return []byte{'"', 'd', 'y', 'n', 'a', 'm', 'i', 'c', '"'}, nil
+        case *capsuleType:
+                return nil, fmt.Errorf("type not allowed: %s", t.FriendlyName())
+        default:
+                // should never happen
+                panic("unknown type implementation")
+        }
+}
+
+// UnmarshalJSON is the opposite of MarshalJSON. See the documentation of
+// MarshalJSON for information on the limitations of JSON serialization of
+// types.
+func (t *Type) UnmarshalJSON(buf []byte) error {
+        r := bytes.NewReader(buf)
+        dec := json.NewDecoder(r)
+
+        tok, err := dec.Token()
+        if err != nil {
+                return err
+        }
+
+        switch v := tok.(type) {
+        case string:
+                switch v {
+                case "bool":
+                        *t = Bool
+                case "number":
+                        *t = Number
+                case "string":
+                        *t = String
+                case "dynamic":
+                        *t = DynamicPseudoType
+                default:
+                        return fmt.Errorf("invalid primitive type name %q", v)
+                }
+
+                if dec.More() {
+                        return fmt.Errorf("extraneous data after type description")
+                }
+                return nil
+        case json.Delim:
+                if rune(v) != '[' {
+                        return fmt.Errorf("invalid complex type description")
+                }
+
+                tok, err = dec.Token()
+                if err != nil {
+                        return err
+                }
+
+                kind, ok := tok.(string)
+                if !ok {
+                        return fmt.Errorf("invalid complex type kind name")
+                }
+
+                switch kind {
+                case "list":
+                        var ety Type
+                        err = dec.Decode(&ety)
+                        if err != nil {
+                                return err
+                        }
+                        *t = List(ety)
+                case "map":
+                        var ety Type
+                        err = dec.Decode(&ety)
+                        if err != nil {
+                                return err
+                        }
+                        *t = Map(ety)
+                case "set":
+                        var ety Type
+                        err = dec.Decode(&ety)
+                        if err != nil {
+                                return err
+                        }
+                        *t = Set(ety)
+                case "object":
+                        var atys map[string]Type
+                        err = dec.Decode(&atys)
+                        if err != nil {
+                                return err
+                        }
+                        *t = Object(atys)
+                case "tuple":
+                        var etys []Type
+                        err = dec.Decode(&etys)
+                        if err != nil {
+                                return err
+                        }
+                        *t = Tuple(etys)
+                default:
+                        return fmt.Errorf("invalid complex type kind name")
+                }
+
+                tok, err = dec.Token()
+                if err != nil {
+                        return err
+                }
+                if delim, ok := tok.(json.Delim); !ok || rune(delim) != ']' || dec.More() {
+                        return fmt.Errorf("unexpected extra data in type description")
+                }
+
+                return nil
+
+        default:
+                return fmt.Errorf("invalid type description")
+        }
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/doc.go b/vendor/github.com/zclconf/go-cty/cty/json/doc.go
new file mode 100644
index 0000000..8916513
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/doc.go
@@ -0,0 +1,11 @@
+// Package json provides functions for serializing cty types and values in
+// JSON format, and for decoding them again.
+//
+// Since the cty type system is a superset of the JSON type system,
+// round-tripping through JSON is lossy unless type information is provided
+// both at encoding time and decoding time. Callers of this package are
+// therefore suggested to define their expected structure as a cty.Type
+// and pass it in consistently both when encoding and when decoding, though
+// default (type-lossy) behavior is provided for situations where the precise
+// representation of the data is not significant.
+package json
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/marshal.go b/vendor/github.com/zclconf/go-cty/cty/json/marshal.go
new file mode 100644
index 0000000..f7bea1a
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/marshal.go
@@ -0,0 +1,189 @@
+package json
+
+import (
+        "bytes"
+        "encoding/json"
+        "sort"
+
+        "github.com/zclconf/go-cty/cty"
+)
+
+func marshal(val cty.Value, t cty.Type, path cty.Path, b *bytes.Buffer) error {
+        // If we're going to decode as DynamicPseudoType then we need to save
+        // dynamic type information to recover the real type.
+        if t == cty.DynamicPseudoType && val.Type() != cty.DynamicPseudoType {
+                return marshalDynamic(val, path, b)
+        }
+
+        if val.IsNull() {
+                b.WriteString("null")
+                return nil
+        }
+
+        if !val.IsKnown() {
+                return path.NewErrorf("value is not known")
+        }
+
+        // The caller should've guaranteed that the given val is conformant with
+        // the given type t, so we'll proceed under that assumption here.
+
+        switch {
+        case t.IsPrimitiveType():
+                switch t {
+                case cty.String:
+                        json, err := json.Marshal(val.AsString())
+                        if err != nil {
+                                return path.NewErrorf("failed to serialize value: %s", err)
+                        }
+                        b.Write(json)
+                        return nil
+                case cty.Number:
+                        if val.RawEquals(cty.PositiveInfinity) || val.RawEquals(cty.NegativeInfinity) {
+                                return path.NewErrorf("cannot serialize infinity as JSON")
+                        }
+                        b.WriteString(val.AsBigFloat().Text('f', -1))
+                        return nil
+                case cty.Bool:
+                        if val.True() {
+                                b.WriteString("true")
+                        } else {
+                                b.WriteString("false")
+                        }
+                        return nil
+                default:
+                        panic("unsupported primitive type")
+                }
+        case t.IsListType(), t.IsSetType():
+                b.WriteRune('[')
+                first := true
+                ety := t.ElementType()
+                it := val.ElementIterator()
+                path := append(path, nil) // local override of 'path' with extra element
+                for it.Next() {
+                        if !first {
+                                b.WriteRune(',')
+                        }
+                        ek, ev := it.Element()
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: ek,
+                        }
+                        err := marshal(ev, ety, path, b)
+                        if err != nil {
+                                return err
+                        }
+                        first = false
+                }
+                b.WriteRune(']')
+                return nil
+        case t.IsMapType():
+                b.WriteRune('{')
+                first := true
+                ety := t.ElementType()
+                it := val.ElementIterator()
+                path := append(path, nil) // local override of 'path' with extra element
+                for it.Next() {
+                        if !first {
+                                b.WriteRune(',')
+                        }
+                        ek, ev := it.Element()
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: ek,
+                        }
+                        var err error
+                        err = marshal(ek, ek.Type(), path, b)
+                        if err != nil {
+                                return err
+                        }
+                        b.WriteRune(':')
+                        err = marshal(ev, ety, path, b)
+                        if err != nil {
+                                return err
+                        }
+                        first = false
+                }
+                b.WriteRune('}')
+                return nil
+        case t.IsTupleType():
+                b.WriteRune('[')
+                etys := t.TupleElementTypes()
+                it := val.ElementIterator()
+                path := append(path, nil) // local override of 'path' with extra element
+                i := 0
+                for it.Next() {
+                        if i > 0 {
+                                b.WriteRune(',')
+                        }
+                        ety := etys[i]
+                        ek, ev := it.Element()
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: ek,
+                        }
+                        err := marshal(ev, ety, path, b)
+                        if err != nil {
+                                return err
+                        }
+                        i++
+                }
+                b.WriteRune(']')
+                return nil
+        case t.IsObjectType():
+                b.WriteRune('{')
+                atys := t.AttributeTypes()
+                path := append(path, nil) // local override of 'path' with extra element
+
+                names := make([]string, 0, len(atys))
+                for k := range atys {
+                        names = append(names, k)
+                }
+                sort.Strings(names)
+
+                for i, k := range names {
+                        aty := atys[k]
+                        if i > 0 {
+                                b.WriteRune(',')
+                        }
+                        av := val.GetAttr(k)
+                        path[len(path)-1] = cty.GetAttrStep{
+                                Name: k,
+                        }
+                        var err error
+                        err = marshal(cty.StringVal(k), cty.String, path, b)
+                        if err != nil {
+                                return err
+                        }
+                        b.WriteRune(':')
+                        err = marshal(av, aty, path, b)
+                        if err != nil {
+                                return err
+                        }
+                }
+                b.WriteRune('}')
+                return nil
+        case t.IsCapsuleType():
+                rawVal := val.EncapsulatedValue()
+                jsonVal, err := json.Marshal(rawVal)
+                if err != nil {
+                        return path.NewError(err)
+                }
+                b.Write(jsonVal)
+                return nil
+        default:
+                // should never happen
+                return path.NewErrorf("cannot JSON-serialize %s", t.FriendlyName())
+        }
+}
+
+// marshalDynamic adds an extra wrapping object containing dynamic type
+// information for the given value.
+func marshalDynamic(val cty.Value, path cty.Path, b *bytes.Buffer) error {
+        typeJSON, err := MarshalType(val.Type())
+        if err != nil {
+                return path.NewErrorf("failed to serialize type: %s", err)
+        }
+        b.WriteString(`{"value":`)
+        marshal(val, val.Type(), path, b)
+        b.WriteString(`,"type":`)
+        b.Write(typeJSON)
+        b.WriteRune('}')
+        return nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/simple.go b/vendor/github.com/zclconf/go-cty/cty/json/simple.go
new file mode 100644
index 0000000..507c9cc
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/simple.go
@@ -0,0 +1,41 @@
+package json
+
+import (
+        "github.com/zclconf/go-cty/cty"
+)
+
+// SimpleJSONValue is a wrapper around cty.Value that adds implementations of
+// json.Marshaler and json.Unmarshaler for simple-but-type-lossy automatic
+// encoding and decoding of values.
+//
+// The couplet Marshal and Unmarshal both take extra type information to
+// inform the encoding and decoding process so that all of the cty types
+// can be represented even though JSON's type system is a subset.
+//
+// SimpleJSONValue instead takes the approach of discarding the value's type
+// information and then deriving a new type from the stored structure when
+// decoding. This results in the same data being returned but not necessarily
+// with exactly the same type.
+//
+// For information on how types are inferred when decoding, see the
+// documentation of the function ImpliedType.
+type SimpleJSONValue struct {
+        cty.Value
+}
+
+// MarshalJSON is an implementation of json.Marshaler. See the documentation
+// of SimpleJSONValue for more information.
+func (v SimpleJSONValue) MarshalJSON() ([]byte, error) {
+        return Marshal(v.Value, v.Type())
+}
+
+// UnmarshalJSON is an implementation of json.Unmarshaler. See the
+// documentation of SimpleJSONValue for more information.
+func (v *SimpleJSONValue) UnmarshalJSON(buf []byte) error {
+        t, err := ImpliedType(buf)
+        if err != nil {
+                return err
+        }
+        v.Value, err = Unmarshal(buf, t)
+        return err
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/type.go b/vendor/github.com/zclconf/go-cty/cty/json/type.go
new file mode 100644
index 0000000..9131c6c
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/type.go
@@ -0,0 +1,23 @@
+package json
+
+import (
+        "github.com/zclconf/go-cty/cty"
+)
+
+// MarshalType returns a JSON serialization of the given type.
+//
+// This is just a thin wrapper around t.MarshalJSON, for symmetry with
+// UnmarshalType.
+func MarshalType(t cty.Type) ([]byte, error) {
+        return t.MarshalJSON()
+}
+
+// UnmarshalType decodes a JSON serialization of the given type as produced
+// by either Type.MarshalJSON or MarshalType.
+//
+// This is a convenience wrapper around Type.UnmarshalJSON.
+func UnmarshalType(buf []byte) (cty.Type, error) {
+        var t cty.Type
+        err := t.UnmarshalJSON(buf)
+        return t, err
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/type_implied.go b/vendor/github.com/zclconf/go-cty/cty/json/type_implied.go
new file mode 100644
index 0000000..1a97306
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/type_implied.go
@@ -0,0 +1,171 @@
+package json
+
+import (
+        "bytes"
+        "encoding/json"
+        "fmt"
+
+        "github.com/zclconf/go-cty/cty"
+)
+
+// ImpliedType returns the cty Type implied by the structure of the given
+// JSON-compliant buffer. This function implements the default type mapping
+// behavior used when decoding arbitrary JSON without explicit cty Type
+// information.
+//
+// The rules are as follows:
+//
+// JSON strings, numbers and bools map to their equivalent primitive type in
+// cty.
+//
+// JSON objects map to cty object types, with the attributes defined by the
+// object keys and the types of their values.
+//
+// JSON arrays map to cty tuple types, with the elements defined by the
+// types of the array members.
+//
+// Any nulls are typed as DynamicPseudoType, so callers of this function
+// must be prepared to deal with this. Callers that do not wish to deal with
+// dynamic typing should not use this function and should instead describe
+// their required types explicitly with a cty.Type instance when decoding.
+//
+// Any JSON syntax errors will be returned as an error, and the type will
+// be the invalid value cty.NilType.
+func ImpliedType(buf []byte) (cty.Type, error) {
+        r := bytes.NewReader(buf)
+        dec := json.NewDecoder(r)
+        dec.UseNumber()
+
+        ty, err := impliedType(dec)
+        if err != nil {
+                return cty.NilType, err
+        }
+
+        if dec.More() {
+                return cty.NilType, fmt.Errorf("extraneous data after JSON object")
+        }
+
+        return ty, nil
+}
+
+func impliedType(dec *json.Decoder) (cty.Type, error) {
+        tok, err := dec.Token()
+        if err != nil {
+                return cty.NilType, err
+        }
+
+        return impliedTypeForTok(tok, dec)
+}
+
+func impliedTypeForTok(tok json.Token, dec *json.Decoder) (cty.Type, error) {
+        if tok == nil {
+                return cty.DynamicPseudoType, nil
+        }
+
+        switch ttok := tok.(type) {
+        case bool:
+                return cty.Bool, nil
+
+        case json.Number:
+                return cty.Number, nil
+
+        case string:
+                return cty.String, nil
+
+        case json.Delim:
+
+                switch rune(ttok) {
+                case '{':
+                        return impliedObjectType(dec)
+                case '[':
+                        return impliedTupleType(dec)
+                default:
+                        return cty.NilType, fmt.Errorf("unexpected token %q", ttok)
+                }
+
+        default:
+                return cty.NilType, fmt.Errorf("unsupported JSON token %#v", tok)
+        }
+}
+
+func impliedObjectType(dec *json.Decoder) (cty.Type, error) {
+        // By the time we get in here, we've already consumed the { delimiter
+        // and so our next token should be the first object key.
+
+        var atys map[string]cty.Type
+
+        for {
+                // Read the object key first
+                tok, err := dec.Token()
+                if err != nil {
+                        return cty.NilType, err
+                }
+
+                if ttok, ok := tok.(json.Delim); ok {
+                        if rune(ttok) != '}' {
+                                return cty.NilType, fmt.Errorf("unexpected delimiter %q", ttok)
+                        }
+                        break
+                }
+
+                key, ok := tok.(string)
+                if !ok {
+                        return cty.NilType, fmt.Errorf("expected string but found %T", tok)
+                }
+
+                // Now read the value
+                tok, err = dec.Token()
+                if err != nil {
+                        return cty.NilType, err
+                }
+
+                aty, err := impliedTypeForTok(tok, dec)
+                if err != nil {
+                        return cty.NilType, err
+                }
+
+                if atys == nil {
+                        atys = make(map[string]cty.Type)
+                }
+                atys[key] = aty
+        }
+
+        if len(atys) == 0 {
+                return cty.EmptyObject, nil
+        }
+
+        return cty.Object(atys), nil
+}
+
+func impliedTupleType(dec *json.Decoder) (cty.Type, error) {
+        // By the time we get in here, we've already consumed the { delimiter
+        // and so our next token should be the first value.
+
+        var etys []cty.Type
+
+        for {
+                tok, err := dec.Token()
+                if err != nil {
+                        return cty.NilType, err
+                }
+
+                if ttok, ok := tok.(json.Delim); ok {
+                        if rune(ttok) != ']' {
+                                return cty.NilType, fmt.Errorf("unexpected delimiter %q", ttok)
+                        }
+                        break
+                }
+
+                ety, err := impliedTypeForTok(tok, dec)
+                if err != nil {
+                        return cty.NilType, err
+                }
+                etys = append(etys, ety)
+        }
+
+        if len(etys) == 0 {
+                return cty.EmptyTuple, nil
+        }
+
+        return cty.Tuple(etys), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/unmarshal.go b/vendor/github.com/zclconf/go-cty/cty/json/unmarshal.go
new file mode 100644
index 0000000..155f0b8
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/unmarshal.go
@@ -0,0 +1,459 @@
+package json
+
+import (
+        "bytes"
+        "encoding/json"
+        "fmt"
+        "reflect"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/convert"
+)
+
+func unmarshal(buf []byte, t cty.Type, path cty.Path) (cty.Value, error) {
+        dec := bufDecoder(buf)
+
+        tok, err := dec.Token()
+        if err != nil {
+                return cty.NilVal, path.NewError(err)
+        }
+
+        if tok == nil {
+                return cty.NullVal(t), nil
+        }
+
+        if t == cty.DynamicPseudoType {
+                return unmarshalDynamic(buf, path)
+        }
+
+        switch {
+        case t.IsPrimitiveType():
+                val, err := unmarshalPrimitive(tok, t, path)
+                if err != nil {
+                        return cty.NilVal, err
+                }
+                return val, nil
+        case t.IsListType():
+                return unmarshalList(buf, t.ElementType(), path)
+        case t.IsSetType():
+                return unmarshalSet(buf, t.ElementType(), path)
+        case t.IsMapType():
+                return unmarshalMap(buf, t.ElementType(), path)
+        case t.IsTupleType():
+                return unmarshalTuple(buf, t.TupleElementTypes(), path)
+        case t.IsObjectType():
+                return unmarshalObject(buf, t.AttributeTypes(), path)
+        case t.IsCapsuleType():
+                return unmarshalCapsule(buf, t, path)
+        default:
+                return cty.NilVal, path.NewErrorf("unsupported type %s", t.FriendlyName())
+        }
+}
+
+func unmarshalPrimitive(tok json.Token, t cty.Type, path cty.Path) (cty.Value, error) {
+
+        switch t {
+        case cty.Bool:
+                switch v := tok.(type) {
+                case bool:
+                        return cty.BoolVal(v), nil
+                case string:
+                        val, err := convert.Convert(cty.StringVal(v), t)
+                        if err != nil {
+                                return cty.NilVal, path.NewError(err)
+                        }
+                        return val, nil
+                default:
+                        return cty.NilVal, path.NewErrorf("bool is required")
+                }
+        case cty.Number:
+                if v, ok := tok.(json.Number); ok {
+                        tok = string(v)
+                }
+                switch v := tok.(type) {
+                case string:
+                        val, err := convert.Convert(cty.StringVal(v), t)
+                        if err != nil {
+                                return cty.NilVal, path.NewError(err)
+                        }
+                        return val, nil
+                default:
+                        return cty.NilVal, path.NewErrorf("number is required")
+                }
+        case cty.String:
+                switch v := tok.(type) {
+                case string:
+                        return cty.StringVal(v), nil
+                case json.Number:
+                        return cty.StringVal(string(v)), nil
+                case bool:
+                        val, err := convert.Convert(cty.BoolVal(v), t)
+                        if err != nil {
+                                return cty.NilVal, path.NewError(err)
+                        }
+                        return val, nil
+                default:
+                        return cty.NilVal, path.NewErrorf("string is required")
+                }
+        default:
+                // should never happen
+                panic("unsupported primitive type")
+        }
+}
+
+func unmarshalList(buf []byte, ety cty.Type, path cty.Path) (cty.Value, error) {
+        dec := bufDecoder(buf)
+        if err := requireDelim(dec, '['); err != nil {
+                return cty.NilVal, path.NewError(err)
+        }
+
+        var vals []cty.Value
+
+        {
+                path := append(path, nil)
+                var idx int64
+
+                for dec.More() {
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: cty.NumberIntVal(idx),
+                        }
+                        idx++
+
+                        rawVal, err := readRawValue(dec)
+                        if err != nil {
+                                return cty.NilVal, path.NewErrorf("failed to read list value: %s", err)
+                        }
+
+                        el, err := unmarshal(rawVal, ety, path)
+                        if err != nil {
+                                return cty.NilVal, err
+                        }
+
+                        vals = append(vals, el)
+                }
+        }
+
+        if err := requireDelim(dec, ']'); err != nil {
+                return cty.NilVal, path.NewError(err)
+        }
+
+        if len(vals) == 0 {
+                return cty.ListValEmpty(ety), nil
+        }
+
+        return cty.ListVal(vals), nil
+}
+
+func unmarshalSet(buf []byte, ety cty.Type, path cty.Path) (cty.Value, error) {
+        dec := bufDecoder(buf)
+        if err := requireDelim(dec, '['); err != nil {
+                return cty.NilVal, path.NewError(err)
+        }
+
+        var vals []cty.Value
+
+        {
+                path := append(path, nil)
+
+                for dec.More() {
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: cty.UnknownVal(ety),
+                        }
+
+                        rawVal, err := readRawValue(dec)
+                        if err != nil {
+                                return cty.NilVal, path.NewErrorf("failed to read set value: %s", err)
+                        }
+
+                        el, err := unmarshal(rawVal, ety, path)
+                        if err != nil {
+                                return cty.NilVal, err
+                        }
+
+                        vals = append(vals, el)
+                }
+        }
+
+        if err := requireDelim(dec, ']'); err != nil {
+                return cty.NilVal, path.NewError(err)
+        }
+
+        if len(vals) == 0 {
+                return cty.SetValEmpty(ety), nil
+        }
+
+        return cty.SetVal(vals), nil
+}
+
+func unmarshalMap(buf []byte, ety cty.Type, path cty.Path) (cty.Value, error) {
+        dec := bufDecoder(buf)
+        if err := requireDelim(dec, '{'); err != nil {
+                return cty.NilVal, path.NewError(err)
+        }
+
+        vals := make(map[string]cty.Value)
+
+        {
+                path := append(path, nil)
+
+                for dec.More() {
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: cty.UnknownVal(cty.String),
+                        }
+
+                        var err error
+
+                        k, err := requireObjectKey(dec)
+                        if err != nil {
+                                return cty.NilVal, path.NewErrorf("failed to read map key: %s", err)
+                        }
+
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: cty.StringVal(k),
+                        }
+
+                        rawVal, err := readRawValue(dec)
+                        if err != nil {
+                                return cty.NilVal, path.NewErrorf("failed to read map value: %s", err)
+                        }
+
+                        el, err := unmarshal(rawVal, ety, path)
+                        if err != nil {
+                                return cty.NilVal, err
+                        }
+
+                        vals[k] = el
+                }
+        }
+
+        if err := requireDelim(dec, '}'); err != nil {
+                return cty.NilVal, path.NewError(err)
+        }
+
+        if len(vals) == 0 {
+                return cty.MapValEmpty(ety), nil
+        }
+
+        return cty.MapVal(vals), nil
+}
+
+func unmarshalTuple(buf []byte, etys []cty.Type, path cty.Path) (cty.Value, error) {
+        dec := bufDecoder(buf)
+        if err := requireDelim(dec, '['); err != nil {
+                return cty.NilVal, path.NewError(err)
+        }
+
+        var vals []cty.Value
+
+        {
+                path := append(path, nil)
+                var idx int
+
+                for dec.More() {
+                        if idx >= len(etys) {
+                                return cty.NilVal, path[:len(path)-1].NewErrorf("too many tuple elements (need %d)", len(etys))
+                        }
+
+                        path[len(path)-1] = cty.IndexStep{
+                                Key: cty.NumberIntVal(int64(idx)),
+                        }
+                        ety := etys[idx]
+                        idx++
+
+                        rawVal, err := readRawValue(dec)
+                        if err != nil {
+                                return cty.NilVal, path.NewErrorf("failed to read tuple value: %s", err)
+                        }
+
+                        el, err := unmarshal(rawVal, ety, path)
+                        if err != nil {
+                                return cty.NilVal, err
+                        }
+
+                        vals = append(vals, el)
+                }
+        }
+
+        if err := requireDelim(dec, ']'); err != nil {
+                return cty.NilVal, path.NewError(err)
+        }
+
+        if len(vals) != len(etys) {
+                return cty.NilVal, path[:len(path)-1].NewErrorf("not enough tuple elements (need %d)", len(etys))
+        }
+
+        if len(vals) == 0 {
+                return cty.EmptyTupleVal, nil
+        }
+
+        return cty.TupleVal(vals), nil
+}
+
+func unmarshalObject(buf []byte, atys map[string]cty.Type, path cty.Path) (cty.Value, error) {
+        dec := bufDecoder(buf)
+        if err := requireDelim(dec, '{'); err != nil {
+                return cty.NilVal, path.NewError(err)
+        }
+
+        vals := make(map[string]cty.Value)
+
+        {
+                objPath := path           // some errors report from the object's perspective
+                path := append(path, nil) // path to a specific attribute
+
+                for dec.More() {
+
+                        var err error
+
+                        k, err := requireObjectKey(dec)
+                        if err != nil {
+                                return cty.NilVal, path.NewErrorf("failed to read object key: %s", err)
+                        }
+
+                        aty, ok := atys[k]
+                        if !ok {
+                                return cty.NilVal, objPath.NewErrorf("unsupported attribute %q", k)
+                        }
+
+                        path[len(path)-1] = cty.GetAttrStep{
+                                Name: k,
+                        }
+
+                        rawVal, err := readRawValue(dec)
+                        if err != nil {
+                                return cty.NilVal, path.NewErrorf("failed to read object value: %s", err)
+                        }
+
+                        el, err := unmarshal(rawVal, aty, path)
+                        if err != nil {
+                                return cty.NilVal, err
+                        }
+
+                        vals[k] = el
+                }
+        }
+
+        if err := requireDelim(dec, '}'); err != nil {
+                return cty.NilVal, path.NewError(err)
+        }
+
+        // Make sure we have a value for every attribute
+        for k, aty := range atys {
+                if _, exists := vals[k]; !exists {
+                        vals[k] = cty.NullVal(aty)
+                }
+        }
+
+        if len(vals) == 0 {
+                return cty.EmptyObjectVal, nil
+        }
+
+        return cty.ObjectVal(vals), nil
+}
+
+func unmarshalCapsule(buf []byte, t cty.Type, path cty.Path) (cty.Value, error) {
+        rawType := t.EncapsulatedType()
+        ptrPtr := reflect.New(reflect.PtrTo(rawType))
+        ptrPtr.Elem().Set(reflect.New(rawType))
+        ptr := ptrPtr.Elem().Interface()
+        err := json.Unmarshal(buf, ptr)
+        if err != nil {
+                return cty.NilVal, path.NewError(err)
+        }
+
+        return cty.CapsuleVal(t, ptr), nil
+}
+
+func unmarshalDynamic(buf []byte, path cty.Path) (cty.Value, error) {
+        dec := bufDecoder(buf)
+        if err := requireDelim(dec, '{'); err != nil {
+                return cty.NilVal, path.NewError(err)
+        }
+
+        var t cty.Type
+        var valBody []byte // defer actual decoding until we know the type
+
+        for dec.More() {
+                var err error
+
+                key, err := requireObjectKey(dec)
+                if err != nil {
+                        return cty.NilVal, path.NewErrorf("failed to read dynamic type descriptor key: %s", err)
+                }
+
+                rawVal, err := readRawValue(dec)
+                if err != nil {
+                        return cty.NilVal, path.NewErrorf("failed to read dynamic type descriptor value: %s", err)
+                }
+
+                switch key {
+                case "type":
+                        err := json.Unmarshal(rawVal, &t)
+                        if err != nil {
+                                return cty.NilVal, path.NewErrorf("failed to decode type for dynamic value: %s", err)
+                        }
+                case "value":
+                        valBody = rawVal
+                default:
+                        return cty.NilVal, path.NewErrorf("invalid key %q in dynamically-typed value", key)
+                }
+
+        }
+
+        if err := requireDelim(dec, '}'); err != nil {
+                return cty.NilVal, path.NewError(err)
+        }
+
+        if t == cty.NilType {
+                return cty.NilVal, path.NewErrorf("missing type in dynamically-typed value")
+        }
+        if valBody == nil {
+                return cty.NilVal, path.NewErrorf("missing value in dynamically-typed value")
+        }
+
+        val, err := Unmarshal([]byte(valBody), t)
+        if err != nil {
+                return cty.NilVal, path.NewError(err)
+        }
+        return val, nil
+}
+
+func requireDelim(dec *json.Decoder, d rune) error {
+        tok, err := dec.Token()
+        if err != nil {
+                return err
+        }
+
+        if tok != json.Delim(d) {
+                return fmt.Errorf("missing expected %c", d)
+        }
+
+        return nil
+}
+
+func requireObjectKey(dec *json.Decoder) (string, error) {
+        tok, err := dec.Token()
+        if err != nil {
+                return "", err
+        }
+        if s, ok := tok.(string); ok {
+                return s, nil
+        }
+        return "", fmt.Errorf("missing expected object key")
+}
+
+func readRawValue(dec *json.Decoder) ([]byte, error) {
+        var rawVal json.RawMessage
+        err := dec.Decode(&rawVal)
+        if err != nil {
+                return nil, err
+        }
+        return []byte(rawVal), nil
+}
+
+func bufDecoder(buf []byte) *json.Decoder {
+        r := bytes.NewReader(buf)
+        dec := json.NewDecoder(r)
+        dec.UseNumber()
+        return dec
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/value.go b/vendor/github.com/zclconf/go-cty/cty/json/value.go
new file mode 100644
index 0000000..f2f7dd5
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/value.go
@@ -0,0 +1,65 @@
+package json
+
+import (
+        "bytes"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/convert"
+)
+
+// Marshal produces a JSON representation of the given value that can later
+// be decoded into a value of the given type.
+//
+// A type is specified separately to allow for the given type to include
+// cty.DynamicPseudoType to represent situations where any type is permitted
+// and so type information must be included to allow recovery of the stored
+// structure when decoding.
+//
+// The given type will also be used to attempt automatic conversions of any
+// non-conformant types in the given value, although this will not always
+// be possible. If the value cannot be made to be conformant then an error is
+// returned, which may be a cty.PathError.
+//
+// Capsule-typed values can be marshalled, but with some caveats. Since
+// capsule values are compared by pointer equality, it is impossible to recover
+// a value that will compare equal to the original value. Additionally,
+// it's not possible to JSON-serialize the capsule type itself, so it's not
+// valid to use capsule types within parts of the value that are conformed to
+// cty.DynamicPseudoType. Otherwise, a capsule value can be used as long as
+// the encapsulated type itself is serializable with the Marshal function
+// in encoding/json.
+func Marshal(val cty.Value, t cty.Type) ([]byte, error) {
+        errs := val.Type().TestConformance(t)
+        if errs != nil {
+                // Attempt a conversion
+                var err error
+                val, err = convert.Convert(val, t)
+                if err != nil {
+                        return nil, err
+                }
+        }
+
+        // From this point onward, val can be assumed to be conforming to t.
+
+        buf := &bytes.Buffer{}
+        var path cty.Path
+        err := marshal(val, t, path, buf)
+
+        if err != nil {
+                return nil, err
+        }
+
+        return buf.Bytes(), nil
+}
+
+// Unmarshal decodes a JSON representation of the given value into a cty Value
+// conforming to the given type.
+//
+// While decoding, type conversions will be done where possible to make
+// the result conformant even if the types given in JSON are not exactly
+// correct. If conversion isn't possible then an error is returned, which
+// may be a cty.PathError.
+func Unmarshal(buf []byte, t cty.Type) (cty.Value, error) {
+        var path cty.Path
+        return unmarshal(buf, t, path)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/list_type.go b/vendor/github.com/zclconf/go-cty/cty/list_type.go
new file mode 100644
index 0000000..eadc865
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/list_type.go
@@ -0,0 +1,68 @@
+package cty
+
+import (
+        "fmt"
+)
+
+// TypeList instances represent specific list types. Each distinct ElementType
+// creates a distinct, non-equal list type.
+type typeList struct {
+        typeImplSigil
+        ElementTypeT Type
+}
+
+// List creates a map type with the given element Type.
+//
+// List types are CollectionType implementations.
+func List(elem Type) Type {
+        return Type{
+                typeList{
+                        ElementTypeT: elem,
+                },
+        }
+}
+
+// Equals returns true if the other Type is a list whose element type is
+// equal to that of the receiver.
+func (t typeList) Equals(other Type) bool {
+        ot, isList := other.typeImpl.(typeList)
+        if !isList {
+                return false
+        }
+
+        return t.ElementTypeT.Equals(ot.ElementTypeT)
+}
+
+func (t typeList) FriendlyName() string {
+        return "list of " + t.ElementTypeT.FriendlyName()
+}
+
+func (t typeList) ElementType() Type {
+        return t.ElementTypeT
+}
+
+func (t typeList) GoString() string {
+        return fmt.Sprintf("cty.List(%#v)", t.ElementTypeT)
+}
+
+// IsListType returns true if the given type is a list type, regardless of its
+// element type.
+func (t Type) IsListType() bool {
+        _, ok := t.typeImpl.(typeList)
+        return ok
+}
+
+// ListElementType is a convenience method that checks if the given type is
+// a list type, returning a pointer to its element type if so and nil
+// otherwise. This is intended to allow convenient conditional branches,
+// like so:
+//
+//     if et := t.ListElementType(); et != nil {
+//         // Do something with *et
+//     }
+func (t Type) ListElementType() *Type {
+        if lt, ok := t.typeImpl.(typeList); ok {
+                return &lt.ElementTypeT
+        }
+        return nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/map_type.go b/vendor/github.com/zclconf/go-cty/cty/map_type.go
new file mode 100644
index 0000000..ae9abae
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/map_type.go
@@ -0,0 +1,68 @@
+package cty
+
+import (
+        "fmt"
+)
+
+// TypeList instances represent specific list types. Each distinct ElementType
+// creates a distinct, non-equal list type.
+type typeMap struct {
+        typeImplSigil
+        ElementTypeT Type
+}
+
+// Map creates a map type with the given element Type.
+//
+// Map types are CollectionType implementations.
+func Map(elem Type) Type {
+        return Type{
+                typeMap{
+                        ElementTypeT: elem,
+                },
+        }
+}
+
+// Equals returns true if the other Type is a map whose element type is
+// equal to that of the receiver.
+func (t typeMap) Equals(other Type) bool {
+        ot, isMap := other.typeImpl.(typeMap)
+        if !isMap {
+                return false
+        }
+
+        return t.ElementTypeT.Equals(ot.ElementTypeT)
+}
+
+func (t typeMap) FriendlyName() string {
+        return "map of " + t.ElementTypeT.FriendlyName()
+}
+
+func (t typeMap) ElementType() Type {
+        return t.ElementTypeT
+}
+
+func (t typeMap) GoString() string {
+        return fmt.Sprintf("cty.Map(%#v)", t.ElementTypeT)
+}
+
+// IsMapType returns true if the given type is a list type, regardless of its
+// element type.
+func (t Type) IsMapType() bool {
+        _, ok := t.typeImpl.(typeMap)
+        return ok
+}
+
+// MapElementType is a convenience method that checks if the given type is
+// a map type, returning a pointer to its element type if so and nil
+// otherwise. This is intended to allow convenient conditional branches,
+// like so:
+//
+//     if et := t.MapElementType(); et != nil {
+//         // Do something with *et
+//     }
+func (t Type) MapElementType() *Type {
+        if lt, ok := t.typeImpl.(typeMap); ok {
+                return &lt.ElementTypeT
+        }
+        return nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/null.go b/vendor/github.com/zclconf/go-cty/cty/null.go
new file mode 100644
index 0000000..d58d028
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/null.go
@@ -0,0 +1,14 @@
+package cty
+
+// NullVal returns a null value of the given type. A null can be created of any
+// type, but operations on such values will always panic. Calling applications
+// are encouraged to use nulls only sparingly, particularly when user-provided
+// expressions are to be evaluated, since the precence of nulls creates a
+// much higher chance of evaluation errors that can't be caught by a type
+// checker.
+func NullVal(t Type) Value {
+        return Value{
+                ty: t,
+                v:  nil,
+        }
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/object_type.go b/vendor/github.com/zclconf/go-cty/cty/object_type.go
new file mode 100644
index 0000000..2540883
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/object_type.go
@@ -0,0 +1,135 @@
+package cty
+
+import (
+        "fmt"
+)
+
+type typeObject struct {
+        typeImplSigil
+        AttrTypes map[string]Type
+}
+
+// Object creates an object type with the given attribute types.
+//
+// After a map is passed to this function the caller must no longer access it,
+// since ownership is transferred to this library.
+func Object(attrTypes map[string]Type) Type {
+        attrTypesNorm := make(map[string]Type, len(attrTypes))
+        for k, v := range attrTypes {
+                attrTypesNorm[NormalizeString(k)] = v
+        }
+
+        return Type{
+                typeObject{
+                        AttrTypes: attrTypesNorm,
+                },
+        }
+}
+
+func (t typeObject) Equals(other Type) bool {
+        if ot, ok := other.typeImpl.(typeObject); ok {
+                if len(t.AttrTypes) != len(ot.AttrTypes) {
+                        // Fast path: if we don't have the same number of attributes
+                        // then we can't possibly be equal. This also avoids the need
+                        // to test attributes in both directions below, since we know
+                        // there can't be extras in "other".
+                        return false
+                }
+
+                for attr, ty := range t.AttrTypes {
+                        oty, ok := ot.AttrTypes[attr]
+                        if !ok {
+                                return false
+                        }
+                        if !oty.Equals(ty) {
+                                return false
+                        }
+                }
+
+                return true
+        }
+        return false
+}
+
+func (t typeObject) FriendlyName() string {
+        // There isn't really a friendly way to write an object type due to its
+        // complexity, so we'll just do something English-ish. Callers will
+        // probably want to make some extra effort to avoid ever printing out
+        // an object type FriendlyName in its entirety. For example, could
+        // produce an error message by diffing two object types and saying
+        // something like "Expected attribute foo to be string, but got number".
+        // TODO: Finish this
+        return "object"
+}
+
+func (t typeObject) GoString() string {
+        if len(t.AttrTypes) == 0 {
+                return "cty.EmptyObject"
+        }
+        return fmt.Sprintf("cty.Object(%#v)", t.AttrTypes)
+}
+
+// EmptyObject is a shorthand for Object(map[string]Type{}), to more
+// easily talk about the empty object type.
+var EmptyObject Type
+
+// EmptyObjectVal is the only possible non-null, non-unknown value of type
+// EmptyObject.
+var EmptyObjectVal Value
+
+func init() {
+        EmptyObject = Object(map[string]Type{})
+        EmptyObjectVal = Value{
+                ty: EmptyObject,
+                v:  map[string]interface{}{},
+        }
+}
+
+// IsObjectType returns true if the given type is an object type, regardless
+// of its element type.
+func (t Type) IsObjectType() bool {
+        _, ok := t.typeImpl.(typeObject)
+        return ok
+}
+
+// HasAttribute returns true if the receiver has an attribute with the given
+// name, regardless of its type. Will panic if the reciever isn't an object
+// type; use IsObjectType to determine whether this operation will succeed.
+func (t Type) HasAttribute(name string) bool {
+        name = NormalizeString(name)
+        if ot, ok := t.typeImpl.(typeObject); ok {
+                _, hasAttr := ot.AttrTypes[name]
+                return hasAttr
+        }
+        panic("HasAttribute on non-object Type")
+}
+
+// AttributeType returns the type of the attribute with the given name. Will
+// panic if the receiver is not an object type (use IsObjectType to confirm)
+// or if the object type has no such attribute (use HasAttribute to confirm).
+func (t Type) AttributeType(name string) Type {
+        name = NormalizeString(name)
+        if ot, ok := t.typeImpl.(typeObject); ok {
+                aty, hasAttr := ot.AttrTypes[name]
+                if !hasAttr {
+                        panic("no such attribute")
+                }
+                return aty
+        }
+        panic("AttributeType on non-object Type")
+}
+
+// AttributeTypes returns a map from attribute names to their associated
+// types. Will panic if the receiver is not an object type (use IsObjectType
+// to confirm).
+//
+// The returned map is part of the internal state of the type, and is provided
+// for read access only. It is forbidden for any caller to modify the returned
+// map. For many purposes the attribute-related methods of Value are more
+// appropriate and more convenient to use.
+func (t Type) AttributeTypes() map[string]Type {
+        if ot, ok := t.typeImpl.(typeObject); ok {
+                return ot.AttrTypes
+        }
+        panic("AttributeTypes on non-object Type")
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/path.go b/vendor/github.com/zclconf/go-cty/cty/path.go
new file mode 100644
index 0000000..84a9de0
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/path.go
@@ -0,0 +1,186 @@
+package cty
+
+import (
+        "errors"
+        "fmt"
+)
+
+// A Path is a sequence of operations to locate a nested value within a
+// data structure.
+//
+// The empty Path represents the given item. Any PathSteps within represent
+// taking a single step down into a data structure.
+//
+// Path has some convenience methods for gradually constructing a path,
+// but callers can also feel free to just produce a slice of PathStep manually
+// and convert to this type, which may be more appropriate in environments
+// where memory pressure is a concern.
+type Path []PathStep
+
+// PathStep represents a single step down into a data structure, as part
+// of a Path. PathStep is a closed interface, meaning that the only
+// permitted implementations are those within this package.
+type PathStep interface {
+        pathStepSigil() pathStepImpl
+        Apply(Value) (Value, error)
+}
+
+// embed pathImpl into a struct to declare it a PathStep implementation
+type pathStepImpl struct{}
+
+func (p pathStepImpl) pathStepSigil() pathStepImpl {
+        return p
+}
+
+// Index returns a new Path that is the reciever with an IndexStep appended
+// to the end.
+//
+// This is provided as a convenient way to construct paths, but each call
+// will create garbage so it should not be used where memory pressure is a
+// concern.
+func (p Path) Index(v Value) Path {
+        ret := make(Path, len(p)+1)
+        copy(ret, p)
+        ret[len(p)] = IndexStep{
+                Key: v,
+        }
+        return ret
+}
+
+// GetAttr returns a new Path that is the reciever with a GetAttrStep appended
+// to the end.
+//
+// This is provided as a convenient way to construct paths, but each call
+// will create garbage so it should not be used where memory pressure is a
+// concern.
+func (p Path) GetAttr(name string) Path {
+        ret := make(Path, len(p)+1)
+        copy(ret, p)
+        ret[len(p)] = GetAttrStep{
+                Name: name,
+        }
+        return ret
+}
+
+// Apply applies each of the steps in turn to successive values starting with
+// the given value, and returns the result. If any step returns an error,
+// the whole operation returns an error.
+func (p Path) Apply(val Value) (Value, error) {
+        var err error
+        for i, step := range p {
+                val, err = step.Apply(val)
+                if err != nil {
+                        return NilVal, fmt.Errorf("at step %d: %s", i, err)
+                }
+        }
+        return val, nil
+}
+
+// LastStep applies the given path up to the last step and then returns
+// the resulting value and the final step.
+//
+// This is useful when dealing with assignment operations, since in that
+// case the *value* of the last step is not important (and may not, in fact,
+// present at all) and we care only about its location.
+//
+// Since LastStep applies all steps except the last, it will return errors
+// for those steps in the same way as Apply does.
+//
+// If the path has *no* steps then the returned PathStep will be nil,
+// representing that any operation should be applied directly to the
+// given value.
+func (p Path) LastStep(val Value) (Value, PathStep, error) {
+        var err error
+
+        if len(p) == 0 {
+                return val, nil, nil
+        }
+
+        journey := p[:len(p)-1]
+        val, err = journey.Apply(val)
+        if err != nil {
+                return NilVal, nil, err
+        }
+        return val, p[len(p)-1], nil
+}
+
+// Copy makes a shallow copy of the receiver. Often when paths are passed to
+// caller code they come with the constraint that they are valid only until
+// the caller returns, due to how they are constructed internally. Callers
+// can use Copy to conveniently produce a copy of the value that _they_ control
+// the validity of.
+func (p Path) Copy() Path {
+        ret := make(Path, len(p))
+        copy(ret, p)
+        return ret
+}
+
+// IndexStep is a Step implementation representing applying the index operation
+// to a value, which must be of either a list, map, or set type.
+//
+// When describing a path through a *type* rather than a concrete value,
+// the Key may be an unknown value, indicating that the step applies to
+// *any* key of the given type.
+//
+// When indexing into a set, the Key is actually the element being accessed
+// itself, since in sets elements are their own identity.
+type IndexStep struct {
+        pathStepImpl
+        Key Value
+}
+
+// Apply returns the value resulting from indexing the given value with
+// our key value.
+func (s IndexStep) Apply(val Value) (Value, error) {
+        switch s.Key.Type() {
+        case Number:
+                if !val.Type().IsListType() {
+                        return NilVal, errors.New("not a list type")
+                }
+        case String:
+                if !val.Type().IsMapType() {
+                        return NilVal, errors.New("not a map type")
+                }
+        default:
+                return NilVal, errors.New("key value not number or string")
+        }
+
+        has := val.HasIndex(s.Key)
+        if !has.IsKnown() {
+                return UnknownVal(val.Type().ElementType()), nil
+        }
+        if !has.True() {
+                return NilVal, errors.New("value does not have given index key")
+        }
+
+        return val.Index(s.Key), nil
+}
+
+func (s IndexStep) GoString() string {
+        return fmt.Sprintf("cty.IndexStep{Key:%#v}", s.Key)
+}
+
+// GetAttrStep is a Step implementation representing retrieving an attribute
+// from a value, which must be of an object type.
+type GetAttrStep struct {
+        pathStepImpl
+        Name string
+}
+
+// Apply returns the value of our named attribute from the given value, which
+// must be of an object type that has a value of that name.
+func (s GetAttrStep) Apply(val Value) (Value, error) {
+        if !val.Type().IsObjectType() {
+                return NilVal, errors.New("not an object type")
+        }
+
+        if !val.Type().HasAttribute(s.Name) {
+                return NilVal, fmt.Errorf("object has no attribute %q", s.Name)
+        }
+
+        return val.GetAttr(s.Name), nil
+}
+
+func (s GetAttrStep) GoString() string {
+        return fmt.Sprintf("cty.GetAttrStep{Name:%q}", s.Name)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/primitive_type.go b/vendor/github.com/zclconf/go-cty/cty/primitive_type.go
new file mode 100644
index 0000000..b8682dd
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/primitive_type.go
@@ -0,0 +1,122 @@
+package cty
+
+import "math/big"
+
+// primitiveType is the hidden implementation of the various primitive types
+// that are exposed as variables in this package.
+type primitiveType struct {
+        typeImplSigil
+        Kind primitiveTypeKind
+}
+
+type primitiveTypeKind byte
+
+const (
+        primitiveTypeBool   primitiveTypeKind = 'B'
+        primitiveTypeNumber primitiveTypeKind = 'N'
+        primitiveTypeString primitiveTypeKind = 'S'
+)
+
+func (t primitiveType) Equals(other Type) bool {
+        if otherP, ok := other.typeImpl.(primitiveType); ok {
+                return otherP.Kind == t.Kind
+        }
+        return false
+}
+
+func (t primitiveType) FriendlyName() string {
+        switch t.Kind {
+        case primitiveTypeBool:
+                return "bool"
+        case primitiveTypeNumber:
+                return "number"
+        case primitiveTypeString:
+                return "string"
+        default:
+                // should never happen
+                panic("invalid primitive type")
+        }
+}
+
+func (t primitiveType) GoString() string {
+        switch t.Kind {
+        case primitiveTypeBool:
+                return "cty.Bool"
+        case primitiveTypeNumber:
+                return "cty.Number"
+        case primitiveTypeString:
+                return "cty.String"
+        default:
+                // should never happen
+                panic("invalid primitive type")
+        }
+}
+
+// Number is the numeric type. Number values are arbitrary-precision
+// decimal numbers, which can then be converted into Go's various numeric
+// types only if they are in the appropriate range.
+var Number Type
+
+// String is the string type. String values are sequences of unicode codepoints
+// encoded internally as UTF-8.
+var String Type
+
+// Bool is the boolean type. The two values of this type are True and False.
+var Bool Type
+
+// True is the truthy value of type Bool
+var True Value
+
+// False is the falsey value of type Bool
+var False Value
+
+// Zero is a number value representing exactly zero.
+var Zero Value
+
+// PositiveInfinity is a Number value representing positive infinity
+var PositiveInfinity Value
+
+// NegativeInfinity is a Number value representing negative infinity
+var NegativeInfinity Value
+
+func init() {
+        Number = Type{
+                primitiveType{Kind: primitiveTypeNumber},
+        }
+        String = Type{
+                primitiveType{Kind: primitiveTypeString},
+        }
+        Bool = Type{
+                primitiveType{Kind: primitiveTypeBool},
+        }
+        True = Value{
+                ty: Bool,
+                v:  true,
+        }
+        False = Value{
+                ty: Bool,
+                v:  false,
+        }
+        Zero = Value{
+                ty: Number,
+                v:  big.NewFloat(0),
+        }
+        PositiveInfinity = Value{
+                ty: Number,
+                v:  (&big.Float{}).SetInf(false),
+        }
+        NegativeInfinity = Value{
+                ty: Number,
+                v:  (&big.Float{}).SetInf(true),
+        }
+}
+
+// IsPrimitiveType returns true if and only if the reciever is a primitive
+// type, which means it's either number, string, or bool. Any two primitive
+// types can be safely compared for equality using the standard == operator
+// without panic, which is not a guarantee that holds for all types. Primitive
+// types can therefore also be used in switch statements.
+func (t Type) IsPrimitiveType() bool {
+        _, ok := t.typeImpl.(primitiveType)
+        return ok
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set/gob.go b/vendor/github.com/zclconf/go-cty/cty/set/gob.go
new file mode 100644
index 0000000..da2978f
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set/gob.go
@@ -0,0 +1,76 @@
+package set
+
+import (
+        "bytes"
+        "encoding/gob"
+        "fmt"
+)
+
+// GobEncode is an implementation of the interface gob.GobEncoder, allowing
+// sets to be included in structures encoded via gob.
+//
+// The set rules are included in the serialized value, so the caller must
+// register its concrete rules type with gob.Register before using a
+// set in a gob, and possibly also implement GobEncode/GobDecode to customize
+// how any parameters are persisted.
+//
+// The set elements are also included, so if they are of non-primitive types
+// they too must be registered with gob.
+//
+// If the produced gob values will persist for a long time, the caller must
+// ensure compatibility of the rules implementation. In particular, if the
+// definition of element equivalence changes between encoding and decoding
+// then two distinct stored elements may be considered equivalent on decoding,
+// causing the recovered set to have fewer elements than when it was stored.
+func (s Set) GobEncode() ([]byte, error) {
+        gs := gobSet{
+                Version: 0,
+                Rules:   s.rules,
+                Values:  s.Values(),
+        }
+
+        buf := &bytes.Buffer{}
+        enc := gob.NewEncoder(buf)
+        err := enc.Encode(gs)
+        if err != nil {
+                return nil, fmt.Errorf("error encoding set.Set: %s", err)
+        }
+
+        return buf.Bytes(), nil
+}
+
+// GobDecode is the opposite of GobEncode. See GobEncode for information
+// on the requirements for and caveats of including set values in gobs.
+func (s *Set) GobDecode(buf []byte) error {
+        r := bytes.NewReader(buf)
+        dec := gob.NewDecoder(r)
+
+        var gs gobSet
+        err := dec.Decode(&gs)
+        if err != nil {
+                return fmt.Errorf("error decoding set.Set: %s", err)
+        }
+        if gs.Version != 0 {
+                return fmt.Errorf("unsupported set.Set encoding version %d; need 0", gs.Version)
+        }
+
+        victim := NewSetFromSlice(gs.Rules, gs.Values)
+        s.vals = victim.vals
+        s.rules = victim.rules
+        return nil
+}
+
+type gobSet struct {
+        Version int
+        Rules   Rules
+
+        // The bucket-based representation is for efficient in-memory access, but
+        // for serialization it's enough to just retain the values themselves,
+        // which we can re-bucket using the rules (which may have changed!) when
+        // we re-inflate.
+        Values []interface{}
+}
+
+func init() {
+        gob.Register([]interface{}(nil))
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set/iterator.go b/vendor/github.com/zclconf/go-cty/cty/set/iterator.go
new file mode 100644
index 0000000..f15498e
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set/iterator.go
@@ -0,0 +1,36 @@
+package set
+
+type Iterator struct {
+        bucketIds []int
+        vals      map[int][]interface{}
+        bucketIdx int
+        valIdx    int
+}
+
+func (it *Iterator) Value() interface{} {
+        return it.currentBucket()[it.valIdx]
+}
+
+func (it *Iterator) Next() bool {
+        if it.bucketIdx == -1 {
+                // init
+                if len(it.bucketIds) == 0 {
+                        return false
+                }
+
+                it.valIdx = 0
+                it.bucketIdx = 0
+                return true
+        }
+
+        it.valIdx++
+        if it.valIdx >= len(it.currentBucket()) {
+                it.valIdx = 0
+                it.bucketIdx++
+        }
+        return it.bucketIdx < len(it.bucketIds)
+}
+
+func (it *Iterator) currentBucket() []interface{} {
+        return it.vals[it.bucketIds[it.bucketIdx]]
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set/ops.go b/vendor/github.com/zclconf/go-cty/cty/set/ops.go
new file mode 100644
index 0000000..726e707
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set/ops.go
@@ -0,0 +1,199 @@
+package set
+
+import (
+        "sort"
+)
+
+// Add inserts the given value into the receiving Set.
+//
+// This mutates the set in-place. This operation is not thread-safe.
+func (s Set) Add(val interface{}) {
+        hv := s.rules.Hash(val)
+        if _, ok := s.vals[hv]; !ok {
+                s.vals[hv] = make([]interface{}, 0, 1)
+        }
+        bucket := s.vals[hv]
+
+        // See if an equivalent value is already present
+        for _, ev := range bucket {
+                if s.rules.Equivalent(val, ev) {
+                        return
+                }
+        }
+
+        s.vals[hv] = append(bucket, val)
+}
+
+// Remove deletes the given value from the receiving set, if indeed it was
+// there in the first place. If the value is not present, this is a no-op.
+func (s Set) Remove(val interface{}) {
+        hv := s.rules.Hash(val)
+        bucket, ok := s.vals[hv]
+        if !ok {
+                return
+        }
+
+        for i, ev := range bucket {
+                if s.rules.Equivalent(val, ev) {
+                        newBucket := make([]interface{}, 0, len(bucket)-1)
+                        newBucket = append(newBucket, bucket[:i]...)
+                        newBucket = append(newBucket, bucket[i+1:]...)
+                        if len(newBucket) > 0 {
+                                s.vals[hv] = newBucket
+                        } else {
+                                delete(s.vals, hv)
+                        }
+                        return
+                }
+        }
+}
+
+// Has returns true if the given value is in the receiving set, or false if
+// it is not.
+func (s Set) Has(val interface{}) bool {
+        hv := s.rules.Hash(val)
+        bucket, ok := s.vals[hv]
+        if !ok {
+                return false
+        }
+
+        for _, ev := range bucket {
+                if s.rules.Equivalent(val, ev) {
+                        return true
+                }
+        }
+        return false
+}
+
+// Copy performs a shallow copy of the receiving set, returning a new set
+// with the same rules and elements.
+func (s Set) Copy() Set {
+        ret := NewSet(s.rules)
+        for k, v := range s.vals {
+                ret.vals[k] = v
+        }
+        return ret
+}
+
+// Iterator returns an iterator over values in the set, in an undefined order
+// that callers should not depend on.
+//
+// The pattern for using the returned iterator is:
+//
+//     it := set.Iterator()
+//     for it.Next() {
+//         val := it.Value()
+//         // ...
+//     }
+//
+// Once an iterator has been created for a set, the set *must not* be mutated
+// until the iterator is no longer in use.
+func (s Set) Iterator() *Iterator {
+        // Sort the bucketIds to ensure that we always traverse in a
+        // consistent order.
+        bucketIds := make([]int, 0, len(s.vals))
+        for id := range s.vals {
+                bucketIds = append(bucketIds, id)
+        }
+        sort.Ints(bucketIds)
+
+        return &Iterator{
+                bucketIds: bucketIds,
+                vals:      s.vals,
+                bucketIdx: -1,
+        }
+}
+
+// EachValue calls the given callback once for each value in the set, in an
+// undefined order that callers should not depend on.
+func (s Set) EachValue(cb func(interface{})) {
+        it := s.Iterator()
+        for it.Next() {
+                cb(it.Value())
+        }
+}
+
+// Values returns a slice of all of the values in the set in no particular
+// order. This is just a wrapper around EachValue that accumulates the results
+// in a slice for caller convenience.
+//
+// The returned slice will be nil if there are no values in the set.
+func (s Set) Values() []interface{} {
+        var ret []interface{}
+        s.EachValue(func(v interface{}) {
+                ret = append(ret, v)
+        })
+        return ret
+}
+
+// Length returns the number of values in the set.
+func (s Set) Length() int {
+        var count int
+        for _, bucket := range s.vals {
+                count = count + len(bucket)
+        }
+        return count
+}
+
+// Union returns a new set that contains all of the members of both the
+// receiving set and the given set. Both sets must have the same rules, or
+// else this function will panic.
+func (s1 Set) Union(s2 Set) Set {
+        mustHaveSameRules(s1, s2)
+        rs := NewSet(s1.rules)
+        s1.EachValue(func(v interface{}) {
+                rs.Add(v)
+        })
+        s2.EachValue(func(v interface{}) {
+                rs.Add(v)
+        })
+        return rs
+}
+
+// Intersection returns a new set that contains the values that both the
+// receiver and given sets have in common. Both sets must have the same rules,
+// or else this function will panic.
+func (s1 Set) Intersection(s2 Set) Set {
+        mustHaveSameRules(s1, s2)
+        rs := NewSet(s1.rules)
+        s1.EachValue(func(v interface{}) {
+                if s2.Has(v) {
+                        rs.Add(v)
+                }
+        })
+        return rs
+}
+
+// Subtract returns a new set that contains all of the values from the receiver
+// that are not also in the given set. Both sets must have the same rules,
+// or else this function will panic.
+func (s1 Set) Subtract(s2 Set) Set {
+        mustHaveSameRules(s1, s2)
+        rs := NewSet(s1.rules)
+        s1.EachValue(func(v interface{}) {
+                if !s2.Has(v) {
+                        rs.Add(v)
+                }
+        })
+        return rs
+}
+
+// SymmetricDifference returns a new set that contains all of the values from
+// both the receiver and given sets, except those that both sets have in
+// common. Both sets must have the same rules, or else this function will
+// panic.
+func (s1 Set) SymmetricDifference(s2 Set) Set {
+        mustHaveSameRules(s1, s2)
+        rs := NewSet(s1.rules)
+        s1.EachValue(func(v interface{}) {
+                if !s2.Has(v) {
+                        rs.Add(v)
+                }
+        })
+        s2.EachValue(func(v interface{}) {
+                if !s1.Has(v) {
+                        rs.Add(v)
+                }
+        })
+        return rs
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set/rules.go b/vendor/github.com/zclconf/go-cty/cty/set/rules.go
new file mode 100644
index 0000000..7200184
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set/rules.go
@@ -0,0 +1,25 @@
+package set
+
+// Rules represents the operations that define membership for a Set.
+//
+// Each Set has a Rules instance, whose methods must satisfy the interface
+// contracts given below for any value that will be added to the set.
+type Rules interface {
+        // Hash returns an int that somewhat-uniquely identifies the given value.
+        //
+        // A good hash function will minimize collisions for values that will be
+        // added to the set, though collisions *are* permitted. Collisions will
+        // simply reduce the efficiency of operations on the set.
+        Hash(interface{}) int
+
+        // Equivalent returns true if and only if the two values are considered
+        // equivalent for the sake of set membership. Two values that are
+        // equivalent cannot exist in the set at the same time, and if two
+        // equivalent values are added it is undefined which one will be
+        // returned when enumerating all of the set members.
+        //
+        // Two values that are equivalent *must* result in the same hash value,
+        // though it is *not* required that two values with the same hash value
+        // be equivalent.
+        Equivalent(interface{}, interface{}) bool
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set/set.go b/vendor/github.com/zclconf/go-cty/cty/set/set.go
new file mode 100644
index 0000000..b4fb316
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set/set.go
@@ -0,0 +1,62 @@
+package set
+
+import (
+        "fmt"
+)
+
+// Set is an implementation of the concept of a set: a collection where all
+// values are conceptually either in or out of the set, but the members are
+// not ordered.
+//
+// This type primarily exists to be the internal type of sets in cty, but
+// it is considered to be at the same level of abstraction as Go's built in
+// slice and map collection types, and so should make no cty-specific
+// assumptions.
+//
+// Set operations are not thread safe. It is the caller's responsibility to
+// provide mutex guarantees where necessary.
+//
+// Set operations are not optimized to minimize memory pressure. Mutating
+// a set will generally create garbage and so should perhaps be avoided in
+// tight loops where memory pressure is a concern.
+type Set struct {
+        vals  map[int][]interface{}
+        rules Rules
+}
+
+// NewSet returns an empty set with the membership rules given.
+func NewSet(rules Rules) Set {
+        return Set{
+                vals:  map[int][]interface{}{},
+                rules: rules,
+        }
+}
+
+func NewSetFromSlice(rules Rules, vals []interface{}) Set {
+        s := NewSet(rules)
+        for _, v := range vals {
+                s.Add(v)
+        }
+        return s
+}
+
+func sameRules(s1 Set, s2 Set) bool {
+        return s1.rules == s2.rules
+}
+
+func mustHaveSameRules(s1 Set, s2 Set) {
+        if !sameRules(s1, s2) {
+                panic(fmt.Errorf("incompatible set rules: %#v, %#v", s1.rules, s2.rules))
+        }
+}
+
+// HasRules returns true if and only if the receiving set has the given rules
+// instance as its rules.
+func (s Set) HasRules(rules Rules) bool {
+        return s.rules == rules
+}
+
+// Rules returns the receiving set's rules instance.
+func (s Set) Rules() Rules {
+        return s.rules
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set_helper.go b/vendor/github.com/zclconf/go-cty/cty/set_helper.go
new file mode 100644
index 0000000..a88ddaf
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set_helper.go
@@ -0,0 +1,126 @@
+package cty
+
+import (
+        "fmt"
+
+        "github.com/zclconf/go-cty/cty/set"
+)
+
+// ValueSet is to cty.Set what []cty.Value is to cty.List and
+// map[string]cty.Value is to cty.Map. It's provided to allow callers a
+// convenient interface for manipulating sets before wrapping them in cty.Set
+// values using cty.SetValFromValueSet.
+//
+// Unlike value slices and value maps, ValueSet instances have a single
+// homogenous element type because that is a requirement of the underlying
+// set implementation, which uses the element type to select a suitable
+// hashing function.
+//
+// Set mutations are not concurrency-safe.
+type ValueSet struct {
+        // ValueSet is just a thin wrapper around a set.Set with our value-oriented
+        // "rules" applied. We do this so that the caller can work in terms of
+        // cty.Value objects even though the set internals use the raw values.
+        s set.Set
+}
+
+// NewValueSet creates and returns a new ValueSet with the given element type.
+func NewValueSet(ety Type) ValueSet {
+        return newValueSet(set.NewSet(setRules{Type: ety}))
+}
+
+func newValueSet(s set.Set) ValueSet {
+        return ValueSet{
+                s: s,
+        }
+}
+
+// ElementType returns the element type for the receiving ValueSet.
+func (s ValueSet) ElementType() Type {
+        return s.s.Rules().(setRules).Type
+}
+
+// Add inserts the given value into the receiving set.
+func (s ValueSet) Add(v Value) {
+        s.requireElementType(v)
+        s.s.Add(v.v)
+}
+
+// Remove deletes the given value from the receiving set, if indeed it was
+// there in the first place. If the value is not present, this is a no-op.
+func (s ValueSet) Remove(v Value) {
+        s.requireElementType(v)
+        s.s.Remove(v.v)
+}
+
+// Has returns true if the given value is in the receiving set, or false if
+// it is not.
+func (s ValueSet) Has(v Value) bool {
+        s.requireElementType(v)
+        return s.s.Has(v.v)
+}
+
+// Copy performs a shallow copy of the receiving set, returning a new set
+// with the same rules and elements.
+func (s ValueSet) Copy() ValueSet {
+        return newValueSet(s.s.Copy())
+}
+
+// Length returns the number of values in the set.
+func (s ValueSet) Length() int {
+        return s.s.Length()
+}
+
+// Values returns a slice of all of the values in the set in no particular
+// order.
+func (s ValueSet) Values() []Value {
+        l := s.s.Length()
+        if l == 0 {
+                return nil
+        }
+        ret := make([]Value, 0, l)
+        ety := s.ElementType()
+        for it := s.s.Iterator(); it.Next(); {
+                ret = append(ret, Value{
+                        ty: ety,
+                        v:  it.Value(),
+                })
+        }
+        return ret
+}
+
+// Union returns a new set that contains all of the members of both the
+// receiving set and the given set. Both sets must have the same element type,
+// or else this function will panic.
+func (s ValueSet) Union(other ValueSet) ValueSet {
+        return newValueSet(s.s.Union(other.s))
+}
+
+// Intersection returns a new set that contains the values that both the
+// receiver and given sets have in common. Both sets must have the same element
+// type, or else this function will panic.
+func (s ValueSet) Intersection(other ValueSet) ValueSet {
+        return newValueSet(s.s.Intersection(other.s))
+}
+
+// Subtract returns a new set that contains all of the values from the receiver
+// that are not also in the given set. Both sets must have the same element
+// type, or else this function will panic.
+func (s ValueSet) Subtract(other ValueSet) ValueSet {
+        return newValueSet(s.s.Subtract(other.s))
+}
+
+// SymmetricDifference returns a new set that contains all of the values from
+// both the receiver and given sets, except those that both sets have in
+// common. Both sets must have the same element type, or else this function
+// will panic.
+func (s ValueSet) SymmetricDifference(other ValueSet) ValueSet {
+        return newValueSet(s.s.SymmetricDifference(other.s))
+}
+
+// requireElementType panics if the given value is not of the set's element type.
+func (s ValueSet) requireElementType(v Value) {
+        if !v.Type().Equals(s.ElementType()) {
+                panic(fmt.Errorf("attempt to use %#v value with set of %#v", v.Type(), s.ElementType()))
+        }
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set_internals.go b/vendor/github.com/zclconf/go-cty/cty/set_internals.go
new file mode 100644
index 0000000..ce738db
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set_internals.go
@@ -0,0 +1,146 @@
+package cty
+
+import (
+        "bytes"
+        "fmt"
+        "hash/crc32"
+        "math/big"
+        "sort"
+)
+
+// setRules provides a Rules implementation for the ./set package that
+// respects the equality rules for cty values of the given type.
+//
+// This implementation expects that values added to the set will be
+// valid internal values for the given Type, which is to say that wrapping
+// the given value in a Value struct along with the ruleset's type should
+// produce a valid, working Value.
+type setRules struct {
+        Type Type
+}
+
+func (r setRules) Hash(v interface{}) int {
+        hashBytes := makeSetHashBytes(Value{
+                ty: r.Type,
+                v:  v,
+        })
+        return int(crc32.ChecksumIEEE(hashBytes))
+}
+
+func (r setRules) Equivalent(v1 interface{}, v2 interface{}) bool {
+        v1v := Value{
+                ty: r.Type,
+                v:  v1,
+        }
+        v2v := Value{
+                ty: r.Type,
+                v:  v2,
+        }
+
+        eqv := v1v.Equals(v2v)
+
+        // By comparing the result to true we ensure that an Unknown result,
+        // which will result if either value is unknown, will be considered
+        // as non-equivalent. Two unknown values are not equivalent for the
+        // sake of set membership.
+        return eqv.v == true
+}
+
+func makeSetHashBytes(val Value) []byte {
+        var buf bytes.Buffer
+        appendSetHashBytes(val, &buf)
+        return buf.Bytes()
+}
+
+func appendSetHashBytes(val Value, buf *bytes.Buffer) {
+        // Exactly what bytes we generate here don't matter as long as the following
+        // constraints hold:
+        // - Unknown and null values all generate distinct strings from
+        //   each other and from any normal value of the given type.
+        // - The delimiter used to separate items in a compound structure can
+        //   never appear literally in any of its elements.
+        // Since we don't support hetrogenous lists we don't need to worry about
+        // collisions between values of different types, apart from
+        // PseudoTypeDynamic.
+        // If in practice we *do* get a collision then it's not a big deal because
+        // the Equivalent function will still distinguish values, but set
+        // performance will be best if we are able to produce a distinct string
+        // for each distinct value, unknown values notwithstanding.
+        if !val.IsKnown() {
+                buf.WriteRune('?')
+                return
+        }
+        if val.IsNull() {
+                buf.WriteRune('~')
+                return
+        }
+
+        switch val.ty {
+        case Number:
+                buf.WriteString(val.v.(*big.Float).String())
+                return
+        case Bool:
+                if val.v.(bool) {
+                        buf.WriteRune('T')
+                } else {
+                        buf.WriteRune('F')
+                }
+                return
+        case String:
+                buf.WriteString(fmt.Sprintf("%q", val.v.(string)))
+                return
+        }
+
+        if val.ty.IsMapType() {
+                buf.WriteRune('{')
+                val.ForEachElement(func(keyVal, elementVal Value) bool {
+                        appendSetHashBytes(keyVal, buf)
+                        buf.WriteRune(':')
+                        appendSetHashBytes(elementVal, buf)
+                        buf.WriteRune(';')
+                        return false
+                })
+                buf.WriteRune('}')
+                return
+        }
+
+        if val.ty.IsListType() || val.ty.IsSetType() {
+                buf.WriteRune('[')
+                val.ForEachElement(func(keyVal, elementVal Value) bool {
+                        appendSetHashBytes(elementVal, buf)
+                        buf.WriteRune(';')
+                        return false
+                })
+                buf.WriteRune(']')
+                return
+        }
+
+        if val.ty.IsObjectType() {
+                buf.WriteRune('<')
+                attrNames := make([]string, 0, len(val.ty.AttributeTypes()))
+                for attrName := range val.ty.AttributeTypes() {
+                        attrNames = append(attrNames, attrName)
+                }
+                sort.Strings(attrNames)
+                for _, attrName := range attrNames {
+                        appendSetHashBytes(val.GetAttr(attrName), buf)
+                        buf.WriteRune(';')
+                }
+                buf.WriteRune('>')
+                return
+        }
+
+        if val.ty.IsTupleType() {
+                buf.WriteRune('<')
+                val.ForEachElement(func(keyVal, elementVal Value) bool {
+                        appendSetHashBytes(elementVal, buf)
+                        buf.WriteRune(';')
+                        return false
+                })
+                buf.WriteRune('>')
+                return
+        }
+
+        // should never get down here
+        panic("unsupported type in set hash")
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set_type.go b/vendor/github.com/zclconf/go-cty/cty/set_type.go
new file mode 100644
index 0000000..952a2d2
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set_type.go
@@ -0,0 +1,66 @@
+package cty
+
+import (
+        "fmt"
+)
+
+type typeSet struct {
+        typeImplSigil
+        ElementTypeT Type
+}
+
+// Set creates a set type with the given element Type.
+//
+// Set types are CollectionType implementations.
+func Set(elem Type) Type {
+        return Type{
+                typeSet{
+                        ElementTypeT: elem,
+                },
+        }
+}
+
+// Equals returns true if the other Type is a set whose element type is
+// equal to that of the receiver.
+func (t typeSet) Equals(other Type) bool {
+        ot, isSet := other.typeImpl.(typeSet)
+        if !isSet {
+                return false
+        }
+
+        return t.ElementTypeT.Equals(ot.ElementTypeT)
+}
+
+func (t typeSet) FriendlyName() string {
+        return "set of " + t.ElementTypeT.FriendlyName()
+}
+
+func (t typeSet) ElementType() Type {
+        return t.ElementTypeT
+}
+
+func (t typeSet) GoString() string {
+        return fmt.Sprintf("cty.Set(%#v)", t.ElementTypeT)
+}
+
+// IsSetType returns true if the given type is a list type, regardless of its
+// element type.
+func (t Type) IsSetType() bool {
+        _, ok := t.typeImpl.(typeSet)
+        return ok
+}
+
+// SetElementType is a convenience method that checks if the given type is
+// a set type, returning a pointer to its element type if so and nil
+// otherwise. This is intended to allow convenient conditional branches,
+// like so:
+//
+//     if et := t.SetElementType(); et != nil {
+//         // Do something with *et
+//     }
+func (t Type) SetElementType() *Type {
+        if lt, ok := t.typeImpl.(typeSet); ok {
+                return &lt.ElementTypeT
+        }
+        return nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/tuple_type.go b/vendor/github.com/zclconf/go-cty/cty/tuple_type.go
new file mode 100644
index 0000000..b98349e
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/tuple_type.go
@@ -0,0 +1,121 @@
+package cty
+
+import (
+        "fmt"
+)
+
+type typeTuple struct {
+        typeImplSigil
+        ElemTypes []Type
+}
+
+// Tuple creates a tuple type with the given element types.
+//
+// After a slice is passed to this function the caller must no longer access
+// the underlying array, since ownership is transferred to this library.
+func Tuple(elemTypes []Type) Type {
+        return Type{
+                typeTuple{
+                        ElemTypes: elemTypes,
+                },
+        }
+}
+
+func (t typeTuple) Equals(other Type) bool {
+        if ot, ok := other.typeImpl.(typeTuple); ok {
+                if len(t.ElemTypes) != len(ot.ElemTypes) {
+                        // Fast path: if we don't have the same number of elements
+                        // then we can't possibly be equal.
+                        return false
+                }
+
+                for i, ty := range t.ElemTypes {
+                        oty := ot.ElemTypes[i]
+                        if !ok {
+                                return false
+                        }
+                        if !oty.Equals(ty) {
+                                return false
+                        }
+                }
+
+                return true
+        }
+        return false
+}
+
+func (t typeTuple) FriendlyName() string {
+        // There isn't really a friendly way to write a tuple type due to its
+        // complexity, so we'll just do something English-ish. Callers will
+        // probably want to make some extra effort to avoid ever printing out
+        // a tuple type FriendlyName in its entirety. For example, could
+        // produce an error message by diffing two object types and saying
+        // something like "Expected attribute foo to be string, but got number".
+        // TODO: Finish this
+        return "tuple"
+}
+
+func (t typeTuple) GoString() string {
+        if len(t.ElemTypes) == 0 {
+                return "cty.EmptyTuple"
+        }
+        return fmt.Sprintf("cty.Tuple(%#v)", t.ElemTypes)
+}
+
+// EmptyTuple is a shorthand for Tuple([]Type{}), to more easily talk about
+// the empty tuple type.
+var EmptyTuple Type
+
+// EmptyTupleVal is the only possible non-null, non-unknown value of type
+// EmptyTuple.
+var EmptyTupleVal Value
+
+func init() {
+        EmptyTuple = Tuple([]Type{})
+        EmptyTupleVal = Value{
+                ty: EmptyTuple,
+                v:  []interface{}{},
+        }
+}
+
+// IsTupleType returns true if the given type is an object type, regardless
+// of its element type.
+func (t Type) IsTupleType() bool {
+        _, ok := t.typeImpl.(typeTuple)
+        return ok
+}
+
+// Length returns the number of elements of the receiving tuple type.
+// Will panic if the reciever isn't a tuple type; use IsTupleType to determine
+// whether this operation will succeed.
+func (t Type) Length() int {
+        if ot, ok := t.typeImpl.(typeTuple); ok {
+                return len(ot.ElemTypes)
+        }
+        panic("Length on non-tuple Type")
+}
+
+// TupleElementType returns the type of the element with the given index. Will
+// panic if the receiver is not a tuple type (use IsTupleType to confirm)
+// or if the index is out of range (use Length to confirm).
+func (t Type) TupleElementType(idx int) Type {
+        if ot, ok := t.typeImpl.(typeTuple); ok {
+                return ot.ElemTypes[idx]
+        }
+        panic("TupleElementType on non-tuple Type")
+}
+
+// TupleElementTypes returns a slice of the recieving tuple type's element
+// types. Will panic if the receiver is not a tuple type (use IsTupleType
+// to confirm).
+//
+// The returned slice is part of the internal state of the type, and is provided
+// for read access only. It is forbidden for any caller to modify the
+// underlying array. For many purposes the element-related methods of Value
+// are more appropriate and more convenient to use.
+func (t Type) TupleElementTypes() []Type {
+        if ot, ok := t.typeImpl.(typeTuple); ok {
+                return ot.ElemTypes
+        }
+        panic("TupleElementTypes on non-tuple Type")
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/type.go b/vendor/github.com/zclconf/go-cty/cty/type.go
new file mode 100644
index 0000000..ae5f1c8
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/type.go
@@ -0,0 +1,95 @@
+package cty
+
+// Type represents value types within the type system.
+//
+// This is a closed interface type, meaning that only the concrete
+// implementations provided within this package are considered valid.
+type Type struct {
+        typeImpl
+}
+
+type typeImpl interface {
+        // isTypeImpl is a do-nothing method that exists only to express
+        // that a type is an implementation of typeImpl.
+        isTypeImpl() typeImplSigil
+
+        // Equals returns true if the other given Type exactly equals the
+        // receiver Type.
+        Equals(other Type) bool
+
+        // FriendlyName returns a human-friendly *English* name for the given
+        // type.
+        FriendlyName() string
+
+        // GoString implements the GoStringer interface from package fmt.
+        GoString() string
+}
+
+// Base implementation of Type to embed into concrete implementations
+// to signal that they are implementations of Type.
+type typeImplSigil struct{}
+
+func (t typeImplSigil) isTypeImpl() typeImplSigil {
+        return typeImplSigil{}
+}
+
+// Equals returns true if the other given Type exactly equals the receiver
+// type.
+func (t Type) Equals(other Type) bool {
+        return t.typeImpl.Equals(other)
+}
+
+// FriendlyName returns a human-friendly *English* name for the given type.
+func (t Type) FriendlyName() string {
+        return t.typeImpl.FriendlyName()
+}
+
+// GoString returns a string approximating how the receiver type would be
+// expressed in Go source code.
+func (t Type) GoString() string {
+        if t.typeImpl == nil {
+                return "cty.NilType"
+        }
+
+        return t.typeImpl.GoString()
+}
+
+// NilType is an invalid type used when a function is returning an error
+// and has no useful type to return. It should not be used and any methods
+// called on it will panic.
+var NilType = Type{}
+
+// HasDynamicTypes returns true either if the receiver is itself
+// DynamicPseudoType or if it is a compound type whose descendent elements
+// are DynamicPseudoType.
+func (t Type) HasDynamicTypes() bool {
+        switch {
+        case t == DynamicPseudoType:
+                return true
+        case t.IsPrimitiveType():
+                return false
+        case t.IsCollectionType():
+                return false
+        case t.IsObjectType():
+                attrTypes := t.AttributeTypes()
+                for _, at := range attrTypes {
+                        if at.HasDynamicTypes() {
+                                return true
+                        }
+                }
+                return false
+        case t.IsTupleType():
+                elemTypes := t.TupleElementTypes()
+                for _, et := range elemTypes {
+                        if et.HasDynamicTypes() {
+                                return true
+                        }
+                }
+                return false
+        case t.IsCapsuleType():
+                return false
+        default:
+                // Should never happen, since above should be exhaustive
+                panic("HasDynamicTypes does not support the given type")
+        }
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/type_conform.go b/vendor/github.com/zclconf/go-cty/cty/type_conform.go
new file mode 100644
index 0000000..b417dc7
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/type_conform.go
@@ -0,0 +1,142 @@
+package cty
+
+// TestConformance recursively walks the receiver and the given other type and
+// returns nil if the receiver *conforms* to the given type.
+//
+// Type conformance is similar to type equality but has one crucial difference:
+// PseudoTypeDynamic can be used within the given type to represent that
+// *any* type is allowed.
+//
+// If any non-conformities are found, the returned slice will be non-nil and
+// contain at least one error value. It will be nil if the type is entirely
+// conformant.
+//
+// Note that the special behavior of PseudoTypeDynamic is the *only* exception
+// to normal type equality. Calling applications may wish to apply their own
+// automatic conversion logic to the given data structure to create a more
+// liberal notion of conformance to a type.
+//
+// Returned errors are usually (but not always) PathError instances that
+// indicate where in the structure the error was found. If a returned error
+// is of that type then the error message is written for (English-speaking)
+// end-users working within the cty type system, not mentioning any Go-oriented
+// implementation details.
+func (t Type) TestConformance(other Type) []error {
+        path := make(Path, 0)
+        var errs []error
+        testConformance(t, other, path, &errs)
+        return errs
+}
+
+func testConformance(given Type, want Type, path Path, errs *[]error) {
+        if want.Equals(DynamicPseudoType) {
+                // anything goes!
+                return
+        }
+
+        if given.Equals(want) {
+                // Any equal types are always conformant
+                return
+        }
+
+        // The remainder of this function is concerned with detecting
+        // and reporting the specific non-conformance, since we wouldn't
+        // have got here if the types were not divergent.
+        // We treat compound structures as special so that we can report
+        // specifically what is non-conforming, rather than simply returning
+        // the entire type names and letting the user puzzle it out.
+
+        if given.IsObjectType() && want.IsObjectType() {
+                givenAttrs := given.AttributeTypes()
+                wantAttrs := want.AttributeTypes()
+
+                if len(givenAttrs) != len(wantAttrs) {
+                        // Something is missing from one of them.
+                        for k := range givenAttrs {
+                                if _, exists := wantAttrs[k]; !exists {
+                                        *errs = append(
+                                                *errs,
+                                                errorf(path, "unsupported attribute %q", k),
+                                        )
+                                }
+                        }
+                        for k := range wantAttrs {
+                                if _, exists := givenAttrs[k]; !exists {
+                                        *errs = append(
+                                                *errs,
+                                                errorf(path, "missing required attribute %q", k),
+                                        )
+                                }
+                        }
+                }
+
+                path = append(path, nil)
+                pathIdx := len(path) - 1
+
+                for k, wantAttrType := range wantAttrs {
+                        if givenAttrType, exists := givenAttrs[k]; exists {
+                                path[pathIdx] = GetAttrStep{Name: k}
+                                testConformance(givenAttrType, wantAttrType, path, errs)
+                        }
+                }
+
+                path = path[0:pathIdx]
+
+                return
+        }
+
+        if given.IsTupleType() && want.IsTupleType() {
+                givenElems := given.TupleElementTypes()
+                wantElems := want.TupleElementTypes()
+
+                if len(givenElems) != len(wantElems) {
+                        *errs = append(
+                                *errs,
+                                errorf(path, "%d elements are required, but got %d", len(wantElems), len(givenElems)),
+                        )
+                        return
+                }
+
+                path = append(path, nil)
+                pathIdx := len(path) - 1
+
+                for i, wantElemType := range wantElems {
+                        givenElemType := givenElems[i]
+                        path[pathIdx] = IndexStep{Key: NumberIntVal(int64(i))}
+                        testConformance(givenElemType, wantElemType, path, errs)
+                }
+
+                path = path[0:pathIdx]
+
+                return
+        }
+
+        if given.IsListType() && want.IsListType() {
+                path = append(path, IndexStep{Key: UnknownVal(Number)})
+                pathIdx := len(path) - 1
+                testConformance(given.ElementType(), want.ElementType(), path, errs)
+                path = path[0:pathIdx]
+                return
+        }
+
+        if given.IsMapType() && want.IsMapType() {
+                path = append(path, IndexStep{Key: UnknownVal(String)})
+                pathIdx := len(path) - 1
+                testConformance(given.ElementType(), want.ElementType(), path, errs)
+                path = path[0:pathIdx]
+                return
+        }
+
+        if given.IsSetType() && want.IsSetType() {
+                path = append(path, IndexStep{Key: UnknownVal(given.ElementType())})
+                pathIdx := len(path) - 1
+                testConformance(given.ElementType(), want.ElementType(), path, errs)
+                path = path[0:pathIdx]
+                return
+        }
+
+        *errs = append(
+                *errs,
+                errorf(path, "%s required, but received %s", want.FriendlyName(), given.FriendlyName()),
+        )
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/types_to_register.go b/vendor/github.com/zclconf/go-cty/cty/types_to_register.go
new file mode 100644
index 0000000..e1e220a
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/types_to_register.go
@@ -0,0 +1,57 @@
+package cty
+
+import (
+        "encoding/gob"
+        "fmt"
+        "math/big"
+        "strings"
+
+        "github.com/zclconf/go-cty/cty/set"
+)
+
+// InternalTypesToRegister is a slice of values that covers all of the
+// internal types used in the representation of cty.Type and cty.Value
+// across all cty Types.
+//
+// This is intended to be used to register these types with encoding
+// packages that require registration of types used in interfaces, such as
+// encoding/gob, thus allowing cty types and values to be included in streams
+// created from those packages. However, registering with gob is not necessary
+// since that is done automatically as a side-effect of importing this package.
+//
+// Callers should not do anything with the values here except pass them on
+// verbatim to a registration function.
+//
+// If the calling application uses Capsule types that wrap local structs either
+// directly or indirectly, these structs may also need to be registered in
+// order to support encoding and decoding of values of these types. That is the
+// responsibility of the calling application.
+var InternalTypesToRegister []interface{}
+
+func init() {
+        InternalTypesToRegister = []interface{}{
+                primitiveType{},
+                typeList{},
+                typeMap{},
+                typeObject{},
+                typeSet{},
+                setRules{},
+                set.Set{},
+                typeTuple{},
+                big.Float{},
+                capsuleType{},
+                []interface{}(nil),
+                map[string]interface{}(nil),
+        }
+
+        // Register these with gob here, rather than in gob.go, to ensure
+        // that this will always happen after we build the above.
+        for _, tv := range InternalTypesToRegister {
+                typeName := fmt.Sprintf("%T", tv)
+                if strings.HasPrefix(typeName, "cty.") {
+                        gob.RegisterName(fmt.Sprintf("github.com/zclconf/go-cty/%s", typeName), tv)
+                } else {
+                        gob.Register(tv)
+                }
+        }
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/unknown.go b/vendor/github.com/zclconf/go-cty/cty/unknown.go
new file mode 100644
index 0000000..9f6fce9
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/unknown.go
@@ -0,0 +1,79 @@
+package cty
+
+// unknownType is the placeholder type used for the sigil value representing
+// "Unknown", to make it unambigiously distinct from any other possible value.
+type unknownType struct {
+}
+
+// Unknown is a special value that can be
+var unknown interface{} = &unknownType{}
+
+// UnknownVal returns an Value that represents an unknown value of the given
+// type. Unknown values can be used to represent a value that is
+// not yet known. Its meaning is undefined in cty, but it could be used by
+// an calling application to allow partial evaluation.
+//
+// Unknown values of any type can be created of any type. All operations on
+// Unknown values themselves return Unknown.
+func UnknownVal(t Type) Value {
+        return Value{
+                ty: t,
+                v:  unknown,
+        }
+}
+
+func (t unknownType) GoString() string {
+        // This is the stringification of our internal unknown marker. The
+        // stringification of the public representation of unknowns is in
+        // Value.GoString.
+        return "cty.unknown"
+}
+
+type pseudoTypeDynamic struct {
+        typeImplSigil
+}
+
+// DynamicPseudoType represents the dynamic pseudo-type.
+//
+// This type can represent situations where a type is not yet known. Its
+// meaning is undefined in cty, but it could be used by a calling
+// application to allow expression type checking with some types not yet known.
+// For example, the application might optimistically permit any operation on
+// values of this type in type checking, allowing a partial type-check result,
+// and then repeat the check when more information is known to get the
+// final, concrete type.
+//
+// It is a pseudo-type because it is used only as a sigil to the calling
+// application. "Unknown" is the only valid value of this pseudo-type, so
+// operations on values of this type will always short-circuit as per
+// the rules for that special value.
+var DynamicPseudoType Type
+
+func (t pseudoTypeDynamic) Equals(other Type) bool {
+        _, ok := other.typeImpl.(pseudoTypeDynamic)
+        return ok
+}
+
+func (t pseudoTypeDynamic) FriendlyName() string {
+        return "dynamic"
+}
+
+func (t pseudoTypeDynamic) GoString() string {
+        return "cty.DynamicPseudoType"
+}
+
+// DynamicVal is the only valid value of the pseudo-type dynamic.
+// This value can be used as a placeholder where a value or expression's
+// type and value are both unknown, thus allowing partial evaluation. See
+// the docs for DynamicPseudoType for more information.
+var DynamicVal Value
+
+func init() {
+        DynamicPseudoType = Type{
+                pseudoTypeDynamic{},
+        }
+        DynamicVal = Value{
+                ty: DynamicPseudoType,
+                v:  unknown,
+        }
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/value.go b/vendor/github.com/zclconf/go-cty/cty/value.go
new file mode 100644
index 0000000..80cb8f7
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/value.go
@@ -0,0 +1,98 @@
+package cty
+
+// Value represents a value of a particular type, and is the interface by
+// which operations are executed on typed values.
+//
+// Value has two different classes of method. Operation methods stay entirely
+// within the type system (methods accept and return Value instances) and
+// are intended for use in implementing a language in terms of cty, while
+// integration methods either enter or leave the type system, working with
+// native Go values. Operation methods are guaranteed to support all of the
+// expected short-circuit behavior for unknown and dynamic values, while
+// integration methods may not.
+//
+// The philosophy for the operations API is that it's the caller's
+// responsibility to ensure that the given types and values satisfy the
+// specified invariants during a separate type check, so that the caller is
+// able to return errors to its user from the application's own perspective.
+//
+// Consequently the design of these methods assumes such checks have already
+// been done and panics if any invariants turn out not to be satisfied. These
+// panic errors are not intended to be handled, but rather indicate a bug in
+// the calling application that should be fixed with more checks prior to
+// executing operations.
+//
+// A related consequence of this philosophy is that no automatic type
+// conversions are done. If a method specifies that its argument must be
+// number then it's the caller's responsibility to do that conversion before
+// the call, thus allowing the application to have more constrained conversion
+// rules than are offered by the built-in converter where necessary.
+type Value struct {
+        ty Type
+        v  interface{}
+}
+
+// Type returns the type of the value.
+func (val Value) Type() Type {
+        return val.ty
+}
+
+// IsKnown returns true if the value is known. That is, if it is not
+// the result of the unknown value constructor Unknown(...), and is not
+// the result of an operation on another unknown value.
+//
+// Unknown values are only produced either directly or as a result of
+// operating on other unknown values, and so an application that never
+// introduces Unknown values can be guaranteed to never receive any either.
+func (val Value) IsKnown() bool {
+        return val.v != unknown
+}
+
+// IsNull returns true if the value is null. Values of any type can be
+// null, but any operations on a null value will panic. No operation ever
+// produces null, so an application that never introduces Null values can
+// be guaranteed to never receive any either.
+func (val Value) IsNull() bool {
+        return val.v == nil
+}
+
+// NilVal is an invalid Value that can be used as a placeholder when returning
+// with an error from a function that returns (Value, error).
+//
+// NilVal is *not* a valid error and so no operations may be performed on it.
+// Any attempt to use it will result in a panic.
+//
+// This should not be confused with the idea of a Null value, as returned by
+// NullVal. NilVal is a nil within the *Go* type system, and is invalid in
+// the cty type system. Null values *do* exist in the cty type system.
+var NilVal = Value{
+        ty: Type{typeImpl: nil},
+        v:  nil,
+}
+
+// IsWhollyKnown is an extension of IsKnown that also recursively checks
+// inside collections and structures to see if there are any nested unknown
+// values.
+func (val Value) IsWhollyKnown() bool {
+        if !val.IsKnown() {
+                return false
+        }
+
+        if val.IsNull() {
+                // Can't recurse into a null, so we're done
+                return true
+        }
+
+        switch {
+        case val.CanIterateElements():
+                for it := val.ElementIterator(); it.Next(); {
+                        _, ev := it.Element()
+                        if !ev.IsWhollyKnown() {
+                                return false
+                        }
+                }
+                return true
+        default:
+                return true
+        }
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/value_init.go b/vendor/github.com/zclconf/go-cty/cty/value_init.go
new file mode 100644
index 0000000..495a83e
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/value_init.go
@@ -0,0 +1,276 @@
+package cty
+
+import (
+        "fmt"
+        "math/big"
+        "reflect"
+
+        "golang.org/x/text/unicode/norm"
+
+        "github.com/zclconf/go-cty/cty/set"
+)
+
+// BoolVal returns a Value of type Number whose internal value is the given
+// bool.
+func BoolVal(v bool) Value {
+        return Value{
+                ty: Bool,
+                v:  v,
+        }
+}
+
+// NumberVal returns a Value of type Number whose internal value is the given
+// big.Float. The returned value becomes the owner of the big.Float object,
+// and so it's forbidden for the caller to mutate the object after it's
+// wrapped in this way.
+func NumberVal(v *big.Float) Value {
+        return Value{
+                ty: Number,
+                v:  v,
+        }
+}
+
+// NumberIntVal returns a Value of type Number whose internal value is equal
+// to the given integer.
+func NumberIntVal(v int64) Value {
+        return NumberVal(new(big.Float).SetInt64(v))
+}
+
+// NumberUIntVal returns a Value of type Number whose internal value is equal
+// to the given unsigned integer.
+func NumberUIntVal(v uint64) Value {
+        return NumberVal(new(big.Float).SetUint64(v))
+}
+
+// NumberFloatVal returns a Value of type Number whose internal value is
+// equal to the given float.
+func NumberFloatVal(v float64) Value {
+        return NumberVal(new(big.Float).SetFloat64(v))
+}
+
+// StringVal returns a Value of type String whose internal value is the
+// given string.
+//
+// Strings must be UTF-8 encoded sequences of valid unicode codepoints, and
+// they are NFC-normalized on entry into the world of cty values.
+//
+// If the given string is not valid UTF-8 then behavior of string operations
+// is undefined.
+func StringVal(v string) Value {
+        return Value{
+                ty: String,
+                v:  NormalizeString(v),
+        }
+}
+
+// NormalizeString applies the same normalization that cty applies when
+// constructing string values.
+//
+// A return value from this function can be meaningfully compared byte-for-byte
+// with a Value.AsString result.
+func NormalizeString(s string) string {
+        return norm.NFC.String(s)
+}
+
+// ObjectVal returns a Value of an object type whose structure is defined
+// by the key names and value types in the given map.
+func ObjectVal(attrs map[string]Value) Value {
+        attrTypes := make(map[string]Type, len(attrs))
+        attrVals := make(map[string]interface{}, len(attrs))
+
+        for attr, val := range attrs {
+                attr = NormalizeString(attr)
+                attrTypes[attr] = val.ty
+                attrVals[attr] = val.v
+        }
+
+        return Value{
+                ty: Object(attrTypes),
+                v:  attrVals,
+        }
+}
+
+// TupleVal returns a Value of a tuple type whose element types are
+// defined by the value types in the given slice.
+func TupleVal(elems []Value) Value {
+        elemTypes := make([]Type, len(elems))
+        elemVals := make([]interface{}, len(elems))
+
+        for i, val := range elems {
+                elemTypes[i] = val.ty
+                elemVals[i] = val.v
+        }
+
+        return Value{
+                ty: Tuple(elemTypes),
+                v:  elemVals,
+        }
+}
+
+// ListVal returns a Value of list type whose element type is defined by
+// the types of the given values, which must be homogenous.
+//
+// If the types are not all consistent (aside from elements that are of the
+// dynamic pseudo-type) then this function will panic. It will panic also
+// if the given list is empty, since then the element type cannot be inferred.
+// (See also ListValEmpty.)
+func ListVal(vals []Value) Value {
+        if len(vals) == 0 {
+                panic("must not call ListVal with empty slice")
+        }
+        elementType := DynamicPseudoType
+        rawList := make([]interface{}, len(vals))
+
+        for i, val := range vals {
+                if elementType == DynamicPseudoType {
+                        elementType = val.ty
+                } else if val.ty != DynamicPseudoType && !elementType.Equals(val.ty) {
+                        panic(fmt.Errorf(
+                                "inconsistent list element types (%#v then %#v)",
+                                elementType, val.ty,
+                        ))
+                }
+
+                rawList[i] = val.v
+        }
+
+        return Value{
+                ty: List(elementType),
+                v:  rawList,
+        }
+}
+
+// ListValEmpty returns an empty list of the given element type.
+func ListValEmpty(element Type) Value {
+        return Value{
+                ty: List(element),
+                v:  []interface{}{},
+        }
+}
+
+// MapVal returns a Value of a map type whose element type is defined by
+// the types of the given values, which must be homogenous.
+//
+// If the types are not all consistent (aside from elements that are of the
+// dynamic pseudo-type) then this function will panic. It will panic also
+// if the given map is empty, since then the element type cannot be inferred.
+// (See also MapValEmpty.)
+func MapVal(vals map[string]Value) Value {
+        if len(vals) == 0 {
+                panic("must not call MapVal with empty map")
+        }
+        elementType := DynamicPseudoType
+        rawMap := make(map[string]interface{}, len(vals))
+
+        for key, val := range vals {
+                if elementType == DynamicPseudoType {
+                        elementType = val.ty
+                } else if val.ty != DynamicPseudoType && !elementType.Equals(val.ty) {
+                        panic(fmt.Errorf(
+                                "inconsistent map element types (%#v then %#v)",
+                                elementType, val.ty,
+                        ))
+                }
+
+                rawMap[NormalizeString(key)] = val.v
+        }
+
+        return Value{
+                ty: Map(elementType),
+                v:  rawMap,
+        }
+}
+
+// MapValEmpty returns an empty map of the given element type.
+func MapValEmpty(element Type) Value {
+        return Value{
+                ty: Map(element),
+                v:  map[string]interface{}{},
+        }
+}
+
+// SetVal returns a Value of set type whose element type is defined by
+// the types of the given values, which must be homogenous.
+//
+// If the types are not all consistent (aside from elements that are of the
+// dynamic pseudo-type) then this function will panic. It will panic also
+// if the given list is empty, since then the element type cannot be inferred.
+// (See also SetValEmpty.)
+func SetVal(vals []Value) Value {
+        if len(vals) == 0 {
+                panic("must not call SetVal with empty slice")
+        }
+        elementType := DynamicPseudoType
+        rawList := make([]interface{}, len(vals))
+
+        for i, val := range vals {
+                if elementType == DynamicPseudoType {
+                        elementType = val.ty
+                } else if val.ty != DynamicPseudoType && !elementType.Equals(val.ty) {
+                        panic(fmt.Errorf(
+                                "inconsistent set element types (%#v then %#v)",
+                                elementType, val.ty,
+                        ))
+                }
+
+                rawList[i] = val.v
+        }
+
+        rawVal := set.NewSetFromSlice(setRules{elementType}, rawList)
+
+        return Value{
+                ty: Set(elementType),
+                v:  rawVal,
+        }
+}
+
+// SetValFromValueSet returns a Value of set type based on an already-constructed
+// ValueSet.
+//
+// The element type of the returned value is the element type of the given
+// set.
+func SetValFromValueSet(s ValueSet) Value {
+        ety := s.ElementType()
+        rawVal := s.s.Copy() // copy so caller can't mutate what we wrap
+
+        return Value{
+                ty: Set(ety),
+                v:  rawVal,
+        }
+}
+
+// SetValEmpty returns an empty set of the given element type.
+func SetValEmpty(element Type) Value {
+        return Value{
+                ty: Set(element),
+                v:  set.NewSet(setRules{element}),
+        }
+}
+
+// CapsuleVal creates a value of the given capsule type using the given
+// wrapVal, which must be a pointer to a value of the capsule type's native
+// type.
+//
+// This function will panic if the given type is not a capsule type, if
+// the given wrapVal is not compatible with the given capsule type, or if
+// wrapVal is not a pointer.
+func CapsuleVal(ty Type, wrapVal interface{}) Value {
+        if !ty.IsCapsuleType() {
+                panic("not a capsule type")
+        }
+
+        wv := reflect.ValueOf(wrapVal)
+        if wv.Kind() != reflect.Ptr {
+                panic("wrapVal is not a pointer")
+        }
+
+        it := ty.typeImpl.(*capsuleType).GoType
+        if !wv.Type().Elem().AssignableTo(it) {
+                panic("wrapVal target is not compatible with the given capsule type")
+        }
+
+        return Value{
+                ty: ty,
+                v:  wrapVal,
+        }
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/value_ops.go b/vendor/github.com/zclconf/go-cty/cty/value_ops.go
new file mode 100644
index 0000000..967aa76
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/value_ops.go
@@ -0,0 +1,1071 @@
+package cty
+
+import (
+        "fmt"
+        "math/big"
+
+        "reflect"
+
+        "github.com/zclconf/go-cty/cty/set"
+)
+
+func (val Value) GoString() string {
+        if val == NilVal {
+                return "cty.NilVal"
+        }
+
+        if val.ty == DynamicPseudoType {
+                return "cty.DynamicVal"
+        }
+
+        if !val.IsKnown() {
+                return fmt.Sprintf("cty.UnknownVal(%#v)", val.ty)
+        }
+        if val.IsNull() {
+                return fmt.Sprintf("cty.NullVal(%#v)", val.ty)
+        }
+
+        // By the time we reach here we've dealt with all of the exceptions around
+        // unknowns and nulls, so we're guaranteed that the values are the
+        // canonical internal representation of the given type.
+
+        switch val.ty {
+        case Bool:
+                if val.v.(bool) {
+                        return "cty.True"
+                } else {
+                        return "cty.False"
+                }
+        case Number:
+                fv := val.v.(*big.Float)
+                // We'll try to use NumberIntVal or NumberFloatVal if we can, since
+                // the fully-general initializer call is pretty ugly-looking.
+                if fv.IsInt() {
+                        return fmt.Sprintf("cty.NumberIntVal(%#v)", fv)
+                }
+                if rfv, accuracy := fv.Float64(); accuracy == big.Exact {
+                        return fmt.Sprintf("cty.NumberFloatVal(%#v)", rfv)
+                }
+                return fmt.Sprintf("cty.NumberVal(new(big.Float).Parse(\"%#v\", 10))", fv)
+        case String:
+                return fmt.Sprintf("cty.StringVal(%#v)", val.v)
+        }
+
+        switch {
+        case val.ty.IsSetType():
+                vals := val.v.(set.Set).Values()
+                if vals == nil || len(vals) == 0 {
+                        return fmt.Sprintf("cty.SetValEmpty()")
+                } else {
+                        return fmt.Sprintf("cty.SetVal(%#v)", vals)
+                }
+        case val.ty.IsCapsuleType():
+                return fmt.Sprintf("cty.CapsuleVal(%#v, %#v)", val.ty, val.v)
+        }
+
+        // Default exposes implementation details, so should actually cover
+        // all of the cases above for good caller UX.
+        return fmt.Sprintf("cty.Value{ty: %#v, v: %#v}", val.ty, val.v)
+}
+
+// Equals returns True if the receiver and the given other value have the
+// same type and are exactly equal in value.
+//
+// The usual short-circuit rules apply, so the result can be unknown or typed
+// as dynamic if either of the given values are. Use RawEquals to compare
+// if two values are equal *ignoring* the short-circuit rules.
+func (val Value) Equals(other Value) Value {
+        if val.ty.HasDynamicTypes() || other.ty.HasDynamicTypes() {
+                return UnknownVal(Bool)
+        }
+
+        if !val.ty.Equals(other.ty) {
+                return BoolVal(false)
+        }
+
+        if !(val.IsKnown() && other.IsKnown()) {
+                return UnknownVal(Bool)
+        }
+
+        if val.IsNull() || other.IsNull() {
+                if val.IsNull() && other.IsNull() {
+                        return BoolVal(true)
+                }
+                return BoolVal(false)
+        }
+
+        ty := val.ty
+        result := false
+
+        switch {
+        case ty == Number:
+                result = val.v.(*big.Float).Cmp(other.v.(*big.Float)) == 0
+        case ty == Bool:
+                result = val.v.(bool) == other.v.(bool)
+        case ty == String:
+                // Simple equality is safe because we NFC-normalize strings as they
+                // enter our world from StringVal, and so we can assume strings are
+                // always in normal form.
+                result = val.v.(string) == other.v.(string)
+        case ty.IsObjectType():
+                oty := ty.typeImpl.(typeObject)
+                result = true
+                for attr, aty := range oty.AttrTypes {
+                        lhs := Value{
+                                ty: aty,
+                                v:  val.v.(map[string]interface{})[attr],
+                        }
+                        rhs := Value{
+                                ty: aty,
+                                v:  other.v.(map[string]interface{})[attr],
+                        }
+                        eq := lhs.Equals(rhs)
+                        if !eq.IsKnown() {
+                                return UnknownVal(Bool)
+                        }
+                        if eq.False() {
+                                result = false
+                                break
+                        }
+                }
+        case ty.IsTupleType():
+                tty := ty.typeImpl.(typeTuple)
+                result = true
+                for i, ety := range tty.ElemTypes {
+                        lhs := Value{
+                                ty: ety,
+                                v:  val.v.([]interface{})[i],
+                        }
+                        rhs := Value{
+                                ty: ety,
+                                v:  other.v.([]interface{})[i],
+                        }
+                        eq := lhs.Equals(rhs)
+                        if !eq.IsKnown() {
+                                return UnknownVal(Bool)
+                        }
+                        if eq.False() {
+                                result = false
+                                break
+                        }
+                }
+        case ty.IsListType():
+                ety := ty.typeImpl.(typeList).ElementTypeT
+                if len(val.v.([]interface{})) == len(other.v.([]interface{})) {
+                        result = true
+                        for i := range val.v.([]interface{}) {
+                                lhs := Value{
+                                        ty: ety,
+                                        v:  val.v.([]interface{})[i],
+                                }
+                                rhs := Value{
+                                        ty: ety,
+                                        v:  other.v.([]interface{})[i],
+                                }
+                                eq := lhs.Equals(rhs)
+                                if !eq.IsKnown() {
+                                        return UnknownVal(Bool)
+                                }
+                                if eq.False() {
+                                        result = false
+                                        break
+                                }
+                        }
+                }
+        case ty.IsSetType():
+                s1 := val.v.(set.Set)
+                s2 := other.v.(set.Set)
+                equal := true
+
+                // Note that by our definition of sets it's never possible for two
+                // sets that contain unknown values (directly or indicrectly) to
+                // ever be equal, even if they are otherwise identical.
+
+                // FIXME: iterating both lists and checking each item is not the
+                // ideal implementation here, but it works with the primitives we
+                // have in the set implementation. Perhaps the set implementation
+                // can provide its own equality test later.
+                s1.EachValue(func(v interface{}) {
+                        if !s2.Has(v) {
+                                equal = false
+                        }
+                })
+                s2.EachValue(func(v interface{}) {
+                        if !s1.Has(v) {
+                                equal = false
+                        }
+                })
+
+                result = equal
+        case ty.IsMapType():
+                ety := ty.typeImpl.(typeMap).ElementTypeT
+                if len(val.v.(map[string]interface{})) == len(other.v.(map[string]interface{})) {
+                        result = true
+                        for k := range val.v.(map[string]interface{}) {
+                                if _, ok := other.v.(map[string]interface{})[k]; !ok {
+                                        result = false
+                                        break
+                                }
+                                lhs := Value{
+                                        ty: ety,
+                                        v:  val.v.(map[string]interface{})[k],
+                                }
+                                rhs := Value{
+                                        ty: ety,
+                                        v:  other.v.(map[string]interface{})[k],
+                                }
+                                eq := lhs.Equals(rhs)
+                                if !eq.IsKnown() {
+                                        return UnknownVal(Bool)
+                                }
+                                if eq.False() {
+                                        result = false
+                                        break
+                                }
+                        }
+                }
+        case ty.IsCapsuleType():
+                // A capsule type's encapsulated value is a pointer to a value of its
+                // native type, so we can just compare these to get the identity test
+                // we need.
+                return BoolVal(val.v == other.v)
+
+        default:
+                // should never happen
+                panic(fmt.Errorf("unsupported value type %#v in Equals", ty))
+        }
+
+        return BoolVal(result)
+}
+
+// NotEqual is a shorthand for Equals followed by Not.
+func (val Value) NotEqual(other Value) Value {
+        return val.Equals(other).Not()
+}
+
+// True returns true if the receiver is True, false if False, and panics if
+// the receiver is not of type Bool.
+//
+// This is a helper function to help write application logic that works with
+// values, rather than a first-class operation. It does not work with unknown
+// or null values. For more robust handling with unknown value
+// short-circuiting, use val.Equals(cty.True).
+func (val Value) True() bool {
+        if val.ty != Bool {
+                panic("not bool")
+        }
+        return val.Equals(True).v.(bool)
+}
+
+// False is the opposite of True.
+func (val Value) False() bool {
+        return !val.True()
+}
+
+// RawEquals returns true if and only if the two given values have the same
+// type and equal value, ignoring the usual short-circuit rules about
+// unknowns and dynamic types.
+//
+// This method is more appropriate for testing than for real use, since it
+// skips over usual semantics around unknowns but as a consequence allows
+// testing the result of another operation that is expected to return unknown.
+// It returns a primitive Go bool rather than a Value to remind us that it
+// is not a first-class value operation.
+func (val Value) RawEquals(other Value) bool {
+        if !val.ty.Equals(other.ty) {
+                return false
+        }
+        if (!val.IsKnown()) && (!other.IsKnown()) {
+                return true
+        }
+        if (val.IsKnown() && !other.IsKnown()) || (other.IsKnown() && !val.IsKnown()) {
+                return false
+        }
+        if val.IsNull() && other.IsNull() {
+                return true
+        }
+        if (val.IsNull() && !other.IsNull()) || (other.IsNull() && !val.IsNull()) {
+                return false
+        }
+        if val.ty == DynamicPseudoType && other.ty == DynamicPseudoType {
+                return true
+        }
+
+        ty := val.ty
+        switch {
+        case ty == Number || ty == Bool || ty == String || ty == DynamicPseudoType:
+                return val.Equals(other).True()
+        case ty.IsObjectType():
+                oty := ty.typeImpl.(typeObject)
+                for attr, aty := range oty.AttrTypes {
+                        lhs := Value{
+                                ty: aty,
+                                v:  val.v.(map[string]interface{})[attr],
+                        }
+                        rhs := Value{
+                                ty: aty,
+                                v:  other.v.(map[string]interface{})[attr],
+                        }
+                        eq := lhs.RawEquals(rhs)
+                        if !eq {
+                                return false
+                        }
+                }
+                return true
+        case ty.IsTupleType():
+                tty := ty.typeImpl.(typeTuple)
+                for i, ety := range tty.ElemTypes {
+                        lhs := Value{
+                                ty: ety,
+                                v:  val.v.([]interface{})[i],
+                        }
+                        rhs := Value{
+                                ty: ety,
+                                v:  other.v.([]interface{})[i],
+                        }
+                        eq := lhs.RawEquals(rhs)
+                        if !eq {
+                                return false
+                        }
+                }
+                return true
+        case ty.IsListType():
+                ety := ty.typeImpl.(typeList).ElementTypeT
+                if len(val.v.([]interface{})) == len(other.v.([]interface{})) {
+                        for i := range val.v.([]interface{}) {
+                                lhs := Value{
+                                        ty: ety,
+                                        v:  val.v.([]interface{})[i],
+                                }
+                                rhs := Value{
+                                        ty: ety,
+                                        v:  other.v.([]interface{})[i],
+                                }
+                                eq := lhs.RawEquals(rhs)
+                                if !eq {
+                                        return false
+                                }
+                        }
+                        return true
+                }
+                return false
+        case ty.IsSetType():
+                s1 := val.v.(set.Set)
+                s2 := other.v.(set.Set)
+
+                // Since we're intentionally ignoring our rule that two unknowns
+                // are never equal, we can cheat here.
+                // (This isn't 100% right since e.g. it will fail if the set contains
+                // numbers that are infinite, which DeepEqual can't compare properly.
+                // We're accepting that limitation for simplicity here, since this
+                // function is here primarily for testing.)
+                return reflect.DeepEqual(s1, s2)
+
+        case ty.IsMapType():
+                ety := ty.typeImpl.(typeMap).ElementTypeT
+                if len(val.v.(map[string]interface{})) == len(other.v.(map[string]interface{})) {
+                        for k := range val.v.(map[string]interface{}) {
+                                if _, ok := other.v.(map[string]interface{})[k]; !ok {
+                                        return false
+                                }
+                                lhs := Value{
+                                        ty: ety,
+                                        v:  val.v.(map[string]interface{})[k],
+                                }
+                                rhs := Value{
+                                        ty: ety,
+                                        v:  other.v.(map[string]interface{})[k],
+                                }
+                                eq := lhs.RawEquals(rhs)
+                                if !eq {
+                                        return false
+                                }
+                        }
+                        return true
+                }
+                return false
+        case ty.IsCapsuleType():
+                // A capsule type's encapsulated value is a pointer to a value of its
+                // native type, so we can just compare these to get the identity test
+                // we need.
+                return val.v == other.v
+
+        default:
+                // should never happen
+                panic(fmt.Errorf("unsupported value type %#v in RawEquals", ty))
+        }
+}
+
+// Add returns the sum of the receiver and the given other value. Both values
+// must be numbers; this method will panic if not.
+func (val Value) Add(other Value) Value {
+        if shortCircuit := mustTypeCheck(Number, Number, val, other); shortCircuit != nil {
+                shortCircuit = forceShortCircuitType(shortCircuit, Number)
+                return *shortCircuit
+        }
+
+        ret := new(big.Float)
+        ret.Add(val.v.(*big.Float), other.v.(*big.Float))
+        return NumberVal(ret)
+}
+
+// Subtract returns receiver minus the given other value. Both values must be
+// numbers; this method will panic if not.
+func (val Value) Subtract(other Value) Value {
+        if shortCircuit := mustTypeCheck(Number, Number, val, other); shortCircuit != nil {
+                shortCircuit = forceShortCircuitType(shortCircuit, Number)
+                return *shortCircuit
+        }
+
+        return val.Add(other.Negate())
+}
+
+// Negate returns the numeric negative of the receiver, which must be a number.
+// This method will panic when given a value of any other type.
+func (val Value) Negate() Value {
+        if shortCircuit := mustTypeCheck(Number, Number, val); shortCircuit != nil {
+                shortCircuit = forceShortCircuitType(shortCircuit, Number)
+                return *shortCircuit
+        }
+
+        ret := new(big.Float).Neg(val.v.(*big.Float))
+        return NumberVal(ret)
+}
+
+// Multiply returns the product of the receiver and the given other value.
+// Both values must be numbers; this method will panic if not.
+func (val Value) Multiply(other Value) Value {
+        if shortCircuit := mustTypeCheck(Number, Number, val, other); shortCircuit != nil {
+                shortCircuit = forceShortCircuitType(shortCircuit, Number)
+                return *shortCircuit
+        }
+
+        ret := new(big.Float)
+        ret.Mul(val.v.(*big.Float), other.v.(*big.Float))
+        return NumberVal(ret)
+}
+
+// Divide returns the quotient of the receiver and the given other value.
+// Both values must be numbers; this method will panic if not.
+//
+// If the "other" value is exactly zero, this operation will return either
+// PositiveInfinity or NegativeInfinity, depending on the sign of the
+// receiver value. For some use-cases the presence of infinities may be
+// undesirable, in which case the caller should check whether the
+// other value equals zero before calling and raise an error instead.
+//
+// If both values are zero or infinity, this function will panic with
+// an instance of big.ErrNaN.
+func (val Value) Divide(other Value) Value {
+        if shortCircuit := mustTypeCheck(Number, Number, val, other); shortCircuit != nil {
+                shortCircuit = forceShortCircuitType(shortCircuit, Number)
+                return *shortCircuit
+        }
+
+        ret := new(big.Float)
+        ret.Quo(val.v.(*big.Float), other.v.(*big.Float))
+        return NumberVal(ret)
+}
+
+// Modulo returns the remainder of an integer division of the receiver and
+// the given other value. Both values must be numbers; this method will panic
+// if not.
+//
+// If the "other" value is exactly zero, this operation will return either
+// PositiveInfinity or NegativeInfinity, depending on the sign of the
+// receiver value. For some use-cases the presence of infinities may be
+// undesirable, in which case the caller should check whether the
+// other value equals zero before calling and raise an error instead.
+//
+// This operation is primarily here for use with nonzero natural numbers.
+// Modulo with "other" as a non-natural number gets somewhat philosophical,
+// and this function takes a position on what that should mean, but callers
+// may wish to disallow such things outright or implement their own modulo
+// if they disagree with the interpretation used here.
+func (val Value) Modulo(other Value) Value {
+        if shortCircuit := mustTypeCheck(Number, Number, val, other); shortCircuit != nil {
+                shortCircuit = forceShortCircuitType(shortCircuit, Number)
+                return *shortCircuit
+        }
+
+        // We cheat a bit here with infinities, just abusing the Multiply operation
+        // to get an infinite result of the correct sign.
+        if val == PositiveInfinity || val == NegativeInfinity || other == PositiveInfinity || other == NegativeInfinity {
+                return val.Multiply(other)
+        }
+
+        if other.RawEquals(Zero) {
+                return val
+        }
+
+        // FIXME: This is a bit clumsy. Should come back later and see if there's a
+        // more straightforward way to do this.
+        rat := val.Divide(other)
+        ratFloorInt := &big.Int{}
+        rat.v.(*big.Float).Int(ratFloorInt)
+        work := (&big.Float{}).SetInt(ratFloorInt)
+        work.Mul(other.v.(*big.Float), work)
+        work.Sub(val.v.(*big.Float), work)
+
+        return NumberVal(work)
+}
+
+// Absolute returns the absolute (signless) value of the receiver, which must
+// be a number or this method will panic.
+func (val Value) Absolute() Value {
+        if shortCircuit := mustTypeCheck(Number, Number, val); shortCircuit != nil {
+                shortCircuit = forceShortCircuitType(shortCircuit, Number)
+                return *shortCircuit
+        }
+
+        ret := (&big.Float{}).Abs(val.v.(*big.Float))
+        return NumberVal(ret)
+}
+
+// GetAttr returns the value of the given attribute of the receiver, which
+// must be of an object type that has an attribute of the given name.
+// This method will panic if the receiver type is not compatible.
+//
+// The method will also panic if the given attribute name is not defined
+// for the value's type. Use the attribute-related methods on Type to
+// check for the validity of an attribute before trying to use it.
+//
+// This method may be called on a value whose type is DynamicPseudoType,
+// in which case the result will also be DynamicVal.
+func (val Value) GetAttr(name string) Value {
+        if val.ty == DynamicPseudoType {
+                return DynamicVal
+        }
+
+        if !val.ty.IsObjectType() {
+                panic("value is not an object")
+        }
+
+        name = NormalizeString(name)
+        if !val.ty.HasAttribute(name) {
+                panic("value has no attribute of that name")
+        }
+
+        attrType := val.ty.AttributeType(name)
+
+        if !val.IsKnown() {
+                return UnknownVal(attrType)
+        }
+
+        return Value{
+                ty: attrType,
+                v:  val.v.(map[string]interface{})[name],
+        }
+}
+
+// Index returns the value of an element of the receiver, which must have
+// either a list, map or tuple type. This method will panic if the receiver
+// type is not compatible.
+//
+// The key value must be the correct type for the receving collection: a
+// number if the collection is a list or tuple, or a string if it is a map.
+// In the case of a list or tuple, the given number must be convertable to int
+// or this method will panic. The key may alternatively be of
+// DynamicPseudoType, in which case the result itself is an unknown of the
+// collection's element type.
+//
+// The result is of the receiver collection's element type, or in the case
+// of a tuple the type of the specific element index requested.
+//
+// This method may be called on a value whose type is DynamicPseudoType,
+// in which case the result will also be the DynamicValue.
+func (val Value) Index(key Value) Value {
+        if val.ty == DynamicPseudoType {
+                return DynamicVal
+        }
+
+        switch {
+        case val.Type().IsListType():
+                elty := val.Type().ElementType()
+                if key.Type() == DynamicPseudoType {
+                        return UnknownVal(elty)
+                }
+
+                if key.Type() != Number {
+                        panic("element key for list must be number")
+                }
+                if !key.IsKnown() {
+                        return UnknownVal(elty)
+                }
+
+                if !val.IsKnown() {
+                        return UnknownVal(elty)
+                }
+
+                index, accuracy := key.v.(*big.Float).Int64()
+                if accuracy != big.Exact || index < 0 {
+                        panic("element key for list must be non-negative integer")
+                }
+
+                return Value{
+                        ty: elty,
+                        v:  val.v.([]interface{})[index],
+                }
+        case val.Type().IsMapType():
+                elty := val.Type().ElementType()
+                if key.Type() == DynamicPseudoType {
+                        return UnknownVal(elty)
+                }
+
+                if key.Type() != String {
+                        panic("element key for map must be string")
+                }
+                if !key.IsKnown() {
+                        return UnknownVal(elty)
+                }
+
+                if !val.IsKnown() {
+                        return UnknownVal(elty)
+                }
+
+                keyStr := key.v.(string)
+
+                return Value{
+                        ty: elty,
+                        v:  val.v.(map[string]interface{})[keyStr],
+                }
+        case val.Type().IsTupleType():
+                if key.Type() == DynamicPseudoType {
+                        return DynamicVal
+                }
+
+                if key.Type() != Number {
+                        panic("element key for tuple must be number")
+                }
+                if !key.IsKnown() {
+                        return DynamicVal
+                }
+
+                index, accuracy := key.v.(*big.Float).Int64()
+                if accuracy != big.Exact || index < 0 {
+                        panic("element key for list must be non-negative integer")
+                }
+
+                eltys := val.Type().TupleElementTypes()
+
+                if !val.IsKnown() {
+                        return UnknownVal(eltys[index])
+                }
+
+                return Value{
+                        ty: eltys[index],
+                        v:  val.v.([]interface{})[index],
+                }
+        default:
+                panic("not a list, map, or tuple type")
+        }
+}
+
+// HasIndex returns True if the receiver (which must be supported for Index)
+// has an element with the given index key, or False if it does not.
+//
+// The result will be UnknownVal(Bool) if either the collection or the
+// key value are unknown.
+//
+// This method will panic if the receiver is not indexable, but does not
+// impose any panic-causing type constraints on the key.
+func (val Value) HasIndex(key Value) Value {
+        if val.ty == DynamicPseudoType {
+                return UnknownVal(Bool)
+        }
+
+        switch {
+        case val.Type().IsListType():
+                if key.Type() == DynamicPseudoType {
+                        return UnknownVal(Bool)
+                }
+
+                if key.Type() != Number {
+                        return False
+                }
+                if !key.IsKnown() {
+                        return UnknownVal(Bool)
+                }
+                if !val.IsKnown() {
+                        return UnknownVal(Bool)
+                }
+
+                index, accuracy := key.v.(*big.Float).Int64()
+                if accuracy != big.Exact || index < 0 {
+                        return False
+                }
+
+                return BoolVal(int(index) < len(val.v.([]interface{})) && index >= 0)
+        case val.Type().IsMapType():
+                if key.Type() == DynamicPseudoType {
+                        return UnknownVal(Bool)
+                }
+
+                if key.Type() != String {
+                        return False
+                }
+                if !key.IsKnown() {
+                        return UnknownVal(Bool)
+                }
+                if !val.IsKnown() {
+                        return UnknownVal(Bool)
+                }
+
+                keyStr := key.v.(string)
+                _, exists := val.v.(map[string]interface{})[keyStr]
+
+                return BoolVal(exists)
+        case val.Type().IsTupleType():
+                if key.Type() == DynamicPseudoType {
+                        return UnknownVal(Bool)
+                }
+
+                if key.Type() != Number {
+                        return False
+                }
+                if !key.IsKnown() {
+                        return UnknownVal(Bool)
+                }
+
+                index, accuracy := key.v.(*big.Float).Int64()
+                if accuracy != big.Exact || index < 0 {
+                        return False
+                }
+
+                length := val.Type().Length()
+                return BoolVal(int(index) < length && index >= 0)
+        default:
+                panic("not a list, map, or tuple type")
+        }
+}
+
+// HasElement returns True if the receiver (which must be of a set type)
+// has the given value as an element, or False if it does not.
+//
+// The result will be UnknownVal(Bool) if either the set or the
+// given value are unknown.
+//
+// This method will panic if the receiver is not a set, or if it is a null set.
+func (val Value) HasElement(elem Value) Value {
+        ty := val.Type()
+
+        if !ty.IsSetType() {
+                panic("not a set type")
+        }
+        if !val.IsKnown() || !elem.IsKnown() {
+                return UnknownVal(Bool)
+        }
+        if val.IsNull() {
+                panic("can't call HasElement on a nil value")
+        }
+        if ty.ElementType() != elem.Type() {
+                return False
+        }
+
+        s := val.v.(set.Set)
+        return BoolVal(s.Has(elem.v))
+}
+
+// Length returns the length of the receiver, which must be a collection type
+// or tuple type, as a number value. If the receiver is not a compatible type
+// then this method will panic.
+//
+// If the receiver is unknown then the result is also unknown.
+//
+// If the receiver is null then this function will panic.
+//
+// Note that Length is not supported for strings. To determine the length
+// of a string, call AsString and take the length of the native Go string
+// that is returned.
+func (val Value) Length() Value {
+        if val.Type().IsTupleType() {
+                // For tuples, we can return the length even if the value is not known.
+                return NumberIntVal(int64(val.Type().Length()))
+        }
+
+        if !val.IsKnown() {
+                return UnknownVal(Number)
+        }
+
+        return NumberIntVal(int64(val.LengthInt()))
+}
+
+// LengthInt is like Length except it returns an int. It has the same behavior
+// as Length except that it will panic if the receiver is unknown.
+//
+// This is an integration method provided for the convenience of code bridging
+// into Go's type system.
+func (val Value) LengthInt() int {
+        if val.Type().IsTupleType() {
+                // For tuples, we can return the length even if the value is not known.
+                return val.Type().Length()
+        }
+        if !val.IsKnown() {
+                panic("value is not known")
+        }
+        if val.IsNull() {
+                panic("value is null")
+        }
+
+        switch {
+
+        case val.ty.IsListType():
+                return len(val.v.([]interface{}))
+
+        case val.ty.IsSetType():
+                return val.v.(set.Set).Length()
+
+        case val.ty.IsMapType():
+                return len(val.v.(map[string]interface{}))
+
+        default:
+                panic("value is not a collection")
+        }
+}
+
+// ElementIterator returns an ElementIterator for iterating the elements
+// of the receiver, which must be a collection type, a tuple type, or an object
+// type. If called on a method of any other type, this method will panic.
+//
+// The value must be Known and non-Null, or this method will panic.
+//
+// If the receiver is of a list type, the returned keys will be of type Number
+// and the values will be of the list's element type.
+//
+// If the receiver is of a map type, the returned keys will be of type String
+// and the value will be of the map's element type. Elements are passed in
+// ascending lexicographical order by key.
+//
+// If the receiver is of a set type, each element is returned as both the
+// key and the value, since set members are their own identity.
+//
+// If the receiver is of a tuple type, the returned keys will be of type Number
+// and the value will be of the corresponding element's type.
+//
+// If the receiver is of an object type, the returned keys will be of type
+// String and the value will be of the corresponding attributes's type.
+//
+// ElementIterator is an integration method, so it cannot handle Unknown
+// values. This method will panic if the receiver is Unknown.
+func (val Value) ElementIterator() ElementIterator {
+        if !val.IsKnown() {
+                panic("can't use ElementIterator on unknown value")
+        }
+        if val.IsNull() {
+                panic("can't use ElementIterator on null value")
+        }
+        return elementIterator(val)
+}
+
+// CanIterateElements returns true if the receiver can support the
+// ElementIterator method (and by extension, ForEachElement) without panic.
+func (val Value) CanIterateElements() bool {
+        return canElementIterator(val)
+}
+
+// ForEachElement executes a given callback function for each element of
+// the receiver, which must be a collection type or tuple type, or this method
+// will panic.
+//
+// ForEachElement uses ElementIterator internally, and so the values passed
+// to the callback are as described for ElementIterator.
+//
+// Returns true if the iteration exited early due to the callback function
+// returning true, or false if the loop ran to completion.
+//
+// ForEachElement is an integration method, so it cannot handle Unknown
+// values. This method will panic if the receiver is Unknown.
+func (val Value) ForEachElement(cb ElementCallback) bool {
+        it := val.ElementIterator()
+        for it.Next() {
+                key, val := it.Element()
+                stop := cb(key, val)
+                if stop {
+                        return true
+                }
+        }
+        return false
+}
+
+// Not returns the logical inverse of the receiver, which must be of type
+// Bool or this method will panic.
+func (val Value) Not() Value {
+        if shortCircuit := mustTypeCheck(Bool, Bool, val); shortCircuit != nil {
+                shortCircuit = forceShortCircuitType(shortCircuit, Bool)
+                return *shortCircuit
+        }
+
+        return BoolVal(!val.v.(bool))
+}
+
+// And returns the result of logical AND with the receiver and the other given
+// value, which must both be of type Bool or this method will panic.
+func (val Value) And(other Value) Value {
+        if shortCircuit := mustTypeCheck(Bool, Bool, val, other); shortCircuit != nil {
+                shortCircuit = forceShortCircuitType(shortCircuit, Bool)
+                return *shortCircuit
+        }
+
+        return BoolVal(val.v.(bool) && other.v.(bool))
+}
+
+// Or returns the result of logical OR with the receiver and the other given
+// value, which must both be of type Bool or this method will panic.
+func (val Value) Or(other Value) Value {
+        if shortCircuit := mustTypeCheck(Bool, Bool, val, other); shortCircuit != nil {
+                shortCircuit = forceShortCircuitType(shortCircuit, Bool)
+                return *shortCircuit
+        }
+
+        return BoolVal(val.v.(bool) || other.v.(bool))
+}
+
+// LessThan returns True if the receiver is less than the other given value,
+// which must both be numbers or this method will panic.
+func (val Value) LessThan(other Value) Value {
+        if shortCircuit := mustTypeCheck(Number, Bool, val, other); shortCircuit != nil {
+                shortCircuit = forceShortCircuitType(shortCircuit, Bool)
+                return *shortCircuit
+        }
+
+        return BoolVal(val.v.(*big.Float).Cmp(other.v.(*big.Float)) < 0)
+}
+
+// GreaterThan returns True if the receiver is greater than the other given
+// value, which must both be numbers or this method will panic.
+func (val Value) GreaterThan(other Value) Value {
+        if shortCircuit := mustTypeCheck(Number, Bool, val, other); shortCircuit != nil {
+                shortCircuit = forceShortCircuitType(shortCircuit, Bool)
+                return *shortCircuit
+        }
+
+        return BoolVal(val.v.(*big.Float).Cmp(other.v.(*big.Float)) > 0)
+}
+
+// LessThanOrEqualTo is equivalent to LessThan and Equal combined with Or.
+func (val Value) LessThanOrEqualTo(other Value) Value {
+        return val.LessThan(other).Or(val.Equals(other))
+}
+
+// GreaterThanOrEqualTo is equivalent to GreaterThan and Equal combined with Or.
+func (val Value) GreaterThanOrEqualTo(other Value) Value {
+        return val.GreaterThan(other).Or(val.Equals(other))
+}
+
+// AsString returns the native string from a non-null, non-unknown cty.String
+// value, or panics if called on any other value.
+func (val Value) AsString() string {
+        if val.ty != String {
+                panic("not a string")
+        }
+        if val.IsNull() {
+                panic("value is null")
+        }
+        if !val.IsKnown() {
+                panic("value is unknown")
+        }
+
+        return val.v.(string)
+}
+
+// AsBigFloat returns a big.Float representation of a non-null, non-unknown
+// cty.Number value, or panics if called on any other value.
+//
+// For more convenient conversions to other native numeric types, use the
+// "gocty" package.
+func (val Value) AsBigFloat() *big.Float {
+        if val.ty != Number {
+                panic("not a number")
+        }
+        if val.IsNull() {
+                panic("value is null")
+        }
+        if !val.IsKnown() {
+                panic("value is unknown")
+        }
+
+        // Copy the float so that callers can't mutate our internal state
+        ret := *(val.v.(*big.Float))
+
+        return &ret
+}
+
+// AsValueSlice returns a []cty.Value representation of a non-null, non-unknown
+// value of any type that CanIterateElements, or panics if called on
+// any other value.
+//
+// For more convenient conversions to slices of more specific types, use
+// the "gocty" package.
+func (val Value) AsValueSlice() []Value {
+        l := val.LengthInt()
+        if l == 0 {
+                return nil
+        }
+
+        ret := make([]Value, 0, l)
+        for it := val.ElementIterator(); it.Next(); {
+                _, v := it.Element()
+                ret = append(ret, v)
+        }
+        return ret
+}
+
+// AsValueMap returns a map[string]cty.Value representation of a non-null,
+// non-unknown value of any type that CanIterateElements, or panics if called
+// on any other value.
+//
+// For more convenient conversions to maps of more specific types, use
+// the "gocty" package.
+func (val Value) AsValueMap() map[string]Value {
+        l := val.LengthInt()
+        if l == 0 {
+                return nil
+        }
+
+        ret := make(map[string]Value, l)
+        for it := val.ElementIterator(); it.Next(); {
+                k, v := it.Element()
+                ret[k.AsString()] = v
+        }
+        return ret
+}
+
+// AsValueSet returns a ValueSet representation of a non-null,
+// non-unknown value of any collection type, or panics if called
+// on any other value.
+//
+// Unlike AsValueSlice and AsValueMap, this method requires specifically a
+// collection type (list, set or map) and does not allow structural types
+// (tuple or object), because the ValueSet type requires homogenous
+// element types.
+//
+// The returned ValueSet can store only values of the receiver's element type.
+func (val Value) AsValueSet() ValueSet {
+        if !val.Type().IsCollectionType() {
+                panic("not a collection type")
+        }
+
+        // We don't give the caller our own set.Set (assuming we're a cty.Set value)
+        // because then the caller could mutate our internals, which is forbidden.
+        // Instead, we will construct a new set and append our elements into it.
+        ret := NewValueSet(val.Type().ElementType())
+        for it := val.ElementIterator(); it.Next(); {
+                _, v := it.Element()
+                ret.Add(v)
+        }
+        return ret
+}
+
+// EncapsulatedValue returns the native value encapsulated in a non-null,
+// non-unknown capsule-typed value, or panics if called on any other value.
+//
+// The result is the same pointer that was passed to CapsuleVal to create
+// the value. Since cty considers values to be immutable, it is strongly
+// recommended to treat the encapsulated value itself as immutable too.
+func (val Value) EncapsulatedValue() interface{} {
+        if !val.Type().IsCapsuleType() {
+                panic("not a capsule-typed value")
+        }
+
+        return val.v
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/walk.go b/vendor/github.com/zclconf/go-cty/cty/walk.go
new file mode 100644
index 0000000..a6943ba
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/walk.go
@@ -0,0 +1,182 @@
+package cty
+
+// Walk visits all of the values in a possibly-complex structure, calling
+// a given function for each value.
+//
+// For example, given a list of strings the callback would first be called
+// with the whole list and then called once for each element of the list.
+//
+// The callback function may prevent recursive visits to child values by
+// returning false. The callback function my halt the walk altogether by
+// returning a non-nil error. If the returned error is about the element
+// currently being visited, it is recommended to use the provided path
+// value to produce a PathError describing that context.
+//
+// The path passed to the given function may not be used after that function
+// returns, since its backing array is re-used for other calls.
+func Walk(val Value, cb func(Path, Value) (bool, error)) error {
+        var path Path
+        return walk(path, val, cb)
+}
+
+func walk(path Path, val Value, cb func(Path, Value) (bool, error)) error {
+        deeper, err := cb(path, val)
+        if err != nil {
+                return err
+        }
+        if !deeper {
+                return nil
+        }
+
+        if val.IsNull() || !val.IsKnown() {
+                // Can't recurse into null or unknown values, regardless of type
+                return nil
+        }
+
+        ty := val.Type()
+        switch {
+        case ty.IsObjectType():
+                for it := val.ElementIterator(); it.Next(); {
+                        nameVal, av := it.Element()
+                        path := append(path, GetAttrStep{
+                                Name: nameVal.AsString(),
+                        })
+                        err := walk(path, av, cb)
+                        if err != nil {
+                                return err
+                        }
+                }
+        case val.CanIterateElements():
+                for it := val.ElementIterator(); it.Next(); {
+                        kv, ev := it.Element()
+                        path := append(path, IndexStep{
+                                Key: kv,
+                        })
+                        err := walk(path, ev, cb)
+                        if err != nil {
+                                return err
+                        }
+                }
+        }
+        return nil
+}
+
+// Transform visits all of the values in a possibly-complex structure,
+// calling a given function for each value which has an opportunity to
+// replace that value.
+//
+// Unlike Walk, Transform visits child nodes first, so for a list of strings
+// it would first visit the strings and then the _new_ list constructed
+// from the transformed values of the list items.
+//
+// This is useful for creating the effect of being able to make deep mutations
+// to a value even though values are immutable. However, it's the responsibility
+// of the given function to preserve expected invariants, such as homogenity of
+// element types in collections; this function can panic if such invariants
+// are violated, just as if new values were constructed directly using the
+// value constructor functions. An easy way to preserve invariants is to
+// ensure that the transform function never changes the value type.
+//
+// The callback function my halt the walk altogether by
+// returning a non-nil error. If the returned error is about the element
+// currently being visited, it is recommended to use the provided path
+// value to produce a PathError describing that context.
+//
+// The path passed to the given function may not be used after that function
+// returns, since its backing array is re-used for other calls.
+func Transform(val Value, cb func(Path, Value) (Value, error)) (Value, error) {
+        var path Path
+        return transform(path, val, cb)
+}
+
+func transform(path Path, val Value, cb func(Path, Value) (Value, error)) (Value, error) {
+        ty := val.Type()
+        var newVal Value
+
+        switch {
+
+        case val.IsNull() || !val.IsKnown():
+                // Can't recurse into null or unknown values, regardless of type
+                newVal = val
+
+        case ty.IsListType() || ty.IsSetType() || ty.IsTupleType():
+                l := val.LengthInt()
+                switch l {
+                case 0:
+                        // No deep transform for an empty sequence
+                        newVal = val
+                default:
+                        elems := make([]Value, 0, l)
+                        for it := val.ElementIterator(); it.Next(); {
+                                kv, ev := it.Element()
+                                path := append(path, IndexStep{
+                                        Key: kv,
+                                })
+                                newEv, err := transform(path, ev, cb)
+                                if err != nil {
+                                        return DynamicVal, err
+                                }
+                                elems = append(elems, newEv)
+                        }
+                        switch {
+                        case ty.IsListType():
+                                newVal = ListVal(elems)
+                        case ty.IsSetType():
+                                newVal = SetVal(elems)
+                        case ty.IsTupleType():
+                                newVal = TupleVal(elems)
+                        default:
+                                panic("unknown sequence type") // should never happen because of the case we are in
+                        }
+                }
+
+        case ty.IsMapType():
+                l := val.LengthInt()
+                switch l {
+                case 0:
+                        // No deep transform for an empty map
+                        newVal = val
+                default:
+                        elems := make(map[string]Value)
+                        for it := val.ElementIterator(); it.Next(); {
+                                kv, ev := it.Element()
+                                path := append(path, IndexStep{
+                                        Key: kv,
+                                })
+                                newEv, err := transform(path, ev, cb)
+                                if err != nil {
+                                        return DynamicVal, err
+                                }
+                                elems[kv.AsString()] = newEv
+                        }
+                        newVal = MapVal(elems)
+                }
+
+        case ty.IsObjectType():
+                switch {
+                case ty.Equals(EmptyObject):
+                        // No deep transform for an empty object
+                        newVal = val
+                default:
+                        atys := ty.AttributeTypes()
+                        newAVs := make(map[string]Value)
+                        for name := range atys {
+                                av := val.GetAttr(name)
+                                path := append(path, GetAttrStep{
+                                        Name: name,
+                                })
+                                newAV, err := transform(path, av, cb)
+                                if err != nil {
+                                        return DynamicVal, err
+                                }
+                                newAVs[name] = newAV
+                        }
+                        newVal = ObjectVal(newAVs)
+                }
+
+        default:
+                newVal = val
+        }
+
+        return cb(path, newVal)
+}