@qaecy/cue-sdk 0.0.50 → 0.0.53

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 */
@@ -12,10 +12,6 @@ export interface CueEndpoints {
     storageEmulatorHost: string;
     /** Firebase Storage emulator port (emulator mode only, default: 9199) */
     storageEmulatorPort: number;
-    /** Firebase Firestore emulator hostname, no protocol (emulator mode only, default: 'localhost') */
-    firestoreEmulatorHost: string;
-    /** Firebase Firestore emulator port (emulator mode only, default: 8080) */
-    firestoreEmulatorPort: number;
 }
 export interface CueSdkConfig {
     /** Firebase API key for this project. Defaults to the QAECY demo app if omitted. */
@@ -122,11 +118,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 +143,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 +156,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 +183,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 +206,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 +262,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 +929,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 +996,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

@@ -1,12 +1,10 @@
 import { UserInfo } from 'firebase/auth';
-import { FirebaseApp } from 'firebase/app';
 import { APIKeyDoc, APIKeyInfo, FileTypeBreakdownDto, OrgConsumptionReportDto, OrgCreditsDto, OrgMember, OrganizationData, ProfileSSOAccount, TrafficReportDto, UsageReportDto } from './models';
 import { CueAuth } from './auth';
 import { ReadonlySignal } from './signal';
 export declare class CueProfile {
     private readonly _auth;
     private readonly _gatewayUrl;
-    private readonly _functions;
     private readonly _orgCredits;
     /**
      * Reactive view of the last-fetched org credit pool. Updated automatically
@@ -17,7 +15,7 @@ export declare class CueProfile {
      * `effect(() => sig.set(cue.profile.orgCredits.get()))` + `.subscribe(...)`.
      */
     readonly orgCredits: ReadonlySignal<OrgCreditsDto | undefined>;
-    constructor(_auth: CueAuth, app: FirebaseApp, useEmulator: boolean, _gatewayUrl: string);
+    constructor(_auth: CueAuth, _gatewayUrl: string);
     private _url;
     private _fetch;
     /** Whether the current user has an active API key. */
@@ -145,14 +143,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

@@ -1,11 +1,16 @@
-import { FirebaseApp } from 'firebase/app';
 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;
     private readonly _gatewayUrl;
     private readonly _projects;
     /**
@@ -14,7 +19,7 @@ export declare class CueProjects {
      * without every caller having to remember to re-fetch the whole list.
      */
     readonly projects: ReadonlySignal<ProjectData[] | undefined>;
-    constructor(_auth: CueAuth, app: FirebaseApp, useEmulator?: boolean, endpoints?: CueEndpoints);
+    constructor(_auth: CueAuth, endpoints?: CueEndpoints);
     /**
      * Create a new project. The authenticated user is automatically set as admin, syncer, and member.
      * Throws if a project with the given ID already exists.
@@ -31,11 +36,6 @@ export declare class CueProjects {
      * single project look like the user's entire project set.
      */
     private _patchProject;
-    /**
-     * Atomically increments `unitsConsumed` on the top-level `clientSync/{projectId}`
-     * document, creating it if it doesn't exist. Intended for pre-flight checks.
-     */
-    incrementUnitsConsumed(projectId: string, units: number, userId: string): Promise<void>;
     /**
      * Invite a user to a project by email. Returns the invited user's uid.
      * Throws if no account exists yet for that email — the gateway route supports
@@ -67,6 +67,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 }`),