@uipath/maestro-builder-sdk 6.3.0 → 6.5.0

package/dist/registry/library-build/events.js

@@ -0,0 +1,476 @@
+/**
+ * Connector EVENTS — triggers and mid-flow waits — from `_events.py` and the
+ * event half of `generate_library_json.py`.
+ *
+ * Events have their own twin pair of CLI calls: `uip is triggers objects`
+ * answers PER EVENT OBJECT (the catalog a generic event ranges over, and per
+ * object the `Parameters` it contributes), `uip is triggers describe` answers
+ * PER (event, object) (`EventParameters`, `FilterFields`, `OutputFields`).
+ * The complete input set is the UNION of the two, required if EITHER side says
+ * required — a field can appear in one and not the other, so neither call alone
+ * is trusted.
+ *
+ * Key order in every field record is the Python's dict order, because these
+ * fields are written into the library and the sidecar with `json.dump`.
+ */
+import { sortedStrings } from "../compat/compare.js";
+import { lowerFirst, pyStr, pyStrip, startsWithUpper } from "../compat/pystr.js";
+import { mapConcurrent } from "../concurrency.js";
+import { Refusal } from "../errors.js";
+import { isTriggersDescribe, isTriggersObjects } from "../uip/commands.js";
+import { safeCacheName } from "../uip/response-cache.js";
+import { schemaCacheScope, writeCache } from "./context.js";
+import { objectsComeFromTheConnection } from "./generic-expand.js";
+import { codePointSlice, deepCopy, get, isRecord, item, pyIter, pyOr, truthy } from "./py.js";
+/**
+ * `Parameters[].type` on a `triggers objects` row routes the value into one of
+ * three `--detail` buckets at emit time. Everything unrecognized is an event
+ * parameter — the designer's own fallback. A `Map`, not an object, because
+ * `_BUCKETS.get(…)` on a dict answers `None` for `"constructor"` where a plain
+ * object would answer `Object`'s constructor function.
+ */
+const BUCKETS = new Map([
+    ["query", "query"],
+    ["path", "path"],
+]);
+/** A trigger metadata call failed, with the reason and the way forward. */
+export class EventDiscoveryError extends Refusal {
+    refused;
+    constructor(message, 
+    /**
+     * True when the call was never made — the client refused it (`--offline`).
+     * Such a failure is not an answer from the tenant and must not be cached
+     * as one; see {@link triggersObjectsCached}.
+     */
+    refused = false) {
+        super(message, "EVENT_DISCOVERY");
+        this.refused = refused;
+        this.name = "EventDiscoveryError";
+    }
+}
+/** `str(value)` for a message, tolerating the shapes `pyStr` refuses. */
+function pyFormat(value) {
+    try {
+        return pyStr(value);
+    }
+    catch {
+        return JSON.stringify(value);
+    }
+}
+/** `_run_json`: the whole of stdout as one `Result: Success` envelope, or an {@link EventDiscoveryError}. */
+async function runJson(client, argv, timeoutMs) {
+    const result = await client.run(argv, timeoutMs === undefined ? undefined : { timeoutMs });
+    const head = `\`${argv.slice(0, 5).join(" ")} …\``;
+    let payload;
+    try {
+        payload = JSON.parse(result.stdout);
+    }
+    catch {
+        const text = codePointSlice(pyStrip(result.stderr || result.stdout), 0, 300);
+        throw new EventDiscoveryError(`${head} did not answer JSON: ${text || "no output"}`, result.refused === true);
+    }
+    if (get(payload, "Result") !== "Success") {
+        // `refused` is carried here too, although the refusing client in this tree
+        // answers with empty stdout and so always fails the parse above. The rule
+        // the cache depends on is "a call that never ran is never remembered", and
+        // that rule should not rest on what a client happens to put on stdout.
+        throw new EventDiscoveryError(`${head} failed: ${pyFormat(pyOr(get(payload, "Message"), get(payload, "Result")))}`, result.refused === true);
+    }
+    return payload;
+}
+/**
+ * `triggers_objects`: the event objects for `(connector, operation)`, PascalCase
+ * rows. `connectionId` is optional; a connector whose objects do not come from
+ * the connection answers identically either way.
+ */
+export async function triggersObjects(client, key, operation, connectionId, timeoutMs) {
+    const payload = await runJson(client, isTriggersObjects(key, operation, connectionId), timeoutMs);
+    let data = get(payload, "Data");
+    if (isRecord(data))
+        data = get(data, "items");
+    return Array.isArray(data) ? data : [];
+}
+/** `triggers_describe`: `EventParameters` / `FilterFields` / `OutputFields` for one object. */
+export async function triggersDescribe(client, key, operation, objectName, connectionId, timeoutMs) {
+    const payload = await runJson(client, isTriggersDescribe(key, operation, objectName, connectionId), timeoutMs);
+    return pyOr(get(payload, "Data"), {});
+}
+/** `k[0].lower() + k[1:] if k[:1].isupper() else k`. */
+function lowerKey(k) {
+    return startsWithUpper(k) ? lowerFirst(k) : k;
+}
+/** `_camelize`: lower-case the first letter of every key, recursively. */
+export function camelize(value) {
+    if (isRecord(value)) {
+        const out = {};
+        for (const [k, v] of Object.entries(value))
+            out[lowerKey(k)] = camelize(v);
+        return out;
+    }
+    if (Array.isArray(value))
+        return value.map(camelize);
+    return value;
+}
+/** The top-level-only key lowering `camel_fields` and `normalize_bucket_fields` do inline. */
+function lowerTop(f) {
+    const low = {};
+    for (const [k, v] of Object.entries(f))
+        low[lowerKey(k)] = v;
+    return low;
+}
+/** `_is_hidden`: a hidden parameter that is safe to DROP — hidden and optional. */
+export function isHidden(low) {
+    const raw = pyOr(get(low, "design"), {});
+    if (!isRecord(raw))
+        return false;
+    const design = camelize(raw);
+    const hidden = truthy(pyOr(get(design, "isHidden"), get(design, "hidden")));
+    return hidden && !truthy(get(low, "required"));
+}
+/** `_keep_hidden_marker`: flag a kept parameter the designer hides (necessarily a required one). */
+export function keepHiddenMarker(low, field) {
+    const design = camelize(pyOr(get(low, "design"), {}));
+    if (isRecord(design) && truthy(pyOr(get(design, "isHidden"), get(design, "hidden"))))
+        field.hidden = true;
+    return field;
+}
+/** `(f.get("sortOrder") is None, f.get("sortOrder") or 0)`. */
+function sortOrderKey(f) {
+    const so = get(f, "sortOrder");
+    return [so === null ? 1 : 0, truthy(so) ? so : 0];
+}
+/**
+ * `_with_cascade`: mark each parameter that another one has to resolve before
+ * it, then order by the designer's `sortOrder` (unset last), stably.
+ */
+export function withCascade(fields) {
+    const names = new Set(fields.map((f) => get(f, "name")));
+    for (const field of fields) {
+        const reference = pyOr(get(field, "reference"), {});
+        const path = pyStr(pyOr(get(reference, "path"), ""));
+        const explicit = pyIter(pyOr(get(reference, "dependsOn"), []));
+        const own = get(field, "name");
+        const depends = sortedStrings([...names]
+            .filter((other) => truthy(other) && other !== own && (path.includes(`{${pyStr(other)}}`) || explicit.includes(other)))
+            .map((other) => pyStr(other)));
+        if (depends.length > 0) {
+            field.dependsOn = depends;
+            if (!("dependsOn" in reference))
+                reference.dependsOn = depends;
+        }
+    }
+    fields.sort((a, b) => {
+        const ka = sortOrderKey(a);
+        const kb = sortOrderKey(b);
+        if (ka[0] !== kb[0])
+            return ka[0] - kb[0];
+        const x = ka[1];
+        const y = kb[1];
+        return x < y ? -1 : x > y ? 1 : 0;
+    });
+    return fields;
+}
+/** `camel_fields`: describe/objects fields normalized to the registry's camelCase shape. */
+export function camelFields(fields) {
+    const out = [];
+    for (const f of pyIter(pyOr(fields, []))) {
+        if (!isRecord(f))
+            continue;
+        const low = lowerTop(f);
+        const name = get(low, "name");
+        if (!truthy(name))
+            continue;
+        if (isHidden(low))
+            continue;
+        const field = { name };
+        for (const k of ["displayName", "description", "required", "dataType", "sortOrder"]) {
+            if (get(low, k) !== null)
+                field[k] = low[k];
+        }
+        if (get(low, "reference") !== null)
+            field.reference = camelize(low.reference);
+        keepHiddenMarker(low, field);
+        // Describe's `Type` is the DATA type; an objects-row Parameter's `type` is
+        // the BUCKET — those go through `normalizeBucketFields` instead.
+        if (get(low, "type") !== null && !("dataType" in field)) {
+            field.type = low.type;
+            field.dataType = low.type;
+        }
+        else if ("dataType" in field) {
+            field.type = field.dataType;
+        }
+        out.push(field);
+    }
+    return out;
+}
+/** `normalize_bucket_fields`: `triggers objects → Parameters[]` rows, camelCase, bucket made explicit. */
+export function normalizeBucketFields(parameters) {
+    const out = [];
+    for (const f of pyIter(pyOr(parameters, []))) {
+        if (!isRecord(f))
+            continue;
+        const low = lowerTop(f);
+        const name = get(low, "name");
+        if (!truthy(name))
+            continue;
+        if (isHidden(low))
+            continue;
+        const field = {
+            name,
+            bucket: BUCKETS.get(pyStr(pyOr(get(low, "type"), "")).toLowerCase()) ?? "event",
+        };
+        for (const k of ["displayName", "description", "required", "sortOrder"]) {
+            if (get(low, k) !== null)
+                field[k] = low[k];
+        }
+        if (get(low, "reference") !== null)
+            field.reference = camelize(low.reference);
+        const dataType = pyOr(get(low, "dataType"), "string");
+        field.type = dataType;
+        field.dataType = dataType;
+        keepHiddenMarker(low, field);
+        out.push(field);
+    }
+    return out;
+}
+/**
+ * `union_event_parameters`: describe's EventParameters ∪ the object row's
+ * Parameters, deduped by name; `required` is an OR; the object row's bucket
+ * survives the merge.
+ */
+export function unionEventParameters(declared, objectParameters) {
+    const merged = new Map();
+    for (const field of camelFields(declared)) {
+        if (!("bucket" in field))
+            field.bucket = "event";
+        merged.set(field.name, field);
+    }
+    for (const field of normalizeBucketFields(objectParameters)) {
+        const existing = merged.get(field.name);
+        if (existing === undefined) {
+            merged.set(field.name, field);
+            continue;
+        }
+        existing.required = truthy(get(existing, "required")) || truthy(get(field, "required"));
+        existing.bucket = field.bucket;
+        for (const k of ["displayName", "description", "reference", "sortOrder"]) {
+            if (get(field, k) !== null && get(existing, k) === null)
+                existing[k] = field[k];
+        }
+    }
+    return withCascade([...merged.values()]);
+}
+const EVENT_FACTS = [
+    ["EventMode", "eventMode"],
+    ["ByoaConnection", "byoaConnection"],
+    ["IsWebhookUrlVisible", "isWebhookUrlVisible"],
+];
+/** `merge_describe_into_node`: fold a `triggers describe` answer into a registry trigger definition (a copy). */
+export function mergeDescribeIntoNode(node, describe, objectParameters = null) {
+    const out = { ...node };
+    out.eventParameters = { fields: unionEventParameters(get(describe, "EventParameters"), objectParameters) };
+    out.filterFields = { fields: camelFields(get(describe, "FilterFields")) };
+    if (truthy(get(describe, "OutputFields"))) {
+        out.outputResponseDefinition = { fields: camelFields(get(describe, "OutputFields")) };
+    }
+    for (const [src, dst] of EVENT_FACTS)
+        if (get(describe, src) !== null)
+            out[dst] = describe[src];
+    return out;
+}
+/** `event_facts`: the three facts that change how a subscription is prepared or tested; the object row wins. */
+export function eventFacts(node, objectRow) {
+    const row = pyOr(objectRow, {});
+    const fact = (rowKey, nodeKey, dflt) => {
+        if (get(row, rowKey) !== null)
+            return row[rowKey];
+        if (get(node, nodeKey) !== null)
+            return node[nodeKey];
+        return dflt;
+    };
+    const textBlocks = pyOr(get(pyOr(get(row, "Design"), {}), "TextBlocks"), get(pyOr(get(row, "design"), {}), "textBlocks"), []);
+    return {
+        eventMode: pyStr(pyOr(get(node, "eventMode"), "polling")),
+        byoaConnection: truthy(fact("ByoaConnection", "byoaConnection", false)),
+        isWebhookUrlVisible: truthy(fact("IsWebhookUrlVisible", "isWebhookUrlVisible", false)),
+        textBlocks: pyIter(textBlocks).map((t) => pyStr(t)),
+    };
+}
+// ---------------------------------------------------------------------------
+// The generator's cached event calls and its event passes
+// ---------------------------------------------------------------------------
+/**
+ * `triggers_objects_cached`: cached `uip is triggers objects <key> <OPERATION>`,
+ * called WITHOUT a connection on purpose. A failure is reported and cached as
+ * an empty catalog — a REAL failure, that is. The Python had no offline mode,
+ * so every failure it cached was the tenant's answer. Under `--offline` the
+ * client refuses the call instead; caching that as `{objects: []}` would make
+ * the next ONLINE build over the same `--keep-temp` caches see an empty event
+ * catalogue and expand nothing, silently. So a refusal is reported and used,
+ * but never written down. (The four describe/list helpers in `context.ts` now
+ * apply the same rule explicitly. They used to rest on an accident — a
+ * refusal's empty stdout is not JSON, so they returned before their cache
+ * write — which held only for as long as the offline client wrote nothing to
+ * stdout. That is precisely the accident this flag replaced, so they check the
+ * flag instead.)
+ */
+export async function triggersObjectsCached(ctx, key, operation) {
+    const name = `${safeCacheName(schemaCacheScope(ctx), key, operation, "_trigger_objects")}.json`;
+    if (ctx.caches.is.has(name))
+        return pyOr(get(ctx.caches.is.read(name), "objects"), []);
+    let rows = [];
+    try {
+        rows = await triggersObjects(ctx.client, key, operation, undefined, ctx.timeoutMs);
+    }
+    catch (error) {
+        if (!(error instanceof EventDiscoveryError))
+            throw error;
+        ctx.reporter.warn(`  WARN: trigger objects failed for ${key} ${operation}: ${error.message}`);
+        if (error.refused)
+            return rows;
+    }
+    writeCache(ctx.caches.is, name, { objects: rows });
+    return rows;
+}
+/**
+ * `triggers_describe_cached`: cached `uip is triggers describe <key> <OPERATION> <object>`.
+ * A refused call is not cached, for the reason given on {@link triggersObjectsCached}.
+ */
+export async function triggersDescribeCached(ctx, key, operation, objectName) {
+    const name = `${safeCacheName(schemaCacheScope(ctx), key, operation, objectName, "_trigger_describe")}.json`;
+    if (ctx.caches.is.has(name))
+        return pyOr(get(ctx.caches.is.read(name), "describe"), {});
+    let data = {};
+    try {
+        data = await triggersDescribe(ctx.client, key, operation, objectName, undefined, ctx.timeoutMs);
+    }
+    catch (error) {
+        if (!(error instanceof EventDiscoveryError))
+            throw error;
+        ctx.reporter.warn(`  WARN: trigger describe failed for ${key} ${operation} ${objectName}: ${error.message}`);
+        if (error.refused)
+            return data;
+    }
+    writeCache(ctx.caches.is, name, { describe: data });
+    return data;
+}
+/**
+ * `_apply_event_schema`: put an event's OWN schema on the entry, replacing the
+ * node manifest's. `inputSchema` becomes the union rule's answer; `eventSchema`
+ * is appended to the entry and later stamped onto the sidecar.
+ */
+export function applyEventSchema(entry, describe, obj) {
+    const e = entry;
+    const d = pyOr(describe, {});
+    const o = pyOr(obj, {});
+    const fields = unionEventParameters(get(d, "EventParameters"), get(o, "Parameters"));
+    e.inputSchema = { fields };
+    const outputFields = camelFields(get(d, "OutputFields"));
+    if (outputFields.length > 0)
+        e.outputSchema = { fields: outputFields };
+    const eventSchema = { eventParameters: fields, filterFields: camelFields(get(d, "FilterFields")) };
+    for (const [src, dst] of EVENT_FACTS)
+        if (get(d, src) !== null)
+            eventSchema[dst] = d[src];
+    e.eventSchema = eventSchema;
+    return entry;
+}
+/** `_describe_curated_events`: give each CURATED event its own schema, in place. */
+export async function describeCuratedEvents(ctx, entries) {
+    if (entries.length === 0)
+        return;
+    const results = await mapConcurrent(entries, ctx.concurrency, async (entry) => {
+        const key = item(item(entry, "connector"), "key");
+        const operation = item(entry, "operation");
+        const eventOperation = pyOr(get(operation, "eventOperation"), "");
+        const objectName = pyOr(get(operation, "objectName"), "");
+        if (!truthy(eventOperation) || !truthy(objectName))
+            return [entry, null, null];
+        const rows = await triggersObjectsCached(ctx, key, eventOperation);
+        const obj = rows.find((r) => get(r, "Name") === objectName) ?? null;
+        return [entry, await triggersDescribeCached(ctx, key, eventOperation, objectName), obj];
+    });
+    let described = 0;
+    for (const [entry, describe, obj] of results) {
+        if (!truthy(describe))
+            continue;
+        applyEventSchema(entry, describe, obj);
+        described += 1;
+    }
+    ctx.reporter.info(`  ${described}/${entries.length} curated events described (subscription parameters, filter fields, payload)`);
+}
+/**
+ * `_make_expanded_event_entry`: one per-object variant of a generic connector
+ * EVENT. The variant keeps `activityType: GenericTrigger` and the template's
+ * nodeType deliberately; the object rides on `operation.objectName`.
+ */
+export function makeExpandedEventEntry(template, obj, describe) {
+    const entry = deepCopy(template);
+    const objectName = pyOr(get(obj, "Name"), "");
+    const objectDisplay = pyOr(get(obj, "DisplayName"), objectName);
+    const operation = item(entry, "operation");
+    operation.objectName = objectName;
+    operation.objectDisplayName = objectDisplay;
+    operation.sourceNodeType = item(template, "nodeType");
+    const label = pyOr(get(pyOr(get(template, "display"), {}), "label"), "");
+    item(entry, "display").label = pyStrip(`${pyStr(label)} (${pyStr(objectDisplay)})`);
+    return applyEventSchema(entry, describe, obj);
+}
+/**
+ * `_expand_generic_events`: expand each generic EVENT template into one entry
+ * per event object. Variants come back in template × object order (the Python
+ * appended them as the describes completed); `build` sorts them before
+ * planning.
+ */
+export async function expandGenericEvents(ctx, templates) {
+    if (templates.length === 0)
+        return [];
+    const work = [];
+    for (const template of templates) {
+        const key = item(item(template, "connector"), "key");
+        const operation = pyOr(get(item(template, "operation"), "eventOperation"), "");
+        if (!truthy(operation))
+            continue;
+        for (const obj of await triggersObjectsCached(ctx, key, operation)) {
+            if (truthy(get(obj, "Name")))
+                work.push([template, key, operation, obj]);
+        }
+    }
+    if (work.length === 0)
+        return [];
+    const describes = await mapConcurrent(work, ctx.concurrency, ([, key, operation, obj]) => triggersDescribeCached(ctx, key, operation, item(obj, "Name")));
+    const expanded = work.map(([template, , , obj], i) => makeExpandedEventEntry(template, obj, pyOr(describes[i], {})));
+    ctx.reporter.info(`  ${expanded.length} generic EVENT variants expanded from ${templates.length} template(s)`);
+    return expanded;
+}
+/**
+ * `resolve_connector_events`: give every connector EVENT its real schema;
+ * expand the expandable ones. Returns `[entries, expanded]` — `entries` is the
+ * input with curated events described in place.
+ */
+export async function resolveConnectorEvents(ctx, entries) {
+    const curated = [];
+    const generic = [];
+    for (const e of entries) {
+        const at = get(item(e, "operation"), "activityType", "");
+        if (at === "CuratedTrigger") {
+            curated.push(e);
+        }
+        else if (at === "GenericTrigger") {
+            // UNKNOWN is not "static": expand only where the connector positively
+            // says its objects do not come from the connection.
+            const discovery = get(pyOr(get(e, "connector"), {}), "discovery");
+            if (!truthy(discovery)) {
+                ctx.reporter.warn(`  WARN: ${item(e, "nodeType")} not expanded — no connector discovery metadata, so whether its ` +
+                    "objects come from the connection is unknown");
+            }
+            else if (!objectsComeFromTheConnection(e)) {
+                generic.push(e);
+            }
+        }
+    }
+    if (curated.length === 0 && generic.length === 0)
+        return [entries, []];
+    await describeCuratedEvents(ctx, curated);
+    return [entries, await expandGenericEvents(ctx, generic)];
+}

package/dist/registry/library-build/generic-expand.d.ts

@@ -0,0 +1,77 @@
+import type { LibraryEntry } from "../model/library.js";
+import { type BuildContext } from "./context.js";
+import { type Dict } from "./py.js";
+/** `{op_name: template}` for one connector, in first-seen order. */
+export type TemplatesByOp = Map<string, LibraryEntry>;
+/**
+ * `_generic_templates_by_op`: bucket Generic CRUD entries by IS operation
+ * name per connector. Generic CRUD actions carry an `operation` verb
+ * (`Create`/`Delete`/`Retrieve`/`List`/`Update`/`Replace`) but no
+ * `httpMethod`; the IS catalog returns the same verbs under
+ * `AvailableOperations[].Name`.
+ */
+export declare function genericTemplatesByOp(genericEntries: readonly LibraryEntry[]): Map<string, TemplatesByOp>;
+/**
+ * `_make_expanded_entry`: one expanded entry from a Generic template + an
+ * (object, op) pair. `obj` is a `resources list` row, `op` an element of
+ * `AvailableOperations`, `opData` the per-operation describe `Data` (may be
+ * absent — the entry is still built, with an empty schema). The template's
+ * discovery flag is copied, never inferred from field counts.
+ */
+export declare function makeExpandedEntry(template: LibraryEntry, obj: unknown, op: unknown, opData: unknown): LibraryEntry;
+/** `_unique_by_name`: first occurrence of each `Name`, in order. */
+export declare function uniqueByName(objects: unknown): Map<string, Dict>;
+/**
+ * `_list_generic_objects`: list and deduplicate the objects available to one
+ * connector. When the caller named specific objects and the catalog does not
+ * contain them, retry once with a refresh before believing it — a stale
+ * `uip is resources list` cache reports a real object as missing.
+ */
+export declare function listGenericObjects(ctx: BuildContext, connectorKey: string, templatesByOp: TemplatesByOp, objectNames?: readonly string[]): Promise<Dict[]>;
+/**
+ * `expand_generic_for_connector`: materialize per-(object, op) entries for one
+ * connector, sequentially — the shape `prepare` uses. `objectNames`, when
+ * given, restricts the objects described; an empty list describes none.
+ */
+export declare function expandGenericForConnector(ctx: BuildContext, connectorKey: string, templatesByOp: TemplatesByOp, objectNames?: readonly string[]): Promise<LibraryEntry[]>;
+/**
+ * `objects_come_from_the_connection`: true when this connector's object set is
+ * only knowable per connection. Field discovery alone does NOT qualify.
+ */
+export declare function objectsComeFromTheConnection(entry: unknown): boolean;
+/**
+ * `as_discovery_entry`: recast a Generic CRUD template as the discovery entry
+ * shipped for it — flagged, object cleared, labelled by verb ("Update Record",
+ * "List Records").
+ */
+export declare function asDiscoveryEntry(entry: LibraryEntry): LibraryEntry;
+/**
+ * `disambiguate_discovery_labels`: keep two discovery entries on one connector
+ * from sharing a label. Only the colliding ones are renamed, from their own
+ * node type (`search-records` → "Search Records", via `str.title()`).
+ */
+export declare function disambiguateDiscoveryLabels(entries: LibraryEntry[]): LibraryEntry[];
+/**
+ * A deterministic order for expanded entries: connector key, object name,
+ * operation name, node type — stable, so ties keep their input order.
+ *
+ * DELIBERATE FIX. The Python appended expansions as thread-pool futures
+ * completed, so the order two entries reached `write_library` in — and, when
+ * both claimed one path with equal input counts, which one survived — varied
+ * from run to run. Sorting here makes the library a function of its inputs.
+ * The index is sorted separately, so this changes no bytes when no such tie
+ * exists.
+ */
+export declare function sortExpandedEntries(entries: readonly LibraryEntry[]): LibraryEntry[];
+/**
+ * `expand_all_generics`: expand every Generic entry into per-(object, op)
+ * entries. Returns `[curatedAndPassthrough, expanded]`: Curated entries pass
+ * through untouched; HTTP-passthrough Generic entries pass through as
+ * one-per-connector entries; CRUD Generic entries are dropped in favour of
+ * their expansions; object-dynamic ones become discovery entries.
+ *
+ * The three remote phases (list objects, describe objects, describe
+ * operations) each run under `mapConcurrent`, so `expanded` comes back in
+ * connector × object × operation order rather than completion order.
+ */
+export declare function expandAllGenerics(ctx: BuildContext, entries: readonly LibraryEntry[]): Promise<[LibraryEntry[], LibraryEntry[]]>;