@qaecy/cue-sdk 0.0.26 → 0.0.28

package/index.d.ts

@@ -23,3 +23,5 @@ export type { CueSdkConfig, SsoProvider, PasswordCredentials, SearchRequest, Sea
 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';

package/index.js

@@ -1,23 +1,24 @@
-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-BjbRXItA.js";
+import { C as s, a as u, b as C, c as t, d as i, 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, p, R as E, q as R, r as f, s as d } from "./cue-BR7V1Nem.js";
 export {
   s as Cue,
   u as CueApi,
   C as CueAuth,
-  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,
+  t as CueCache,
+  i as CueExtraction,
+  c as CueGis,
+  o as CuePrivileges,
+  r as CueProfile,
+  l as CueProjectDocuments,
+  n as CueProjectEntities,
+  P as CueProjectSchema,
+  j as CueProjectView,
+  m as CueProjects,
+  S as CueSignal,
+  g as CueStorage,
+  h as CueSyncApi,
+  p as CueTables,
+  E as REQUIRED_ROLES,
   R as configureScanWasm,
   f as cueComputed,
-  E as staleWhileRevalidate
+  d as staleWhileRevalidate
 };

package/lib/api.d.ts

@@ -3,12 +3,15 @@ import { SearchRequest, SearchResponse, ShaclValidationReport, UnitsConsumedDto
 import { CueProjects } from './project';
 import { CueSyncApi } from './sync';
 import { CueTables } from './tables';
+import { CueExtraction } from './extraction';
 export declare class CueApi {
     private readonly _auth;
     private readonly _gatewayUrl;
     readonly projects: CueProjects;
     readonly sync?: CueSyncApi | undefined;
     readonly tables: CueTables;
+    /** Semantic extraction client — call document pages against a SemanticTemplate. */
+    readonly extraction: CueExtraction;
     /** 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/auth.d.ts

@@ -47,6 +47,8 @@ export declare class CueAuth {
     checkSuperAdmin(): Promise<boolean>;
     /** Sign in with a Cue API key. `projectId` is optional — omit it when no project context is available (e.g. admin flows). */
     signInWithApiKey(cueApiKey: string, projectId?: string): Promise<User>;
+    /** Sign in with a Firebase custom token (e.g. minted server-side for MCP/OAuth flows). */
+    signInWithCustomToken(token: string): Promise<User>;
     /** Sign out the current user */
     signOut(): Promise<void>;
     /**

package/lib/documents.d.ts

@@ -1,5 +1,6 @@
 import { CueApi } from './api';
 import { ReadonlySignal } from './signal';
+import { FileType } from 'js/models';
 import { DocumentInfo, ProjectDocumentsData, QueryCache } from './models';
 /**
  * Manages document data for a single project.
@@ -122,6 +123,64 @@ export declare class CueProjectDocuments {
      * Useful for pre-filling path-based query inputs with a realistic example.
      */
     randomFilePath(): Promise<string | null>;
+    /**
+     * Fetches all `qcy:FileContent` documents whose file suffix matches one of
+     * the given extensions (e.g. `'.ifc'`, `'.pdf'`).
+     *
+     * By default returns only `{ iri, uuid }` — pass `includeMetadata: true` to
+     * also get `path`, `suffix`, and `size`. Use the default form when you intend
+     * to lazy-load full details via `requestDocumentData`.
+     *
+     * Suffixes are matched case-insensitively and the leading dot is optional
+     * (both `'ifc'` and `'.ifc'` are accepted).
+     */
+    documentsBySuffix(suffixes: string[], includeMetadata?: false): Promise<Array<{
+        iri: string;
+        uuid: string;
+    }>>;
+    documentsBySuffix(suffixes: string[], includeMetadata: true): Promise<Array<{
+        iri: string;
+        uuid: string;
+        path: string;
+        suffix: string;
+        size: number;
+    }>>;
+    /**
+     * Fetches documents whose file suffix maps to one of the given `FileType`
+     * values (e.g. `FileType.BIM`, `FileType.CAD`).
+     *
+     * Resolves matching suffixes from `fileExtensionsInfo` and delegates to
+     * `documentsBySuffix`. Accepts the same `includeMetadata` flag.
+     */
+    documentsByFileType(fileTypes: FileType[], includeMetadata?: false): Promise<Array<{
+        iri: string;
+        uuid: string;
+    }>>;
+    documentsByFileType(fileTypes: FileType[], includeMetadata: true): Promise<Array<{
+        iri: string;
+        uuid: string;
+        path: string;
+        suffix: string;
+        size: number;
+    }>>;
+    /**
+     * Fetches documents whose MIME type matches one of the given strings
+     * (e.g. `'application/x-step'`, `'application/pdf'`).
+     *
+     * Resolves matching suffixes from `fileExtensionsInfo` and delegates to
+     * `documentsBySuffix`. Accepts the same `includeMetadata` flag.
+     */
+    documentsByMime(mimeTypes: string[], includeMetadata?: false): Promise<Array<{
+        iri: string;
+        uuid: string;
+    }>>;
+    documentsByMime(mimeTypes: string[], includeMetadata: true): Promise<Array<{
+        iri: string;
+        uuid: string;
+        path: string;
+        suffix: string;
+        size: number;
+    }>>;
     /** Executes the document-info SPARQL query for the given UUIDs, merges results
      * into `documentInfoMap`, and returns the newly fetched entries. */
     private _fetchDocumentInfoBatch;

package/lib/entities.d.ts

@@ -106,6 +106,28 @@ export declare class CueProjectEntities {
         iri: string;
         label: string;
     }[]>;
+    /**
+     * Fetches all `qcy:CanonicalEntity` instances that belong to at least one of
+     * the given category IRIs.
+     *
+     * Accepts both full HTTP IRIs and prefixed forms, e.g.:
+     * - `"qcy:Building"`
+     * - `"https://cue.qaecy.com/ontology#Building"`
+     *
+     * By default returns only `{ iri, uuid }` — pass `includeMetadata: true` to
+     * also get `value` and `categories` (all categories, not just the filtered ones).
+     * Use the default form when you intend to lazy-load details via `requestEntityData`.
+     */
+    entitiesByCategory(categoryIris: string[], includeMetadata?: false): Promise<Array<{
+        iri: string;
+        uuid: string;
+    }>>;
+    entitiesByCategory(categoryIris: string[], includeMetadata: true): Promise<Array<{
+        iri: string;
+        uuid: string;
+        value: string;
+        categories: string[];
+    }>>;
     /**
      * Fetches a summary graph of entity category relationships for the project.
      *

package/lib/extraction.d.ts

@@ -0,0 +1,48 @@
+import { CueAuth } from './auth';
+export declare const ENDPOINT_EXTRACTION = "/semantic-extraction/extract";
+export interface ExtractionRequest {
+    /** PNG (or other image) blob of the document page to extract from. */
+    image: Blob;
+    /** SemanticTemplate JSON object. */
+    template: object;
+    /** Project / space ID used by the extraction service. */
+    projectId: string;
+    /** IRI of the pre-selected content category; omit to let the model classify. */
+    category?: string | null;
+    /** Plain text of the page, used as additional context. */
+    text?: string | null;
+    /** Desired RDF serialisation — defaults to `'json-ld'`. */
+    rdfFormat?: 'json-ld' | 'turtle' | 'ntriples' | 'xml';
+}
+export interface ExtractionResponse {
+    /** Parsed JSON-LD document ready for `cue-rdf-graph`. */
+    jsonld: object;
+}
+/**
+ * Client for the Cue semantic-extraction endpoint.
+ *
+ * Exposed as `cue.api.extraction`.
+ *
+ * @example
+ * ```ts
+ * const result = await cue.api.extraction.extract({
+ *   image: pngBlob,
+ *   template: myTemplate,
+ *   projectId: 'my-project',
+ * });
+ * // result.jsonld is a JSON-LD document for cue-rdf-graph
+ * ```
+ */
+export declare class CueExtraction {
+    private readonly _auth;
+    private readonly _gatewayUrl;
+    constructor(_auth: CueAuth, _gatewayUrl: string);
+    /**
+     * Run semantic extraction on a document page image.
+     *
+     * Sends a multipart/form-data POST to `/semantic-extraction/extract`.
+     * Always requests JSON-LD so the result can be displayed directly in
+     * `cue-rdf-graph` without any further parsing.
+     */
+    extract(request: ExtractionRequest): Promise<ExtractionResponse>;
+}

package/node.js

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

package/package.json

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