@uipath/maestro-builder-sdk 6.14.5 → 6.15.0

package/dist/core/connector-inputs.js

@@ -0,0 +1,453 @@
+/**
+ * core/connector-inputs — a connector operation's authored inputs, validated
+ * against its declared field list and ROUTED to the wire slots the platform reads.
+ *
+ * Shared by every family that authors a connector activity. It was Flow's, inside
+ * `serialize.ts`, and BPMN had a fourteen-line substitute: an input the library
+ * did not declare went silently to the body, a missing required field was never
+ * reported, and a `lookup()` token was refused outright because nothing here
+ * read `connectors-local/resolutions.json`. That last one is why
+ * `skill-bpmn-paginated-reference-lookup` could resolve a Slack channel id and
+ * then emit a process that did not carry it.
+ *
+ * Two things differ between families and are injected rather than assumed:
+ *
+ *  - `dialect` — which values are opaque (a Flow `Expr`, a BPMN `=`-expression).
+ *    An opaque value is not type-checked against the field's declared type,
+ *    because nothing here can evaluate it.
+ *  - `render` — how an authored value becomes a wire value. Flow runs `renderDeep`
+ *    to lower `Expr` objects into `$vars.…` source; BPMN's values are already
+ *    plain, so it passes them through.
+ *
+ * The ROUTING is the library's business either way: a field's location is a
+ * property of the operation, not of the family emitting it.
+ */
+import { isLookupToken, resolvedValue, unresolvedLookupMessage, } from './lookups.js';
+import { prepareCommand } from './cli-spelling.js';
+/** Flow's dialect, re-exported so `serialize.ts` need not reach past this module. */
+export { FLOW_EXPR_DIALECT } from './connector-checks.js';
+import { FLOW_EXPR_DIALECT as FLOW_DIALECT } from './connector-checks.js';
+/**
+ * Validate a connector's activity inputs against its declared field list and
+ * return them ROUTED to the wire slots the platform reads. Catches the three
+ * connector-input mistakes — missing required, unknown key, type mismatch — at
+ * compile, where the author can act on them.
+ *
+ * Generated descriptors accept natural nested objects and arrays; the legacy
+ * string form also accepts exact flat registry field ids. Routing remains the
+ * library's business because a field's location is a property of the operation.
+ * Each projected registry field lands in the slot its declaration names:
+ *
+ * ```jsonc
+ * // connector('uipath-atlassian-jira','get-issue', { issueId: …, project: 'IN', issuetype: 'Task' })
+ * "inputs": { "detail": {
+ *   "endpoint":        "/curated_get_issue/{issueId}",
+ *   "pathParameters":  { "issueId": "IN-28" },
+ *   "queryParameters": { "project": "IN", "issuetype": "Task" },
+ *   "bodyParameters":  {} } }
+ * ```
+ *
+ * That is the platform's own encoding, measured on the deployed corpus: 1,283
+ * connector nodes in the nightly artifacts, 384 carrying `pathParameters` and
+ * 576 carrying `queryParameters`, always as a FLAT map keyed by the parameter's
+ * DECLARED name (`send_as`, `issuetype`, `channel_id` keep their spelling — no
+ * camelCasing) and always as a SIBLING of `bodyParameters` rather than as a
+ * location-tagged entry inside it.
+ */
+/** For a missing required lookup field: what it sends and how to resolve it. Empty for a plain field. */
+function missingLookupHint(field, lookup, spec, descriptors) {
+    if (!lookup)
+        return '';
+    const target = `${lookup.objectName ?? lookup.path}.${lookup.value}`;
+    const alias = Object.keys(lookup.aliases)[0];
+    const by = lookup.by[0] ?? 'id';
+    // `<Descriptor>` is a placeholder only a Flow author can fill, from a
+    // generated `connectors/<key>.ts`. BPMN imports none, so it gets the string
+    // form with the real key and action — which is the call that compiles there.
+    const call = descriptors
+        ? (alias
+            ? `lookup(<Descriptor>, '${field}').${alias}('<value>')`
+            : `lookup(<Descriptor>, '${field}').by('${by}', '<value>')`)
+        : `lookup('${spec.key ?? '<key>'}', '${spec.action ?? '<action>'}', '${field}').by('${by}', '<value>')`;
+    return ` — a lookup id (\`${target}\`), not a name or address: ${call}`;
+}
+/**
+ * What `compile` would refuse these connector inputs with, or `undefined` when it
+ * would accept them — the SAME code path `buildConnectorInputs` runs at emit time,
+ * so `check` and `compile` cannot disagree about a missing required field, an
+ * unknown or mistyped input, or a container part passed as a value. Unresolved
+ * lookups are the one thing skipped: `check` already reports them as
+ * LOOKUP_UNRESOLVED with the resolution recipe.
+ */
+export function connectorInputErrors(rc, inputs, resolutions = {}, lookups = {}, wire = { dialect: FLOW_DIALECT }) {
+    try {
+        buildConnectorInputs(rc, inputs, { ...wire, resolutions, lookups, unresolvedLookups: 'ignore' });
+        return undefined;
+    }
+    catch (e) {
+        return e instanceof Error ? e.message : String(e);
+    }
+}
+export function buildConnectorInputs(rc, inputs, opts) {
+    const { dialect, resolutions = {}, lookups = {}, unresolvedLookups } = opts;
+    const render = opts.render ?? ((value) => value);
+    const policy = { unresolvedLookups };
+    const fields = (rc.fields ?? []);
+    const byName = new Map(fields.map((f) => [f.name, f]));
+    const errs = validateNestedConnectorKeys(fields, inputs, byName, dialect);
+    const routed = {
+        bodyParameters: {}, pathParameters: {}, queryParameters: {},
+    };
+    // The author's values for FILE parts, by part name. The part LIST itself comes
+    // from the library (`rc.multipartParts`): a string-typed part is a transport
+    // container the runtime composes from `bodyParameters`, so it is listed without
+    // a value and is never an author input — see `readFields` in core/library.ts.
+    const partValues = new Map();
+    for (const f of fields) {
+        const flat = Object.prototype.hasOwnProperty.call(inputs, f.name);
+        let nested = flat
+            ? { found: true, value: inputs[f.name], projectedArrays: 0 }
+            : readConnectorPath(inputs, f.name, dialect);
+        if (!nested.found) {
+            // A required LOOKUP field is missing far more often because the author does
+            // not know what to put in it than because they forgot it exists: name the
+            // id it sends and the helper that finds one, so "(string)" is not read as
+            // "any string" — an e-mail into `fields.reporter.id` is exactly that misreading.
+            if (f.required)
+                errs.push(`missing required input "${f.name}" (${f.type ?? 'value'})${missingLookupHint(f.name, lookups[f.name], rc, dialect.descriptors)}`);
+            continue;
+        }
+        // An unresolved lookup is swapped for its recorded id, or reported. It is
+        // NOT rendered as a placeholder: emitting something for a value nobody
+        // resolved would produce a flow that compiles and then talks to the wrong
+        // record, which is exactly the failure the lookup surface exists to remove.
+        //
+        // A token is swapped wherever the field's value can hold one: the whole
+        // value, or an element of an array at any depth. A multiselect is
+        // `users: [lookup(…), lookup(…)]` — the form `ConnectorLookupValue`'s array
+        // branch types and the generated `## Example` prints — and until this swapped
+        // only the whole-value case, so every token inside the array reached
+        // validation as an object ("expected string, got object") with every lookup
+        // recorded. An unresolved element under 'ignore' becomes `null`, which
+        // validation skips, so `check` still type-checks the resolved siblings.
+        const unresolved = [];
+        const swapped = swapLookupTokens(nested.value, resolutions, unresolved);
+        if (unresolved.length) {
+            if (policy.unresolvedLookups !== 'ignore') {
+                for (const token of unresolved)
+                    errs.push(unresolvedLookupMessage(token));
+                continue;
+            }
+            if (isLookupToken(nested.value))
+                continue;
+        }
+        nested = { ...nested, value: swapped };
+        // A FLAT key whose wire name ends in `[*]` names one array: an array value
+        // there is checked element by element, as the nested form is. A flat scalar
+        // keeps depth 0 and is emitted as the scalar it is — the product wraps it
+        // into a one-element list (flow-v1 `convertDotNotationToNested`).
+        const depth = flat
+            ? (f.name.endsWith('[*]') && Array.isArray(nested.value) ? 1 : 0)
+            : nested.projectedArrays;
+        validateConnectorFieldValue(f, nested.value, depth, errs, dialect);
+        if (f.location === 'multipart') {
+            partValues.set(f.name, render(nested.value));
+            continue;
+        }
+        const slot = SLOT_FOR_LOCATION[f.location ?? 'body'] ?? 'bodyParameters';
+        routed[slot][f.name] = render(nested.value);
+    }
+    if (errs.length) {
+        // Name the location of each required field: a "missing required input" on a
+        // path parameter reads very differently from one on a body field, and the
+        // author's fix is the same either way (add it to the same flat `inputs` map).
+        const req = fields
+            .filter((f) => f.required)
+            .map((f) => (f.location && f.location !== 'body' ? `${f.name} (${f.location})` : f.name))
+            .join(', ') || '(none required)';
+        // Phase 1 propagates connector discovery capability to every activity. When
+        // one of those activities rejects an unknown field, point at the live-schema
+        // preparation path; fully static activities on the same connector still
+        // compile normally and never reach this hint.
+        const schemaDynamic = !!rc.entry?.runtime?.requiresConnectionForSchema;
+        const hasUnknown = errs.some((e) => e.startsWith('unknown input'));
+        let hint = '';
+        if (schemaDynamic && hasUnknown) {
+            const prefix = `uipath.connector.${rc.connectorKey}.`;
+            const action = String(rc.nodeType).startsWith(prefix)
+                ? String(rc.nodeType).slice(prefix.length)
+                // `.pop()` on a split is never empty at runtime, but its type admits
+                // `undefined`; the node type itself is the only sane fallback.
+                : String(rc.nodeType).split('.').pop() ?? String(rc.nodeType);
+            hint =
+                ` This connector supports connection-specific object or field discovery, and the ` +
+                    `static library does not contain this input. Run ` +
+                    `\`${prepareCommand(rc.connectorKey, action)}\` ` +
+                    `to load them ` +
+                    `(writes ./.flow-sdk/connectors-local/, which the compiler auto-detects). If that still ` +
+                    `does not carry this input, the operation resolves its fields from the VALUES of ` +
+                    `parent inputs: resolve every parent and re-run with ` +
+                    `\`-f <parent-field>=<value>\` for each — too few parents is refused, and a ` +
+                    `wrong value resolves back to just the parents. ` +
+                    `See the connector guide's parent-field loop.`;
+        }
+        throw new Error(`connector ${rc.nodeType}: ${errs.join('; ')}. Required fields: ${req}.${hint}`);
+    }
+    // Every declared part, in declaration order, as the designer lists them: the
+    // container part valueless, a file part with the author's value when given. A
+    // test double that resolves no `multipartParts` falls back to its multipart
+    // fields, which are all file parts by construction.
+    const declaredParts = rc.multipartParts
+        ?? fields.filter((f) => f.location === 'multipart').map((f) => ({ name: f.name, dataType: f.type ?? 'string' }));
+    const multipartParameters = declaredParts.map((part) => (partValues.has(part.name)
+        ? { name: part.name, dataType: part.dataType, value: partValues.get(part.name) }
+        : { name: part.name, dataType: part.dataType }));
+    // A FIXED slot order, so a recompile is byte-identical no matter which order
+    // the author listed the inputs in.
+    const slots = multipartParameters.length === 0 || Object.keys(routed.bodyParameters).length > 0
+        ? { bodyParameters: routed.bodyParameters }
+        : {};
+    if (Object.keys(routed.pathParameters).length)
+        slots.pathParameters = routed.pathParameters;
+    if (Object.keys(routed.queryParameters).length)
+        slots.queryParameters = routed.queryParameters;
+    if (multipartParameters.length) {
+        slots.multipartParameters = multipartParameters;
+        slots.inputMetadata = { type: 'multipart', multipart: { bodyFieldName: multipartBodyFieldName(declaredParts) } };
+    }
+    return slots;
+}
+/**
+ * `value` with every lookup token swapped for its recorded id: the value itself,
+ * or the elements of an array at any depth. An unrecorded token is pushed to
+ * `unresolved` and stands as `null`, so an array keeps its length.
+ *
+ * Objects are NOT descended: a lookup's place is a field's value or an element
+ * of an array field (`ConnectorLookupValue`), and a nested path such as
+ * `contacts[*].id` reaches here already projected to its leaf array. A token
+ * anywhere else is refused by {@link renderDeep}.
+ */
+function swapLookupTokens(value, resolutions, unresolved) {
+    if (isLookupToken(value)) {
+        const resolved = resolvedValue(value, resolutions);
+        if (resolved === undefined) {
+            unresolved.push(value);
+            return null;
+        }
+        return resolved;
+    }
+    if (Array.isArray(value))
+        return value.map((item) => swapLookupTokens(item, resolutions, unresolved));
+    return value;
+}
+/**
+ * `inputMetadata.multipart.bodyFieldName` names the CONTAINER part — the one the
+ * runtime composes from `bodyParameters`. Measured on the designer's own nodes in
+ * the eval archive: `body` ×413, `RagRequest` ×1 (GenAI `content-generation`, whose
+ * string part is named that), and `body` on 91 of 93 file-only operations. A
+ * mis-named container is fatal at dispatch — hardcoding `body` for GenAI made
+ * Integration Service answer `400 The request body is empty` (verified live
+ * 2026-09-02) — so it is the string part's own name, with `body` only as the
+ * default for an operation that has no string part.
+ */
+export function multipartBodyFieldName(parts) {
+    const containers = parts.filter((p) => p.dataType.toLowerCase() !== 'file');
+    return containers.length === 1 ? containers[0].name : 'body';
+}
+const SLOT_FOR_LOCATION = {
+    body: 'bodyParameters',
+    query: 'queryParameters',
+    path: 'pathParameters',
+};
+function connectorPath(name) {
+    return name.split('.').map((raw) => ({
+        key: raw.endsWith('[*]') ? raw.slice(0, -3) : raw,
+        array: raw.endsWith('[*]'),
+    }));
+}
+/** Read a natural nested authoring value using a registry path such as
+ * `contacts[*].id`. Wildcards project one value per array element so the Flow
+ * bodyParameters map can retain the registry's exact field ids. */
+function readConnectorPath(inputs, name, dialect) {
+    const parts = connectorPath(name);
+    const read = (value, index) => {
+        if (index >= parts.length)
+            return { found: true, value, projectedArrays: 0 };
+        if (!value || typeof value !== 'object' || dialect.isOpaque(value) || Array.isArray(value))
+            return { found: false, projectedArrays: 0 };
+        const part = parts[index];
+        const object = value;
+        if (!Object.prototype.hasOwnProperty.call(object, part.key))
+            return { found: false, projectedArrays: 0 };
+        const next = object[part.key];
+        if (!part.array)
+            return read(next, index + 1);
+        if (!Array.isArray(next))
+            return { found: false, projectedArrays: 0 };
+        if (index === parts.length - 1)
+            return { found: true, value: next, projectedArrays: 1 };
+        const projected = next.map((item) => read(item, index + 1));
+        if (!projected.some((item) => item.found))
+            return { found: false, projectedArrays: 0 };
+        return {
+            found: true,
+            value: projected.map((item) => item.found ? item.value : null),
+            projectedArrays: 1 + Math.max(0, ...projected.map((item) => item.projectedArrays)),
+        };
+    };
+    return read(inputs, 0);
+}
+function buildConnectorInputTrie(fields) {
+    const root = { children: new Map(), array: false };
+    for (const field of fields) {
+        let cursor = root;
+        for (const part of connectorPath(field.name)) {
+            let child = cursor.children.get(part.key);
+            if (!child) {
+                child = { children: new Map(), array: part.array };
+                cursor.children.set(part.key, child);
+            }
+            child.array ||= part.array;
+            cursor = child;
+        }
+        cursor.terminal = field;
+    }
+    return root;
+}
+/** Reject nested typos with the same unknown-key message as flat keys. */
+function validateNestedConnectorKeys(fields, inputs, exact, dialect) {
+    const root = buildConnectorInputTrie(fields);
+    const errs = [];
+    const visit = (value, node, path) => {
+        if (dialect.isOpaque(value))
+            return;
+        if (node.array) {
+            if (!Array.isArray(value)) {
+                errs.push(`input "${path}" expected array, got ${typeof value}`);
+                return;
+            }
+            for (const item of value)
+                visit(item, { ...node, array: false }, `${path}[*]`);
+            return;
+        }
+        // An opaque object/array terminal owns its complete value; there is no
+        // child metadata with which to validate its internal keys.
+        if (node.terminal && node.children.size === 0)
+            return;
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            if (node.children.size > 0)
+                errs.push(`input "${path}" expected object, got ${Array.isArray(value) ? 'array' : typeof value}`);
+            return;
+        }
+        for (const [key, childValue] of Object.entries(value)) {
+            const child = node.children.get(key);
+            const childPath = path ? `${path}.${key}` : key;
+            if (!child) {
+                const near = nearestField(childPath, fields.map((f) => f.name));
+                errs.push(`unknown input "${childPath}"${near ? ` — did you mean "${near}"?` : ''}`);
+            }
+            else {
+                visit(childValue, child, childPath);
+            }
+        }
+    };
+    for (const [key, value] of Object.entries(inputs)) {
+        if (exact.has(key))
+            continue; // backwards-compatible flat authoring
+        const node = root.children.get(key);
+        if (!node) {
+            const near = nearestField(key, [...exact.keys()]);
+            errs.push(`unknown input "${key}"${near ? ` — did you mean "${near}"?` : ''}`);
+        }
+        else {
+            visit(value, node, key);
+        }
+    }
+    return errs;
+}
+function validateConnectorFieldValue(field, value, projectedArrays, errs, dialect) {
+    if (projectedArrays > 0) {
+        if (!Array.isArray(value)) {
+            errs.push(`input "${field.name}" expected array projection, got ${typeof value}`);
+            return;
+        }
+        for (const item of value) {
+            if (item !== null && item !== undefined)
+                validateConnectorFieldValue(field, item, projectedArrays - 1, errs, dialect);
+        }
+        return;
+    }
+    // An opaque value is whatever the family cannot evaluate here — a Flow `Expr`,
+    // a BPMN `=`-expression. Its runtime type is unknowable, so it is not checked.
+    if (dialect.isOpaque(value) || value === null || value === undefined)
+        return;
+    if (field.type === 'array') {
+        if (!Array.isArray(value))
+            errs.push(`input "${field.name}" expected array, got ${typeof value}`);
+        return;
+    }
+    if (field.type === 'object') {
+        if (typeof value !== 'object' || Array.isArray(value))
+            errs.push(`input "${field.name}" expected object, got ${Array.isArray(value) ? 'array' : typeof value}`);
+        return;
+    }
+    if (field.type === 'string' || field.type === 'number' || field.type === 'boolean') {
+        const actual = typeof value;
+        const ok = actual === field.type ||
+            (field.type === 'number' && actual === 'string' && value !== '' && !isNaN(Number(value)));
+        if (!ok)
+            errs.push(`input "${field.name}" expected ${field.type}, got ${actual}`);
+    }
+}
+/**
+ * The closest declared field name to `key`, for the "did you mean …?" half of an
+ * unknown-input error.
+ *
+ * Three rules, tried in order: an exact case-insensitive match (`pagesize` →
+ * `pageSize`), a substring either way (`summary` → `fields.summary`), and — the
+ * one added for query/path parameters — a small EDIT DISTANCE. The first two miss
+ * every substitution typo: `projekt` and `project` share no containment, so the
+ * suggestion was simply absent, and it is absent exactly where it is needed most.
+ * Parameter names are unfamiliar (`issuetype`, `nextPage`, `expansionLevel`), so
+ * the author has no memory to fall back on.
+ *
+ * The threshold scales with the name's length (⌈len/4⌉, at least 1, at most 3), so
+ * a short name needs a near-exact miss and a long one may be off by a few — and
+ * two genuinely different fields are never conflated.
+ */
+function nearestField(key, names) {
+    const lk = key.toLowerCase();
+    const exact = names.find((n) => n.toLowerCase() === lk);
+    if (exact)
+        return exact;
+    const contained = names.find((n) => n.toLowerCase().includes(lk) || lk.includes(n.toLowerCase()));
+    if (contained)
+        return contained;
+    const budget = Math.min(3, Math.max(1, Math.ceil(lk.length / 4)));
+    let best;
+    let bestD = budget + 1;
+    for (const n of names) {
+        const d = editDistance(lk, n.toLowerCase());
+        if (d < bestD) {
+            bestD = d;
+            best = n;
+        }
+    }
+    return bestD <= budget ? best : undefined;
+}
+/** Levenshtein distance, two rows — enough for field-name suggestions. */
+function editDistance(a, b) {
+    if (a === b)
+        return 0;
+    if (Math.abs(a.length - b.length) > 3)
+        return 99; // cheap bail: beyond any budget
+    let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+    for (let i = 1; i <= a.length; i++) {
+        const row = [i];
+        for (let j = 1; j <= b.length; j++) {
+            row[j] = Math.min(prev[j] + 1, row[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+        prev = row;
+    }
+    return prev[b.length];
+}

package/dist/core/event-checks.d.ts

@@ -0,0 +1,137 @@
+/**
+ * core/event-checks — the connector-EVENT rules, shared by every family that can
+ * subscribe to one.
+ *
+ * The activity twin is `core/connector-checks.ts`. These were Flow's, and like
+ * those they were never flow-shaped: both functions take the subscription as
+ * `unknown` and duck-type `{ connector, event, where, object, filters, version,
+ * connection }`, because that is all they need. BPMN's `.eventTrigger()` /
+ * `.waitForEvent()` node carries the same facts under its own names, and
+ * `bpmn/check.ts` adapts one to the other.
+ *
+ * What BPMN does NOT carry is `filters` — payload filtering is a Flow surface —
+ * so the `EVENT_FILTER_*` family simply does not fire there. The rules that do
+ * are the ones about the SUBSCRIPTION: whether it resolves at all, whether a
+ * generic event named its object, and whether its scope names parameters the
+ * operation actually declares. `skill-bpmn-outlook-waitfor-email` in
+ * `flow-v2-run-8` failed on exactly that last question.
+ */
+import { type LookupResolutions } from './lookups.js';
+import { type ByoaEventFacts, type ByoaLedger } from './byoa.js';
+import type { BindingsView } from './binding-messages.js';
+/** A code/message sink, as each family's check supplies one. */
+export type ReportEvent = (code: string, message: string, suggestion?: string) => void;
+/**
+ * What a connector operation declares as its EVENT PARAMETERS — the `where` half
+ * of a subscription. `known: false` means "no library was supplied", which is a
+ * different answer from `known: true, names: []` ("this operation takes none").
+ * Conflating the two is what made `EVENT_NO_SCOPE` an error for the HTTP Webhook
+ * connector, whose only correct `where` is empty.
+ */
+export interface EventParamFields {
+    known: boolean;
+    names: string[];
+    /**
+     * The operation is a GENERIC event (`activityType: GenericTrigger`): its node type
+     * covers every object of the connection, so the subscription must name one with
+     * `object`. Unknown (no library) reads as `false`, which fails open.
+     */
+    generic?: boolean;
+    /** The entry's own object — `''` for a generic event, the built-in one for a curated event. */
+    object?: string;
+    /**
+     * Required parameters that SELECT the schema rather than scope the
+     * subscription (Jira's `project` / `issuetype`). Their values decide which
+     * filter and output fields exist, and no CLI surface accepts them — so when
+     * this is non-empty the known filter vocabulary is a BASELINE, and a leaf
+     * outside it may still be legal.
+     */
+    selectors?: string[];
+    /**
+     * The named object has no prepared variant on a connector whose objects come
+     * from the connection — the generic template answered instead.
+     */
+    objectUnprepared?: boolean;
+    /**
+     * The connector discovers custom fields per connection and nothing has
+     * prepared this event, so the known vocabulary is a strict subset of the
+     * tenant's BY DESIGN.
+     */
+    customFieldsUnprepared?: boolean;
+    /**
+     * The filter vocabulary is a subset that NO prepare can complete.
+     *
+     * An activity closes this gap: `resources describe` takes `-f name=value`
+     * and `--action`, so supplying the parent values runs the connector's
+     * ObjectAction (Jira `GenerateSchema`, Salesforce `GenerateQuerySchema`) and
+     * the custom fields come back. `uip is triggers describe` has neither flag,
+     * so for an EVENT on a custom-field-discovering connector there is no call
+     * that reaches the parent-scoped fields — the designer grows Jira's filter
+     * list once a project and issue type are picked, and nothing in this CLI
+     * can. Distinct from `customFieldsUnprepared`, which preparing DOES fix.
+     */
+    filtersPartial?: boolean;
+}
+/** The library-backed facts the event rules need, or `undefined` for "no library". */
+export interface EventCheckOpts {
+    /** A connector event's declared event PARAMETERS — the `where` half of a subscription. */
+    eventParams?: (connector: string, event: string, object?: string) => EventParamFields | undefined;
+    /** What `compile` would refuse a subscription with, or `undefined` when it resolves. */
+    eventResolveError?: (kind: 'trigger' | 'event', subscription: {
+        connector: string;
+        event: string;
+        version?: string;
+        object?: string;
+    }) => string | undefined;
+    /** A connector event's FILTERABLE field names — the vocabulary a `filters` leaf may name. */
+    eventFilterFields?: (connector: string, event: string, object?: string) => string[] | undefined;
+    /** A connector event's BYOA and webhook-URL facts, or `undefined` when unknown. */
+    eventFacts?: (connector: string, event: string, object?: string) => ByoaEventFacts | undefined;
+    /** The BYOA checks `registry prepare` recorded. */
+    byoa?: ByoaLedger;
+    /** Everything `registry prepare --resolve` has recorded in the local overlay. */
+    resolutions?: LookupResolutions;
+    /** The project's `bindings.json`, for the BYOA connection check. */
+    bindings?: BindingsView;
+}
+/**
+ * Ask the library what event parameters a subscription's operation declares.
+ * Returns `undefined` when the subscription is too broken to look up (its own
+ * diagnostics say so) or when no resolver was supplied — both mean "unknown", and
+ * unknown fails open.
+ */
+export declare function eventParamsFor(subscription: unknown, opts: EventCheckOpts): EventParamFields | undefined;
+/**
+ * The event-side resolution rules — the trigger twin of `checkConnectorLookups`,
+ * plus three rules with no activity counterpart:
+ *
+ * - `EVENT_UNKNOWN` — an ERROR: a library is loaded and it cannot resolve the
+ *   subscription, so `compile` will refuse it. The message is the resolver's
+ *   own (`eventResolveError`), the same text compile throws. Checked first; when
+ *   it fires, EVENT_UNPREPARED and the filter rules below are skipped for this
+ *   subscription, since there is no entry for them to read.
+ * - `EVENT_UNPREPARED` — the event RESOLVES but the library knows nothing
+ *   about its parameters (or no `eventResolveError` resolver was supplied):
+ *   the fallback case for a connector the shipped library was not generated
+ *   against. A warning, because compile still succeeds. Prints the one
+ *   command that makes the event checkable.
+ * - `EVENT_BYOA_UNVERIFIED` — an ERROR: the event only fires on a BYOA
+ *   (bring-your-own-app) connection, and the bound connection id has no record
+ *   of `prepare` having checked it (`core/byoa.ts` has the rule and when it
+ *   stays silent). A standard connection deploys and the trigger never fires;
+ *   the usual way in is binding the connection by preparing one of the
+ *   connector's ACTIONS, which checks nothing about BYOA. `compile` throws the
+ *   same text.
+ * - `EVENT_FILTER_UNKNOWN_FIELD` — a filter leaf naming a field outside the
+ *   prepared vocabulary is an ERROR, not a warning, because the platform's own
+ *   configure DROPS an unmatched leaf and reports Success: the deployed
+ *   trigger then fires on events the filter should exclude, silently. Matching
+ *   is case-sensitive, so the near-miss hint checks case first. When the
+ *   vocabulary is unknown or known-empty this stays quiet — fail open.
+ *
+ * Unresolved `where` lookups follow the activity rule exactly: a WARNING here
+ * (compile repeats it as the hard failure), with the recorded answer looked up
+ * under the event-form node type — the form `prepare` stores.
+ */
+export declare function checkEventResolution(subscription: unknown, where: string, kind: 'trigger' | 'event', opts: EventCheckOpts, error: (code: string, message: string, suggestion?: string) => void, warn: (code: string, message: string, suggestion?: string) => void, eventParams?: EventParamFields): void;
+export declare function checkEventSubscription(subscription: unknown, where: string, at: (code: string, message: string, suggestion?: string) => void, warn?: (code: string, message: string, suggestion?: string) => void, eventParams?: EventParamFields): void;