Python: Fn - CDK Terrain (CDKTN)

Initializers

import cdktn

cdktn.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.
`length_of`	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.
`lookup_nested`	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.
`raw_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).

`abs`

import cdktn

cdktn.Fn.abs(
  num: typing.Union[int, float]
)

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: typing.Union[int, float]

`abspath`

import cdktn

cdktn.Fn.abspath(
  path: str
)

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

`alltrue`

import cdktn

cdktn.Fn.alltrue(
  list: typing.List[typing.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: typing.List[typing.Any]

`anytrue`

import cdktn

cdktn.Fn.anytrue(
  list: typing.List[typing.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: typing.List[typing.Any]

`base64decode`

import cdktn

cdktn.Fn.base64decode(
  str: str
)

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

`str`^Required

Type: str

`base64encode`

import cdktn

cdktn.Fn.base64encode(
  str: str
)

base64encode applies Base64 encoding to a string.

`str`^Required

Type: str

`base64gunzip`

import cdktn

cdktn.Fn.base64gunzip(
  str: str
)

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

`str`^Required

Type: str

`base64gzip`

import cdktn

cdktn.Fn.base64gzip(
  str: str
)

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

`str`^Required

Type: str

`base64sha256`

import cdktn

cdktn.Fn.base64sha256(
  str: str
)

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

`base64sha512`

import cdktn

cdktn.Fn.base64sha512(
  str: str
)

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

`basename`

import cdktn

cdktn.Fn.basename(
  path: str
)

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

`path`^Required

Type: str

`can`

import cdktn

cdktn.Fn.can(
  expression: typing.Any
)

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

`expression`^Required

Type: typing.Any

`ceil`

import cdktn

cdktn.Fn.ceil(
  num: typing.Union[int, float]
)

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

`num`^Required

Type: typing.Union[int, float]

`chomp`

import cdktn

cdktn.Fn.chomp(
  str: str
)

chomp removes newline characters at the end of a string.

`str`^Required

Type: str

`chunklist`

import cdktn

cdktn.Fn.chunklist(
  list: typing.List[typing.Any],
  size: typing.Union[int, float]
)

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

`list`^Required

Type: typing.List[typing.Any]

`size`^Required

Type: typing.Union[int, float]

`cidrcontains`

import cdktn

cdktn.Fn.cidrcontains(
  containing_prefix: str,
  contained_ip_or_prefix: str
)

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

`contained_ip_or_prefix`^Required

Type: str

`cidrhost`

import cdktn

cdktn.Fn.cidrhost(
  prefix: str,
  hostnum: typing.Union[int, float]
)

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

`prefix`^Required

Type: str

`hostnum`^Required

Type: typing.Union[int, float]

`cidrnetmask`

import cdktn

cdktn.Fn.cidrnetmask(
  prefix: str
)

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

`prefix`^Required

Type: str

`cidrsubnet`

import cdktn

cdktn.Fn.cidrsubnet(
  prefix: str,
  newbits: typing.Union[int, float],
  netnum: typing.Union[int, float]
)

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

`prefix`^Required

Type: str

`newbits`^Required

Type: typing.Union[int, float]

`netnum`^Required

Type: typing.Union[int, float]

`cidrsubnets`

import cdktn

cdktn.Fn.cidrsubnets(
  prefix: str,
  newbits: typing.List[typing.Union[int, float]]
)

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

`prefix`^Required

Type: str

`newbits`^Required

Type: typing.List[typing.Union[int, float]]

`coalesce`

import cdktn

cdktn.Fn.coalesce(
  vals: typing.List[typing.Any]
)

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

`vals`^Required

Type: typing.List[typing.Any]

`coalescelist`

import cdktn

cdktn.Fn.coalescelist(
  vals: typing.List[typing.Any]
)

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

`vals`^Required

Type: typing.List[typing.Any]

`compact`

import cdktn

cdktn.Fn.compact(
  list: typing.List[str]
)

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

`list`^Required

Type: typing.List[str]

`concat`

import cdktn

cdktn.Fn.concat(
  seqs: typing.List[typing.Any]
)

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

`seqs`^Required

Type: typing.List[typing.Any]

`contains`

import cdktn

cdktn.Fn.contains(
  list: typing.Any,
  value: typing.Any
)

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

`list`^Required

Type: typing.Any

`value`^Required

Type: typing.Any

`convert`

import cdktn

cdktn.Fn.convert(
  value: typing.Any,
  type: typing.Any
)

convert converts a value to the given type constraint.

`value`^Required

Type: typing.Any

`type`^Required

Type: typing.Any

`csvdecode`

import cdktn

cdktn.Fn.csvdecode(
  str: str
)

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

`str`^Required

Type: str

`dirname`

import cdktn

cdktn.Fn.dirname(
  path: str
)

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

`path`^Required

Type: str

`distinct`

import cdktn

cdktn.Fn.distinct(
  list: typing.List[typing.Any]
)

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

`list`^Required

Type: typing.List[typing.Any]

`element`

import cdktn

cdktn.Fn.element(
  list: typing.Any,
  index: typing.Union[int, float]
)

element retrieves a single element from a list.

`list`^Required

Type: typing.Any

`index`^Required

Type: typing.Union[int, float]

`endswith`

import cdktn

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

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

`suffix`^Required

Type: str

`ephemeralasnull`

import cdktn

cdktn.Fn.ephemeralasnull(
  value: typing.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: typing.Any

`file`

import cdktn

cdktn.Fn.file(
  path: str
)

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

`path`^Required

Type: str

`filebase64`

import cdktn

cdktn.Fn.filebase64(
  path: str
)

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

`path`^Required

Type: str

`filebase64sha256`

import cdktn

cdktn.Fn.filebase64sha256(
  path: str
)

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

`path`^Required

Type: str

`filebase64sha512`

import cdktn

cdktn.Fn.filebase64sha512(
  path: str
)

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

`path`^Required

Type: str

`fileexists`

import cdktn

cdktn.Fn.fileexists(
  path: str
)

fileexists determines whether a file exists at a given path.

`path`^Required

Type: str

`filemd5`

import cdktn

cdktn.Fn.filemd5(
  path: str
)

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

`path`^Required

Type: str

`fileset`

import cdktn

cdktn.Fn.fileset(
  path: str,
  pattern: str
)

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

`pattern`^Required

Type: str

`filesha1`

import cdktn

cdktn.Fn.filesha1(
  path: str
)

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

`path`^Required

Type: str

`filesha256`

import cdktn

cdktn.Fn.filesha256(
  path: str
)

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

`path`^Required

Type: str

`filesha512`

import cdktn

cdktn.Fn.filesha512(
  path: str
)

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

`path`^Required

Type: str

`flatten`

import cdktn

cdktn.Fn.flatten(
  list: typing.Any
)

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

`list`^Required

Type: typing.Any

`floor`

import cdktn

cdktn.Fn.floor(
  num: typing.Union[int, float]
)

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

`num`^Required

Type: typing.Union[int, float]

`format`

import cdktn

cdktn.Fn.format(
  format: str,
  args: typing.List[typing.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: str

`args`^Required

Type: typing.List[typing.Any]

`formatdate`

import cdktn

cdktn.Fn.formatdate(
  format: str,
  time: str
)

formatdate converts a timestamp into a different time format.

`format`^Required

Type: str

`time`^Required

Type: str

`formatlist`

import cdktn

cdktn.Fn.formatlist(
  format: str,
  args: typing.List[typing.Any]
)

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

`format`^Required

Type: str

`args`^Required

Type: typing.List[typing.Any]

`indent`

import cdktn

cdktn.Fn.indent(
  spaces: typing.Union[int, float],
  str: str
)

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: typing.Union[int, float]

`str`^Required

Type: str

`index`

import cdktn

cdktn.Fn.index(
  list: typing.Any,
  value: typing.Any
)

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

`list`^Required

Type: typing.Any

`value`^Required

Type: typing.Any

`issensitive`

import cdktn

cdktn.Fn.issensitive(
  value: typing.Any
)

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

`value`^Required

Type: typing.Any

`jsondecode`

import cdktn

cdktn.Fn.jsondecode(
  str: str
)

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

`str`^Required

Type: str

`jsonencode`

import cdktn

cdktn.Fn.jsonencode(
  val: typing.Any
)

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

`val`^Required

Type: typing.Any

`keys`

import cdktn

cdktn.Fn.keys(
  input_map: typing.Any
)

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

`input_map`^Required

Type: typing.Any

`length_of`

import cdktn

cdktn.Fn.length_of(
  value: typing.Any
)

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

`value`^Required

Type: typing.Any

`log`

import cdktn

cdktn.Fn.log(
  num: typing.Union[int, float],
  base: typing.Union[int, float]
)

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

`num`^Required

Type: typing.Union[int, float]

`base`^Required

Type: typing.Union[int, float]

`lower`

import cdktn

cdktn.Fn.lower(
  str: str
)

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

`str`^Required

Type: str

`matchkeys`

import cdktn

cdktn.Fn.matchkeys(
  values: typing.List[typing.Any],
  keys: typing.List[typing.Any],
  searchset: typing.List[typing.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: typing.List[typing.Any]

`keys`^Required

Type: typing.List[typing.Any]

`searchset`^Required

Type: typing.List[typing.Any]

`max`

import cdktn

cdktn.Fn.max(
  numbers: typing.List[typing.Union[int, float]]
)

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

`numbers`^Required

Type: typing.List[typing.Union[int, float]]

`md5`

import cdktn

cdktn.Fn.md5(
  str: str
)

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

`str`^Required

Type: str

`merge`

import cdktn

cdktn.Fn.merge(
  maps: typing.List[typing.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: typing.List[typing.Any]

`min`

import cdktn

cdktn.Fn.min(
  numbers: typing.List[typing.Union[int, float]]
)

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

`numbers`^Required

Type: typing.List[typing.Union[int, float]]

`nonsensitive`

import cdktn

cdktn.Fn.nonsensitive(
  value: typing.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: typing.Any

`one`

import cdktn

cdktn.Fn.one(
  list: typing.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: typing.Any

`parseint`

import cdktn

cdktn.Fn.parseint(
  number: typing.Any,
  base: typing.Union[int, float]
)

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: typing.Any

`base`^Required

Type: typing.Union[int, float]

`pathexpand`

import cdktn

cdktn.Fn.pathexpand(
  path: str
)

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

`plantimestamp`

import cdktn

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 cdktn

cdktn.Fn.pow(
  num: typing.Union[int, float],
  power: typing.Union[int, float]
)

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

`num`^Required

Type: typing.Union[int, float]

`power`^Required

Type: typing.Union[int, float]

`regex`

import cdktn

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

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

`pattern`^Required

Type: str

`str`^Required

Type: str

`regexall`

import cdktn

cdktn.Fn.regexall(
  pattern: str,
  str: str
)

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

`pattern`^Required

Type: str

`str`^Required

Type: str

`replace`

import cdktn

cdktn.Fn.replace(
  str: str,
  substr: str,
  replace: str
)

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

`str`^Required

Type: str

`substr`^Required

Type: str

`replace`^Required

Type: str

`reverse`

import cdktn

cdktn.Fn.reverse(
  list: typing.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: typing.Any

`rsadecrypt`

import cdktn

cdktn.Fn.rsadecrypt(
  ciphertext: str,
  privatekey: str
)

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

`ciphertext`^Required

Type: str

`privatekey`^Required

Type: str

`sensitive`

import cdktn

cdktn.Fn.sensitive(
  value: typing.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: typing.Any

`setintersection`

import cdktn

cdktn.Fn.setintersection(
  first_set: typing.List[typing.Any],
  other_sets: typing.List[typing.List[typing.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: typing.List[typing.Any]

`other_sets`^Required

Type: typing.List[typing.List[typing.Any]]

`setproduct`

import cdktn

cdktn.Fn.setproduct(
  sets: typing.List[typing.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: typing.List[typing.Any]

`setsubtract`

import cdktn

cdktn.Fn.setsubtract(
  a: typing.List[typing.Any],
  b: typing.List[typing.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: typing.List[typing.Any]

`b`^Required

Type: typing.List[typing.Any]

`setunion`

import cdktn

cdktn.Fn.setunion(
  first_set: typing.List[typing.Any],
  other_sets: typing.List[typing.List[typing.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: typing.List[typing.Any]

`other_sets`^Required

Type: typing.List[typing.List[typing.Any]]

`sha1`

import cdktn

cdktn.Fn.sha1(
  str: str
)

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

`str`^Required

Type: str

`sha256`

import cdktn

cdktn.Fn.sha256(
  str: str
)

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

`str`^Required

Type: str

`sha512`

import cdktn

cdktn.Fn.sha512(
  str: str
)

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

`str`^Required

Type: str

`signum`

import cdktn

cdktn.Fn.signum(
  num: typing.Union[int, float]
)

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

`num`^Required

Type: typing.Union[int, float]

`slice`

import cdktn

cdktn.Fn.slice(
  list: typing.Any,
  start_index: typing.Union[int, float],
  end_index: typing.Union[int, float]
)

slice extracts some consecutive elements from within a list.

`list`^Required

Type: typing.Any

`start_index`^Required

Type: typing.Union[int, float]

`end_index`^Required

Type: typing.Union[int, float]

`sort`

import cdktn

cdktn.Fn.sort(
  list: typing.List[str]
)

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

`list`^Required

Type: typing.List[str]

`split`

import cdktn

cdktn.Fn.split(
  separator: str,
  str: str
)

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

`separator`^Required

Type: str

`str`^Required

Type: str

`startswith`

import cdktn

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

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

`prefix`^Required

Type: str

`strcontains`

import cdktn

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

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

`substr`^Required

Type: str

`strrev`

import cdktn

cdktn.Fn.strrev(
  str: str
)

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

`substr`

import cdktn

cdktn.Fn.substr(
  str: str,
  offset: typing.Union[int, float],
  length: typing.Union[int, float]
)

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

`str`^Required

Type: str

`offset`^Required

Type: typing.Union[int, float]

`length`^Required

Type: typing.Union[int, float]

`sum`

import cdktn

cdktn.Fn.sum(
  list: typing.Any
)

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

`list`^Required

Type: typing.Any

`templatefile`

import cdktn

cdktn.Fn.templatefile(
  path: str,
  vars: typing.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: str

`vars`^Required

Type: typing.Any

`templatestring`

import cdktn

cdktn.Fn.templatestring(
  template: str,
  vars: typing.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: str

`vars`^Required

Type: typing.Any

`textdecodebase64`

import cdktn

cdktn.Fn.textdecodebase64(
  source: str,
  encoding: str
)

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

`encoding`^Required

Type: str

`textencodebase64`

import cdktn

cdktn.Fn.textencodebase64(
  str: str,
  encoding: str
)

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

`encoding`^Required

Type: str

`timeadd`

import cdktn

cdktn.Fn.timeadd(
  timestamp: str,
  duration: str
)

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

`timestamp`^Required

Type: str

`duration`^Required

Type: str

`timecmp`

import cdktn

cdktn.Fn.timecmp(
  timestamp_a: str,
  timestamp_b: str
)

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

`timestamp_a`^Required

Type: str

`timestamp_b`^Required

Type: str

`timestamp`

import cdktn

cdktn.Fn.timestamp()

timestamp returns a UTC timestamp string in RFC 3339 format.

`title`

import cdktn

cdktn.Fn.title(
  str: str
)

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

`str`^Required

Type: str

`tobool`

import cdktn

cdktn.Fn.tobool(
  v: typing.Any
)

tobool converts its argument to a boolean value.

`v`^Required

Type: typing.Any

`tolist`

import cdktn

cdktn.Fn.tolist(
  v: typing.Any
)

tolist converts its argument to a list value.

`v`^Required

Type: typing.Any

`tomap`

import cdktn

cdktn.Fn.tomap(
  v: typing.Any
)

tomap converts its argument to a map value.

`v`^Required

Type: typing.Any

`tonumber`

import cdktn

cdktn.Fn.tonumber(
  v: typing.Any
)

tonumber converts its argument to a number value.

`v`^Required

Type: typing.Any

`toset`

import cdktn

cdktn.Fn.toset(
  v: typing.Any
)

toset converts its argument to a set value.

`v`^Required

Type: typing.Any

`tostring`

import cdktn

cdktn.Fn.tostring(
  v: typing.Any
)

tostring converts its argument to a string value.

`v`^Required

Type: typing.Any

`transpose`

import cdktn

cdktn.Fn.transpose(
  values: typing.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: typing.Any

`trim`

import cdktn

cdktn.Fn.trim(
  str: str,
  cutset: str
)

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

`str`^Required

Type: str

`cutset`^Required

Type: str

`trimprefix`

import cdktn

cdktn.Fn.trimprefix(
  str: str,
  prefix: str
)

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

`prefix`^Required

Type: str

`trimspace`

import cdktn

cdktn.Fn.trimspace(
  str: str
)

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

`str`^Required

Type: str

`trimsuffix`

import cdktn

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

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

`str`^Required

Type: str

`suffix`^Required

Type: str

`try`

import cdktn

cdktn.Fn.try(
  expressions: typing.List[typing.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: typing.List[typing.Any]

`upper`

import cdktn

cdktn.Fn.upper(
  str: str
)

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

`str`^Required

Type: str

`urldecode`

import cdktn

cdktn.Fn.urldecode(
  str: str
)

urldecode applies URL decoding to a given encoded string.

`str`^Required

Type: str

`urlencode`

import cdktn

cdktn.Fn.urlencode(
  str: str
)

urlencode applies URL encoding to a given string.

`str`^Required

Type: str

`uuid`

import cdktn

cdktn.Fn.uuid()

uuid generates a unique identifier string.

`uuidv5`

import cdktn

cdktn.Fn.uuidv5(
  namespace: str,
  name: str
)

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

`namespace`^Required

Type: str

`name`^Required

Type: str

`values`

import cdktn

cdktn.Fn.values(
  mapping: typing.Any
)

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

`mapping`^Required

Type: typing.Any

`yamldecode`

import cdktn

cdktn.Fn.yamldecode(
  src: str
)

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

`src`^Required

Type: str

`yamlencode`

import cdktn

cdktn.Fn.yamlencode(
  value: typing.Any
)

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

`value`^Required

Type: typing.Any

`zipmap`

import cdktn

cdktn.Fn.zipmap(
  keys: typing.List[str],
  values: typing.Any
)

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

`keys`^Required

Type: typing.List[str]

`values`^Required

Type: typing.Any

`bcrypt`

import cdktn

cdktn.Fn.bcrypt(
  str: str,
  cost: typing.Union[int, float] = None
)

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

`cost`^Optional

Type: typing.Union[int, float]

`conditional`

import cdktn

cdktn.Fn.conditional(
  condition: typing.Any,
  true_value: typing.Any,
  false_value: typing.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: typing.Any

`true_value`^Required

Type: typing.Any

`false_value`^Required

Type: typing.Any

`join`

import cdktn

cdktn.Fn.join(
  separator: str,
  list: typing.List[str]
)

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

`separator`^Required

Type: str

`list`^Required

Type: typing.List[str]

`lookup`

import cdktn

cdktn.Fn.lookup(
  input_map: typing.Any,
  key: str,
  default_value: typing.Any = None
)

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.

`input_map`^Required

Type: typing.Any

`key`^Required

Type: str

`default_value`^Optional

Type: typing.Any

`lookup_nested`

import cdktn

cdktn.Fn.lookup_nested(
  input_map: typing.Any,
  path: typing.List[typing.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”]

`input_map`^Required

Type: typing.Any

`path`^Required

Type: typing.List[typing.Any]

`range`

import cdktn

cdktn.Fn.range(
  start: typing.Union[int, float],
  limit: typing.Union[int, float],
  step: typing.Union[int, float] = None
)

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

`start`^Required

Type: typing.Union[int, float]

`limit`^Required

Type: typing.Union[int, float]

`step`^Optional

Type: typing.Union[int, float]

`raw_string`

import cdktn

cdktn.Fn.raw_string(
  str: str
)

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

Python: DynamicListTerraformIterator

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