---
metadata:
  - name: generator
    content: Diplodoc Platform v5.50.3
alternate:
  - https://divkit.tech/docs/en/concepts/expression-dsl-functions.md
  - https://divkit.tech/docs/ru/concepts/expression-dsl-functions.md
---
> **Documentation Index:** Fetch the complete configuration index at https://divkit.tech/docs/en/llms.txt

# Functions

## abs
```kotlin
fun abs(
    Expression<Double>,  // Number value to get absolute.
): Expression<Double>
```
***

```kotlin
fun Expression<Double>.abs(): Expression<Double>
```
***

```kotlin
fun abs(
    Expression<Long>,  // Integer value to get absolute.
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.abs(): Expression<Long>
```
***

## acos
```kotlin
fun acos(
    Expression<Double>,  // Cosine value.
): Expression<Double>
```
***

```kotlin
fun Expression<Double>.acos(): Expression<Double>
```
***

## addMillis
```kotlin
fun addMillis(
    Expression<Long>,  // Datetime value, date to add milliseconds.
    Expression<Long>,  // Integer value, count of milliseconds to add.
): Expression<Long>
```
***

## argb
```kotlin
fun argb(
    Expression<Double>,  // Number value of alpha in range 0.0 to 1.0.
    Expression<Double>,  // Number value of red in range 0.0 to 1.0.
    Expression<Double>,  // Number value of green in range 0.0 to 1.0.
    Expression<Double>,  // Number value of blue in range 0.0 to 1.0.
): Expression<String>
```
***

## asin
```kotlin
fun asin(
    Expression<Double>,  // Sine value.
): Expression<Double>
```
***

```kotlin
fun Expression<Double>.asin(): Expression<Double>
```
***

## atan
```kotlin
fun atan(
    Expression<Double>,  // Tangent value.
): Expression<Double>
```
***

```kotlin
fun Expression<Double>.atan(): Expression<Double>
```
***

## atan2
```kotlin
fun atan2(
    Expression<Double>,  // Y coordinate of the point
    Expression<Double>,  // X coordinate of the point
): Expression<Double>
```
***

## ceil
```kotlin
fun ceil(
    Expression<Double>,  // Number value to round.
): Expression<Double>
```
***

```kotlin
fun Expression<Double>.ceil(): Expression<Double>
```
***

## contains
```kotlin
fun contains(
    Expression<String>,  // String value to find substring.
    Expression<String>,  // String value substring to find.
): Expression<Boolean>
```
***

## containsKey
```kotlin
fun containsKey(
    Expression<out Map<*, *>>,  // Dict.
    Expression<String>,  // Key in dictionary.
): Expression<Boolean>
```
***

## copySign
```kotlin
fun copySign(
    Expression<Double>,  // Number value to copy value from.
    Expression<Double>,  // Number value to copy sign from.
): Expression<Double>
```
***

```kotlin
fun copySign(
    Expression<Long>,  // Integer value to copy value from.
    Expression<Long>,  // Integer value to copy sign from.
): Expression<Long>
```
***

## cos
```kotlin
fun cos(
    Expression<Double>,  // Angle in radians.
): Expression<Double>
```
***

```kotlin
fun Expression<Double>.cos(): Expression<Double>
```
***

## cot
```kotlin
fun cot(
    Expression<Double>,  // Angle in radians.
): Expression<Double>
```
***

```kotlin
fun Expression<Double>.cot(): Expression<Double>
```
***

## decimalFormat
```kotlin
fun decimalFormat(
    Expression<Double>,  // Number value to format.
    Expression<String>,  // Number format, similar to ICU-like.
): Expression<String>
```
***

```kotlin
fun decimalFormat(
    Expression<Double>,  // Number value to format.
    Expression<String>,  // Number format, similar to ICU-like.
    Expression<String>,  // Locale.
): Expression<String>
```
***

```kotlin
fun decimalFormat(
    Expression<Long>,  // Integer value to format.
    Expression<String>,  // Number format, similar to ICU-like.
): Expression<String>
```
***

```kotlin
fun decimalFormat(
    Expression<Long>,  // Integer value to format.
    Expression<String>,  // Number format, similar to ICU-like.
    Expression<String>,  // Locale.
): Expression<String>
```
***

## decodeUri
```kotlin
fun decodeUri(
    Expression<String>,  // String value to decode.
): Expression<String>
```
***

```kotlin
fun Expression<String>.decodeUri(): Expression<String>
```
***

## div
```kotlin
fun div(
    Expression<Double>,  // Divisible number value.
    Expression<Double>,  // Divisor number value.
): Expression<Double>
```
***

```kotlin
fun div(
    Expression<Long>,  // Divisible integer value.
    Expression<Long>,  // Divisor integer value.
): Expression<Long>
```
***

## encodeRegex
```kotlin
fun encodeRegex(
    Expression<String>,  // A string to encode.
): Expression<String>
```
***

```kotlin
fun Expression<String>.encodeRegex(): Expression<String>
```
***

## encodeUri
```kotlin
fun encodeUri(
    Expression<String>,  // String value to translate.
): Expression<String>
```
***

```kotlin
fun Expression<String>.encodeUri(): Expression<String>
```
***

## floor
```kotlin
fun floor(
    Expression<Double>,  // Number value to round.
): Expression<Double>
```
***

```kotlin
fun Expression<Double>.floor(): Expression<Double>
```
***

## formatDateAsLocal
```kotlin
fun formatDateAsLocal(
    Expression<Long>,  // Datetime value, date to get milliseconds.
    Expression<String>,  // Date and time formats are specified by date and time pattern strings.
): Expression<String>
```
***

## formatDateAsLocalWithLocale
```kotlin
fun formatDateAsLocalWithLocale(
    Expression<Long>,  // Datetime value, date to get milliseconds.
    Expression<String>,  // Date and time formats are specified by date and time pattern strings.
    Expression<String>,  // Language for specified date and time pattern strings.
): Expression<String>
```
***

## formatDateAsUTC
```kotlin
fun formatDateAsUTC(
    Expression<Long>,  // Datetime value, date to get milliseconds.
    Expression<String>,  // Date and time formats are specified by date and time pattern strings.
): Expression<String>
```
***

## formatDateAsUTCWithLocale
```kotlin
fun formatDateAsUTCWithLocale(
    Expression<Long>,  // Datetime value, date to get milliseconds.
    Expression<String>,  // Date and time formats are specified by date and time pattern strings.
    Expression<String>,  // Language for specified date and time pattern strings.
): Expression<String>
```
***

## getArray
```kotlin
fun getArray(
    Expression<out Map<*, *>>,  // Dict.
    vararg Expression<String>,  // Path in dictionary.
): Expression<List<*>>
```
***

## getArrayBoolean
```kotlin
fun getArrayBoolean(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
): Expression<Boolean>
```
***

## getArrayColor
```kotlin
fun getArrayColor(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
): Expression<String>
```
***

## getArrayFromArray
```kotlin
fun getArrayFromArray(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
): Expression<List<*>>
```
***

## getArrayFromDict
```kotlin
fun getArrayFromDict(
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<List<*>>
```
***

## getArrayInteger
```kotlin
fun getArrayInteger(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
): Expression<Long>
```
***

## getArrayNumber
```kotlin
fun getArrayNumber(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
): Expression<Double>
```
***

## getArrayOptBoolean
```kotlin
fun getArrayOptBoolean(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
    Expression<Boolean>,  // Fallback value if value by index not exists or it's is not a boolean.
): Expression<Boolean>
```
***

## getArrayOptColor
```kotlin
fun getArrayOptColor(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
    Expression<String>,  // Fallback value if value by index not exists or it's is not a color.
): Expression<String>
```
***

## getArrayOptInteger
```kotlin
fun getArrayOptInteger(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
    Expression<Long>,  // Fallback value if property does not exist or a property value is not an integer.
): Expression<Long>
```
***

## getArrayOptNumber
```kotlin
fun getArrayOptNumber(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
    Expression<Double>,  // Fallback value if value by index not exists or it's is not a number.
): Expression<Double>
```
***

## getArrayOptString
```kotlin
fun getArrayOptString(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
    Expression<String>,  // Fallback value if value by index not exists or it's is not a string.
): Expression<String>
```
***

## getArrayOptUrl
```kotlin
fun getArrayOptUrl(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
    Expression<String>,  // Fallback value if value by index not exists or it's is not a url.
): Expression<String>
```
***

## getArrayString
```kotlin
fun getArrayString(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
): Expression<String>
```
***

## getArrayUrl
```kotlin
fun getArrayUrl(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
): Expression<String>
```
***

## getBoolean
```kotlin
fun getBoolean(
    Expression<out Map<*, *>>,  // Dict.
    vararg Expression<String>,  // Path in dictionary.
): Expression<Boolean>
```
***

## getBooleanFromArray
```kotlin
fun getBooleanFromArray(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
): Expression<Boolean>
```
***

## getBooleanFromDict
```kotlin
fun getBooleanFromDict(
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<Boolean>
```
***

## getBooleanValue
```kotlin
fun getBooleanValue(
    Expression<String>,  // Variable name.
    Expression<Boolean>,  // Fallback value.
): Expression<Boolean>
```
***

## getColor
```kotlin
fun getColor(
    Expression<out Map<*, *>>,  // Dict.
    vararg Expression<String>,  // Path in dictionary.
): Expression<String>
```
***

## getColorAlpha
```kotlin
fun getColorAlpha(
    Expression<String>,  // String value of color in hex format.
): Expression<Double>
```
***

```kotlin
fun Expression<String>.getColorAlpha(): Expression<Double>
```
***

## getColorBlue
```kotlin
fun getColorBlue(
    Expression<String>,  // String value of color in hex format.
): Expression<Double>
```
***

```kotlin
fun Expression<String>.getColorBlue(): Expression<Double>
```
***

## getColorFromArray
```kotlin
fun getColorFromArray(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
): Expression<String>
```
***

## getColorFromDict
```kotlin
fun getColorFromDict(
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<String>
```
***

## getColorGreen
```kotlin
fun getColorGreen(
    Expression<String>,  // String value of color in hex format.
): Expression<Double>
```
***

```kotlin
fun Expression<String>.getColorGreen(): Expression<Double>
```
***

## getColorRed
```kotlin
fun getColorRed(
    Expression<String>,  // String value of color in hex format.
): Expression<Double>
```
***

```kotlin
fun Expression<String>.getColorRed(): Expression<Double>
```
***

## getColorValue
```kotlin
fun getColorValue(
    Expression<String>,  // Variable name.
    Expression<String>,  // Fallback value.
): Expression<String>
```
***

## getDay
```kotlin
fun getDay(
    Expression<Long>,  // Datetime value, date to get day of month.
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.getDay(): Expression<Long>
```
***

## getDayOfWeek
```kotlin
fun getDayOfWeek(
    Expression<Long>,  // Datetime value, date to get day of week.
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.getDayOfWeek(): Expression<Long>
```
***

## getDict
```kotlin
fun getDict(
    Expression<out Map<*, *>>,  // Dict.
    vararg Expression<String>,  // Path in dictionary.
): Expression<Map<*, *>>
```
***

## getDictBoolean
```kotlin
fun getDictBoolean(
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<Boolean>
```
***

## getDictColor
```kotlin
fun getDictColor(
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<String>
```
***

## getDictFromArray
```kotlin
fun getDictFromArray(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
): Expression<Map<*, *>>
```
***

## getDictFromDict
```kotlin
fun getDictFromDict(
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<Map<*, *>>
```
***

## getDictInteger
```kotlin
fun getDictInteger(
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<Long>
```
***

## getDictKeys
```kotlin
fun getDictKeys(
    Expression<out Map<*, *>>,  // Dictionary.
): Expression<List<*>>
```
***

```kotlin
fun Expression<out Map<*, *>>.getDictKeys(): Expression<List<*>>
```
***

## getDictNumber
```kotlin
fun getDictNumber(
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<Double>
```
***

## getDictOptBoolean
```kotlin
fun getDictOptBoolean(
    Expression<Boolean>,  // Fallback value if property does not exist or a property value is not a boolean.
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<Boolean>
```
***

## getDictOptColor
```kotlin
fun getDictOptColor(
    Expression<String>,  // Fallback value if property does not exist or a property value is not a color.
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<String>
```
***

## getDictOptInteger
```kotlin
fun getDictOptInteger(
    Expression<Long>,  // Fallback value if property does not exist or a property value is not an integer.
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<Long>
```
***

## getDictOptNumber
```kotlin
fun getDictOptNumber(
    Expression<Double>,  // Fallback value if property does not exist or a property value is not a number.
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<Double>
```
***

## getDictOptString
```kotlin
fun getDictOptString(
    Expression<String>,  // Fallback value if property does not exist or a property value is not a string.
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<String>
```
***

## getDictOptUrl
```kotlin
fun getDictOptUrl(
    Expression<String>,  // Fallback value if property does not exist or a property value is not an url.
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<String>
```
***

## getDictString
```kotlin
fun getDictString(
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<String>
```
***

## getDictUrl
```kotlin
fun getDictUrl(
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<String>
```
***

## getDictValues
```kotlin
fun getDictValues(
    Expression<out Map<*, *>>,  // Dictionary.
): Expression<List<*>>
```
***

```kotlin
fun Expression<out Map<*, *>>.getDictValues(): Expression<List<*>>
```
***

## getHours
```kotlin
fun getHours(
    Expression<Long>,  // Datetime value, date to get hours.
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.getHours(): Expression<Long>
```
***

## getInteger
```kotlin
fun getInteger(
    Expression<out Map<*, *>>,  // Dict.
    vararg Expression<String>,  // Path in dictionary.
): Expression<Long>
```
***

## getIntegerFromArray
```kotlin
fun getIntegerFromArray(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
): Expression<Long>
```
***

## getIntegerFromDict
```kotlin
fun getIntegerFromDict(
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<Long>
```
***

## getIntegerValue
```kotlin
fun getIntegerValue(
    Expression<String>,  // Variable name.
    Expression<Long>,  // Fallback value.
): Expression<Long>
```
***

## getIntervalHours
```kotlin
fun getIntervalHours(
    Expression<Long>,  // Milliseconds count
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.getIntervalHours(): Expression<Long>
```
***

## getIntervalMinutes
```kotlin
fun getIntervalMinutes(
    Expression<Long>,  // Milliseconds count
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.getIntervalMinutes(): Expression<Long>
```
***

## getIntervalSeconds
```kotlin
fun getIntervalSeconds(
    Expression<Long>,  // Milliseconds count
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.getIntervalSeconds(): Expression<Long>
```
***

## getIntervalTotalDays
```kotlin
fun getIntervalTotalDays(
    Expression<Long>,  // Milliseconds count
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.getIntervalTotalDays(): Expression<Long>
```
***

## getIntervalTotalHours
```kotlin
fun getIntervalTotalHours(
    Expression<Long>,  // Milliseconds count
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.getIntervalTotalHours(): Expression<Long>
```
***

## getIntervalTotalMinutes
```kotlin
fun getIntervalTotalMinutes(
    Expression<Long>,  // Milliseconds count
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.getIntervalTotalMinutes(): Expression<Long>
```
***

## getIntervalTotalSeconds
```kotlin
fun getIntervalTotalSeconds(
    Expression<Long>,  // Milliseconds count
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.getIntervalTotalSeconds(): Expression<Long>
```
***

## getIntervalTotalWeeks
```kotlin
fun getIntervalTotalWeeks(
    Expression<Long>,  // Milliseconds count
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.getIntervalTotalWeeks(): Expression<Long>
```
***

## getKeys
```kotlin
fun getKeys(
    Expression<out Map<*, *>>,  // Dictionary.
): Expression<List<*>>
```
***

```kotlin
fun Expression<out Map<*, *>>.getKeys(): Expression<List<*>>
```
***

## getMillis
```kotlin
fun getMillis(
    Expression<Long>,  // Datetime value, date to get milliseconds.
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.getMillis(): Expression<Long>
```
***

## getMinutes
```kotlin
fun getMinutes(
    Expression<Long>,  // Datetime value, date to get minutes.
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.getMinutes(): Expression<Long>
```
***

## getMonth
```kotlin
fun getMonth(
    Expression<Long>,  // Datetime value, date to get month.
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.getMonth(): Expression<Long>
```
***

## getNumber
```kotlin
fun getNumber(
    Expression<out Map<*, *>>,  // Dict.
    vararg Expression<String>,  // Path in dictionary.
): Expression<Double>
```
***

## getNumberFromArray
```kotlin
fun getNumberFromArray(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
): Expression<Double>
```
***

## getNumberFromDict
```kotlin
fun getNumberFromDict(
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<Double>
```
***

## getNumberValue
```kotlin
fun getNumberValue(
    Expression<String>,  // Variable name.
    Expression<Double>,  // Fallback value.
): Expression<Double>
```
***

## getOptArrayFromArray
```kotlin
fun getOptArrayFromArray(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
): Expression<List<*>>
```
***

## getOptArrayFromDict
```kotlin
fun getOptArrayFromDict(
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<List<*>>
```
***

## getOptBooleanFromArray
```kotlin
fun getOptBooleanFromArray(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
    Expression<Boolean>,  // Fallback value if value by index not exists or it's is not a boolean.
): Expression<Boolean>
```
***

## getOptBooleanFromDict
```kotlin
fun getOptBooleanFromDict(
    Expression<Boolean>,  // Fallback value if property does not exist or a property value is not a boolean.
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<Boolean>
```
***

## getOptColorFromArray
```kotlin
fun getOptColorFromArray(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
    Expression<String>,  // Fallback value if value by index not exists or it's is not a color.
): Expression<String>
```
***

## getOptColorFromDict
```kotlin
fun getOptColorFromDict(
    Expression<String>,  // Fallback value if property does not exist or a property value is not a color.
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<String>
```
***

## getOptDictFromArray
```kotlin
fun getOptDictFromArray(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
): Expression<Map<*, *>>
```
***

## getOptDictFromDict
```kotlin
fun getOptDictFromDict(
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<Map<*, *>>
```
***

## getOptIntegerFromArray
```kotlin
fun getOptIntegerFromArray(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
    Expression<Long>,  // Fallback value if property does not exist or a property value is not an integer.
): Expression<Long>
```
***

## getOptIntegerFromDict
```kotlin
fun getOptIntegerFromDict(
    Expression<Long>,  // Fallback value if property does not exist or a property value is not an integer.
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<Long>
```
***

## getOptNumberFromArray
```kotlin
fun getOptNumberFromArray(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
    Expression<Double>,  // Fallback value if value by index not exists or it's is not a number.
): Expression<Double>
```
***

## getOptNumberFromDict
```kotlin
fun getOptNumberFromDict(
    Expression<Double>,  // Fallback value if property does not exist or a property value is not a number.
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<Double>
```
***

## getOptStringFromArray
```kotlin
fun getOptStringFromArray(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
    Expression<String>,  // Fallback value if value by index not exists or it's is not a string.
): Expression<String>
```
***

## getOptStringFromDict
```kotlin
fun getOptStringFromDict(
    Expression<String>,  // Fallback value if property does not exist or a property value is not a string.
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<String>
```
***

## getOptUrlFromArray
```kotlin
fun getOptUrlFromArray(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
    Expression<String>,  // Fallback value if value by index not exists or it's is not a url.
): Expression<String>
```
***

## getOptUrlFromDict
```kotlin
fun getOptUrlFromDict(
    Expression<String>,  // Fallback value if property does not exist or a property value is not an url.
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<String>
```
***

## getSeconds
```kotlin
fun getSeconds(
    Expression<Long>,  // Datetime value, date to get seconds.
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.getSeconds(): Expression<Long>
```
***

## getStoredArrayValue
```kotlin
fun getStoredArrayValue(
    Expression<String>,  // Stored value name.
): Expression<List<*>>
```
***

```kotlin
fun Expression<String>.getStoredArrayValue(): Expression<List<*>>
```
***

## getStoredBooleanValue
```kotlin
fun getStoredBooleanValue(
    Expression<String>,  // Stored value name.
    Expression<Boolean>,  // Fallback value.
): Expression<Boolean>
```
***

## getStoredColorValue
```kotlin
fun getStoredColorValue(
    Expression<String>,  // Stored value name.
    Expression<String>,  // Fallback value.
): Expression<String>
```
***

## getStoredDictValue
```kotlin
fun getStoredDictValue(
    Expression<String>,  // Stored value name.
): Expression<Map<*, *>>
```
***

```kotlin
fun Expression<String>.getStoredDictValue(): Expression<Map<*, *>>
```
***

## getStoredIntegerValue
```kotlin
fun getStoredIntegerValue(
    Expression<String>,  // Stored value name.
    Expression<Long>,  // Fallback value.
): Expression<Long>
```
***

## getStoredNumberValue
```kotlin
fun getStoredNumberValue(
    Expression<String>,  // Stored value name.
    Expression<Double>,  // Fallback value.
): Expression<Double>
```
***

## getStoredStringValue
```kotlin
fun getStoredStringValue(
    Expression<String>,  // Stored value name.
    Expression<String>,  // Fallback value.
): Expression<String>
```
***

## getStoredUrlValue
```kotlin
fun getStoredUrlValue(
    Expression<String>,  // Stored value name.
    Expression<String>,  // Fallback value.
): Expression<String>
```
***

## getString
```kotlin
fun getString(
    Expression<out Map<*, *>>,  // Dict.
    vararg Expression<String>,  // Path in dictionary.
): Expression<String>
```
***

## getStringFromArray
```kotlin
fun getStringFromArray(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
): Expression<String>
```
***

## getStringFromDict
```kotlin
fun getStringFromDict(
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<String>
```
***

## getStringValue
```kotlin
fun getStringValue(
    Expression<String>,  // Variable name.
    Expression<String>,  // Fallback value.
): Expression<String>
```
***

## getTimestamp
```kotlin
fun getTimestamp(
    Expression<Long>,  // Datetime value to convert to timestamp in milliseconds.
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.getTimestamp(): Expression<Long>
```
***

## getUrl
```kotlin
fun getUrl(
    Expression<out Map<*, *>>,  // Dict.
    vararg Expression<String>,  // Path in dictionary.
): Expression<String>
```
***

## getUrlFromArray
```kotlin
fun getUrlFromArray(
    Expression<out List<*>>,  // Array.
    Expression<Long>,  // Index at array.
): Expression<String>
```
***

## getUrlFromDict
```kotlin
fun getUrlFromDict(
    Expression<out Map<*, *>>,  // Dictionary.
    vararg Expression<String>,  // Path in dictionary.
): Expression<String>
```
***

## getUrlValue
```kotlin
fun getUrlValue(
    Expression<String>,  // Variable name.
    Expression<String>,  // Fallback value.
): Expression<String>
```
***

## getValues
```kotlin
fun getValues(
    Expression<out Map<*, *>>,  // Dictionary.
): Expression<List<*>>
```
***

```kotlin
fun Expression<out Map<*, *>>.getValues(): Expression<List<*>>
```
***

## getYear
```kotlin
fun getYear(
    Expression<Long>,  // Datetime value, date to get year.
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.getYear(): Expression<Long>
```
***

## index
```kotlin
fun index(
    Expression<String>,  // String value, original string.
    Expression<String>,  // String value, string to find.
): Expression<Long>
```
***

## isEmpty
```kotlin
fun isEmpty(
    Expression<out Map<*, *>>,  // Dict.
): Expression<Boolean>
```
***

```kotlin
fun Expression<out Map<*, *>>.isEmpty(): Expression<Boolean>
```
***

## lastIndex
```kotlin
fun lastIndex(
    Expression<String>,  // String value, original string.
    Expression<String>,  // String value, string to find.
): Expression<Long>
```
***

## len
```kotlin
fun len(
    Expression<String>,  // String value to get length of.
): Expression<Long>
```
***

```kotlin
fun Expression<String>.len(): Expression<Long>
```
***

```kotlin
fun len(
    Expression<out List<*>>,  // Array value to get length of.
): Expression<Long>
```
***

```kotlin
fun Expression<out List<*>>.len(): Expression<Long>
```
***

```kotlin
fun len(
    Expression<out Map<*, *>>,  // Dictionary.
): Expression<Long>
```
***

```kotlin
fun Expression<out Map<*, *>>.len(): Expression<Long>
```
***

## max
```kotlin
fun max(
    vararg Expression<Double>,  // Number value.
): Expression<Double>
```
***

```kotlin
fun max(
    vararg Expression<Long>,  // Integer value.
): Expression<Long>
```
***

## maxInteger
```kotlin
fun maxInteger(): Expression<Long>
```
***

## maxNumber
```kotlin
fun maxNumber(): Expression<Double>
```
***

## min
```kotlin
fun min(
    vararg Expression<Double>,  // Number value.
): Expression<Double>
```
***

```kotlin
fun min(
    vararg Expression<Long>,  // Integer value.
): Expression<Long>
```
***

## minInteger
```kotlin
fun minInteger(): Expression<Long>
```
***

## minNumber
```kotlin
fun minNumber(): Expression<Double>
```
***

## mod
```kotlin
fun mod(
    Expression<Double>,  // Divisible number value.
    Expression<Double>,  // Divisor number value.
): Expression<Double>
```
***

```kotlin
fun mod(
    Expression<Long>,  // Divisible integer value.
    Expression<Long>,  // Divisor integer value.
): Expression<Long>
```
***

## mul
```kotlin
fun mul(
    vararg Expression<Double>,  // Number value to multiply.
): Expression<Double>
```
***

```kotlin
fun mul(
    vararg Expression<Long>,  // Integer value to multiply.
): Expression<Long>
```
***

## nowLocal
```kotlin
fun nowLocal(): Expression<Long>
```
***

## padEnd
```kotlin
fun padEnd(
    Expression<Long>,  // Integer value to pad.
    Expression<Long>,  // String length
    Expression<String>,  // String character to pad with
): Expression<String>
```
***

```kotlin
fun padEnd(
    Expression<String>,  // String value to pad.
    Expression<Long>,  // String length
    Expression<String>,  // String character to pad with
): Expression<String>
```
***

## padStart
```kotlin
fun padStart(
    Expression<Long>,  // Integer value to pad.
    Expression<Long>,  // String length
    Expression<String>,  // String character to pad with
): Expression<String>
```
***

```kotlin
fun padStart(
    Expression<String>,  // String value to pad.
    Expression<Long>,  // String length
    Expression<String>,  // String character to pad with
): Expression<String>
```
***

## parseUnixTime
```kotlin
fun parseUnixTime(
    Expression<Long>,  // Time in UTC seconds from the epoch.
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.parseUnixTime(): Expression<Long>
```
***

## parseUnixTimeAsLocal
```kotlin
fun parseUnixTimeAsLocal(
    Expression<Long>,  // Time in local time zone seconds from the epoch.
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.parseUnixTimeAsLocal(): Expression<Long>
```
***

## pi
```kotlin
fun pi(): Expression<Double>
```
***

## replaceAll
```kotlin
fun replaceAll(
    Expression<String>,  // String value, original string.
    Expression<String>,  // String value, string to find.
    Expression<String>,  // String value, string to replace.
): Expression<String>
```
***

## rgb
```kotlin
fun rgb(
    Expression<Double>,  // Number value of red in range 0.0 to 1.0.
    Expression<Double>,  // Number value of green in range 0.0 to 1.0.
    Expression<Double>,  // Number value of blue in range 0.0 to 1.0.
): Expression<String>
```
***

## round
```kotlin
fun round(
    Expression<Double>,  // Number value to round.
): Expression<Double>
```
***

```kotlin
fun Expression<Double>.round(): Expression<Double>
```
***

## setColorAlpha
```kotlin
fun setColorAlpha(
    Expression<String>,  // String value of color in hex format.
    Expression<Double>,  // Number value of alpha in range 0.0 to 1.0.
): Expression<String>
```
***

## setColorBlue
```kotlin
fun setColorBlue(
    Expression<String>,  // String value of color in hex format.
    Expression<Double>,  // Number value of blue in range 0.0 to 1.0.
): Expression<String>
```
***

## setColorGreen
```kotlin
fun setColorGreen(
    Expression<String>,  // String value of color in hex format.
    Expression<Double>,  // Number value of green in range 0.0 to 1.0.
): Expression<String>
```
***

## setColorRed
```kotlin
fun setColorRed(
    Expression<String>,  // String value of color in hex format.
    Expression<Double>,  // Number value of red in range 0.0 to 1.0.
): Expression<String>
```
***

## setDay
```kotlin
fun setDay(
    Expression<Long>,  // Datetime value, date to set day of month.
    Expression<Long>,  // Integer value, day of month to set to date.
): Expression<Long>
```
***

## setHours
```kotlin
fun setHours(
    Expression<Long>,  // Datetime value, date to set hours.
    Expression<Long>,  // Integer value, hours to set to date.
): Expression<Long>
```
***

## setMillis
```kotlin
fun setMillis(
    Expression<Long>,  // Datetime value, date to set milliseconds.
    Expression<Long>,  // Integer value, milliseconds to set to date.
): Expression<Long>
```
***

## setMinutes
```kotlin
fun setMinutes(
    Expression<Long>,  // Datetime value, date to set minutes.
    Expression<Long>,  // Integer value, minutes to set to date.
): Expression<Long>
```
***

## setMonth
```kotlin
fun setMonth(
    Expression<Long>,  // Datetime value, date to set month.
    Expression<Long>,  // Integer value, month to set to date. Expected values from 1 to 12.
): Expression<Long>
```
***

## setSeconds
```kotlin
fun setSeconds(
    Expression<Long>,  // Datetime value, date to set seconds.
    Expression<Long>,  // Integer value, seconds to set to date.
): Expression<Long>
```
***

## setYear
```kotlin
fun setYear(
    Expression<Long>,  // Datetime value, date to set year.
    Expression<Long>,  // Integer value, year to set to date.
): Expression<Long>
```
***

## signum
```kotlin
fun signum(
    Expression<Double>,  // Number value to get sign value.
): Expression<Double>
```
***

```kotlin
fun Expression<Double>.signum(): Expression<Double>
```
***

```kotlin
fun signum(
    Expression<Long>,  // Integer value to get sign value.
): Expression<Long>
```
***

```kotlin
fun Expression<Long>.signum(): Expression<Long>
```
***

## sin
```kotlin
fun sin(
    Expression<Double>,  // Angle in radians.
): Expression<Double>
```
***

```kotlin
fun Expression<Double>.sin(): Expression<Double>
```
***

## sub
```kotlin
fun sub(
    vararg Expression<Double>,  // Number value to subtract.
): Expression<Double>
```
***

```kotlin
fun sub(
    vararg Expression<Long>,  // Integer value to subtract.
): Expression<Long>
```
***

## substring
```kotlin
fun substring(
    Expression<String>,  // String value to get substring from.
    Expression<Long>,  // Integer value, left index of substring.
    Expression<Long>,  // Integer value, right index of substring.
): Expression<String>
```
***

## sum
```kotlin
fun sum(
    vararg Expression<Double>,  // Number value to sum.
): Expression<Double>
```
***

```kotlin
fun sum(
    vararg Expression<Long>,  // Integer value to sum.
): Expression<Long>
```
***

## tan
```kotlin
fun tan(
    Expression<Double>,  // Angle in radians.
): Expression<Double>
```
***

```kotlin
fun Expression<Double>.tan(): Expression<Double>
```
***

## testRegex
```kotlin
fun testRegex(
    Expression<String>,  // A string to test.
    Expression<String>,  // Regex string.
): Expression<Boolean>
```
***

## toBoolean
```kotlin
fun toBoolean(
    Expression<Long>,  // Integer value to convert.
): Expression<Boolean>
```
***

```kotlin
fun Expression<Long>.toBoolean(): Expression<Boolean>
```
***

```kotlin
fun toBoolean(
    Expression<String>,  // String value to convert.
): Expression<Boolean>
```
***

```kotlin
fun Expression<String>.toBoolean(): Expression<Boolean>
```
***

## toColor
```kotlin
fun toColor(
    Expression<String>,  // String value to convert.
): Expression<String>
```
***

```kotlin
fun Expression<String>.toColor(): Expression<String>
```
***

## toDegrees
```kotlin
fun toDegrees(
    Expression<Double>,  // Number value representing radians.
): Expression<Double>
```
***

```kotlin
fun Expression<Double>.toDegrees(): Expression<Double>
```
***

## toInteger
```kotlin
fun toInteger(
    Expression<Boolean>,  // Boolean value to convert.
): Expression<Long>
```
***

```kotlin
fun Expression<Boolean>.toInteger(): Expression<Long>
```
***

```kotlin
fun toInteger(
    Expression<Double>,  // Number value to convert.
): Expression<Long>
```
***

```kotlin
fun Expression<Double>.toInteger(): Expression<Long>
```
***

```kotlin
fun toInteger(
    Expression<String>,  // String value to convert.
): Expression<Long>
```
***

```kotlin
fun Expression<String>.toInteger(): Expression<Long>
```
***

## toLowerCase
```kotlin
fun toLowerCase(
    Expression<String>,  // String value to transform.
): Expression<String>
```
***

```kotlin
fun Expression<String>.toLowerCase(): Expression<String>
```
***

## toNumber
```kotlin
fun toNumber(
    Expression<Long>,  // Integer value to convert.
): Expression<Double>
```
***

```kotlin
fun Expression<Long>.toNumber(): Expression<Double>
```
***

```kotlin
fun toNumber(
    Expression<String>,  // String value to convert.
): Expression<Double>
```
***

```kotlin
fun Expression<String>.toNumber(): Expression<Double>
```
***

## toRadians
```kotlin
fun toRadians(
    Expression<Double>,  // Number value representing degrees.
): Expression<Double>
```
***

```kotlin
fun Expression<Double>.toRadians(): Expression<Double>
```
***

## toString
```kotlin
fun toString(
    Expression<Boolean>,  // Boolean value.
): Expression<String>
```
***

```kotlin
fun toString(
    Expression<Double>,  // Number value.
): Expression<String>
```
***

```kotlin
fun toString(
    Expression<Long>,  // Integer Value.
): Expression<String>
```
***

```kotlin
fun toString(
    Expression<String>,  // Color value.
): Expression<String>
```
***

```kotlin
fun toString(
    Expression<out List<*>>,  // Array value.
): Expression<String>
```
***

```kotlin
fun toString(
    Expression<out Map<*, *>>,  // Dictionary value.
): Expression<String>
```
***

## toUpperCase
```kotlin
fun toUpperCase(
    Expression<String>,  // String value to transform.
): Expression<String>
```
***

```kotlin
fun Expression<String>.toUpperCase(): Expression<String>
```
***

## toUrl
```kotlin
fun toUrl(
    Expression<String>,  // String value to convert.
): Expression<String>
```
***

```kotlin
fun Expression<String>.toUrl(): Expression<String>
```
***

## trim
```kotlin
fun trim(
    Expression<String>,  // String value to trim.
): Expression<String>
```
***

```kotlin
fun Expression<String>.trim(): Expression<String>
```
***

## trimLeft
```kotlin
fun trimLeft(
    Expression<String>,  // String value to trim.
): Expression<String>
```
***

```kotlin
fun Expression<String>.trimLeft(): Expression<String>
```
***

## trimRight
```kotlin
fun trimRight(
    Expression<String>,  // String value to trim.
): Expression<String>
```
***

```kotlin
fun Expression<String>.trimRight(): Expression<String>
```
***