Go: Fn - CDK Terrain (CDKTN)

Initializers

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.NewFn() Fn

Name	Type	Description

Static Functions

Name	Description
`Abs`	abs returns the absolute value of the given number. In other words, if the number is zero or positive then it is returned as-is, but if it is negative then it is multiplied by -1 to make it positive before returning it.
`Abspath`	abspath takes a string containing a filesystem path and converts it to an absolute path. That is, if the path is not absolute, it will be joined with the current working directory.
`Alltrue`	alltrue returns `true` if all elements in a given collection are `true` or `"true"`. It also returns `true` if the collection is empty.
`Anytrue`	anytrue returns `true` if any element in a given collection is `true` or `"true"`. It also returns `false` if the collection is empty.
`Base64decode`	base64decode takes a string containing a Base64 character sequence and returns the original string.
`Base64encode`	base64encode applies Base64 encoding to a string.
`Base64gzip`	base64gzip compresses a string with gzip and then encodes the result in Base64 encoding.
`Base64sha256`	base64sha256 computes the SHA256 hash of a given string and encodes it with Base64. This is not equivalent to `base64encode(sha256("test"))` since `sha256()` returns hexadecimal representation.
`Base64sha512`	base64sha512 computes the SHA512 hash of a given string and encodes it with Base64. This is not equivalent to `base64encode(sha512("test"))` since `sha512()` returns hexadecimal representation.
`Basename`	basename takes a string containing a filesystem path and removes all except the last portion from it.
`Can`	can evaluates the given expression and returns a boolean value indicating whether the expression produced a result without any errors.
`Ceil`	ceil returns the closest whole number that is greater than or equal to the given value, which may be a fraction.
`Chomp`	chomp removes newline characters at the end of a string.
`Chunklist`	chunklist splits a single list into fixed-size chunks, returning a list of lists.
`Cidrhost`	cidrhost calculates a full host IP address for a given host number within a given IP network address prefix.
`Cidrnetmask`	cidrnetmask converts an IPv4 address prefix given in CIDR notation into a subnet mask address.
`Cidrsubnet`	cidrsubnet calculates a subnet address within given IP network address prefix.
`Cidrsubnets`	cidrsubnets calculates a sequence of consecutive IP address ranges within a particular CIDR prefix.
`Coalesce`	coalesce takes any number of arguments and returns the first one that isn’t null or an empty string.
`Coalescelist`	coalescelist takes any number of list arguments and returns the first one that isn’t empty.
`Compact`	compact takes a list of strings and returns a new list with any empty string elements removed.
`Concat`	concat takes two or more lists and combines them into a single list.
`Contains`	contains determines whether a given list or set contains a given single value as one of its elements.
`Csvdecode`	csvdecode decodes a string containing CSV-formatted data and produces a list of maps representing that data.
`Dirname`	dirname takes a string containing a filesystem path and removes the last portion from it.
`Distinct`	distinct takes a list and returns a new list with any duplicate elements removed.
`Element`	element retrieves a single element from a list.
`Endswith`	endswith takes two values: a string to check and a suffix string. The function returns true if the first string ends with that exact suffix.
`File`	file reads the contents of a file at the given path and returns them as a string.
`Filebase64`	filebase64 reads the contents of a file at the given path and returns them as a base64-encoded string.
`Filebase64sha256`	filebase64sha256 is a variant of `base64sha256` that hashes the contents of a given file rather than a literal string.
`Filebase64sha512`	filebase64sha512 is a variant of `base64sha512` that hashes the contents of a given file rather than a literal string.
`Fileexists`	fileexists determines whether a file exists at a given path.
`Filemd5`	filemd5 is a variant of `md5` that hashes the contents of a given file rather than a literal string.
`Fileset`	fileset enumerates a set of regular file names given a path and pattern. The path is automatically removed from the resulting set of file names and any result still containing path separators always returns forward slash (`/`) as the path separator for cross-system compatibility.
`Filesha1`	filesha1 is a variant of `sha1` that hashes the contents of a given file rather than a literal string.
`Filesha256`	filesha256 is a variant of `sha256` that hashes the contents of a given file rather than a literal string.
`Filesha512`	filesha512 is a variant of `sha512` that hashes the contents of a given file rather than a literal string.
`Flatten`	flatten takes a list and replaces any elements that are lists with a flattened sequence of the list contents.
`Floor`	floor returns the closest whole number that is less than or equal to the given value, which may be a fraction.
`Format`	The format function produces a string by formatting a number of other values according to a specification string. It is similar to the `printf` function in C, and other similar functions in other programming languages.
`Formatdate`	formatdate converts a timestamp into a different time format.
`Formatlist`	formatlist produces a list of strings by formatting a number of other values according to a specification string.
`Indent`	indent adds a given number of spaces to the beginnings of all but the first line in a given multi-line string.
`Index`	index finds the element index for a given value in a list.
`Jsondecode`	jsondecode interprets a given string as JSON, returning a representation of the result of decoding that string.
`Jsonencode`	jsonencode encodes a given value to a string using JSON syntax.
`Keys`	keys takes a map and returns a list containing the keys from that map.
`LengthOf`	length determines the length of a given list, map, or string.
`Log`	log returns the logarithm of a given number in a given base.
`Lower`	lower converts all cased letters in the given string to lowercase.
`Matchkeys`	matchkeys constructs a new list by taking a subset of elements from one list whose indexes match the corresponding indexes of values in another list.
`Max`	max takes one or more numbers and returns the greatest number from the set.
`Md5`	md5 computes the MD5 hash of a given string and encodes it with hexadecimal digits.
`Merge`	merge takes an arbitrary number of maps or objects, and returns a single map or object that contains a merged set of elements from all arguments.
`Min`	min takes one or more numbers and returns the smallest number from the set.
`Nonsensitive`	nonsensitive takes a sensitive value and returns a copy of that value with the sensitive marking removed, thereby exposing the sensitive value.
`One`	one takes a list, set, or tuple value with either zero or one elements. If the collection is empty, `one` returns `null`. Otherwise, `one` returns the first element. If there are two or more elements then `one` will return an error.
`Parseint`	parseint parses the given string as a representation of an integer in the specified base and returns the resulting number. The base must be between 2 and 62 inclusive.
`Pathexpand`	pathexpand takes a filesystem path that might begin with a `~` segment, and if so it replaces that segment with the current user’s home directory path.
`Plantimestamp`	plantimestamp returns a UTC timestamp string in RFC 3339 format, fixed to a constant time representing the time of the plan.
`Pow`	pow calculates an exponent, by raising its first argument to the power of the second argument.
`Regex`	regex applies a regular expression to a string and returns the matching substrings.
`Regexall`	regexall applies a regular expression to a string and returns a list of all matches.
`Replace`	replace searches a given string for another given substring, and replaces each occurrence with a given replacement string.
`Reverse`	reverse 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.
`Rsadecrypt`	rsadecrypt decrypts an RSA-encrypted ciphertext, returning the corresponding cleartext.
`Sensitive`	sensitive takes any value and returns a copy of it marked so that Terraform will treat it as sensitive, with the same meaning and behavior as for sensitive input variables.
`Setintersection`	The setintersection function takes multiple sets and produces a single set containing only the elements that all of the given sets have in common. In other words, it computes the intersection of the sets.
`Setproduct`	The setproduct function finds all of the possible combinations of elements from all of the given sets by computing the Cartesian product.
`Setsubtract`	The setsubtract function returns a new set containing the elements from the first set that are not present in the second set. In other words, it computes the relative complement of the second set.
`Setunion`	The setunion function takes multiple sets and produces a single set containing the elements from all of the given sets. In other words, it computes the union of the sets.
`Sha1`	sha1 computes the SHA1 hash of a given string and encodes it with hexadecimal digits.
`Sha256`	sha256 computes the SHA256 hash of a given string and encodes it with hexadecimal digits.
`Sha512`	sha512 computes the SHA512 hash of a given string and encodes it with hexadecimal digits.
`Signum`	signum determines the sign of a number, returning a number between -1 and 1 to represent the sign.
`Slice`	slice extracts some consecutive elements from within a list.
`Sort`	sort takes a list of strings and returns a new list with those strings sorted lexicographically.
`Split`	split produces a list by dividing a given string at all occurrences of a given separator.
`Startswith`	startswith takes two values: a string to check and a prefix string. The function returns true if the string begins with that exact prefix.
`Strcontains`	strcontains takes two values: a string to check and an expected substring. The function returns true if the string has the substring contained within it.
`Strrev`	strrev reverses the characters in a string. Note that the characters are treated as Unicode characters (in technical terms, Unicode grapheme cluster boundaries are respected).
`Substr`	substr extracts a substring from a given string by offset and (maximum) length.
`Sum`	sum takes a list or set of numbers and returns the sum of those numbers.
`Templatefile`	templatefile reads the file at the given path and renders its content as a template using a supplied set of template variables.
`Textdecodebase64`	textdecodebase64 function decodes a string that was previously Base64-encoded, and then interprets the result as characters in a specified character encoding.
`Textencodebase64`	textencodebase64 encodes the unicode characters in a given string using a specified character encoding, returning the result base64 encoded because Terraform language strings are always sequences of unicode characters.
`Timeadd`	timeadd adds a duration to a timestamp, returning a new timestamp.
`Timecmp`	timecmp compares two timestamps and returns a number that represents the ordering of the instants those timestamps represent.
`Timestamp`	timestamp returns a UTC timestamp string in RFC 3339 format.
`Title`	title converts the first letter of each word in the given string to uppercase.
`Tobool`	tobool converts its argument to a boolean value.
`Tolist`	tolist converts its argument to a list value.
`Tomap`	tomap converts its argument to a map value.
`Tonumber`	tonumber converts its argument to a number value.
`Toset`	toset converts its argument to a set value.
`Tostring`	tostring converts its argument to a string value.
`Transpose`	transpose takes a map of lists of strings and swaps the keys and values to produce a new map of lists of strings.
`Trim`	trim removes the specified set of characters from the start and end of the given string.
`Trimprefix`	trimprefix removes the specified prefix from the start of the given string. If the string does not start with the prefix, the string is returned unchanged.
`Trimspace`	trimspace removes any space characters from the start and end of the given string.
`Trimsuffix`	trimsuffix removes the specified suffix from the end of the given string.
`Try`	try evaluates all of its argument expressions in turn and returns the result of the first one that does not produce any errors.
`Upper`	upper converts all cased letters in the given string to uppercase.
`Urlencode`	urlencode applies URL encoding to a given string.
`Uuid`	uuid generates a unique identifier string.
`Uuidv5`	uuidv5 generates a name-based UUID, as described in RFC 4122 section 4.3, also known as a “version 5” UUID.
`Values`	values takes a map and returns a list containing the values of the elements in that map.
`Yamldecode`	yamldecode parses a string as a subset of YAML, and produces a representation of its value.
`Yamlencode`	yamlencode encodes a given value to a string using YAML 1.2 block syntax.
`Zipmap`	zipmap constructs a map from a list of keys and a corresponding list of values.
`Bcrypt`	bcrypt computes a hash of the given string using the Blowfish cipher, returning a string in the Modular Crypt Format usually expected in the shadow password file on many Unix systems.
`Conditional`	https://developer.hashicorp.com/terraform/language/expressions/conditionals A conditional expression uses the value of a boolean expression to select one of two values.
`Join`	join produces a string by concatenating together all elements of a given list of strings with the given delimiter.
`Lookup`	lookup retrieves the value of a single element from a map, given its key. If the given key does not exist, the given default value is returned instead.
`LookupNested`	returns a property access expression that accesses the property at the given path in the given inputMap.
`Range`	range generates a list of numbers using a start value, a limit value, and a step value.
`RawString`	Use this function to wrap a string and escape it properly for the use in Terraform This is only needed in certain scenarios (e.g., if you have unescaped double quotes in the string).

`Abs`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Abs(num *f64) *f64

abs returns the absolute value of the given number. In other words, if the number is zero or positive then it is returned as-is, but if it is negative then it is multiplied by -1 to make it positive before returning it.

`num`^Required

Type: *f64

`Abspath`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Abspath(path *string) *string

abspath takes a string containing a filesystem path and converts it to an absolute path. That is, if the path is not absolute, it will be joined with the current working directory.

`path`^Required

Type: *string

`Alltrue`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Alltrue(list *[]interface{}) IResolvable

alltrue returns true if all elements in a given collection are true or "true". It also returns true if the collection is empty.

`list`^Required

Type: *[]interface{}

`Anytrue`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Anytrue(list *[]interface{}) IResolvable

anytrue returns true if any element in a given collection is true or "true". It also returns false if the collection is empty.

`list`^Required

Type: *[]interface{}

`Base64decode`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Base64decode(str *string) *string

base64decode takes a string containing a Base64 character sequence and returns the original string.

`str`^Required

Type: *string

`Base64encode`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Base64encode(str *string) *string

base64encode applies Base64 encoding to a string.

`str`^Required

Type: *string

`Base64gzip`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Base64gzip(str *string) *string

base64gzip compresses a string with gzip and then encodes the result in Base64 encoding.

`str`^Required

Type: *string

`Base64sha256`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Base64sha256(str *string) *string

base64sha256 computes the SHA256 hash of a given string and encodes it with Base64. This is not equivalent to base64encode(sha256("test")) since sha256() returns hexadecimal representation.

`str`^Required

Type: *string

`Base64sha512`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Base64sha512(str *string) *string

base64sha512 computes the SHA512 hash of a given string and encodes it with Base64. This is not equivalent to base64encode(sha512("test")) since sha512() returns hexadecimal representation.

`str`^Required

Type: *string

`Basename`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Basename(path *string) *string

basename takes a string containing a filesystem path and removes all except the last portion from it.

`path`^Required

Type: *string

`Can`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Can(expression interface{}) IResolvable

can evaluates the given expression and returns a boolean value indicating whether the expression produced a result without any errors.

`expression`^Required

Type: interface{}

`Ceil`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Ceil(num *f64) *f64

ceil returns the closest whole number that is greater than or equal to the given value, which may be a fraction.

`num`^Required

Type: *f64

`Chomp`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Chomp(str *string) *string

chomp removes newline characters at the end of a string.

`str`^Required

Type: *string

`Chunklist`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Chunklist(list *[]interface{}, size *f64) *[]*string

chunklist splits a single list into fixed-size chunks, returning a list of lists.

`list`^Required

Type: *[]interface{}

`size`^Required

Type: *f64

`Cidrhost`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Cidrhost(prefix *string, hostnum *f64) *string

cidrhost calculates a full host IP address for a given host number within a given IP network address prefix.

`prefix`^Required

Type: *string

`hostnum`^Required

Type: *f64

`Cidrnetmask`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Cidrnetmask(prefix *string) *string

cidrnetmask converts an IPv4 address prefix given in CIDR notation into a subnet mask address.

`prefix`^Required

Type: *string

`Cidrsubnet`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Cidrsubnet(prefix *string, newbits *f64, netnum *f64) *string

cidrsubnet calculates a subnet address within given IP network address prefix.

`prefix`^Required

Type: *string

`newbits`^Required

Type: *f64

`netnum`^Required

Type: *f64

`Cidrsubnets`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Cidrsubnets(prefix *string, newbits *[]*f64) *[]*string

cidrsubnets calculates a sequence of consecutive IP address ranges within a particular CIDR prefix.

`prefix`^Required

Type: *string

`newbits`^Required

Type: *[]*f64

`Coalesce`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Coalesce(vals *[]interface{}) interface{}

coalesce takes any number of arguments and returns the first one that isn’t null or an empty string.

`vals`^Required

Type: *[]interface{}

`Coalescelist`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Coalescelist(vals *[]interface{}) interface{}

coalescelist takes any number of list arguments and returns the first one that isn’t empty.

`vals`^Required

Type: *[]interface{}

`Compact`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Compact(list *[]*string) *[]*string

compact takes a list of strings and returns a new list with any empty string elements removed.

`list`^Required

Type: *[]*string

`Concat`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Concat(seqs *[]interface{}) interface{}

concat takes two or more lists and combines them into a single list.

`seqs`^Required

Type: *[]interface{}

`Contains`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Contains(list interface{}, value interface{}) interface{}

contains determines whether a given list or set contains a given single value as one of its elements.

`list`^Required

Type: interface{}

`value`^Required

Type: interface{}

`Csvdecode`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Csvdecode(str *string) interface{}

csvdecode decodes a string containing CSV-formatted data and produces a list of maps representing that data.

`str`^Required

Type: *string

`Dirname`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Dirname(path *string) *string

dirname takes a string containing a filesystem path and removes the last portion from it.

`path`^Required

Type: *string

`Distinct`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Distinct(list *[]interface{}) *[]*string

distinct takes a list and returns a new list with any duplicate elements removed.

`list`^Required

Type: *[]interface{}

`Element`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Element(list interface{}, index *f64) interface{}

element retrieves a single element from a list.

`list`^Required

Type: interface{}

`index`^Required

Type: *f64

`Endswith`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Endswith(str *string, suffix *string) IResolvable

endswith takes two values: a string to check and a suffix string. The function returns true if the first string ends with that exact suffix.

`str`^Required

Type: *string

`suffix`^Required

Type: *string

`File`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_File(path *string) *string

file reads the contents of a file at the given path and returns them as a string.

`path`^Required

Type: *string

`Filebase64`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Filebase64(path *string) *string

filebase64 reads the contents of a file at the given path and returns them as a base64-encoded string.

`path`^Required

Type: *string

`Filebase64sha256`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Filebase64sha256(path *string) *string

filebase64sha256 is a variant of base64sha256 that hashes the contents of a given file rather than a literal string.

`path`^Required

Type: *string

`Filebase64sha512`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Filebase64sha512(path *string) *string

filebase64sha512 is a variant of base64sha512 that hashes the contents of a given file rather than a literal string.

`path`^Required

Type: *string

`Fileexists`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Fileexists(path *string) IResolvable

fileexists determines whether a file exists at a given path.

`path`^Required

Type: *string

`Filemd5`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Filemd5(path *string) *string

filemd5 is a variant of md5 that hashes the contents of a given file rather than a literal string.

`path`^Required

Type: *string

`Fileset`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Fileset(path *string, pattern *string) *[]*string

fileset enumerates a set of regular file names given a path and pattern. The path is automatically removed from the resulting set of file names and any result still containing path separators always returns forward slash (/) as the path separator for cross-system compatibility.

`path`^Required

Type: *string

`pattern`^Required

Type: *string

`Filesha1`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Filesha1(path *string) *string

filesha1 is a variant of sha1 that hashes the contents of a given file rather than a literal string.

`path`^Required

Type: *string

`Filesha256`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Filesha256(path *string) *string

filesha256 is a variant of sha256 that hashes the contents of a given file rather than a literal string.

`path`^Required

Type: *string

`Filesha512`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Filesha512(path *string) *string

filesha512 is a variant of sha512 that hashes the contents of a given file rather than a literal string.

`path`^Required

Type: *string

`Flatten`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Flatten(list interface{}) interface{}

flatten takes a list and replaces any elements that are lists with a flattened sequence of the list contents.

`list`^Required

Type: interface{}

`Floor`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Floor(num *f64) *f64

floor returns the closest whole number that is less than or equal to the given value, which may be a fraction.

`num`^Required

Type: *f64

`Format`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Format(format *string, args *[]interface{}) interface{}

The format function produces a string by formatting a number of other values according to a specification string. It is similar to the printf function in C, and other similar functions in other programming languages.

`format`^Required

Type: *string

`args`^Required

Type: *[]interface{}

`Formatdate`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Formatdate(format *string, time *string) *string

formatdate converts a timestamp into a different time format.

`format`^Required

Type: *string

`time`^Required

Type: *string

`Formatlist`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Formatlist(format *string, args *[]interface{}) interface{}

formatlist produces a list of strings by formatting a number of other values according to a specification string.

`format`^Required

Type: *string

`args`^Required

Type: *[]interface{}

`Indent`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Indent(spaces *f64, str *string) *string

indent adds a given number of spaces to the beginnings of all but the first line in a given multi-line string.

`spaces`^Required

Type: *f64

`str`^Required

Type: *string

`Index`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Index(list interface{}, value interface{}) interface{}

index finds the element index for a given value in a list.

`list`^Required

Type: interface{}

`value`^Required

Type: interface{}

`Jsondecode`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Jsondecode(str *string) interface{}

jsondecode interprets a given string as JSON, returning a representation of the result of decoding that string.

`str`^Required

Type: *string

`Jsonencode`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Jsonencode(val interface{}) *string

jsonencode encodes a given value to a string using JSON syntax.

`val`^Required

Type: interface{}

`Keys`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Keys(inputMap interface{}) interface{}

keys takes a map and returns a list containing the keys from that map.

`inputMap`^Required

Type: interface{}

`LengthOf`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_LengthOf(value interface{}) *f64

length determines the length of a given list, map, or string.

`value`^Required

Type: interface{}

`Log`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Log(num *f64, base *f64) *f64

log returns the logarithm of a given number in a given base.

`num`^Required

Type: *f64

`base`^Required

Type: *f64

`Lower`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Lower(str *string) *string

lower converts all cased letters in the given string to lowercase.

`str`^Required

Type: *string

`Matchkeys`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Matchkeys(values *[]interface{}, keys *[]interface{}, searchset *[]interface{}) *[]*string

matchkeys constructs a new list by taking a subset of elements from one list whose indexes match the corresponding indexes of values in another list.

`values`^Required

Type: *[]interface{}

`keys`^Required

Type: *[]interface{}

`searchset`^Required

Type: *[]interface{}

`Max`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Max(numbers *[]*f64) *f64

max takes one or more numbers and returns the greatest number from the set.

`numbers`^Required

Type: *[]*f64

`Md5`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Md5(str *string) *string

md5 computes the MD5 hash of a given string and encodes it with hexadecimal digits.

`str`^Required

Type: *string

`Merge`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Merge(maps *[]interface{}) interface{}

merge takes an arbitrary number of maps or objects, and returns a single map or object that contains a merged set of elements from all arguments.

`maps`^Required

Type: *[]interface{}

`Min`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Min(numbers *[]*f64) *f64

min takes one or more numbers and returns the smallest number from the set.

`numbers`^Required

Type: *[]*f64

`Nonsensitive`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Nonsensitive(value interface{}) interface{}

nonsensitive takes a sensitive value and returns a copy of that value with the sensitive marking removed, thereby exposing the sensitive value.

`value`^Required

Type: interface{}

`One`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_One(list interface{}) interface{}

one takes a list, set, or tuple value with either zero or one elements. If the collection is empty, one returns null. Otherwise, one returns the first element. If there are two or more elements then one will return an error.

`list`^Required

Type: interface{}

`Parseint`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Parseint(number interface{}, base *f64) interface{}

parseint parses the given string as a representation of an integer in the specified base and returns the resulting number. The base must be between 2 and 62 inclusive.

`number`^Required

Type: interface{}

`base`^Required

Type: *f64

`Pathexpand`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Pathexpand(path *string) *string

pathexpand takes a filesystem path that might begin with a ~ segment, and if so it replaces that segment with the current user’s home directory path.

`path`^Required

Type: *string

`Plantimestamp`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Plantimestamp() *string

plantimestamp returns a UTC timestamp string in RFC 3339 format, fixed to a constant time representing the time of the plan.

`Pow`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Pow(num *f64, power *f64) *f64

pow calculates an exponent, by raising its first argument to the power of the second argument.

`num`^Required

Type: *f64

`power`^Required

Type: *f64

`Regex`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Regex(pattern *string, str *string) interface{}

regex applies a regular expression to a string and returns the matching substrings.

`pattern`^Required

Type: *string

`str`^Required

Type: *string

`Regexall`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Regexall(pattern *string, str *string) *[]*string

regexall applies a regular expression to a string and returns a list of all matches.

`pattern`^Required

Type: *string

`str`^Required

Type: *string

`Replace`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Replace(str *string, substr *string, replace *string) *string

replace searches a given string for another given substring, and replaces each occurrence with a given replacement string.

`str`^Required

Type: *string

`substr`^Required

Type: *string

`replace`^Required

Type: *string

`Reverse`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Reverse(list interface{}) interface{}

reverse 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.

`list`^Required

Type: interface{}

`Rsadecrypt`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Rsadecrypt(ciphertext *string, privatekey *string) *string

rsadecrypt decrypts an RSA-encrypted ciphertext, returning the corresponding cleartext.

`ciphertext`^Required

Type: *string

`privatekey`^Required

Type: *string

`Sensitive`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Sensitive(value interface{}) interface{}

sensitive takes any value and returns a copy of it marked so that Terraform will treat it as sensitive, with the same meaning and behavior as for sensitive input variables.

`value`^Required

Type: interface{}

`Setintersection`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Setintersection(first_set *[]interface{}, other_sets *[]*[]interface{}) *[]*string

The setintersection function takes multiple sets and produces a single set containing only the elements that all of the given sets have in common. In other words, it computes the intersection of the sets.

`first_set`^Required

Type: *[]interface{}

`other_sets`^Required

Type: [][]interface{}

`Setproduct`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Setproduct(sets *[]interface{}) interface{}

The setproduct function finds all of the possible combinations of elements from all of the given sets by computing the Cartesian product.

`sets`^Required

Type: *[]interface{}

`Setsubtract`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Setsubtract(a *[]interface{}, b *[]interface{}) *[]*string

The setsubtract function returns a new set containing the elements from the first set that are not present in the second set. In other words, it computes the relative complement of the second set.

`a`^Required

Type: *[]interface{}

`b`^Required

Type: *[]interface{}

`Setunion`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Setunion(first_set *[]interface{}, other_sets *[]*[]interface{}) *[]*string

The setunion function takes multiple sets and produces a single set containing the elements from all of the given sets. In other words, it computes the union of the sets.

`first_set`^Required

Type: *[]interface{}

`other_sets`^Required

Type: [][]interface{}

`Sha1`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Sha1(str *string) *string

sha1 computes the SHA1 hash of a given string and encodes it with hexadecimal digits.

`str`^Required

Type: *string

`Sha256`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Sha256(str *string) *string

sha256 computes the SHA256 hash of a given string and encodes it with hexadecimal digits.

`str`^Required

Type: *string

`Sha512`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Sha512(str *string) *string

sha512 computes the SHA512 hash of a given string and encodes it with hexadecimal digits.

`str`^Required

Type: *string

`Signum`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Signum(num *f64) *f64

signum determines the sign of a number, returning a number between -1 and 1 to represent the sign.

`num`^Required

Type: *f64

`Slice`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Slice(list interface{}, start_index *f64, end_index *f64) interface{}

slice extracts some consecutive elements from within a list.

`list`^Required

Type: interface{}

`start_index`^Required

Type: *f64

`end_index`^Required

Type: *f64

`Sort`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Sort(list *[]*string) *[]*string

sort takes a list of strings and returns a new list with those strings sorted lexicographically.

`list`^Required

Type: *[]*string

`Split`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Split(separator *string, str *string) *[]*string

split produces a list by dividing a given string at all occurrences of a given separator.

`separator`^Required

Type: *string

`str`^Required

Type: *string

`Startswith`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Startswith(str *string, prefix *string) IResolvable

startswith takes two values: a string to check and a prefix string. The function returns true if the string begins with that exact prefix.

`str`^Required

Type: *string

`prefix`^Required

Type: *string

`Strcontains`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Strcontains(str *string, substr *string) IResolvable

strcontains takes two values: a string to check and an expected substring. The function returns true if the string has the substring contained within it.

`str`^Required

Type: *string

`substr`^Required

Type: *string

`Strrev`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Strrev(str *string) *string

strrev reverses the characters in a string. Note that the characters are treated as Unicode characters (in technical terms, Unicode grapheme cluster boundaries are respected).

`str`^Required

Type: *string

`Substr`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Substr(str *string, offset *f64, length *f64) *string

substr extracts a substring from a given string by offset and (maximum) length.

`str`^Required

Type: *string

`offset`^Required

Type: *f64

`length`^Required

Type: *f64

`Sum`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Sum(list interface{}) interface{}

sum takes a list or set of numbers and returns the sum of those numbers.

`list`^Required

Type: interface{}

`Templatefile`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Templatefile(path *string, vars interface{}) interface{}

templatefile reads the file at the given path and renders its content as a template using a supplied set of template variables.

`path`^Required

Type: *string

`vars`^Required

Type: interface{}

`Textdecodebase64`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Textdecodebase64(source *string, encoding *string) *string

textdecodebase64 function decodes a string that was previously Base64-encoded, and then interprets the result as characters in a specified character encoding.

`source`^Required

Type: *string

`encoding`^Required

Type: *string

`Textencodebase64`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Textencodebase64(str *string, encoding *string) *string

textencodebase64 encodes the unicode characters in a given string using a specified character encoding, returning the result base64 encoded because Terraform language strings are always sequences of unicode characters.

`str`^Required

Type: *string

`encoding`^Required

Type: *string

`Timeadd`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Timeadd(timestamp *string, duration *string) *string

timeadd adds a duration to a timestamp, returning a new timestamp.

`timestamp`^Required

Type: *string

`duration`^Required

Type: *string

`Timecmp`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Timecmp(timestamp_a *string, timestamp_b *string) *f64

timecmp compares two timestamps and returns a number that represents the ordering of the instants those timestamps represent.

`timestamp_a`^Required

Type: *string

`timestamp_b`^Required

Type: *string

`Timestamp`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Timestamp() *string

timestamp returns a UTC timestamp string in RFC 3339 format.

`Title`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Title(str *string) *string

title converts the first letter of each word in the given string to uppercase.

`str`^Required

Type: *string

`Tobool`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Tobool(v interface{}) IResolvable

tobool converts its argument to a boolean value.

`v`^Required

Type: interface{}

`Tolist`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Tolist(v interface{}) *[]*string

tolist converts its argument to a list value.

`v`^Required

Type: interface{}

`Tomap`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Tomap(v interface{}) interface{}

tomap converts its argument to a map value.

`v`^Required

Type: interface{}

`Tonumber`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Tonumber(v interface{}) *f64

tonumber converts its argument to a number value.

`v`^Required

Type: interface{}

`Toset`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Toset(v interface{}) *[]*string

toset converts its argument to a set value.

`v`^Required

Type: interface{}

`Tostring`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Tostring(v interface{}) *string

tostring converts its argument to a string value.

`v`^Required

Type: interface{}

`Transpose`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Transpose(values interface{}) interface{}

transpose takes a map of lists of strings and swaps the keys and values to produce a new map of lists of strings.

`values`^Required

Type: interface{}

`Trim`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Trim(str *string, cutset *string) *string

trim removes the specified set of characters from the start and end of the given string.

`str`^Required

Type: *string

`cutset`^Required

Type: *string

`Trimprefix`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Trimprefix(str *string, prefix *string) *string

trimprefix removes the specified prefix from the start of the given string. If the string does not start with the prefix, the string is returned unchanged.

`str`^Required

Type: *string

`prefix`^Required

Type: *string

`Trimspace`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Trimspace(str *string) *string

trimspace removes any space characters from the start and end of the given string.

`str`^Required

Type: *string

`Trimsuffix`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Trimsuffix(str *string, suffix *string) *string

trimsuffix removes the specified suffix from the end of the given string.

`str`^Required

Type: *string

`suffix`^Required

Type: *string

`Try`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Try(expressions *[]interface{}) interface{}

try evaluates all of its argument expressions in turn and returns the result of the first one that does not produce any errors.

`expressions`^Required

Type: *[]interface{}

`Upper`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Upper(str *string) *string

upper converts all cased letters in the given string to uppercase.

`str`^Required

Type: *string

`Urlencode`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Urlencode(str *string) *string

urlencode applies URL encoding to a given string.

`str`^Required

Type: *string

`Uuid`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Uuid() *string

uuid generates a unique identifier string.

`Uuidv5`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Uuidv5(namespace *string, name *string) *string

uuidv5 generates a name-based UUID, as described in RFC 4122 section 4.3, also known as a “version 5” UUID.

`namespace`^Required

Type: *string

`name`^Required

Type: *string

`Values`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Values(mapping interface{}) interface{}

values takes a map and returns a list containing the values of the elements in that map.

`mapping`^Required

Type: interface{}

`Yamldecode`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Yamldecode(src *string) interface{}

yamldecode parses a string as a subset of YAML, and produces a representation of its value.

`src`^Required

Type: *string

`Yamlencode`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Yamlencode(value interface{}) *string

yamlencode encodes a given value to a string using YAML 1.2 block syntax.

`value`^Required

Type: interface{}

`Zipmap`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Zipmap(keys *[]*string, values interface{}) interface{}

zipmap constructs a map from a list of keys and a corresponding list of values.

`keys`^Required

Type: *[]*string

`values`^Required

Type: interface{}

`Bcrypt`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Bcrypt(str *string, cost *f64) *string

bcrypt computes a hash of the given string using the Blowfish cipher, returning a string in the Modular Crypt Format usually expected in the shadow password file on many Unix systems.

`str`^Required

Type: *string

`cost`^Optional

Type: *f64

`Conditional`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Conditional(condition interface{}, trueValue interface{}, falseValue interface{}) interface{}

https://developer.hashicorp.com/terraform/language/expressions/conditionals A conditional expression uses the value of a boolean expression to select one of two values.

`condition`^Required

Type: interface{}

`trueValue`^Required

Type: interface{}

`falseValue`^Required

Type: interface{}

`Join`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Join(separator *string, list *[]*string) *string

join produces a string by concatenating together all elements of a given list of strings with the given delimiter.

`separator`^Required

Type: *string

`list`^Required

Type: *[]*string

`Lookup`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Lookup(inputMap interface{}, key *string, defaultValue interface{}) interface{}

lookup retrieves the value of a single element from a map, given its key. If the given key does not exist, the given default value is returned instead.

`inputMap`^Required

Type: interface{}

`key`^Required

Type: *string

`defaultValue`^Optional

Type: interface{}

`LookupNested`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_LookupNested(inputMap interface{}, path *[]interface{}) interface{}

returns a property access expression that accesses the property at the given path in the given inputMap. For example lookupNested(x, [“a”, “b”, “c”]) will return a Terraform expression like x[“a”][“b”][“c”]

`inputMap`^Required

Type: interface{}

`path`^Required

Type: *[]interface{}

`Range`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_Range(start *f64, limit *f64, step *f64) *[]*string

range generates a list of numbers using a start value, a limit value, and a step value.

`start`^Required

Type: *f64

`limit`^Required

Type: *f64

`step`^Optional

Type: *f64

`RawString`

import "github.com/open-constructs/cdk-terrain-go/cdktn"

cdktn.Fn_RawString(str *string) *string

Use this function to wrap a string and escape it properly for the use in Terraform This is only needed in certain scenarios (e.g., if you have unescaped double quotes in the string).

`str`^Required

Type: *string

Overview

TypeScript

Python

Java

C#

Go

​Initializers

​Static Functions

​Abs

​numRequired

​Abspath

​pathRequired

​Alltrue

​listRequired

​Anytrue

​listRequired

​Base64decode

​strRequired

​Base64encode

​strRequired

​Base64gzip

​strRequired

​Base64sha256

​strRequired

​Base64sha512

​strRequired

​Basename

​pathRequired

​Can

​expressionRequired

​Ceil

​numRequired

​Chomp

​strRequired

​Chunklist

​listRequired

​sizeRequired

​Cidrhost

​prefixRequired

​hostnumRequired

​Cidrnetmask

​prefixRequired

​Cidrsubnet

​prefixRequired

​newbitsRequired

​netnumRequired

​Cidrsubnets

​prefixRequired

​newbitsRequired

​Coalesce

​valsRequired

​Coalescelist

​valsRequired

​Compact

​listRequired

​Concat

​seqsRequired

​Contains

​listRequired

​valueRequired

​Csvdecode

​strRequired

​Dirname

​pathRequired

​Distinct

​listRequired

​Element

​listRequired

​indexRequired

​Endswith

​strRequired

​suffixRequired

​File

​pathRequired

​Filebase64

​pathRequired

​Filebase64sha256

​pathRequired

​Filebase64sha512

​pathRequired

Initializers

Static Functions

`Abs`

`num`^Required

`Abspath`

`path`^Required

`Alltrue`

`list`^Required

`Anytrue`

`list`^Required

`Base64decode`

`str`^Required

`Base64encode`

`str`^Required

`Base64gzip`

`str`^Required

`Base64sha256`

`str`^Required

`Base64sha512`

`str`^Required

`Basename`

`path`^Required

`Can`

`expression`^Required

`Ceil`

`num`^Required

`Chomp`

`str`^Required

`Chunklist`

`list`^Required

`size`^Required

`Cidrhost`

`prefix`^Required

`hostnum`^Required

`Cidrnetmask`

`prefix`^Required

`Cidrsubnet`

`prefix`^Required

`newbits`^Required

`netnum`^Required

`Cidrsubnets`

`prefix`^Required

`newbits`^Required

`Coalesce`

`vals`^Required

`Coalescelist`

`vals`^Required

`Compact`

`list`^Required

`Concat`

`seqs`^Required

`Contains`

`list`^Required

`value`^Required

`Csvdecode`

`str`^Required

`Dirname`

`path`^Required

`Distinct`

`list`^Required

`Element`

`list`^Required

`index`^Required

`Endswith`

`str`^Required

`suffix`^Required

`File`

`path`^Required

`Filebase64`

`path`^Required

`Filebase64sha256`

`path`^Required

`Filebase64sha512`

`path`^Required

`Fileexists`

`path`^Required

`Filemd5`

`path`^Required

`Fileset`

`path`^Required