--- title: "Read a table published as a template" method: GET path: "/tables/{table_id}/template/" tags: ["tables"] --- # Read a table published as a template `GET /tables/{table_id}/template/` ## Request - Base URL: `https://api.getoneprofile.ai` (the document declares no server; this is the origin it was published from) - URL: `https://api.getoneprofile.ai/tables/{table_id}/template/` - Auth: none declared PUBLIC, no sign-in. Serves a table's SHAPE (its columns, their configuration, and what each column holds in words) when, and only when, its owner has turned on `shared_as_template`. A table that has not opted in answers 404 exactly as a non-existent one does, so an id alone reveals nothing. Never serves a row or a cell value. ## Path parameters - `table_id` string, uuid, required ## Response `200` Successful Response - SharedTableTemplateSchema: A table's published shape. Deliberately NOT a `TableReadSchema`: this is served without sign-in, so every field on it is a decision rather than an inheritance. Row counts, org, timestamps and run settings are all absent because none of them are part of a recipe. - `columns` SharedTableTemplateColumnSchema[], required - `column_type` 'text' | 'paragraph' | 'url' | 'email' | 'image_url' | 'person' | 'select' | 'number' | 'decimal' | 'currency' | 'checkbox' | 'date' | 'multi_select' | 'list' | 'object', required: The type a user picks for a table column. Ordered as the picker shows them, which is also the order the groups below run in: text-ish, then numeric, then choice, then structured. - `definition` union, required: Discriminated union of column definitions. A ``RootModel`` is required because ``PydanticJSON`` needs a ``BaseModel`` subclass to (de)serialize the stored JSON. Consumers always access the concrete member via ``.root``. - ManualColumnDefinition: Definition of a manual column: typed, user-editable cells. - `default_value` union - string - integer - number - boolean - `kind` 'manual' - FormulaColumnDefinitionOutput: Definition of a formula column: a pure-function chain over other columns. - `chain` union, required - TableCopyOutput: Copy the input value unchanged. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'copy' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableChangeCaseOutput: Change the case of a string value. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'change_case' - `mode` 'lower' | 'upper' | 'title', required - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableTrimOutput: Strip leading and trailing whitespace from a string value. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'trim' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableReplaceOutput: Replace all occurrences of a substring. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'replace' - `new` string, required - `next` union - … - `old` string, required - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableRegexExtractOutput: Extract a regex group from a string value. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'regex_extract' - `group` integer - `next` union - … - `pattern` string, required - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableRegexReplaceOutput: Replace regex matches in a string value. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'regex_replace' - `next` union - … - `pattern` string, required - `replacement` string, required - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableConcatenateOutput: Join several values into one string. Sources are ORDERED and may mix columns with the results of earlier steps: ``[First name, step 2]`` and ``[step 2, First name]`` are different strings, which is why there is one list rather than a list of columns beside a list of steps. The field keeps its original name: every stored definition holds ``source_column_ids``, and the list is still overwhelmingly columns. Only the item type widened, so old definitions validate untouched. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'concatenate' - `ignore_empty` boolean - `next` union - … - `separator` string - `source_column_ids` union[], required: Values to join, in order. A UUID reads that column on the row; a step reference reads an earlier step's output. - … - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableArithmeticOutput: Apply an arithmetic operator with a constant or column-valued operand. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'arithmetic' - `next` union - … - `operand` union, required - … - `operator` 'add' | 'subtract' | 'multiply' | 'divide', required - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableRoundOutput: Round a numeric value to a precision. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'round' - `mode` 'round' | 'ceil' | 'floor' - `next` union - … - `precision` integer - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableClampOutput: Clamp a numeric value to an inclusive range. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'clamp' - `max_value` union - … - `min_value` union - … - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableDateFormatOutput: Convert a date between iso/unix/unix_ms representations. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'date_format' - `input_format` 'iso' | 'unix' | 'unix_ms', required - `next` union - … - `output_format` 'iso' | 'unix' | 'unix_ms', required - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableDateExtractOutput: Extract a component (year, month, ...) from a date value. - `component` 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second', required - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'date_extract' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableDateArithmeticOutput: Add or subtract a fixed duration from a date value. - `amount` integer, required - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'date_arithmetic' - `next` union - … - `operator` 'add' | 'subtract', required - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - `unit` 'days' | 'hours' | 'minutes' | 'seconds', required - TableListFirstOutput: Take the first element of a list value. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'list_first' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableListLastOutput: Take the last element of a list value. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'list_last' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableListNthOutput: Take the element at an index of a list value. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'list_nth' - `index` integer - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableListJoinOutput: Join list elements into a string with a separator. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'list_join' - `next` union - … - `separator` string - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableListCountOutput: Count the elements of a list value. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'list_count' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableListPluckOutput: Pull one field out of every object in a list. Enrichment payloads routinely carry lists of objects (``[{"value": "Payroll"}, {"value": "HR"}]``) where the useful thing is the field, not the wrapper. Plucking turns that into ``["Payroll", "HR"]`` so ``list_join`` and friends can work on it; items without the field become empty and scalar items pass through unchanged. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `field` string, required - `function` 'list_pluck' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableListUniqueOutput: De-duplicate list elements, keeping first-seen order. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'list_unique' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableListSplitOutput: Split a string value into a list on a separator. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'list_split' - `next` union - … - `separator` string - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableCoalesceOutput: Substitute a default (a literal or another column) when the input is empty. - `default_value` union, required - … - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'coalesce' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableIfThenElseOutput: Pick one of two values based on a comparison. Each of the three slots takes a literal or a column, so this expresses both "if this column is over that column" and "use A, else use B". Neither of those was reachable while they were constants. - `compare_value` union - … - `else_value` union - … - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'if_then_else' - `next` union - … - `operator` 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte' | 'contains' | 'not_contains', required - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - `then_value` union - … - TableConditionsOutput: Fold several comparisons into ONE boolean. The engine's only boolean combinator, and the shape a column's ``run_condition`` is authored in: "only run where Employees > 50 AND Country is US". Nothing else here joins predicates: ``if_then_else`` compares exactly one pair and returns a value rather than a verdict. So without this a multi-clause gate could only be reached by chaining steps that pipe a truthy stand-in forward, which no editor could read back. One joiner over clauses and, at most one level down, groups of clauses: "A and (B or C)". That is precisely the row filter's shape, so a view's filter can be saved as a gate and read back as a filter without loss; a deeper tree would be expressible on one side only. Reads its clauses' operands directly and ignores the piped input, so it is a leaf rather than a transform. - `clauses` union[], required - … - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'conditions' - `joiner` 'and' | 'or' - `next` union - … - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableValueMappingOutput: Map input values through a lookup table. - `default_value` union - … - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'value_mapping' - `mapping` object, required - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableToStringOutput: Coerce the input to a string. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'to_string' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableToIntOutput: Coerce the input to an integer. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'to_int' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableToFloatOutput: Coerce the input to a float. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'to_float' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableToBoolOutput: Coerce the input to a boolean. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'to_bool' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableToDateOutput: Coerce the input to a date. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'to_date' - `input_format` 'iso' | 'unix' | 'unix_ms' | 'auto' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TablePhoneE164Output: Normalize a phone number to E.164 format. - `default_region` string - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'phone_e164' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableUtmParseOutput: Extract a UTM parameter from a URL value. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'utm_parse' - `next` union - … - `parameter` 'source' | 'medium' | 'campaign' | 'term' | 'content', required - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableUrlDomainOutput: Reduce a URL to its bare registrable-looking host. A website field arrives as a whole URL (``https://www.acme.com/about``) but the thing that joins, dedupes and enriches is ``acme.com``. Doing it with ``regex_extract`` means every caller hand-writes the same fragile pattern, so the parse lives here once and uses a real URL parser. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'url_domain' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableCompanyDomainOutput: Reduce a company's website URL to the company's own registrable domain. Three differences from ``url_domain``, which stays the generic read (a column of LinkedIn profile URLs legitimately reduces to ``linkedin.com`` there): Hosts that name a platform rather than the company (LinkedIn and Facebook pages, link aggregators, review sites, vendor partner directories) come out empty. A company whose only listed website is its LinkedIn page has no derivable domain, and an empty cell says so; ``linkedin.com`` is worse than empty because it joins, dedupes and syncs as if it were real. The result is the domain someone REGISTERED, not the bare host: a provider that lists ``careers.acme.com`` is describing ``acme.com``. A subdomain joins against nothing and sends an agent somewhere that often does not resolve. Page builders that give each customer their own label are the exception the Public Suffix List already encodes, so ``acme.wixsite.com`` survives whole rather than collapsing into ``wixsite.com``. ``company_name`` guards the case those two cannot: a directory listing reduces to the DIRECTORY owner's domain, so ``cloudpartners.transform.microsoft.com`` becomes ``microsoft.com``: right shape, wrong company, and nothing downstream can tell. Pointed at the column naming the employer, the domain is dropped when the two disagree. Optional: without it the other two rules still apply. - `company_name` union - … - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'company_domain' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableGetPathOutput: Read a dotted path out of an object- or list-valued cell. Object and list columns were storable but unreadable: nothing in the catalog could reach a field inside one, so an enrichment payload landed in a cell and stopped there. Segments index dicts by key and lists by integer position: ``employees.count``, ``emails.0.address``. ``output_type`` is declared rather than derived because a JSON path can land on anything, and the column's data type has to be known before a single row is evaluated. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'get_path' - `next` union - … - `output_type` 'string' | 'integer' | 'float' | 'boolean' | 'datetime' | 'date' | 'list' | 'dict': Type of a property. Used while creating/updating/deleting properties. - `path` string, required - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableFormatOutput: Build a string from a positional template and a list of arguments. ``concatenate`` joins whole columns with one separator, which cannot produce "Enterprise: Acme (12.4%)". Placeholders are positional only (``{0}``, ``{1}``) so the template stays data, not an expression language. Like ``concatenate`` this takes no ``source_column_id``: its inputs are its arguments, not the value flowing down the chain. - `arguments` union[] - … - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'format' - `next` union - … - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - `template` string, required - TableDateDiffOutput: The signed duration between this step's date and another date. ``date_arithmetic`` shifts a date by a CONSTANT amount, so the gap between two date columns had no expression. Positive when the step's own date is the later of the two. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'date_diff' - `next` union - … - `other` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - `unit` 'days' | 'hours' | 'minutes' | 'seconds' - TableKeywordsOutput: The most frequent meaningful words in a text or list value. Reads a body of text (a scraped page, a bio, a job description) and returns the words that carry its subject, ordered most frequent first. Stopwords ("the", "and", "with") are dropped: a frequency count that keeps them returns the same five words for every row and says nothing about any of them. Deterministic and pure: no model call, so a keyword column costs nothing and re-runs identically. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'keywords' - `limit` integer: How many keywords to keep, most frequent first. - `min_length` integer: Shortest word to consider; anything shorter is noise. - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableListFilterOutput: Keep only the list items whose field passes a test. An enrichment payload lands as a list of objects (every job opening, every funding round, every contact) and the row usually wants a subset of it: the engineering roles, the rounds after 2024, the contacts with an email. Without this the whole list is the only thing a cell can hold. ``field`` is a dotted path INSIDE each item (``location.country``); leaving it empty tests the item itself, which is what a list of plain strings needs. ``exists``/``missing`` ignore ``value``: they ask only whether the field is there. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `field` string: Dotted path inside each item; empty tests the item itself. - `function` 'list_filter' - `next` union - … - `operator` 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte' | 'contains' | 'not_contains' | 'exists' | 'missing' - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - `value` union - … - TableListSortOutput: Order a list, ascending or descending. ``list_unique`` and ``list_join`` both preserve whatever order the source happened to arrive in, which is fine until the cell is meant to be READ: a top-3 of anything, a chronological history, an alphabetised tag list. ``field`` names the dotted path to sort objects BY; empty sorts the items themselves. Values that cannot be compared with each other (a number next to a string) are ordered by type first, so the sort is total instead of raising on the row where the data is mixed. - `direction` 'asc' | 'desc' - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `field` string: Dotted path inside each item to sort by; empty sorts the items. - `function` 'list_sort' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableListIntersectOutput: The values this list shares with another: the overlap, in the first list's order. The scoring question every ICP fit column asks: which of the buyer's tags, technologies or keywords are ALSO on my target list. Doing it by hand meant one ``if_then_else`` per tag. ``other`` is a column holding the second list, or literal text split on ``separator``. Matching ignores case and surrounding spaces, because the two lists come from different sources and "Shopify " never equals "shopify" when it matters most. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'list_intersect' - `next` union - … - `other` union - … - `separator` string: Splits ``other`` when it is text rather than a list. - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableTextSimilarityOutput: How alike two pieces of text are, as a percentage. The dedupe and match question: is "Acme Inc." the same company as "Acme, Inc"? An exact comparison says no and a human says obviously yes, so the honest answer is a number the row can threshold on. Case and surrounding whitespace never count: they are formatting, not difference. 100 means identical after that normalisation, 0 means nothing in common. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'text_similarity' - `next` union - … - `other` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableDetectLanguageOutput: The language a piece of text is written in, as an ISO 639-1 code. Routes a row before anything expensive touches it: which sequence to enrol a lead into, which reviewer sees a scraped page, whether to translate at all. Script comes first (Cyrillic, Greek, Hebrew, Arabic, Han, kana and hangul each answer on their own) and Latin text is decided by the function words it uses. That is a heuristic, not a model: it is deterministic, free, and honest about not knowing, returning null when the text is too short or matches nothing. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'detect_language' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableScoreWordsOutput: Score text by the weighted words it contains. The rules half of lead scoring, without a model: "enterprise" is worth 3, "student" is worth -5, and the cell adds up whatever the row's text, tags or tech stack actually say. Expressing the same thing with ``if_then_else`` needs one step per word and runs out of chain depth at ten. Weights are a plain object: word or phrase to number. Matching is case-insensitive; a multi-word key matches as a phrase. ``count_repeats`` decides whether saying "enterprise" three times scores three times, which is the difference between weighing a claim and weighing a page. - `count_repeats` boolean: Score every occurrence rather than once per distinct word. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'score_words' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - `weights` object: Word or phrase to score, e.g. {'enterprise': 3, 'student': -5}. - TableHashOutput: Hash a value: the identifier ad platforms and clean rooms ask for. Uploading an audience means handing over hashed emails, never raw ones, and the hash has to be produced the way the platform specifies: lowercased and trimmed first, hex digest out. That normalisation is the part people get wrong by hand, so it happens here rather than in three chained steps. - `algorithm` 'sha256' | 'sha1' | 'md5' - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'hash' - `next` union - … - `normalize` boolean: Trim and lowercase before hashing, as ad platforms require. - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableUriEncodeOutput: Percent-encode a value so it survives being put in a URL. Every search-URL column builds the same thing (a query string with a company name in it) and every one of them breaks on the first ampersand or accent. Encoding belongs one step before the URL is assembled, not in a regex chain that handles the four characters someone remembered. ``component`` escapes everything reserved, which is what a query value needs; ``full`` leaves ``:/?#`` alone so an entire URL stays usable. Lists are encoded item by item. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'uri_encode' - `mode` 'component' | 'full' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableUrlValidOutput: Whether a value is a usable web address. The gate in front of every scrape, screenshot and HTTP column: a row whose "website" cell holds "n/a", "coming soon" or a bare company name should never spend a credit finding that out. True means the value parses as a host with a real-looking domain, not that the site answers. A formula cannot make a request, and pretending otherwise would be the one dishonest thing this function could do. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'url_valid' - `next` union - … - `require_scheme` boolean: Demand http:// or https://; off accepts a bare domain. - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableEmailPermutationsOutput: The candidate work-email addresses for a name at a domain. What a verifier needs to be pointed at: nine or so patterns companies actually use, in the order they are actually common, so the cheapest verification step has a list to work through instead of one guess. The piped value is the person's name: "Ada Lovelace", or a first name with ``last_name`` supplying the rest. Anything after the first and last token (middle names, suffixes) is ignored rather than permuted, which is what keeps the list nine long instead of ninety. - `domain` union - … - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'email_permutations' - `last_name` union - … - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableRoundRobinOutput: Assign each row to one of a list of owners, evenly. Lead routing, as a column: the rep, the region, the sending inbox. The piped value is the row's IDENTITY (its email, domain or id) and the owner is derived from a hash of it rather than from the row's position. That is a deliberate departure from a counter-based round robin, and it is the only version that behaves: re-running the column, adding rows above, or sorting the view all leave every existing row with the owner it already had. A counter reassigns half the table the first time anything moves, which in a CRM means the wrong rep gets the follow-up. - `assignees` string[]: The owners to distribute across, e.g. rep names or inboxes. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'round_robin' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - TableWeightedRoundRobinOutput: Assign each row to an owner, in proportion to each owner's share. The version real teams need: a senior rep takes three leads for every one a new hire gets, one region absorbs twice the volume of another. Shares are whole numbers and mean exactly what they look like: 3 and 1 is three quarters and one quarter. Stable per row for the same reason ``round_robin`` is: the owner comes from a hash of the row's identity, so nothing already assigned moves when the table grows or the view is sorted. Changing the SHARES does move rows, because that is what changing them means. - `failure_mode` 'pass_through_raw' | 'set_null' | 'static' | 'skip': What a formula cell resolves to when a step in its chain fails. Applies to the whole chain, read off the top-level function only. ``SKIP`` is equivalent to ``SET_NULL`` for table cells (a cell always has a stored slot, so there is nothing to skip). Kept for shape compatibility. - `fallback_value` union - … - `function` 'weighted_round_robin' - `next` union - … - `source_column_id` string, uuid, nullable - `source_step` integer, nullable: Read the result of an EARLIER step, by 1-based position, instead of the step immediately before. Lets a later step fork back to an intermediate value (splitting a URL once and then using both the raw split and something derived from it), which a strict pipeline cannot express. Ignored when source_column_id is set (a column wins over a step), and ignored by functions that read their arguments rather than the piped value. None reads the previous step. - `weights` object: Owner to share, e.g. {'ada': 3, 'grace': 1}. - `kind` 'formula' - EnrichmentColumnDefinitionOutput: Definition of an enrichment column: an external action run once per row. The action is named by its registry key; everything the action needs to run (its prompt, model, output shape, settings) grows on this member rather than on the column row, so the definition-version snapshot covers all of it. - `action_key` string, required: The enrichment action's registry key; validated against the catalog. - `action_settings` union: Action-specific configuration; its kind must match the action key. None uses the action's defaults. - UseAISettings: Settings for the Use AI action, in both of its modes. ONE action covers both "answer from what the table already knows" and "go and find out", because from the author's seat they are the same request with a different reach, and splitting them made people pick the wrong one. ``web_research`` is that reach, and it is what selects the mode: off runs a single completion over the row, on runs the bounded research agent (search, map, scrape, cite). It defaults OFF. The cheap mode is the common one, a web run costs several times more per row, and a toggle that silently spends is the wrong default even when research is the better answer. ``context`` is "Provide context for task"; ``examples`` are the few-shot pairs that show the model what a good response looks like. Both are hard-capped so a pathological configuration cannot blow up the request or the cost. ``use_row_context`` defaults ON, and a column stored before the field existed decodes to that same default (deliberately), so an author who never thought to reference a column still gets a model that can see the row. Turning it off narrows the run back to what the prompt itself names. ``context_column_ids`` narrows ``use_row_context`` from the whole row to a chosen subset: None (the default, and what every column stored before the field existed decodes to) keeps every column ("Entire row" in the editor) while a list holds exactly the columns the author picked. It means nothing while ``use_row_context`` is off. The remaining fields only bite in web mode. They are held on this one model rather than a nested "agent settings" object so that flipping ``web_research`` never migrates a stored payload: a column that has been both ways keeps whatever research scope it was last given. - `context` string, nullable - `context_column_ids` string[], nullable: The columns folded in when use_row_context is on; None means every column ("Entire row"). Stored by identity so renames are safe, but deliberately NOT a dependency: a listed column that is later deleted simply stops appearing in the context rather than blocking the delete or joining the recompute graph. - `examples` UseAIExample[] - … - `find_work_email` boolean: Whether the model may buy a work email from the product's data suppliers while it researches, paid from the run's research budget. Off by default. For a column linked to a saved agent, the agent's own switch decides and this one is ignored. - `kind` 'use_ai' - `read_linkedin_profile` boolean: Whether the model may read a LinkedIn profile through the product's data suppliers while it researches, paid from the run's research budget. Off by default; ignored on a column linked to a saved agent. - `saved_agent_id` string, uuid, nullable: Web research only: an org-level saved agent whose persona (effort, context) replaces this column's own. - `starting_url_column_id` string, uuid, nullable: Web research only: a column whose per-row value seeds the research. Stored by identity, so renames are safe. - `stay_on_domain` boolean: Web research only: confine every site-targeting tool to the starting URL's domain. - `use_business_context` boolean: Whether the org's AI business context is folded into the run's standing context. Off by default and folded at run time: the org edits its context in one place and every column that opted in follows, with no stored copy to go stale. - `use_row_context` boolean: Whether the rest of this row's columns are folded in as context, on top of whatever the prompt itself references. - `web_research` boolean: Whether the model may research the web. On turns this column into a bounded research agent that searches, reads pages and cites its sources; off answers from the row and the model's own knowledge. Off by default: a web run costs several times more per row. - BuiltinAgentSettings: Settings for a built-in agent column: which columns supply which facts. The same contract an :class:`EnrichmentSettings` column carries, and for the same reason. A built-in agent is configured entirely server-side (prompt, model, reach and output shape all live on the agent row), so the ONE thing a column decides is where each declared input comes from. Those bound cells are also all the agent sees. Its predecessor folded in the whole row (optionally narrowed to a chosen subset), which made the same agent read a different question on every table, cost the most on the widest ones, and quietly answer from whatever cell happened to sit beside the one it wanted. Now an input reaches the prompt only by being declared and bound, keyed by the agent's CANONICAL name (``domain``, ``full_name``), so renaming a column changes nothing here. A stored binding whose declaration is gone is ignored rather than resurrecting a fact nobody asked for. - `input_bindings` object: Declared input name → the column that supplies it. - `kind` 'builtin' - AgentSettings: Settings for the Agent web-research action. ``starting_url_column_id`` binds a column whose per-row value seeds the research (stored by identity, like prompt references, so renames are safe and deletes are detectable). ``stay_on_domain`` confines every tool that targets a site to that URL's domain and therefore requires a starting URL to scope to. The two tool toggles are split by what a tool RETURNS, not by how many calls it makes: ``allow_search`` governs discovery (web search and site mapping, which return URLs and snippets), ``allow_fetch`` governs content reads (scraping one page and crawling several). ``use_row_context`` defaults ON, and a column stored before the field existed decodes to that same default: an investigation whose subject is named in a column the prompt never mentions is the ordinary case, not the exception. ``context`` is deliberately uncapped here. This shape is the run-time handoff into the research loop, and by the time it is built the context is ASSEMBLED text: the column's own standing context with the org's business context folded onto it. The length cap belongs on what an author types, and it lives there: on ``UseAISettings.context``, checked when the column is saved. Re-checking the assembled string here failed every cell of a column that was perfectly valid when saved, purely because the org had written a thorough business context. - `allow_fetch` boolean: Tool toggle: whether the agent may scrape pages and crawl sites. - `allow_search` boolean: Tool toggle: whether the agent may search the web and map sites. - `context` string, nullable - `effort` 'low' | 'standard' | 'high': How hard the Agent works on each row. Named levels rather than raw step counts: the level is the user-facing contract, and what each level buys (step and page budgets) is a product decision the loop maps internally. Re-tuning budgets never invalidates stored columns. - `kind` 'agent' - `saved_agent_id` string, uuid, nullable: An org-level saved agent this column's settings derive from. - `starting_url_column_id` string, uuid, nullable: A column whose per-row value is the research's starting URL. - `stay_on_domain` boolean: Whether site-targeting tools are confined to the starting URL's domain. - `use_row_context` boolean: Whether the rest of this row's columns are folded in as context, on top of whatever the prompt itself references. - DevEchoSettings: Settings for the development-only echo action. The delay is configurable so pipeline tests can run fast; the action's display name promises one second, which is the default. - `delay_ms` integer - `kind` 'dev_echo' - DevFlakySettings: Settings for the development-only intermittent-failure action. Failures are deterministic PER ROW: whether a given row fails is a pure function of the seed and the row's identity, so a failing row fails identically on every run, which is what makes retry policy, partial failure and the errored re-run scope testable at all. Changing the seed changes WHICH rows fail. - `error_class` 'timeout' | 'rate_limited' | 'quota_exhausted' | 'provider_error' | 'network' | 'schema_violation' | 'refused' | 'invalid_input' | 'no_data' | 'enrichment_failed' | 'unexpected': Machine-readable classification of a failed enrichment cell. The class decides everything downstream: whether the executor retries (transient classes) or gives up (terminal ones), what the cell tooltip names, and whether the failure is free. Errors never charge, but only a classified error can prove which kind it was. A clean no-answer (no_data) is free for a lookup; an AI column's is charged what it used. - `failure_rate` number: The fraction of rows that fail. - `kind` 'dev_flaky' - `seed` integer, nullable: Varies which rows fail; None derives purely from row identity. - EnrichmentSettings: Settings for a curated enrichment: which columns supply which facts. The whole configuration of an enrichment column, and deliberately tiny. Its predecessor stored the entire fallback chain here: an ordered list of vendor operations, each with its own input mapping, assembled by the customer in the editor. That made the supply chain part of the customer's data: visible in the API, editable by hand, and frozen at the moment they saved it, so improving a chain meant migrating every column that had copied it. Now the chain lives in the catalog and is resolved per run. A column stores only the outcome it wants (the action key) and where its inputs come from, keyed by CANONICAL name (``full_name``, ``company_domain``), never by whatever the vendor at the front of today's chain happens to call them. Adding a supplier, reordering the chain or renaming a vendor's field changes nothing here. - `input_bindings` object: Canonical input name → the column that supplies it. - `kind` 'enrichment' - `second_check` boolean: Whether an answer the enrichment marks as worth a second look (Verify email's catch-all) goes on to the next supplier instead of ending the lookup. Kept when no later supplier gives a definite answer. A second check that answers is charged as one more lookup. Only offered where the enrichment has such answers. - ProviderSettings: Settings for an integration-provider enrichment action. A provider action's inputs are STRUCTURED (named fields the provider's operation declares: full name, company domain, …), not a prompt. Each binding maps one declared input name to the column whose per-row value feeds it. Required inputs without a binding block the save; bound-but-empty required inputs skip the row at run time, before any provider call. - `input_bindings` object, required: Declared operation input name → source column id. - `kind` 'provider' - HttpApiSettingsOutput: Settings for the HTTP API action: one request per row, described here. The URL is the column's prompt, so it can carry ``{{column}}`` tokens the same way every other prompt does and gets the same picker. Everything a URL cannot express lives here, and the body and header values carry column references of the same kind (see ``HttpRequestTemplate``). ``json_path`` is what turns a response into a CELL: an API answers with a document, and the column usually wants one value out of it. Dotted, with integer segments indexing arrays: ``data.0.email``. Left empty the whole decoded body lands in the cell. - `body` EnrichmentPromptTemplate: The persisted prompt: an ordered mix of text and column references. Resolution to a per-row string happens at run time; the segment list is the single source of truth the editor renders pills from and the executor substitutes values into. - … - `headers` object: Sent with every row's request, e.g. an Authorization header. Each value is a template like the body: text and column references, or a string in which {{Column name}} stands for that column's value in the row. - `json_path` string: Dotted path to the value to keep, e.g. data.0.email. - `kind` 'http_api' - `method` 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' - HttpApiJwtSettingsOutput: Settings for the JWT-authenticated HTTP API action. Same request as :class:`HttpApiSettings` with the one thing that cannot be hand-written in a header: a JWT minted per run from the caller's own secret, so the token in flight is short-lived instead of a permanent credential pasted into a header field. - `body` EnrichmentPromptTemplate: The persisted prompt: an ordered mix of text and column references. Resolution to a per-row string happens at run time; the segment list is the single source of truth the editor renders pills from and the executor substitutes values into. - … - `headers` object: Sent with every row's request, e.g. an Authorization header. Each value is a template like the body: text and column references, or a string in which {{Column name}} stands for that column's value in the row. - `json_path` string - `jwt_claims` object: Claims to sign, e.g. {'iss': 'oneprofile'}. - `jwt_header` string: Which header carries the token. - `jwt_prefix` string: Prefix in front of the token, e.g. 'Bearer '. - `jwt_secret` string: The shared secret the token is signed with (HS256). - `jwt_ttl_seconds` integer: How long each minted token stays valid. - `kind` 'http_api_jwt' - `method` 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' - LookupSettings: Settings for the cross-table lookup actions. Columns are named rather than identified: whoever configures this is reading the other table's headers, and a name that stops resolving is a message worth showing rather than a silently blank column. - `kind` 'lookup' - `match_column` string: The column in that table whose value must equal this row's value. - `return_column` string: The column to bring back; empty returns the whole row. - `table_id` string, uuid, nullable: The other table this column reads. - IntegrationLookupSettings: Settings for the connected-integration record lookup: which record, where. The identity VALUE is not here. It arrives per row through the action's bound input column, like ``resolve_hostname``'s hostname. What a column fixes is the address: which of the org's connections to ask (``integration_id``: an ID, not a name, because two connections to one system are two different destinations), which record type, and which of the SDK's declared identity fields the value keys on. All three are plain identifiers rather than integration-stratum types on purpose: this module sits in the table stratum, which may not import the integration domain, so the executor (which lives above both) resolves and validates them at run time. ``identity_field`` defaults empty so a half-configured draft can be saved; the executor skips such a column rather than guessing a key. - `identity_field` string: The identity field the bound value keys on, e.g. 'id' or 'email'. - `integration_id` string, uuid, nullable: The org's connection to read from. - `kind` 'integration_lookup' - `record_type` string: The record type to fetch, e.g. 'user' or 'organization'. - SendToTableSettings: Settings for the send-to-table action: where the row goes. - `kind` 'send_to_table' - `table_id` string, uuid, nullable: The table each row is appended to. - `target_column` string: The column in that table this row's value is written to. - RepDataSettings: Settings for the rep-data action: which part of the identity to return. - `field` 'email_address' | 'display_name' | 'first_name' | 'last_name' | 'signature' | 'all' - `kind` 'rep_data' - OutreachActivitySettings: Settings for the outreach-activity action: which signal to return. - `field` 'summary' | 'in_live_sequence' | 'live_sequences' | 'reply_threads' | 'total_matching_threads' | 'last_reply_at' | 'bounced' - `kind` 'outreach_activity' - `kind` 'enrichment' - `model_key` string, nullable: The user-facing model catalog key this column runs on; None uses the action's default model. - `output` union: The declared result shape: named typed fields, or a raw strict-mode JSON schema in the advanced mode. The column's own type derives from it: the single field's type, or a structured object for multi-field outputs. - EnrichmentOutputFieldsOutput: The fields-mode output shape: repeatable named typed fields. The default is Clay's: one text field named ``response``. - `fields` EnrichmentOutputField[] - … - `mode` 'fields' - EnrichmentOutputRawSchema: The advanced output shape: a raw strict-mode JSON schema, verbatim. Held to every strict-mode constraint at SAVE time by the service layer. The shape is stored exactly as authored, and validation failures name the exact violated rule rather than surfacing at run time. - `json_schema` object, required: A strict-mode JSON schema with an object root. - `mode` 'json_schema' - `prompt` EnrichmentPromptTemplate: The persisted prompt: an ordered mix of text and column references. Resolution to a per-row string happens at run time; the segment list is the single source of truth the editor renders pills from and the executor substitutes values into. - `format` 'plain' | 'markdown': How the editor reads text segments: 'markdown' renders them as markdown source, 'plain' verbatim. Templates saved before the field existed carry no value and default to 'plain', the safe reading. Purely editor metadata: run-time resolution concatenates text segments identically either way. - `segments` union[] - union - … - SourceColumnDefinition: Definition of a source column: one imported record, held verbatim. Carries no configuration of its own. What to import, from where, and how often lives on the table's ``table_import_integration`` row, which points back here through ``object_column_id``; duplicating any of it on the column would only create somewhere for the two to disagree. - `kind` 'source' - ExportColumnDefinitionOutput: Definition of an export column: one row pushed to a connected destination. The cell holds the RECEIPT of that push (status, the destination record id, when it happened), never the row's own data (see ``TableColumnKind.EXPORT``). The destination integration is named by id plus a denormalized ``integration_type``, for the same reason ``table_import_integration`` denormalizes it: rendering a column must not need a join into the integration stratum. - `action` 'create' | 'update' | 'upsert': What one export cell does at the destination. Its own vocabulary, not a copy of the integration stratum's ``WriteBehavior``: the members and their values differ, and ``table_export_integration`` translates between the two at the seam (``_WRITE_BEHAVIOR_TO_EXPORT_ACTION``). Mirroring has no member here because it deletes and recreates the whole destination object, which is a whole-object concern rather than a per-row one. - `batched` boolean: Write rows in destination-sized batches instead of one at a time. Faster, at a cost: the destination reports batch-level results, so receipts say 'pushed' rather than created-versus-updated, and a burst of writes can overwhelm automations attached to the destination. Off by default for that reason. - `fields` ExportFieldMappingOutput[], required: The destination properties written, in mapping order. - `destination_field` string, required - `property_type` 'string' | 'integer' | 'float' | 'boolean' | 'datetime' | 'date' | 'list' | 'dict': Type of a property. Used while creating/updating/deleting properties. - `skip_if_blank` boolean, nullable: Per-field override of the definition's ``remove_blanks``; None inherits it. Set False on one field to send an explicit blank that clears a destination value. - `source` ExportValueSourceOutput, required: The per-row value written into ONE destination field. ``template`` reuses the enrichment prompt format verbatim: ordered text and column-reference segments, references stored by column identity so a rename can never silently repoint a mapping and a delete is detectable. PASSTHROUGH RULE: when the template is exactly one whole-cell column reference (one segment, no path), the RAW stored cell value is sent, not its rendered text, so a LIST cell reaches a multi-select property as a list and a NUMBER cell as a number. Any other shape (text around a reference, two references, a path) renders to a string, because concatenation only has a string answer. - `template` EnrichmentPromptTemplate: The persisted prompt: an ordered mix of text and column references. Resolution to a per-row string happens at run time; the segment list is the single source of truth the editor renders pills from and the executor substitutes values into. - … - `identity` ExportIdentityMappingOutput[]: The destination fields the row may be identified by: the match key that decides create-versus-update, required for every action. More than one is an ordered FALLBACK, not a composite key: the first entry that renders a non-empty value for a row is the one that row is matched on, and the rest are not consulted. Order them most to least trustworthy ('match on work email, failing that personal email'). Matching on two fields at once is not offered because the destination contract takes a single identity field. - `destination_field` string, required - `source` ExportValueSourceOutput, required: The per-row value written into ONE destination field. ``template`` reuses the enrichment prompt format verbatim: ordered text and column-reference segments, references stored by column identity so a rename can never silently repoint a mapping and a delete is detectable. PASSTHROUGH RULE: when the template is exactly one whole-cell column reference (one segment, no path), the RAW stored cell value is sent, not its rendered text, so a LIST cell reaches a multi-select property as a list and a NUMBER cell as a number. Any other shape (text around a reference, two references, a path) renders to a string, because concatenation only has a string answer. - `template` EnrichmentPromptTemplate: The persisted prompt: an ordered mix of text and column references. Resolution to a per-row string happens at run time; the segment list is the single source of truth the editor renders pills from and the executor substitutes values into. - … - `integration_id` string, uuid, required: The connected DESTINATION integration this column writes to. - `integration_type` string, required: Provider slug, denormalized so display needs no cross-stratum join. - `kind` 'export' - `only_on_change` boolean: Skip a row whose outgoing payload is identical to the one last successfully written. The row-level idempotency knob; off, every run re-writes every row. - `record_type` string, required: Which destination object to write: 'contacts', 'deals', a custom type. - `remove_blanks` boolean: Drop fields whose rendered value is empty from the outgoing payload rather than sending a blank. Off, a blank clears the destination value: a deliberate act, not a default. - `retry` ExportRetryPolicy: One export column's reliability contract with its destination. Defaults are chosen so the common case needs no configuration: retry the errors worth retrying (rate limits, server errors, network failures) a few times, honour the destination's own Retry-After when it names one, and otherwise write as fast as the destination accepts. - `max_retries` integer: Retry attempts per row beyond the first, when retrying at all. - `requests_per_minute` integer, nullable: Custom ceiling on write calls per minute. None means the destination's own pace. Its live rate-limit answers are honoured either way. - `retry_on_failure` boolean: Retry a row whose failure is retryable: rate limits, server errors, network failures. Bad requests never retry: the same payload would fail the same way. - `timeout_seconds` integer, nullable: Response timeout per destination request. None uses the platform default. - `typecast` boolean: Coerce each rendered value into the destination property's declared type before writing. Off, values are sent verbatim and the destination's own coercion applies. - `update_mode` 'replace' | 'patch' | 'set_once': replace overwrites the whole record, patch touches only the mapped fields, set_once writes only where the destination is empty. Degrades to patch at run time when the destination does not declare replace, the same fallback the sync export makes. - SequenceColumnDefinition: Definition of a sequence column: one contact's live cadence state, or what it sent them. The referenced sequence is denormalized by id only; rendering needs nothing beyond the cell's own value, and the outreach stratum owns the write path (see ``TableColumnKind.SEQUENCE``). - `content` 'status' | 'messages': Which of a sequence's two mirrors a SEQUENCE column holds. ``STATUS`` is one short sentence about where the contact stands. ``MESSAGES`` is a list with one object per email or LinkedIn message the sequence sent them, which formulas, AI columns and exports may read. - `kind` 'sequence' - `sequence_id` string, uuid, required: The sequence whose enrolment status this column mirrors. - `description` string, nullable, required: Author's note; null when unset. - `display_name` string, required - `holds` string, required: What this column holds, in words ("An email address", "A date"). Stands in for an example value: a template never carries one of the owner's cells. - `kind` 'manual' | 'formula' | 'enrichment' | 'source' | 'export' | 'sequence', required: Kind of a table column. ``MANUAL`` cells are user-editable; ``FORMULA`` cells are a pure computed chain over other columns; ``ENRICHMENT`` cells are produced by an external action (an AI model, a research agent) run once per row. Formula and enrichment cells are both computed (read-only in the grid) but only enrichment work leaves the process and costs credits. ``SOURCE`` cells hold one imported record verbatim, written only by the table's import source. Like ``MANUAL`` it is an externally-written leaf rather than a computed node (it joins no run plan and derives from no other column), but unlike ``MANUAL`` nobody may edit or retype it: the whole point is that a refresh can overwrite it wholesale, and every ``get_path`` column promoted off it reads paths that only survive while its shape does. ``EXPORT`` cells hold the RECEIPT of pushing the row to a connected destination (status, the destination record id, when it happened), never the row's own data. The mirror image of ``SOURCE``: where a source column is an externally-written leaf, an export column is an externally-READ leaf. It joins the run plan like a computed column (its mappings are dependencies, so a changed input re-pushes) but nothing may depend on it in turn, nobody may edit it (a hand-edited receipt would silently pin the row out of future pushes), and re-running it means "push again", not "re-answer". ``SEQUENCE`` cells hold a contact's live status in an email sequence, or the messages it sent them, written by the outreach send engine and nobody else: an externally-written leaf with no run plan, no dependencies, no user edits, no retyping. A status column, like ``EXPORT`` receipts, may not be referenced in a formula: the status only exists to be looked at, never derived from. A messages column may, the way a ``SOURCE`` record may: the engine requests a run of its dependents whenever it rewrites a cell. The columns are created by the sequence that targets the table, not from the add-column catalog. - `sample_value` unknown - `description` string, nullable, required - `id` string, uuid, required - `name` string, required ## Other responses - `401`: Unauthorized - `403`: Forbidden - `404`: Table not found - `422`: Invalid request made to the API. - `500`: Internal server error. - `502`: Bad gateway error. - `503`: Service unavailable. --- [API](https://skmtc.dev/getoneprofile/apis/api-reference-oneprofile.md) · [All operations](https://skmtc.dev/getoneprofile/apis/api-reference-oneprofile/llms.txt) · [OpenAPI document](https://skmtc.dev/getoneprofile/apis/api-reference-oneprofile/revisions/dc5ac3c84444?raw)