## `abs`

```hcl
abs(num) number
```

return the absolute value of the given number

## `abspath`

```hcl
abspath(path) string
```

convert the path into an absolute path

## `base64decode`

```hcl
base64decode(str) string
```

decode the given string in base64 encoding back to binary

## `base64encode`

```hcl
base64encode(str) string
```

encode the given string to base64 encoding

## `base64gzip`

```hcl
base64gzip(str) string
```

gzip the given string and encode the compressed body as base64

## `basename`

```hcl
basename(path) string
```

return the last component of the string interpreted as a filesystem path

## `ceil`

```hcl
ceil(num) number
```

round the given number to the next integer

## `chomp`

```hcl
chomp(str) string
```

remove white space from the start and end of the given string

## `chunklist`

```hcl
chunklist(list, size) list of list of dynamic
```

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

## `coalescelist`

```hcl
coalescelist(vals) dynamic
```

take any number of list arguments and returns the first one that isn't empty

## `compact`

```hcl
compact(list) list of string
```

remove empty strings from a list

## `concat`

```hcl
concat(seqs) dynamic
```

combine 2 or more lists into a single list

## `contains`

```hcl
contains(list, value) dynamic
```

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

## `csvdecode`

```hcl
csvdecode(str) dynamic
```

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

## `dirname`

```hcl
dirname(path) string
```

return all except the last component of the string interpreted as a filesystem path

## `distinct`

```hcl
distinct(list) list of dynamic
```

removes any duplicate elements from a list

## `element`

```hcl
element(list, index) dynamic
```

return the value at given numeric index in the list

## `file`

```hcl
file(path) string
```

return the data in the file located at the given path. This can be paired with the `${path.app}` variable to get a path relative to your app folder, i.e. `filebase64("${path.app}/file.txt")`

## `filebase64`

```hcl
filebase64(path) string
```

return the data in the file located at the given path after base64 decoding it. This can be paired with the `${path.app}` variable to get a path relative to your app folder, i.e. `filebase64("${path.app}/file.txt")`

## `fileexists`

```hcl
fileexists(path) bool
```

indicate if a file exists at the given path. This can be paired with the `${path.app}` variable to get a path relative to your app folder, i.e. `filebase64("${path.app}/file.txt")`

## `fileset`

```hcl
fileset(path, pattern) set of string
```

gather a list of paths that match the given pattern under the given directory

## `flatten`

```hcl
flatten(list) dynamic
```

remove any embedded lists by moving the contents to the outer list

## `floor`

```hcl
floor(num) number
```

round the given number to the lowest next integer

## `format`

```hcl
format(format, args) dynamic
```

format a string according to the given parameters

## `formatdate`

```hcl
formatdate(format, time) string
```

format the current date as a string according to the given parameters

## `formatlist`

```hcl
formatlist(format, args) dynamic
```

apply the format() function across all values in the given lists

## `gitrefhash`

```hcl
gitrefhash() string
```

return the full git hash for the HEAD ref

## `gitrefpretty`

```hcl
gitrefpretty() string
```

return a humanized version of the git hash, taking into account tags and changes

## `gitreftag`

```hcl
gitreftag() string
```

return the tag name that points to the HEAD ref

## `gitremoteurl`

```hcl
gitremoteurl(name) string
```

return the remote url of the git repo

## `indent`

```hcl
indent(spaces, str) string
```

indent each line of the given string

## `join`

```hcl
join(separator, lists) string
```

create a string by joining each list element with the given separator

## `jsondecode`

```hcl
jsondecode(str) dynamic
```

decode the given string as json into HCL values

## `jsonencode`

```hcl
jsonencode(val) string
```

encode the given HCL value as json

## `jsonnetdir`

```hcl
jsonnetdir(dir, options) dynamic
```

convert a directory of Jsonnet files into JSON, returning a path

## `jsonnetfile`

```hcl
jsonnetfile(path, options) dynamic
```

convert a Jsonnet file into JSON, returning a file path

## `keys`

```hcl
keys(inputMap) dynamic
```

return a list of the keys present in the given map

## `log`

```hcl
log(num, base) number
```

returns the logarithm of a given number in a given base

## `lower`

```hcl
lower(str) string
```

convert the given string to lower case according the unicode rules

## `max`

```hcl
max(numbers) number
```

return the largest number present in the list

## `merge`

```hcl
merge(maps) dynamic
```

combine a set of map or objects together as one map

## `min`

```hcl
min(numbers) number
```

return the smallest number present in the list

## `parseint`

```hcl
parseint(number, base) dynamic
```

parse the string as a number of the given base and return an HCL number value

## `pathexpand`

```hcl
pathexpand(path) string
```

expand any tildes in the given path

## `pow`

```hcl
pow(num, power) number
```

raise the given number to the given power

## `range`

```hcl
range(params) list of number
```

generate a list of numbers

## `regex`

```hcl
regex(pattern, string) dynamic
```

match the given string against the given regular expression pattern, returning captures if defined

## `regexall`

```hcl
regexall(pattern, string) list of dynamic
```

same as regex but look for all matches of the given pattern rather than just the first

## `replace`

```hcl
replace(str, substr, replace) string
```

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

## `reverse`

```hcl
reverse(list) dynamic
```

reverse the order of the elements in the list

## `selectorlookup`

```hcl
selectorlookup(map, selectormap, default) dynamic
```

applies a map of selectors to a map of labels. The value for the first matching selector is returned. If none match, the default is returned.

## `selectormatch`

```hcl
selectormatch(map, selector) bool
```

applies a selector to a map and returns true if the selector matches

## `setintersection`

```hcl
setintersection(first_set, other_sets) set of dynamic
```

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`

```hcl
setproduct(sets) dynamic
```

finds all of the possible combinations of elements from all of the given sets by computing the Cartesian product

## `setsubtract`

```hcl
setsubtract(a, b) set of dynamic
```

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 first set in the second set

## `setunion`

```hcl
setunion(first_set, other_sets) set of dynamic
```

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

## `signum`

```hcl
signum(num) number
```

indicates the sign of the given number by -1, 0, or 1

## `slice`

```hcl
slice(list, start_index, end_index) dynamic
```

return a subset of the given list

## `sort`

```hcl
sort(list) list of string
```

reorder the given elements according to their sorting order

## `split`

```hcl
split(separator, str) list of string
```

break the given string up into substrings

## `strrev`

```hcl
strrev(str) string
```

reverse the characters in the given string

## `substr`

```hcl
substr(str, offset, length) string
```

return a subset of the given string

## `timeadd`

```hcl
timeadd(timestamp, duration) string
```

add a quantum of time to the given timestamp to calculate a new timestamp

## `timestamp`

```hcl
timestamp() string
```

## `title`

```hcl
title(str) string
```

upper case each character on each word in the given string

## `trim`

```hcl
trim(str, cutset) string
```

remove characters present in the cutset from the given string from the head and tail of the string

## `trimprefix`

```hcl
trimprefix(str, prefix) string
```

remove the given prefix from the string

## `trimspace`

```hcl
trimspace(str) string
```

remove space charaters from the head and tail of the string

## `trimsuffix`

```hcl
trimsuffix(str, suffix) string
```

remove the given suffix from the string

## `upper`

```hcl
upper(str) string
```

convert each character to upper case according to the unicode rules

## `urlencode`

```hcl
urlencode(str) string
```

encode the given string according to the url encoding rules

## `values`

```hcl
values(values) dynamic
```

return the list of values in the given map or object

## `yamldecode`

```hcl
yamldecode(src) dynamic
```

decode the string as YAML and return the equiv HCL values

## `yamlencode`

```hcl
yamlencode(value) string
```

convert the given HCL values to YAML

## `zipmap`

```hcl
zipmap(keys, values) dynamic
```

construct a map from a list of keys and a corresponding list of values
