@celigo/api-specs 0.2.171 → 0.2.172

package/dist/tool.yml

@@ -3578,7 +3578,11 @@ components:
 
             **Simple Types (direct value mapping)**
             - `string`: Text values, converts other types to string representation
-            - `number`: Numeric values, attempts conversion from strings
+            - `number`: Numeric values. Converts a numeric string (`"24"` → `24`,
+              `"007"` → `7`) and leaves the field out for an empty string; a value
+              holding letters or a thousands separator (`"1,250.00"`) fails the
+              record with `non_parsable_string` (`<generate>: String contains alpha
+              characters`)
             - `boolean`: True/false values, converts truthy/falsy values
 
             Dates are represented as strings — use `string` for date fields and
@@ -3621,8 +3625,14 @@ components:
             - |-
               Missing `dataType` is rejected at save with validation error
               `[mandatory_destination_datatype] Destination datatype is a
-              required field.` When in doubt, use `"string"` — it accepts
-              any source value and the runtime will coerce it.
+              required field.`
+            - |-
+              Give each row the type the destination field expects; `"string"` is
+              not a safe default. It accepts any source value, but sends a numeric
+              source as text (`"24"`), which a destination that checks JSON types
+              refuses. Map numeric destination fields as `number`, which fails a
+              record (`non_parsable_string`) only when the value holds letters or a
+              thousands separator.
           enum:
             - string
             - number
@@ -3634,7 +3644,7 @@ components:
             - objectarray
           x-enumDescriptions:
             string: Text values; converts other types to their string representation.
-            number: Numeric values; attempts conversion from strings.
+            number: Numeric values; converts numeric strings, and fails the record (`non_parsable_string`) on letters or a thousands separator.
             boolean: True/false values; converts truthy/falsy values.
             object: Nested object built from child `mappings`, or copied whole with `extract` (not both).
             stringarray: Array of string values.
@@ -4662,7 +4672,11 @@ components:
 
               **Simple Types (direct value mapping)**
               - `string`: Text values, converts other types to string representation
-              - `number`: Numeric values, attempts conversion from strings
+              - `number`: Numeric values. Converts a numeric string (`"24"` → `24`,
+                `"007"` → `7`) and leaves the field out for an empty string; a value
+                holding letters or a thousands separator (`"1,250.00"`) fails the
+                record with `non_parsable_string` (`<generate>: String contains alpha
+                characters`)
               - `boolean`: True/false values, converts truthy/falsy values
 
               Dates are represented as strings — use `string` for date fields and
@@ -4705,8 +4719,14 @@ components:
               - |-
                 Missing `dataType` is rejected at save with validation error
                 `[mandatory_destination_datatype] Destination datatype is a
-                required field.` When in doubt, use `"string"` — it accepts
-                any source value and the runtime will coerce it.
+                required field.`
+              - |-
+                Give each row the type the destination field expects; `"string"` is
+                not a safe default. It accepts any source value, but sends a numeric
+                source as text (`"24"`), which a destination that checks JSON types
+                refuses. Map numeric destination fields as `number`, which fails a
+                record (`non_parsable_string`) only when the value holds letters or a
+                thousands separator.
             enum:
               - string
               - number
@@ -4718,7 +4738,7 @@ components:
               - objectarray
             x-enumDescriptions:
               string: Text values; converts other types to their string representation.
-              number: Numeric values; attempts conversion from strings.
+              number: Numeric values; converts numeric strings, and fails the record (`non_parsable_string`) on letters or a thousands separator.
               boolean: True/false values; converts truthy/falsy values.
               object: Nested object built from child `mappings`, or copied whole with `extract` (not both).
               stringarray: Array of string values.
@@ -5860,7 +5880,7 @@ components:
 
               This value is used as a fallback when:
               1. The source value doesn't match any key in the map
-              2. allowFailures is set to true
+              2. allowFailures is true or omitted
 
               Setting an appropriate default helps prevent flow failures due to unexpected
               values and provides predictable behavior for edge cases.
@@ -5870,8 +5890,10 @@ components:
               - Original value indicators: "{Original Value}", "No mapping found"
               - Neutral values: "Other", "N/A", "Miscellaneous"
 
-              If allowFailures is false, a record whose value is unmapped fails and the default
-              is ignored.
+              A save refuses a default together with an explicit `allowFailures: false`
+              (422 `Lookups with default set can not have allowFailures explicitly set to
+              false.`): a lookup either fails a miss (`allowFailures: false`, no default) or
+              falls back to its default.
             examples:
               - Unknown
               - Other
@@ -5879,7 +5901,8 @@ components:
               - Unmapped Value
               - '{Original Value}'
             x-celigo-ai-guidance:
-              - 'Omit this field entirely when no fallback value is intended: a miss the lookup lets through then leaves the mapped field out, and with `allowFailures: false` a miss fails the record whatever the default. An empty string is a value, not "no default" — the save accepts `default: ""`, and an allowed miss writes `""`.'
+              - 'Omit this field entirely when no fallback value is intended: a miss the lookup lets through then leaves the mapped field out, and `allowFailures: false` (which a save refuses alongside a default) fails it. An empty string is a value, not "no default" — the save accepts `default: ""`, and an allowed miss writes `""`.'
+              - A default sends every unmapped value with no error, so add the missing key to the map when the destination needs the real value; keys match the extracted value exactly (case, spacing and suffixes count), and a save replaces the whole map.
           allowFailures:
             type:
               - boolean
@@ -13625,6 +13648,8 @@ components:
             Reference the existing record ID in the UPDATE URI with `{{{data.0.fieldName}}}` (triple braces with the data.0 prefix).
             Use separate array elements per operation rather than `{{#if}}` conditionals inside a single URI.
             URI templates render strictly: a path that is undefined on the record — such as `record.<field>` on a grouped record, whose root is `rows` — fails the request instead of rendering empty.
+            A field the record lacks, or a `{{lookup.<name>}}` whose lookup found nothing, fails that record before anything is sent, with `handlebars_template_parse_error` (source `application`, classification `parse`): `Failed to generate request url from template: <URL>. Details: "<field>" not defined in the model.` That is missing data, not template syntax, and a retry of the same record fails the same way: send records that may lack the destination id through a composite UPDATE/CREATE import (`existingExtract`), or skip them with `ignoreMissing` and `ignoreExtract`.
+            A field that holds an empty string or null is defined: it renders empty, and the request is sent without the value.
           x-celigo-ai-guidance:
             - '**CRITICAL: This MUST be an array of strings, NOT an object.**'
             - |-
@@ -14668,9 +14693,17 @@ components:
               extract:
                 type: string
                 description: |
-                  JSONPath expression that selects the lookup value from the
-                  HTTP response body. ``$.`` prefix optional. Examples:
-                  ``$.data[0].id``, ``$.results.primaryKey``, ``id``.
+                  Path to the lookup value in the HTTP response body, written
+                  without a ``$.`` prefix: ``id``, ``results[0].id``, or ``ids``
+                  for an array of ids. A ``$.``-prefixed path, a ``[*]``
+                  wildcard, or a dot path through an array (``results.id``)
+                  resolves nothing, so the lookup misses: with
+                  ``allowFailures: false`` the record fails
+                  (``batch_lookup_evaluation_failed``); otherwise it goes on with
+                  ``default`` or without the value, and nothing errors. A
+                  composite import whose ``existingLookupName`` names such a
+                  lookup sends every record to CREATE. Mapper 2.0 mapping
+                  extracts are the opposite: they take the ``$.``.
               _lookupCacheId:
                 type: string
                 format: objectId
@@ -14694,13 +14727,17 @@ components:
                   - string
                   - 'null'
                 description: |
-                  Value returned when the HTTP request returns no usable
-                  match. When omitted and ``allowFailures`` is false, an
-                  unmatched lookup halts the record. Stored as null when no
+                  Value written when the lookup finds no match and the miss is
+                  allowed (``allowFailures`` true, or omitted on a static
+                  ``map``). A save refuses a ``default`` together with an
+                  explicit ``allowFailures: false`` (422 "Lookups with default
+                  set can not have allowFailures explicitly set to false."), so
+                  a lookup either fails a miss (``allowFailures: false``, no
+                  default) or falls back to its default. Stored as null when no
                   fallback is configured.
                 x-celigo-ai-guidance:
                   - 'Omit this field entirely when no fallback value is intended. An empty string is a value, not "no default": the save accepts `default: ""`, and a miss the lookup lets through writes `""`.'
-                  - 'A fallback only takes effect on an allowed miss — pair a real default with allowFailures: true (or useDefaultOnMultipleMatches: true for the ambiguous-match case).'
+                  - 'A default raises no error: every unmatched value goes out as the default with a 200. Set one only when a single fallback is right for every value the lookup can''t match; when a miss must stop the record, set allowFailures: false and leave the default out. An ambiguous answer (two or more matches) doesn''t use the default either: see useDefaultOnMultipleMatches.'
               allowFailures:
                 type:
                   - boolean
@@ -14710,20 +14747,40 @@ components:
                   field out when there is none) and the record continues. When
                   false, a miss fails the record: ``lookup_error`` ("Could not find
                   value for static lookup: …") for a static ``map``,
-                  ``lookupcache_evaluation_failed`` for a cache. Omitted or null,
+                  ``lookupcache_evaluation_failed`` for a cache, and
+                  ``batch_lookup_evaluation_failed`` (source ``internal``, "<field>:
+                  The batch lookup could not be evaluated. Check the value in the
+                  key '<value>', and try again.") for a live request that matches
+                  nothing or whose ``extract`` resolves nothing. Omitted or null,
                   a miss doesn't fail the record either: a static lookup writes
                   its ``default`` if it has one, and a lookup without one (static,
                   cache, or a live request that matches nothing or fails) leaves
                   the mapped field out.
+
+                  False is also the only setting under which an ambiguous answer
+                  fails the record: two or more values at ``extract`` (an array of
+                  ids or of result objects) fail it with ``lookup_conflict``
+                  ("Multiple matches found for lookup."). Omitted, null or true,
+                  the first value is sent with no error, and an array of result
+                  objects is written as the text ``[object Object]``. An indexed
+                  ``extract`` (``ids[0]``) takes the first match whatever this
+                  field says, so it hides an ambiguous search rather than fixing
+                  it.
                 x-celigo-ai-guidance:
                   - Set false explicitly when a miss must stop the record. Leaving the field out lets the record through with the default or without the looked-up value, so a destination that needs the real value gets a request without it and nothing errors.
+                  - 'Fix an ambiguous lookup in its search, not here: query on a key that identifies one record (an email, an external id) and keep false, so a search that still finds two fails instead of writing against the first match.'
               useDefaultOnMultipleMatches:
                 type: boolean
                 description: |
-                  Controls behaviour when the response contains more than one
-                  match. When true, the ``default`` value is returned instead
-                  of raising an ambiguous-match error. When false (default),
-                  multiple matches are treated as a failure.
+                  Meant to return ``default`` when the response holds more than
+                  one match. On an HTTP import it has not been seen to take
+                  effect: with ``allowFailures`` omitted or true the first match
+                  is sent whatever this flag says, with or without a
+                  ``default``, and with ``allowFailures: false`` the record
+                  fails with ``lookup_conflict``. Two or more matches fail the
+                  record only when ``allowFailures`` is false (see
+                  ``allowFailures``), so make the search match one record
+                  rather than relying on this flag.
           type: array
     Ftp:
       type: object
@@ -23806,15 +23863,30 @@ components:
                 - `"lessthan"`: Value is less than specified value (is less than)
                 - `"lessthanequals"`: Value is less than or equal to specified value (is less than or equals)
                 - `"startswith"`: String starts with specified prefix (starts with)
+                - `"notstartswith"`: String does not start with specified prefix (does not start with)
                 - `"endswith"`: String ends with specified suffix (ends with)
+                - `"notendswith"`: String does not end with specified suffix (does not end with)
                 - `"contains"`: String contains specified substring (contains)
                 - `"doesnotcontain"`: String does not contain specified substring (does not contain)
                 - `"empty"`: Field is missing or empty (is empty)
                 - `"notempty"`: Field contains a value (is not empty)
-                - `"matches"`: Matches a regular expression (matches)
-
-                `isempty`, `isnotempty` and `anyof` are not operators: they are refused with 422
-                "Invalid operation: <name>".
+                - `"matches"`: Matches a regular expression, ignoring case (matches)
+
+                Operator names are case-insensitive: `NOTEMPTY` and `endsWith` work and are stored
+                as sent. `isempty`, `isnotempty`, `anyof`, `notcontains`, `doesnotstartwith`,
+                `doesnotendwith`, `notmatches`, `doesnotmatch` and `notequal` are not operators:
+                they are refused with 422 "Invalid operation: <name>", with the name in lowercase,
+                both when the filter is saved and by `POST /v1/processors/filter`. To negate a
+                condition, wrap it in `not`.
+
+                The string comparisons (`equals`, `contains`, `startswith`, `endswith` and their
+                negations) are case-sensitive; wrap the field in `lowercase` to compare without case.
+                `matches` is not: every pattern is compiled with the flags `gi`, so `^paid$` also
+                matches `PAID` and `[a-z]` matches capital letters. An inline flag such as `(?i)`
+                makes the pattern invalid. The filter still saves, but in a run every record fails
+                with `FILTER_EVALUATION_FAILED` ("Invalid regular expression: /(?i)…/gi: Invalid
+                group"), and `POST /v1/processors/filter` refuses the call with 422 (live-verified
+                2026-10-22).
 
                 **Logical Operators**
                 - `"and"`: All conditions must be true
@@ -24235,8 +24307,10 @@ components:
             - A dot path from the record root (e.g. `email`, `address.city`), read from the
               incoming record. A path that matches no field writes nothing.
             - Handlebars template (contains `{{`) for concatenation /
-              formatting / conditional logic (e.g.
-              `{{record.firstName}} {{record.lastName}}`).
+              formatting / conditional logic (e.g. `{{firstName}} {{lastName}}`,
+              `{{#if mobile}}{{mobile}}{{else}}{{phone}}{{/if}}`). The template reads the
+              record's fields by bare name: `{{record.firstName}}` and `{{data.firstName}}`
+              render nothing, so the field is left out even when the record has the value.
 
             A `$.` JSONPath (the Mapper 2.0 `mappings` syntax) reads nothing here, and a bare
             string is read as a field path, not a constant: set constants in `hardCodedValue`.
@@ -24277,8 +24351,9 @@ components:
           x-celigo-ai-guidance:
             - |-
               When true, skip this field entirely when ``extract`` / lookup
-              produces empty / null. Without this flag the destination field
-              receives null and may overwrite existing data.
+              produces an empty string, null or nothing. Without this flag an
+              empty string is written as ``""`` and null as null, either of which
+              may overwrite existing data; a missing source is left out either way.
         immutable:
           type: boolean
           description: When true, the mapped value cannot be overwritten by later mapping steps.
@@ -24295,7 +24370,15 @@ components:
           type:
             - string
             - 'null'
-          description: Fallback value used when the extract yields no value.
+          description: |-
+            Fallback value written when the source value is an empty string, null or
+            missing. Without a default, an empty string and null are written as they are
+            and a missing field is left out.
+          x-celigo-ai-guidance:
+            - |-
+              Use ``default``, not ``hardCodedValue``, for a fallback on a field that is
+              sometimes empty: ``hardCodedValue`` is written on every record and replaces
+              the values that exist.
         extractDateFormat:
           type: string
           description: Date format of the source value, used to parse it before conversion.
@@ -24411,8 +24494,8 @@ components:
                   id:
                     type: string
                     description: |
-                      Unique identifier for this field within the form.
-                      This value typically matches the key in the fieldMap object.
+                      Unique identifier for this field within the form: layout containers and conditions
+                      refer to the field by it. Use the same string as the field's fieldMap key and its `name`.
                     examples:
                       - url
                       - mode
@@ -24423,8 +24506,9 @@ components:
                   name:
                     type: string
                     description: |
-                      Name of the field, used as the property name when generating the settings object
-                      from the submitted form data.
+                      Key the field's value is saved under: one top-level key of the resource's `settings`,
+                      which the form also reads the value back from when it opens. Nested objects inside
+                      `settings` are written to it directly, not through a form field's `name`.
                     examples:
                       - url
                       - mode
@@ -24499,11 +24583,19 @@ components:
                   required:
                     type: boolean
                     description: |
-                      When true, the field must have a value before the form can be submitted.
+                      When true, the field must have a value before the form can be submitted. Only the form
+                      enforces it: an API write of `settings` is stored without the value.
                     default: false
                     examples:
                       - true
                       - false
+                  defaultValue:
+                    description: |
+                      Value the form shows while the resource's `settings` holds no value under the field's
+                      `name`.
+                    examples:
+                      - us
+                      - true
                   multiline:
                     type: boolean
                     description: |
@@ -24566,15 +24658,187 @@ components:
                   keyName:
                     type: string
                     description: |
-                      For keyvalue fields, specifies the placeholder and field name for the key input.
+                      For keyvalue and staticMap fields, names the first column: each saved row holds that
+                      column's value under this key. A keyvalue field without it uses `key`.
                     examples:
                       - theKey
+                      - source
                   valueName:
                     type: string
                     description: |
-                      For keyvalue fields, specifies the placeholder and field name for the value input.
+                      For keyvalue and staticMap fields, names the second column: each saved row holds that
+                      column's value under this key. A keyvalue field without it uses `value`.
                     examples:
                       - theValue
+                      - target
+                  keyLabel:
+                    type: string
+                    description: |
+                      For staticMap fields, heading of the first column.
+                    examples:
+                      - Source status
+                  valueLabel:
+                    type: string
+                    description: |
+                      For staticMap fields, heading of the second column.
+                    examples:
+                      - Destination status
+                  keyOptions:
+                    type: array
+                    description: |
+                      For staticMap fields, suggestions offered in the first column's cells. A cell still
+                      accepts a typed value.
+                    items:
+                      type: object
+                      properties:
+                        label:
+                          type: string
+                          description: |
+                            Display text for the suggestion.
+                        value:
+                          type: string
+                          description: |
+                            Value saved when the suggestion is chosen.
+                    examples:
+                      - - label: Pending
+                          value: pending
+                        - label: Shipped
+                          value: shipped
+                  valueOptions:
+                    type: array
+                    description: |
+                      For staticMap fields, suggestions offered in the second column's cells. A cell still
+                      accepts a typed value.
+                    items:
+                      type: object
+                      properties:
+                        label:
+                          type: string
+                          description: |
+                            Display text for the suggestion.
+                        value:
+                          type: string
+                          description: |
+                            Value saved when the suggestion is chosen.
+                    examples:
+                      - - label: Open
+                          value: open
+                        - label: Closed
+                          value: closed
+                  keyResource:
+                    type: object
+                    description: |
+                      For staticMap fields, fills the first column's suggestions from an export the form
+                      carries inline in `virtual`, run the way an exportSelect's `resource` is. With
+                      `keyResource` or `valueResource` set, the form requires both columns in every row
+                      unless `keyValueRequired` is false.
+                    properties:
+                      virtual:
+                        type: object
+                        description: |
+                          Export document to run, inline, shaped like an exportSelect's `resource.virtual`.
+                        additionalProperties: true
+                  valueResource:
+                    type: object
+                    description: |
+                      For staticMap fields, fills the second column's suggestions from an export the form
+                      carries inline in `virtual`, run the way an exportSelect's `resource` is.
+                    properties:
+                      virtual:
+                        type: object
+                        description: |
+                          Export document to run, inline, shaped like an exportSelect's `resource.virtual`.
+                        additionalProperties: true
+                  keyValueRequired:
+                    type: boolean
+                    description: |
+                      For staticMap fields with `keyResource` or `valueResource`, when false, saves rows
+                      that fill only one column; by default the form drops them.
+                    default: true
+                    examples:
+                      - false
+                  resource:
+                    type: object
+                    description: |
+                      For exportSelect fields, the export whose records become the options. When the form
+                      opens, the UI previews the export in `virtual` (with `test.limit` 100 unless the export
+                      sets its own) and lists the preview's `data`: each record needs a `label` and a `value`
+                      (a string or number serves as both), so shape them with the export's `transform`. A
+                      saved export can't be referenced, and an HTTP export that finds no records leaves the
+                      field showing an error instead of options.
+                    properties:
+                      virtual:
+                        type: object
+                        description: |
+                          Export document to run, inline: `adaptorType`, its adaptor block, and an optional
+                          `transform`. `_connectionId` defaults to the connection of the export or import the
+                          form belongs to; set it on any other resource's form.
+                        additionalProperties: true
+                    examples:
+                      - virtual:
+                          adaptorType: HTTPExport
+                          http:
+                            relativeURI: /v1/warehouses
+                            method: GET
+                            formType: http
+                            response:
+                              resourcePath: warehouses
+                          transform:
+                            type: expression
+                            expression:
+                              version: '2'
+                              rulesTwoDotZero:
+                                mode: create
+                                mappings:
+                                  - generate: label
+                                    extract: $.name
+                                    dataType: string
+                                    status: Active
+                                  - generate: value
+                                    extract: $.code
+                                    dataType: string
+                                    status: Active
+                  multiselect:
+                    type: boolean
+                    description: |
+                      For exportSelect fields, when true, the user can choose several options and the value
+                      is saved as an array.
+                    default: false
+                    examples:
+                      - true
+                  supportHandlebars:
+                    type: boolean
+                    description: |
+                      For exportSelect fields, when true, renders the `resource.virtual` export as a Handlebars
+                      template before each preview (all but its `transform`, `hooks`, and `filter`). On an
+                      integration, flow group, flow, export, or import form, the form's current values are
+                      under that form's scope name (`integration`, `flowGrouping`, `flow`, `export`, or
+                      `import`), beside the saved settings of the scopes above it, with no `settings.`
+                      prefix; on a connection or iClient form the template has no context. The options then
+                      load through `refreshOptionsOnChangesTo` or `typeAheadSearch`, or when the user
+                      refreshes the field.
+                    default: false
+                    examples:
+                      - true
+                  refreshOptionsOnChangesTo:
+                    type: array
+                    items:
+                      type: string
+                    description: |
+                      For exportSelect fields with `supportHandlebars`, ids of the fields whose values the
+                      templated export uses: the options load once one of them has a value and reload whenever
+                      one changes.
+                    examples:
+                      - - region
+                  typeAheadSearch:
+                    type: boolean
+                    description: |
+                      For exportSelect fields, when true, re-runs the templated export as the user types, with
+                      the typed text as this field's own value; an empty box clears the options, and typed
+                      text is accepted as the value.
+                    default: false
+                    examples:
+                      - true
                   showDelete:
                     type: boolean
                     description: |
@@ -24675,7 +24939,9 @@ components:
                         field:
                           type: string
                           description: |
-                            The ID of another field whose value controls the visibility of this field.
+                            The ID of another field whose value controls the visibility of this field. The
+                            save doesn't check it: a rule naming an ID that isn't in the form counts as met,
+                            so the field stays visible.
                           examples:
                             - mode
                         is:
@@ -24711,7 +24977,7 @@ components:
                     - tabWithoutSave
                     - verticalTabWithoutSave
                   x-enumDescriptions:
-                    column: Arranges form fields in a single vertical column layout.
+                    column: Places the containers side by side, one column each.
                     collapse: Groups fields into collapsible/expandable sections.
                     box: Wraps field groups in bordered boxes with headings.
                     indent: Indents field groups to show hierarchy.
@@ -24720,6 +24986,15 @@ components:
                   examples:
                     - column
                     - collapse
+                fields:
+                  type: array
+                  items:
+                    type: string
+                  description: |
+                    Field IDs shown above the containers, without a heading.
+                  examples:
+                    - - region
+                      - vatNumber
                 containers:
                   type: array
                   description: |
@@ -24759,7 +25034,8 @@ components:
                           type: string
                         description: |
                           Array of field IDs that should be displayed in this container.
-                          Each ID must correspond to a key in the fieldMap object.
+                          Each ID must correspond to a key in the fieldMap object: the save doesn't check it,
+                          and an ID that doesn't renders nothing. A field the layout doesn't list isn't shown.
                         examples:
                           - - A
                             - url
@@ -24836,6 +25112,9 @@ components:
 
             The function must return a valid form object that the UI can render.
             Throwing an exception will signal an error to the user.
+
+            The UI runs the function each time it opens the form and renders the returned form instead of
+            `form`, then fills in the values from `settings`; a thrown error's message replaces the form.
           properties:
             function:
               type: string
@@ -24859,8 +25138,10 @@ components:
                 Reference to a predefined script resource containing the initialization function.
 
                 The referenced script should contain the function specified in the
-                'function' property. This script must be accessible within the user's account
-                and have appropriate permissions.
+                'function' property. On an integration, a flow group, a flow, an export, an import, or a
+                connection, an id that isn't a script in the same account (or, on an Integration App's
+                resources, one the app shares) is refused with 422 `invalid_ref`. An iClient save
+                stores the id without that check.
               examples:
                 - 60a2c4e6f321d800129a1a3c
                 - 5f8d43a1b9e5a80011a35f2c
@@ -37491,8 +37772,11 @@ components:
             (CSV/XML/JSON) into records. Most modes take their matching configuration object (e.g. a
             `webhook` object when `type` is `webhook`); an HTTP or SQL `delta` export saves without a
             `delta` object because its request carries `{{lastExportDateTime}}`, though
-            `delta.startDate` sets its first window. Use `blob` only to transfer raw files without
-            parsing their contents.
+            `delta.startDate` sets its first window. It still needs `type: delta`: on an export
+            with no `type`, `{{lastExportDateTime}}` and `{{currentExportDateTime}}` render
+            empty on every run, so a request that carries them goes out with blank values each time
+            (live-verified 2026-10-22). Use `blob` only to transfer raw files without parsing their
+            contents.
           x-celigo-ai-guidance:
             - |-
               ## HOW TO PICK THE TYPE VALUE

package/dist/tradingpartnerconnector.yml

@@ -615,15 +615,30 @@ components:
                 - `"lessthan"`: Value is less than specified value (is less than)
                 - `"lessthanequals"`: Value is less than or equal to specified value (is less than or equals)
                 - `"startswith"`: String starts with specified prefix (starts with)
+                - `"notstartswith"`: String does not start with specified prefix (does not start with)
                 - `"endswith"`: String ends with specified suffix (ends with)
+                - `"notendswith"`: String does not end with specified suffix (does not end with)
                 - `"contains"`: String contains specified substring (contains)
                 - `"doesnotcontain"`: String does not contain specified substring (does not contain)
                 - `"empty"`: Field is missing or empty (is empty)
                 - `"notempty"`: Field contains a value (is not empty)
-                - `"matches"`: Matches a regular expression (matches)
-
-                `isempty`, `isnotempty` and `anyof` are not operators: they are refused with 422
-                "Invalid operation: <name>".
+                - `"matches"`: Matches a regular expression, ignoring case (matches)
+
+                Operator names are case-insensitive: `NOTEMPTY` and `endsWith` work and are stored
+                as sent. `isempty`, `isnotempty`, `anyof`, `notcontains`, `doesnotstartwith`,
+                `doesnotendwith`, `notmatches`, `doesnotmatch` and `notequal` are not operators:
+                they are refused with 422 "Invalid operation: <name>", with the name in lowercase,
+                both when the filter is saved and by `POST /v1/processors/filter`. To negate a
+                condition, wrap it in `not`.
+
+                The string comparisons (`equals`, `contains`, `startswith`, `endswith` and their
+                negations) are case-sensitive; wrap the field in `lowercase` to compare without case.
+                `matches` is not: every pattern is compiled with the flags `gi`, so `^paid$` also
+                matches `PAID` and `[a-z]` matches capital letters. An inline flag such as `(?i)`
+                makes the pattern invalid. The filter still saves, but in a run every record fails
+                with `FILTER_EVALUATION_FAILED` ("Invalid regular expression: /(?i)…/gi: Invalid
+                group"), and `POST /v1/processors/filter` refuses the call with 422 (live-verified
+                2026-10-22).
 
                 **Logical Operators**
                 - `"and"`: All conditions must be true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celigo/api-specs",
-  "version": "0.2.171",
+  "version": "0.2.172",
   "private": false,
   "description": "Public OpenAPI bundles (dist/) and the celigo-cli lint schema pack (schemas.json).",
   "keywords": [