@uipath/maestro-builder-sdk 6.14.5 → 6.15.0

package/dist/check.d.ts

@@ -1,8 +1,7 @@
-import { type LookupResolutions, type LookupSpec } from './core/lookups.js';
-import type { SchemaReadiness } from './core/library.js';
 import type { BuiltFlow } from './flow-sdk.js';
-import { type BindingsView } from './core/binding-messages.js';
-import { type ByoaEventFacts, type ByoaLedger } from './core/byoa.js';
+import { type EventCheckOpts } from './core/event-checks.js';
+export type { EventParamFields } from './core/event-checks.js';
+import { type ConnectorCheckOpts } from './core/connector-checks.js';
 export interface Diagnostic {
     level: 'error' | 'warning';
     code: string;
@@ -10,157 +9,26 @@ export interface Diagnostic {
     step?: string;
     suggestion?: string;
 }
-/**
- * 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;
-}
 export interface ListEnvelopeFields {
     envelope: string | null;
     source: string;
     tier: string;
 }
-export interface CheckOpts {
-    /**
-     * Resolve a connector event's declared event parameters, by connector key and
-     * event name. Supplied by `check-cli` when `$FLOW_SDK_LIBRARY_JSON` points at a
-     * library; omitted (and so unknown) otherwise.
-     *
-     * A function rather than a `Library`, on purpose: `check` stays a pure function
-     * of the built flow plus this one lookup, so it needs no library at all to run
-     * and cannot be slowed down by one.
-     */
-    eventParams?: (connector: string, event: string, object?: string) => EventParamFields | undefined;
-    /**
-     * What `compile` would refuse a connector event subscription with, or
-     * `undefined` when the library resolves it. `kind` is the node form compile
-     * asks for: `trigger` for `onEvent` (the flow's trigger and every entry point),
-     * `event` for `waitForEvent`. Supplied by the CLIs from the same
-     * `library.resolveEvent(kind, connector, event, version, object)` call
-     * `serialize` makes (`eventResolveErrorFor` in `cli-library.ts`), so the two
-     * cannot disagree; omitted (no library) → not checked.
-     *
-     * Before this hook `check` could only warn EVENT_UNPREPARED here, because
-     * `eventParams` answers `undefined` for "cannot resolve" and for "no facts"
-     * alike: it printed `0 error(s)` on a source `compile` then refused
-     * (2026-09-23, `skill-flow-datafabric-trigger-lifecycle`, v2 commands 31 and 46).
-     */
-    eventResolveError?: (kind: 'trigger' | 'event', subscription: {
-        connector: string;
-        event: string;
-        version?: string;
-        object?: string;
-    }) => string | undefined;
-    /**
-     * Resolve a connector event's FILTERABLE field names — the vocabulary a
-     * `filters` leaf may name — sourced the same way as `eventParams`. A GENERIC
-     * event's vocabulary is per object, so the subscription's `object` rides
-     * along. `undefined` means unknown and fails open; a known-EMPTY list also
-     * fails open, because connectors that declare no filter fields exist and
-     * refusing every leaf on their events would turn a coverage gap into a
-     * false error.
-     */
-    eventFilterFields?: (connector: string, event: string, object?: string) => string[] | undefined;
-    /**
-     * Resolve one connector operation's generated lookup table, keyed by field.
-     *
-     * Supplied by the CLIs when a library is on hand, omitted otherwise — so a
-     * `check` with no library simply does not fire the lookup rules rather than
-     * guessing at them.
-     */
-    lookups?: (connector: string, action: string, version?: string, object?: string) => Readonly<Record<string, LookupSpec>> | undefined;
-    /** Everything `registry prepare --resolve` has recorded in the local overlay. */
-    resolutions?: LookupResolutions;
-    /**
-     * A connector event's BYOA and webhook-URL facts, or `undefined` when unknown.
-     * Supplied by the CLIs from `library.eventFacts` — the call `serialize` makes
-     * for the same refusal — so check and compile cannot disagree; omitted (no
-     * library) → EVENT_BYOA_UNVERIFIED is not checked.
-     */
-    eventFacts?: (connector: string, event: string, object?: string) => ByoaEventFacts | undefined;
-    /**
-     * The BYOA checks `registry prepare` recorded — the `byoa` section of the
-     * overlay's `resolutions.json`, as `library.byoaVerifications` loads it.
-     */
-    byoa?: ByoaLedger;
-    /**
-     * Whether a connector step's schema is materialized locally — the fact behind
-     * the OBJECT_UNPREPARED and CUSTOM_FIELDS_UNPREPARED warnings. Supplied by the
-     * CLIs when a library is on hand, omitted otherwise, same as `lookups`: with
-     * no library, `check` cannot know what is owed and says nothing.
-     */
-    schemaReadiness?: (connector: string, action: string, version?: string, object?: string) => SchemaReadiness | undefined;
+/**
+ * The facts `check` cannot derive from the built flow.
+ *
+ * Two of the three bags are shared with the other families — the connector rules
+ * (`core/connector-checks.ts`) and the event rules (`core/event-checks.ts`) were
+ * never flow-shaped. What is left here is the one hook only Flow has a site for.
+ *
+ * Every member is optional and every rule that reads one fails OPEN: `check` is
+ * the fast inner-loop rung and stays a pure function of the built flow without a
+ * library. Given one, `compile` and `check` make the SAME call with the facts in
+ * hand, which is what keeps the two rungs from disagreeing.
+ */
+export interface CheckOpts extends ConnectorCheckOpts, EventCheckOpts {
     /** Resolve the measured collection envelope for one connector operation. */
     listEnvelope?: (connector: string, operation: string, version?: string, object?: string) => ListEnvelopeFields | undefined;
-    /**
-     * What `compile` would refuse one connector step's inputs with — a missing
-     * required field, an unknown or mistyped input, a container part given a value —
-     * or `undefined` when it would accept them. Supplied by the CLIs from the same
-     * library-backed validator `serialize` runs (`connectorInputErrors`), so the
-     * inner loop and the emit rung cannot disagree; omitted (no library) → not checked.
-     * Before this hook, `check` printed `0 error(s)` for a source `compile` then
-     * refused twice in a row (teams-decision, 2026-09-01, turns 22–25).
-     */
-    connectorInputs?: (spec: {
-        key: string;
-        action: string;
-        version?: string;
-        object?: string;
-    }, inputs: Record<string, unknown>) => string | undefined;
-    /**
-     * The project's `bindings.json`, when there is one — enough of it to detect the
-     * two labels `compile` refuses: an entry that answers with its own name
-     * (BINDING_SELF_NAME), and a label a populated file does not declare
-     * (BINDING_UNDECLARED). `declared` and `entry` are optional so a caller holding
-     * only `resolve` still gets the first rule; the `Bindings` class has all three.
-     */
-    bindings?: BindingsView;
 }
 export declare function check(built: BuiltFlow, opts?: CheckOpts): Diagnostic[];
 /**