@qaecy/cue-sdk 0.0.14 → 0.0.17

package/index.d.ts

@@ -1,4 +1,8 @@
 export { Cue } from './lib/cue';
+export { CueGis } from './lib/gis';
+export { CueStorage } from './lib/storage';
+export type { StorageBucket } from './lib/storage';
+export type { GisBBox, GisCategoryDescriptor, GisFeature, GisFeaturesMap, FeatureCategory } from './lib/gis';
 export { CueAuth } from './lib/auth';
 export { CueApi } from './lib/api';
 export { CueSyncApi, configureScanWasm } from './lib/sync';
@@ -17,3 +21,5 @@ export { CueCache } from './lib/cache';
 export type { QueryCacheEntry } from './lib/cache';
 export type { CueSdkConfig, SsoProvider, PasswordCredentials, SearchRequest, SearchResponse, SearchSource, SearchOptions, ProjectData, ProjectSettings, CreateProjectOptions, SyncOptions, SyncResult, SyncPreview, ScanOutputRecord, UnitsConsumedDto, OrganizationData, OrgMember, ProfileSSOAccount, APIKeyInfo, APIKeyDoc, ProjectDoc, OrganizationDoc, UserDoc, RDFWritingDoc, ViewDefinition, QueryCache, CategoryDef, RelationshipDef, EntityCoreData, EntityRelationship, EntityRelationships, MapGeometry, EntityDetailedData, ProjectEntitiesData, DocumentInfo, DocumentSummary, ProjectDocumentsData, } from './lib/models';
 export type { AuthStateListener, Unsubscribe } from './lib/auth';
+export { CueTables } from './lib/tables';
+export type { ProjectTable } from './lib/tables';

package/index.js

@@ -1,20 +1,23 @@
-import { C as s, a as u, b as C, c, d as i, e as t, f as o, g as r, h as l, i as n, j as P, k as j, l as m, R as h, m as R, n as S, s as f } from "./cue-DjbCgB69.js";
+import { C as s, a as u, b as C, c as i, d as t, e as c, f as o, g as r, h as l, i as n, j as P, k as j, l as m, m as S, n as g, o as h, R as p, p as R, q as f, s as E } from "./cue-yUoyoy61.js";
 export {
   s as Cue,
   u as CueApi,
   C as CueAuth,
-  c as CueCache,
-  i as CuePrivileges,
-  t as CueProfile,
-  o as CueProjectDocuments,
-  r as CueProjectEntities,
-  l as CueProjectSchema,
-  n as CueProjectView,
-  P as CueProjects,
-  j as CueSignal,
-  m as CueSyncApi,
-  h as REQUIRED_ROLES,
+  i as CueCache,
+  t as CueGis,
+  c as CuePrivileges,
+  o as CueProfile,
+  r as CueProjectDocuments,
+  l as CueProjectEntities,
+  n as CueProjectSchema,
+  P as CueProjectView,
+  j as CueProjects,
+  m as CueSignal,
+  S as CueStorage,
+  g as CueSyncApi,
+  h as CueTables,
+  p as REQUIRED_ROLES,
   R as configureScanWasm,
-  S as cueComputed,
-  f as staleWhileRevalidate
+  f as cueComputed,
+  E as staleWhileRevalidate
 };

package/lib/api.d.ts

@@ -1,12 +1,18 @@
 import { CueAuth } from './auth';
-import { SearchRequest, SearchResponse, UnitsConsumedDto } from './models';
+import { SearchRequest, SearchResponse, ShaclValidationReport, UnitsConsumedDto } from './models';
 import { CueProjects } from './project';
 import { CueSyncApi } from './sync';
+import { CueTables } from './tables';
 export declare class CueApi {
     private readonly _auth;
     private readonly _gatewayUrl;
     readonly projects: CueProjects;
     readonly sync?: CueSyncApi | undefined;
+    readonly tables: CueTables;
+    /** 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. */
+    setLanguage(lang: string): void;
     constructor(_auth: CueAuth, _gatewayUrl: string, projects: CueProjects, sync?: CueSyncApi | undefined);
     /**
      * Returns standard authentication headers for the current user.
@@ -23,5 +29,20 @@ export declare class CueApi {
      * The user must be authenticated before calling this.
      */
     sparql(query: string, projectId: string, graphType?: string): Promise<unknown>;
+    /**
+     * Validate a SHACL shape against the project's triplestore.
+     *
+     * @param shape     - SHACL shapes graph in Turtle syntax.
+     * @param projectId - Project to validate against.
+     * @param options   - `format`: `'json-ld'` (default, structured result) or `'turtle'` (raw string).
+     *                    `verbose`: include server-side timing logs.
+     *
+     * Returns a {@link ShaclValidationReport} for JSON-LD, or a Turtle string.
+     */
+    shacl(shape: string, projectId: string, options?: {
+        format?: 'json-ld' | 'turtle';
+        verbose?: boolean;
+        graphType?: string;
+    }): Promise<ShaclValidationReport | string>;
     getConsumption(projectId: string): Promise<UnitsConsumedDto>;
 }

package/lib/cue.d.ts

@@ -1,11 +1,16 @@
 import { FirebaseApp } from 'firebase/app';
+import { FirebaseStorage } from 'firebase/storage';
 import { CueAuth } from './auth';
+import { CueStorage } from './storage';
 import { CueApi } from './api';
+import { CueGis } from './gis';
 import { CueProjects } from './project';
 import { CueProfile } from './profile';
 import { CuePrivileges } from './privileges';
 import { CueCache } from './cache';
 import { CueProjectView, CueProjectViewOptions } from './project-view';
+import { CueProjectEntities } from './entities';
+import { CueProjectDocuments } from './documents';
 import { CueEndpoints, CueSdkConfig, QueryCache } from './models';
 /**
  * Main entry point for the QAECY SDK (browser-safe).
@@ -23,9 +28,25 @@ export declare class Cue {
     readonly profile: CueProfile;
     readonly privileges: CuePrivileges;
     readonly cache: CueCache;
+    readonly storage: CueStorage;
     protected readonly _app: FirebaseApp;
     protected readonly _endpoints: CueEndpoints;
     protected readonly _isEmulator: boolean;
+    protected _storageRaw: FirebaseStorage;
+    protected _storageProcessed: FirebaseStorage;
+    private _gis;
+    /**
+     * Reactive GIS service. Lazily constructed on first access.
+     *
+     * @example
+     * ```ts
+     * cue.gis.setProjectId('my-project');
+     * cue.gis.onAvailableCategories(cats => ...);
+     * cue.gis.setBbox([west, south, east, north]);
+     * cue.gis.setSelectedCategories(new Set(['cadastre', 'building']));
+     * ```
+     */
+    get gis(): CueGis;
     constructor(config?: CueSdkConfig);
     /**
      * Create a `Cue` instance from an already-initialized Firebase app.
@@ -65,4 +86,46 @@ export declare class Cue {
     createProjectView(projectId: string, opts: Omit<CueProjectViewOptions, 'queryCache'> & {
         queryCache?: QueryCache;
     }): CueProjectView;
+    /**
+     * Creates a `CueProjectEntities` instance for the given project, with the
+     * SDK query cache wired automatically.
+     *
+     * Prefer this over `new CueProjectEntities(cue.api, projectId)` — it avoids
+     * the manual cache setup and keeps the instance bound to the correct API.
+     *
+     * @example
+     * ```ts
+     * const entities = cue.createProjectEntities('my-project');
+     * entities.requestEntityData(['uuid1']);
+     * const info = entities.entityInfoMap.get()['uuid1'];
+     *
+     * // Promise-based (no signal polling needed):
+     * const graph = await entities.buildSummaryGraph('graph');
+     * ```
+     */
+    createProjectEntities(projectId: string, opts?: {
+        rdfBase?: string;
+        graphType?: string;
+        queryCache?: QueryCache;
+    }): CueProjectEntities;
+    /**
+     * Creates a `CueProjectDocuments` instance for the given project, with the
+     * SDK query cache wired automatically.
+     *
+     * Prefer this over `new CueProjectDocuments(cue.api, projectId)` — it avoids
+     * the manual cache setup and keeps the instance bound to the correct API.
+     *
+     * @example
+     * ```ts
+     * const docs = cue.createProjectDocuments('my-project');
+     * await docs.fetchOverview();
+     * const data = await docs.fetchDocumentData(['uuid1', 'uuid2']);
+     * ```
+     */
+    createProjectDocuments(projectId: string, opts?: {
+        language?: string;
+        rdfBase?: string;
+        graphType?: string;
+        queryCache?: QueryCache;
+    }): CueProjectDocuments;
 }

package/lib/documents.d.ts

@@ -39,14 +39,15 @@ export declare class CueProjectDocuments {
     private readonly _graphType?;
     /** Full RDF base URL for this project, e.g. `https://cue.qaecy.com/r/{pid}/` */
     readonly baseURL: string;
-    private _language;
+    /** Tracks the language for which `_documentInfoMap` is currently populated. */
+    private _currentLang;
     private readonly _documentInfoMap;
     private readonly _projectDocumentsData;
     /** Lazily populated per-document detail map. */
     readonly documentInfoMap: ReadonlySignal<Record<string, DocumentInfo>>;
     /** Project-level document overview (grouped counts + sizes). */
     readonly projectDocumentsData: ReadonlySignal<ProjectDocumentsData>;
-    constructor(_api: CueApi, _projectId: string, language: string, 
+    constructor(_api: CueApi, _projectId: string, language?: string, 
     /** Override the RDF resource base URL. Defaults to `https://cue.qaecy.com/r/`. */
     rdfBase?: string, _queryCache?: QueryCache | undefined, _graphType?: string | undefined);
     /**
@@ -72,6 +73,48 @@ export declare class CueProjectDocuments {
      * once the SPARQL response arrives.
      */
     requestDocumentData(uuids: string[]): void;
+    /**
+     * Promise-based alternative to {@link requestDocumentData} for non-reactive contexts.
+     *
+     * Resolves with the `DocumentInfo` entries for every requested UUID once the
+     * SPARQL response arrives. UUIDs already present in the cache are returned
+     * immediately without a network request. The result is also written into
+     * `documentInfoMap` so reactive consumers stay in sync.
+     *
+     * UUIDs not found in the triplestore are omitted from the returned map.
+     *
+     * @example
+     * ```ts
+     * const docs = await cueProjectDocs.fetchDocumentData(['uuid1', 'uuid2']);
+     * console.log(docs['uuid1'].subject);
+     * ```
+     */
+    fetchDocumentData(uuids: string[]): Promise<Record<string, DocumentInfo>>;
+    /**
+     * Returns the alternative representations of the given document UUID.
+     *
+     * Alternative representations are derived artefacts stored under
+     * `qcy:alternativeRepresentation` in the triplestore — for example a
+     * `.fragments` BIM tile derived from an `.ifc` source file.
+     *
+     * The returned `DocumentInfo` entries are also merged into
+     * `documentInfoMap` so reactive consumers stay in sync.
+     *
+     * @example
+     * ```ts
+     * const alts = await docs.fetchAlternativeRepresentations('abc-123');
+     * // alts[0].suffix => '.fragments'
+     * ```
+     */
+    fetchAlternativeRepresentations(uuid: string): Promise<DocumentInfo[]>;
+    /**
+     * Returns a single arbitrary file path from the project's triplestore.
+     * Useful for pre-filling path-based query inputs with a realistic example.
+     */
+    randomFilePath(): Promise<string | null>;
+    /** Executes the document-info SPARQL query for the given UUIDs, merges results
+     * into `documentInfoMap`, and returns the newly fetched entries. */
+    private _fetchDocumentInfoBatch;
     private _fetchDocumentsBySuffix;
     private _buildDocumentsBySuffixQuery;
     private _runDocumentsBySuffixQuery;

package/lib/entities.d.ts

@@ -1,6 +1,6 @@
 import { CueApi } from './api';
 import { ReadonlySignal } from './signal';
-import { EntityDetailedData, EntityRelationships, ProjectEntitiesData, QueryCache } from './models';
+import { EntityDetailedData, EntityRelationships, ProjectEntitiesData, SummaryGraphData, QueryCache } from './models';
 /**
  * Manages entity data for a single project.
  *
@@ -97,6 +97,42 @@ export declare class CueProjectEntities {
      * document service (future `CueProjectDocuments`).
      */
     fetchEntityDocuments(iri: string): Promise<string[]>;
+    /**
+     * Fetches all `qcy:EntityCategory` IRIs and their preferred labels for this
+     * project. Uses `api.language` (default `'en'`);
+     * falls back to an untagged label when no match is found.
+     */
+    contentCategoriesInProject(orderByOccurences?: boolean): Promise<{
+        iri: string;
+        label: string;
+    }[]>;
+    /**
+     * Fetches a summary graph of entity category relationships for the project.
+     *
+     * Each row describes how many times entities of `sourceCat` point to
+     * entities of `targetCat` via a given `predicate`, ordered by descending
+     * occurrence count.
+     *
+     * @param format
+     *   - `undefined` — raw SPARQL JSON result
+     *   - `'graph'`   — structured `{ entities, relations }` with predicates and weights
+     *   - `'md'`      — compact aligned text table
+     *
+     * @example
+     * ```ts
+     * // Structured graph (nodes + edges)
+     * const g = await entities.buildSummaryGraph('graph');
+     * // g.entities  → [{ iri: 'https://…FloorPlanDrawing' }, …]
+     * // g.relations → [{ sourceID, predicate, targetID, weight }, …]
+     *
+     * // Markdown table
+     * const md = await entities.buildSummaryGraph('md');
+     * // qcy:FloorPlanDrawing -> qcy:includesBuildingEntity -> qcy:BuildingZone  (5652)
+     * ```
+     */
+    buildSummaryGraph(format: 'graph'): Promise<SummaryGraphData>;
+    buildSummaryGraph(format: 'md'): Promise<string>;
+    buildSummaryGraph(format?: undefined): Promise<unknown>;
     private _computeEntityInfoMap;
     private _fetchOutgoingRelationships;
     private _fetchIncomingRelationships;

package/lib/gis.d.ts

@@ -0,0 +1,89 @@
+import { BBox, FeatureCategory, FeatureCategoryDescriptor, GisFeature } from 'js/cue-gis';
+export type GisBBox = BBox;
+export type { FeatureCategory };
+export type GisCategoryDescriptor = FeatureCategoryDescriptor;
+export type { GisFeature };
+export type GisFeaturesMap = Map<FeatureCategory, GisFeature[]>;
+type Listener<T> = (value: T) => void;
+/**
+ * Reactive GIS service, exposed lazily as `cue.gis`.
+ *
+ * Push-based: consumers set the active bbox and selected categories; results are
+ * delivered via subscription callbacks.  All debouncing and request cancellation
+ * are handled internally.
+ *
+ * @example
+ * ```ts
+ * cue.gis.setProjectId('my-project-id');
+ * cue.gis.onAvailableCategories(cats => console.log(cats));
+ *
+ * // On every map pan/zoom:
+ * cue.gis.setBbox([west, south, east, north]);
+ *
+ * // When the user toggles a category:
+ * cue.gis.setSelectedCategories(new Set(['cadastre', 'building']));
+ *
+ * // Cleanup:
+ * cue.gis.destroy();
+ * ```
+ */
+export declare class CueGis {
+    private readonly _getAuthHeaders;
+    private readonly _gatewayUrl;
+    private _bbox;
+    private _projectId;
+    private _selectedCategories;
+    private _queryToken;
+    private _categoryTokens;
+    private _debounceTimer;
+    private _availableCategories;
+    private _features;
+    private readonly _catListeners;
+    private readonly _featListeners;
+    private readonly _loadListeners;
+    private _gatewayCache;
+    private _gatewayProjectId;
+    /** @internal — construct via `cue.gis`, not directly. */
+    constructor(_getAuthHeaders: () => Promise<Record<string, string>>, _gatewayUrl: string);
+    /**
+     * Update the current map viewport.
+     * Triggers a debounced query for available categories and reloads selected ones.
+     */
+    setBbox(bbox: BBox): void;
+    /**
+     * Set or clear the active project.
+     * Rebuilds the authenticated adapter so subsequent requests carry the new project header.
+     */
+    setProjectId(projectId: string | null): void;
+    /**
+     * Replace the full set of selected categories.
+     * Newly added categories begin loading immediately; removed categories are cleared.
+     */
+    setSelectedCategories(categories: Set<FeatureCategory>): void;
+    /**
+     * Subscribe to available-category updates.
+     * Replays the current value immediately, then fires on every bbox change.
+     * @returns An unsubscribe function.
+     */
+    onAvailableCategories(cb: Listener<GisCategoryDescriptor[]>): () => void;
+    /**
+     * Subscribe to the feature map (category → GisFeature[]).
+     * Replays the current value immediately, then fires whenever features change.
+     * @returns An unsubscribe function.
+     */
+    onFeaturesChange(cb: Listener<GisFeaturesMap>): () => void;
+    /**
+     * Subscribe to the global loading state.
+     * Fires `true` while the category list is being queried, `false` when done.
+     * @returns An unsubscribe function.
+     */
+    onLoadingChange(cb: Listener<boolean>): () => void;
+    /** Cancel all pending requests and clear all listeners. */
+    destroy(): void;
+    private _scheduleDebouncedQuery;
+    private _getGateway;
+    private _queryLayers;
+    private _loadCategory;
+    private _emitFeatures;
+    private _emitLoading;
+}

package/lib/models.d.ts

@@ -152,6 +152,34 @@ export interface UnitsConsumedDto {
     unitsAvailable: number;
     unitsConsumed: number;
 }
+export interface ShaclViolation {
+    '@type': string;
+    'sh:focusNode': {
+        '@id': string;
+    } | {
+        '@value': string;
+    };
+    'sh:resultPath'?: {
+        '@id': string;
+    };
+    'sh:resultSeverity': {
+        '@id': string;
+    };
+    'sh:sourceConstraintComponent': {
+        '@id': string;
+    };
+    'sh:sourceShape'?: {
+        '@id': string;
+    };
+    'sh:resultMessage': string;
+    'sh:value'?: string;
+}
+export interface ShaclValidationReport {
+    '@context': Record<string, string>;
+    '@type': string;
+    'sh:conforms': boolean;
+    'sh:result'?: ShaclViolation[];
+}
 export interface SyncPreview {
     /** Per-extension cost breakdown for files not yet synced */
     costRecords: ScanOutputRecord[];
@@ -320,6 +348,22 @@ export interface ProjectEntitiesData {
         targetID: string;
     }>;
 }
+/**
+ * Structured summary graph returned by `buildSummaryGraph('graph')`.
+ * Nodes are deduplicated category IRIs; edges carry the predicate and
+ * occurrence count from the summary query.
+ */
+export interface SummaryGraphData {
+    entities: Array<{
+        iri: string;
+    }>;
+    relations: Array<{
+        sourceID: string;
+        predicate: string;
+        targetID: string;
+        weight: number;
+    }>;
+}
 /** Core metadata for a single document (FileContent node). */
 export interface DocumentInfo {
     id: string;

package/lib/project-view.d.ts

@@ -42,6 +42,11 @@ export declare class CueProjectView {
     readonly availableEntityCategories: ReadonlySignal<CategoryDef[]>;
     /** Available entity relationship types. Auto-fetched on init. */
     readonly availableEntityRelationships: ReadonlySignal<RelationshipDef[]>;
+    /**
+     * Resolves when the initial schema load has completed. Await before reading
+     * schema signal values imperatively.
+     */
+    readonly schemaReady: Promise<void>;
     /** Merged per-entity detail map. Populated lazily via `requestEntityData()` etc. */
     readonly entityInfoMap: ReadonlySignal<Record<string, EntityDetailedData>>;
     /** Project-level entity co-occurrence graph. Fetched once on init. */

package/lib/schema.d.ts

@@ -31,7 +31,7 @@ export declare class CueProjectSchema {
     private readonly _queryCache?;
     private readonly _graphType?;
     private readonly _cache;
-    private readonly _language;
+    private _currentLang;
     private readonly _contentCategories;
     private readonly _entityCategories;
     private readonly _relationships;
@@ -41,6 +41,11 @@ export declare class CueProjectSchema {
     readonly availableEntityCategories: ReadonlySignal<CategoryDef[]>;
     /** Currently active entity relationship types for the selected language. */
     readonly availableEntityRelationships: ReadonlySignal<RelationshipDef[]>;
+    /**
+     * Resolves when the initial schema load for the constructor language has
+     * completed (or failed). Await this before reading signal values imperatively.
+     */
+    readonly ready: Promise<void>;
     constructor(_api: CueApi, _projectId: string, language: string, _queryCache?: QueryCache | undefined, _graphType?: string | undefined);
     /** Returns the currently active language. */
     get language(): string;

package/lib/storage.d.ts

@@ -0,0 +1,26 @@
+import { FirebaseStorage } from 'firebase/storage';
+export type StorageBucket = 'raw' | 'processed';
+/**
+ * Provides document download URL resolution against the Cue Firebase Storage buckets.
+ *
+ * @example
+ * ```ts
+ * const url = await cue.storage.getDownloadUrl('my-project', 'abc123', '.pdf');
+ * ```
+ */
+export declare class CueStorage {
+    private readonly _storageRaw;
+    private readonly _storageProcessed;
+    constructor(_storageRaw: FirebaseStorage, _storageProcessed: FirebaseStorage);
+    /**
+     * Returns a Firebase authenticated download URL for a document stored in Cue.
+     *
+     * The storage path is `{projectId}/{uuid}{suffix}`, e.g. `my-project/abc-123.pdf`.
+     *
+     * @param projectId - The Cue project (space) ID.
+     * @param uuid - The document UUID.
+     * @param suffix - File suffix including the leading dot, e.g. `'.pdf'`, `'.ifc'`.
+     * @param bucket - `'raw'` (default, original uploads) or `'processed'` (derived artefacts).
+     */
+    getDownloadUrl(projectId: string, uuid: string, suffix: string, bucket?: StorageBucket): Promise<string>;
+}

package/lib/tables.d.ts

@@ -0,0 +1,14 @@
+import { CueAuth } from './auth';
+export interface ProjectTable {
+    id: string;
+    title: string;
+    columnDefs: Record<string, unknown>[];
+    rowDef: string;
+}
+export declare class CueTables {
+    private readonly _auth;
+    private readonly _gatewayUrl;
+    constructor(_auth: CueAuth, _gatewayUrl: string);
+    listTables(projectId: string): Promise<ProjectTable[]>;
+    saveTables(tables: ProjectTable[] | unknown[], projectId: string): Promise<void>;
+}

package/node.js

@@ -1,55 +1,58 @@
-import { C as _, B as E, o as l, p as S, q as m, r as P, t as d, l as U, u as B, a as R } from "./cue-DjbCgB69.js";
-import { b as y, c as I, d as L, e as O, f as x, g as D, h as H, i as N, j as W, k as v, R as k, m as q, n as G, s as Q } from "./cue-DjbCgB69.js";
-import { getStorage as s, connectStorageEmulator as o } from "firebase/storage";
+import { C as h, B as l, r as _, t as S, u as E, n as m, v as P, a as d } from "./cue-yUoyoy61.js";
+import { b as j, c as y, d as I, e as K, f as L, g as v, h as x, i as H, j as N, k as O, l as D, m as G, o as W, R as k, p as q, q as Q, s as V } from "./cue-yUoyoy61.js";
+import { getStorage as e, connectStorageEmulator as b } from "firebase/storage";
 import "firebase/firestore";
-class w extends _ {
-  constructor(t) {
-    super(t);
+class A extends h {
+  constructor(s) {
+    super(s);
   }
-  _buildApi(t) {
-    const p = s(this._app, E), C = s(this._app, l), i = s(this._app, S), g = s(this._app, m), r = s(this._app, P), n = s(this._app, d);
+  _buildApi(s) {
+    const r = e(this._app, l), i = e(this._app, _), n = this._storageRaw, u = e(this._app, S), c = this._storageProcessed, t = e(this._app, E);
     if (this._isEmulator) {
-      const e = this._endpoints.storageEmulatorHost, a = this._endpoints.storageEmulatorPort;
-      o(i, e, a), o(r, e, a), o(n, e, a);
+      const p = this._endpoints.storageEmulatorHost, g = this._endpoints.storageEmulatorPort;
+      b(t, p, g);
     }
-    const h = new B({
-      storageChatSessions: p,
-      storageLogs: C,
-      storageRaw: i,
-      storagePersistence: g,
-      storageProcessed: r,
-      storagePublic: n
-    }), c = new U(
+    const C = new P({
+      storageChatSessions: r,
+      storageLogs: i,
+      storageRaw: n,
+      storagePersistence: u,
+      storageProcessed: c,
+      storagePublic: t
+    }), a = new m(
       this.auth,
-      t,
-      h,
+      s,
+      C,
       this._endpoints.gatewayUrl
-    ), u = new R(
+    ), o = new d(
       this.auth,
       this._endpoints.gatewayUrl,
-      t,
-      c
+      s,
+      a
     );
-    return c._bindApi(u), u;
+    return a._bindApi(o), o;
   }
 }
 export {
-  _ as Cue,
-  R as CueApi,
-  y as CueAuth,
-  I as CueCache,
-  w as CueNode,
-  L as CuePrivileges,
-  O as CueProfile,
-  x as CueProjectDocuments,
-  D as CueProjectEntities,
+  h as Cue,
+  d as CueApi,
+  j as CueAuth,
+  y as CueCache,
+  I as CueGis,
+  A as CueNode,
+  K as CuePrivileges,
+  L as CueProfile,
+  v as CueProjectDocuments,
+  x as CueProjectEntities,
   H as CueProjectSchema,
   N as CueProjectView,
-  W as CueProjects,
-  v as CueSignal,
-  U as CueSyncApi,
+  O as CueProjects,
+  D as CueSignal,
+  G as CueStorage,
+  m as CueSyncApi,
+  W as CueTables,
   k as REQUIRED_ROLES,
   q as configureScanWasm,
-  G as cueComputed,
-  Q as staleWhileRevalidate
+  Q as cueComputed,
+  V as staleWhileRevalidate
 };

package/package.json

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

package/variables.d.ts

@@ -30,8 +30,10 @@ export declare const ENDPOINT_CREATE_PROJECT = "/commands/admin/project";
 export declare const ENDPOINT_SEARCH = "/assistant/search";
 export declare const ENDPOINT_FUSEKI_QUERY = "/triplestore/query";
 export declare const ENDPOINT_FUSEKI_UPDATE = "/triplestore/update";
+export declare const ENDPOINT_FUSEKI_SHACL = "/triplestore/shacl";
 export declare const ENDPOINT_QLEVER_QUERY = "/qlever-server/qlever/query";
 export declare const ENDPOINT_QLEVER_UPDATE = "/qlever-server/qlever/update";
+export declare const ENDPOINT_QLEVER_SHACL = "/qlever-server/qlever/shacl";
 export declare const ENDPOINT_FSS_BATCH = "/commands/file-system-structure/batch";
 export declare const MICROSOFT_PROVIDER_ID = "microsoft.com";
 export declare const SUPERADMIN_ROLE = "superadmin";