Referencia de funciones CEL
AutoTalk evalúa CEL con CEL-Go en el navegador y el servidor. Las funciones de
la plataforma usan <family>.<camelCase>. Las funciones estándar,
macros con receptor y namespaces de las extensiones CEL mantienen su sintaxis
canónica. Las funciones del tenant usan <slug>.<function> de una versión
exacta de biblioteca importada.
La generación de schema 4 usa raíces cortas: maps.get(...),
values.coalesce(...) y labels.normalizeName(...) para una biblioteca labels
importada. Las formas antiguas autotalk.* y tenant.* no están disponibles.
optional.*, cel.bind, funciones globales y sintaxis con receptor siguen
siendo nativas; la conversión nativa a texto entre comillas CEL es
text.quote(...).
| Familia | Finalidad |
|---|---|
maps, values | Rutas seguras, valores predeterminados, presencia y mapas inmutables |
lists, text | Transformaciones de listas, unión, templates y normalización de texto |
datetime | Operaciones de fecha en UTC y conversiones explícitas de unidades |
phone, br | Interpretación/visualización de teléfonos y validación de CPF brasileño |
json, bson, toon | Serialización y valores BSON |
math, number, url | Cálculos, moneda y formato de URL |
workflow | Salidas de pasos en workflows y cadenas de acciones de agentes |
form, i18n | Funciones de interfaz y traducción, solo en formularios |
El catálogo generado muestra sintaxis, tipos, contexto y pureza de cada función. CEL no admite alias globales de plataforma ni callbacks JavaScript con arrow functions.
Mapas y presencia
Rutas seguras y valores alternativos
maps.get(contact, "address.city", "Unknown")
values.coalesce(maps.get(contact, "name"), "Guest")
values.firstPresent(["", null, "Alice", "Guest"])
Una ruta ausente usa el valor predeterminado de maps.get. Un null
explícito en el valor final sigue siendo null; usa values.coalesce
para sustituirlo. Coalesce conserva cero, false y texto vacío. firstPresent
también omite texto en blanco y listas vacías. Coalesce admite hasta doce
argumentos.
Presencia
values.present(value) considera ausentes null, texto con solo espacios
y listas vacías. Cero y false están presentes.
Valores en blanco
values.blank(value) es el inverso de present.
has(contact.name)
maps.has(contact, "name")
contact.?nickname.orValue("Guest")
La macro nativa has(contact.name) comprueba presencia: un campo explícitamente
null está presente. maps.has comprueba una ruta no null. orValue
usa el valor alternativo solo cuando el opcional está ausente, no cuando está
presente con null. Una variable raíz ausente produce un error; no se crea
automáticamente con null.
Mapas inmutables
maps.defaults(record, {"status": "unknown"})
maps.merge(record, {"status": "confirmed", "note": null})
maps.pick(record, ["name", "status"])
maps.omit(record, ["internalNote"])
Defaults rellena claves ausentes/null. Merge es superficial y prevalecen los valores de la derecha, incluidos false, cero, texto vacío y null. El mapa original no cambia.
Listas y texto
Recortes de listas
lists.slice(list, start, end?) admite índices negativos y devuelve una
lista vacía para entradas que no son listas. lists.pluck(list, path)
lee una ruta de cada elemento. Las macros estándar list.filter(variable, predicate)
y list.map(variable, transform) mantienen sintaxis con receptor.
Mapeo y unión
lists.mapList(people, person,
values.coalesce(maps.get(person, "name"), "Guest"))
lists.join(["Alice", null, "Bob"], " | ")
Join devuelve "Alice | | Bob": los elementos null/vacíos mantienen sus posiciones entre separadores; false y cero se incluyen. Una lista null devuelve texto vacío; el separador predeterminado es coma. Una variable o campo ausente puede fallar al evaluar el argumento, antes de llamar a join. Las fechas nativas se muestran como texto ISO.
Templates
text.template("Hello {name}!", {"name": "Alice"})
text.template("{address.city}", contact)
Los placeholders admiten rutas con puntos; valores ausentes/null se convierten en texto vacío.
Unión condicional
text.joinPresent(" · ", "Title", null, "Author")
lists.join(parts.filter(part, values.present(part)), "\n")
joinPresent omite valores en blanco y admite hasta once valores después del
separador. Usa una lista filtrada cuando el número de partes sea dinámico.
Límites y normalización de texto
text.truncate(text, maxLength, suffix?) incluye el sufijo en el límite.
fold aplica NFKD, elimina marcas combinantes y pasa a minúsculas sin cambiar
espacios. nameKey también reduce espacios y elimina los de los extremos.
singleLine reduce espacios conservando mayúsculas y acentos.
text.replace solo realiza sustituciones literales; usa regex.replace para sustituciones por patrones.
Fechas y hora
Reloj explícito
datetime.now() devuelve el instante UTC actual y no es determinista.
Obtén ese valor en el llamador y pásalo a funciones puras del tenant.
datetime.localTimeZone() lee explícitamente la zona configurada en el
navegador o servidor que evalúa la expresión. Es contextual y no puede aparecer
en el cuerpo de una función del tenant; obtén la zona en el llamador y pásala
como parámetro. Las otras funciones compartidas de fecha son puras y usan UTC e
inglés fijo por defecto.
datetime.format(clock, "DD/MM/YYYY HH:mm", "America/Sao_Paulo")
datetime.add(clock, 1, "day", "America/Sao_Paulo")
datetime.diff(clock, previous, "day", "America/Sao_Paulo")
datetime.isBetween(clock, start, end, "day", "[]", "UTC")
Las unidades de calendario usan la zona explícita; unidades menores de un día
representan tiempo transcurrido. diff(a, b, unit?, zone?) trunca su resultado;
las diferencias de días/semanas en la zona explícita consideran los cambios de
horario de verano, mientras horas/minutos miden tiempo transcurrido. isBetween admite seis argumentos y también
una zona en la quinta posición cuando se omite la sexta. Se rechazan fechas
ausentes o de formato libre. zoned(date, time, zone, format?) crea un instante
según la hora local; el formato personalizado debe contener año/mes/día,
coincidir estrictamente y usar interpretación en inglés.
Unidades y conversiones tipadas
int(v) y las otras conversiones nativas son tipadas. Comprueba el texto antes
de convertirlo; la presencia no maneja un error de conversión.
qty.matches("^-?[0-9]+$") ? int(qty) : 0
timestamp(1705276800)
datetime.fromMillis(1705276800000)
datetime.toMillis(timestamp("2024-01-15T00:00:00Z"))
uint("42") + 1u
timestamp(int) y int(timestamp) usan segundos Unix. int(duration) usa
nanosegundos; crea duraciones con unidades explícitas, como duration("60s").
Las funciones de milisegundos hacen explícitas las unidades externas y respetan
el intervalo nativo, años 0001–9999. La adaptación Date tiene precisión de
milisegundos. Las conversiones numéricas inválidas producen un error, no un
valor alternativo utilizable.
Los getters nativos usan receptor. timestamp.getDayOfMonth() empieza en cero;
timestamp.getDate() empieza en uno. type(x) == string es una comparación válida.
CEL estándar y extensiones
CEL mantiene size, int, uint, double, bool, string, bytes, timestamp,
duration, type, dyn, has, el operador in y macros con receptor. Usa
cel.bind para un valor local de expresión, selección opcional para presencia,
sortBy/transformaciones de dos variables para colecciones y namespaces estándar
como regex, math, sets, lists y base64.
Matemática nativa y funciones con coerción
math.abs, math.ceil, math.floor, math.round y math.sqrt usan los
contratos numéricos nativos de CEL. Por ejemplo, type(math.abs(-3)) == int.
Las funciones de plataforma con coerción tienen nombres explícitos:
math.absCoerced, math.ceilCoerced, math.floorCoerced, math.roundDecimal
y math.sqrtCoerced. type(math.absCoerced(-3)) == double;
math.roundDecimal(12.345, 2) acepta un número opcional de decimales.
Elige el contrato deseado; los nombres nativos cortos no son alias de las
funciones con coerción.
lists.mapList(items, item, expression) es la macro de mapeo de la plataforma.
items.map(item, expression) sigue siendo una macro nativa con receptor y
lists.range(...) sigue siendo nativa. json.encode(...) y base64.* mantienen
sus contratos nativos. Usa text.quote(...) para producir texto entre comillas
CEL; bson.ObjectId es la constante de tipo BSON, por ejemplo
type(contact._id) == bson.ObjectId cuando la entrada es un ObjectId real.
Condiciones con cortocircuito
cel.bind(stamp, maps.get(record, "deadline"),
values.present(stamp) && datetime.isAfter(clock, stamp))
Cuando el lado izquierdo decide && o ||, el otro lado puede no ejecutarse.
La absorción de errores comunes sigue CEL; los límites de evaluación
interrumpen la evaluación, sin convertirse en resultados de negocio exitosos.
Los filtros de hook tienen su propio contexto y presupuesto.
Expresiones regulares
name.matches("(?i:alice)")
name.matches("^[\\p{L} ]+$")
regex.extract("ID:123", "ID:([0-9]+)").orValue("")
regex.extractAll("ID:123 ID:456", "ID:([0-9]+)")
Los patrones usan RE2 nativo, incluidas clases Unicode y flags locales. Lookaround y backreferences no están admitidos. Prueba fixtures representativas. Guardar agentes/workflows puede informar problemas de compilación sin impedir el guardado; una expresión inválida almacenada sigue fallando al ejecutarse. Publicar una biblioteca exige compilación y fixtures configuradas exitosas.
Límites de evaluación
CEL-Go controla el coste de ejecución. También hay límites de tiempo,
texto/lista/mapa, bytes y crecimiento de valores; llamadas anidadas del tenant comparten el
presupuesto del llamador. Una denegación por presupuesto interrumpe la
evaluación. Corrige expresión o datos en vez de ocultarla. El diagnóstico nativo
usa resource_budget_exceeded. Los límites son 8 MiB por valor y 64 MiB de bytes
producidos durante una evaluación; las llamadas anidadas comparten esos límites.
Reutiliza cálculos con cel.bind o una función pura del tenant.
Salidas de workflows y agentes
Éxito del paso
workflow.stepOk(0)
workflow.stepError(0)
Las funciones referencian un paso anterior existente en la cadena actual.
stepOk exige ejecución completada y estado HTTP 200 o ausencia de estado HTTP.
stepError devuelve un descriptor seguro de error o null.
Datos del paso
workflow.stepData(0, "title", "Unknown")
workflow.stepData(1, "choices.0.message.content", "")
workflow.stepHasContent(1, "choices")
La ruta es relativa a data cuando la acción usa ese envelope; no repitas el
prefijo data. Rutas ausentes usan el valor alternativo; un índice inexistente
produce error. stepHasContent combina éxito y contenido significativo.
Salidas en raíz y de código
Consulta las salidas declaradas de la acción. Acciones sin envelope publican
campos como count, choices o file en la raíz. La función resuelve esos campos
cuando no hay data/result.
Estas 23 acciones publican las salidas declaradas en la raíz del paso, sin
envelope data o result:
| Acción | Salidas en la raíz |
|---|---|
actions/ai/agent/send | messages |
actions/ai/llm/chat/generate | choices |
actions/agent/lifecycle/session/set_reply_delay | replyDelayMs |
actions/agent/lifecycle/session/wait_for_user | deferredUntil, seconds |
actions/ai/text/speakable | text, model |
actions/data/company/resource/count | count |
actions/mcp/connect | url, toolCount |
actions/mcp/connect/autotalk-mcp | url, toolCount |
actions/media/audio/synthesize | file, bucket, fullPath, size, contentType, format, cache, billedMeter, billedMs |
actions/media/audio/transcribe | jobId, jobStatus, enginePath, providerType, diarized |
actions/media/document/generate | file, bucket, fullPath, fileName, size, contentType, format |
actions/media/read | text, supported, truncated, reason, mediaKind, mimeType, fileName, size |
actions/media/storage/delete | deleted, existed, bucket, fullPath |
actions/media/storage/probe | durationSeconds, width, height, formatName, videoCodec, audioCodec, hasAudio, sizeBytes, contentType, cached |
actions/media/storage/signed-url | signedUrl, contentType, size, mediaKind, bucket, fullPath, name, expiresAt, file |
actions/media/storage/upload | file, signedUrl, contentType, size |
actions/messaging/contact/send | messages |
actions/messaging/conversation/response/compose | messages |
actions/media/transform | jobId, jobStatus, preset |
actions/monitors/cancel | monitorId, monitorState |
actions/monitors/create | monitorId, monitorState, expiresAtIso |
actions/network/http/download-to-storage | status, file, signedUrl, contentType, size |
actions/security/auth/jwt/generate | jwt |
Lee un campo en la raíz explícitamente con las funciones calificadas:
maps.get(workflow.step(0), "count", 0)
maps.get(workflow.step(1), "files", [])
Ejecutar código publica result: workflow.stepData(N,"count")
resuelve workflow.step(N).result.count. Los campos raíz files, logs
y executionTimeMs requieren acceso explícito.
Algunas salidas de paso mantienen valores ObjectId reales: Actualizar datos con filtro, Ejecutar Workflow en workflow.step(N).data.workflow, y Enviar mensaje / Componer respuesta en workflow.step(N).messages. ==, != comparan ids; operaciones de texto como startsWith() requieren bson.objectIdToString() primero.
Diagnósticos al guardar
Guardar agentes/workflows devuelve problemas de compilación en warnings:
CEL_COMPILE_ERROR tiene severity: "error". La comprobación limitada al
guardar omite expresiones de más de 8.192 caracteres o que superan los 10.000
caracteres de CEL por agente o workflow restantes, prompts de sistema incluidos,
y señala CEL_TOO_LARGE_TO_LINT. Una expresión omitida igual se compila cuando
se ejecuta. La prosa claramente sin comillas usa una comprobación separada y
limitada del parser, para que un prompt largo aún reciba un diagnóstico útil
de CEL/texto. Publicar una biblioteca exige compilación y fixtures exitosas.
Errores seguros
workflow.stepError devuelve detalles seguros de error o null.
Contenido significativo
workflow.stepHasContent exige éxito y contenido significativo.
Estas funciones no están disponibles en cuerpos puros de bibliotecas del tenant.
Otras funciones compartidas y de formulario
url.params("https://api.example.com/search", {"q": query})
number.formatCurrency("BRL", "pt-BR", 100.0)
math.clamp(value, 0, 100)
Formato de URL
url.params añade parámetros codificados; url.encode codifica
texto para una URL.
Límites numéricos
math.clamp(value, minimum, maximum) mantiene el número entre los límites.
Las funciones de teléfono exigen modo de origen explícito para dígitos
internacionales sin prefijo o direcciones WhatsApp. Los números nacionales
necesitan defaultCountry; los LID de WhatsApp no son números de teléfono.
br.cpfValid comprueba formato y checksum; las reglas de aceptación del
negocio pertenecen al código del tenant.
El formato de interfaz y i18n.t dependen del formulario y no son
funciones de workflow. El catálogo indica la disponibilidad de cada función.
Bibliotecas del tenant
Crea bibliotecas en Automatizaciones → Bibliotecas (Nueva biblioteca → CEL), o en el modelo Dynadata
cel_libraries mediante MCP/API. Las funciones tienen parámetros nombrados y
tipados, retorno, cuerpo CEL y fixtures JSON. Reciben solo parámetros y funciones
puras compartidas/importadas: pasa reloj, contacto y datos guardados explícitamente.
No leen estado ambiente de paso/formulario/agente ni realizan I/O.
Guarda un borrador estructurado, valida, ejecuta las fixtures y publica el
draftRevision guardado. La publicación vuelve a verificar compilación y fixtures
y crea una versión exacta inmutable. La importación raíz del llamador la fija:
{"celLibraries": [{"libraryId": "000000000000000000000001", "releaseId": "000000000000000000000002"}]}
Usa los IDs devueltos, no estos ejemplos. Una biblioteca de slug labels expone
labels.normalizeName(...). Editar o publicar no cambia llamadores
existentes; selecciona otra versión exacta deliberadamente. Las dependencias
también fijan versiones exactas.
labels.normalizeName(value) pertenece al tenant que define e importa la biblioteca labels. No es una función disponible globalmente. Consulta el editor para un borrador tipado completo y el flujo por UI/MCP/API.
Raíces de bibliotecas y datos
El slug de la biblioteca es su namespace raíz: labels.normalizeName(...).
Los slugs son fijos, tienen hasta 48 caracteres y usan una letra minúscula
seguida de letras minúsculas, dígitos o underscores. Las raíces de plataforma y
extensiones nativas, raíces retiradas (autotalk, tenant, strings),
palabras clave/funciones globales/tipos CEL y claves de seguridad están
reservadas. Usa un nombre de negocio distinto, como clinic o labels.
Los nombres válidos de parámetros/miembros, como values, math, lists,
map o all, siguen permitidos dentro de una biblioteca.
Funciones y datos pueden compartir una raíz: values.coalesce(...) llama una
función y values.name lee datos del formulario. Para hacer explícito un
receptor de datos que capturaría una función/importación cualificada, usa
dyn(lists).join(","). Conserva el valor del receptor, pero reduce la precisión
de la comprobación estática de tipos y consume el costo normal de evaluación.
Revisa los diagnósticos al cambiar importaciones. Una entrada de catálogo sola
no importa una biblioteca ni cambia un receptor como clinic.size().
bson.ObjectId identifica la constante de tipo BSON. Para leer un campo de
datos llamado ObjectId en una variable bson, usa corchetes:
bson['ObjectId']. Conserva la comprobación de tipos del campo y los errores
por campo ausente. Por ejemplo, esta expresión completa devuelve "data":
cel.bind(bson, {'ObjectId': 'data'}, bson['ObjectId'])
Catálogo generado de funciones
Generado a partir de los metadatos de Commons. Sintaxis, tipos, contextos y pureza proceden del mismo contrato utilizado por el editor y MCP.
base64
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
base64.decode(value) | base64.decode(string) -> bytes | Workflow, Agente, Formulario | pura |
base64.encode(value) | base64.encode(bytes) -> string | Workflow, Agente, Formulario | pura |
br
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
br.cpfValid(value) | br.cpfValid(dyn) -> bool | Workflow, Agente, Formulario | pura |
bson
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
bson.deserialize(bsonString, encoding?) | bson.deserialize(string, string?) -> dyn | Workflow, Agente, Formulario | pura |
bson.ejsonParse(ejsonString, relaxed?) | bson.ejsonParse(string, bool?) -> dyn | Workflow, Agente, Formulario | pura |
bson.ejsonStringify(value, relaxed?) | bson.ejsonStringify(dyn, bool?) -> string | Workflow, Agente, Formulario | pura |
bson.objectId(value?) | bson.objectId(dyn?) -> objectId | Workflow, Agente, Formulario | no determinista |
bson.objectIdIsValid(value) | bson.objectIdIsValid(dyn) -> bool | Workflow, Agente, Formulario | pura |
bson.objectIdToString(value) | bson.objectIdToString(dyn) -> string | Workflow, Agente, Formulario | pura |
bson.serialize(value, encoding?) | bson.serialize(dyn, string?) -> string | Workflow, Agente, Formulario | pura |
Biblioteca estándar CEL y extensiones
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
list.all(var, predicate) | list<any>.all(identifier, bool) -> bool | Workflow, Agente, Formulario | pura |
bool(value) | bool(string|bool) -> bool | Workflow, Agente, Formulario | pura |
bytes(value) | bytes(string|bytes) -> bytes | Workflow, Agente, Formulario | pura |
cel.bind(variable, initial, expression) | cel.bind(identifier, T, R) -> R | Workflow, Agente, Formulario | pura |
text.charAt(index) | string.charAt(int) -> string | Workflow, Agente, Formulario | pura |
text.contains(substr) | string.contains(string) -> bool | Workflow, Agente, Formulario | pura |
list.distinct() | list<T>.distinct() -> list<T> | Workflow, Agente, Formulario | pura |
double(value) | double(number|string) -> double | Workflow, Agente, Formulario | pura |
duration(value) | duration(string|duration) -> duration | Workflow, Agente, Formulario | pura |
dyn(value) | dyn(any) -> dyn | Workflow, Agente, Formulario | pura |
text.endsWith(suffix) | string.endsWith(string) -> bool | Workflow, Agente, Formulario | pura |
list.exists(var, predicate) | list<any>.exists(identifier, bool) -> bool | Workflow, Agente, Formulario | pura |
list.exists_one(var, predicate) | list<any>.exists_one(identifier, bool) -> bool | Workflow, Agente, Formulario | pura |
list.filter(var, predicate) | list<any>.filter(identifier, bool) -> list<any> | Workflow, Agente, Formulario | pura |
list.first() | list<T>.first() -> optional<T> | Workflow, Agente, Formulario | pura |
list.flatten(depth?) | list<dyn>.flatten(int?) -> list<T> | Workflow, Agente, Formulario | pura |
format.format(args) | string.format(list<any>) -> string | Workflow, Agente, Formulario | pura |
timestamp.getDate(tz?) | timestamp.getDate(string?) -> int | Workflow, Agente, Formulario | pura |
timestamp.getDayOfMonth(tz?) | timestamp.getDayOfMonth(string?) -> int | Workflow, Agente, Formulario | pura |
timestamp.getDayOfWeek(tz?) | timestamp.getDayOfWeek(string?) -> int | Workflow, Agente, Formulario | pura |
timestamp.getDayOfYear(tz?) | timestamp.getDayOfYear(string?) -> int | Workflow, Agente, Formulario | pura |
timestamp.getFullYear(tz?) | timestamp.getFullYear(string?) -> int | Workflow, Agente, Formulario | pura |
timestamp.getHours(tz?) / duration.getHours() | timestamp.getHours(string?) -> int / duration.getHours() -> int | Workflow, Agente, Formulario | pura |
timestamp.getMilliseconds(tz?) / duration.getMilliseconds() | timestamp.getMilliseconds(string?) -> int / duration.getMilliseconds() -> int | Workflow, Agente, Formulario | pura |
timestamp.getMinutes(tz?) / duration.getMinutes() | timestamp.getMinutes(string?) -> int / duration.getMinutes() -> int | Workflow, Agente, Formulario | pura |
timestamp.getMonth(tz?) | timestamp.getMonth(string?) -> int | Workflow, Agente, Formulario | pura |
timestamp.getSeconds(tz?) / duration.getSeconds() | timestamp.getSeconds(string?) -> int / duration.getSeconds() -> int | Workflow, Agente, Formulario | pura |
has(selection) | has(select expression) -> bool | Workflow, Agente, Formulario | pura |
optional.hasValue() | optional<T>.hasValue() -> bool | Workflow, Agente, Formulario | pura |
text.indexOf(substr, start?) | string.indexOf(string, int?) -> int | Workflow, Agente, Formulario | pura |
int(value) | int(number|string|timestamp|duration) -> int | Workflow, Agente, Formulario | pura |
list.join(sep?) | list<string>.join(string?) -> string | Workflow, Agente, Formulario | pura |
list.last() | list<T>.last() -> optional<T> | Workflow, Agente, Formulario | pura |
text.lastIndexOf(substr, start?) | string.lastIndexOf(string, int?) -> int | Workflow, Agente, Formulario | pura |
text.lowerAscii() | string.lowerAscii() -> string | Workflow, Agente, Formulario | pura |
list.map(var, expr) | list<any>.map(identifier, any) -> list<any> | Workflow, Agente, Formulario | pura |
text.matches(pattern) | string.matches(string) -> bool | Workflow, Agente, Formulario | pura |
optional.optFlatMap(variable, expression) | optional<T>.optFlatMap(identifier, optional<R>) -> optional<R> | Workflow, Agente, Formulario | pura |
optional.optMap(variable, expression) | optional<T>.optMap(identifier, R) -> optional<R> | Workflow, Agente, Formulario | pura |
optional.or(fallback) | optional<T>.or(optional<T>) -> optional<T> | Workflow, Agente, Formulario | pura |
optional.orValue(fallback) | optional<T>.orValue(T) -> T | Workflow, Agente, Formulario | pura |
text.replace(substr, repl, count?) | string.replace(string, string, int?) -> string | Workflow, Agente, Formulario | pura |
value.reverse() | list<T>|string.reverse() -> list<T>|string | Workflow, Agente, Formulario | pura |
size(value) | size(list|map|string|bytes) -> int | Workflow, Agente, Formulario | pura |
list.slice(start, end) | list<T>.slice(int, int) -> list<T> | Workflow, Agente, Formulario | pura |
list.sort() | list<T>.sort() -> list<T> | Workflow, Agente, Formulario | pura |
list.sortBy(variable, key) | list<T>.sortBy(identifier, comparable expression) -> list<T> | Workflow, Agente, Formulario | pura |
text.split(sep, limit?) | string.split(string, int?) -> list<string> | Workflow, Agente, Formulario | pura |
text.startsWith(prefix) | string.startsWith(string) -> bool | Workflow, Agente, Formulario | pura |
string(value) | string(bool|int|uint|double|string|bytes|timestamp|duration|ObjectId) -> string | Workflow, Agente, Formulario | pura |
text.substring(start, end?) | string.substring(int, int?) -> string | Workflow, Agente, Formulario | pura |
timestamp(value) | timestamp(string|int|timestamp) -> timestamp | Workflow, Agente, Formulario | pura |
collection.transformList(keyOrIndex, value, predicateOrTransform, transform?) | list<T>|map<K,T>.transformList(identifier, identifier, bool|R, R?) -> list<R> | Workflow, Agente, Formulario | pura |
collection.transformMap(keyOrIndex, value, predicateOrTransform, transform?) | list<T>|map<K,T>.transformMap(identifier, identifier, bool|R, R?) -> map<K,R> | Workflow, Agente, Formulario | pura |
collection.transformMapEntry(keyOrIndex, value, predicateOrTransform, transform?) | list<T>|map<K,T>.transformMapEntry(identifier, identifier, bool|map<K,R>, map<K,R>?) -> map<K,R> | Workflow, Agente, Formulario | pura |
text.trim() | string.trim() -> string | Workflow, Agente, Formulario | pura |
type(value) | type(any) -> type | Workflow, Agente, Formulario | pura |
uint(value) | uint(number|string) -> uint | Workflow, Agente, Formulario | pura |
text.upperAscii() | string.upperAscii() -> string | Workflow, Agente, Formulario | pura |
optional.value() | optional<T>.value() -> T | Workflow, Agente, Formulario | pura |
datetime
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
datetime.add(isoOrMs, amount, unit, tz?) | datetime.add(string|int|double|timestamp, int|double, string, string?) -> string | Workflow, Agente, Formulario | pura |
datetime.diff(a, b, unit?, tz?) | datetime.diff(string|int|double|timestamp, string|int|double|timestamp, string?, string?) -> double | Workflow, Agente, Formulario | pura |
datetime.format(isoOrMs, fmt, tz?, locale?) | datetime.format(string|int|double|timestamp, string, string?, string?) -> string | Workflow, Agente, Formulario | pura |
datetime.fromMillis(milliseconds) | datetime.fromMillis(int|double) -> timestamp | Workflow, Agente, Formulario | pura |
datetime.isAfter(a, b, unit?, tz?) | datetime.isAfter(string|int|double|timestamp, string|int|double|timestamp, string?, string?) -> bool | Workflow, Agente, Formulario | pura |
datetime.isBefore(a, b, unit?, tz?) | datetime.isBefore(string|int|double|timestamp, string|int|double|timestamp, string?, string?) -> bool | Workflow, Agente, Formulario | pura |
datetime.isBetween(value, start, end, unit?, inclusivity?, tz?) | datetime.isBetween(string|int|double|timestamp, string|int|double|timestamp, string|int|double|timestamp, string?, string?, string?) -> bool | Workflow, Agente, Formulario | pura |
datetime.isSameDate(a, b, unit?, tz?) | datetime.isSameDate(string|int|double|timestamp, string|int|double|timestamp, string?, string?) -> bool | Workflow, Agente, Formulario | pura |
datetime.isSameOrAfter(a, b, unit?, tz?) | datetime.isSameOrAfter(string|int|double|timestamp, string|int|double|timestamp, string?, string?) -> bool | Workflow, Agente, Formulario | pura |
datetime.isSameOrBefore(a, b, unit?, tz?) | datetime.isSameOrBefore(string|int|double|timestamp, string|int|double|timestamp, string?, string?) -> bool | Workflow, Agente, Formulario | pura |
datetime.localTimeZone() | datetime.localTimeZone() -> string | Workflow, Agente, Formulario | contextual |
datetime.now(tz?) | datetime.now(string?) -> string | Workflow, Agente, Formulario | no determinista |
datetime.toMillis(timestamp) | datetime.toMillis(timestamp) -> double | Workflow, Agente, Formulario | pura |
datetime.zoned(dateStr, timeStr, tz, format?) | datetime.zoned(string, string, string, string?) -> string | Workflow, Agente, Formulario | pura |
form
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
form.argsOf(node) | form.argsOf(map<string,dyn>|null) -> dyn | Formulario | pura |
form.compact(value) | form.compact(dyn) -> string | Formulario | contextual |
form.concat(...parts) | form.concat(...dyn) -> string | Formulario | pura |
form.evalActionPreview(action) | form.evalActionPreview(map<string,dyn>) -> string|null | Formulario | contextual |
form.formatDate(value, format?) | form.formatDate(dyn, string?) -> string | Formulario | contextual |
form.formatPhone(value) | form.formatPhone(dyn) -> string | Formulario | pura |
form.getField(type) | form.getField(string) -> map<string,dyn>|null | Formulario | contextual |
form.innerEval(expr) | form.innerEval(string) -> dyn | Formulario | contextual |
form.isChatTabActive(conversationId) | form.isChatTabActive(dyn) -> bool | Formulario | contextual |
form.isChatTabOpen(conversationId) | form.isChatTabOpen(dyn) -> bool | Formulario | contextual |
form.isTabOpen(tabId) | form.isTabOpen(dyn) -> bool | Formulario | contextual |
form.len(value) | form.len(dyn) -> double | Formulario | pura |
form.log(...args) | form.log(...dyn) -> null | Formulario | con efectos |
form.money(value, currency?, locale?) | form.money(dyn, string?, string?) -> string | Formulario | pura |
form.navigate(to) | form.navigate(dyn) -> null | Formulario | con efectos |
form.number(value) | form.number(dyn) -> string | Formulario | contextual |
form.objectKeys(value) | form.objectKeys(map<string,dyn>) -> list<string> | Formulario | pura |
form.pluralize(value, one, many) | form.pluralize(dyn, string, string) -> string | Formulario | pura |
form.randomApiTokenAlias() | form.randomApiTokenAlias() -> string | Formulario | no determinista |
form.scope(overrides, expr) | form.scope(map<string,dyn>, string) -> dyn | Formulario | contextual |
form.shortId(id) | form.shortId(dyn) -> string | Formulario | pura |
form.timeAgo(value) | form.timeAgo(dyn) -> string | Formulario | no determinista |
form.toast(msg) | form.toast(dyn) -> dyn | Formulario | con efectos |
form.ucFirst(value) | form.ucFirst(dyn) -> string | Formulario | pura |
i18n
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
i18n.t(key) | i18n.t(string) -> string | Formulario | contextual |
json
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
json.encode(value) | json.encode(dyn) -> string | Workflow, Agente, Formulario | pura |
json.parse(jsonString) | json.parse(string) -> dyn | Workflow, Agente, Formulario | pura |
json.stringify(value, space?) | json.stringify(dyn, int|double?) -> string | Workflow, Agente, Formulario | pura |
lists
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
lists.join(list, separator?) | lists.join(list<dyn>|null, string?) -> string | Workflow, Agente, Formulario | pura |
lists.mapList(list, variable, transform) | lists.mapList(list<dyn>, identifier, expression) -> list<dyn> | Workflow, Agente, Formulario | pura |
lists.pluck(arr, path) | lists.pluck(list<dyn>|null, string) -> list<dyn>|null | Workflow, Agente, Formulario | pura |
lists.range(end) | lists.range(int) -> list<int> | Workflow, Agente, Formulario | pura |
lists.slice(arr, start, end?) | lists.slice(dyn, int|double, int|double|null?) -> list<dyn> | Workflow, Agente, Formulario | pura |
maps
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
maps.defaults(obj, fallbacks) | maps.defaults(map<string,dyn>|null, map<string,dyn>) -> map<string,dyn> | Workflow, Agente, Formulario | pura |
maps.get(obj, prop, defaultValue?) | maps.get(dyn, string, dyn?) -> dyn | Workflow, Agente, Formulario | pura |
maps.has(obj, prop?) | maps.has(dyn, string?) -> bool | Workflow, Agente, Formulario | pura |
maps.merge(...maps) | maps.merge(...map<string,dyn>|null) -> map<string,dyn> | Workflow, Agente, Formulario | pura |
maps.omit(map, keys) | maps.omit(map<string,dyn>|null, list<string>) -> map<string,dyn> | Workflow, Agente, Formulario | pura |
maps.pick(map, keys) | maps.pick(map<string,dyn>|null, list<string>) -> map<string,dyn> | Workflow, Agente, Formulario | pura |
maps.set(map, key, value) | maps.set(map<string,dyn>|null, string, dyn) -> map<string,dyn> | Workflow, Agente, Formulario | pura |
math
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
math.abs(value) | math.abs(int|uint|double) -> int|uint|double | Workflow, Agente, Formulario | pura |
math.absCoerced(value) | math.absCoerced(int|double) -> double | Workflow, Agente, Formulario | pura |
math.add(a, b) | math.add(int|double, int|double) -> double | Workflow, Agente, Formulario | pura |
math.bitAnd(first, second) | math.bitAnd(int|uint, int|uint) -> int|uint | Workflow, Agente, Formulario | pura |
math.bitNot(value) | math.bitNot(int|uint) -> int|uint | Workflow, Agente, Formulario | pura |
math.bitOr(first, second) | math.bitOr(int|uint, int|uint) -> int|uint | Workflow, Agente, Formulario | pura |
math.bitShiftLeft(first, second) | math.bitShiftLeft(int|uint, int) -> int|uint | Workflow, Agente, Formulario | pura |
math.bitShiftRight(first, second) | math.bitShiftRight(int|uint, int) -> int|uint | Workflow, Agente, Formulario | pura |
math.bitXor(first, second) | math.bitXor(int|uint, int|uint) -> int|uint | Workflow, Agente, Formulario | pura |
math.ceil(value) | math.ceil(double) -> double | Workflow, Agente, Formulario | pura |
math.ceilCoerced(value) | math.ceilCoerced(int|double) -> double | Workflow, Agente, Formulario | pura |
math.clamp(value, min, max) | math.clamp(int|double, int|double, int|double) -> double | Workflow, Agente, Formulario | pura |
math.cos(value) | math.cos(int|double) -> double | Workflow, Agente, Formulario | pura |
math.divide(a, b) | math.divide(int|double, int|double) -> double | Workflow, Agente, Formulario | pura |
math.dot(a, b) | math.dot(list<number>, list<number>) -> double | Workflow, Agente, Formulario | pura |
math.evaluate(expr) | math.evaluate(string) -> double | Workflow, Agente, Formulario | pura |
math.exp(value) | math.exp(int|double) -> double | Workflow, Agente, Formulario | pura |
math.floor(value) | math.floor(double) -> double | Workflow, Agente, Formulario | pura |
math.floorCoerced(value) | math.floorCoerced(int|double) -> double | Workflow, Agente, Formulario | pura |
math.greatest(...values) | math.greatest(...int|uint|double|list<number>) -> int|uint|double | Workflow, Agente, Formulario | pura |
math.isFinite(value) | math.isFinite(double) -> bool | Workflow, Agente, Formulario | pura |
math.isInf(value) | math.isInf(double) -> bool | Workflow, Agente, Formulario | pura |
math.isNaN(value) | math.isNaN(double) -> bool | Workflow, Agente, Formulario | pura |
math.least(...values) | math.least(...int|uint|double|list<number>) -> int|uint|double | Workflow, Agente, Formulario | pura |
math.log(value, base?) | math.log(int|double, int|double?) -> double | Workflow, Agente, Formulario | pura |
math.max(arr) | math.max(list<number>) -> double | Workflow, Agente, Formulario | pura |
math.mean(arr) | math.mean(list<number>) -> double | Workflow, Agente, Formulario | pura |
math.median(arr) | math.median(list<number>) -> double | Workflow, Agente, Formulario | pura |
math.min(arr) | math.min(list<number>) -> double | Workflow, Agente, Formulario | pura |
math.multiply(a, b) | math.multiply(int|double, int|double) -> double | Workflow, Agente, Formulario | pura |
math.norm(arr) | math.norm(list<number>) -> double | Workflow, Agente, Formulario | pura |
math.pow(base, exponent) | math.pow(int|double, int|double) -> double | Workflow, Agente, Formulario | pura |
math.round(value) | math.round(double) -> double | Workflow, Agente, Formulario | pura |
math.roundDecimal(value, decimals?) | math.roundDecimal(int|double, int|double?) -> double | Workflow, Agente, Formulario | pura |
math.sign(value) | math.sign(int|uint|double) -> int|uint|double | Workflow, Agente, Formulario | pura |
math.sin(value) | math.sin(int|double) -> double | Workflow, Agente, Formulario | pura |
math.sqrt(value) | math.sqrt(int|uint|double) -> double | Workflow, Agente, Formulario | pura |
math.sqrtCoerced(value) | math.sqrtCoerced(int|double) -> double | Workflow, Agente, Formulario | pura |
math.std(arr) | math.std(list<number>) -> double | Workflow, Agente, Formulario | pura |
math.subtract(a, b) | math.subtract(int|double, int|double) -> double | Workflow, Agente, Formulario | pura |
math.tan(value) | math.tan(int|double) -> double | Workflow, Agente, Formulario | pura |
math.trunc(value) | math.trunc(double) -> double | Workflow, Agente, Formulario | pura |
math.variance(arr) | math.variance(list<number>) -> double | Workflow, Agente, Formulario | pura |
number
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
number.formatCurrency(currency, locale, amount) | number.formatCurrency(string, string, int|double) -> string | Workflow, Agente, Formulario | pura |
optional
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
optional.none() | optional.none() -> optional<dyn> | Workflow, Agente, Formulario | pura |
optional.of(value) | optional.of(T) -> optional<T> | Workflow, Agente, Formulario | pura |
optional.ofNonZeroValue(value) | optional.ofNonZeroValue(T) -> optional<T> | Workflow, Agente, Formulario | pura |
optional.unwrap(values) | optional.unwrap(list<optional<T>>) -> list<T> | Workflow, Agente, Formulario | pura |
phone
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
phone.display(value, options?) | phone.display(string|null, map<string,dyn>|null?) -> string | Workflow, Agente, Formulario | pura |
phone.isValid(value, options?) | phone.isValid(string|null, map<string,dyn>|null?) -> bool | Workflow, Agente, Formulario | pura |
phone.parse(value, options?) | phone.parse(string|null, map<string,dyn>|null?) -> map<string,dyn> | Workflow, Agente, Formulario | pura |
regex
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
regex.extract(text, pattern) | regex.extract(string, string) -> optional<string> | Workflow, Agente, Formulario | pura |
regex.extractAll(text, pattern) | regex.extractAll(string, string) -> list<string> | Workflow, Agente, Formulario | pura |
regex.replace(text, pattern, replacement, count?) | regex.replace(string, string, string, int?) -> string | Workflow, Agente, Formulario | pura |
sets
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
sets.contains(superset, subset) | sets.contains(list<T>, list<T>) -> bool | Workflow, Agente, Formulario | pura |
sets.equivalent(first, second) | sets.equivalent(list<T>, list<T>) -> bool | Workflow, Agente, Formulario | pura |
sets.intersects(first, second) | sets.intersects(list<T>, list<T>) -> bool | Workflow, Agente, Formulario | pura |
text
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
text.fold(value) | text.fold(string|null) -> string | Workflow, Agente, Formulario | pura |
text.joinPresent(separator, ...values) | text.joinPresent(string, ...dyn) -> string | Workflow, Agente, Formulario | pura |
text.nameKey(value) | text.nameKey(string|null) -> string | Workflow, Agente, Formulario | pura |
text.quote(text) | text.quote(string) -> string | Workflow, Agente, Formulario | pura |
text.singleLine(value) | text.singleLine(string|null) -> string | Workflow, Agente, Formulario | pura |
text.template(template, vars) | text.template(string, map<string,dyn>|null) -> string | Workflow, Agente, Formulario | pura |
text.truncate(str, maxLen, suffix?) | text.truncate(dyn, int|double, string?) -> string | Workflow, Agente, Formulario | pura |
toon
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
toon.decode(toonString) | toon.decode(string) -> dyn | Workflow, Agente, Formulario | pura |
toon.encode(value) | toon.encode(dyn) -> string | Workflow, Agente, Formulario | pura |
url
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
url.encode(str) | url.encode(string) -> string | Workflow, Agente, Formulario | pura |
url.params(base, params) | url.params(string, map<string,dyn>) -> string | Workflow, Agente, Formulario | pura |
values
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
values.blank(val) | values.blank(dyn) -> bool | Workflow, Agente, Formulario | pura |
values.coalesce(...args) | values.coalesce(...dyn) -> dyn | Workflow, Agente, Formulario | pura |
values.firstPresent(values) | values.firstPresent(list<dyn>|null) -> dyn | Workflow, Agente, Formulario | pura |
values.present(val) | values.present(dyn) -> bool | Workflow, Agente, Formulario | pura |
workflow
| Llamada | Firma tipada | Contexto | Pureza |
|---|---|---|---|
workflow.getContext() | workflow.getContext() -> map<string,dyn> | Workflow, Agente | contextual |
workflow.getRoot() | workflow.getRoot() -> map<string,dyn> | Workflow, Agente | contextual |
workflow.getTool() | workflow.getTool() -> map<string,dyn> | Workflow, Agente | contextual |
workflow.step(index?) | workflow.step(int|double|null?) -> map<string,dyn> | Workflow, Agente | contextual |
workflow.stepData(index, path?, default?) | workflow.stepData(int|double, string|null?, dyn?) -> dyn | Workflow, Agente | contextual |
workflow.stepError(index) | workflow.stepError(int|double) -> map<string,dyn>|null | Workflow, Agente | contextual |
workflow.stepHasContent(index, path?) | workflow.stepHasContent(int|double, string|null?) -> bool | Workflow, Agente | contextual |
workflow.stepOk(index) | workflow.stepOk(int|double) -> bool | Workflow, Agente | contextual |