node-autotask 0.40.0 → 0.42.0

package/dist/operations/index.d.cts

@@ -1,8 +1,21 @@
-import { I as Identifier, n5 as RowNamesSummary, a as AutotaskClient, n6 as BlindSurfaceInfo, eU as EmptyReasonInfo, n7 as RelationshipResource, n8 as BlindSurfaceInventory, n9 as BlindSurfaceRow, na as CreateGuidanceValueRequirement, nb as CreateGuidanceRow, nc as CreateBlockerKind, nd as CreateGuidanceReport, Z as ZoneName, c as FilterCondition } from '../index-BKp8_P2L.cjs';
-export { ne as DerivationRule, fe as FIELD_CACHE_KINDS, nf as FIELD_CATALOG_HONESTY_NOTE, fg as FieldCacheKind, ng as FieldCatalogCompactFieldRow, nh as FieldCatalogFieldRow, ni as FieldCatalogOptions, nj as FieldCatalogResult, nk as FieldCatalogRow, nl as FieldCatalogRowError, nm as FieldCatalogTrimKind, nn as FieldCatalogTruncation, no as FieldDerivation, np as MAX_FIELD_CATALOG_WIRE, nq as MIN_FIELD_CATALOG_MAX_BYTES, nr as PICKLIST_CATALOG_UNAVAILABLE_NOTE, ns as PICKLIST_VALUE_NOT_SERVED_NOTE, nt as fieldCatalog } from '../index-BKp8_P2L.cjs';
+import { a as AutotaskClient, el as BlindSurfaceInfo, em as RelationshipResource, en as BlindSurfaceInventory, eo as BlindSurfaceRow, ep as CreateGuidanceValueRequirement, eq as CreateGuidanceRow, er as CreateBlockerKind, es as CreateGuidanceReport, Z as ZoneName, be as FieldCacheKind } from '../index-Cm_Xpt7X.cjs';
+export { bd as FIELD_CACHE_KINDS } from '../index-Cm_Xpt7X.cjs';
+import { I as Identifier, cX as EmptyReasonInfo, e9 as PickListValue, a as FilterCondition } from '../index-C3KFMnRT.cjs';
+export { hV as PICKLIST_VALUE_NOT_SERVED_NOTE } from '../index-C3KFMnRT.cjs';
 import { CapabilityRecord } from '../capabilities.cjs';
 import { b as AutotaskConfigError } from '../base-CVx2VMSj.cjs';
 
+/** The `names` summary a labelled result carries ONLY when something was
+ * left unlabelled: the cold-read cap was hit or a picklist could not be
+ * resolved. Issue #287: the structured `truncated` / `capped` / catalogError
+ * bookkeeping was trimmed — the note is the summary. */
+interface RowNamesSummary {
+    /** One line a reader can act on. */
+    note: string;
+    /** Picklist field -> why its `*Label` is null (the fieldCatalog honesty note / the value-not-served note). */
+    reasons?: Record<string, string>;
+}
+
 /**
  * Cross-resource operations layer — shared types (ARCHITECTURE section 19.1,
  * 19.5). The operations layer is MCP-independent: plain SDK code, no MCP
@@ -81,6 +94,19 @@ interface FetchManyResult {
 interface ResolveAnyOptions {
     /** Resource keys to resolve against (default: the five workflow resources). */
     resources?: readonly string[];
+    /**
+     * Issue #287 (D7): the match mode (default `'exact'`).
+     * - `'exact'` — the per-resource exact resolution (numeric id first, then
+     *   exact on the primary text field); the historical behaviour.
+     * - `'auto'` — exact first (the same per-resource order); on a clean miss of a
+     *   NON-NUMERIC string identifier, a bounded case-insensitive CONTAINS on the
+     *   resource's primary text field (bounded by the resource's scan record cap —
+     *   default 500 records): exactly one hit resolves it (cost `'server-filter'`),
+     *   several hits report that resource as `RESOLUTION_AMBIGUOUS` with the
+     *   candidate ids, zero hits report the miss unchanged. A numeric id miss is
+     *   never re-scanned (the contains fallback is for text values only).
+     */
+    match?: 'exact' | 'auto';
 }
 /**
  * One resource's outcome. Unlike single-resource `resolve`, a miss does NOT
@@ -92,11 +118,22 @@ interface ResolveAnyResourceOutcome {
     value: Record<string, unknown> | null;
     /** How the match was found (or what was attempted). */
     resolutionCost: 'direct' | 'server-filter' | 'client-scan';
-    /** Records read by the bounded client-scan fallback. */
+    /**
+     * Records read by the bounded CLIENT scan fallback. The `match: 'auto'`
+     * server-filter contains fallback reads ZERO records client-side (the
+     * vendor applies the contains filter; the client receives at most the
+     * scan-cap matching rows) and reports `scanned: 0` with
+     * `resolutionCost: 'server-filter'`.
+     */
     scanned: number;
     /** True when the scan hit its cap (a complete non-match is unproven). */
     scanTruncated: boolean;
-    /** Candidate ids when the resource matched more than one record. */
+    /**
+     * Candidate ids when the resource matched more than one record. The
+     * server-filter contains fallback's list is bounded by the scan record
+     * cap — a `RESOLUTION_AMBIGUOUS` outcome can carry up to the cap
+     * candidate ids (default 500).
+     */
     candidates: (number | string)[];
     /** Error code when the resource could not resolve (e.g. `NOT_FOUND`, `CONFIG_ERROR`). */
     error?: string;
@@ -246,8 +283,18 @@ interface AggregateOptions {
     top?: number;
     /** The total-record cap for the walk modes (default = max = the house 2500 — `queryBounded`'s hard limit). */
     limit?: number;
-    /** Issue #276: label siblings on the returned group keys (`key.ticketIDName`, `key.statusLabel`, …). Default true; false = raw ids. */
+    /** Issue #276 (issue #287: default flipped off): label siblings on the
+     *  returned group keys (`key.ticketIDName`, `key.statusLabel`, …). Absent
+     *  = the client's `labels` option (off by default); true adds them,
+     *  false = raw ids. */
     names?: boolean;
+    /** Issue #287 (D3): acknowledge the UNSCOPED group/sum walk. A group/sum
+     *  with no filter (absent/empty) walks the whole tenant table and is
+     *  REFUSED pre-request (zero wire, the typed `SCOPE_REQUIRED`) unless
+     *  this is `true` — the count mode is unaffected (one vendor count, no
+     *  walk). A filter with an id scope (eq/in on an id field) is the
+     *  narrow remedy. */
+    acknowledgeUnscoped?: boolean;
 }
 /** One folded group (the key = the groupBy field tuple; `sums` present iff `sum` was given). */
 interface AggregateGroup {
@@ -270,6 +317,10 @@ interface AggregateResult {
     totalScanned?: number;
     /** group/sum mode: the walk's truncation flag (true → groups/sums cover the returned rows only). */
     hasMore?: boolean;
+    /** Issue #287 (D6): the walk hit its limit and the groups may be
+     * incomplete (walk modes: the walk's truncation flag — `hasMore`; count
+     * mode: no walk, always `false`). */
+    truncated: boolean;
     /** count mode: true exactly when the S12-C sentinel stamped the 0 (the filter-aware predicate). */
     blind?: boolean;
     /** The S12-C typed sentinel (count mode: the blind 0; walk mode: the 0-row walk stamp). */
@@ -754,33 +805,238 @@ interface UiLinkResult {
 /** Zero-wire meta op: build the deep link from the client's live REST base (or an explicit `host`). */
 declare function uiLink(client: AutotaskClient, input: UiLinkInput): Promise<UiLinkResult>;
 
+/** The helper's result shape (issue #224: every helper names its result type). */
+type SanitiseResult = Record<string, unknown>;
 /**
- * Every entity name the registry resolves, mapped to its plan resource key.
- * Derived from `apiEntity` (+ the singular entity-name alias) — never
- * hand-written, so a plan resource lands here the moment it is generated.
+ * `operations.sanitiseResult(result, operation)` — wrap the result's
+ * untrusted fields per the operation's own registry record.
+ *
+ * @param client      The wired client (unused — zero wire by construction).
+ * @param result      The raw result of a prior SDK read (a query envelope, a
+ *                    record or the op's result object).
+ * @param operation   The registry operation key of the call the result came
+ *                    from (e.g. `tickets.query`) — the record whose
+ *                    `metadata.untrustedFields` decides the field list.
+ * @returns A promise for a NEW result object with the present untrusted
+ *          fields wrapped (the input is never mutated) when the operation
+ *          declares untrusted fields — or the input returned unchanged
+ *          (the same reference) when it declares none.
+ * @throws {AutotaskConfigError} an unknown (non-string/empty, or not-in-the-
+ *          registry) operation — typed, zero wire.
  */
-declare const ENTITY_TYPE_TO_RESOURCE: Readonly<Record<string, string>>;
+declare function sanitiseResult(client: AutotaskClient, result: Record<string, unknown>, operation: string): Promise<SanitiseResult>;
+
+/** The pinned wire cap: `resources × include` above it is refused
+ * pre-request (CONFIG_ERROR naming the computed cost and the cap) —
+ * refused, never truncated. */
+declare const MAX_FIELD_CATALOG_WIRE = 60;
+/** The stable honesty sentence served in the result (the live catalog
+ * reports field SHAPE as FLAGS and NAMES; with the opt-in `labels: true`
+ * the projected picklist rows carry the vendor's exposed picklist
+ * VALUES; it cannot resolve a picklist VALUE the vendor does not expose
+ * to this API user — the W-A4 wall). */
+declare const FIELD_CATALOG_HONESTY_NOTE: string;
+/** One projected field row (the stable, small served shape — not the raw
+ * vendor blob; the raw one stays available through the resource's own
+ * `getFieldInfo` / `getUdfInfo` op). */
+interface FieldCatalogFieldRow {
+    /** The vendor field name. */
+    name: string;
+    /** The display label (UDF catalog rows only; vendor standard fields carry none). */
+    label?: string;
+    /** The vendor field type (`dataType` on standard fields, `type` on UDFs). */
+    type: string;
+    isRequired: boolean;
+    isReadOnly: boolean;
+    /** The vendor `isQueryable` flag — ABSENT on a UDF row: the vendor reports UDFs as queryable, but a filter on a UDF name is accepted only with the `udf: true` marker, so the row states the mechanism in `filterable` instead of a boolean the vendor contradicts (issue #219 N7). */
+    isQueryable?: boolean;
+    isPickList: boolean;
+    /** Present exactly on a UDF row: the filter mechanism a consumer must send to filter on this name (`udf: true` in the filter condition) — never infer plain filterability from the vendor's `isQueryable` (issue #219 N7). */
+    filterable?: 'udf-marker';
+    /** The write shape for an object/array field: `merge` (a sent subset is merged — `userDefinedFields` is the proven case) or `replace-all` (the vendor's full-model PUT replaces the collection). Absent on scalar fields (issue #219 N7). */
+    writeShape?: 'merge' | 'replace-all';
+    /** The vendor `length` bound (null when the catalog names none). */
+    maxLength: number | null;
+    /** The referenced entity type for reference fields ('' when none). */
+    referenceEntityType: string;
+    /** Present exactly when the plan declares this field DERIVED for the resource (issue #219 N8): the vendor overwrites or inherits the value, so a submitted one is not authoritative. Distinct from `isReadOnly` (never write at all) — a derived field can be absent from that list and still be recomputed. */
+    derived?: DerivationRule;
+    /** The vendor's exposed picklist VALUES, verbatim (present exactly when the `labels` opt is `true` and the vendor exposed values for this picklist field — the vendor-walled and non-picklist rows carry none). */
+    picklistValues?: PickListValue[];
+}
+/** One compact field row (`compact: true`, issue #282): the five columns a
+ * caller needs to pick a field name — the full row's flags, lengths and
+ * reference targets are dropped. `picklistValues` rides only when `labels`
+ * AND a `fields` filter are both given (a targeted value lookup). */
+interface FieldCatalogCompactFieldRow {
+    name: string;
+    type: string;
+    isPickList: boolean;
+    /** True when the vendor names a referenced entity (`referenceEntityType` non-empty). */
+    isReference: boolean;
+    /** True on a `udf`-kind row, false on a standard field. */
+    udf: boolean;
+    picklistValues?: PickListValue[];
+}
+/** The derivation rule of one field (issue #219 N8) — a closed plan token, served without the field name it decorates. */
+interface DerivationRule {
+    /** elapsed(<start>,<end>) (recomputed from those timestamps) | parent (inherited from the parent record) | mirror(<field>) (the vendor copies that field) | external (written by another entity's op — writableRoute names it). */
+    rule: string;
+    /** The op that actually writes the value (the external rule names it — billing_item_approval_levels.create for a time entry's approval level). */
+    writableRoute?: string;
+}
+/** One declared derived field of a resource (issue #219 N8) — the declaration the plan pins. */
+interface FieldDerivation extends DerivationRule {
+    /** The vendor field name. */
+    field: string;
+}
+/** One per-resource fault (partial failures are typed PER ROW — never all-or-nothing). */
+interface FieldCatalogRowError {
+    code: string;
+    message: string;
+}
+/** One resource's catalog row (`F` = the field-row shape: compact by default when `fields` is absent and `labels` is not `true`, the full row under `compact: false` / `labels: true`). */
+interface FieldCatalogRow<F = FieldCatalogFieldRow> {
+    /** The plan resource key. */
+    resource: string;
+    /** The vendor entity name (the path segment; plan-derived). */
+    apiEntity: string;
+    /** The plan resource's `udfCapable` flag, read from the registry record (`CapabilityRecord.udfCapable`, issue #254): true for the resources whose records carry `userDefinedFields`. Every vendor entity has a `getUdfInfo` catalog endpoint, so the `udf` include works on any row; that endpoint's presence does not make a resource UDF-capable. */
+    udfCapable: boolean;
+    /** The filter mechanism for a UDF name — present exactly when `udfCapable`: a filter on a UDF name is accepted only with the vendor's `udf: true` marker (a plain filter is refused), so the row states the marker rather than leaving a consumer to read the UDF rows' `isQueryable` (issue #219 N7). */
+    udfFilter?: 'udf-marker';
+    /** The write shape of a record's `userDefinedFields` collection — present exactly when `udfCapable`: the vendor MERGES a sent list, so a subset is correct (issue #219 N7). */
+    udfWriteShape?: 'merge';
+    /** The entity information model (present exactly when `info` was included and fetched). */
+    info?: Record<string, unknown> | null;
+    /** The plan's derived-field declaration for this resource (issue #219 N8) — present exactly when the plan declares any, in plan order; the same list the create guidance row and the describe channel serve. Read it before treating a submitted field value as authoritative. */
+    derivedFields?: FieldDerivation[];
+    /** The projected standard-field catalog (present exactly when `fields` was included and fetched; when the `fields` opt is given, only the matching rows — the requested names absent here land in `unmatchedFields`). */
+    fields?: F[];
+    /** The requested `fields`-filter names absent from this resource's fields catalog (in request order); `[]` when no filter is given, when the row carries no fields catalog (an `info`/`udf`-only include or a row error), or when nothing was missing. Reported, never an error. */
+    unmatchedFields: string[];
+    /** The projected UDF catalog (present exactly when `udf` was included and fetched). */
+    udf?: F[] | null;
+    /** Present exactly when a `fields` projection was applied (the `fields` opt was given): the four derived lists below then describe the PROJECTED set only. A full row omits the key (it never carries `false`). */
+    projected?: true;
+    /** `isRequired === true` names, in catalog order (the `fields` catalog). */
+    required: string[];
+    /** `isReadOnly === true` names, in catalog order. */
+    readOnly: string[];
+    /** `isQueryable === true` names, in catalog order. */
+    queryable: string[];
+    /** `isPickList === true` names, in catalog order — NAMES only (see `honesty`: the VALUES may be vendor-walled). */
+    picklistFields: string[];
+    /** The FieldCache state for this row: `hit` = every included kind was served from the cache (no wire for the row); `age` = the oldest entry's age in ms (null when `hit` is false). */
+    cache: {
+        hit: boolean;
+        age: number | null;
+    };
+    /** The metadata reads this row issued (0 = fully cached; one per included kind otherwise — in-flight de-dup may make the actual wire smaller than this). */
+    wire: number;
+    /** The first per-kind failure (code + message); the sweep keeps going. */
+    error: FieldCatalogRowError | null;
+}
+/** The sweep result. */
+interface FieldCatalogResult<F = FieldCatalogFieldRow> {
+    /** The resolved client zone ('unknown' for a bare explicit baseUrl). */
+    zone: string;
+    /** The zone label (a live op has no plan-pinned tenant label — it mirrors `zone`). */
+    label: string;
+    /** Whether a FieldCache was configured at all. */
+    cached: boolean;
+    /** The resolved `labels` opt (the served payload names what it carries: `true` = the picklist rows may carry `picklistValues`). */
+    labels: boolean;
+    /** The configured TTL (null when no cache). */
+    ttlMs: number | null;
+    /** The call instant (ISO). */
+    fetchedAt: string;
+    /** One row per requested resource, in request order. */
+    rows: FieldCatalogRow<F>[];
+    /** The metadata reads actually issued across the call (≤ `cap` by construction). */
+    wireUsed: number;
+    /** The wire cap the call ran under. */
+    cap: number;
+    /** The resolved `compact` opt (true = the field rows are FieldCatalogCompactFieldRow). */
+    compact: boolean;
+    /** True only when the `maxBytes` size cap dropped field rows (see `truncation`). Over the WIRE cap the call is still refused (CONFIG_ERROR), never truncated. */
+    truncated: boolean;
+    /** Present exactly when `truncated`: the typed note naming what the `maxBytes` cap dropped (issue #282) — the payload stays valid JSON, never cut mid-document. */
+    truncation?: FieldCatalogTruncation;
+    counts: {
+        /** The requested (deduplicated) resource count. */
+        resources: number;
+        /** The plan's `getFieldInfo`-bearing resource count (the field-capable set). */
+        fieldCapableResources: number;
+        /** The plan's `udfCapable` resource count (issue #254: the resources whose records carry `userDefinedFields` — not the wider set with a `getUdfInfo` catalog endpoint). */
+        udfCapableResources: number;
+        /** The rows served fully from the cache. */
+        cached: number;
+    };
+    /** The honest scope: what the live catalog can and cannot report. */
+    honesty: {
+        /** The vendor's WIRE exposure of picklist values, informational only (orthogonal to the `labels` opt — it reports what the vendor exposed on the wire, not what the caller opted into): 'partial' when any row's raw vendor response carried picklist VALUES on the wire — computed over the full raw list, not the filtered subset; 'unexposed' otherwise. */
+        picklistValues: 'unexposed' | 'partial';
+        note: string;
+    };
+}
+/** The typed size-cap note (issue #282). */
+interface FieldCatalogTruncation {
+    reason: 'maxBytes';
+    /** The cap the call ran under (UTF-8 bytes of the JSON result). */
+    maxBytes: number;
+    /** The UTF-8 byte size of the untruncated JSON result. */
+    fullBytes: number;
+    /** The entries dropped, per resource and list (taken from the end: the udf rows, then the fields rows, last resource first; the name lists only when the field rows alone could not fit). */
+    omitted: Array<{
+        resource: string;
+        kind: FieldCatalogTrimKind;
+        count: number;
+    }>;
+    note: string;
+}
+/** The smallest accepted `maxBytes` (a cap below it could not hold a one-resource result envelope; a larger envelope that still cannot fit is refused at result-build). */
+declare const MIN_FIELD_CATALOG_MAX_BYTES = 4096;
+/** The optional call bag for `operations.fieldCatalog` (closed: unknown keys refuse). */
+interface FieldCatalogOptions {
+    /** The plan resource keys to read. Omitted → the five workflow resources (never the full set — an on-demand op must not fan out 121 wire calls by default). */
+    resources?: string[];
+    /** What to fetch per resource (closed set `info` | `fields` | `udf`; default `['fields']`). */
+    include?: FieldCacheKind[];
+    /** Bypass the fieldCache for this call (fetch live, refresh the entries). Default false. */
+    fresh?: boolean;
+    /** The optional post-projection filter on the `fields`-kind rows only: keep the named fields (vendor names, trimmed, de-duplicated). Report-not-error: names absent from a resource's fields catalog land on that row's `unmatchedFields`, never an error; the `info` and `udf` rows are unaffected (the filter is a no-op on them). Applied after projection, on cache hits and wire reads alike — the cache entries stay the full raw list (zero extra wire, no invalidation). */
+    fields?: string[];
+    /** Opt-in: when `true`, the projected `fields`-kind and `udf`-kind picklist rows carry the vendor's exposed `picklistValues` (the raw vendor shape as-is — `{ value, label, parentValue?, isActive?, ... }`, `value` a string, zero transform) for the picklist fields. The W-A4 wall still applies (a value the vendor does not expose to this API user is not resolvable — retrying will not surface it). Default `false`: the rows carry no VALUES (today's exact output). Zero extra wire: the values ride the same cached raw rows. */
+    labels?: boolean;
+    /** Issue #282: when `true`, every field row is a FieldCatalogCompactFieldRow `{ name, type, isPickList, isReference, udf }` (a live tickets result: ~11 KB compact against ~20 KB full and ~137 KB full with `labels: true`). `picklistValues` ride a compact row only with `labels: true` AND a `fields` filter. Issue #287: an ABSENT `compact` is compact BY DEFAULT — compact ONLY when `fields` is absent AND `labels` is not `true` (an explicit `compact: false` restores the full rows; `labels: true` without `fields` keeps the full rows + picklist values — the server's current ~137 KB case, unchanged). */
+    compact?: boolean;
+    /** Issue #282: a UTF-8 byte cap on the JSON result (integer ≥ MIN_FIELD_CATALOG_MAX_BYTES). Over it, field rows are dropped from the end until the result fits, `truncated` is `true` and `truncation` names what was dropped — never an invalid, cut-off document. The row-level name lists (required, readOnly, queryable, picklistFields) keep every name unless the field rows alone cannot fit (then they are trimmed too). A served result never exceeds the cap: when the envelope alone (it grows with the resource count) cannot fit, the call is refused with CONFIG_ERROR. The cost is linear in the result size. Default: no cap. */
+    maxBytes?: number;
+}
+/** The lists the size cap trims, in drop order within a row: the field rows
+ * first, then the name lists (only when the field rows alone cannot fit). */
+declare const TRIM_KINDS: readonly ["udf", "fields", "picklistFields", "queryable", "readOnly", "required"];
+type FieldCatalogTrimKind = (typeof TRIM_KINDS)[number];
 /**
- * Resolve a vendor `referenceEntityType` to the plan resource key a caller
- * would enumerate (the same derivation the field-catalog row serves as
- * `targetResource`).
+ * Run the bounded live field-metadata sweep.
  *
  * ```ts
- * import { resourceForEntityType } from 'node-autotask/operations';
- * resourceForEntityType('CompanyLocation'); // 'company_locations'
- * resourceForEntityType('Queue');           // null — the plan has no queue entity
+ * import { fieldCatalog } from 'node-autotask/operations';
+ * const res = await fieldCatalog(client);                     // the 5 workflow resources, fields only (compact rows by default)
+ * const fresh = await fieldCatalog(client, { resources: ['tickets'], include: ['fields', 'udf'], fresh: true });
  * ```
  *
- * `null` means "the plan carries no resource for this vendor entity name" —
- * it never guesses a near match. A blank/absent name resolves to `null`.
- */
-declare function resourceForEntityType(entityType: string | null | undefined): string | null;
-/**
- * True when `resource` is a plan resource with a read path (`query` or `get`) —
- * the `targetEnumerable` half of the field-catalog row. A null/unknown key is
- * false (a reference the plan cannot enumerate).
+ * @param client The wired client (the reads issue entityInformation GETs).
+ * @param opts   The call bag ({ resources?, include?, fresh?, fields?, labels?, compact?, maxBytes? }).
  */
-declare function isEnumerableResource(resource: string | null | undefined): boolean;
+declare function fieldCatalog(client: AutotaskClient, opts: FieldCatalogOptions & {
+    compact: true;
+}): Promise<FieldCatalogResult<FieldCatalogCompactFieldRow>>;
+declare function fieldCatalog(client: AutotaskClient, opts?: FieldCatalogOptions & {
+    compact?: false;
+}): Promise<FieldCatalogResult>;
+declare function fieldCatalog(client: AutotaskClient, opts?: FieldCatalogOptions): Promise<FieldCatalogResult<FieldCatalogFieldRow | FieldCatalogCompactFieldRow>>;
 
 /** The pinned per-call id cap (mirrors `FETCH_BY_IDS_MAX_ITEMS` — the house bulk cap; over → pre-request refusal, zero wire). */
 declare const EXPAND_RESOURCE_NAMES_MAX_IDS = 500;
@@ -1065,4 +1321,4 @@ declare function invokeWrite(client: AutotaskClient, operation: string, args?: r
  */
 declare function invokeDelete(client: AutotaskClient, operation: string, args?: readonly unknown[] | Record<string, unknown>, opts?: InvokeOptions): Promise<unknown>;
 
-export { AGGREGATE_DATE_BUCKETS, AGGREGATE_DEFAULT_LIMIT, AGGREGATE_DEFAULT_TOP, AGGREGATE_TOP_MAX, type AggregateGroup, type AggregateOptions, type AggregateResult, BLIND_SURFACE_KINDS, type BlindSurfaceKind, type BlindSurfaceOptions, BlindSurfaceRow, CREATE_BLOCKER_KINDS, type CreateGuidanceOptions, type DateBucket, ENTITY_TYPE_TO_RESOURCE, EXPAND_RESOURCE_NAMES_MAX_IDS, type EffectiveRequiredFields, type ExpandResourceNameRow, type ExpandResourceNamesOptions, type ExpandResourceNamesResult, FETCH_BY_IDS_CHUNK_SIZE, FETCH_BY_IDS_MAX_ITEMS, FETCH_MANY_MAX_ITEMS, type FetchByIdsOptions, type FetchManyItem, type FetchManyItemError, type FetchManyItemResult, type FetchManyOptions, type FetchManyResult, INVOKE_OPTION_KEYS, type InvokeMode, type InvokeOptions, PARAMS_BAG_KEYS, type ProbeReachabilityOptions, type ProbeReachabilityResult, type ProbeSurfaceRow, RECOVERY_CONFIRM, RECOVERY_DEFAULT_LIMIT, RECOVERY_MAX_LIMIT, type RecoveryDeleteBoundary, type RecoveryInput, type RecoveryMatch, type RecoveryOptions, type RecoveryResult, type RequiredFieldsRecord, type RequiredFieldsSource, type RequiredFieldsZoneFacts, type ResolveAnyOptions, type ResolveAnyResourceOutcome, type ResolveAnyResult, type RevenueRollupAmount, type RevenueRollupDimension, type RevenueRollupKey, type RevenueRollupNonChargeable, type RevenueRollupNonChargeableAmount, type RevenueRollupOptions, type RevenueRollupResult, type RevenueRollupRow, RowNamesSummary, type SearchAcrossResourcesOptions, type SearchAcrossResourcesResult, type SearchAcrossResourcesRow, type ServedCreateGuidanceReport, type ServedCreateGuidanceRow, UI_LINK_ENTITIES, type UiLinkEntity, type UiLinkInput, type UiLinkResult, WORKFLOW_RESOURCES, aggregate, blindSurfaces, buildUiLink, createGuidance, dateBucketLabel, effectiveRequiredFields, expandResourceNames, fetchByIds, fetchMany, foldFlattenedOpts, invoke, invokeDelete, invokeRead, invokeWrite, isEnumerableResource, needsConfirmation, probeReachability, recovery, relationshipMap, resolveAny, resourceForEntityType, revenueRollup, searchAcrossResources, uiLink, unknownKeysRefusal, validateDispatchArgs, validateFetchManyItems, validateInvokeOptions, validateParamsBag };
+export { AGGREGATE_DATE_BUCKETS, AGGREGATE_DEFAULT_LIMIT, AGGREGATE_DEFAULT_TOP, AGGREGATE_TOP_MAX, type AggregateGroup, type AggregateOptions, type AggregateResult, BLIND_SURFACE_KINDS, type BlindSurfaceKind, type BlindSurfaceOptions, BlindSurfaceRow, CREATE_BLOCKER_KINDS, type CreateGuidanceOptions, type DateBucket, type DerivationRule, EXPAND_RESOURCE_NAMES_MAX_IDS, type EffectiveRequiredFields, type ExpandResourceNameRow, type ExpandResourceNamesOptions, type ExpandResourceNamesResult, FETCH_BY_IDS_CHUNK_SIZE, FETCH_BY_IDS_MAX_ITEMS, FETCH_MANY_MAX_ITEMS, FIELD_CATALOG_HONESTY_NOTE, type FetchByIdsOptions, type FetchManyItem, type FetchManyItemError, type FetchManyItemResult, type FetchManyOptions, type FetchManyResult, FieldCacheKind, type FieldCatalogCompactFieldRow, type FieldCatalogFieldRow, type FieldCatalogOptions, type FieldCatalogResult, type FieldCatalogRow, type FieldCatalogRowError, type FieldCatalogTrimKind, type FieldCatalogTruncation, type FieldDerivation, INVOKE_OPTION_KEYS, type InvokeMode, type InvokeOptions, MAX_FIELD_CATALOG_WIRE, MIN_FIELD_CATALOG_MAX_BYTES, PARAMS_BAG_KEYS, type ProbeReachabilityOptions, type ProbeReachabilityResult, type ProbeSurfaceRow, RECOVERY_CONFIRM, RECOVERY_DEFAULT_LIMIT, RECOVERY_MAX_LIMIT, type RecoveryDeleteBoundary, type RecoveryInput, type RecoveryMatch, type RecoveryOptions, type RecoveryResult, type RequiredFieldsRecord, type RequiredFieldsSource, type RequiredFieldsZoneFacts, type ResolveAnyOptions, type ResolveAnyResourceOutcome, type ResolveAnyResult, type RevenueRollupAmount, type RevenueRollupDimension, type RevenueRollupKey, type RevenueRollupNonChargeable, type RevenueRollupNonChargeableAmount, type RevenueRollupOptions, type RevenueRollupResult, type RevenueRollupRow, type RowNamesSummary, type SanitiseResult, type SearchAcrossResourcesOptions, type SearchAcrossResourcesResult, type SearchAcrossResourcesRow, type ServedCreateGuidanceReport, type ServedCreateGuidanceRow, UI_LINK_ENTITIES, type UiLinkEntity, type UiLinkInput, type UiLinkResult, WORKFLOW_RESOURCES, aggregate, blindSurfaces, buildUiLink, createGuidance, dateBucketLabel, effectiveRequiredFields, expandResourceNames, fetchByIds, fetchMany, fieldCatalog, foldFlattenedOpts, invoke, invokeDelete, invokeRead, invokeWrite, needsConfirmation, probeReachability, recovery, relationshipMap, resolveAny, revenueRollup, sanitiseResult, searchAcrossResources, uiLink, unknownKeysRefusal, validateDispatchArgs, validateFetchManyItems, validateInvokeOptions, validateParamsBag };