@larc-iu/plaid-client 0.2.0-alpha.3 → 0.2.0-alpha.30

package/src/events.js

@@ -0,0 +1,271 @@
+import { transformRequest } from "./transforms.js";
+import { readResearchTelemetry } from "./roles.js";
+
+// ---------------------------------------------------------------------------
+// Client events: the opt-in research telemetry of a project (defined in
+// plaid-core sql/client_event.clj).
+//
+// `client.events.record(type, fields)` is a fire-and-forget recorder. It
+// buffers events and sends them every FLUSH_INTERVAL_MS or FLUSH_AT events,
+// and when the page is hidden (`pagehide`, with `keepalive` so the request
+// outlives the page). A batch that fails is dropped: no retry, no toast, no
+// error for the caller. Nothing it does can block or break the screen that
+// called it.
+//
+// It sends nothing for a project whose switch is off. The switch is read
+// from the project (`config.plaid.research.telemetry`). An "on" is kept for
+// FLAG_TTL_MS, one flush interval, and an "off" for FLAG_OFF_TTL_MS, so a
+// switch another maintainer turns on reaches an open page within a minute,
+// while a page whose switch is off, which records on every render of a grid,
+// does not read the project every few seconds. An event recorded while an old
+// "off" is being read again waits for the answer rather than being dropped.
+// `events.setEnabled` tells it at once, which is what the settings checkbox
+// does. A server refusal (the switch was turned off since) turns it off here
+// too.
+//
+// ONE recorder per server per page, whatever client records into it: an app
+// makes a client per editor, and a suggestion's "shown" is deduplicated for
+// the page session, not per client. The last client to record lends its
+// token to the next send.
+// ---------------------------------------------------------------------------
+
+/** Every event type the server accepts. */
+export const EVENT_TYPES = Object.freeze([
+  "suggestion.shown",
+  "suggestion.adopted",
+  "suggestion.dismissed",
+  "plan.opened",
+]);
+
+export const FLUSH_INTERVAL_MS = 10000;
+export const FLUSH_AT = 50;
+export const FLAG_TTL_MS = FLUSH_INTERVAL_MS;
+export const FLAG_OFF_TTL_MS = 60000;
+// Events per request. A browser refuses a `keepalive` request whose body,
+// with every other keepalive request still in flight, passes 64 KiB, and a
+// refused request is lost. So the pagehide send goes out in small pieces, and
+// only that send is keepalive: a backlog sent while the page stays (the first
+// page of a grid, drawn while the switch was still being read, can hold
+// hundreds of guesses) would otherwise lose everything past the quota. The
+// server takes up to 500 in one request.
+const PER_REQUEST = FLUSH_AT;
+// A suggested or written value is a gloss, not prose. A long one is cut, in
+// code points as the server counts them, so no character is split in two.
+// The server refuses a value past this length, and a key its type does not
+// take (plaid-core sql/client_event.clj).
+const MAX_VALUE_CHARS = 200;
+
+const clip = (v) => {
+  if (typeof v !== "string" || v.length <= MAX_VALUE_CHARS) return v;
+  const cps = Array.from(v);
+  return cps.length > MAX_VALUE_CHARS
+    ? cps.slice(0, MAX_VALUE_CHARS).join("")
+    : v;
+};
+
+export class EventRecorder {
+  /**
+   * @param {object} [opts]
+   * @param {function} [opts.now] - Clock, for tests
+   * @param {object} [opts.window] - Where `pagehide` fires (default globalThis)
+   */
+  constructor({ now = () => Date.now(), window = globalThis } = {}) {
+    this.client = null;
+    this.buffer = [];
+    this.timer = null;
+    this.now = now;
+    // projectId -> { state: 'on' | 'off' | 'pending', at }
+    this.flags = new Map();
+    // "shown" keys already recorded this page session.
+    this.seen = new Set();
+    this._onPageHide = () => this.flush({ keepalive: true });
+    this.window = window;
+    window?.addEventListener?.("pagehide", this._onPageHide);
+  }
+
+  /** Tell the recorder a project's switch, e.g. right after changing it. */
+  setEnabled(projectId, on) {
+    this.flags.set(projectId, { state: on ? "on" : "off", at: this.now() });
+    if (!on) this._drop(projectId);
+    else if (this.buffer.length) this._schedule();
+  }
+
+  /**
+   * Record one event. Returns true when it was buffered, false when it was
+   * not (switch off, a repeat "shown", an unknown type, no project).
+   * @param {any} client
+   * @param {string} type
+   * @param {{projectId?: string, documentId?: string, targetId?: string, data?: Record<string, any>}} [fields]
+   * @returns {boolean}
+   */
+  record(client, type, { projectId, documentId, targetId, data } = {}) {
+    try {
+      if (!EVENT_TYPES.includes(type) || !projectId) return false;
+      this.client = client;
+      const flag = this._flag(projectId);
+      if (flag === "off") return false;
+      // A key with no value is left out: the server takes only a string or
+      // a number.
+      const clipped = data
+        ? Object.fromEntries(
+            Object.entries(data)
+              .filter(([, v]) => v != null)
+              .map(([k, v]) => [k, clip(v)]),
+          )
+        : undefined;
+      let key = null;
+      if (type === "suggestion.shown") {
+        key = JSON.stringify([
+          projectId,
+          targetId ?? null,
+          clipped?.field ?? null,
+          clipped?.value ?? null,
+        ]);
+        if (this.seen.has(key)) return false;
+        this.seen.add(key);
+      }
+      this.buffer.push({
+        projectId,
+        key,
+        event: {
+          type,
+          documentId: documentId ?? undefined,
+          targetId: targetId == null ? undefined : String(targetId),
+          data: clipped,
+          clientTs: new Date(this.now()).toISOString(),
+        },
+      });
+      if (this.buffer.length >= FLUSH_AT) this.flush();
+      else this._schedule();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Send what is buffered for every project whose switch is known to be on,
+   * drop what is buffered for one known to be off, and keep the rest until
+   * the switch is known. With `keepalive` (the page is going away) nothing is
+   * kept.
+   */
+  flush({ keepalive = false } = {}) {
+    clearTimeout(this.timer);
+    this.timer = null;
+    const keep = [];
+    const byProject = new Map();
+    for (const entry of this.buffer) {
+      const state = this.flags.get(entry.projectId)?.state;
+      if (state === "on") {
+        if (!byProject.has(entry.projectId)) byProject.set(entry.projectId, []);
+        byProject.get(entry.projectId).push(entry.event);
+      } else if (state === "off") {
+        if (entry.key) this.seen.delete(entry.key);
+      } else if (!keepalive) {
+        keep.push(entry);
+      }
+    }
+    this.buffer = keep;
+    for (const [projectId, events] of byProject) {
+      for (let i = 0; i < events.length; i += PER_REQUEST) {
+        this._send(projectId, events.slice(i, i + PER_REQUEST), keepalive);
+      }
+    }
+  }
+
+  /** Stop listening for `pagehide` and forget everything (tests). */
+  close() {
+    clearTimeout(this.timer);
+    this.timer = null;
+    this.buffer = [];
+    this.window?.removeEventListener?.("pagehide", this._onPageHide);
+  }
+
+  _schedule() {
+    if (this.timer == null) {
+      this.timer = setTimeout(() => this.flush(), FLUSH_INTERVAL_MS);
+    }
+  }
+
+  _drop(projectId) {
+    this.buffer = this.buffer.filter((e) => {
+      if (e.projectId !== projectId) return true;
+      if (e.key) this.seen.delete(e.key);
+      return false;
+    });
+  }
+
+  // The switch as known now: 'on', 'off' or 'pending'. An unknown one sets
+  // off a read of the project, and a stale one a fresh read. While it is
+  // read, an old "on" stands and an old "off" is 'pending', so what is
+  // recorded meanwhile waits for the answer. The answer flushes or drops what
+  // is buffered.
+  _flag(projectId) {
+    const known = this.flags.get(projectId);
+    const ttl = known?.state === "on" ? FLAG_TTL_MS : FLAG_OFF_TTL_MS;
+    const fresh = known && this.now() - known.at < ttl;
+    if (known && (fresh || known.checking)) return known.state;
+    const state = known?.state === "on" ? "on" : "pending";
+    this.flags.set(projectId, {
+      state,
+      at: known ? known.at : 0,
+      checking: true,
+    });
+    const client = this.client;
+    Promise.resolve()
+      .then(() => client.projects.get(projectId))
+      .then(
+        (project) => readResearchTelemetry(project?.config),
+        () => false,
+      )
+      .then((on) => {
+        this.flags.set(projectId, { state: on ? "on" : "off", at: this.now() });
+        if (!on) this._drop(projectId);
+        else if (this.buffer.length >= FLUSH_AT) this.flush();
+        else if (this.buffer.length) this._schedule();
+      });
+    return state;
+  }
+
+  _send(projectId, events, keepalive) {
+    const client = this.client;
+    try {
+      const url = `${client.baseUrl}/api/v1/projects/${projectId}/events`;
+      fetch(url, {
+        method: "POST",
+        keepalive,
+        headers: {
+          Authorization: `Bearer ${client.token}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(transformRequest(events)),
+      }).then(
+        (res) => {
+          // The switch was turned off since it was read.
+          if (res.status === 403) this.setEnabled(projectId, false);
+        },
+        () => {},
+      );
+    } catch {
+      /* dropped, as every failed batch is */
+    }
+  }
+}
+
+const recorders = new Map();
+
+/** The page's recorder for `client`'s server. */
+export function recorderFor(client) {
+  let r = recorders.get(client.baseUrl);
+  if (!r) {
+    r = new EventRecorder();
+    recorders.set(client.baseUrl, r);
+  }
+  return r;
+}
+
+/** Forget every recorder (tests). */
+export function resetEventRecorders() {
+  for (const r of recorders.values()) r.close();
+  recorders.clear();
+}

package/src/families.d.ts

@@ -0,0 +1,349 @@
+/** @typedef {import("./client.js").PlaidClient} PlaidClient */
+/**
+ * @typedef {import("./types.js").MetadataOp} MetadataOp
+ * @typedef {import("./types.js").LayerConstraint} LayerConstraint
+ * @typedef {import("./types.js").ConstraintViolation} ConstraintViolation
+ * @typedef {import("./types.js").OperationKind} OperationKind
+ * @typedef {import("./types.js").ConstraintRepair} ConstraintRepair
+ * @typedef {import("./types.js").ValueSetRule} ValueSetRule
+ * @typedef {import("./types.js").RefusedValues} RefusedValues
+ * @typedef {import("./types.js").MetadataRecords} MetadataRecords
+ * @typedef {import("./types.js").LayerRecords} LayerRecords
+ * @typedef {import("./types.js").AuditEntry} AuditEntry
+ */
+/**
+ * @template [T=any]
+ * @typedef {import("./types.js").Page<T>} Page
+ */
+export function csvParam(values: any): string;
+export function bodyOf(obj: any): {};
+/**
+ * The request options of a config write. With `options.expected` present
+ * (even as undefined, which means the key was absent) the write is a
+ * compare-and-set: `?if-unchanged=true` and the body `{expected, value}`,
+ * which the server refuses with a 409 when the stored value is no longer
+ * `expected`. Without it the body is the value itself. Config is opaque, so
+ * neither body is re-cased.
+ */
+export function configRequest(auditMessage: any, value: any, options: any, isDelete?: boolean): {
+    auditMessage: any;
+    rawBody?: undefined;
+    queryParams?: undefined;
+} | {
+    auditMessage: any;
+    rawBody: any;
+    queryParams?: undefined;
+} | {
+    auditMessage: any;
+    queryParams: {
+        "if-unchanged": boolean;
+    };
+    rawBody: {
+        expected: any;
+        value?: undefined;
+    } | {
+        expected: any;
+        value: any;
+    };
+};
+/**
+ * The query of an audit read: the window, the op-type and kind filters, the
+ * one vocabulary entry, and for one page its order, ops limit and entry id. A
+ * key left undefined is not sent.
+ * @private
+ */
+export function auditQuery({ startTime, endTime, opTypes, itemId, kinds, order, opsLimit, entryId }: {
+    startTime: any;
+    endTime: any;
+    opTypes: any;
+    itemId: any;
+    kinds: any;
+    order: any;
+    opsLimit: any;
+    entryId: any;
+}): {
+    "start-time": any;
+    "end-time": any;
+    "op-types": string;
+    "item-id": any;
+    kinds: string;
+    order: any;
+    "ops-limit": any;
+    "entry-id": any;
+};
+/**
+ * The audit readers of a document, a project or a user, on
+ * `/api/v1/<kind>/<id>/audit`. A vocabulary's take an entry id as well and are
+ * its own, and the instance-wide log is `audit.list`.
+ * @param {PlaidClient} client
+ * @param {"documents"|"projects"|"users"} kind
+ */
+export function auditMethods(client: PlaidClient, kind: "documents" | "projects" | "users"): {
+    /**
+     * Get the audit log of a document or a project, or of a user's actions.
+     * Transparently follows pagination cursors and returns the full flat
+     * array. Each entry, and each of its `ops`, says what kind of credential
+     * made it as `credential`: `login`, `named-token` or `delegated` (absent
+     * on older operations, `service` on some from 2026-10-06 to 2026-10-08),
+     * beside `apiToken` (the named token's id and name) when there was one.
+     * @param {string} id - The document, project or user ID
+     * @param {string} [startTime] - Start of time range
+     * @param {string} [endTime] - End of time range
+     * @param {string[]|string} [opTypes] - Only return operations of these
+     *   types, spelled as in an entry's `op/type` (e.g.
+     *   `['span-layer/create', 'span-layer/delete']`). An entry appears when
+     *   one of its operations matches, carrying only the ones that did.
+     * @param {string[]|string} [kinds] - Only the entries of operations of
+     *   these kinds (e.g. `['review', 'guess-adoption']`), each whole
+     * @returns {Promise<AuditEntry[]>}
+     */
+    audit: (id: string, startTime?: string, endTime?: string, opTypes?: string[] | string, kinds?: string[] | string) => Promise<AuditEntry[]>;
+    /**
+     * One page of the same log, newest-first with `order: "desc"`. Use this
+     * rather than audit() wherever the caller wants the recent end of a log
+     * that may be long: audit() walks every page before it resolves.
+     * @param {string} id - The document, project or user ID
+     * @param {object} [opts]
+     * @param {string} [opts.startTime] - Only entries at or after this instant
+     * @param {string} [opts.endTime] - Only entries at or before this instant
+     * @param {string[]|string} [opts.opTypes] - Only these op types
+     * @param {OperationKind[]|string} [opts.kinds] - Only the entries of operations of these kinds, each whole
+     * @param {"asc"|"desc"} [opts.order] - "desc" pages newest-first
+     * @param {number} [opts.limit] - Page size (1..1000; server default 100)
+     * @param {string} [opts.cursor] - Opaque cursor from a previous page
+     * @param {number} [opts.opsLimit] - Keep only each entry's oldest N
+     *   operations in `ops` (1..1000). `opCount` on every entry says how
+     *   many it has
+     * @param {string} [opts.entryId] - Read only this entry, not a page
+     * @returns {Promise<Page<AuditEntry>>}
+     */
+    auditPage: (id: string, { startTime, endTime, opTypes, kinds, order, limit, cursor, opsLimit, entryId }?: {
+        startTime?: string;
+        endTime?: string;
+        opTypes?: string[] | string;
+        kinds?: OperationKind[] | string;
+        order?: "asc" | "desc";
+        limit?: number;
+        cursor?: string;
+        opsLimit?: number;
+        entryId?: string;
+    }) => Promise<Page<AuditEntry>>;
+};
+/**
+ * The three metadata methods of a bundle whose entities carry metadata, on
+ * `/api/v1/<kind>/<id>/metadata`. Metadata is opaque, so no body is re-cased.
+ * Each answers the entity as its GET does.
+ * @template {keyof MetadataRecords} K
+ * @param {PlaidClient} client
+ * @param {K} kind
+ */
+export function metadataMethods<K extends keyof MetadataRecords>(client: PlaidClient, kind: K): {
+    /**
+     * Replace all metadata of an entity. Keys left out of the new map are removed.
+     * @param {string} id - The entity's ID
+     * @param {object} body - The new metadata map
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<MetadataRecords[K]>}
+     */
+    setMetadata: (id: string, body: object, auditMessage?: string) => Promise<MetadataRecords[K]>;
+    /**
+     * Remove all metadata from an entity.
+     * @param {string} id - The entity's ID
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<MetadataRecords[K]>}
+     */
+    deleteMetadata: (id: string, auditMessage?: string) => Promise<MetadataRecords[K]>;
+    /**
+     * Edit an entity's metadata with a list of ops applied in order, in one operation. `{op: 'set', path, value}` writes value at path, creating missing objects along it; `{op: 'delete', path}` removes the key at path (a no-op when absent). A path is a non-empty array of keys, the first a top-level key. A path through a non-object is refused (400). See metadataOps and applyMetadataOps.
+     * @param {string} id - The entity's ID
+     * @param {MetadataOp[]} body - The metadata ops
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<MetadataRecords[K]>}
+     */
+    patchMetadata: (id: string, body: MetadataOp[], auditMessage?: string) => Promise<MetadataRecords[K]>;
+};
+/**
+ * The two config methods of a bundle whose records carry editor config, on
+ * `/api/v1/<kind>/<id>/config/<namespace>/<key>`.
+ * @param {PlaidClient} client
+ * @param {string} kind
+ */
+export function configMethods(client: PlaidClient, kind: string): {
+    /**
+     * Set a configuration value in an editor namespace.
+     * @param {string} id - The record's ID
+     * @param {string} namespace - The config namespace
+     * @param {string} configKey - The config key
+     * @param {any} configValue - Configuration value to set
+     * @param {string} [auditMessage] - Audit message for this write
+     * @param {{expected?: any}} [options] - `expected`: the value read for this key (null or undefined when it
+     *   was absent). The write is then refused with a 409 when the stored value differs. A value the key
+     *   already holds is not written and leaves no audit row, so the value read, expecting it, states in a
+     *   batch that the key is unchanged.
+     * @returns {Promise<void>}
+     */
+    setConfig: (id: string, namespace: string, configKey: string, configValue: any, auditMessage?: string, options?: {
+        expected?: any;
+    }) => Promise<void>;
+    /**
+     * Remove a configuration value.
+     * @param {string} id - The record's ID
+     * @param {string} namespace - The config namespace
+     * @param {string} configKey - The config key
+     * @param {string} [auditMessage] - Audit message for this write
+     * @param {{expected?: any}} [options] - `expected`, as on setConfig. A key that is absent is not
+     *   written, so expecting null states in a batch that it is still absent.
+     * @returns {Promise<void>}
+     */
+    deleteConfig: (id: string, namespace: string, configKey: string, auditMessage?: string, options?: {
+        expected?: any;
+    }) => Promise<void>;
+};
+/**
+ * The get, delete, update and shift methods of the four layer bundles, on
+ * `/api/v1/<kind>/<layerId>`.
+ * @template {keyof LayerRecords} K
+ * @param {PlaidClient} client
+ * @param {K} kind
+ */
+export function layerMethods<K extends keyof LayerRecords>(client: PlaidClient, kind: K): {
+    /**
+     * Get a layer by ID.
+     * @param {string} layerId - The layer ID
+     * @returns {Promise<LayerRecords[K]>}
+     */
+    get: (layerId: string) => Promise<LayerRecords[K]>;
+    /**
+     * Delete a layer.
+     * @param {string} layerId - The layer ID
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<void>}
+     */
+    delete: (layerId: string, auditMessage?: string) => Promise<void>;
+    /**
+     * Rename a layer.
+     * @param {string} layerId - The layer ID
+     * @param {string} name - The new name
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<LayerRecords[K]>}
+     */
+    update: (layerId: string, name: string, auditMessage?: string) => Promise<LayerRecords[K]>;
+    /**
+     * Move a layer one place in its display order.
+     * @param {string} layerId - The layer ID
+     * @param {string} direction - The direction ("up" or "down")
+     * @param {string} [auditMessage] - Audit message for this write
+     * @returns {Promise<void>}
+     */
+    shift: (layerId: string, direction: string, auditMessage?: string) => Promise<void>;
+};
+/**
+ * The four layer-constraint methods of a layer bundle, on `/api/v1/<kind>`.
+ * See constraints.js and the core manual, "Layer constraints".
+ * @param {PlaidClient} client
+ * @param {string} kind
+ */
+export function constraintMethods(client: PlaidClient, kind: string): {
+    /**
+     * Declare an app namespace's constraints on this layer, replacing that
+     * namespace's list. Refused with 422 and the violations when the layer's
+     * stored data breaks them (see violationsOf).
+     * @param {string} layerId - The layer ID
+     * @param {string} namespace - The declaring app's namespace, e.g. "igt"
+     * @param {LayerConstraint[]} constraints - e.g. [{type: "single-span"}, {type: "value-set", values: ["N"]}]
+     * @param {string} [auditMessage] - Audit message for this write
+     * @param {{expected?: Array<object>|null}} [options] - `expected`: the list read for this
+     *   namespace (null when it was absent). The write is then refused with a 409 when the stored
+     *   list differs.
+     * @returns {Promise<{constraints: Record<string, LayerConstraint[]>}>} the layer's whole constraint map
+     */
+    setConstraints: (layerId: string, namespace: string, constraints: LayerConstraint[], auditMessage?: string, options?: {
+        expected?: Array<object> | null;
+    }) => Promise<{
+        constraints: Record<string, LayerConstraint[]>;
+    }>;
+    /**
+     * Remove an app namespace's constraints from this layer.
+     * @param {string} layerId - The layer ID
+     * @param {string} namespace - The declaring app's namespace
+     * @param {string} [auditMessage] - Audit message for this write
+     * @param {{expected?: Array<object>|null}} [options] - `expected`, as on setConstraints.
+     * @returns {Promise<void>}
+     */
+    deleteConstraints: (layerId: string, namespace: string, auditMessage?: string, options?: {
+        expected?: Array<object> | null;
+    }) => Promise<void>;
+    /**
+     * The violations the given constraints would meet in this layer's stored
+     * data. Writes nothing.
+     * @param {string} layerId - The layer ID
+     * @param {LayerConstraint[]} constraints - The list to check
+     * @param {{limit?: number}} [options] - `limit`: how many violations to list (default 100)
+     * @returns {Promise<{violations: ConstraintViolation[], violationCount: number}>}
+     */
+    checkConstraints: (layerId: string, constraints: LayerConstraint[], options?: {
+        limit?: number;
+    }) => Promise<{
+        violations: ConstraintViolation[];
+        violationCount: number;
+    }>;
+    /**
+     * Apply the remedies of the given constraints' remediable types
+     * (coextensive, single-span, single-link, same-ancestor) to every
+     * violation in this layer's stored data, one operation per document.
+     * With `document`, only that document is repaired, and a writer may
+     * ask. A document another user holds the lock on is left as it is and
+     * listed under `locked`.
+     * @param {string} layerId - The layer ID
+     * @param {LayerConstraint[]} constraints - The list to repair for
+     * @param {string} [auditMessage] - Audit message for this write
+     * @param {{document?: string}} [options]
+     * @returns {Promise<{repaired: ConstraintRepair[], locked: Array<{document: string, lockedBy: string}>, violations: ConstraintViolation[], violationCount: number}>}
+     */
+    repairConstraints: (layerId: string, constraints: LayerConstraint[], auditMessage?: string, options?: {
+        document?: string;
+    }) => Promise<{
+        repaired: ConstraintRepair[];
+        locked: Array<{
+            document: string;
+            lockedBy: string;
+        }>;
+        violations: ConstraintViolation[];
+        violationCount: number;
+    }>;
+};
+/**
+ * The value-set read of a span or relation layer bundle, on
+ * `/api/v1/<kind>/<layerId>/constraints/refused-values`.
+ * @param {PlaidClient} client
+ * @param {string} kind
+ */
+export function valueSetMethods(client: PlaidClient, kind: string): {
+    /**
+     * The stored values of this layer that a value-set rule would refuse,
+     * before it is declared: exactly what a declaration of it would meet,
+     * with the rule's exemptions (an unconfirmed machine value, a value an
+     * import, a document copy or a restore set). Writes nothing, and a
+     * reader may ask.
+     * @param {string} layerId - The layer ID
+     * @param {ValueSetRule} rule - The list as a value-set declaration takes it
+     * @param {{limit?: number}} [options] - `limit`: how many values to list, the most frequent first
+     *   (default 20, at most 100)
+     * @returns {Promise<RefusedValues>}
+     */
+    refusedValues: (layerId: string, rule: ValueSetRule, options?: {
+        limit?: number;
+    }) => Promise<RefusedValues>;
+};
+export type PlaidClient = import("./client.js").PlaidClient;
+export type MetadataOp = import("./types.js").MetadataOp;
+export type LayerConstraint = import("./types.js").LayerConstraint;
+export type ConstraintViolation = import("./types.js").ConstraintViolation;
+export type OperationKind = import("./types.js").OperationKind;
+export type ConstraintRepair = import("./types.js").ConstraintRepair;
+export type ValueSetRule = import("./types.js").ValueSetRule;
+export type RefusedValues = import("./types.js").RefusedValues;
+export type MetadataRecords = import("./types.js").MetadataRecords;
+export type LayerRecords = import("./types.js").LayerRecords;
+export type AuditEntry = import("./types.js").AuditEntry;
+export type Page<T = any> = import("./types.js").Page<T>;