Field Type Reference

The Activity Form Builder supports a rich set of field types. Each type is designed for a specific kind of input and carries its own configuration options in the Property Panel.

This page documents every available field type, with deep-dive sections for Mappable Field and Remote Select — the two most powerful and commonly misunderstood types.

Quick Reference

Field Type	Use When You Need…
`text`	A single-line text input
`password`	A masked text input for secrets
`number`	A numeric input
`checkBox`	A boolean toggle (checkbox style)
`SwitchSelector`	A boolean toggle (switch/toggle style)
`RadioButton`	A group of mutually exclusive options
`select`	A single-choice dropdown with fixed options
`multiSelect`	A multi-choice dropdown shown as tags
`multiSelectWithoutTags`	A multi-choice dropdown without tag UI
`remoteSelect`	A dropdown whose options are fetched dynamically from an API
`mappableField`	A field whose value can be bound to a workflow variable, resource, or schema property
`DndField`	A drag-and-drop binding target for global variables and resources
`CodeInput`	A code editor with syntax highlighting
`table`	A repeatable table of rows with defined columns
`UploadSchema`	A JSON Schema upload and editor
`MappingInput`	An input mapping/transformation UI
`MappingOutput`	An output mapping/transformation UI
`ConditionExpression`	A visual condition / expression builder
`FilterGroups`	A filter group builder (AND/OR conditions)
`AggregationTable`	A SQL-style aggregation table
`FixedWidthTable`	A fixed-width table display
`Context`	A context variable picker
`WorkflowAttributes`	A workflow attribute selector
`GroupActivitySelector`	A picker for the activity's group
`TimeZoneSelector`	A timezone picker
`RunIntervalSelector`	A cron expression selector
`DateSelector`	A date picker
`TimeSelector`	A time picker
`ScopesTable`	An OAuth scopes table
`Button`	An action button
`prefixedText`	A text input with a fixed prefix
`AlertMsg`	A read-only alert/info message
`DisplayComponent`	A read-only display element

Mappable Field

A Mappable Field is a text-based input that can optionally be bound to a data source — a workflow global variable, a resource reference, or a schema property. When bound, the field value is resolved dynamically at runtime rather than being typed in manually.

This is the field type to use for any value that might change per workflow run, per tenant, or per environment — such as API keys, IDs, tenant codes, or dynamic URLs.

How It Works

In its default state a Mappable Field looks and behaves like a plain text input. The binding capability is unlocked by setting allowGlobalVariable or allowResource to true, which wraps the field in a drag-and-drop zone. Users can then drag a variable or resource from the workflow sidebar onto the field to bind it.

At runtime, the platform resolves the bound reference and substitutes the real value before the activity executes.

Configuration Properties

Property	Type	Description
Title	string	Label shown above the field.
Key	string	Internal schema key for this field.
Required	boolean	Whether a value or binding is required.
Placeholder	string	Ghost text for the unbound state.
Info Message	string	Tooltip text (ℹ icon).
Mapped To	string	Declares that this field is a binding point for a specific schema path (see below).
Hide While Mapping	boolean	When `true`, this property is excluded from the activity's output schema when the field is bound. Prevents duplication in the mapper.
Allow Global Variable	boolean	Enables drag-and-drop binding from workflow global variables. Uses the `$:` prefix internally.
Allow Resource	boolean	Enables drag-and-drop binding from deployed Managed Resources. Uses the `ref:` prefix internally.
Accepts Dynamic Values Of Type	string[]	Filters which resource types can be dropped onto this field (e.g., `["OAuth", "SFTP"]`).
Data Type	`string` \| `integer` \| `number` \| `boolean`	Changes the rendered input: `boolean` renders a toggle switch; `number`/`integer` renders a numeric input; `string` renders a text input.

The `mappedTo` Property

mappedTo declares which part of the activity's API schema this field controls. The format is:

<table>/<fieldName>

Examples:

`mappedTo` value	What it targets
`header/Authorization`	The `Authorization` HTTP header
`queryParams/userId`	The `userId` query parameter
`body/customerId`	The `customerId` property in the request body
`path/orderId`	The `{orderId}` path parameter

Internally, Koodisi converts this to the JSONPath $.properties.<table>.properties.<fieldName> when building the input schema.

`hideFieldWhileMapping`

When a Mappable Field has a binding set and hideFieldWhileMapping is true, the property is removed from the activity's output schema during schema transformation. This prevents a bound field from appearing as a redundant, always-empty property in the mapper.

Set this to true for fields that represent parameters injected at runtime (e.g., auth tokens, tenant IDs) that should never be manually wired in the workflow mapper.

When to Use Mappable Field

HTTP header values (e.g., Authorization, X-Tenant-ID)
URL path or query parameters that vary per run
Credentials or tokens supplied from a Managed Resource
Any field where the value comes from upstream workflow data

Remote Select

A Remote Select is a dropdown whose options are loaded lazily from an API — they are not hardcoded in the form definition. Options are fetched the first time the user opens the dropdown, using a JavaScript code snippet you provide.

How It Works

The user opens the dropdown.
Koodisi runs your fetchCode snippet in a sandboxed JavaScript environment.
The snippet calls an API (using fetch or a platform helper) and returns an array of { id, name } objects.
The dropdown displays the returned options.
The selected value is encoded as remote:{"id":"<rawValue>","name":"<label>"} and stored in the form.

The platform automatically decodes this encoded value when passing data to the activity's actual API call — your downstream code always receives the raw id.

Configuration Properties

Property	Type	Description
Title	string	Label shown above the field.
Key	string	Internal schema key for this field.
Required	boolean	Whether a selection is required.
Placeholder	string	Text shown before an option is selected.
Fetch Code	string	JavaScript code executed to retrieve options (see below).
Auth Config — Header Name	string	The name of the HTTP header used for auth (e.g., `Authorization`).
Auth Config — Scheme	string	The auth scheme prepended to the token (e.g., `Bearer`).
Depends On	string	The `key` of another field this dropdown depends on. When that field's value changes, the cached options are cleared and re-fetched on next open.
Mapped To	string	Same as Mappable Field's `mappedTo` — links the selected value to a schema path.
Hide While Mapping	boolean	Same as Mappable Field's `hideFieldWhileMapping`.

Writing `fetchCode`

The fetchCode snippet is plain JavaScript executed in a secure sandbox. It has access to:

formValues — the current values of all other fields in the form (useful for dependent fetches).
authToken — the resolved auth token if authConfig is set.
fetch — the standard Web Fetch API.

The snippet must return (or resolve to) an array of objects with at least id and name properties:

// Example: fetch a list of Salesforce objects
const response = await fetch("https://myapi.example.com/objects", {
  headers: {
    Authorization: `Bearer ${authToken}`,
  },
});
const data = await response.json();
return data.records.map((r) => ({ id: r.Id, name: r.Name }));

For a field that depends on a parent selection (via dependsOn):

// parentField value is available in formValues
const parentId = formValues.parentCategory;
const response = await fetch(`https://myapi.example.com/subcategories/${parentId}`);
const data = await response.json();
return data.map((item) => ({ id: item.code, name: item.label }));

Value Encoding

The stored value format is:

remote:{"id":"<rawId>","name":"<displayLabel>"}

Example: If a user selects "Acme Corp" (ID acme-001) from the dropdown, the form stores:

remote:{"id":"acme-001","name":"Acme Corp"}

When the form is submitted or the activity runs, the platform strips the remote: wrapper and passes the raw ID to the API. The label is preserved so the form can display the previously selected value even before options are re-fetched.

Dependency Cascade

Setting dependsOn to another field's key creates a parent-child relationship:

When the parent field changes, the Remote Select clears its cached options and its current selection.
The next time the user opens the dropdown, fresh options are fetched based on the new parent value.
On initial form load (hydrating a saved value), the cascade is suppressed so the existing selection is preserved.

When to Use Remote Select

Selecting a record from a CRM or ERP (Salesforce object, HubSpot contact, etc.)
Picking from a list that changes frequently (e.g., live campaigns, active projects)
Chained dropdowns where the second list depends on the first selection
Any field where options cannot be known at activity-design time

Other Field Types

Basic Inputs

text — Single-line text input. Use for free-form string values such as names, URLs, and identifiers.

password — Masked text input. Use for secrets, API keys, or passwords that should not be visible on screen.

number — Numeric input. Accepts integers and decimals. Use for timeouts, counts, and thresholds.

checkBox — Boolean checkbox. Displays a labelled checkbox. Use for simple on/off toggles.

SwitchSelector — Boolean toggle switch. Visually distinct from a checkbox; preferred for settings that feel like on/off states (e.g., "Enable caching", "Active").

RadioButton — A group of mutually exclusive options rendered as radio buttons. Suitable when the user must pick exactly one value from a small fixed set (3–5 options).

prefixedText — A text input with a fixed, non-editable prefix attached to the left. Useful for path segments or namespaced identifiers (e.g., PREFIX_<user input>).

Dropdowns

select — Single-choice dropdown with a fixed list of options defined at design time. Use when the set of valid values is known and small.

multiSelect — Multi-choice dropdown. Selected values are displayed as removable tags. Use for selecting multiple items from a fixed set.

multiSelectWithoutTags — Same as multiSelect but without the tag display. Selected values are shown as a comma-separated list.

Code and Schema

CodeInput — A code editor with syntax highlighting. Supports JavaScript and other languages. Use for expressions, scripts, or custom transformation logic.

UploadSchema — A combined JSON Schema upload + inline editor. Users can paste a schema directly or upload a JSON file. Used for defining structured input/output shapes.

Mapping

MappingInput — An input mapping configuration UI. Allows users to define how incoming workflow data is mapped to the activity's expected input structure.

MappingOutput — An output mapping configuration UI. Allows users to define how the activity's output is mapped back into the workflow context.

DndField — A drag-and-drop binding field. Similar to a Mappable Field but without a text fallback — the value can only be set by dragging a variable or resource onto it.

Logic and Conditions

ConditionExpression — A visual builder for a single condition expression (e.g., value > 10 AND status === "active").

FilterGroups — A builder for nested AND/OR filter groups, similar to query builders in BI tools. Produces a structured condition tree.

Tables

table — A repeatable table where each row contains a set of defined sub-fields (columns). Users can add, remove, and reorder rows. Use for key-value pairs, header lists, or any variable-length structured data.

AggregationTable — A specialised table for defining SQL-style aggregations (GROUP BY, SUM, COUNT, etc.).

FixedWidthTable — A read-only or lightly editable fixed-column table. Used when the number and structure of columns is fixed at design time.

ScopesTable — A specialised table for defining OAuth scopes (scope ID, description, default flag). Used in Resource Template configuration.

Date and Time

DateSelector — A calendar date picker.

TimeSelector — A time picker (hours/minutes).

TimeZoneSelector — A searchable timezone picker (e.g., America/New_York).

RunIntervalSelector — A cron expression builder. Generates a cron string (e.g., 0 9 * * 1-5) from a visual UI. Used for scheduling activities.

Workflow Integration

Context — A picker for workflow context variables. Allows the user to select a key from the current workflow's context object.

WorkflowAttributes — A picker for workflow-level attributes and metadata.

GroupActivitySelector — A dropdown for selecting the activity group this activity belongs to (used in metadata configuration).

Display Only

AlertMsg — A static alert or informational message displayed inside the form. Not an input — used to surface warnings, notes, or instructions to the user.

DisplayComponent — A generic read-only display element. Renders a computed or static value without allowing user edits.

Button — An action button that triggers an operation (e.g., "Test Connection", "Fetch Schema") without submitting the form.

Quick Reference​

Mappable Field​

How It Works​

Configuration Properties​

The mappedTo Property​

hideFieldWhileMapping​

When to Use Mappable Field​

Remote Select​

How It Works​

Configuration Properties​

Writing fetchCode​

Value Encoding​

Dependency Cascade​

When to Use Remote Select​

Other Field Types​

Basic Inputs​

Dropdowns​

Code and Schema​

Mapping​

Logic and Conditions​

Tables​

Date and Time​

Workflow Integration​

Display Only​

Quick Reference

Mappable Field

How It Works

Configuration Properties

The `mappedTo` Property

`hideFieldWhileMapping`

When to Use Mappable Field

Remote Select

How It Works

Configuration Properties

Writing `fetchCode`

Value Encoding

Dependency Cascade

When to Use Remote Select

Other Field Types

Basic Inputs

Dropdowns

Code and Schema

Mapping

Logic and Conditions

Tables

Date and Time

Workflow Integration

Display Only