@qaecy/cue-sdk 0.0.50 → 0.0.52

package/lib/models.d.ts

@@ -1,5 +1,5 @@
 import { SupportedCurrency } from './currency';
-import { ComparisonResult } from 'js-sync-tools';
+import { ComparisonResult } from '../../sync-tools/src/index';
 export type CueEnvironment = 'production' | 'emulator';
 export interface CueEndpoints {
     /** API gateway base URL */
@@ -122,11 +122,13 @@ export interface McpContext {
  * Deliberately a sibling of `graph`, not a new `graph.type` value: `cue` is not
  * a graph backend. `databases-cue` owns all three engines, so `graph.type:
  * 'cue'` would say "the graph lives at cue" while leaving vector and FTS
- * pointed at `writers-index` — two owners for one project, which is the exact
- * split this field exists to prevent. See the monorepo's
- * `apps/databases/cue/PLAN.md` §9b.
+ * pointed elsewhere — two owners for one project, which is the exact split this
+ * field exists to prevent. See the monorepo's `apps/databases/cue/PLAN.md` §9b.
+ *
+ * A union of one: `cue` is the only owner left, and the type is kept so that a
+ * second deployment of it stays expressible without changing every call site.
  */
-export type IndexService = 'writers-index' | 'cue';
+export type IndexService = 'cue';
 export interface IndexSettings {
     service: IndexService;
     /**
@@ -145,10 +147,7 @@ export interface ProjectSettings {
         type: 'qlever' | 'fuseki';
         uri?: string;
     };
-    /**
-     * Absent means `writers-index` — every project predating this field is on it,
-     * so the default has to be the status quo, not the new service.
-     */
+    /** Absent means the deployment's configured `index_default_service`. */
     index?: IndexSettings;
     /** Processing tier determining credit costs. Defaults to "l" if not set. */
     tier?: 's' | 'm' | 'l';
@@ -161,6 +160,23 @@ export interface ProjectSettings {
      * project) — set it directly on the project's Firestore doc.
      */
     gzipEnabled?: boolean;
+    /**
+     * BCP-47 tags the project works in, and the single source of that answer.
+     *
+     * `en` is the pivot: every label map carries it, it is what an untranslated
+     * literal falls back to, and it is therefore never a translation *target*. It
+     * is implied whether or not it is stored, so `['da']` and `['en','da']` mean
+     * the same thing — both readers normalize to `['en','da']`.
+     *
+     * Absent means English only, which is what every project resolved to before
+     * this field existed.
+     *
+     * Read by `writers-commands` (stamped onto `ProjectSchema.languages` on every
+     * schema write), the schema-suggestion endpoint (which languages a proposed
+     * term is translated into), and the translation enricher (its targets, minus
+     * the pivot).
+     */
+    languages?: string[];
 }
 /** One daily snapshot in `QleverStats.history` — a calendar day this index's stats were (re)computed. */
 export interface QleverStatsHistoryEntry {
@@ -171,13 +187,22 @@ export interface QleverStatsHistoryEntry {
     numSubjects: number | null;
     numPredicates: number | null;
     numObjects: number | null;
-    indexSizeBytes: number | null;
+    graphSizeInBytes: number | null;
 }
+/**
+ * A project's index stats, sourced from `databases-cue`'s `/stats/project`.
+ * Field names follow `databases-cue`'s shape (`graphSizeInBytes`, plus
+ * `fts`/`vector`/`ledgerSizeInBytes`) rather than the legacy `indexSizeBytes` —
+ * this is also exactly the shape `cue-ui`'s `ProjectInsights`
+ * (`views/project-workspace/models.ts`) expects.
+ */
 export interface QleverStats {
     /** ISO timestamp of when this index was first created (init or clone) — null for indexes built before this field existed. */
     created: string | null;
     builtAt: string | null;
     qleverVersion: string | null;
+    /** QLever CLI version currently deployed — compare against `qleverVersion` to tell whether this project's index needs `migrate()`. */
+    currentQleverVersion: string | null;
     numTriples: number | null;
     numSubjects: number | null;
     numPredicates: number | null;
@@ -185,7 +210,19 @@ export interface QleverStats {
     numDocuments: number | null;
     /** ISO timestamp of the last build whose triple/subject/predicate counts actually differed from the build before it. */
     lastChanged: string | null;
-    indexSizeBytes: number | null;
+    graphSizeInBytes: number | null;
+    /** FTS (Tantivy) index size, in bytes. */
+    ftsSizeInBytes: number | null;
+    /** Vector (LanceDB) index size, in bytes. */
+    vectorSizeInBytes: number | null;
+    /** Total size of the RDF ledger backing this project, in bytes. */
+    ledgerSizeInBytes: number | null;
+    /**
+     * True when at least one engine holding real data has been evicted to cloud
+     * storage and deleted locally by the sync-bridge's idle sweep —
+     * `CueIndexApi.warmUp` restores it.
+     */
+    idled: boolean;
     updateFractionPct: number | null;
     lastQueriedAt: string | null;
     resolvedMentions: number | null;
@@ -229,6 +266,11 @@ export interface CreateProjectOptions {
     graphType?: 'fuseki' | 'qlever';
     /** Processing tier determining credit costs. */
     tier?: 's' | 'm' | 'l';
+    /**
+     * BCP-47 tags the project works in. See {@link ProjectSettings.languages} —
+     * normalized server-side, so omitting `en` is the same as naming it.
+     */
+    languages?: string[];
 }
 export interface ProjectLocation {
     lat: number;
@@ -891,8 +933,12 @@ export interface EntityCoreData {
 }
 /** A single directed relationship edge between two entities. */
 export interface EntityRelationship {
-    /** IRI of the property used (e.g. `qcy:hasContractor`). */
+    /** IRI of the property used — one of the five groups (e.g. `qcy:involves`). */
     relIRI: string;
+    /** IRI of the relation category that says which relation this is, when one was named. */
+    categoryIRI?: string;
+    /** What the source document said about this relation, when there is a note. */
+    note?: string;
     /** Full IRI of the related entity. */
     nodeIRI: string;
     /** Label of the related entity. */
@@ -954,6 +1000,115 @@ export interface SummaryGraphData {
         weight: number;
     }>;
 }
+/**
+ * One entity category that at least one `qcy:EntityPrototype` belongs to,
+ * with the number of prototypes carrying it.
+ *
+ * Unlike `contentCategoriesInProject`, the count is a field of its own rather
+ * than being folded into `label` — the prototype browser renders the two
+ * separately.
+ */
+export interface PrototypeCategoryCount {
+    iri: string;
+    /**
+     * `skos:prefLabel` in the active language when the category has one. The IFC
+     * processor mints category IRIs from the BEO class list, so most carry no
+     * label at all; those fall back to the IRI fragment.
+     */
+    label: string;
+    /** Number of distinct prototypes in this category. */
+    count: number;
+}
+/** One `qcy:EntityPrototype`, as listed under a category. */
+export interface PrototypeSummary {
+    iri: string;
+    uuid: string;
+    /**
+     * `qcy:value` — the type object's name. Empty when the IFC type object had no
+     * `Name`/`ElementType`/`PredefinedType`, which the writer allows.
+     */
+    value: string;
+    /** Number of entities pointing here with `qcy:inheritsFrom`. */
+    instanceCount: number;
+}
+/** One `qcy:Property` hanging off a prototype (or any other entity). */
+export interface PrototypeProperty {
+    iri: string;
+    /** `qcy:label` — an untagged literal, so no language filtering applies. */
+    label: string;
+    /** `qcy:value`, stringified. The writer types these (`xsd:double`, …). */
+    value: string;
+    /** `qcy:unit` — only the polygon-area path emits one, so usually absent. */
+    unit?: string;
+    /** `qcy:ifcPSet` — the IFC property set this came from. */
+    pset?: string;
+}
+/** One entity inheriting from a prototype via `qcy:inheritsFrom`. */
+export interface PrototypeInstance {
+    iri: string;
+    uuid: string;
+    value: string;
+}
+/**
+ * One entity located inside one source model, as resolved from a
+ * `qcy:IFCExpressIDSelector`.
+ *
+ * An entity can appear in several models (a federated project mentions the same
+ * canonical entity from each of them), so a single requested IRI can yield more
+ * than one of these.
+ */
+export interface EntityModelLocation {
+    /** The IRI that was asked about — a mention or a canonical entity. */
+    requestedIri: string;
+    /**
+     * The IRI the selector actually points at (`qcy:selectorObject`). Equal to
+     * `requestedIri` for a mention; the mention behind it when a canonical entity
+     * was requested and the `qcy:resolvesTo` hop was taken.
+     */
+    mentionIri: string;
+    /** `qcy:selectorSubject` — the model's `qcy:FileContent` IRI. */
+    modelIri: string;
+    /** UUID of that model — the key `CueProjectDocuments` and storage take. */
+    modelUuid: string;
+    /** `qcy:value` of the selector, parsed. The handle `cue-ifc-viewer` selects on. */
+    expressId: number;
+}
+/**
+ * The express IDs of a set of entities that live in one model, ready to hand to
+ * a viewer alongside that model's file.
+ */
+export interface ModelExpressIds {
+    /** `qcy:FileContent` IRI of the model. */
+    modelIri: string;
+    /** UUID of that model. */
+    modelUuid: string;
+    /** Ascending, de-duplicated. */
+    expressIds: number[];
+}
+/**
+ * One prototype's occurrences inside one model, as returned for a whole entity
+ * category at once — enough to colour every prototype in that category
+ * differently in a single pass.
+ */
+export interface PrototypeCategoryExpressIds extends ModelExpressIds {
+    /** The `qcy:EntityPrototype` the express IDs inherit from. */
+    prototypeIri: string;
+}
+/**
+ * The entity behind one express ID, with the prototype and category it belongs
+ * to — the reverse of `entityExpressIds`, for turning a click in a model viewer
+ * back into something the graph can be browsed by.
+ */
+export interface EntityAtExpressId {
+    /** The `qcy:EntityMention` the selector points at. */
+    entityIri: string;
+    /** `qcy:value` of that entity, or an empty string when it carries none. */
+    value: string;
+    /** The `qcy:EntityPrototype` it inherits from, when it has one. */
+    prototypeIri?: string;
+    /** The prototype's entity category, when the prototype carries one. */
+    categoryIri?: string;
+}
 /** Core metadata for a single document (FileContent node). */
 export interface DocumentInfo {
     id: string;

package/lib/privileges.d.ts

@@ -18,6 +18,7 @@ export interface Privileges {
     editTier: boolean;
     hardDeleteProject: boolean;
     inviteUserToProject: boolean;
+    migrate: boolean;
     rebuildIndex: boolean;
     refreshStats: boolean;
     renameDocuments: boolean;

package/lib/profile.d.ts

@@ -145,14 +145,6 @@ export declare class CueProfile {
         checkoutUrl?: string;
     }>;
     private _requireUser;
-    /**
-     * Fetch display name and email for a list of user UIDs.
-     * Uses the `getUserInfo` Firebase callable function.
-     */
-    getUserInfo(uids: string[]): Promise<Record<string, {
-        name: string;
-        email: string;
-    }>>;
     /** Record that the current user has accepted the terms of service. Sets a `terms` custom claim on the token. */
     acceptTerms(version: string): Promise<void>;
     /**

package/lib/project-schema.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The project-schema DTO, re-exported so consumers outside the monorepo can
+ * reach it.
+ *
+ * `js/models` is a monorepo-internal tsconfig path — there is no `@qaecy/models`
+ * package — so cue-ui and any other external consumer can only see these shapes
+ * through this barrel. The alternative is a third hand-written copy of the DTO,
+ * and the parity test (`libs/py/shared-types/tests/test_project_schema_parity.py`)
+ * only guards two: the TypeScript source and its Python twin. So nothing outside
+ * declares its own.
+ *
+ * Two names are renamed on the way out, because the SDK already owns them:
+ *
+ * - `LangMap` -> `SchemaLangMap`. The SDK's own {@link LangMap} is the
+ *   *graph-read* shape, which adds a `default` key that always resolves to
+ *   English. The DTO's is the *document* shape, where `en` is the pivot and is
+ *   always present and there is no `default`. Both are legitimate; a consumer
+ *   must not be able to pass one where the other is meant.
+ * - `Kind` -> `SchemaTermKind`, which says what it is: the IRI segment a term's
+ *   kind contributes (`e` / `c` / `p`).
+ * - `AltLabelMap` -> `SchemaAltLabelMap`, for the same reason as `LangMap`: a
+ *   name the SDK might otherwise want for something else.
+ */
+export { CatalogKind, Provenance, CanonicalPolicy, ResolutionIdentity, NumeralRole, EmbeddingBasis, Kind as SchemaTermKind, DEFAULT_SCHEMA_BASE, CORE_PREFIXES, isCurie, deriveIri, expandCurie, resolveRef, resolveIri, rdfBase, schemaGraphIri, } from '../../models/src/index';
+export type { LangMap as SchemaLangMap, AltLabelMap as SchemaAltLabelMap, Ref as SchemaRef, ResolutionRules, Canonical, EntityCategory, RelationCategory, ContentCategory, CodingScheme, CodingSchemeField, ProjectSchema, Catalog, CatalogIndex, CatalogIndexEntry, MimeCategoryTerm, MimeDeclaration, } from '../../models/src/index';

package/lib/project.d.ts

@@ -3,6 +3,13 @@ import { CueAuth } from './auth';
 import { CreateProjectOptions, CueEndpoints, ProjectData, ProjectMetadata } from './models';
 import { ReadonlySignal } from './signal';
 type ProjectRole = 'admin' | 'syncer' | 'member';
+/** What `updateProject` accepts. Every field optional; omitted means unchanged. */
+export interface ProjectUpdate {
+    name?: string;
+    isPublic?: boolean;
+    /** BCP-47 tags. See {@link ProjectSettings.languages}; normalized server-side. */
+    languages?: string[];
+}
 export declare class CueProjects {
     private readonly _auth;
     private readonly _db;
@@ -67,6 +74,20 @@ export declare class CueProjects {
      * Returns `{}` if none has been set yet.
      */
     getProjectMetadata(projectId: string): Promise<ProjectMetadata>;
+    /**
+     * Edits the project itself — name, visibility, and the languages it works in.
+     *
+     * Project admins and superadmins only; anyone else is refused. Omit a field
+     * to leave it as it is.
+     *
+     * `languages` is normalized server-side: the `en` pivot is always present and
+     * always first, order is otherwise preserved and duplicates dropped, so
+     * `['da']` and `['en','da']` are the same request. It is the single source of
+     * what languages a project works in — a schema write stamps it onto the
+     * document, a proposed term is translated into it, and the translation
+     * enricher takes its targets from it.
+     */
+    updateProject(projectId: string, updates: ProjectUpdate): Promise<ProjectData>;
     /** Sets a project's portal-only metadata. Omit a field to leave it untouched, `null` to clear it. */
     setProjectMetadata(projectId: string, metadata: ProjectMetadata): Promise<void>;
 }

package/lib/schema-suggestion.d.ts

@@ -0,0 +1,81 @@
+import { CatalogIndex, ProjectSchema } from '../../models/src/index';
+import { CueAuth } from './auth';
+export declare const ENDPOINT_SCHEMA_SUGGESTION_FROM_PROSE = "/llm-tools/schema-suggestion/from-prose";
+export declare const ENDPOINT_SCHEMA_SUGGESTION_CATALOGS = "/llm-tools/schema-suggestion/catalogs";
+export interface SuggestSchemaFromProseRequest {
+    /** A description of the project — a paragraph or two, not a document. */
+    prose: string;
+    /** Project the request is scoped to, and the one the returned IRIs derive against. */
+    projectId: string;
+    /**
+     * Carried onto the returned schema. The catalogues hold da/de/en/fr/it, and a
+     * proposed term is translated in the same call that proposes it, so this is
+     * what decides whether a Danish project gets Danish labels on both.
+     *
+     * The endpoint does **not** look the project's languages up — it falls back
+     * to `['en']` alone. Pass the project's own `ProjectSettings.languages`, or
+     * a Danish project gets English-only suggestions beside Danish catalogue
+     * terms.
+     */
+    languages?: string[];
+    /** How many catalogues triage may open. Server default is 6; the cap is 12. */
+    maxCatalogs?: number;
+}
+export interface SchemaSuggestionUsage {
+    /** Catalogue ids triage chose to open, in index order. */
+    catalogsOpened: string[];
+    /** Entity categories the model could see in the selection call. */
+    termsOffered: number;
+    /** Entity categories it selected, before reference closure. */
+    termsSelected: number;
+    /** Entity categories pulled in because a selected one referenced them. */
+    termsClosedOver: number;
+    tokensIn: number;
+    tokensOut: number;
+}
+export interface SuggestSchemaFromProseResponse {
+    /**
+     * Entity categories only. Document types are a fixed QAECY-maintained
+     * taxonomy shared by every project, so `schema.contentCategories` comes back
+     * empty and an entity references one by `qcy-e:` CURIE instead.
+     *
+     * This is a *proposal*, not a saved document: it has never been through
+     * `putSchema` and its `revision` means nothing. Merge it into the document
+     * you read, then save that.
+     */
+    schema: ProjectSchema;
+    /** Anything the caller should know: dropped suggestions, refs closed over, a thin selection. */
+    notes: string[];
+    usage: SchemaSuggestionUsage;
+}
+/**
+ * Client for llm-tools' schema-suggestion endpoints — prose in, a proposed
+ * `ProjectSchema` out, assembled by selecting from the published catalogues
+ * rather than by having a model retype curated terms.
+ *
+ * Exposed as `cue.api.schemaSuggestion`.
+ */
+export declare class CueSchemaSuggestion {
+    private readonly _auth;
+    private readonly _gatewayUrl;
+    constructor(_auth: CueAuth, _gatewayUrl: string);
+    /**
+     * Turns a project description into a proposed schema of entity categories.
+     *
+     * Two model calls: triage picks which catalogues are worth opening from the
+     * index alone, selection picks terms out of digests of just those. Selected
+     * terms are hydrated from the catalogue JSON verbatim, so their prompts and
+     * label maps arrive intact.
+     */
+    fromProse(request: SuggestSchemaFromProseRequest): Promise<SuggestSchemaFromProseResponse>;
+    /**
+     * The catalogue index triage sees: ids, labels, term counts and the file each
+     * one lives in.
+     *
+     * Worth calling on its own to show the same map a user's suggestion was drawn
+     * from, or to check that a deploy actually reaches the catalogue bucket —
+     * an empty index is the failure mode, and it is silent from `fromProse` alone.
+     */
+    catalogs(projectId: string): Promise<CatalogIndex>;
+    private _errorMessage;
+}

package/lib/semantic-template.d.ts

@@ -1,3 +1,4 @@
+import { EntityCategory, ProjectSchema } from '../../models/src/index';
 import { CueAuth } from './auth';
 export interface MutationResult {
     message: string;
@@ -31,6 +32,26 @@ export interface EntityRelationshipInput extends EntityCategoryInput {
     sources: string[];
     targets: string[];
 }
+/**
+ * One project the caller could take an existing schema from — what
+ * `listSchemaSources` lists.
+ *
+ * Counts rather than terms: the picker needs to say which project and how much
+ * is in it, and the document itself is one `getSchema(projectId)` away once the
+ * user has chosen. Projects with a schema that has no terms are not listed at
+ * all, so every entry here copies something.
+ */
+export interface SchemaSource {
+    projectId: string;
+    projectName: string;
+    /** The source document's revision, not the destination's. */
+    revision: number;
+    updatedAt?: string;
+    sourceLanguage: string;
+    languages: string[];
+    entityCategories: number;
+    relations: number;
+}
 /**
  * Client for writers-commands' semantic-template CRUD endpoints — persists a
  * project's custom extraction/classification schema (content categories,
@@ -55,8 +76,48 @@ export declare class CueSemanticTemplate {
     createEntityRelationshipBatch(projectId: string, items: EntityRelationshipInput[]): Promise<BatchMutationResult>;
     deleteEntityRelationship(projectId: string, value: string): Promise<MutationResult>;
     deleteEntityRelationshipBatch(projectId: string, values: string[]): Promise<BatchMutationResult>;
+    /**
+     * The project's `ProjectSchema` — the document that replaces the semantic
+     * extraction template, migrated from it on first read.
+     *
+     * Read the document rather than the schema graph: `provenance`, `catalog`,
+     * `canonicalPolicy` and the `iri` pin exist only here, and `provenance` is
+     * what decides which fields a user is allowed to edit.
+     */
+    getSchema(projectId: string): Promise<ProjectSchema>;
+    /**
+     * Replaces the whole document.
+     *
+     * `schema.revision` is the concurrency token: pass back the one you read. A
+     * stale revision is refused with 409 rather than overwriting whatever landed
+     * in between, so re-read and re-apply rather than retrying the same body.
+     *
+     * The response carries the saved document with its revision bumped — use it
+     * as the new baseline.
+     */
+    putSchema(projectId: string, schema: ProjectSchema): Promise<ProjectSchema>;
+    /**
+     * The caller's *other* projects that already have a schema, so a new project
+     * can start from one instead of from prose.
+     *
+     * `projectId` is the destination — the project being set up — and is excluded
+     * from its own answer. What comes back is scoped to the caller's memberships
+     * server-side, so this never reveals a project they are not on.
+     *
+     * Reading a chosen source is plain `getSchema(source.projectId)`: the gateway
+     * authorizes that call by membership on that project, which the caller has by
+     * virtue of it being listed here.
+     */
+    listSchemaSources(projectId: string): Promise<SchemaSource[]>;
+    /**
+     * The QAECY catalogues' non-deprecated entity categories, for the wizard's "use default"
+     * starting point — the same list for every caller, nothing project-specific about it.
+     */
+    getDefaultEntities(projectId: string): Promise<EntityCategory[]>;
     /** Re-pushes the project's currently stored template into its `databases-cue` schema graph, without mutating it. */
     reloadSchema(projectId: string): Promise<MutationResult>;
+    private _get;
+    private _send;
     private _post;
     private _delete;
     private _errorMessage;

package/lib/sync.d.ts

@@ -1,5 +1,5 @@
-import { CueBlobStorage } from 'js-databases';
-import { LocalFile } from 'js-sync-tools';
+import { CueBlobStorage } from '../../databases/src/index';
+import { LocalFile } from '../../sync-tools/src/index';
 import { CueAuth } from './auth';
 import { CueApi } from './api';
 import { CueProfile } from './profile';
@@ -137,7 +137,12 @@ export declare class CueSyncApi {
      *
      * @param file    - `LocalFile` with `data` populated (e.g. from `File.arrayBuffer()`).
      * @param options - Upload options including project/provider/user context and an
-     *   optional `AbortSignal` for cancellation and `onProgress` for tracking.
+     *   optional `AbortSignal` for cancellation and `onProgress` for tracking. Set
+     *   `skipProcessing` to keep the standard per-suffix processor pipeline from
+     *   picking this file up (e.g. when the caller already parsed it itself).
+     * @returns The identifiers `uploadedFileMetadata` derived for this file, so
+     *   callers that need to reference the document immediately (e.g. to attach
+     *   an alternative representation) don't have to recompute them.
      */
     syncBrowserFile(file: LocalFile, options: {
         spaceId: string;
@@ -145,7 +150,12 @@ export declare class CueSyncApi {
         userId: string;
         signal?: AbortSignal;
         onProgress?: (percent: number) => void;
-    }): Promise<void>;
+        skipProcessing?: boolean;
+    }): Promise<{
+        documentUUID: string;
+        blob_name: string;
+        suffix: string;
+    }>;
     getTierNames(): Promise<Record<string, string>>;
     /**
      * Per-extension credit rates for `tier` (e.g. `{ pdf: 4, ifc: 2, dwg: 2 }`),

package/node.js

@@ -1,49 +1,69 @@
-import { C as s } from "./document-filter-C9Og2u8R.js";
-import { B as o, a as c, b as i, c as n, d as p, e as S, f as m, g as E, h as A, i as l, j as P, k as R, l as g, m as D, n as x, o as d, p as j, q as U, r as f, s as h, t as I, u as T, v as y, w as G, x as N, y as _, z as b, A as q, D as v, E as w, F as B, G as F, H as L, I as O, R as k, S as z, J as H, K as J } from "./document-filter-C9Og2u8R.js";
-class C extends s {
+import { c as s } from "./document-filter-BuFNMQwr.js";
+import { B as t, C as c, a as n, b as S, d as E, e as m, f as p, g as l, h as A, i as P, j as R, k as d, l as _, m as I, n as g, o as T, p as D, q as N, r as O, s as U, t as G, u as h, v as x, w as f, x as j, y as v, z as M, A as y, D as B, E as F, F as L, G as H, H as b, I as K, J as q, K as w, L as Q, M as V, N as W, O as X, P as Y, Q as k, R as z, S as J, T as Z, U as $, V as ee, W as se, X as ae, Y as ue, Z as Ce, _ as re, $ as ie, a0 as oe, a1 as te, a2 as ce, a3 as ne } from "./document-filter-BuFNMQwr.js";
+import "uuid";
+class r extends s {
   constructor(e) {
     super(e);
   }
 }
 export {
-  o as BASE_CURRENCY,
+  t as BASE_CURRENCY,
+  c as CORE_PREFIXES,
+  n as CanonicalPolicy,
+  S as CatalogKind,
   s as Cue,
-  c as CueAdmin,
-  i as CueApi,
-  n as CueAppData,
-  p as CueApps,
-  S as CueAuth,
-  m as CueCache,
-  E as CueContexts,
-  A as CueCurrency,
-  l as CueDataSources,
-  P as CueDmsApi,
-  R as CueDocumentFilter,
-  g as CueExtraction,
+  E as CueAdmin,
+  m as CueApi,
+  p as CueAppData,
+  l as CueApps,
+  A as CueAuth,
+  P as CueCache,
+  R as CueContexts,
+  d as CueCurrency,
+  _ as CueDataSources,
+  I as CueDmsApi,
+  g as CueDocumentFilter,
+  T as CueExtraction,
   D as CueGis,
-  x as CueGisSources,
-  d as CueIndexApi,
-  j as CueLlmTools,
-  U as CueMcp,
-  C as CueNode,
-  f as CuePrivileges,
-  h as CueProcessingApi,
-  I as CueProfile,
-  T as CueProjectDocuments,
-  y as CueProjectEntities,
-  G as CueProjectSchema,
-  N as CueProjectView,
-  _ as CueProjects,
-  b as CueRequestError,
-  q as CueSemanticTemplate,
-  v as CueSignUp,
-  w as CueSignal,
-  B as CueStorage,
-  F as CueSyncApi,
-  L as CueTables,
-  O as CueUserSettings,
-  k as REQUIRED_ROLES,
-  z as SUPPORTED_CURRENCIES,
-  H as configureScanWasm,
-  J as cueComputed
+  N as CueGisSources,
+  O as CueIndexApi,
+  U as CueLlmTools,
+  G as CueMcp,
+  r as CueNode,
+  h as CuePrivileges,
+  x as CueProcessingApi,
+  f as CueProfile,
+  j as CueProjectDocuments,
+  v as CueProjectEntities,
+  M as CueProjectSchema,
+  y as CueProjectView,
+  B as CueProjects,
+  F as CueRequestError,
+  L as CueSchemaSuggestion,
+  H as CueSemanticTemplate,
+  b as CueSignUp,
+  K as CueSignal,
+  q as CueStorage,
+  w as CueSyncApi,
+  Q as CueTables,
+  V as CueUserSettings,
+  W as DEFAULT_SCHEMA_BASE,
+  X as ENDPOINT_SCHEMA_SUGGESTION_CATALOGS,
+  Y as ENDPOINT_SCHEMA_SUGGESTION_FROM_PROSE,
+  k as EmbeddingBasis,
+  z as NumeralRole,
+  J as Provenance,
+  Z as REQUIRED_ROLES,
+  $ as ResolutionIdentity,
+  ee as SUPPORTED_CURRENCIES,
+  se as SchemaTermKind,
+  ae as configureScanWasm,
+  ue as cueComputed,
+  Ce as deriveIri,
+  re as expandCurie,
+  ie as isCurie,
+  oe as rdfBase,
+  te as resolveIri,
+  ce as resolveRef,
+  ne as schemaGraphIri
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qaecy/cue-sdk",
-  "version": "0.0.50",
+  "version": "0.0.52",
   "type": "module",
   "main": "./index.js",
   "types": "./index.d.ts",