diff --git a/go.mod b/go.mod
index 0f1592dcb..a06befe8e 100644
--- a/go.mod
+++ b/go.mod
@@ -41,7 +41,7 @@ require (
 	github.com/spf13/pflag v1.0.5
 	github.com/spf13/viper v1.13.0
 	github.com/stretchr/testify v1.8.0
-	github.com/zclconf/go-cty v1.11.0
+	github.com/zclconf/go-cty v1.12.1
 	go.uber.org/zap v1.24.0
 	golang.org/x/crypto v0.3.0
 	golang.org/x/net v0.2.0 // indirect
diff --git a/go.sum b/go.sum
index 9a602a33e..a20548c4f 100644
--- a/go.sum
+++ b/go.sum
@@ -403,8 +403,8 @@ github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/zclconf/go-cty v1.2.0/go.mod h1:hOPWgoHbaTUnI5k4D2ld+GRpFJSCe6bCM7m1q/N4PQ8=
 github.com/zclconf/go-cty v1.10.0/go.mod h1:vVKLxnk3puL4qRAv72AO+W99LUD4da90g3uUAzyuvAk=
-github.com/zclconf/go-cty v1.11.0 h1:726SxLdi2SDnjY+BStqB9J1hNp4+2WlzyXLuimibIe0=
-github.com/zclconf/go-cty v1.11.0/go.mod h1:s9IfD1LK5ccNMSWCVFCE2rJfHiZgi7JijgeWIMfhLvA=
+github.com/zclconf/go-cty v1.12.1 h1:PcupnljUm9EIvbgSHQnHhUr3fO6oFmkOrvs2BAFNXXY=
+github.com/zclconf/go-cty v1.12.1/go.mod h1:s9IfD1LK5ccNMSWCVFCE2rJfHiZgi7JijgeWIMfhLvA=
 github.com/zclconf/go-cty-debug v0.0.0-20191215020915-b22d67c1ba0b/go.mod h1:ZRKQfBXbGkpdV6QMzT3rU1kSTAnfu1dO8dPKjYprgj8=
 go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
 go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion.go
index ededc5f37..541b9a490 100644
--- a/vendor/github.com/zclconf/go-cty/cty/convert/conversion.go
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion.go
@@ -43,14 +43,14 @@ func getConversion(in cty.Type, out cty.Type, unsafe bool) conversion {
 			out = out.WithoutOptionalAttributesDeep()
 
 			if !isKnown {
-				return cty.UnknownVal(out), nil
+				return cty.UnknownVal(dynamicReplace(in.Type(), out)), nil
 			}
 
 			if 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 cty.NullVal(dynamicReplace(in.Type(), out)), 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
index e70b0184c..05399c9a6 100644
--- a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_collection.go
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_collection.go
@@ -39,6 +39,11 @@ func conversionCollectionToList(ety cty.Type, conv conversion) conversion {
 					return cty.NilVal, err
 				}
 			}
+
+			if val.IsNull() {
+				val = cty.NullVal(val.Type().WithoutOptionalAttributesDeep())
+			}
+
 			elems = append(elems, val)
 
 			i++
@@ -50,7 +55,7 @@ func conversionCollectionToList(ety cty.Type, conv conversion) conversion {
 			if ety == cty.DynamicPseudoType {
 				return cty.ListValEmpty(val.Type().ElementType()), nil
 			}
-			return cty.ListValEmpty(ety), nil
+			return cty.ListValEmpty(ety.WithoutOptionalAttributesDeep()), nil
 		}
 
 		if !cty.CanListVal(elems) {
@@ -88,6 +93,11 @@ func conversionCollectionToSet(ety cty.Type, conv conversion) conversion {
 					return cty.NilVal, err
 				}
 			}
+
+			if val.IsNull() {
+				val = cty.NullVal(val.Type().WithoutOptionalAttributesDeep())
+			}
+
 			elems = append(elems, val)
 
 			i++
@@ -99,7 +109,7 @@ func conversionCollectionToSet(ety cty.Type, conv conversion) conversion {
 			if ety == cty.DynamicPseudoType {
 				return cty.SetValEmpty(val.Type().ElementType()), nil
 			}
-			return cty.SetValEmpty(ety), nil
+			return cty.SetValEmpty(ety.WithoutOptionalAttributesDeep()), nil
 		}
 
 		if !cty.CanSetVal(elems) {
@@ -180,7 +190,7 @@ func conversionTupleToSet(tupleType cty.Type, setEty cty.Type, unsafe bool) conv
 	if len(tupleEtys) == 0 {
 		// Empty tuple short-circuit
 		return func(val cty.Value, path cty.Path) (cty.Value, error) {
-			return cty.SetValEmpty(setEty), nil
+			return cty.SetValEmpty(setEty.WithoutOptionalAttributesDeep()), nil
 		}
 	}
 
@@ -242,6 +252,11 @@ func conversionTupleToSet(tupleType cty.Type, setEty cty.Type, unsafe bool) conv
 					return cty.NilVal, err
 				}
 			}
+
+			if val.IsNull() {
+				val = cty.NullVal(val.Type().WithoutOptionalAttributesDeep())
+			}
+
 			elems = append(elems, val)
 
 			i++
@@ -265,7 +280,7 @@ func conversionTupleToList(tupleType cty.Type, listEty cty.Type, unsafe bool) co
 	if len(tupleEtys) == 0 {
 		// Empty tuple short-circuit
 		return func(val cty.Value, path cty.Path) (cty.Value, error) {
-			return cty.ListValEmpty(listEty), nil
+			return cty.ListValEmpty(listEty.WithoutOptionalAttributesDeep()), nil
 		}
 	}
 
@@ -357,7 +372,7 @@ func conversionObjectToMap(objectType cty.Type, mapEty cty.Type, unsafe bool) co
 	if len(objectAtys) == 0 {
 		// Empty object short-circuit
 		return func(val cty.Value, path cty.Path) (cty.Value, error) {
-			return cty.MapValEmpty(mapEty), nil
+			return cty.MapValEmpty(mapEty.WithoutOptionalAttributesDeep()), nil
 		}
 	}
 
@@ -448,13 +463,28 @@ func conversionMapToObject(mapType cty.Type, objType cty.Type, unsafe bool) conv
 
 		elemConvs[name] = getConversion(mapEty, objectAty, unsafe)
 		if elemConvs[name] == nil {
-			// If any of our element conversions are impossible, then the our
-			// whole conversion is impossible.
+			// This means that this conversion is impossible. Typically, we
+			// would give up at this point and declare the whole conversion
+			// impossible. But, if this attribute is optional then maybe we will
+			// be able to do this conversion anyway provided the actual concrete
+			// map doesn't have this value set.
+			//
+			// We only do this in "unsafe" mode, because we cannot guarantee
+			// that the returned conversion will actually succeed once applied.
+			if objType.AttributeOptional(name) && unsafe {
+				// This attribute is optional, so let's leave this conversion in
+				// as a nil, and we can error later if we actually have to
+				// convert this.
+				continue
+			}
+
+			// Otherwise, give up. This conversion is impossible as we have a
+			// required attribute that doesn't match the map's inner type.
 			return nil
 		}
 	}
 
-	// If we fall out here then a conversion is possible, using the
+	// If we fall out here then a conversion may be 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))
@@ -474,12 +504,43 @@ func conversionMapToObject(mapType cty.Type, objType cty.Type, unsafe bool) conv
 				Key: name,
 			}
 
-			conv := elemConvs[name.AsString()]
-			if conv != nil {
+			// There are 3 cases here:
+			//   1. This attribute is not in elemConvs
+			//   2. This attribute is in elemConvs and is not nil
+			//   3. This attribute is in elemConvs and is nil.
+
+			// In case 1, we do not enter any of the branches below. This case
+			// means the attribute type is the same between the map and the
+			// object, and we don't need to do any conversion.
+
+			if conv, ok := elemConvs[name.AsString()]; conv != nil {
+				// This is case 2. The attribute type is different between the
+				// map and the object, and we know how to convert between them.
+				// So, we reset val to be the converted value and carry on.
 				val, err = conv(val, elemPath)
 				if err != nil {
 					return cty.NilVal, err
 				}
+			} else if ok {
+				// This is case 3 and it is an error. The attribute types are
+				// different between the map and the object, but we cannot
+				// convert between them.
+				//
+				// Now typically, this would be picked earlier on when we were
+				// building elemConvs. However, in the case of optional
+				// attributes there was a chance we could still convert the
+				// overall object even if this particular attribute was not
+				// convertable. This is because it could have not been set in
+				// the map, and we could skip over it here and set a null value.
+				//
+				// Since we reached this branch, we know that map did actually
+				// contain a non-convertable optional attribute. This means we
+				// error.
+				return cty.NilVal, path.NewErrorf("map element type is incompatible with attribute %q: %s", name.AsString(), MismatchMessage(val.Type(), objType.AttributeType(name.AsString())))
+			}
+
+			if val.IsNull() {
+				val = cty.NullVal(val.Type().WithoutOptionalAttributesDeep())
 			}
 
 			elems[name.AsString()] = val
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
index 4d19cf6c5..3b554e01b 100644
--- a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_dynamic.go
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_dynamic.go
@@ -31,3 +31,107 @@ func dynamicFixup(wantType cty.Type) conversion {
 func dynamicPassthrough(in cty.Value, path cty.Path) (cty.Value, error) {
 	return in, nil
 }
+
+// dynamicReplace aims to return the out type unchanged, but if it finds a
+// dynamic type either directly or in any descendent elements it replaces them
+// with the equivalent type from in.
+//
+// This function assumes that in and out are compatible from a Convert
+// perspective, and will panic if it finds that they are not. For example if
+// in is an object and out is a map, this function will still attempt to iterate
+// through both as if they were the same.
+func dynamicReplace(in, out cty.Type) cty.Type {
+	if in == cty.DynamicPseudoType || in == cty.NilType {
+		// Short circuit this case, there's no point worrying about this if in
+		// is a dynamic type or a nil type. Out is the best we can do.
+		return out
+	}
+
+	switch {
+	case out == cty.DynamicPseudoType:
+		// So replace out with in.
+		return in
+	case out.IsPrimitiveType(), out.IsCapsuleType():
+		// out is not dynamic and it doesn't contain descendent elements so just
+		// return it unchanged.
+		return out
+	case out.IsMapType():
+		var elemType cty.Type
+
+		// Maps are compatible with other maps or objects.
+		if in.IsMapType() {
+			elemType = dynamicReplace(in.ElementType(), out.ElementType())
+		}
+
+		if in.IsObjectType() {
+			var types []cty.Type
+			for _, t := range in.AttributeTypes() {
+				types = append(types, t)
+			}
+			unifiedType, _ := unify(types, true)
+			elemType = dynamicReplace(unifiedType, out.ElementType())
+		}
+
+		return cty.Map(elemType)
+	case out.IsObjectType():
+		// Objects are compatible with other objects and maps.
+		outTypes := map[string]cty.Type{}
+		if in.IsMapType() {
+			for attr, attrType := range out.AttributeTypes() {
+				outTypes[attr] = dynamicReplace(in.ElementType(), attrType)
+			}
+		}
+
+		if in.IsObjectType() {
+			for attr, attrType := range out.AttributeTypes() {
+				if !in.HasAttribute(attr) {
+					// If in does not have this attribute, then it is an
+					// optional attribute and there is nothing we can do except
+					// to return the type from out even if it is dynamic.
+					outTypes[attr] = attrType
+					continue
+				}
+				outTypes[attr] = dynamicReplace(in.AttributeType(attr), attrType)
+			}
+		}
+
+		return cty.Object(outTypes)
+	case out.IsSetType():
+		var elemType cty.Type
+
+		// Sets are compatible with other sets, lists, tuples.
+		if in.IsSetType() || in.IsListType() {
+			elemType = dynamicReplace(in.ElementType(), out.ElementType())
+		}
+
+		if in.IsTupleType() {
+			unifiedType, _ := unify(in.TupleElementTypes(), true)
+			elemType = dynamicReplace(unifiedType, out.ElementType())
+		}
+
+		return cty.Set(elemType)
+	case out.IsListType():
+		var elemType cty.Type
+
+		// Lists are compatible with other lists, sets, and tuples.
+		if in.IsSetType() || in.IsListType() {
+			elemType = dynamicReplace(in.ElementType(), out.ElementType())
+		}
+
+		if in.IsTupleType() {
+			unifiedType, _ := unify(in.TupleElementTypes(), true)
+			elemType = dynamicReplace(unifiedType, out.ElementType())
+		}
+
+		return cty.List(elemType)
+	case out.IsTupleType():
+		// Tuples are only compatible with other tuples
+		var types []cty.Type
+		for ix := 0; ix < len(out.TupleElementTypes()); ix++ {
+			types = append(types, dynamicReplace(in.TupleElementType(ix), out.TupleElementType(ix)))
+		}
+		return cty.Tuple(types)
+	default:
+		panic("unrecognized type " + out.FriendlyName())
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_object.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_object.go
index 098c109bd..51958ef4b 100644
--- a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_object.go
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_object.go
@@ -80,13 +80,19 @@ func conversionObjectToObject(in, out cty.Type, unsafe bool) conversion {
 				}
 			}
 
+			if val.IsNull() {
+				// Strip optional attributes out of the embedded type for null
+				// values.
+				val = cty.NullVal(val.Type().WithoutOptionalAttributesDeep())
+			}
+
 			attrVals[name] = val
 		}
 
 		for name := range outOptionals {
 			if _, exists := attrVals[name]; !exists {
 				wantTy := outAtys[name]
-				attrVals[name] = cty.NullVal(wantTy)
+				attrVals[name] = cty.NullVal(wantTy.WithoutOptionalAttributesDeep())
 			}
 		}
 
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/public.go b/vendor/github.com/zclconf/go-cty/cty/convert/public.go
index af19bdc50..aab0d0ec9 100644
--- a/vendor/github.com/zclconf/go-cty/cty/convert/public.go
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/public.go
@@ -40,7 +40,7 @@ func GetConversionUnsafe(in cty.Type, out cty.Type) Conversion {
 // 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) {
+	if in.Type().Equals(want.WithoutOptionalAttributesDeep()) {
 		return in, nil
 	}
 
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/argument.go b/vendor/github.com/zclconf/go-cty/cty/function/argument.go
index 5a26c275f..61a1cf97d 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/argument.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/argument.go
@@ -10,6 +10,9 @@ type Parameter struct {
 	// value, but callers may use it for documentation, etc.
 	Name string
 
+	// Description is an optional description for the argument.
+	Description 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
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/function.go b/vendor/github.com/zclconf/go-cty/cty/function/function.go
index c00a0e7f8..c4d99f6c9 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/function.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/function.go
@@ -14,6 +14,9 @@ type Function struct {
 // Spec is the specification of a function, used to instantiate
 // a new Function.
 type Spec struct {
+	// Description is an optional description for the function specification.
+	Description string
+
 	// 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
@@ -344,3 +347,62 @@ func (f Function) VarParam() *Parameter {
 	ret := *f.spec.VarParam
 	return &ret
 }
+
+// Description returns a human-readable description of the function.
+func (f Function) Description() string {
+	return f.spec.Description
+}
+
+// WithNewDescriptions returns a new function that has the same signature
+// and implementation as the receiver but has the function description and
+// the parameter descriptions replaced with those given in the arguments.
+//
+// All descriptions may be given as an empty string to specify that there
+// should be no description at all.
+//
+// The paramDescs argument must match the number of parameters
+// the reciever expects, or this function will panic. If the function has a
+// VarParam then that counts as one parameter for the sake of this rule. The
+// given descriptions will be assigned in order starting with the positional
+// arguments in their declared order, followed by the variadic parameter if
+// any.
+//
+// As a special case, WithNewDescriptions will accept a paramDescs which
+// does not cover the reciever's variadic parameter (if any), so that it's
+// possible to add a variadic parameter to a function which didn't previously
+// have one without that being a breaking change for an existing caller using
+// WithNewDescriptions against that function. In this case the base description
+// of the variadic parameter will be preserved.
+func (f Function) WithNewDescriptions(funcDesc string, paramDescs []string) Function {
+	retSpec := *f.spec // shallow copy of the reciever
+	retSpec.Description = funcDesc
+
+	retSpec.Params = make([]Parameter, len(f.spec.Params))
+	copy(retSpec.Params, f.spec.Params) // shallow copy of positional parameters
+	if f.spec.VarParam != nil {
+		retVarParam := *f.spec.VarParam // shallow copy of variadic parameter
+		retSpec.VarParam = &retVarParam
+	}
+
+	if retSpec.VarParam != nil {
+		if with, without := len(retSpec.Params)+1, len(retSpec.Params); len(paramDescs) != with && len(paramDescs) != without {
+			panic(fmt.Sprintf("paramDescs must have length of either %d or %d", with, without))
+		}
+	} else {
+		if want := len(retSpec.Params); len(paramDescs) != want {
+			panic(fmt.Sprintf("paramDescs must have length %d", want))
+		}
+	}
+
+	posParamDescs := paramDescs[:len(retSpec.Params)]
+	varParamDescs := paramDescs[len(retSpec.Params):] // guaranteed to be zero or one elements because of the rules above
+
+	for i, desc := range posParamDescs {
+		retSpec.Params[i].Description = desc
+	}
+	for _, desc := range varParamDescs {
+		retSpec.VarParam.Description = desc
+	}
+
+	return New(&retSpec)
+}
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
index 4f1ecc8d9..8192d8ce8 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bool.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bool.go
@@ -6,6 +6,7 @@ import (
 )
 
 var NotFunc = function.New(&function.Spec{
+	Description: `Applies the logical NOT operation to the given boolean value.`,
 	Params: []function.Parameter{
 		{
 			Name:             "val",
@@ -21,6 +22,7 @@ var NotFunc = function.New(&function.Spec{
 })
 
 var AndFunc = function.New(&function.Spec{
+	Description: `Applies the logical AND operation to the given boolean values.`,
 	Params: []function.Parameter{
 		{
 			Name:             "a",
@@ -42,6 +44,7 @@ var AndFunc = function.New(&function.Spec{
 })
 
 var OrFunc = function.New(&function.Spec{
+	Description: `Applies the logical OR operation to the given boolean values.`,
 	Params: []function.Parameter{
 		{
 			Name:             "a",
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
index a132e0cde..3fe600ff1 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bytes.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bytes.go
@@ -30,6 +30,7 @@ func BytesVal(buf []byte) cty.Value {
 // BytesLen is a Function that returns the length of the buffer encapsulated
 // in a Bytes value.
 var BytesLenFunc = function.New(&function.Spec{
+	Description: `Returns the total number of bytes in the given buffer.`,
 	Params: []function.Parameter{
 		{
 			Name:             "buf",
@@ -46,6 +47,7 @@ var BytesLenFunc = function.New(&function.Spec{
 
 // BytesSlice is a Function that returns a slice of the given Bytes value.
 var BytesSliceFunc = function.New(&function.Spec{
+	Description: `Extracts a subslice from the given buffer.`,
 	Params: []function.Parameter{
 		{
 			Name:             "buf",
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
index a91821e94..0573e74e3 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/collection.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/collection.go
@@ -12,6 +12,7 @@ import (
 )
 
 var HasIndexFunc = function.New(&function.Spec{
+	Description: `Returns true if if the given collection can be indexed with the given key without producing an error, or false otherwise.`,
 	Params: []function.Parameter{
 		{
 			Name:             "collection",
@@ -37,6 +38,7 @@ var HasIndexFunc = function.New(&function.Spec{
 })
 
 var IndexFunc = function.New(&function.Spec{
+	Description: `Returns the element with the given key from the given collection, or raises an error if there is no such element.`,
 	Params: []function.Parameter{
 		{
 			Name: "collection",
@@ -106,6 +108,7 @@ var IndexFunc = function.New(&function.Spec{
 })
 
 var LengthFunc = function.New(&function.Spec{
+	Description: `Returns the number of elements in the given collection.`,
 	Params: []function.Parameter{
 		{
 			Name:             "collection",
@@ -127,6 +130,7 @@ var LengthFunc = function.New(&function.Spec{
 })
 
 var ElementFunc = function.New(&function.Spec{
+	Description: `Returns the element with the given index from the given list or tuple, applying the modulo operation to the given index if it's greater than the number of elements.`,
 	Params: []function.Parameter{
 		{
 			Name:        "list",
@@ -206,9 +210,11 @@ var ElementFunc = function.New(&function.Spec{
 // CoalesceListFunc is a function that takes any number of list arguments
 // and returns the first one that isn't empty.
 var CoalesceListFunc = function.New(&function.Spec{
-	Params: []function.Parameter{},
+	Description: `Returns the first of the given sequences that has a length greater than zero.`,
+	Params:      []function.Parameter{},
 	VarParam: &function.Parameter{
 		Name:             "vals",
+		Description:      `List or tuple values to test in the given order.`,
 		Type:             cty.DynamicPseudoType,
 		AllowUnknown:     true,
 		AllowDynamicType: true,
@@ -270,6 +276,7 @@ var CoalesceListFunc = function.New(&function.Spec{
 // CompactFunc is a function that takes a list of strings and returns a new list
 // with any empty string elements removed.
 var CompactFunc = function.New(&function.Spec{
+	Description: `Removes all empty string elements from the given list of strings.`,
 	Params: []function.Parameter{
 		{
 			Name: "list",
@@ -306,6 +313,7 @@ var CompactFunc = function.New(&function.Spec{
 // ContainsFunc is a function that determines whether a given list or
 // set contains a given single value as one of its elements.
 var ContainsFunc = function.New(&function.Spec{
+	Description: `Returns true if the given value is a value in the given list, tuple, or set, or false otherwise.`,
 	Params: []function.Parameter{
 		{
 			Name: "list",
@@ -364,6 +372,7 @@ var ContainsFunc = function.New(&function.Spec{
 // DistinctFunc is a function that takes a list and returns a new list
 // with any duplicate elements removed.
 var DistinctFunc = function.New(&function.Spec{
+	Description: `Removes any duplicate values from the given list, preserving the order of remaining elements.`,
 	Params: []function.Parameter{
 		{
 			Name: "list",
@@ -399,14 +408,17 @@ var DistinctFunc = function.New(&function.Spec{
 // ChunklistFunc is a function that splits a single list into fixed-size chunks,
 // returning a list of lists.
 var ChunklistFunc = function.New(&function.Spec{
+	Description: `Splits a single list into multiple lists where each has at most the given number of elements.`,
 	Params: []function.Parameter{
 		{
 			Name:        "list",
+			Description: `The list to split into chunks.`,
 			Type:        cty.List(cty.DynamicPseudoType),
 			AllowMarked: true,
 		},
 		{
 			Name:        "size",
+			Description: `The maximum length of each chunk. All but the last element of the result is guaranteed to be of exactly this size.`,
 			Type:        cty.Number,
 			AllowMarked: true,
 		},
@@ -471,6 +483,7 @@ var ChunklistFunc = function.New(&function.Spec{
 // FlattenFunc is a function that takes a list and replaces any elements
 // that are lists with a flattened sequence of the list contents.
 var FlattenFunc = function.New(&function.Spec{
+	Description: `Transforms a list, set, or tuple value into a tuple by replacing any given elements that are themselves sequences with a flattened tuple of all of the nested elements concatenated together.`,
 	Params: []function.Parameter{
 		{
 			Name:        "list",
@@ -567,9 +580,11 @@ func flattener(flattenList cty.Value) ([]cty.Value, []cty.ValueMarks, bool) {
 
 // KeysFunc is a function that takes a map and returns a sorted list of the map keys.
 var KeysFunc = function.New(&function.Spec{
+	Description: `Returns a list of the keys of the given map in lexicographical order.`,
 	Params: []function.Parameter{
 		{
 			Name:         "inputMap",
+			Description:  `The map to extract keys from. May instead be an object-typed value, in which case the result is a tuple of the object attributes.`,
 			Type:         cty.DynamicPseudoType,
 			AllowUnknown: true,
 			AllowMarked:  true,
@@ -642,6 +657,7 @@ var KeysFunc = function.New(&function.Spec{
 
 // LookupFunc is a function that performs dynamic lookups of map types.
 var LookupFunc = function.New(&function.Spec{
+	Description: `Returns the value of the element with the given key from the given map, or returns the default value if there is no such element.`,
 	Params: []function.Parameter{
 		{
 			Name:        "inputMap",
@@ -734,7 +750,8 @@ var LookupFunc = function.New(&function.Spec{
 // If more than one given map or object defines the same key then the one that
 // is later in the argument sequence takes precedence.
 var MergeFunc = function.New(&function.Spec{
-	Params: []function.Parameter{},
+	Description: `Merges all of the elements from the given maps into a single map, or the attributes from given objects into a single object.`,
+	Params:      []function.Parameter{},
 	VarParam: &function.Parameter{
 		Name:             "maps",
 		Type:             cty.DynamicPseudoType,
@@ -850,6 +867,7 @@ var MergeFunc = function.New(&function.Spec{
 // ReverseListFunc takes a sequence and produces a new sequence of the same length
 // with all of the same elements as the given sequence but in reverse order.
 var ReverseListFunc = function.New(&function.Spec{
+	Description: `Returns the given list with its elements in reverse order.`,
 	Params: []function.Parameter{
 		{
 			Name:        "list",
@@ -898,9 +916,11 @@ var ReverseListFunc = function.New(&function.Spec{
 // preserving the ordering of all of the input lists. Otherwise the result is a
 // set of tuples.
 var SetProductFunc = function.New(&function.Spec{
-	Params: []function.Parameter{},
+	Description: `Calculates the cartesian product of two or more sets.`,
+	Params:      []function.Parameter{},
 	VarParam: &function.Parameter{
 		Name:        "sets",
+		Description: "The sets to consider. Also accepts lists and tuples, and if all arguments are of list or tuple type then the result will preserve the input ordering",
 		Type:        cty.DynamicPseudoType,
 		AllowMarked: true,
 	},
@@ -1038,6 +1058,7 @@ var SetProductFunc = function.New(&function.Spec{
 // SliceFunc is a function that extracts some consecutive elements
 // from within a list.
 var SliceFunc = function.New(&function.Spec{
+	Description: `Extracts a subslice of the given list or tuple value.`,
 	Params: []function.Parameter{
 		{
 			Name:        "list",
@@ -1159,9 +1180,10 @@ func sliceIndexes(args []cty.Value) (int, int, bool, error) {
 // ValuesFunc is a function that returns a list of the map values,
 // in the order of the sorted keys.
 var ValuesFunc = function.New(&function.Spec{
+	Description: `Returns the values of elements of a given map, or the values of attributes of a given object, in lexicographic order by key or attribute name.`,
 	Params: []function.Parameter{
 		{
-			Name:        "values",
+			Name:        "mapping",
 			Type:        cty.DynamicPseudoType,
 			AllowMarked: true,
 		},
@@ -1226,6 +1248,7 @@ var ValuesFunc = function.New(&function.Spec{
 // ZipmapFunc is a function that constructs a map from a list of keys
 // and a corresponding list of values.
 var ZipmapFunc = function.New(&function.Spec{
+	Description: `Constructs a map from a list of keys and a corresponding list of values, which must both be of the same length.`,
 	Params: []function.Parameter{
 		{
 			Name:        "keys",
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/conversion.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/conversion.go
index 66eb97e25..f61b53409 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/conversion.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/conversion.go
@@ -1,6 +1,7 @@
 package stdlib
 
 import (
+	"fmt"
 	"strconv"
 
 	"github.com/zclconf/go-cty/cty"
@@ -18,6 +19,7 @@ import (
 // a tuple.
 func MakeToFunc(wantTy cty.Type) function.Function {
 	return function.New(&function.Spec{
+		Description: fmt.Sprintf("Converts the given value to %s, or raises an error if that conversion is impossible.", wantTy.FriendlyName()),
 		Params: []function.Parameter{
 			{
 				Name: "v",
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
index 339d04dbd..20d82bcdb 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/csv.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/csv.go
@@ -11,6 +11,7 @@ import (
 )
 
 var CSVDecodeFunc = function.New(&function.Spec{
+	Description: `Parses the given string as Comma Separated Values (as defined by RFC 4180) and returns a map of objects representing the table of data, using the first row as a header row to define the object attributes.`,
 	Params: []function.Parameter{
 		{
 			Name: "str",
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/datetime.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/datetime.go
index 1ceffcf63..6c0ee05e9 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/datetime.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/datetime.go
@@ -12,6 +12,7 @@ import (
 )
 
 var FormatDateFunc = function.New(&function.Spec{
+	Description: `Formats a timestamp given in RFC 3339 syntax into another timestamp in some other machine-oriented time syntax, as described in the format string.`,
 	Params: []function.Parameter{
 		{
 			Name: "format",
@@ -205,6 +206,7 @@ var FormatDateFunc = function.New(&function.Spec{
 
 // TimeAddFunc is a function that adds a duration to a timestamp, returning a new timestamp.
 var TimeAddFunc = function.New(&function.Spec{
+	Description: `Adds the duration represented by the given duration string to the given RFC 3339 timestamp string, returning another RFC 3339 timestamp.`,
 	Params: []function.Parameter{
 		{
 			Name: "timestamp",
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
index 8b1775895..ca163a876 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go
@@ -18,6 +18,7 @@ import (
 //go:generate gofmt -w format_fsm.go
 
 var FormatFunc = function.New(&function.Spec{
+	Description: `Constructs a string by applying formatting verbs to a series of arguments, using a similar syntax to the C function \"printf\".`,
 	Params: []function.Parameter{
 		{
 			Name: "format",
@@ -45,6 +46,7 @@ var FormatFunc = function.New(&function.Spec{
 })
 
 var FormatListFunc = function.New(&function.Spec{
+	Description: `Constructs a list of strings by applying formatting verbs to a series of arguments, using a similar syntax to the C function \"printf\".`,
 	Params: []function.Parameter{
 		{
 			Name: "format",
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
index 6b31f2661..4f70fff94 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/general.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/general.go
@@ -9,6 +9,7 @@ import (
 )
 
 var EqualFunc = function.New(&function.Spec{
+	Description: `Returns true if the two given values are equal, or false otherwise.`,
 	Params: []function.Parameter{
 		{
 			Name:             "a",
@@ -32,6 +33,7 @@ var EqualFunc = function.New(&function.Spec{
 })
 
 var NotEqualFunc = function.New(&function.Spec{
+	Description: `Returns false if the two given values are equal, or true otherwise.`,
 	Params: []function.Parameter{
 		{
 			Name:             "a",
@@ -55,7 +57,8 @@ var NotEqualFunc = function.New(&function.Spec{
 })
 
 var CoalesceFunc = function.New(&function.Spec{
-	Params: []function.Parameter{},
+	Description: `Returns the first of the given arguments that isn't null, or raises an error if there are no non-null arguments.`,
+	Params:      []function.Parameter{},
 	VarParam: &function.Parameter{
 		Name:             "vals",
 		Type:             cty.DynamicPseudoType,
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
index 02770a652..63dd320e4 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/json.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/json.go
@@ -7,6 +7,7 @@ import (
 )
 
 var JSONEncodeFunc = function.New(&function.Spec{
+	Description: `Returns a string containing a JSON representation of the given value.`,
 	Params: []function.Parameter{
 		{
 			Name:             "val",
@@ -39,6 +40,7 @@ var JSONEncodeFunc = function.New(&function.Spec{
 })
 
 var JSONDecodeFunc = function.New(&function.Spec{
+	Description: `Parses the given string as JSON and returns a value corresponding to what the JSON document describes.`,
 	Params: []function.Parameter{
 		{
 			Name: "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
index 4effeb7bb..ce7375135 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/number.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/number.go
@@ -11,6 +11,7 @@ import (
 )
 
 var AbsoluteFunc = function.New(&function.Spec{
+	Description: `If the given number is negative then returns its positive equivalent, or otherwise returns the given number unchanged.`,
 	Params: []function.Parameter{
 		{
 			Name:             "num",
@@ -26,6 +27,7 @@ var AbsoluteFunc = function.New(&function.Spec{
 })
 
 var AddFunc = function.New(&function.Spec{
+	Description: `Returns the sum of the two given numbers.`,
 	Params: []function.Parameter{
 		{
 			Name:             "a",
@@ -59,6 +61,7 @@ var AddFunc = function.New(&function.Spec{
 })
 
 var SubtractFunc = function.New(&function.Spec{
+	Description: `Returns the difference between the two given numbers.`,
 	Params: []function.Parameter{
 		{
 			Name:             "a",
@@ -92,6 +95,7 @@ var SubtractFunc = function.New(&function.Spec{
 })
 
 var MultiplyFunc = function.New(&function.Spec{
+	Description: `Returns the product of the two given numbers.`,
 	Params: []function.Parameter{
 		{
 			Name:             "a",
@@ -126,6 +130,7 @@ var MultiplyFunc = function.New(&function.Spec{
 })
 
 var DivideFunc = function.New(&function.Spec{
+	Description: `Divides the first given number by the second.`,
 	Params: []function.Parameter{
 		{
 			Name:             "a",
@@ -160,6 +165,7 @@ var DivideFunc = function.New(&function.Spec{
 })
 
 var ModuloFunc = function.New(&function.Spec{
+	Description: `Divides the first given number by the second and then returns the remainder.`,
 	Params: []function.Parameter{
 		{
 			Name:             "a",
@@ -194,6 +200,7 @@ var ModuloFunc = function.New(&function.Spec{
 })
 
 var GreaterThanFunc = function.New(&function.Spec{
+	Description: `Returns true if and only if the second number is greater than the first.`,
 	Params: []function.Parameter{
 		{
 			Name:             "a",
@@ -215,6 +222,7 @@ var GreaterThanFunc = function.New(&function.Spec{
 })
 
 var GreaterThanOrEqualToFunc = function.New(&function.Spec{
+	Description: `Returns true if and only if the second number is greater than or equal to the first.`,
 	Params: []function.Parameter{
 		{
 			Name:             "a",
@@ -236,6 +244,7 @@ var GreaterThanOrEqualToFunc = function.New(&function.Spec{
 })
 
 var LessThanFunc = function.New(&function.Spec{
+	Description: `Returns true if and only if the second number is less than the first.`,
 	Params: []function.Parameter{
 		{
 			Name:             "a",
@@ -257,6 +266,7 @@ var LessThanFunc = function.New(&function.Spec{
 })
 
 var LessThanOrEqualToFunc = function.New(&function.Spec{
+	Description: `Returns true if and only if the second number is less than or equal to the first.`,
 	Params: []function.Parameter{
 		{
 			Name:             "a",
@@ -278,6 +288,7 @@ var LessThanOrEqualToFunc = function.New(&function.Spec{
 })
 
 var NegateFunc = function.New(&function.Spec{
+	Description: `Multiplies the given number by -1.`,
 	Params: []function.Parameter{
 		{
 			Name:             "num",
@@ -293,7 +304,8 @@ var NegateFunc = function.New(&function.Spec{
 })
 
 var MinFunc = function.New(&function.Spec{
-	Params: []function.Parameter{},
+	Description: `Returns the numerically smallest of all of the given numbers.`,
+	Params:      []function.Parameter{},
 	VarParam: &function.Parameter{
 		Name:             "numbers",
 		Type:             cty.Number,
@@ -317,7 +329,8 @@ var MinFunc = function.New(&function.Spec{
 })
 
 var MaxFunc = function.New(&function.Spec{
-	Params: []function.Parameter{},
+	Description: `Returns the numerically greatest of all of the given numbers.`,
+	Params:      []function.Parameter{},
 	VarParam: &function.Parameter{
 		Name:             "numbers",
 		Type:             cty.Number,
@@ -341,6 +354,7 @@ var MaxFunc = function.New(&function.Spec{
 })
 
 var IntFunc = function.New(&function.Spec{
+	Description: `Discards any fractional portion of the given number.`,
 	Params: []function.Parameter{
 		{
 			Name:             "num",
@@ -363,6 +377,7 @@ var IntFunc = function.New(&function.Spec{
 // CeilFunc is a function that returns the closest whole number greater
 // than or equal to the given value.
 var CeilFunc = function.New(&function.Spec{
+	Description: `Returns the smallest whole number that is greater than or equal to the given value.`,
 	Params: []function.Parameter{
 		{
 			Name: "num",
@@ -392,6 +407,7 @@ var CeilFunc = function.New(&function.Spec{
 // FloorFunc is a function that returns the closest whole number lesser
 // than or equal to the given value.
 var FloorFunc = function.New(&function.Spec{
+	Description: `Returns the greatest whole number that is less than or equal to the given value.`,
 	Params: []function.Parameter{
 		{
 			Name: "num",
@@ -420,6 +436,7 @@ var FloorFunc = function.New(&function.Spec{
 
 // LogFunc is a function that returns the logarithm of a given number in a given base.
 var LogFunc = function.New(&function.Spec{
+	Description: `Returns the logarithm of the given number in the given base.`,
 	Params: []function.Parameter{
 		{
 			Name: "num",
@@ -448,6 +465,7 @@ var LogFunc = function.New(&function.Spec{
 
 // PowFunc is a function that returns the logarithm of a given number in a given base.
 var PowFunc = function.New(&function.Spec{
+	Description: `Returns the given number raised to the given power (exponentiation).`,
 	Params: []function.Parameter{
 		{
 			Name: "num",
@@ -477,6 +495,7 @@ var PowFunc = function.New(&function.Spec{
 // SignumFunc is a function that determines the sign of a number, returning a
 // number between -1 and 1 to represent the sign..
 var SignumFunc = function.New(&function.Spec{
+	Description: `Returns 0 if the given number is zero, 1 if the given number is positive, or -1 if the given number is negative.`,
 	Params: []function.Parameter{
 		{
 			Name: "num",
@@ -502,6 +521,7 @@ var SignumFunc = function.New(&function.Spec{
 
 // ParseIntFunc is a function that parses a string argument and returns an integer of the specified base.
 var ParseIntFunc = function.New(&function.Spec{
+	Description: `Parses the given string as a number of the given base, or raises an error if the string contains invalid characters.`,
 	Params: []function.Parameter{
 		{
 			Name: "number",
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/regexp.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/regexp.go
index 2dd6348a2..ab4257b67 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/regexp.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/regexp.go
@@ -10,6 +10,7 @@ import (
 )
 
 var RegexFunc = function.New(&function.Spec{
+	Description: `Applies the given regular expression pattern to the given string and returns information about a single match, or raises an error if there is no match.`,
 	Params: []function.Parameter{
 		{
 			Name: "pattern",
@@ -54,6 +55,7 @@ var RegexFunc = function.New(&function.Spec{
 })
 
 var RegexAllFunc = function.New(&function.Spec{
+	Description: `Applies the given regular expression pattern to the given string and returns a list of information about all non-overlapping matches, or an empty list if there are no matches.`,
 	Params: []function.Parameter{
 		{
 			Name: "pattern",
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
index 6a6f66b3f..6b2d97b4a 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go
@@ -9,7 +9,8 @@ import (
 )
 
 var ConcatFunc = function.New(&function.Spec{
-	Params: []function.Parameter{},
+	Description: `Concatenates together all of the given lists or tuples into a single sequence, preserving the input order.`,
+	Params:      []function.Parameter{},
 	VarParam: &function.Parameter{
 		Name:        "seqs",
 		Type:        cty.DynamicPseudoType,
@@ -137,6 +138,7 @@ var ConcatFunc = function.New(&function.Spec{
 })
 
 var RangeFunc = function.New(&function.Spec{
+	Description: `Returns a list of numbers spread evenly over a particular range.`,
 	VarParam: &function.Parameter{
 		Name: "params",
 		Type: cty.Number,
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
index 29c425eaf..15f4c05e7 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/set.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/set.go
@@ -10,6 +10,7 @@ import (
 )
 
 var SetHasElementFunc = function.New(&function.Spec{
+	Description: `Returns true if the given set contains the given element, or false otherwise.`,
 	Params: []function.Parameter{
 		{
 			Name:             "set",
@@ -29,6 +30,7 @@ var SetHasElementFunc = function.New(&function.Spec{
 })
 
 var SetUnionFunc = function.New(&function.Spec{
+	Description: `Returns the union of all given sets.`,
 	Params: []function.Parameter{
 		{
 			Name:             "first_set",
@@ -48,6 +50,7 @@ var SetUnionFunc = function.New(&function.Spec{
 })
 
 var SetIntersectionFunc = function.New(&function.Spec{
+	Description: `Returns the intersection of all given sets.`,
 	Params: []function.Parameter{
 		{
 			Name:             "first_set",
@@ -67,6 +70,7 @@ var SetIntersectionFunc = function.New(&function.Spec{
 })
 
 var SetSubtractFunc = function.New(&function.Spec{
+	Description: `Returns the relative complement of the two given sets.`,
 	Params: []function.Parameter{
 		{
 			Name:             "a",
@@ -86,6 +90,7 @@ var SetSubtractFunc = function.New(&function.Spec{
 })
 
 var SetSymmetricDifferenceFunc = function.New(&function.Spec{
+	Description: `Returns the symmetric difference of the two given sets.`,
 	Params: []function.Parameter{
 		{
 			Name:             "first_set",
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
index 43182dd5a..f340ef747 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string.go
@@ -14,6 +14,7 @@ import (
 )
 
 var UpperFunc = function.New(&function.Spec{
+	Description: "Returns the given string with all Unicode letters translated to their uppercase equivalents.",
 	Params: []function.Parameter{
 		{
 			Name:             "str",
@@ -30,6 +31,7 @@ var UpperFunc = function.New(&function.Spec{
 })
 
 var LowerFunc = function.New(&function.Spec{
+	Description: "Returns the given string with all Unicode letters translated to their lowercase equivalents.",
 	Params: []function.Parameter{
 		{
 			Name:             "str",
@@ -46,6 +48,7 @@ var LowerFunc = function.New(&function.Spec{
 })
 
 var ReverseFunc = function.New(&function.Spec{
+	Description: "Returns the given string with all of its Unicode characters in reverse order.",
 	Params: []function.Parameter{
 		{
 			Name:             "str",
@@ -73,6 +76,7 @@ var ReverseFunc = function.New(&function.Spec{
 })
 
 var StrlenFunc = function.New(&function.Spec{
+	Description: "Returns the number of Unicode characters (technically: grapheme clusters) in the given string.",
 	Params: []function.Parameter{
 		{
 			Name:             "str",
@@ -97,19 +101,23 @@ var StrlenFunc = function.New(&function.Spec{
 })
 
 var SubstrFunc = function.New(&function.Spec{
+	Description: "Extracts a substring from the given string.",
 	Params: []function.Parameter{
 		{
 			Name:             "str",
+			Description:      "The input string.",
 			Type:             cty.String,
 			AllowDynamicType: true,
 		},
 		{
 			Name:             "offset",
+			Description:      "The starting offset in Unicode characters.",
 			Type:             cty.Number,
 			AllowDynamicType: true,
 		},
 		{
 			Name:             "length",
+			Description:      "The maximum length of the result in Unicode characters.",
 			Type:             cty.Number,
 			AllowDynamicType: true,
 		},
@@ -197,15 +205,18 @@ var SubstrFunc = function.New(&function.Spec{
 })
 
 var JoinFunc = function.New(&function.Spec{
+	Description: "Concatenates together the elements of all given lists with a delimiter, producing a single string.",
 	Params: []function.Parameter{
 		{
-			Name: "separator",
-			Type: cty.String,
+			Name:        "separator",
+			Description: "Delimiter to insert between the given strings.",
+			Type:        cty.String,
 		},
 	},
 	VarParam: &function.Parameter{
-		Name: "lists",
-		Type: cty.List(cty.String),
+		Name:        "lists",
+		Description: "One or more lists of strings to join.",
+		Type:        cty.List(cty.String),
 	},
 	Type: function.StaticReturnType(cty.String),
 	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
@@ -244,6 +255,7 @@ var JoinFunc = function.New(&function.Spec{
 })
 
 var SortFunc = function.New(&function.Spec{
+	Description: "Applies a lexicographic sort to the elements of the given list.",
 	Params: []function.Parameter{
 		{
 			Name: "list",
@@ -282,14 +294,17 @@ var SortFunc = function.New(&function.Spec{
 })
 
 var SplitFunc = function.New(&function.Spec{
+	Description: "Produces a list of one or more strings by splitting the given string at all instances of a given separator substring.",
 	Params: []function.Parameter{
 		{
-			Name: "separator",
-			Type: cty.String,
+			Name:        "separator",
+			Description: "The substring that delimits the result strings.",
+			Type:        cty.String,
 		},
 		{
-			Name: "str",
-			Type: cty.String,
+			Name:        "str",
+			Description: "The string to split.",
+			Type:        cty.String,
 		},
 	},
 	Type: function.StaticReturnType(cty.List(cty.String)),
@@ -311,6 +326,7 @@ var SplitFunc = function.New(&function.Spec{
 // ChompFunc is a function that removes newline characters at the end of a
 // string.
 var ChompFunc = function.New(&function.Spec{
+	Description: "Removes one or more newline characters from the end of the given string.",
 	Params: []function.Parameter{
 		{
 			Name: "str",
@@ -327,14 +343,17 @@ var ChompFunc = function.New(&function.Spec{
 // IndentFunc is a function that adds a given number of spaces to the
 // beginnings of all but the first line in a given multi-line string.
 var IndentFunc = function.New(&function.Spec{
+	Description: "Adds a given number of spaces after each newline character in the given string.",
 	Params: []function.Parameter{
 		{
-			Name: "spaces",
-			Type: cty.Number,
+			Name:        "spaces",
+			Description: "Number of spaces to add after each newline character.",
+			Type:        cty.Number,
 		},
 		{
-			Name: "str",
-			Type: cty.String,
+			Name:        "str",
+			Description: "The string to transform.",
+			Type:        cty.String,
 		},
 	},
 	Type: function.StaticReturnType(cty.String),
@@ -352,6 +371,7 @@ var IndentFunc = function.New(&function.Spec{
 // TitleFunc is a function that converts the first letter of each word in the
 // given string to uppercase.
 var TitleFunc = function.New(&function.Spec{
+	Description: "Replaces one letter after each non-letter and non-digit character with its uppercase equivalent.",
 	Params: []function.Parameter{
 		{
 			Name: "str",
@@ -367,6 +387,7 @@ var TitleFunc = function.New(&function.Spec{
 // TrimSpaceFunc is a function that removes any space characters from the start
 // and end of the given string.
 var TrimSpaceFunc = function.New(&function.Spec{
+	Description: "Removes any consecutive space characters (as defined by Unicode) from the start and end of the given string.",
 	Params: []function.Parameter{
 		{
 			Name: "str",
@@ -382,20 +403,26 @@ var TrimSpaceFunc = function.New(&function.Spec{
 // TrimFunc is a function that removes the specified characters from the start
 // and end of the given string.
 var TrimFunc = function.New(&function.Spec{
+	Description: "Removes consecutive sequences of characters in \"cutset\" from the start and end of the given string.",
 	Params: []function.Parameter{
 		{
-			Name: "str",
-			Type: cty.String,
+			Name:        "str",
+			Description: "The string to trim.",
+			Type:        cty.String,
 		},
 		{
-			Name: "cutset",
-			Type: cty.String,
+			Name:        "cutset",
+			Description: "A string containing all of the characters to trim. Each character is taken separately, so the order of characters is insignificant.",
+			Type:        cty.String,
 		},
 	},
 	Type: function.StaticReturnType(cty.String),
 	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
 		str := args[0].AsString()
 		cutset := args[1].AsString()
+		// NOTE: This doesn't properly handle any character that is encoded
+		// with multiple sequential code units, such as letters with
+		// combining diacritics and emoji modifier sequences.
 		return cty.StringVal(strings.Trim(str, cutset)), nil
 	},
 })
@@ -403,14 +430,17 @@ var TrimFunc = function.New(&function.Spec{
 // TrimPrefixFunc is a function that removes the specified characters from the
 // start the given string.
 var TrimPrefixFunc = function.New(&function.Spec{
+	Description: "Removes the given prefix from the start of the given string, if present.",
 	Params: []function.Parameter{
 		{
-			Name: "str",
-			Type: cty.String,
+			Name:        "str",
+			Description: "The string to trim.",
+			Type:        cty.String,
 		},
 		{
-			Name: "prefix",
-			Type: cty.String,
+			Name:        "prefix",
+			Description: "The prefix to remove, if present.",
+			Type:        cty.String,
 		},
 	},
 	Type: function.StaticReturnType(cty.String),
@@ -424,14 +454,17 @@ var TrimPrefixFunc = function.New(&function.Spec{
 // TrimSuffixFunc is a function that removes the specified characters from the
 // end of the given string.
 var TrimSuffixFunc = function.New(&function.Spec{
+	Description: "Removes the given suffix from the start of the given string, if present.",
 	Params: []function.Parameter{
 		{
-			Name: "str",
-			Type: cty.String,
+			Name:        "str",
+			Description: "The string to trim.",
+			Type:        cty.String,
 		},
 		{
-			Name: "suffix",
-			Type: cty.String,
+			Name:        "suffix",
+			Description: "The suffix to remove, if present.",
+			Type:        cty.String,
 		},
 	},
 	Type: function.StaticReturnType(cty.String),
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string_replace.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string_replace.go
index f777ce5c3..573083bcf 100644
--- a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string_replace.go
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string_replace.go
@@ -12,18 +12,22 @@ import (
 // substring, and replaces each occurence with a given replacement string.
 // The substr argument is a simple string.
 var ReplaceFunc = function.New(&function.Spec{
+	Description: `Replaces all instances of the given substring in the given string with the given replacement string.`,
 	Params: []function.Parameter{
 		{
-			Name: "str",
-			Type: cty.String,
+			Name:        "str",
+			Description: `The string to search within.`,
+			Type:        cty.String,
 		},
 		{
-			Name: "substr",
-			Type: cty.String,
+			Name:        "substr",
+			Description: `The substring to search for.`,
+			Type:        cty.String,
 		},
 		{
-			Name: "replace",
-			Type: cty.String,
+			Name:        "replace",
+			Description: `The new substring to replace substr with.`,
+			Type:        cty.String,
 		},
 	},
 	Type: function.StaticReturnType(cty.String),
@@ -40,13 +44,14 @@ var ReplaceFunc = function.New(&function.Spec{
 // given substring, and replaces each occurence with a given replacement
 // string. The substr argument must be a valid regular expression.
 var RegexReplaceFunc = function.New(&function.Spec{
+	Description: `Applies the given regular expression pattern to the given string and replaces all matches with the given replacement string.`,
 	Params: []function.Parameter{
 		{
 			Name: "str",
 			Type: cty.String,
 		},
 		{
-			Name: "substr",
+			Name: "pattern",
 			Type: cty.String,
 		},
 		{
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 01928f981..006a75b20 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -392,7 +392,7 @@ github.com/vmihailenco/msgpack/v5/msgpcode
 github.com/vmihailenco/tagparser/v2
 github.com/vmihailenco/tagparser/v2/internal
 github.com/vmihailenco/tagparser/v2/internal/parser
-# github.com/zclconf/go-cty v1.11.0
+# github.com/zclconf/go-cty v1.12.1
 ## explicit; go 1.18
 github.com/zclconf/go-cty/cty
 github.com/zclconf/go-cty/cty/convert