Typescript: Fn - CDK Terrain (CDKTN)

Initializers

import { Fn } from 'cdktn'

new 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.
`base64gunzip`	base64gunzip decodes a Base64-encoded string and uncompresses the result with gzip.
`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.
`cidrcontains`	cidrcontains determines whether a given IP address or an address prefix given in CIDR notation is within a given IP network address prefix.
`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.
`convert`	convert converts a value to the given type constraint.
`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.
`ephemeralasnull`	ephemeralasnull takes a value of any type and returns a similar value of the same type with any ephemeral values replaced with non-ephemeral null values and all non-ephemeral values preserved.
`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.
`issensitive`	issensitive takes a value and returns a boolean indicating if the value is sensitive.
`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.
`templatestring`	templatestring takes a string from elsewhere in the module 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.
`urldecode`	urldecode applies URL decoding to a given encoded string.
`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 { Fn } from 'cdktn'

Fn.abs(num: number)

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: number

`abspath`

import { Fn } from 'cdktn'

Fn.abspath(path: 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 { Fn } from 'cdktn'

Fn.alltrue(list: any[])

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: any[]

`anytrue`

import { Fn } from 'cdktn'

Fn.anytrue(list: any[])

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: any[]

`base64decode`

import { Fn } from 'cdktn'

Fn.base64decode(str: string)

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

`str`^Required

Type: string

`base64encode`

import { Fn } from 'cdktn'

Fn.base64encode(str: string)

base64encode applies Base64 encoding to a string.

`str`^Required

Type: string

`base64gunzip`

import { Fn } from 'cdktn'

Fn.base64gunzip(str: string)

base64gunzip decodes a Base64-encoded string and uncompresses the result with gzip.

`str`^Required

Type: string

`base64gzip`

import { Fn } from 'cdktn'

Fn.base64gzip(str: string)

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

`str`^Required

Type: string

`base64sha256`

import { Fn } from 'cdktn'

Fn.base64sha256(str: 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 { Fn } from 'cdktn'

Fn.base64sha512(str: 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 { Fn } from 'cdktn'

Fn.basename(path: string)

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

`path`^Required

Type: string

`can`

import { Fn } from 'cdktn'

Fn.can(expression: any)

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

`expression`^Required

Type: any

`ceil`

import { Fn } from 'cdktn'

Fn.ceil(num: number)

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

`num`^Required

Type: number

`chomp`

import { Fn } from 'cdktn'

Fn.chomp(str: string)

chomp removes newline characters at the end of a string.

`str`^Required

Type: string

`chunklist`

import { Fn } from 'cdktn'

Fn.chunklist(list: any[], size: number)

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

`list`^Required

Type: any[]

`size`^Required

Type: number

`cidrcontains`

import { Fn } from 'cdktn'

Fn.cidrcontains(containing_prefix: string, contained_ip_or_prefix: string)

cidrcontains determines whether a given IP address or an address prefix given in CIDR notation is within a given IP network address prefix.

`containing_prefix`^Required

Type: string

`contained_ip_or_prefix`^Required

Type: string

`cidrhost`

import { Fn } from 'cdktn'

Fn.cidrhost(prefix: string, hostnum: number)

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: number

`cidrnetmask`

import { Fn } from 'cdktn'

Fn.cidrnetmask(prefix: string)

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

`prefix`^Required

Type: string

`cidrsubnet`

import { Fn } from 'cdktn'

Fn.cidrsubnet(prefix: string, newbits: number, netnum: number)

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

`prefix`^Required

Type: string

`newbits`^Required

Type: number

`netnum`^Required

Type: number

`cidrsubnets`

import { Fn } from 'cdktn'

Fn.cidrsubnets(prefix: string, newbits: number[])

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

`prefix`^Required

Type: string

`newbits`^Required

Type: number[]

`coalesce`

import { Fn } from 'cdktn'

Fn.coalesce(vals: any[])

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

`vals`^Required

Type: any[]

`coalescelist`

import { Fn } from 'cdktn'

Fn.coalescelist(vals: any[])

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

`vals`^Required

Type: any[]

`compact`

import { Fn } from 'cdktn'

Fn.compact(list: string[])

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

`list`^Required

Type: string[]

`concat`

import { Fn } from 'cdktn'

Fn.concat(seqs: any[])

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

`seqs`^Required

Type: any[]

`contains`

import { Fn } from 'cdktn'

Fn.contains(list: any, value: any)

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

`list`^Required

Type: any

`value`^Required

Type: any

`convert`

import { Fn } from 'cdktn'

Fn.convert(value: any, type: any)

convert converts a value to the given type constraint.

`value`^Required

Type: any

`type`^Required

Type: any

`csvdecode`

import { Fn } from 'cdktn'

Fn.csvdecode(str: string)

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

`str`^Required

Type: string

`dirname`

import { Fn } from 'cdktn'

Fn.dirname(path: string)

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

`path`^Required

Type: string

`distinct`

import { Fn } from 'cdktn'

Fn.distinct(list: any[])

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

`list`^Required

Type: any[]

`element`

import { Fn } from 'cdktn'

Fn.element(list: any, index: number)

element retrieves a single element from a list.

`list`^Required

Type: any

`index`^Required

Type: number

`endswith`

import { Fn } from 'cdktn'

Fn.endswith(str: string, suffix: string)

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

`ephemeralasnull`

import { Fn } from 'cdktn'

Fn.ephemeralasnull(value: any)

ephemeralasnull takes a value of any type and returns a similar value of the same type with any ephemeral values replaced with non-ephemeral null values and all non-ephemeral values preserved.

`value`^Required

Type: any

`file`

import { Fn } from 'cdktn'

Fn.file(path: string)

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

`path`^Required

Type: string

`filebase64`

import { Fn } from 'cdktn'

Fn.filebase64(path: 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 { Fn } from 'cdktn'

Fn.filebase64sha256(path: 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 { Fn } from 'cdktn'

Fn.filebase64sha512(path: 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 { Fn } from 'cdktn'

Fn.fileexists(path: string)

fileexists determines whether a file exists at a given path.

`path`^Required

Type: string

`filemd5`

import { Fn } from 'cdktn'

Fn.filemd5(path: 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 { Fn } from 'cdktn'

Fn.fileset(path: string, pattern: 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 { Fn } from 'cdktn'

Fn.filesha1(path: 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 { Fn } from 'cdktn'

Fn.filesha256(path: 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 { Fn } from 'cdktn'

Fn.filesha512(path: 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 { Fn } from 'cdktn'

Fn.flatten(list: any)

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

`list`^Required

Type: any

`floor`

import { Fn } from 'cdktn'

Fn.floor(num: number)

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

`num`^Required

Type: number

`format`

import { Fn } from 'cdktn'

Fn.format(format: string, args: any[])

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: any[]

`formatdate`

import { Fn } from 'cdktn'

Fn.formatdate(format: string, time: string)

formatdate converts a timestamp into a different time format.

`format`^Required

Type: string

`time`^Required

Type: string

`formatlist`

import { Fn } from 'cdktn'

Fn.formatlist(format: string, args: any[])

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: any[]

`indent`

import { Fn } from 'cdktn'

Fn.indent(spaces: number, str: 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: number

`str`^Required

Type: string

`index`

import { Fn } from 'cdktn'

Fn.index(list: any, value: any)

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

`list`^Required

Type: any

`value`^Required

Type: any

`issensitive`

import { Fn } from 'cdktn'

Fn.issensitive(value: any)

issensitive takes a value and returns a boolean indicating if the value is sensitive.

`value`^Required

Type: any

`jsondecode`

import { Fn } from 'cdktn'

Fn.jsondecode(str: string)

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

`str`^Required

Type: string

`jsonencode`

import { Fn } from 'cdktn'

Fn.jsonencode(val: any)

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

`val`^Required

Type: any

`keys`

import { Fn } from 'cdktn'

Fn.keys(inputMap: any)

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

`inputMap`^Required

Type: any

`lengthOf`

import { Fn } from 'cdktn'

Fn.lengthOf(value: any)

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

`value`^Required

Type: any

`log`

import { Fn } from 'cdktn'

Fn.log(num: number, base: number)

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

`num`^Required

Type: number

`base`^Required

Type: number

`lower`

import { Fn } from 'cdktn'

Fn.lower(str: string)

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

`str`^Required

Type: string

`matchkeys`

import { Fn } from 'cdktn'

Fn.matchkeys(values: any[], keys: any[], searchset: any[])

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: any[]

`keys`^Required

Type: any[]

`searchset`^Required

Type: any[]

`max`

import { Fn } from 'cdktn'

Fn.max(numbers: number[])

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

`numbers`^Required

Type: number[]

`md5`

import { Fn } from 'cdktn'

Fn.md5(str: string)

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

`str`^Required

Type: string

`merge`

import { Fn } from 'cdktn'

Fn.merge(maps: any[])

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: any[]

`min`

import { Fn } from 'cdktn'

Fn.min(numbers: number[])

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

`numbers`^Required

Type: number[]

`nonsensitive`

import { Fn } from 'cdktn'

Fn.nonsensitive(value: any)

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: any

`one`

import { Fn } from 'cdktn'

Fn.one(list: any)

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: any

`parseint`

import { Fn } from 'cdktn'

Fn.parseint(number: any, base: number)

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: any

`base`^Required

Type: number

`pathexpand`

import { Fn } from 'cdktn'

Fn.pathexpand(path: 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 { Fn } from 'cdktn'

Fn.plantimestamp()

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

`pow`

import { Fn } from 'cdktn'

Fn.pow(num: number, power: number)

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

`num`^Required

Type: number

`power`^Required

Type: number

`regex`

import { Fn } from 'cdktn'

Fn.regex(pattern: string, str: string)

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

`pattern`^Required

Type: string

`str`^Required

Type: string

`regexall`

import { Fn } from 'cdktn'

Fn.regexall(pattern: string, str: 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 { Fn } from 'cdktn'

Fn.replace(str: string, substr: string, replace: 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 { Fn } from 'cdktn'

Fn.reverse(list: any)

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: any

`rsadecrypt`

import { Fn } from 'cdktn'

Fn.rsadecrypt(ciphertext: string, privatekey: string)

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

`ciphertext`^Required

Type: string

`privatekey`^Required

Type: string

`sensitive`

import { Fn } from 'cdktn'

Fn.sensitive(value: any)

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: any

`setintersection`

import { Fn } from 'cdktn'

Fn.setintersection(first_set: any[], other_sets: any[][])

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: any[]

`other_sets`^Required

Type: any[][]

`setproduct`

import { Fn } from 'cdktn'

Fn.setproduct(sets: any[])

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: any[]

`setsubtract`

import { Fn } from 'cdktn'

Fn.setsubtract(a: any[], b: any[])

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: any[]

`b`^Required

Type: any[]

`setunion`

import { Fn } from 'cdktn'

Fn.setunion(first_set: any[], other_sets: any[][])

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: any[]

`other_sets`^Required

Type: any[][]

`sha1`

import { Fn } from 'cdktn'

Fn.sha1(str: string)

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

`str`^Required

Type: string

`sha256`

import { Fn } from 'cdktn'

Fn.sha256(str: string)

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

`str`^Required

Type: string

`sha512`

import { Fn } from 'cdktn'

Fn.sha512(str: string)

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

`str`^Required

Type: string

`signum`

import { Fn } from 'cdktn'

Fn.signum(num: number)

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

`num`^Required

Type: number

`slice`

import { Fn } from 'cdktn'

Fn.slice(list: any, start_index: number, end_index: number)

slice extracts some consecutive elements from within a list.

`list`^Required

Type: any

`start_index`^Required

Type: number

`end_index`^Required

Type: number

`sort`

import { Fn } from 'cdktn'

Fn.sort(list: string[])

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

`list`^Required

Type: string[]

`split`

import { Fn } from 'cdktn'

Fn.split(separator: string, str: 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 { Fn } from 'cdktn'

Fn.startswith(str: string, prefix: string)

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 { Fn } from 'cdktn'

Fn.strcontains(str: string, substr: string)

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 { Fn } from 'cdktn'

Fn.strrev(str: 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 { Fn } from 'cdktn'

Fn.substr(str: string, offset: number, length: number)

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

`str`^Required

Type: string

`offset`^Required

Type: number

`length`^Required

Type: number

`sum`

import { Fn } from 'cdktn'

Fn.sum(list: any)

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

`list`^Required

Type: any

`templatefile`

import { Fn } from 'cdktn'

Fn.templatefile(path: string, vars: any)

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: any

`templatestring`

import { Fn } from 'cdktn'

Fn.templatestring(template: string, vars: any)

templatestring takes a string from elsewhere in the module and renders its content as a template using a supplied set of template variables.

`template`^Required

Type: string

`vars`^Required

Type: any

`textdecodebase64`

import { Fn } from 'cdktn'

Fn.textdecodebase64(source: string, encoding: 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 { Fn } from 'cdktn'

Fn.textencodebase64(str: string, encoding: 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 { Fn } from 'cdktn'

Fn.timeadd(timestamp: string, duration: string)

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

`timestamp`^Required

Type: string

`duration`^Required

Type: string

`timecmp`

import { Fn } from 'cdktn'

Fn.timecmp(timestamp_a: string, timestamp_b: string)

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 { Fn } from 'cdktn'

Fn.timestamp()

timestamp returns a UTC timestamp string in RFC 3339 format.

`title`

import { Fn } from 'cdktn'

Fn.title(str: string)

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

`str`^Required

Type: string

`tobool`

import { Fn } from 'cdktn'

Fn.tobool(v: any)

tobool converts its argument to a boolean value.

`v`^Required

Type: any

`tolist`

import { Fn } from 'cdktn'

Fn.tolist(v: any)

tolist converts its argument to a list value.

`v`^Required

Type: any

`tomap`

import { Fn } from 'cdktn'

Fn.tomap(v: any)

tomap converts its argument to a map value.

`v`^Required

Type: any

`tonumber`

import { Fn } from 'cdktn'

Fn.tonumber(v: any)

tonumber converts its argument to a number value.

`v`^Required

Type: any

`toset`

import { Fn } from 'cdktn'

Fn.toset(v: any)

toset converts its argument to a set value.

`v`^Required

Type: any

`tostring`

import { Fn } from 'cdktn'

Fn.tostring(v: any)

tostring converts its argument to a string value.

`v`^Required

Type: any

`transpose`

import { Fn } from 'cdktn'

Fn.transpose(values: any)

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: any

`trim`

import { Fn } from 'cdktn'

Fn.trim(str: string, cutset: 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 { Fn } from 'cdktn'

Fn.trimprefix(str: string, prefix: 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 { Fn } from 'cdktn'

Fn.trimspace(str: string)

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

`str`^Required

Type: string

`trimsuffix`

import { Fn } from 'cdktn'

Fn.trimsuffix(str: string, suffix: string)

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

`str`^Required

Type: string

`suffix`^Required

Type: string

`try`

import { Fn } from 'cdktn'

Fn.try(expressions: any[])

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: any[]

`upper`

import { Fn } from 'cdktn'

Fn.upper(str: string)

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

`str`^Required

Type: string

`urldecode`

import { Fn } from 'cdktn'

Fn.urldecode(str: string)

urldecode applies URL decoding to a given encoded string.

`str`^Required

Type: string

`urlencode`

import { Fn } from 'cdktn'

Fn.urlencode(str: string)

urlencode applies URL encoding to a given string.

`str`^Required

Type: string

`uuid`

import { Fn } from 'cdktn'

Fn.uuid()

uuid generates a unique identifier string.

`uuidv5`

import { Fn } from 'cdktn'

Fn.uuidv5(namespace: string, name: 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 { Fn } from 'cdktn'

Fn.values(mapping: any)

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

`mapping`^Required

Type: any

`yamldecode`

import { Fn } from 'cdktn'

Fn.yamldecode(src: string)

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

`src`^Required

Type: string

`yamlencode`

import { Fn } from 'cdktn'

Fn.yamlencode(value: any)

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

`value`^Required

Type: any

`zipmap`

import { Fn } from 'cdktn'

Fn.zipmap(keys: string[], values: any)

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

`keys`^Required

Type: string[]

`values`^Required

Type: any

`bcrypt`

import { Fn } from 'cdktn'

Fn.bcrypt(str: string, cost?: number)

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: number

`conditional`

import { Fn } from 'cdktn'

Fn.conditional(condition: any, trueValue: any, falseValue: any)

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: any

`trueValue`^Required

Type: any

`falseValue`^Required

Type: any

`join`

import { Fn } from 'cdktn'

Fn.join(separator: string, list: 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 { Fn } from 'cdktn'

Fn.lookup(inputMap: any, key: string, defaultValue?: any)

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: any

`key`^Required

Type: string

`defaultValue`^Optional

Type: any

`lookupNested`

import { Fn } from 'cdktn'

Fn.lookupNested(inputMap: any, path: any[])

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: any

`path`^Required

Type: any[]

`range`

import { Fn } from 'cdktn'

Fn.range(start: number, limit: number, step?: number)

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

`start`^Required

Type: number

`limit`^Required

Type: number

`step`^Optional

Type: number

`rawString`

import { Fn } from 'cdktn'

Fn.rawString(str: 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

Typescript: DynamicListTerraformIterator

Typescript: FnGenerated

⌘I

​Initializers

​Static Functions

​abs

​numRequired

​abspath

​pathRequired

​alltrue

​listRequired

​anytrue

​listRequired

​base64decode

​strRequired

​base64encode

​strRequired

​base64gunzip

​strRequired

​base64gzip

​strRequired

​base64sha256

​strRequired

​base64sha512

​strRequired

​basename

​pathRequired

​can

​expressionRequired

​ceil

​numRequired

​chomp

​strRequired

​chunklist

​listRequired

​sizeRequired

​cidrcontains

​containing_prefixRequired

​contained_ip_or_prefixRequired

​cidrhost

​prefixRequired

​hostnumRequired

​cidrnetmask

​prefixRequired

​cidrsubnet

​prefixRequired

​newbitsRequired

​netnumRequired

​cidrsubnets

​prefixRequired

​newbitsRequired

​coalesce

​valsRequired

​coalescelist

​valsRequired

​compact

​listRequired

​concat

​seqsRequired

​contains

​listRequired

​valueRequired

​convert

​valueRequired

​typeRequired

​csvdecode

​strRequired

​dirname

​pathRequired

​distinct

​listRequired

​element

​listRequired

​indexRequired

​endswith

​strRequired

​suffixRequired

​ephemeralasnull

​valueRequired

​file

​pathRequired

​filebase64

​pathRequired

Initializers

Static Functions

`abs`

`num`^Required

`abspath`

`path`^Required

`alltrue`

`list`^Required

`anytrue`

`list`^Required

`base64decode`

`str`^Required

`base64encode`

`str`^Required

`base64gunzip`

`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

`cidrcontains`

`containing_prefix`^Required

`contained_ip_or_prefix`^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

`convert`

`value`^Required

`type`^Required

`csvdecode`

`str`^Required

`dirname`

`path`^Required

`distinct`

`list`^Required

`element`

`list`^Required

`index`^Required

`endswith`

`str`^Required

`suffix`^Required

`ephemeralasnull`

`value`^Required

`file`

`path`^Required

`filebase64`

`path`^Required