FnGenerated (com.hashicorp:cdktf 0.16.0-pre.113 API)

java.lang.Object
- software.amazon.jsii.JsiiObject
- - com.hashicorp.cdktf.FnGenerated

All Implemented Interfaces:: software.amazon.jsii.JsiiSerializable

Direct Known Subclasses:: Fn

@Generated(value="jsii-pacmak/1.79.0 (build b22f628)",
           date="2023-04-14T14:24:19.114Z")
 @Stability(value=Experimental)
public class FnGenerated
extends software.amazon.jsii.JsiiObject

Nested Class Summary
- Nested classes/interfaces inherited from class software.amazon.jsii.JsiiObject
  software.amazon.jsii.JsiiObject.InitializationMode

Constructor Summary

Constructors
Modifier	Constructor and Description
	`FnGenerated()`
`protected`	`FnGenerated(software.amazon.jsii.JsiiObject.InitializationMode initializationMode)`
`protected`	`FnGenerated(software.amazon.jsii.JsiiObjectRef objRef)`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Number`	`abs(Number num)` (experimental) `abs` returns the absolute value of the given number.
`static String`	`abspath(String path)` (experimental) `abspath` takes a string containing a filesystem path and converts it to an absolute path.
`static IResolvable`	`alltrue(List<? extends Object> list)` (experimental) `alltrue` returns `true` if all elements in a given collection are `true` or `"true"`.
`static IResolvable`	`anytrue(List<? extends Object> list)` (experimental) `anytrue` returns `true` if any element in a given collection is `true` or `"true"`.
`static String`	`base64decode(String str)` (experimental) `base64decode` takes a string containing a Base64 character sequence and returns the original string.
`static String`	`base64encode(String str)` (experimental) `base64encode` applies Base64 encoding to a string.
`static String`	`base64gzip(String str)` (experimental) `base64gzip` compresses a string with gzip and then encodes the result in Base64 encoding.
`static String`	`base64sha256(String str)` (experimental) `base64sha256` computes the SHA256 hash of a given string and encodes it with Base64.
`static String`	`base64sha512(String str)` (experimental) `base64sha512` computes the SHA512 hash of a given string and encodes it with Base64.
`static String`	`basename(String path)` (experimental) `basename` takes a string containing a filesystem path and removes all except the last portion from it.
`static IResolvable`	`can(Object expression)` (experimental) `can` evaluates the given expression and returns a boolean value indicating whether the expression produced a result without any errors.
`static Number`	`ceil(Number num)` (experimental) `ceil` returns the closest whole number that is greater than or equal to the given value, which may be a fraction.
`static String`	`chomp(String str)` (experimental) `chomp` removes newline characters at the end of a string.
`static List<String>`	`chunklist(List<? extends Object> list, Number size)` (experimental) `chunklist` splits a single list into fixed-size chunks, returning a list of lists.
`static String`	`cidrhost(String prefix, Number hostnum)` (experimental) `cidrhost` calculates a full host IP address for a given host number within a given IP network address prefix.
`static String`	`cidrnetmask(String prefix)` (experimental) `cidrnetmask` converts an IPv4 address prefix given in CIDR notation into a subnet mask address.
`static String`	`cidrsubnet(String prefix, Number newbits, Number netnum)` (experimental) `cidrsubnet` calculates a subnet address within given IP network address prefix.
`static List<String>`	`cidrsubnets(String prefix, List<? extends Number> newbits)` (experimental) `cidrsubnets` calculates a sequence of consecutive IP address ranges within a particular CIDR prefix.
`static Object`	`coalesce(List<? extends Object> vals)` (experimental) `coalesce` takes any number of arguments and returns the first one that isn't null or an empty string.
`static Object`	`coalescelist(List<? extends Object> vals)` (experimental) `coalescelist` takes any number of list arguments and returns the first one that isn't empty.
`static List<String>`	`compact(List<String> list)` (experimental) `compact` takes a list of strings and returns a new list with any empty string elements removed.
`static Object`	`concat(List<? extends Object> seqs)` (experimental) `concat` takes two or more lists and combines them into a single list.
`static Object`	`contains(Object list, Object value)` (experimental) `contains` determines whether a given list or set contains a given single value as one of its elements.
`static Object`	`csvdecode(String str)` (experimental) `csvdecode` decodes a string containing CSV-formatted data and produces a list of maps representing that data.
`static String`	`dirname(String path)` (experimental) `dirname` takes a string containing a filesystem path and removes the last portion from it.
`static List<String>`	`distinct(List<? extends Object> list)` (experimental) `distinct` takes a list and returns a new list with any duplicate elements removed.
`static Object`	`doTry(List<? extends Object> expressions)` (experimental) `try` evaluates all of its argument expressions in turn and returns the result of the first one that does not produce any errors.
`static Object`	`element(Object list, Number index)` (experimental) `element` retrieves a single element from a list.
`static IResolvable`	`endswith(String str, String suffix)` (experimental) `endswith` takes two values: a string to check and a suffix string.
`static String`	`file(String path)` (experimental) `file` reads the contents of a file at the given path and returns them as a string.
`static String`	`filebase64(String path)` (experimental) `filebase64` reads the contents of a file at the given path and returns them as a base64-encoded string.
`static String`	`filebase64sha256(String path)` (experimental) `filebase64sha256` is a variant of `base64sha256` that hashes the contents of a given file rather than a literal string.
`static String`	`filebase64sha512(String path)` (experimental) `filebase64sha512` is a variant of `base64sha512` that hashes the contents of a given file rather than a literal string.
`static IResolvable`	`fileexists(String path)` (experimental) `fileexists` determines whether a file exists at a given path.
`static String`	`filemd5(String path)` (experimental) `filemd5` is a variant of `md5` that hashes the contents of a given file rather than a literal string.
`static List<String>`	`fileset(String path, String pattern)` (experimental) `fileset` enumerates a set of regular file names given a path and pattern.
`static String`	`filesha1(String path)` (experimental) `filesha1` is a variant of `sha1` that hashes the contents of a given file rather than a literal string.
`static String`	`filesha256(String path)` (experimental) `filesha256` is a variant of `sha256` that hashes the contents of a given file rather than a literal string.
`static String`	`filesha512(String path)` (experimental) `filesha512` is a variant of `sha512` that hashes the contents of a given file rather than a literal string.
`static Object`	`flatten(Object list)` (experimental) `flatten` takes a list and replaces any elements that are lists with a flattened sequence of the list contents.
`static Number`	`floor(Number num)` (experimental) `floor` returns the closest whole number that is less than or equal to the given value, which may be a fraction.
`static Object`	`format(String format, List<? extends Object> args)` (experimental) The `format` function produces a string by formatting a number of other values according to a specification string.
`static String`	`formatdate(String format, String time)` (experimental) `formatdate` converts a timestamp into a different time format.
`static Object`	`formatlist(String format, List<? extends Object> args)` (experimental) `formatlist` produces a list of strings by formatting a number of other values according to a specification string.
`static String`	`indent(Number spaces, String str)` (experimental) `indent` adds a given number of spaces to the beginnings of all but the first line in a given multi-line string.
`static Object`	`index(Object list, Object value)` (experimental) `index` finds the element index for a given value in a list.
`static Object`	`jsondecode(String str)` (experimental) `jsondecode` interprets a given string as JSON, returning a representation of the result of decoding that string.
`static String`	`jsonencode(Object val)` (experimental) `jsonencode` encodes a given value to a string using JSON syntax.
`static Object`	`keys(Object inputMap)` (experimental) `keys` takes a map and returns a list containing the keys from that map.
`static Number`	`lengthOf(Object value)` (experimental) `length` determines the length of a given list, map, or string.
`static Number`	`log(Number num, Number base)` (experimental) `log` returns the logarithm of a given number in a given base.
`static String`	`lower(String str)` (experimental) `lower` converts all cased letters in the given string to lowercase.
`static List<String>`	`matchkeys(List<? extends Object> values, List<? extends Object> keys, List<? extends Object> searchset)` (experimental) `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.
`static Number`	`max(List<? extends Number> numbers)` (experimental) `max` takes one or more numbers and returns the greatest number from the set.
`static String`	`md5(String str)` (experimental) `md5` computes the MD5 hash of a given string and encodes it with hexadecimal digits.
`static Object`	`merge(List<? extends Object> maps)` (experimental) `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.
`static Number`	`min(List<? extends Number> numbers)` (experimental) `min` takes one or more numbers and returns the smallest number from the set.
`static Object`	`nonsensitive(Object value)` (experimental) `nonsensitive` takes a sensitive value and returns a copy of that value with the sensitive marking removed, thereby exposing the sensitive value.
`static Object`	`one(Object list)` (experimental) `one` takes a list, set, or tuple value with either zero or one elements.
`static Object`	`parseint(Object number, Number base)` (experimental) `parseint` parses the given string as a representation of an integer in the specified base and returns the resulting number.
`static String`	`pathexpand(String path)` (experimental) `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.
`static Number`	`pow(Number num, Number power)` (experimental) `pow` calculates an exponent, by raising its first argument to the power of the second argument.
`static Object`	`regex(String pattern, String str)` (experimental) `regex` applies a [regular expression](https://en.wikipedia.org/wiki/Regular_expression) to a string and returns the matching substrings.
`static List<String>`	`regexall(String pattern, String str)` (experimental) `regexall` applies a [regular expression](https://en.wikipedia.org/wiki/Regular_expression) to a string and returns a list of all matches.
`static String`	`replace(String str, String substr, String replace)` (experimental) `replace` searches a given string for another given substring, and replaces each occurrence with a given replacement string.
`static Object`	`reverse(Object list)` (experimental) `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.
`static String`	`rsadecrypt(String ciphertext, String privatekey)` (experimental) `rsadecrypt` decrypts an RSA-encrypted ciphertext, returning the corresponding cleartext.
`static Object`	`sensitive(Object value)` (experimental) `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](/language/values/variables#suppressing-values-in-cli-output).
`static List<String>`	`setintersection(List<? extends Object> first_set, List<? extends List<? extends Object>> other_sets)` (experimental) The `setintersection` function takes multiple sets and produces a single set containing only the elements that all of the given sets have in common.
`static Object`	`setproduct(List<? extends Object> sets)` (experimental) The `setproduct` function finds all of the possible combinations of elements from all of the given sets by computing the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product).
`static List<String>`	`setsubtract(List<? extends Object> a, List<? extends Object> b)` (experimental) The `setsubtract` function returns a new set containing the elements from the first set that are not present in the second set.
`static List<String>`	`setunion(List<? extends Object> first_set, List<? extends List<? extends Object>> other_sets)` (experimental) The `setunion` function takes multiple sets and produces a single set containing the elements from all of the given sets.
`static String`	`sha1(String str)` (experimental) `sha1` computes the SHA1 hash of a given string and encodes it with hexadecimal digits.
`static String`	`sha256(String str)` (experimental) `sha256` computes the SHA256 hash of a given string and encodes it with hexadecimal digits.
`static String`	`sha512(String str)` (experimental) `sha512` computes the SHA512 hash of a given string and encodes it with hexadecimal digits.
`static Number`	`signum(Number num)` (experimental) `signum` determines the sign of a number, returning a number between -1 and 1 to represent the sign.
`static Object`	`slice(Object list, Number start_index, Number end_index)` (experimental) `slice` extracts some consecutive elements from within a list.
`static List<String>`	`sort(List<String> list)` (experimental) `sort` takes a list of strings and returns a new list with those strings sorted lexicographically.
`static List<String>`	`split(String separator, String str)` (experimental) `split` produces a list by dividing a given string at all occurrences of a given separator.
`static IResolvable`	`startswith(String str, String prefix)` (experimental) `startswith` takes two values: a string to check and a prefix string.
`static String`	`strrev(String str)` (experimental) `strrev` reverses the characters in a string.
`static String`	`substr(String str, Number offset, Number length)` (experimental) `substr` extracts a substring from a given string by offset and (maximum) length.
`static Object`	`sum(Object list)` (experimental) `sum` takes a list or set of numbers and returns the sum of those numbers.
`static Object`	`templatefile(String path, Object vars)` (experimental) `templatefile` reads the file at the given path and renders its content as a template using a supplied set of template variables.
`static String`	`textdecodebase64(String source, String encoding)` (experimental) `textdecodebase64` function decodes a string that was previously Base64-encoded, and then interprets the result as characters in a specified character encoding.
`static String`	`textencodebase64(String str, String encoding)` (experimental) `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.
`static String`	`timeadd(String timestamp, String duration)` (experimental) `timeadd` adds a duration to a timestamp, returning a new timestamp.
`static Number`	`timecmp(String timestamp_a, String timestamp_b)` (experimental) `timecmp` compares two timestamps and returns a number that represents the ordering of the instants those timestamps represent.
`static String`	`timestamp()` (experimental) `timestamp` returns a UTC timestamp string in [RFC 3339](https://tools.ietf.org/html/rfc3339) format.
`static String`	`title(String str)` (experimental) `title` converts the first letter of each word in the given string to uppercase.
`static IResolvable`	`tobool(Object v)` (experimental) `tobool` converts its argument to a boolean value.
`static List<String>`	`tolist(Object v)` (experimental) `tolist` converts its argument to a list value.
`static Object`	`tomap(Object v)` (experimental) `tomap` converts its argument to a map value.
`static Number`	`tonumber(Object v)` (experimental) `tonumber` converts its argument to a number value.
`static List<String>`	`toset(Object v)` (experimental) `toset` converts its argument to a set value.
`static String`	`tostring(Object v)` (experimental) `tostring` converts its argument to a string value.
`static Object`	`transpose(Object values)` (experimental) `transpose` takes a map of lists of strings and swaps the keys and values to produce a new map of lists of strings.
`static String`	`trim(String str, String cutset)` (experimental) `trim` removes the specified set of characters from the start and end of the given string.
`static String`	`trimprefix(String str, String prefix)` (experimental) `trimprefix` removes the specified prefix from the start of the given string.
`static String`	`trimspace(String str)` (experimental) `trimspace` removes any space characters from the start and end of the given string.
`static String`	`trimsuffix(String str, String suffix)` (experimental) `trimsuffix` removes the specified suffix from the end of the given string.
`static String`	`upper(String str)` (experimental) `upper` converts all cased letters in the given string to uppercase.
`static String`	`urlencode(String str)` (experimental) `urlencode` applies URL encoding to a given string.
`static String`	`uuid()` (experimental) `uuid` generates a unique identifier string.
`static String`	`uuidv5(String namespace, String name)` (experimental) `uuidv5` generates a _name-based_ UUID, as described in [RFC 4122 section 4.3](https://tools.ietf.org/html/rfc4122#section-4.3), also known as a "version 5" UUID.
`static Object`	`values(Object mapping)` (experimental) `values` takes a map and returns a list containing the values of the elements in that map.
`static Object`	`yamldecode(String src)` (experimental) `yamldecode` parses a string as a subset of YAML, and produces a representation of its value.
`static String`	`yamlencode(Object value)` (experimental) `yamlencode` encodes a given value to a string using [YAML 1.2](https://yaml.org/spec/1.2/spec.html) block syntax.
`static Object`	`zipmap(List<String> keys, Object values)` (experimental) `zipmap` constructs a map from a list of keys and a corresponding list of values.

Methods inherited from class software.amazon.jsii.JsiiObject
jsiiAsyncCall, jsiiAsyncCall, jsiiCall, jsiiCall, jsiiGet, jsiiGet, jsiiSet, jsiiStaticCall, jsiiStaticCall, jsiiStaticGet, jsiiStaticGet, jsiiStaticSet, jsiiStaticSet

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface software.amazon.jsii.JsiiSerializable
$jsii$toJson

Constructor Detail

FnGenerated

protected FnGenerated(software.amazon.jsii.JsiiObjectRef objRef)

FnGenerated

protected FnGenerated(software.amazon.jsii.JsiiObject.InitializationMode initializationMode)

FnGenerated

@Stability(value=Experimental)
public FnGenerated()

Method Detail

abs
```
@Stability(value=Experimental)
 @NotNull
public static Number abs(@NotNull
                                                                  Number num)
```
(experimental) 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.

Parameters:

num - This parameter is required.

abspath
```
@Stability(value=Experimental)
 @NotNull
public static String abspath(@NotNull
                                                                      String path)
```
(experimental) 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.

Parameters:

path - This parameter is required.

alltrue

@Stability(value=Experimental)
 @NotNull
public static IResolvable alltrue(@NotNull
                                                                           List<? extends Object> list)

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

Parameters:: list - This parameter is required.

anytrue

@Stability(value=Experimental)
 @NotNull
public static IResolvable anytrue(@NotNull
                                                                           List<? extends Object> list)

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

Parameters:: list - This parameter is required.

base64decode

@Stability(value=Experimental)
 @NotNull
public static String base64decode(@NotNull
                                                                           String str)

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

Parameters:: str - This parameter is required.

base64encode

@Stability(value=Experimental)
 @NotNull
public static String base64encode(@NotNull
                                                                           String str)

(experimental) base64encode applies Base64 encoding to a string.

Parameters:: str - This parameter is required.

base64gzip

@Stability(value=Experimental)
 @NotNull
public static String base64gzip(@NotNull
                                                                         String str)

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

Parameters:: str - This parameter is required.

base64sha256
```
@Stability(value=Experimental)
 @NotNull
public static String base64sha256(@NotNull
                                                                           String str)
```
(experimental) 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.

Parameters:

str - This parameter is required.

base64sha512
```
@Stability(value=Experimental)
 @NotNull
public static String base64sha512(@NotNull
                                                                           String str)
```
(experimental) 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.

Parameters:

str - This parameter is required.

basename

@Stability(value=Experimental)
 @NotNull
public static String basename(@NotNull
                                                                       String path)

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

Parameters:: path - This parameter is required.

can

@Stability(value=Experimental)
 @NotNull
public static IResolvable can(@NotNull
                                                                       Object expression)

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

Parameters:: expression - This parameter is required.

ceil

@Stability(value=Experimental)
 @NotNull
public static Number ceil(@NotNull
                                                                   Number num)

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

Parameters:: num - This parameter is required.

chomp

@Stability(value=Experimental)
 @NotNull
public static String chomp(@NotNull
                                                                    String str)

(experimental) chomp removes newline characters at the end of a string.

Parameters:: str - This parameter is required.

chunklist

@Stability(value=Experimental)
 @NotNull
public static List<String> chunklist(@NotNull
                                                                              List<? extends Object> list,
                                                                              @NotNull
                                                                              Number size)

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

Parameters:: list - This parameter is required.; size - This parameter is required.

cidrhost

@Stability(value=Experimental)
 @NotNull
public static String cidrhost(@NotNull
                                                                       String prefix,
                                                                       @NotNull
                                                                       Number hostnum)

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

Parameters:: prefix - This parameter is required.; hostnum - This parameter is required.

cidrnetmask

@Stability(value=Experimental)
 @NotNull
public static String cidrnetmask(@NotNull
                                                                          String prefix)

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

Parameters:: prefix - This parameter is required.

cidrsubnet

@Stability(value=Experimental)
 @NotNull
public static String cidrsubnet(@NotNull
                                                                         String prefix,
                                                                         @NotNull
                                                                         Number newbits,
                                                                         @NotNull
                                                                         Number netnum)

(experimental) cidrsubnet calculates a subnet address within given IP network address prefix.

Parameters:: prefix - This parameter is required.; newbits - This parameter is required.; netnum - This parameter is required.

cidrsubnets

@Stability(value=Experimental)
 @NotNull
public static List<String> cidrsubnets(@NotNull
                                                                                String prefix,
                                                                                @NotNull
                                                                                List<? extends Number> newbits)

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

Parameters:: prefix - This parameter is required.; newbits - This parameter is required.

coalesce

@Stability(value=Experimental)
 @NotNull
public static Object coalesce(@NotNull
                                                                       List<? extends Object> vals)

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

Parameters:: vals - This parameter is required.

coalescelist

@Stability(value=Experimental)
 @NotNull
public static Object coalescelist(@NotNull
                                                                           List<? extends Object> vals)

(experimental) coalescelist takes any number of list arguments and returns the first one that isn't empty.

Parameters:: vals - This parameter is required.

compact

@Stability(value=Experimental)
 @NotNull
public static List<String> compact(@NotNull
                                                                            List<String> list)

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

Parameters:: list - This parameter is required.

concat

@Stability(value=Experimental)
 @NotNull
public static Object concat(@NotNull
                                                                     List<? extends Object> seqs)

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

Parameters:: seqs - This parameter is required.

contains

@Stability(value=Experimental)
 @NotNull
public static Object contains(@NotNull
                                                                       Object list,
                                                                       @NotNull
                                                                       Object value)

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

Parameters:: list - This parameter is required.; value - This parameter is required.

csvdecode

@Stability(value=Experimental)
 @NotNull
public static Object csvdecode(@NotNull
                                                                        String str)

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

Parameters:: str - This parameter is required.

dirname

@Stability(value=Experimental)
 @NotNull
public static String dirname(@NotNull
                                                                      String path)

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

Parameters:: path - This parameter is required.

distinct

@Stability(value=Experimental)
 @NotNull
public static List<String> distinct(@NotNull
                                                                             List<? extends Object> list)

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

Parameters:: list - This parameter is required.

element

@Stability(value=Experimental)
 @NotNull
public static Object element(@NotNull
                                                                      Object list,
                                                                      @NotNull
                                                                      Number index)

(experimental) element retrieves a single element from a list.

Parameters:: list - This parameter is required.; index - This parameter is required.

endswith

@Stability(value=Experimental)
 @NotNull
public static IResolvable endswith(@NotNull
                                                                            String str,
                                                                            @NotNull
                                                                            String suffix)

(experimental) 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.

Parameters:: str - This parameter is required.; suffix - This parameter is required.

file

@Stability(value=Experimental)
 @NotNull
public static String file(@NotNull
                                                                   String path)

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

Parameters:: path - This parameter is required.

filebase64

@Stability(value=Experimental)
 @NotNull
public static String filebase64(@NotNull
                                                                         String path)

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

Parameters:: path - This parameter is required.

filebase64sha256

@Stability(value=Experimental)
 @NotNull
public static String filebase64sha256(@NotNull
                                                                               String path)

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

Parameters:: path - This parameter is required.

filebase64sha512

@Stability(value=Experimental)
 @NotNull
public static String filebase64sha512(@NotNull
                                                                               String path)

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

Parameters:: path - This parameter is required.

fileexists

@Stability(value=Experimental)
 @NotNull
public static IResolvable fileexists(@NotNull
                                                                              String path)

(experimental) fileexists determines whether a file exists at a given path.

Parameters:: path - This parameter is required.

filemd5

@Stability(value=Experimental)
 @NotNull
public static String filemd5(@NotNull
                                                                      String path)

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

Parameters:: path - This parameter is required.

fileset

@Stability(value=Experimental)
 @NotNull
public static List<String> fileset(@NotNull
                                                                            String path,
                                                                            @NotNull
                                                                            String pattern)

(experimental) 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.

Parameters:: path - This parameter is required.; pattern - This parameter is required.

filesha1

@Stability(value=Experimental)
 @NotNull
public static String filesha1(@NotNull
                                                                       String path)

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

Parameters:: path - This parameter is required.

filesha256

@Stability(value=Experimental)
 @NotNull
public static String filesha256(@NotNull
                                                                         String path)

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

Parameters:: path - This parameter is required.

filesha512

@Stability(value=Experimental)
 @NotNull
public static String filesha512(@NotNull
                                                                         String path)

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

Parameters:: path - This parameter is required.

flatten

@Stability(value=Experimental)
 @NotNull
public static Object flatten(@NotNull
                                                                      Object list)

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

Parameters:: list - This parameter is required.

floor

@Stability(value=Experimental)
 @NotNull
public static Number floor(@NotNull
                                                                    Number num)

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

Parameters:: num - This parameter is required.

format

@Stability(value=Experimental)
 @NotNull
public static Object format(@NotNull
                                                                     String format,
                                                                     @NotNull
                                                                     List<? extends Object> args)

(experimental) 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.

Parameters:: format - This parameter is required.; args - This parameter is required.

formatdate

@Stability(value=Experimental)
 @NotNull
public static String formatdate(@NotNull
                                                                         String format,
                                                                         @NotNull
                                                                         String time)

(experimental) formatdate converts a timestamp into a different time format.

Parameters:: format - This parameter is required.; time - This parameter is required.

formatlist

@Stability(value=Experimental)
 @NotNull
public static Object formatlist(@NotNull
                                                                         String format,
                                                                         @NotNull
                                                                         List<? extends Object> args)

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

Parameters:: format - This parameter is required.; args - This parameter is required.

indent

@Stability(value=Experimental)
 @NotNull
public static String indent(@NotNull
                                                                     Number spaces,
                                                                     @NotNull
                                                                     String str)

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

Parameters:: spaces - This parameter is required.; str - This parameter is required.

index

@Stability(value=Experimental)
 @NotNull
public static Object index(@NotNull
                                                                    Object list,
                                                                    @NotNull
                                                                    Object value)

(experimental) index finds the element index for a given value in a list.

Parameters:: list - This parameter is required.; value - This parameter is required.

jsondecode

@Stability(value=Experimental)
 @NotNull
public static Object jsondecode(@NotNull
                                                                         String str)

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

Parameters:: str - This parameter is required.

jsonencode

@Stability(value=Experimental)
 @NotNull
public static String jsonencode(@NotNull
                                                                         Object val)

(experimental) jsonencode encodes a given value to a string using JSON syntax.

Parameters:: val - This parameter is required.

keys

@Stability(value=Experimental)
 @NotNull
public static Object keys(@NotNull
                                                                   Object inputMap)

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

Parameters:: inputMap - This parameter is required.

lengthOf

@Stability(value=Experimental)
 @NotNull
public static Number lengthOf(@NotNull
                                                                       Object value)

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

Parameters:: value - This parameter is required.

log

@Stability(value=Experimental)
 @NotNull
public static Number log(@NotNull
                                                                  Number num,
                                                                  @NotNull
                                                                  Number base)

(experimental) log returns the logarithm of a given number in a given base.

Parameters:: num - This parameter is required.; base - This parameter is required.

lower

@Stability(value=Experimental)
 @NotNull
public static String lower(@NotNull
                                                                    String str)

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

Parameters:: str - This parameter is required.

matchkeys

@Stability(value=Experimental)
 @NotNull
public static List<String> matchkeys(@NotNull
                                                                              List<? extends Object> values,
                                                                              @NotNull
                                                                              List<? extends Object> keys,
                                                                              @NotNull
                                                                              List<? extends Object> searchset)

(experimental) 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.

Parameters:: values - This parameter is required.; keys - This parameter is required.; searchset - This parameter is required.

max

@Stability(value=Experimental)
 @NotNull
public static Number max(@NotNull
                                                                  List<? extends Number> numbers)

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

Parameters:: numbers - This parameter is required.

md5

@Stability(value=Experimental)
 @NotNull
public static String md5(@NotNull
                                                                  String str)

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

Parameters:: str - This parameter is required.

merge

@Stability(value=Experimental)
 @NotNull
public static Object merge(@NotNull
                                                                    List<? extends Object> maps)

(experimental) 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.

Parameters:: maps - This parameter is required.

min

@Stability(value=Experimental)
 @NotNull
public static Number min(@NotNull
                                                                  List<? extends Number> numbers)

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

Parameters:: numbers - This parameter is required.

nonsensitive

@Stability(value=Experimental)
 @NotNull
public static Object nonsensitive(@NotNull
                                                                           Object value)

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

Parameters:: value - This parameter is required.

one
```
@Stability(value=Experimental)
 @NotNull
public static Object one(@NotNull
                                                                  Object list)
```
(experimental) 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.

Parameters:

list - This parameter is required.

parseint

@Stability(value=Experimental)
 @NotNull
public static Object parseint(@NotNull
                                                                       Object number,
                                                                       @NotNull
                                                                       Number base)

(experimental) 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.

Parameters:: number - This parameter is required.; base - This parameter is required.

pathexpand

@Stability(value=Experimental)
 @NotNull
public static String pathexpand(@NotNull
                                                                         String path)

(experimental) 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.

Parameters:: path - This parameter is required.

pow

@Stability(value=Experimental)
 @NotNull
public static Number pow(@NotNull
                                                                  Number num,
                                                                  @NotNull
                                                                  Number power)

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

Parameters:: num - This parameter is required.; power - This parameter is required.

regex

@Stability(value=Experimental)
 @NotNull
public static Object regex(@NotNull
                                                                    String pattern,
                                                                    @NotNull
                                                                    String str)

(experimental) regex applies a [regular expression](https://en.wikipedia.org/wiki/Regular_expression) to a string and returns the matching substrings.

Parameters:: pattern - This parameter is required.; str - This parameter is required.

regexall

@Stability(value=Experimental)
 @NotNull
public static List<String> regexall(@NotNull
                                                                             String pattern,
                                                                             @NotNull
                                                                             String str)

(experimental) regexall applies a [regular expression](https://en.wikipedia.org/wiki/Regular_expression) to a string and returns a list of all matches.

Parameters:: pattern - This parameter is required.; str - This parameter is required.

replace

@Stability(value=Experimental)
 @NotNull
public static String replace(@NotNull
                                                                      String str,
                                                                      @NotNull
                                                                      String substr,
                                                                      @NotNull
                                                                      String replace)

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

Parameters:: str - This parameter is required.; substr - This parameter is required.; replace - This parameter is required.

reverse

@Stability(value=Experimental)
 @NotNull
public static Object reverse(@NotNull
                                                                      Object list)

(experimental) 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.

Parameters:: list - This parameter is required.

rsadecrypt

@Stability(value=Experimental)
 @NotNull
public static String rsadecrypt(@NotNull
                                                                         String ciphertext,
                                                                         @NotNull
                                                                         String privatekey)

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

Parameters:: ciphertext - This parameter is required.; privatekey - This parameter is required.

sensitive
```
@Stability(value=Experimental)
 @NotNull
public static Object sensitive(@NotNull
                                                                        Object value)
```
(experimental) 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](/language/values/variables#suppressing-values-in-cli-output).

Parameters:

value - This parameter is required.

setintersection

@Stability(value=Experimental)
 @NotNull
public static List<String> setintersection(@NotNull
                                                                                    List<? extends Object> first_set,
                                                                                    @NotNull
                                                                                    List<? extends List<? extends Object>> other_sets)

(experimental) 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](https://en.wikipedia.org/wiki/Intersection_$set_theory$) of the sets.

Parameters:: first_set - This parameter is required.; other_sets - This parameter is required.

setproduct

@Stability(value=Experimental)
 @NotNull
public static Object setproduct(@NotNull
                                                                         List<? extends Object> sets)

(experimental) The setproduct function finds all of the possible combinations of elements from all of the given sets by computing the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product).

Parameters:: sets - This parameter is required.

setsubtract

@Stability(value=Experimental)
 @NotNull
public static List<String> setsubtract(@NotNull
                                                                                List<? extends Object> a,
                                                                                @NotNull
                                                                                List<? extends Object> b)

(experimental) 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](https://en.wikipedia.org/wiki/Complement_$set_theory$#Relative_complement) of the second set.

Parameters:: a - This parameter is required.; b - This parameter is required.

setunion

@Stability(value=Experimental)
 @NotNull
public static List<String> setunion(@NotNull
                                                                             List<? extends Object> first_set,
                                                                             @NotNull
                                                                             List<? extends List<? extends Object>> other_sets)

(experimental) 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](https://en.wikipedia.org/wiki/Union_$set_theory$) of the sets.

Parameters:: first_set - This parameter is required.; other_sets - This parameter is required.

sha1

@Stability(value=Experimental)
 @NotNull
public static String sha1(@NotNull
                                                                   String str)

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

Parameters:: str - This parameter is required.

sha256

@Stability(value=Experimental)
 @NotNull
public static String sha256(@NotNull
                                                                     String str)

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

Parameters:: str - This parameter is required.

sha512

@Stability(value=Experimental)
 @NotNull
public static String sha512(@NotNull
                                                                     String str)

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

Parameters:: str - This parameter is required.

signum

@Stability(value=Experimental)
 @NotNull
public static Number signum(@NotNull
                                                                     Number num)

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

Parameters:: num - This parameter is required.

slice

@Stability(value=Experimental)
 @NotNull
public static Object slice(@NotNull
                                                                    Object list,
                                                                    @NotNull
                                                                    Number start_index,
                                                                    @NotNull
                                                                    Number end_index)

(experimental) slice extracts some consecutive elements from within a list.

Parameters:: list - This parameter is required.; start_index - This parameter is required.; end_index - This parameter is required.

sort

@Stability(value=Experimental)
 @NotNull
public static List<String> sort(@NotNull
                                                                         List<String> list)

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

Parameters:: list - This parameter is required.

split

@Stability(value=Experimental)
 @NotNull
public static List<String> split(@NotNull
                                                                          String separator,
                                                                          @NotNull
                                                                          String str)

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

Parameters:: separator - This parameter is required.; str - This parameter is required.

startswith

@Stability(value=Experimental)
 @NotNull
public static IResolvable startswith(@NotNull
                                                                              String str,
                                                                              @NotNull
                                                                              String prefix)

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

Parameters:: str - This parameter is required.; prefix - This parameter is required.

strrev
```
@Stability(value=Experimental)
 @NotNull
public static String strrev(@NotNull
                                                                     String str)
```
(experimental) strrev reverses the characters in a string. Note that the characters are treated as _Unicode characters_ (in technical terms, Unicode [grapheme cluster boundaries](https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries) are respected).

Parameters:

str - This parameter is required.

substr

@Stability(value=Experimental)
 @NotNull
public static String substr(@NotNull
                                                                     String str,
                                                                     @NotNull
                                                                     Number offset,
                                                                     @NotNull
                                                                     Number length)

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

Parameters:: str - This parameter is required.; offset - This parameter is required.; length - This parameter is required.

sum

@Stability(value=Experimental)
 @NotNull
public static Object sum(@NotNull
                                                                  Object list)

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

Parameters:: list - This parameter is required.

templatefile

@Stability(value=Experimental)
 @NotNull
public static Object templatefile(@NotNull
                                                                           String path,
                                                                           @NotNull
                                                                           Object vars)

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

Parameters:: path - This parameter is required.; vars - This parameter is required.

textdecodebase64

@Stability(value=Experimental)
 @NotNull
public static String textdecodebase64(@NotNull
                                                                               String source,
                                                                               @NotNull
                                                                               String encoding)

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

Parameters:: source - This parameter is required.; encoding - This parameter is required.

textencodebase64

@Stability(value=Experimental)
 @NotNull
public static String textencodebase64(@NotNull
                                                                               String str,
                                                                               @NotNull
                                                                               String encoding)

(experimental) 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.

Parameters:: str - This parameter is required.; encoding - This parameter is required.

timeadd

@Stability(value=Experimental)
 @NotNull
public static String timeadd(@NotNull
                                                                      String timestamp,
                                                                      @NotNull
                                                                      String duration)

(experimental) timeadd adds a duration to a timestamp, returning a new timestamp.

Parameters:: timestamp - This parameter is required.; duration - This parameter is required.

timecmp

@Stability(value=Experimental)
 @NotNull
public static Number timecmp(@NotNull
                                                                      String timestamp_a,
                                                                      @NotNull
                                                                      String timestamp_b)

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

Parameters:: timestamp_a - This parameter is required.; timestamp_b - This parameter is required.

timestamp
```
@Stability(value=Experimental)
 @NotNull
public static String timestamp()
```
(experimental) timestamp returns a UTC timestamp string in [RFC 3339](https://tools.ietf.org/html/rfc3339) format.

title

@Stability(value=Experimental)
 @NotNull
public static String title(@NotNull
                                                                    String str)

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

Parameters:: str - This parameter is required.

tobool

@Stability(value=Experimental)
 @NotNull
public static IResolvable tobool(@NotNull
                                                                          Object v)

(experimental) tobool converts its argument to a boolean value.

Parameters:: v - This parameter is required.

tolist

@Stability(value=Experimental)
 @NotNull
public static List<String> tolist(@NotNull
                                                                           Object v)

(experimental) tolist converts its argument to a list value.

Parameters:: v - This parameter is required.

tomap

@Stability(value=Experimental)
 @NotNull
public static Object tomap(@NotNull
                                                                    Object v)

(experimental) tomap converts its argument to a map value.

Parameters:: v - This parameter is required.

tonumber

@Stability(value=Experimental)
 @NotNull
public static Number tonumber(@NotNull
                                                                       Object v)

(experimental) tonumber converts its argument to a number value.

Parameters:: v - This parameter is required.

toset

@Stability(value=Experimental)
 @NotNull
public static List<String> toset(@NotNull
                                                                          Object v)

(experimental) toset converts its argument to a set value.

Parameters:: v - This parameter is required.

tostring

@Stability(value=Experimental)
 @NotNull
public static String tostring(@NotNull
                                                                       Object v)

(experimental) tostring converts its argument to a string value.

Parameters:: v - This parameter is required.

transpose

@Stability(value=Experimental)
 @NotNull
public static Object transpose(@NotNull
                                                                        Object values)

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

Parameters:: values - This parameter is required.

trim

@Stability(value=Experimental)
 @NotNull
public static String trim(@NotNull
                                                                   String str,
                                                                   @NotNull
                                                                   String cutset)

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

Parameters:: str - This parameter is required.; cutset - This parameter is required.

trimprefix

@Stability(value=Experimental)
 @NotNull
public static String trimprefix(@NotNull
                                                                         String str,
                                                                         @NotNull
                                                                         String prefix)

(experimental) 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.

Parameters:: str - This parameter is required.; prefix - This parameter is required.

trimspace

@Stability(value=Experimental)
 @NotNull
public static String trimspace(@NotNull
                                                                        String str)

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

Parameters:: str - This parameter is required.

trimsuffix

@Stability(value=Experimental)
 @NotNull
public static String trimsuffix(@NotNull
                                                                         String str,
                                                                         @NotNull
                                                                         String suffix)

(experimental) trimsuffix removes the specified suffix from the end of the given string.

Parameters:: str - This parameter is required.; suffix - This parameter is required.

doTry

@Stability(value=Experimental)
 @NotNull
public static Object doTry(@NotNull
                                                                    List<? extends Object> expressions)

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

Parameters:: expressions - This parameter is required.

upper

@Stability(value=Experimental)
 @NotNull
public static String upper(@NotNull
                                                                    String str)

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

Parameters:: str - This parameter is required.

urlencode

@Stability(value=Experimental)
 @NotNull
public static String urlencode(@NotNull
                                                                        String str)

(experimental) urlencode applies URL encoding to a given string.

Parameters:: str - This parameter is required.

uuid

@Stability(value=Experimental)
 @NotNull
public static String uuid()

(experimental) uuid generates a unique identifier string.

uuidv5

@Stability(value=Experimental)
 @NotNull
public static String uuidv5(@NotNull
                                                                     String namespace,
                                                                     @NotNull
                                                                     String name)

(experimental) uuidv5 generates a _name-based_ UUID, as described in [RFC 4122 section 4.3](https://tools.ietf.org/html/rfc4122#section-4.3), also known as a "version 5" UUID.

Parameters:: namespace - This parameter is required.; name - This parameter is required.

values

@Stability(value=Experimental)
 @NotNull
public static Object values(@NotNull
                                                                     Object mapping)

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

Parameters:: mapping - This parameter is required.

yamldecode

@Stability(value=Experimental)
 @NotNull
public static Object yamldecode(@NotNull
                                                                         String src)

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

Parameters:: src - This parameter is required.

yamlencode

@Stability(value=Experimental)
 @NotNull
public static String yamlencode(@NotNull
                                                                         Object value)

(experimental) yamlencode encodes a given value to a string using [YAML 1.2](https://yaml.org/spec/1.2/spec.html) block syntax.

Parameters:: value - This parameter is required.

zipmap

@Stability(value=Experimental)
 @NotNull
public static Object zipmap(@NotNull
                                                                     List<String> keys,
                                                                     @NotNull
                                                                     Object values)

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

Parameters:: keys - This parameter is required.; values - This parameter is required.

Class FnGenerated

Nested Class Summary

Nested classes/interfaces inherited from class software.amazon.jsii.JsiiObject

Constructor Summary

Method Summary

Methods inherited from class software.amazon.jsii.JsiiObject

Methods inherited from class java.lang.Object

Methods inherited from interface software.amazon.jsii.JsiiSerializable

Constructor Detail

FnGenerated

FnGenerated

FnGenerated

Method Detail

abs

abspath

alltrue

anytrue

base64decode

base64encode

base64gzip

base64sha256

base64sha512

basename

can

ceil

chomp

chunklist

cidrhost

cidrnetmask

cidrsubnet

cidrsubnets

coalesce

coalescelist

compact

concat

contains

csvdecode

dirname

distinct

element

endswith

file

filebase64

filebase64sha256

filebase64sha512

fileexists

filemd5

fileset

filesha1

filesha256

filesha512

flatten

floor

format

formatdate

formatlist

indent

index

jsondecode

jsonencode

keys

lengthOf

log

lower

matchkeys

max

md5

merge

min

nonsensitive

one

parseint

pathexpand

pow

regex

regexall

replace

reverse

rsadecrypt

sensitive