Referência de funções CEL
O AutoTalk avalia CEL com CEL-Go no navegador e no servidor. As funções da
plataforma usam <family>.<camelCase>. Funções padrão, macros com
receptor e namespaces das extensões CEL mantêm a sintaxe canônica. Funções do
tenant usam <slug>.<function> de uma versão exata de biblioteca importada.
A geração de schema 4 usa raízes curtas: maps.get(...),
values.coalesce(...) e labels.normalizeName(...) para uma biblioteca labels
importada. As grafias antigas autotalk.* e tenant.* não estão disponíveis.
optional.*, cel.bind, funções globais e sintaxe com receptor continuam
nativas; a conversão nativa para texto entre aspas CEL é text.quote(...).
| Família | Finalidade |
|---|---|
maps, values | Caminhos seguros, valores padrão, presença e mapas imutáveis |
lists, text | Transformações de listas, junção, templates e normalização de texto |
datetime | Operações de data em UTC e conversões explícitas de unidades |
phone, br | Leitura/exibição de telefone e validação de CPF |
json, bson, toon | Serialização e valores BSON |
math, number, url | Cálculos, moeda e formatação de URL |
workflow | Saídas de etapas em workflows e cadeias de ações de agentes |
form, i18n | Funções de interface e tradução, somente em formulários |
O catálogo gerado mostra sintaxe, tipos, contexto e pureza para cada função. CEL não aceita aliases globais da plataforma nem callbacks JavaScript com arrow functions.
Mapas e presença
Caminhos seguros e valores alternativos
maps.get(contact, "address.city", "Unknown")
values.coalesce(maps.get(contact, "name"), "Guest")
values.firstPresent(["", null, "Alice", "Guest"])
Um caminho ausente usa o padrão de maps.get. Um null explícito no
valor final permanece null; use values.coalesce para substituí-lo.
Coalesce preserva zero, false e texto vazio. firstPresent também ignora texto
em branco e listas vazias. Coalesce aceita até doze argumentos.
Presença
values.present(value) considera ausentes null, texto só com espaços e
listas vazias. Zero e false estão presentes.
Valores em branco
values.blank(value) é o inverso de present.
has(contact.name)
maps.has(contact, "name")
contact.?nickname.orValue("Guest")
A macro nativa has(contact.name) verifica presença: um campo explicitamente
null está presente. maps.has verifica um caminho não null. orValue
só aplica o padrão quando o opcional está ausente, não quando está presente com
null. Uma variável raiz ausente gera erro; ela não é criada automaticamente com
null.
Mapas imutáveis
maps.defaults(record, {"status": "unknown"})
maps.merge(record, {"status": "confirmed", "note": null})
maps.pick(record, ["name", "status"])
maps.omit(record, ["internalNote"])
Defaults preenche chaves ausentes/null. Merge é superficial e os valores à direita prevalecem, incluindo false, zero, texto vazio e null. O mapa original permanece igual.
Listas e texto
Recortes de listas
lists.slice(list, start, end?) aceita índices negativos e retorna uma
lista vazia para entradas que não são listas. lists.pluck(list, path)
lê um caminho de cada item. As macros padrão list.filter(variable, predicate)
e list.map(variable, transform) mantêm a sintaxe com receptor.
Mapeamento e junção
lists.mapList(people, person,
values.coalesce(maps.get(person, "name"), "Guest"))
lists.join(["Alice", null, "Bob"], " | ")
Join retorna "Alice | | Bob": itens null/vazios mantêm suas posições entre separadores; false e zero são incluídos. Uma lista null retorna texto vazio; o separador padrão é vírgula. Uma variável ou campo ausente pode falhar na avaliação do argumento, antes da chamada de join. Datas nativas são exibidas como texto ISO.
Templates
text.template("Hello {name}!", {"name": "Alice"})
text.template("{address.city}", contact)
Placeholders aceitam caminhos com pontos; valores ausentes/null viram texto vazio.
Junção condicional
text.joinPresent(" · ", "Title", null, "Author")
lists.join(parts.filter(part, values.present(part)), "\n")
joinPresent ignora valores em branco e aceita até onze valores após o
separador. Use uma lista filtrada quando a quantidade de partes for dinâmica.
Limite e normalização de texto
text.truncate(text, maxLength, suffix?) inclui o sufixo no limite.
fold aplica NFKD, remove marcas combinantes e converte para minúsculas sem
mudar espaços. nameKey também reduz espaços e remove espaços nas extremidades.
singleLine reduz espaços, preservando maiúsculas e acentos.
text.replace faz apenas substituições literais; use regex.replace para substituições por padrões.
Datas e horário
Relógio explícito
datetime.now() retorna o instante UTC atual e não é determinística.
Obtenha esse valor no chamador e passe-o para funções puras do tenant.
datetime.localTimeZone() lê explicitamente o fuso configurado no
navegador ou servidor que avalia a expressão. É contextual e não pode aparecer
no corpo de uma função do tenant; obtenha o fuso no chamador e passe-o como
parâmetro. As outras funções compartilhadas de data são puras e usam UTC e
inglês fixo por padrão.
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")
Unidades de calendário usam o calendário do fuso explícito; unidades menores
que um dia representam tempo decorrido. diff(a, b, unit?, zone?) trunca o
resultado; diferenças de dias/semanas no fuso explícito consideram mudanças do
horário de verão, enquanto horas/minutos medem tempo decorrido. isBetween aceita seis argumentos e
também um fuso na quinta posição quando a sexta é omitida. Datas ausentes ou em
formato livre são rejeitadas. zoned(date, time, zone, format?) cria um instante
com base no horário local; o formato personalizado deve conter ano/mês/dia,
coincidir estritamente e usar leitura em inglês.
Unidades e conversões tipadas
int(v) e as outras conversões nativas são tipadas. Verifique o texto antes de
convertê-lo; presença não trata um erro de conversão.
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) e int(timestamp) usam segundos Unix. int(duration) usa
nanossegundos; crie durações com unidades explícitas, como duration("60s").
As funções de milissegundos tornam explícitas as unidades de um sistema externo
e respeitam o intervalo nativo, anos 0001–9999. A adaptação Date tem precisão de
milissegundos. Conversões numéricas inválidas geram erro, não um valor alternativo
utilizável.
Getters nativos usam receptor. timestamp.getDayOfMonth() começa em zero;
timestamp.getDate() começa em um. type(x) == string é uma comparação válida.
CEL padrão e extensões
CEL mantém size, int, uint, double, bool, string, bytes, timestamp,
duration, type, dyn, has, o operador in e macros com receptor. Use
cel.bind para um valor local da expressão, seleção opcional para presença,
sortBy/transformações com duas variáveis para coleções e namespaces padrão como
regex, math, sets, lists e base64.
Matemática nativa e funções com coerção
math.abs, math.ceil, math.floor, math.round e math.sqrt usam os
contratos numéricos nativos do CEL. Por exemplo, type(math.abs(-3)) == int.
As funções de plataforma com coerção têm nomes explícitos: math.absCoerced,
math.ceilCoerced, math.floorCoerced, math.roundDecimal e
math.sqrtCoerced. type(math.absCoerced(-3)) == double;
math.roundDecimal(12.345, 2) aceita um número opcional de casas decimais.
Escolha o contrato desejado; os nomes nativos curtos não são aliases das
funções com coerção.
lists.mapList(items, item, expression) é a macro de mapeamento da plataforma.
items.map(item, expression) continua sendo uma macro nativa com receptor e
lists.range(...) continua nativa. json.encode(...) e base64.* mantêm seus
contratos nativos. Use text.quote(...) para produzir texto entre aspas CEL;
bson.ObjectId é a constante de tipo BSON, por exemplo
type(contact._id) == bson.ObjectId quando a entrada é um ObjectId real.
Condições com curto-circuito
cel.bind(stamp, maps.get(record, "deadline"),
values.present(stamp) && datetime.isAfter(clock, stamp))
Quando o lado esquerdo decide && ou ||, o outro lado pode não ser executado.
A absorção de erros comuns segue CEL; limites de avaliação
interrompem a avaliação, sem virar resultados de negócio bem-sucedidos. Filtros
de hook têm seu próprio contexto e orçamento.
Expressões 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]+)")
Os padrões usam RE2 nativo, incluindo classes Unicode e flags locais. Lookaround e backreferences não são aceitos. Teste com fixtures representativas. Salvar agentes/workflows pode reportar problemas de compilação sem impedir o salvamento; uma expressão inválida armazenada continua falhando quando executada. Publicar uma biblioteca exige compilação e fixtures configuradas bem-sucedidas.
Limites de avaliação
CEL-Go controla o custo de execução. Também há limites de tempo, texto/lista/mapa,
bytes e crescimento de valores; chamadas de tenant aninhadas compartilham o orçamento do
chamador. Uma recusa por orçamento interrompe a avaliação. Corrija a expressão
ou os dados em vez de ocultar a recusa. O diagnóstico nativo usa
resource_budget_exceeded. Os limites de bytes são 8 MiB por valor e 64 MiB
produzidos durante uma avaliação; chamadas aninhadas compartilham esses limites.
Reutilize cálculos com cel.bind ou uma função pura do tenant.
Saídas de workflows e agentes
Sucesso da etapa
workflow.stepOk(0)
workflow.stepError(0)
As funções referenciam uma etapa anterior existente na cadeia atual. stepOk
exige execução concluída e status HTTP 200 ou ausência de status HTTP.
stepError retorna um descritor seguro de erro ou null.
Dados da etapa
workflow.stepData(0, "title", "Unknown")
workflow.stepData(1, "choices.0.message.content", "")
workflow.stepHasContent(1, "choices")
O caminho é relativo a data quando a ação usa esse envelope; não repita o
prefixo data. Caminhos ausentes usam o padrão; um índice inexistente gera erro.
stepHasContent combina sucesso e conteúdo significativo.
Saídas na raiz e de código
Consulte as saídas declaradas da ação. Ações sem envelope publicam campos como
count, choices ou file na raiz. A função resolve esses campos quando não
há data/result.
Estas 23 ações publicam as saídas declaradas na raiz da etapa, sem envelope
data ou result:
| Ação | Saídas na raiz |
|---|---|
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 |
Leia um campo na raiz explicitamente com as funções qualificadas:
maps.get(workflow.step(0), "count", 0)
maps.get(workflow.step(1), "files", [])
Executar código publica result: workflow.stepData(N,"count")
resolve workflow.step(N).result.count. Os campos raiz files, logs
e executionTimeMs precisam de acesso explícito.
Algumas saídas de etapa mantêm valores ObjectId reais: Atualizar dados com filtro, Executar Workflow em workflow.step(N).data.workflow, e Enviar mensagem / Compor resposta em workflow.step(N).messages. ==, != comparam ids; operações de texto como startsWith() exigem bson.objectIdToString() primeiro.
Diagnósticos ao salvar
Salvar agentes/workflows retorna problemas de compilação em warnings:
CEL_COMPILE_ERROR tem severity: "error". A verificação limitada ao salvar
ignora expressões acima de 8.192 caracteres ou além dos 10.000 caracteres de CEL
por agente ou workflow restantes, prompts de sistema incluídos, e informa
CEL_TOO_LARGE_TO_LINT. Uma expressão ignorada ainda é compilada quando roda.
Prosa claramente sem aspas usa uma verificação separada e limitada do parser,
para que um prompt longo ainda receba um diagnóstico útil de CEL/texto.
Publicar uma biblioteca exige compilação e validação de fixtures bem-sucedidas.
Erros seguros
workflow.stepError retorna detalhes seguros de erro ou null.
Conteúdo significativo
workflow.stepHasContent exige sucesso e conteúdo significativo.
Essas funções não estão disponíveis em corpos puros de bibliotecas do tenant.
Outras funções compartilhadas e de formulário
url.params("https://api.example.com/search", {"q": query})
number.formatCurrency("BRL", "pt-BR", 100.0)
math.clamp(value, 0, 100)
Formatação de URL
url.params adiciona parâmetros codificados; url.encode
codifica texto para uma URL.
Limites numéricos
math.clamp(value, minimum, maximum) mantém o número dentro dos limites.
As funções de telefone exigem modo de origem explícito para dígitos
internacionais sem prefixo ou endereços WhatsApp. Números nacionais precisam de
defaultCountry; LIDs do WhatsApp não são números de telefone.
br.cpfValid verifica formato e checksum; regras de aceitação do
negócio pertencem ao código do tenant.
Formatação de interface e i18n.t dependem do formulário e não são
funções de workflow. O catálogo mostra a disponibilidade de cada função.
Bibliotecas do tenant
Crie bibliotecas em Automações → Bibliotecas (Nova biblioteca → CEL), ou no modelo Dynadata
cel_libraries por MCP/API. As funções têm parâmetros nomeados e tipados, tipo
de retorno, corpo CEL e fixtures JSON. Recebem só parâmetros e funções puras
compartilhadas/importadas: passe relógio, contato e dados salvos explicitamente.
Não leem estado ambiente de etapa/formulário/agente nem realizam I/O.
Salve um rascunho estruturado, valide, execute as fixtures e publique o
draftRevision salvo. A publicação verifica novamente compilação e fixtures e
cria uma versão exata imutável. A importação raiz do chamador fixa essa versão:
{"celLibraries": [{"libraryId": "000000000000000000000001", "releaseId": "000000000000000000000002"}]}
Use os IDs retornados, não esses exemplos. Uma biblioteca de slug labels
expõe labels.normalizeName(...). Editar ou publicar não muda chamadores
existentes; selecione outra versão exata deliberadamente. Dependências também
fixam versões exatas.
labels.normalizeName(value) pertence ao tenant que define e importa a biblioteca labels. Não é uma função fornecida globalmente. Veja o guia do editor para um rascunho tipado completo e o fluxo por UI/MCP/API.
Raízes de bibliotecas e dados
O slug da biblioteca é seu namespace raiz: labels.normalizeName(...). Slugs
são fixos, têm até 48 caracteres e usam uma letra minúscula seguida por letras
minúsculas, números ou underscores. Raízes de plataforma/extensões nativas,
raízes antigas (autotalk, tenant, strings), palavras-chave/funções
globais/tipos CEL e chaves de segurança são reservados. Use um nome de negócio
distinto, como clinic ou labels. Nomes comuns válidos de parâmetros/membros,
como values, math, lists, map ou all, continuam permitidos na biblioteca.
Funções e dados podem compartilhar uma raiz: values.coalesce(...) chama uma
função e values.name lê dados do formulário. Para tornar explícito um receptor
de dados que seria capturado por uma função/importação qualificada, use
dyn(lists).join(","). O valor do receptor é mantido, mas a checagem estática de
tipos fica menos precisa e há custo normal de avaliação. Revise os diagnósticos
ao mudar importações. Um item do catálogo sozinho não importa uma biblioteca nem
altera um receptor como clinic.size().
bson.ObjectId identifica a constante de tipo BSON. Para ler um campo de dados
com nome ObjectId em uma variável bson, use colchetes: bson['ObjectId'].
Isso mantém a checagem de tipos do campo e os erros de campo ausente. Por
exemplo, esta expressão completa retorna "data":
cel.bind(bson, {'ObjectId': 'data'}, bson['ObjectId'])
Catálogo gerado de funções
Gerado a partir dos metadados do Commons. Sintaxe, tipos, contextos e pureza vêm do mesmo contrato usado pelo editor e pelo MCP.
base64
| Chamada | Assinatura tipada | Contexto | Pureza |
|---|---|---|---|
base64.decode(value) | base64.decode(string) -> bytes | Workflow, Agente, Formulário | pura |
base64.encode(value) | base64.encode(bytes) -> string | Workflow, Agente, Formulário | pura |
br
| Chamada | Assinatura tipada | Contexto | Pureza |
|---|---|---|---|
br.cpfValid(value) | br.cpfValid(dyn) -> bool | Workflow, Agente, Formulário | pura |
bson
| Chamada | Assinatura tipada | Contexto | Pureza |
|---|---|---|---|
bson.deserialize(bsonString, encoding?) | bson.deserialize(string, string?) -> dyn | Workflow, Agente, Formulário | pura |
bson.ejsonParse(ejsonString, relaxed?) | bson.ejsonParse(string, bool?) -> dyn | Workflow, Agente, Formulário | pura |
bson.ejsonStringify(value, relaxed?) | bson.ejsonStringify(dyn, bool?) -> string | Workflow, Agente, Formulário | pura |
bson.objectId(value?) | bson.objectId(dyn?) -> objectId | Workflow, Agente, Formulário | não determinística |
bson.objectIdIsValid(value) | bson.objectIdIsValid(dyn) -> bool | Workflow, Agente, Formulário | pura |
bson.objectIdToString(value) | bson.objectIdToString(dyn) -> string | Workflow, Agente, Formulário | pura |
bson.serialize(value, encoding?) | bson.serialize(dyn, string?) -> string | Workflow, Agente, Formulário | pura |
Biblioteca padrão CEL e extensões
| Chamada | Assinatura tipada | Contexto | Pureza |
|---|---|---|---|
list.all(var, predicate) | list<any>.all(identifier, bool) -> bool | Workflow, Agente, Formulário | pura |
bool(value) | bool(string|bool) -> bool | Workflow, Agente, Formulário | pura |
bytes(value) | bytes(string|bytes) -> bytes | Workflow, Agente, Formulário | pura |
cel.bind(variable, initial, expression) | cel.bind(identifier, T, R) -> R | Workflow, Agente, Formulário | pura |
text.charAt(index) | string.charAt(int) -> string | Workflow, Agente, Formulário | pura |
text.contains(substr) | string.contains(string) -> bool | Workflow, Agente, Formulário | pura |
list.distinct() | list<T>.distinct() -> list<T> | Workflow, Agente, Formulário | pura |
double(value) | double(number|string) -> double | Workflow, Agente, Formulário | pura |
duration(value) | duration(string|duration) -> duration | Workflow, Agente, Formulário | pura |
dyn(value) | dyn(any) -> dyn | Workflow, Agente, Formulário | pura |
text.endsWith(suffix) | string.endsWith(string) -> bool | Workflow, Agente, Formulário | pura |
list.exists(var, predicate) | list<any>.exists(identifier, bool) -> bool | Workflow, Agente, Formulário | pura |
list.exists_one(var, predicate) | list<any>.exists_one(identifier, bool) -> bool | Workflow, Agente, Formulário | pura |
list.filter(var, predicate) | list<any>.filter(identifier, bool) -> list<any> | Workflow, Agente, Formulário | pura |
list.first() | list<T>.first() -> optional<T> | Workflow, Agente, Formulário | pura |
list.flatten(depth?) | list<dyn>.flatten(int?) -> list<T> | Workflow, Agente, Formulário | pura |
format.format(args) | string.format(list<any>) -> string | Workflow, Agente, Formulário | pura |
timestamp.getDate(tz?) | timestamp.getDate(string?) -> int | Workflow, Agente, Formulário | pura |
timestamp.getDayOfMonth(tz?) | timestamp.getDayOfMonth(string?) -> int | Workflow, Agente, Formulário | pura |
timestamp.getDayOfWeek(tz?) | timestamp.getDayOfWeek(string?) -> int | Workflow, Agente, Formulário | pura |
timestamp.getDayOfYear(tz?) | timestamp.getDayOfYear(string?) -> int | Workflow, Agente, Formulário | pura |
timestamp.getFullYear(tz?) | timestamp.getFullYear(string?) -> int | Workflow, Agente, Formulário | pura |
timestamp.getHours(tz?) / duration.getHours() | timestamp.getHours(string?) -> int / duration.getHours() -> int | Workflow, Agente, Formulário | pura |
timestamp.getMilliseconds(tz?) / duration.getMilliseconds() | timestamp.getMilliseconds(string?) -> int / duration.getMilliseconds() -> int | Workflow, Agente, Formulário | pura |
timestamp.getMinutes(tz?) / duration.getMinutes() | timestamp.getMinutes(string?) -> int / duration.getMinutes() -> int | Workflow, Agente, Formulário | pura |
timestamp.getMonth(tz?) | timestamp.getMonth(string?) -> int | Workflow, Agente, Formulário | pura |
timestamp.getSeconds(tz?) / duration.getSeconds() | timestamp.getSeconds(string?) -> int / duration.getSeconds() -> int | Workflow, Agente, Formulário | pura |
has(selection) | has(select expression) -> bool | Workflow, Agente, Formulário | pura |
optional.hasValue() | optional<T>.hasValue() -> bool | Workflow, Agente, Formulário | pura |
text.indexOf(substr, start?) | string.indexOf(string, int?) -> int | Workflow, Agente, Formulário | pura |
int(value) | int(number|string|timestamp|duration) -> int | Workflow, Agente, Formulário | pura |
list.join(sep?) | list<string>.join(string?) -> string | Workflow, Agente, Formulário | pura |
list.last() | list<T>.last() -> optional<T> | Workflow, Agente, Formulário | pura |
text.lastIndexOf(substr, start?) | string.lastIndexOf(string, int?) -> int | Workflow, Agente, Formulário | pura |
text.lowerAscii() | string.lowerAscii() -> string | Workflow, Agente, Formulário | pura |
list.map(var, expr) | list<any>.map(identifier, any) -> list<any> | Workflow, Agente, Formulário | pura |
text.matches(pattern) | string.matches(string) -> bool | Workflow, Agente, Formulário | pura |
optional.optFlatMap(variable, expression) | optional<T>.optFlatMap(identifier, optional<R>) -> optional<R> | Workflow, Agente, Formulário | pura |
optional.optMap(variable, expression) | optional<T>.optMap(identifier, R) -> optional<R> | Workflow, Agente, Formulário | pura |
optional.or(fallback) | optional<T>.or(optional<T>) -> optional<T> | Workflow, Agente, Formulário | pura |
optional.orValue(fallback) | optional<T>.orValue(T) -> T | Workflow, Agente, Formulário | pura |
text.replace(substr, repl, count?) | string.replace(string, string, int?) -> string | Workflow, Agente, Formulário | pura |
value.reverse() | list<T>|string.reverse() -> list<T>|string | Workflow, Agente, Formulário | pura |
size(value) | size(list|map|string|bytes) -> int | Workflow, Agente, Formulário | pura |
list.slice(start, end) | list<T>.slice(int, int) -> list<T> | Workflow, Agente, Formulário | pura |
list.sort() | list<T>.sort() -> list<T> | Workflow, Agente, Formulário | pura |
list.sortBy(variable, key) | list<T>.sortBy(identifier, comparable expression) -> list<T> | Workflow, Agente, Formulário | pura |
text.split(sep, limit?) | string.split(string, int?) -> list<string> | Workflow, Agente, Formulário | pura |
text.startsWith(prefix) | string.startsWith(string) -> bool | Workflow, Agente, Formulário | pura |
string(value) | string(bool|int|uint|double|string|bytes|timestamp|duration|ObjectId) -> string | Workflow, Agente, Formulário | pura |
text.substring(start, end?) | string.substring(int, int?) -> string | Workflow, Agente, Formulário | pura |
timestamp(value) | timestamp(string|int|timestamp) -> timestamp | Workflow, Agente, Formulário | pura |
collection.transformList(keyOrIndex, value, predicateOrTransform, transform?) | list<T>|map<K,T>.transformList(identifier, identifier, bool|R, R?) -> list<R> | Workflow, Agente, Formulário | pura |
collection.transformMap(keyOrIndex, value, predicateOrTransform, transform?) | list<T>|map<K,T>.transformMap(identifier, identifier, bool|R, R?) -> map<K,R> | Workflow, Agente, Formulário | 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, Formulário | pura |
text.trim() | string.trim() -> string | Workflow, Agente, Formulário | pura |
type(value) | type(any) -> type | Workflow, Agente, Formulário | pura |
uint(value) | uint(number|string) -> uint | Workflow, Agente, Formulário | pura |
text.upperAscii() | string.upperAscii() -> string | Workflow, Agente, Formulário | pura |
optional.value() | optional<T>.value() -> T | Workflow, Agente, Formulário | pura |
datetime
| Chamada | Assinatura tipada | Contexto | Pureza |
|---|---|---|---|
datetime.add(isoOrMs, amount, unit, tz?) | datetime.add(string|int|double|timestamp, int|double, string, string?) -> string | Workflow, Agente, Formulário | pura |
datetime.diff(a, b, unit?, tz?) | datetime.diff(string|int|double|timestamp, string|int|double|timestamp, string?, string?) -> double | Workflow, Agente, Formulário | pura |
datetime.format(isoOrMs, fmt, tz?, locale?) | datetime.format(string|int|double|timestamp, string, string?, string?) -> string | Workflow, Agente, Formulário | pura |
datetime.fromMillis(milliseconds) | datetime.fromMillis(int|double) -> timestamp | Workflow, Agente, Formulário | pura |
datetime.isAfter(a, b, unit?, tz?) | datetime.isAfter(string|int|double|timestamp, string|int|double|timestamp, string?, string?) -> bool | Workflow, Agente, Formulário | pura |
datetime.isBefore(a, b, unit?, tz?) | datetime.isBefore(string|int|double|timestamp, string|int|double|timestamp, string?, string?) -> bool | Workflow, Agente, Formulário | 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, Formulário | pura |
datetime.isSameDate(a, b, unit?, tz?) | datetime.isSameDate(string|int|double|timestamp, string|int|double|timestamp, string?, string?) -> bool | Workflow, Agente, Formulário | pura |
datetime.isSameOrAfter(a, b, unit?, tz?) | datetime.isSameOrAfter(string|int|double|timestamp, string|int|double|timestamp, string?, string?) -> bool | Workflow, Agente, Formulário | pura |
datetime.isSameOrBefore(a, b, unit?, tz?) | datetime.isSameOrBefore(string|int|double|timestamp, string|int|double|timestamp, string?, string?) -> bool | Workflow, Agente, Formulário | pura |
datetime.localTimeZone() | datetime.localTimeZone() -> string | Workflow, Agente, Formulário | contextual |
datetime.now(tz?) | datetime.now(string?) -> string | Workflow, Agente, Formulário | não determinística |
datetime.toMillis(timestamp) | datetime.toMillis(timestamp) -> double | Workflow, Agente, Formulário | pura |
datetime.zoned(dateStr, timeStr, tz, format?) | datetime.zoned(string, string, string, string?) -> string | Workflow, Agente, Formulário | pura |
form
| Chamada | Assinatura tipada | Contexto | Pureza |
|---|---|---|---|
form.argsOf(node) | form.argsOf(map<string,dyn>|null) -> dyn | Formulário | pura |
form.compact(value) | form.compact(dyn) -> string | Formulário | contextual |
form.concat(...parts) | form.concat(...dyn) -> string | Formulário | pura |
form.evalActionPreview(action) | form.evalActionPreview(map<string,dyn>) -> string|null | Formulário | contextual |
form.formatDate(value, format?) | form.formatDate(dyn, string?) -> string | Formulário | contextual |
form.formatPhone(value) | form.formatPhone(dyn) -> string | Formulário | pura |
form.getField(type) | form.getField(string) -> map<string,dyn>|null | Formulário | contextual |
form.innerEval(expr) | form.innerEval(string) -> dyn | Formulário | contextual |
form.isChatTabActive(conversationId) | form.isChatTabActive(dyn) -> bool | Formulário | contextual |
form.isChatTabOpen(conversationId) | form.isChatTabOpen(dyn) -> bool | Formulário | contextual |
form.isTabOpen(tabId) | form.isTabOpen(dyn) -> bool | Formulário | contextual |
form.len(value) | form.len(dyn) -> double | Formulário | pura |
form.log(...args) | form.log(...dyn) -> null | Formulário | com efeitos |
form.money(value, currency?, locale?) | form.money(dyn, string?, string?) -> string | Formulário | pura |
form.navigate(to) | form.navigate(dyn) -> null | Formulário | com efeitos |
form.number(value) | form.number(dyn) -> string | Formulário | contextual |
form.objectKeys(value) | form.objectKeys(map<string,dyn>) -> list<string> | Formulário | pura |
form.pluralize(value, one, many) | form.pluralize(dyn, string, string) -> string | Formulário | pura |
form.randomApiTokenAlias() | form.randomApiTokenAlias() -> string | Formulário | não determinística |
form.scope(overrides, expr) | form.scope(map<string,dyn>, string) -> dyn | Formulário | contextual |
form.shortId(id) | form.shortId(dyn) -> string | Formulário | pura |
form.timeAgo(value) | form.timeAgo(dyn) -> string | Formulário | não determinística |
form.toast(msg) | form.toast(dyn) -> dyn | Formulário | com efeitos |
form.ucFirst(value) | form.ucFirst(dyn) -> string | Formulário | pura |
i18n
| Chamada | Assinatura tipada | Contexto | Pureza |
|---|---|---|---|
i18n.t(key) | i18n.t(string) -> string | Formulário | contextual |
json
| Chamada | Assinatura tipada | Contexto | Pureza |
|---|---|---|---|
json.encode(value) | json.encode(dyn) -> string | Workflow, Agente, Formulário | pura |
json.parse(jsonString) | json.parse(string) -> dyn | Workflow, Agente, Formulário | pura |
json.stringify(value, space?) | json.stringify(dyn, int|double?) -> string | Workflow, Agente, Formulário | pura |
lists
| Chamada | Assinatura tipada | Contexto | Pureza |
|---|---|---|---|
lists.join(list, separator?) | lists.join(list<dyn>|null, string?) -> string | Workflow, Agente, Formulário | pura |
lists.mapList(list, variable, transform) | lists.mapList(list<dyn>, identifier, expression) -> list<dyn> | Workflow, Agente, Formulário | pura |
lists.pluck(arr, path) | lists.pluck(list<dyn>|null, string) -> list<dyn>|null | Workflow, Agente, Formulário | pura |
lists.range(end) | lists.range(int) -> list<int> | Workflow, Agente, Formulário | pura |
lists.slice(arr, start, end?) | lists.slice(dyn, int|double, int|double|null?) -> list<dyn> | Workflow, Agente, Formulário | pura |
maps
| Chamada | Assinatura tipada | Contexto | Pureza |
|---|---|---|---|
maps.defaults(obj, fallbacks) | maps.defaults(map<string,dyn>|null, map<string,dyn>) -> map<string,dyn> | Workflow, Agente, Formulário | pura |
maps.get(obj, prop, defaultValue?) | maps.get(dyn, string, dyn?) -> dyn | Workflow, Agente, Formulário | pura |
maps.has(obj, prop?) | maps.has(dyn, string?) -> bool | Workflow, Agente, Formulário | pura |
maps.merge(...maps) | maps.merge(...map<string,dyn>|null) -> map<string,dyn> | Workflow, Agente, Formulário | pura |
maps.omit(map, keys) | maps.omit(map<string,dyn>|null, list<string>) -> map<string,dyn> | Workflow, Agente, Formulário | pura |
maps.pick(map, keys) | maps.pick(map<string,dyn>|null, list<string>) -> map<string,dyn> | Workflow, Agente, Formulário | pura |
maps.set(map, key, value) | maps.set(map<string,dyn>|null, string, dyn) -> map<string,dyn> | Workflow, Agente, Formulário | pura |
math
| Chamada | Assinatura tipada | Contexto | Pureza |
|---|---|---|---|
math.abs(value) | math.abs(int|uint|double) -> int|uint|double | Workflow, Agente, Formulário | pura |
math.absCoerced(value) | math.absCoerced(int|double) -> double | Workflow, Agente, Formulário | pura |
math.add(a, b) | math.add(int|double, int|double) -> double | Workflow, Agente, Formulário | pura |
math.bitAnd(first, second) | math.bitAnd(int|uint, int|uint) -> int|uint | Workflow, Agente, Formulário | pura |
math.bitNot(value) | math.bitNot(int|uint) -> int|uint | Workflow, Agente, Formulário | pura |
math.bitOr(first, second) | math.bitOr(int|uint, int|uint) -> int|uint | Workflow, Agente, Formulário | pura |
math.bitShiftLeft(first, second) | math.bitShiftLeft(int|uint, int) -> int|uint | Workflow, Agente, Formulário | pura |
math.bitShiftRight(first, second) | math.bitShiftRight(int|uint, int) -> int|uint | Workflow, Agente, Formulário | pura |
math.bitXor(first, second) | math.bitXor(int|uint, int|uint) -> int|uint | Workflow, Agente, Formulário | pura |
math.ceil(value) | math.ceil(double) -> double | Workflow, Agente, Formulário | pura |
math.ceilCoerced(value) | math.ceilCoerced(int|double) -> double | Workflow, Agente, Formulário | pura |
math.clamp(value, min, max) | math.clamp(int|double, int|double, int|double) -> double | Workflow, Agente, Formulário | pura |
math.cos(value) | math.cos(int|double) -> double | Workflow, Agente, Formulário | pura |
math.divide(a, b) | math.divide(int|double, int|double) -> double | Workflow, Agente, Formulário | pura |
math.dot(a, b) | math.dot(list<number>, list<number>) -> double | Workflow, Agente, Formulário | pura |
math.evaluate(expr) | math.evaluate(string) -> double | Workflow, Agente, Formulário | pura |
math.exp(value) | math.exp(int|double) -> double | Workflow, Agente, Formulário | pura |
math.floor(value) | math.floor(double) -> double | Workflow, Agente, Formulário | pura |
math.floorCoerced(value) | math.floorCoerced(int|double) -> double | Workflow, Agente, Formulário | pura |
math.greatest(...values) | math.greatest(...int|uint|double|list<number>) -> int|uint|double | Workflow, Agente, Formulário | pura |
math.isFinite(value) | math.isFinite(double) -> bool | Workflow, Agente, Formulário | pura |
math.isInf(value) | math.isInf(double) -> bool | Workflow, Agente, Formulário | pura |
math.isNaN(value) | math.isNaN(double) -> bool | Workflow, Agente, Formulário | pura |
math.least(...values) | math.least(...int|uint|double|list<number>) -> int|uint|double | Workflow, Agente, Formulário | pura |
math.log(value, base?) | math.log(int|double, int|double?) -> double | Workflow, Agente, Formulário | pura |
math.max(arr) | math.max(list<number>) -> double | Workflow, Agente, Formulário | pura |
math.mean(arr) | math.mean(list<number>) -> double | Workflow, Agente, Formulário | pura |
math.median(arr) | math.median(list<number>) -> double | Workflow, Agente, Formulário | pura |
math.min(arr) | math.min(list<number>) -> double | Workflow, Agente, Formulário | pura |
math.multiply(a, b) | math.multiply(int|double, int|double) -> double | Workflow, Agente, Formulário | pura |
math.norm(arr) | math.norm(list<number>) -> double | Workflow, Agente, Formulário | pura |
math.pow(base, exponent) | math.pow(int|double, int|double) -> double | Workflow, Agente, Formulário | pura |
math.round(value) | math.round(double) -> double | Workflow, Agente, Formulário | pura |
math.roundDecimal(value, decimals?) | math.roundDecimal(int|double, int|double?) -> double | Workflow, Agente, Formulário | pura |
math.sign(value) | math.sign(int|uint|double) -> int|uint|double | Workflow, Agente, Formulário | pura |
math.sin(value) | math.sin(int|double) -> double | Workflow, Agente, Formulário | pura |
math.sqrt(value) | math.sqrt(int|uint|double) -> double | Workflow, Agente, Formulário | pura |
math.sqrtCoerced(value) | math.sqrtCoerced(int|double) -> double | Workflow, Agente, Formulário | pura |
math.std(arr) | math.std(list<number>) -> double | Workflow, Agente, Formulário | pura |
math.subtract(a, b) | math.subtract(int|double, int|double) -> double | Workflow, Agente, Formulário | pura |
math.tan(value) | math.tan(int|double) -> double | Workflow, Agente, Formulário | pura |
math.trunc(value) | math.trunc(double) -> double | Workflow, Agente, Formulário | pura |
math.variance(arr) | math.variance(list<number>) -> double | Workflow, Agente, Formulário | pura |
number
| Chamada | Assinatura tipada | Contexto | Pureza |
|---|---|---|---|
number.formatCurrency(currency, locale, amount) | number.formatCurrency(string, string, int|double) -> string | Workflow, Agente, Formulário | pura |
optional
| Chamada | Assinatura tipada | Contexto | Pureza |
|---|---|---|---|
optional.none() | optional.none() -> optional<dyn> | Workflow, Agente, Formulário | pura |
optional.of(value) | optional.of(T) -> optional<T> | Workflow, Agente, Formulário | pura |
optional.ofNonZeroValue(value) | optional.ofNonZeroValue(T) -> optional<T> | Workflow, Agente, Formulário | pura |
optional.unwrap(values) | optional.unwrap(list<optional<T>>) -> list<T> | Workflow, Agente, Formulário | pura |
phone
| Chamada | Assinatura tipada | Contexto | Pureza |
|---|---|---|---|
phone.display(value, options?) | phone.display(string|null, map<string,dyn>|null?) -> string | Workflow, Agente, Formulário | pura |
phone.isValid(value, options?) | phone.isValid(string|null, map<string,dyn>|null?) -> bool | Workflow, Agente, Formulário | pura |
phone.parse(value, options?) | phone.parse(string|null, map<string,dyn>|null?) -> map<string,dyn> | Workflow, Agente, Formulário | pura |
regex
| Chamada | Assinatura tipada | Contexto | Pureza |
|---|---|---|---|
regex.extract(text, pattern) | regex.extract(string, string) -> optional<string> | Workflow, Agente, Formulário | pura |
regex.extractAll(text, pattern) | regex.extractAll(string, string) -> list<string> | Workflow, Agente, Formulário | pura |
regex.replace(text, pattern, replacement, count?) | regex.replace(string, string, string, int?) -> string | Workflow, Agente, Formulário | pura |
sets
| Chamada | Assinatura tipada | Contexto | Pureza |
|---|---|---|---|
sets.contains(superset, subset) | sets.contains(list<T>, list<T>) -> bool | Workflow, Agente, Formulário | pura |
sets.equivalent(first, second) | sets.equivalent(list<T>, list<T>) -> bool | Workflow, Agente, Formulário | pura |
sets.intersects(first, second) | sets.intersects(list<T>, list<T>) -> bool | Workflow, Agente, Formulário | pura |
text
| Chamada | Assinatura tipada | Contexto | Pureza |
|---|---|---|---|
text.fold(value) | text.fold(string|null) -> string | Workflow, Agente, Formulário | pura |
text.joinPresent(separator, ...values) | text.joinPresent(string, ...dyn) -> string | Workflow, Agente, Formulário | pura |
text.nameKey(value) | text.nameKey(string|null) -> string | Workflow, Agente, Formulário | pura |
text.quote(text) | text.quote(string) -> string | Workflow, Agente, Formulário | pura |
text.singleLine(value) | text.singleLine(string|null) -> string | Workflow, Agente, Formulário | pura |
text.template(template, vars) | text.template(string, map<string,dyn>|null) -> string | Workflow, Agente, Formulário | pura |
text.truncate(str, maxLen, suffix?) | text.truncate(dyn, int|double, string?) -> string | Workflow, Agente, Formulário | pura |
toon
| Chamada | Assinatura tipada | Contexto | Pureza |
|---|---|---|---|
toon.decode(toonString) | toon.decode(string) -> dyn | Workflow, Agente, Formulário | pura |
toon.encode(value) | toon.encode(dyn) -> string | Workflow, Agente, Formulário | pura |
url
| Chamada | Assinatura tipada | Contexto | Pureza |
|---|---|---|---|
url.encode(str) | url.encode(string) -> string | Workflow, Agente, Formulário | pura |
url.params(base, params) | url.params(string, map<string,dyn>) -> string | Workflow, Agente, Formulário | pura |
values
| Chamada | Assinatura tipada | Contexto | Pureza |
|---|---|---|---|
values.blank(val) | values.blank(dyn) -> bool | Workflow, Agente, Formulário | pura |
values.coalesce(...args) | values.coalesce(...dyn) -> dyn | Workflow, Agente, Formulário | pura |
values.firstPresent(values) | values.firstPresent(list<dyn>|null) -> dyn | Workflow, Agente, Formulário | pura |
values.present(val) | values.present(dyn) -> bool | Workflow, Agente, Formulário | pura |
workflow
| Chamada | Assinatura 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 |