@qaecy/cue-sdk 0.0.37 → 0.0.39

package/index.d.ts

@@ -13,7 +13,7 @@ export type { McpCallOptions } from './lib/mcp';
 export type { IndexSearchRequest, IndexItem, IndexSearchResponse, IndexFilterOption, IndexAppliedFilters, AvailableFiltersResponse, SearchFilter, DocumentFilterOption, AvailableDocumentFilters, } from './lib/models';
 export { CueSyncApi, configureScanWasm } from './lib/sync';
 export { CueProcessingApi } from './lib/processing';
-export type { ProcessingStatusWatcher } from './lib/processing';
+export type { ProcessingStatusWatcher, MyProcessingStatusWatcher } from './lib/processing';
 export { CueDmsApi } from './lib/dms';
 export type { DmsProviderInfo, DmsRemoteFile, DmsSyncPreviewResponse } from './lib/models';
 export { CueProjectSchema } from './lib/schema';
@@ -24,6 +24,8 @@ export { CueProjectView } from './lib/project-view';
 export type { CueProjectViewOptions } from './lib/project-view';
 export { CueProjects } from './lib/project';
 export { CueProfile } from './lib/profile';
+export { CueAdmin } from './lib/admin';
+export type { AdminOrgSearchResult, AdminUserSearchResult, AdminProjectSearchResult, AdminUserOrgSummary, AdminUserProjectSummary, AdminUserDetail, AdminDeletedUserOrgRef, AdminDeletedUserProjectRef, AdminDeletedUserSummary, AdminRestoreUserResult, } from './lib/models';
 export { CuePrivileges, REQUIRED_ROLES } from './lib/privileges';
 export type { UserProjectRole, Privileges } from './lib/privileges';
 export { CueSignal, cueComputed } from './lib/signal';
@@ -32,12 +34,16 @@ export { CueCache } from './lib/cache';
 export type { QueryCacheEntry } from './lib/cache';
 export { CueCurrency, SUPPORTED_CURRENCIES, BASE_CURRENCY } from './lib/currency';
 export type { SupportedCurrency, CurrencyRates } from './lib/currency';
-export type { CueSdkConfig, SsoProvider, PasswordCredentials, SearchRequest, SearchResponse, SearchSource, SearchOptions, ProjectData, ProjectSettings, QleverStats, CreateProjectOptions, SyncOptions, SyncResult, SyncPreview, ScanOutputRecord, UnitCreditMap, UnitsConsumedDto, OrgCreditsDto, OrgPlanSummary, MonthlyConsumptionDto, ProjectConsumptionReportDto, OrgConsumptionReportDto, FileTypeConsumptionDto, FileTypeBreakdownDto, OrganizationData, OrgMember, ProfileSSOAccount, APIKeyInfo, APIKeyDoc, ProjectDoc, OrganizationDoc, UserDoc, UserSettings, CustomAppRecord, CustomAppWithHtml, CreateCustomAppOptions, UpdateCustomAppOptions, RDFWritingDoc, ProcessingStatus, ProcessingStage, ViewDefinition, QueryCache, LangMap, CategoryDef, RelationshipDef, EntityCoreData, EntityRelationship, EntityRelationships, MapGeometry, EntityDetailedData, ProjectEntitiesData, SummaryGraphData, DocumentInfo, DocumentSummary, ProjectDocumentsData, } from './lib/models';
+export type { CueSdkConfig, SsoProvider, PasswordCredentials, SearchRequest, SearchResponse, SearchSource, SearchOptions, ProjectData, ProjectSettings, QleverStats, CreateProjectOptions, SyncOptions, SyncResult, SyncPreview, ScanOutputRecord, UnitCreditMap, UnitsConsumedDto, OrgCreditsDto, OrgPlanSummary, MonthlyConsumptionDto, ProjectConsumptionReportDto, OrgConsumptionReportDto, FileTypeConsumptionDto, FileTypeBreakdownDto, RouteTrafficDto, DayTrafficDto, MonthTrafficDto, TrafficReportDto, ViewUsageDto, DayUsageDto, MonthUsageDto, UsageReportDto, OrganizationData, OrgMember, ProfileSSOAccount, APIKeyInfo, APIKeyDoc, ProjectDoc, OrganizationDoc, UserDoc, UserSettings, CustomAppRecord, CustomAppWithHtml, CreateCustomAppOptions, UpdateCustomAppOptions, RDFWritingDoc, ProcessingStatus, ProcessingStage, DocumentProcessingStage, DocumentProgress, ProjectProcessingSummary, MyProcessingStatus, DocumentReprocessJob, ReprocessJobStatus, ViewDefinition, QueryCache, LangMap, CategoryDef, RelationshipDef, EntityCoreData, EntityRelationship, EntityRelationships, MapGeometry, EntityDetailedData, ProjectEntitiesData, SummaryGraphData, DocumentInfo, DocumentSummary, ProjectDocumentsData, } from './lib/models';
 export type { AuthStateListener, Unsubscribe } from './lib/auth';
 export { CueTables } from './lib/tables';
 export type { ProjectTable } from './lib/tables';
 export { CueExtraction } from './lib/extraction';
 export type { ExtractionRequest, ExtractionResponse } from './lib/extraction';
+export { CueLlmTools } from './lib/llm-tools';
+export type { GenerateWranglingSchemaRequest, GenerateWranglingSchemaResponse } from './lib/llm-tools';
+export { CueDataSources } from './lib/data-sources';
+export type { DataSourceRecord, XToRdfConfig, RmlXToRdfConfig, GraphXToRdfConfig, TypeMappingConfiguration, UploadDataSourceMode, UploadDataSourceResult, } from './lib/data-sources';
 export { CueContexts } from './lib/contexts';
 export type { ContextDoc, ContextItem, McpContext } from './lib/models';
 export { CueAppData } from './lib/app-data';

package/index.js

@@ -1,37 +1,40 @@
-import { B as a, C as u, a as C, b as t, c as r, d as i, e as c, f as o, g as n, h as p, i as E, j as S, k as A, l as P, m as R, n as g, o as m, p as D, q as j, r as l, s as U, t as x, u as f, v as h, w as d, x as y, y as I, z as _, A as b, D as q, R as v, S as w, E as B, F } from "./document-filter-BNui_ucF.js";
+import { B as a, C as u, a as C, b as t, c as r, d as i, e as o, f as c, g as n, h as p, i as S, j as E, k as A, l as m, m as P, n as R, o as g, p as l, q as D, r as j, s as U, t as x, u as d, v as f, w as h, x as I, y, z as T, A as _, D as b, E as q, F as v, G as w, R as B, S as F, H as G, I as L } from "./document-filter-CuDPYi7U.js";
 export {
   a as BASE_CURRENCY,
   u as Cue,
-  C as CueApi,
-  t as CueAppData,
-  r as CueApps,
-  i as CueAuth,
+  C as CueAdmin,
+  t as CueApi,
+  r as CueAppData,
+  i as CueApps,
+  o as CueAuth,
   c as CueCache,
-  o as CueContexts,
-  n as CueCurrency,
-  p as CueDmsApi,
-  E as CueDocumentFilter,
-  S as CueExtraction,
-  A as CueGis,
-  P as CueIndexApi,
-  R as CueMcp,
-  g as CuePrivileges,
-  m as CueProcessingApi,
-  D as CueProfile,
-  j as CueProjectDocuments,
-  l as CueProjectEntities,
-  U as CueProjectSchema,
-  x as CueProjectView,
-  f as CueProjects,
-  h as CueRequestError,
-  d as CueSignUp,
-  y as CueSignal,
-  I as CueStorage,
-  _ as CueSyncApi,
-  b as CueTables,
-  q as CueUserSettings,
-  v as REQUIRED_ROLES,
-  w as SUPPORTED_CURRENCIES,
-  B as configureScanWasm,
-  F as cueComputed
+  n as CueContexts,
+  p as CueCurrency,
+  S as CueDataSources,
+  E as CueDmsApi,
+  A as CueDocumentFilter,
+  m as CueExtraction,
+  P as CueGis,
+  R as CueIndexApi,
+  g as CueLlmTools,
+  l as CueMcp,
+  D as CuePrivileges,
+  j as CueProcessingApi,
+  U as CueProfile,
+  x as CueProjectDocuments,
+  d as CueProjectEntities,
+  f as CueProjectSchema,
+  h as CueProjectView,
+  I as CueProjects,
+  y as CueRequestError,
+  T as CueSignUp,
+  _ as CueSignal,
+  b as CueStorage,
+  q as CueSyncApi,
+  v as CueTables,
+  w as CueUserSettings,
+  B as REQUIRED_ROLES,
+  F as SUPPORTED_CURRENCIES,
+  G as configureScanWasm,
+  L as cueComputed
 };

package/lib/admin.d.ts

@@ -0,0 +1,109 @@
+import { CueAuth } from './auth';
+import { AdminDeletedOrganizationSummary, AdminDeletedUserSummary, AdminOrganization, AdminOrgSearchResult, AdminOrphanedOrganization, AdminOrphanedProject, AdminOrphanedUser, AdminProjectSearchResult, AdminRestoreOrganizationResult, AdminRestoreUserResult, AdminUserDetail, AdminUserSearchResult, OrganizationData, ProjectData } from './models';
+/**
+ * Cross-organisation lookup for platform superadmins.
+ *
+ * Every method here reaches data outside the caller's own orgs and projects, so
+ * each backing endpoint is `@SuperAdminsOnly()` — a non-superadmin caller gets a
+ * 403, not a filtered result set. Check `cue.auth.isSuperAdmin` before surfacing
+ * any UI that calls into this.
+ *
+ * Search is substring matching done server-side over a capped scan (Firestore
+ * has no substring index), so results are best-effort rather than exhaustive on
+ * very large collections — see the service-side notes in `data-views`.
+ *
+ * @example
+ * ```ts
+ * if (cue.auth.isSuperAdmin.get()) {
+ *   const orgs = await cue.admin.searchOrganizations('acme');
+ *   const detail = await cue.admin.getUserDetail(orgs[0].id);
+ * }
+ * ```
+ */
+export declare class CueAdmin {
+    private readonly _auth;
+    private readonly _gatewayUrl;
+    constructor(_auth: CueAuth, _gatewayUrl: string);
+    private _fetch;
+    private _search;
+    /** Matches organisations on name, id or any alternative id. */
+    searchOrganizations(q: string): Promise<AdminOrgSearchResult[]>;
+    /** Matches users on display name, e-mail, or an exact uid. */
+    searchUsers(q: string): Promise<AdminUserSearchResult[]>;
+    /**
+     * Matches projects on name, id or any alternative id, across every organisation.
+     * Soft-deleted projects are excluded unless `includeDeleted` is set.
+     */
+    searchProjects(q: string, includeDeleted?: boolean): Promise<AdminProjectSearchResult[]>;
+    /** Full profile for one user: auth record, orgs and projects they belong to. */
+    getUserDetail(uid: string): Promise<AdminUserDetail>;
+    /** Every organisation on the platform. Unpaginated — prefer `searchOrganizations`. */
+    listOrganizations(): Promise<OrganizationData[]>;
+    /**
+     * Every project owned by `orgId`, regardless of the caller's membership.
+     * Unlike `cue.projects.listProjects()` (which lists by direct project
+     * membership) this is what lets a superadmin open a foreign org's projects.
+     */
+    listOrgProjects(orgId: string): Promise<ProjectData[]>;
+    /** Every user holding the `superadmin` custom claim. */
+    listSuperadmins(): Promise<AdminUserSearchResult[]>;
+    /**
+     * Deletes the Auth account and profile doc, and scrubs every org/project
+     * membership. Archives a restorable snapshot first (see `restoreUser`) unless
+     * `hard` is set, which skips the archive entirely — intended for e2e test
+     * teardown, not normal superadmin use, since a hard delete cannot be undone.
+     */
+    deleteUser(uid: string, hard?: boolean): Promise<void>;
+    /**
+     * Undoes `deleteUser`: recreates the Auth account (same uid) and profile doc,
+     * and re-grants the recorded org/project roles where those still exist.
+     */
+    restoreUser(uid: string): Promise<AdminRestoreUserResult>;
+    /** Every archived deletion, restored or not — newest first. */
+    listDeletedUsers(): Promise<AdminDeletedUserSummary[]>;
+    /** Creates a Firebase Auth account with no organisation — for picking as a new org's initial admin. */
+    createAdminUser(dto: {
+        name: string;
+        email: string;
+    }): Promise<{
+        uid: string;
+        email: string;
+        name: string;
+    }>;
+    /** Grants the `superadmin` custom claim. The user must sign in again for it to take effect. */
+    grantSuperadmin(uid: string): Promise<void>;
+    /** Revokes the `superadmin` custom claim. */
+    revokeSuperadmin(uid: string): Promise<void>;
+    /** Creates a new organisation with `adminUserId` as its sole admin/member. */
+    createOrganization(dto: {
+        name: string;
+        domains: string[];
+        adminUserId: string;
+    }): Promise<AdminOrganization>;
+    /** Sets an organisation's allowed email domains for auto-join sign-up. */
+    setOrgDomains(orgId: string, domains: string[]): Promise<OrganizationData>;
+    /**
+     * Soft-deletes an organisation: flags it deleted (its `admins`/`members` stay
+     * intact as a relationship snapshot for `restoreOrganization`) and cascades —
+     * every active project under it is soft-deleted, and every admin/member with
+     * no *other* org membership is soft-deleted too (their own restorable
+     * snapshot, same as a direct `deleteUser`).
+     */
+    deleteOrganization(orgId: string): Promise<void>;
+    /** Undoes `deleteOrganization`: restores cascaded projects/users where they still can be, then un-flags the org. */
+    restoreOrganization(orgId: string): Promise<AdminRestoreOrganizationResult>;
+    /** Every soft-deleted organisation, restored or not — newest first. */
+    listDeletedOrganizations(): Promise<AdminDeletedOrganizationSummary[]>;
+    /** Users belonging to no organisation — a data-health diagnostic, not paginated. */
+    listUsersWithoutOrg(): Promise<AdminOrphanedUser[]>;
+    /** Users belonging to no project — a data-health diagnostic, not paginated. */
+    listUsersWithoutProject(): Promise<AdminOrphanedUser[]>;
+    /** Projects with no members, syncers, or admins — a data-health diagnostic. */
+    listProjectsWithoutUsers(): Promise<AdminOrphanedProject[]>;
+    /** Projects with no admin (may still have members/syncers) — a data-health diagnostic. */
+    listProjectsWithoutAdmins(): Promise<AdminOrphanedProject[]>;
+    /** Organisations with no members — a data-health diagnostic. */
+    listOrgsWithoutUsers(): Promise<AdminOrphanedOrganization[]>;
+    /** Organisations with no admin (may still have members) — a data-health diagnostic. */
+    listOrgsWithoutAdmins(): Promise<AdminOrphanedOrganization[]>;
+}

package/lib/api.d.ts

@@ -12,6 +12,8 @@ import { CueApps } from './apps';
 import { CueUserSettings } from './user-settings';
 import { CueProcessingApi } from './processing';
 import { CueDmsApi } from './dms';
+import { CueLlmTools } from './llm-tools';
+import { CueDataSources } from './data-sources';
 export declare class CueApi {
     private readonly _auth;
     private readonly _gatewayUrl;
@@ -36,6 +38,10 @@ export declare class CueApi {
     readonly processing: CueProcessingApi;
     /** Sync files into a project from a 3rd-party DMS (e.g. ThinkProject). */
     readonly dms: CueDmsApi;
+    /** Guarded LLM endpoints (llm-tools) — prompt-driven helpers like data-wrangling schema generation. */
+    readonly llmTools: CueLlmTools;
+    /** Project-scoped data sources — reusable raw-data-to-RDF pipelines writing into their own named graph. */
+    readonly dataSources: CueDataSources;
     /** Active language used for language-sensitive SPARQL queries across all project classes. */
     language: string;
     /** Updates the active language. All project classes (`CueProjectSchema`, `CueProjectDocuments`, `CueProjectEntities`) read this at query time. */

package/lib/cue.d.ts

@@ -8,6 +8,8 @@ import { CueApi } from './api';
 import { CueGis } from './gis';
 import { CueProjects } from './project';
 import { CueProfile } from './profile';
+import { CueUsageStats } from './usage-stats';
+import { CueAdmin } from './admin';
 import { CuePrivileges } from './privileges';
 import { CueCache } from './cache';
 import { CueCurrency } from './currency';
@@ -30,6 +32,9 @@ export declare class Cue {
     readonly api: CueApi;
     readonly projects: CueProjects;
     readonly profile: CueProfile;
+    readonly usageStats: CueUsageStats;
+    /** Cross-org lookup for platform superadmins — every call 403s for anyone else. */
+    readonly admin: CueAdmin;
     readonly privileges: CuePrivileges;
     readonly cache: CueCache;
     readonly storage: CueStorage;

package/lib/data-sources.d.ts

@@ -0,0 +1,186 @@
+import { CueAuth } from './auth';
+export type XToRdfConfig = RmlXToRdfConfig | GraphXToRdfConfig | DecompositionConfig;
+interface XToRdfConfigBase {
+    /** Steps run on the transform's output, in order — see `XToRdfPostProcessingStep`. */
+    postProcessing?: XToRdfPostProcessingStep[];
+}
+export interface RmlXToRdfConfig extends XToRdfConfigBase {
+    type: 'rml';
+    yarrrml?: string;
+    rml?: string;
+    options?: Record<string, unknown>;
+}
+export interface GraphXToRdfConfig extends XToRdfConfigBase {
+    type: 'graph';
+    constructQuery: string;
+    /**
+     * cue-ui's tuner-x-to-rdf wizard's saved type/relation mapping selection that
+     * produced constructQuery — lets a UI fully reopen the visual wizard for
+     * editing instead of only showing raw SPARQL text. Opaque to the SDK itself.
+     */
+    wizardConfig?: TypeMappingConfiguration;
+}
+export interface DecompositionConfig extends XToRdfConfigBase {
+    type: 'decomposition';
+    /**
+     * The `@context` `graph` and `frame` are written against — no longer a fixed constant once
+     * relationship predicates are user-chosen (a reversed relationship needs its own `@reverse`
+     * alias term). Opaque to the SDK itself.
+     */
+    context: Record<string, unknown>;
+    /**
+     * FLAT JSON-LD: one node object per canonical entity, no embedding — a building broken into
+     * storeys and spaces, a system into subsystems and components, an organization into
+     * departments and teams, or any other hierarchy a project needs. Containment is edges
+     * (`{'@id': ...}` references under each level's own relationship predicate), the actual RDF
+     * this decomposition produces. See cue-ui's spatial-decomposition component's `JsonLdNode`
+     * for the shape this always follows in practice. Opaque to the SDK itself.
+     */
+    graph: Record<string, unknown>[];
+    /**
+     * A real JSON-LD Frame that reconstitutes the hierarchy from `graph` — the declarative,
+     * standards-based artifact any JSON-LD processor can apply, unlike `levels` below which is
+     * specific to cue-ui's editor. Always regenerated from `levels` on save. Opaque to the SDK.
+     */
+    frame: Record<string, unknown>;
+    /**
+     * Root-to-leaf tiers of the hierarchy (label, category IRI, the relationship connecting each
+     * tier to its parent, and how that tier's nodes were created — geographic/floor-plan/manual)
+     * — lets the frontend reopen the editor with the same configuration it was built with, and is
+     * what `frame` above is derived from. Opaque to the SDK itself.
+     */
+    levels: Record<string, unknown>[];
+}
+/**
+ * A step applied to a transform's *output*, after the CONSTRUCT query (or RML mapping) has run.
+ *
+ * Recorded in the config rather than hardcoded in the pipeline so a data source is
+ * self-describing: what a stored mapping does to its input is not the query alone, and neither a
+ * human reading the config nor a future engine should have to know about an implicit post-pass.
+ * Order is significant. An absent `postProcessing` means "the default for this config type" —
+ * see `_postProcessingSteps` in writers-commands' data-sources.service.ts, which is also where the legacy
+ * behaviour for configs saved before this field existed is pinned down.
+ */
+export type XToRdfPostProcessingStep = MintCanonicalEntitiesStep;
+/**
+ * Rewrites every constructed subject that carries both `qcy:value` and `qcy:hasEntityCategory`
+ * onto a deterministic IRI derived from that pair (`<rdfBase><projectId>/<uuidv5(value+category)>`),
+ * rewrites every other reference to it, and adds a `qcy:similarTo` link back to the source IRI.
+ *
+ * Deriving the IRI from the value rather than the source document is what makes an `add` upload
+ * idempotent: the same entity arriving again — re-uploaded, exported under a different source
+ * IRI, or split across several files — resolves to the same IRI and merges instead of creating a
+ * second instance.
+ */
+export interface MintCanonicalEntitiesStep {
+    type: 'mint-canonical-entities';
+    /**
+     * Revision of the IRI derivation itself. Bumped only if that derivation changes, so an
+     * existing data source keeps producing the IRIs it was built against instead of silently
+     * re-keying everything already in its named graph.
+     */
+    version: 1;
+}
+/** Mirrors cue-ui's tuner-x-to-rdf `TypeMappingConfiguration` exactly. */
+export interface TypeMappingConfiguration {
+    id?: string;
+    name: string;
+    typeMappings: {
+        typeIri: string;
+        categoryIri: string;
+    }[];
+    relationMappings: {
+        sourceTypeIri: string;
+        targetTypeIri: string;
+        predicateIri: string;
+        reversed?: boolean;
+    }[];
+}
+export interface DataSourceRecord {
+    id: string;
+    projectId: string;
+    name: string;
+    createdAt: string;
+    createdBy: string;
+    updatedAt: string;
+    updatedBy: string;
+    /** Named graph all of this data source's derived triples live in. */
+    namedGraph: string;
+    /** Triple count in `namedGraph` as of the last successful upload — a cache updated after every
+     *  upload, not computed live on read. */
+    tripleCount: number;
+    /** When data was last uploaded to this source; null until the first upload. */
+    lastUploadedAt: string | null;
+    config: XToRdfConfig;
+}
+export type UploadDataSourceMode = 'replace' | 'add';
+export interface UploadDataSourceResult {
+    added: number;
+    removed: number;
+}
+/** Live status reported while `uploadData`/`previewTransform` are in flight — any
+ *  number of these arrive via `onProgress` before the call resolves or rejects. */
+export interface DataSourceProgressEvent {
+    phase: string;
+    message: string;
+    pct?: number;
+}
+/**
+ * Client for project-scoped data sources — a named, reusable raw-data-to-RDF
+ * pipeline whose config (RML mapping or CONSTRUCT query) is stored once and
+ * re-applied to every subsequent data upload. Uploaded data's derived triples
+ * land in the data source's own named graph.
+ *
+ * Mutations (create/update/delete/uploadData) go through writers-commands and
+ * require the syncer role; reads (list/get) go through data-views.
+ *
+ * Exposed as `cue.api.dataSources`.
+ */
+export declare class CueDataSources {
+    private readonly _auth;
+    private readonly _gatewayUrl;
+    constructor(_auth: CueAuth, _gatewayUrl: string);
+    createDataSource(projectId: string, name: string, config: XToRdfConfig): Promise<DataSourceRecord>;
+    updateDataSource(projectId: string, id: string, updates: {
+        name?: string;
+        config?: XToRdfConfig;
+    }): Promise<DataSourceRecord>;
+    /** Hard delete — also removes the data source's triples from the graph/ledger. */
+    deleteDataSource(projectId: string, id: string): Promise<void>;
+    /**
+     * Uploads new data to be transformed by the data source's stored config and
+     * committed into its named graph. `mode: 'replace'` swaps out everything
+     * previously derived from this source; `'add'` merges alongside it.
+     *
+     * `files` may contain more than one document — for `type: 'graph'` configs
+     * they're all loaded into one shared graph server-side before the stored
+     * CONSTRUCT query runs against it. `type: 'rml'` configs expect exactly one.
+     *
+     * The endpoint streams NDJSON progress while the upload is in flight — pass
+     * `onProgress` to receive it. The call still resolves/rejects only once, with
+     * the final result or an `Error` built from the stream's `error` line (a
+     * non-2xx HTTP status, e.g. an auth/guard rejection before the handler even
+     * runs, is still thrown from `response.ok` as before).
+     */
+    uploadData(projectId: string, id: string, files: Blob[], mode: UploadDataSourceMode, onProgress?: (event: DataSourceProgressEvent) => void): Promise<UploadDataSourceResult>;
+    /**
+     * Dry-run: runs `config` against `files` and returns the resulting Turtle,
+     * without creating a data source or writing anything to the graph/ledger —
+     * for previewing a transform (e.g. while building a CONSTRUCT query or RML
+     * mapping) before saving it. Same transform code as `uploadData`, so a
+     * preview never drifts from what an actual upload would produce. Streams
+     * progress the same way — see `uploadData`'s doc comment.
+     */
+    previewTransform(projectId: string, config: XToRdfConfig, files: Blob[], onProgress?: (event: DataSourceProgressEvent) => void): Promise<{
+        turtle: string;
+    }>;
+    /** Reads an NDJSON response (`{type:'progress',...}` lines, then one `{type:'result',...}`
+     *  or `{type:'error',...}` line), forwarding progress events to `onProgress` and
+     *  resolving/rejecting with the terminal event. The HTTP status alone can't signal
+     *  failure here — the server commits to 200 as soon as the first line is written. */
+    private _consumeNdjsonResult;
+    listDataSources(projectId: string): Promise<DataSourceRecord[]>;
+    getDataSource(projectId: string, id: string): Promise<DataSourceRecord>;
+    private _errorMessage;
+}
+export {};

package/lib/index-api.d.ts

@@ -29,11 +29,13 @@ export declare class CueIndexApi {
      */
     rebuild(projectId: string, onProgress?: (message: string) => void): Promise<string>;
     /**
-     * Forces a full re-scan of every project's QLever stats (materialized views,
-     * index size, cue-meta) and persists the result, bypassing the normal cache
-     * TTL. Super-admin only. This refreshes the shared stats aggregate for ALL
-     * projects, not just the current one — there's no per-project variant since
-     * the aggregate is written as a single file. Resolves with a summary message.
+     * Recomputes QLever stats (document count, materialized views, index size)
+     * from the index and persists the result, bypassing the normal cache TTL.
+     * Super-admin only. Resolves with a summary message.
+     *
+     * Pass `projectId` to refresh that project alone — the usual case, and much
+     * cheaper. Omit it to re-scan EVERY project on the volume, which costs several
+     * SPARQL queries per index and can run for minutes.
      */
-    refreshStats(): Promise<string>;
+    refreshStats(projectId?: string): Promise<string>;
 }

package/lib/llm-tools.d.ts

@@ -0,0 +1,64 @@
+import { CueAuth } from './auth';
+export declare const ENDPOINT_WRANGLING_SCHEMA_GENERATE = "/llm-tools/wrangling-schema/generate";
+export declare const ENDPOINT_WRANGLING_SCHEMA_REFINE = "/llm-tools/wrangling-schema/refine";
+export interface GenerateWranglingSchemaRequest {
+    /** Plain-language instruction for how the sheet should be reshaped. */
+    prompt: string;
+    /** Column names available in the sheet. */
+    columns: string[];
+    /** A handful of real rows, given as worked examples for the model. */
+    exampleRows: Record<string, unknown>[];
+    /** Project the request is scoped to. */
+    projectId: string;
+}
+export interface GenerateWranglingSchemaResponse {
+    /**
+     * Plain objects shaped like cue-ui's `WranglingRule` (splitCell | formula).
+     * Run through cue-ui's `normalizeWranglingSettings` before use — the model's
+     * output isn't guaranteed to be a well-formed rule set.
+     */
+    rules: Record<string, unknown>[];
+}
+export interface RefineWranglingSchemaRequest {
+    /** The instruction that produced `currentRules`. */
+    previousPrompt: string;
+    /** The rule set currently in effect — may include manual edits since `previousPrompt`. */
+    currentRules: Record<string, unknown>[];
+    /** The new, follow-up instruction. */
+    prompt: string;
+    /** Column names available in the sheet. */
+    columns: string[];
+    /** A handful of real rows, given as worked examples for the model. */
+    exampleRows: Record<string, unknown>[];
+    /** Project the request is scoped to. */
+    projectId: string;
+}
+export interface RefineWranglingSchemaResponse {
+    /** The complete, updated rule set — a replacement, not a diff. Same shape as `generate`'s. */
+    rules: Record<string, unknown>[];
+}
+/**
+ * Client for the llm-tools guarded-LLM endpoints — small, single-purpose
+ * backend calls that turn a prompt plus example data into a structured JSON
+ * result, each backed by its own internal system instructions.
+ *
+ * Exposed as `cue.api.llmTools`.
+ */
+export declare class CueLlmTools {
+    private readonly _auth;
+    private readonly _gatewayUrl;
+    constructor(_auth: CueAuth, _gatewayUrl: string);
+    /**
+     * Generates a data-wrangling rule set (the `splitCell`/`formula` rules cue-ui's
+     * `cue-data-wrangler` runs) from a plain-language instruction and a few example
+     * rows — for people who don't want to hand-write a regex.
+     */
+    generateWranglingSchema(request: GenerateWranglingSchemaRequest): Promise<GenerateWranglingSchemaResponse>;
+    /**
+     * Improves a previously drafted rule set from a follow-up instruction — sends the
+     * instruction that produced the current rules alongside the new one and the rules
+     * themselves (which may have been hand-edited since), so the model revises rather
+     * than starts over.
+     */
+    refineWranglingSchema(request: RefineWranglingSchemaRequest): Promise<RefineWranglingSchemaResponse>;
+}