@qaecy/cue-sdk 0.0.50 → 0.0.53

package/lib/entities.d.ts

@@ -1,6 +1,6 @@
 import { CueApi } from './api';
 import { ReadonlySignal } from './signal';
-import { EntityDetailedData, EntityRelationships, ProjectEntitiesData, SummaryGraphData } from './models';
+import { EntityAtExpressId, EntityDetailedData, EntityModelLocation, EntityRelationships, ModelExpressIds, ProjectEntitiesData, PrototypeCategoryCount, PrototypeCategoryExpressIds, PrototypeInstance, PrototypeProperty, PrototypeSummary, SummaryGraphData } from './models';
 /**
  * Manages entity data for a single project.
  *
@@ -148,6 +148,118 @@ export declare class CueProjectEntities {
         value: string;
         categories: string[];
     }>>;
+    /**
+     * Fetches every entity category that has at least one `qcy:EntityPrototype`,
+     * with the number of prototypes in it, most populous first.
+     *
+     * Labels use `api.language` (default `'en'`), falling back to an untagged
+     * `skos:prefLabel` and then to the IRI fragment.
+     */
+    prototypeCategories(): Promise<PrototypeCategoryCount[]>;
+    /**
+     * Fetches the prototypes belonging to one category, most-inherited first.
+     *
+     * Accepts both a full HTTP IRI and a prefixed form (`qcy-e:Door`).
+     */
+    prototypesByCategory(categoryIri: string): Promise<PrototypeSummary[]>;
+    /**
+     * Fetches the `qcy:Property` nodes hanging off one entity, grouped in the
+     * result order by IFC property set.
+     *
+     * Works for any entity, not just a prototype — an occurrence carries the
+     * properties that differ from what it inherits.
+     */
+    prototypeProperties(entityIri: string): Promise<PrototypeProperty[]>;
+    /**
+     * Fetches a page of the entities that inherit from one prototype.
+     *
+     * Paginated because a single type object can have thousands of occurrences.
+     * The total is already known from `prototypesByCategory`'s `instanceCount`,
+     * so there's no separate count query here.
+     */
+    prototypeInstances(prototypeIri: string, opts?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<PrototypeInstance[]>;
+    /**
+     * Resolves entity IRIs to their express IDs inside the models they came from.
+     *
+     * Accepts both `qcy:EntityMention` IRIs (what the prototype browser lists) and
+     * `qcy:CanonicalEntity` IRIs — for the latter the query hops the mentions that
+     * `qcy:resolvesTo` them, since selectors only ever hang off mentions. Pass
+     * `viaMentions: false` to skip that hop when the caller knows it holds mentions.
+     *
+     * One entity can resolve to several rows: a federated project mentions the same
+     * entity from more than one model, and each model has its own express ID.
+     *
+     * Resolve `modelUuid` to a loadable file with `CueProjectDocuments`
+     * (`fetchDocumentDataSimple`) and the storage download URL.
+     *
+     * @example
+     * ```ts
+     * const hits = await entities.entityExpressIds([instance.iri]);
+     * // → [{ requestedIri, mentionIri, modelIri, modelUuid, expressId: 1234 }]
+     * ```
+     */
+    entityExpressIds(entityIris: string[], opts?: {
+        viaMentions?: boolean;
+    }): Promise<EntityModelLocation[]>;
+    /**
+     * Resolves every occurrence of one prototype to its express ID, grouped by the
+     * model it lives in — the shape a viewer needs to load a model and highlight
+     * all of that type's instances at once. Models with the most occurrences come
+     * first.
+     *
+     * A prototype is an IFC type object and carries no selector itself, so this
+     * traverses `qcy:inheritsFrom` to the occurrences and reads theirs. Passing a
+     * prototype IRI to `entityExpressIds` returns nothing for that reason.
+     *
+     * Unpaginated: a type object with thousands of occurrences yields thousands of
+     * integers, which is still a small payload and has to be complete for the
+     * viewer to highlight them all.
+     *
+     * @example
+     * ```ts
+     * const groups = await entities.prototypeExpressIds(prototype.iri);
+     * // → [{ modelIri, modelUuid, expressIds: [12, 48, 91, …] }]
+     * ```
+     */
+    prototypeExpressIds(prototypeIri: string): Promise<ModelExpressIds[]>;
+    /**
+     * The entity one express ID stands for inside one model, plus the prototype
+     * and category to browse it by — the reverse of `entityExpressIds`, for
+     * turning a click in a model viewer back into a graph selection.
+     *
+     * `modelIri` is the `qcy:FileContent` IRI, the same `modelIri` the other
+     * selector methods return; a viewer usually holds only the UUID, so keep the
+     * mapping the occurrence query already handed you.
+     *
+     * @example
+     * ```ts
+     * const hit = await entities.entityAtExpressId(modelIri, 1234);
+     * // → { entityIri, value, prototypeIri, categoryIri }
+     * ```
+     */
+    entityAtExpressId(modelIri: string, expressId: number): Promise<EntityAtExpressId | undefined>;
+    /**
+     * Every occurrence of every prototype in one entity category, grouped by
+     * prototype and model — what a viewer needs to colour a whole category, one
+     * colour per prototype, without a query per prototype.
+     *
+     * Same traversal as `prototypeExpressIds`, with the prototype left unbound and
+     * constrained by `qcy:hasEntityCategory` the way `prototypesByCategory` does,
+     * so a compact category IRI is expanded first.
+     *
+     * Unpaginated, and a category is a good deal larger than a single prototype:
+     * expect tens of thousands of integers for a real project.
+     *
+     * @example
+     * ```ts
+     * const groups = await entities.categoryExpressIds('beo:Wall');
+     * // → [{ prototypeIri, modelIri, modelUuid, expressIds: [12, 48, …] }]
+     * ```
+     */
+    categoryExpressIds(categoryIri: string): Promise<PrototypeCategoryExpressIds[]>;
     /**
      * Fetches a summary graph of entity category relationships for the project.
      *
@@ -165,6 +277,13 @@ export declare class CueProjectEntities {
      *   the source or target category equals this IRI are returned — i.e. the
      *   one-hop neighbourhood of that category.
      *
+     * @param namedGraph  Optional named-graph IRI to scope the summary to (e.g.
+     *   one data source's own graph) instead of the whole project. Bypasses the
+     *   QLever materialized view (which is project-wide and can't be scoped) and
+     *   skips the project-wide category-count enrichment on `format: 'graph'`
+     *   entities — a project-wide weight next to a single scoped graph's
+     *   relations would be misleading.
+     *
      * @example
      * ```ts
      * // Structured graph (nodes + edges)
@@ -175,14 +294,27 @@ export declare class CueProjectEntities {
      * // Neighbourhood of a single category (prefixed IRI)
      * const g2 = await entities.buildSummaryGraph('graph', 'qcy:Building');
      *
+     * // Scoped to one data source's own named graph
+     * const g3 = await entities.buildSummaryGraph('graph', undefined, 'https://cue.qaecy.com/r/p1/datasource/d1');
+     *
      * // Markdown table
      * const md = await entities.buildSummaryGraph('md');
-     * // qcy:FloorPlanDrawing -> qcy:includesBuildingEntity -> qcy:BuildingZone  (5652)
+     * // qcy:FloorPlanDrawing -> includesBuildingEntity -> qcy:BuildingZone  (5652)
      * ```
      */
-    buildSummaryGraph(format: 'graph', entityIRI?: string): Promise<SummaryGraphData>;
-    buildSummaryGraph(format: 'md', entityIRI?: string): Promise<string>;
-    buildSummaryGraph(format?: undefined, entityIRI?: string): Promise<unknown>;
+    buildSummaryGraph(format: 'graph', entityIRI?: string, namedGraph?: string): Promise<SummaryGraphData>;
+    buildSummaryGraph(format: 'md', entityIRI?: string, namedGraph?: string): Promise<string>;
+    buildSummaryGraph(format?: undefined, entityIRI?: string, namedGraph?: string): Promise<unknown>;
+    /**
+     * Turns one selector binding into a location, dropping rows whose express ID
+     * is not a number.
+     */
+    private _toModelLocation;
+    /**
+     * Express IDs are written as plain string literals, so a non-numeric value is
+     * possible in principle — dropping such a row beats handing a viewer `NaN`.
+     */
+    private _parseExpressId;
     /**
      * Fetches the category-summary rows. On QLever the pre-computed
      * `entity-summary` materialized view is tried first; if it yields no rows we

package/lib/extraction.d.ts

@@ -1,10 +1,11 @@
+import { ProjectSchema } from '../../models/src/index';
 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;
+    /** The `ProjectSchema` to extract with, as a JSON object. */
+    projectSchema: ProjectSchema;
     /** Project / space ID used by the extraction service. */
     projectId: string;
     /** IRI of the pre-selected content category; omit to let the model classify. */
@@ -27,7 +28,7 @@ export interface ExtractionResponse {
  * ```ts
  * const result = await cue.api.extraction.extract({
  *   image: pngBlob,
- *   template: myTemplate,
+ *   projectSchema: mySchema,
  *   projectId: 'my-project',
  * });
  * // result.jsonld is a JSON-LD document for cue-rdf-graph

package/lib/gis.d.ts

@@ -1,4 +1,4 @@
-import { BBox, FeatureCategory, FeatureCategoryDescriptor, GisFeature } from 'js/cue-gis';
+import { BBox, FeatureCategory, FeatureCategoryDescriptor, GisFeature } from '../../../cue-gis/src/index.ts';
 export type GisBBox = BBox;
 export type { FeatureCategory };
 export type GisCategoryDescriptor = FeatureCategoryDescriptor;

package/lib/index-api.d.ts

@@ -1,5 +1,23 @@
 import { CueAuth } from './auth';
-import { AvailableFiltersResponse, IndexAppliedFilters, IndexSearchRequest, IndexSearchResponse } from './models';
+import { AvailableFiltersResponse, IndexAppliedFilters, IndexSearchRequest, IndexSearchResponse, QleverStats } from './models';
+interface RebuildProgress {
+    status: 'in-progress' | 'finished' | 'error';
+    message: string;
+    success?: boolean;
+}
+export interface MigrateAllResult {
+    projectId: string;
+    outcome: 'migrated' | 'skipped' | 'failed';
+    message: string;
+}
+export interface MigrateAllProgress extends RebuildProgress {
+    summary?: {
+        migrated: number;
+        skipped: number;
+        failed: number;
+    };
+    results?: MigrateAllResult[];
+}
 export declare class CueIndexApi {
     private readonly _auth;
     private readonly _gatewayUrl;
@@ -29,13 +47,52 @@ export declare class CueIndexApi {
      */
     rebuild(projectId: string, onProgress?: (message: string) => void): Promise<string>;
     /**
-     * Recomputes QLever stats (document count, materialized views, index size)
-     * from the index and persists the result, bypassing the normal cache TTL.
-     * Super-admin only. Resolves with a summary message.
+     * Upgrades the project's QLever index to the currently-deployed CLI's index
+     * format (see `QleverStats.qleverVersion` vs. `currentQleverVersion`).
+     * Super-admin only. Streams NDJSON progress lines from the backend, same
+     * contract as `rebuild()` above; a no-op if the index already matches.
+     */
+    migrate(projectId: string, onProgress?: (message: string) => void): Promise<string>;
+    /**
+     * Upgrades every project's QLever index to the currently-deployed CLI's
+     * index format in one call — same backend as `migrate()`, but omits
+     * `projectId` from the request body so the graph engine loops over every
+     * project on the volume itself. Super-admin only.
+     *
+     * `anyProjectId` is only there to satisfy the gateway's `x-project-id`
+     * header requirement (any project the caller can see works — the backend
+     * ignores it for scoping and migrates everything regardless). Streams
+     * NDJSON progress lines like `migrate()`; the final line additionally
+     * carries `summary` (migrated/skipped/failed counts) and `results` (one
+     * entry per project). Only throws on a hard failure of the operation
+     * itself — a project failing to migrate is reported in `results`, not
+     * thrown.
+     */
+    migrateAll(anyProjectId: string, onProgress?: (message: string) => void, force?: boolean): Promise<MigrateAllProgress>;
+    /**
+     * This project's combined graph+fts+vector+ledger stats, straight off
+     * `databases-cue` — every project member can call this (unlike `refreshStats`
+     * below), since it only reads.
+     */
+    stats(projectId: string): Promise<QleverStats>;
+    /**
+     * Recomputes the graph engine's stats aggregate (document count, index size,
+     * materialized views — FTS and vector always answer live, so there is
+     * nothing to recompute for them) and persists the result, bypassing the
+     * normal cache TTL. Super-admin only. Resolves with a summary message.
      *
      * Pass `projectId` to refresh that project alone — the usual case, and much
      * cheaper. Omit it to re-scan EVERY project on the volume, which costs several
      * SPARQL queries per index and can run for minutes.
      */
     refreshStats(projectId?: string): Promise<string>;
+    /**
+     * Restores every idled engine's data from cloud storage — `databases-cue`'s
+     * `/warm-up`, the same restore a query triggers automatically on a miss, run
+     * explicitly so a user can bring a project back without just querying it and
+     * hoping. Every project member can call this: it only restores data the
+     * project already owns. Resolves with a status message.
+     */
+    warmUp(projectId: string): Promise<string>;
 }
+export {};

package/lib/llm-tools.d.ts

@@ -1,8 +1,16 @@
 import { CueAuth } from './auth';
+import { ProjectSchema } from '../../models/src/index';
 export declare const ENDPOINT_WRANGLING_SCHEMA_GENERATE = "/llm-tools/wrangling-schema/generate";
 export declare const ENDPOINT_WRANGLING_SCHEMA_REFINE = "/llm-tools/wrangling-schema/refine";
 export declare const ENDPOINT_ENTITY_CATEGORY_SUGGEST = "/llm-tools/entity-category-suggestion/suggest";
 export declare const ENDPOINT_ENTITY_CATEGORY_SUGGEST_BATCH = "/llm-tools/entity-category-suggestion/suggest-batch";
+export declare const ENDPOINT_SCHEMA_SUGGESTION_FROM_PROSE = "/llm-tools/schema-suggestion/from-prose";
+export declare const ENDPOINT_SCHEMA_SUGGESTION_FROM_IMAGES = "/llm-tools/schema-suggestion/from-images";
+export declare const ENDPOINT_SCHEMA_SUGGESTION_PARSE_CODING_SCHEME = "/llm-tools/schema-suggestion/parse-coding-scheme";
+export declare const ENDPOINT_SCHEMA_SUGGESTION_FROM_CODING_SCHEME = "/llm-tools/schema-suggestion/from-coding-scheme";
+export declare const ENDPOINT_SCHEMA_SUGGESTION_FROM_COLUMNS = "/llm-tools/schema-suggestion/from-columns";
+export declare const ENDPOINT_SCHEMA_SUGGESTION_PROMPT = "/llm-tools/schema-suggestion/prompt";
+export declare const ENDPOINT_SCHEMA_SUGGESTION_TRANSLATE = "/llm-tools/schema-suggestion/translate";
 export interface GenerateWranglingSchemaRequest {
     /** Plain-language instruction for how the sheet should be reshaped. */
     prompt: string;
@@ -60,6 +68,12 @@ export interface SuggestEntityCategoryRequest {
     kind: 'category' | 'relationship';
     /** Every already-existing entity category (or relationship, matching `kind`) in the project. */
     existingCategories: ExistingCategoryForSuggestion[];
+    /**
+     * The languages the project works in. The candidate may be typed in any language; the term
+     * comes back English under `en` plus one entry per language asked for, with the candidate's
+     * own wording kept under the language it was written in. `en` is always implied.
+     */
+    languages?: string[];
     /** Project the request is scoped to. */
     projectId: string;
 }
@@ -70,14 +84,25 @@ export interface SuggestEntityCategoryMatch {
     reasoning: string;
 }
 export interface SuggestEntityCategorySuggestion {
+    /** The English label — `labels['en']`, kept flat for callers that read one string. */
     label: string;
+    /** The English definition — `definitions['en']`. */
     definition: string;
+    /**
+     * The label per language: English under `en`, one entry per language the project asked for,
+     * and the candidate's own wording under the language it was written in. These become the
+     * term's `skos:prefLabel`s, so a German project keeps `Fachgebiet` beside `Discipline`.
+     */
+    labels: Record<string, string>;
+    definitions: Record<string, string>;
     /** IRI of the existing category/relationship this new one should nest under, if any. */
     parentIri?: string;
     reasoning: string;
 }
 export interface SuggestEntityCategoryResponse {
     decision: 'match' | 'new';
+    /** The language the candidate turned out to be written in, when the model could tell. */
+    detectedLanguage?: string;
     match?: SuggestEntityCategoryMatch;
     suggestion?: SuggestEntityCategorySuggestion;
 }
@@ -98,13 +123,205 @@ export interface SuggestEntityCategoryBatchRequest {
     columns: ColumnToSuggest[];
     /** Every already-existing entity category in the project. */
     existingCategories: ExistingCategoryForSuggestion[];
+    /** As on the single-candidate request: the languages every proposed term comes back in. */
+    languages?: string[];
     /** Project the request is scoped to. */
     projectId: string;
 }
 export interface SuggestEntityCategoryBatchResponse {
     /** One result per given column, in the same order. */
     results: ColumnCategorySuggestionResult[];
+    /** The language the column headings turned out to be written in, when the model could tell. */
+    detectedLanguage?: string;
+}
+export interface SuggestFromProseRequest {
+    /** Project the request is scoped to. */
+    projectId: string;
+    /** Free-text description of the schema to build (or extend). */
+    prose: string;
+    /** The schema to extend, if one already exists. */
+    current?: ProjectSchema;
+    /** BCP-47 tags a proposed term is translated into. Pivot (`en`) always implied. */
+    languages?: string[];
+}
+export interface SuggestFromProseResponse {
+    schema: ProjectSchema;
+    notes?: string[];
+}
+export interface SuggestFromImagesRequest {
+    /** Project the request is scoped to. */
+    projectId: string;
+    /** Base64-encoded PNG bytes (no `data:` URL prefix), a handful of example-document pages. */
+    images: string[];
+    /** The schema to extend, if one already exists. */
+    current?: ProjectSchema;
+    /** BCP-47 tags a proposed term is translated into. Pivot (`en`) always implied. */
+    languages?: string[];
+}
+export type SuggestFromImagesResponse = SuggestFromProseResponse;
+export interface ParseCodingSchemeRequest {
+    /** Project the request is scoped to. */
+    projectId: string;
+    /** Which field position within the code this segment occupies. */
+    position: number;
+    /** The label the person gave this segment. */
+    label: string;
+    /** The raw text (e.g. a legend or table) describing the segment's codes. */
+    text: string;
+    /**
+     * The languages the project works in; every code's gloss comes back in each of them. The
+     * legend's own language is filed on top whether or not it is one of these — see
+     * `detectedLanguage` on the response.
+     */
+    languages?: string[];
+}
+/**
+ * One candidate code parsed out of a coding scheme's legend text.
+ *
+ * `meaning` is the legend's own wording, untranslated — it is what the documents say. `labels`
+ * carries the same gloss per language, `en` included, once the text has been through
+ * `parseCodingScheme`.
+ */
+export interface CodingSchemeOption {
+    code: string;
+    meaning?: string;
+    labels?: Record<string, string>;
+}
+export interface ParseCodingSchemeResponse {
+    options: CodingSchemeOption[];
+    /**
+     * The language the legend turned out to be written in, as a two-letter code — detected rather
+     * than declared, since a pasted legend carries no language field. Stamp it on the scheme:
+     * `from-coding-scheme` uses it to decide which language the field labels are kept in.
+     */
+    detectedLanguage?: string;
 }
+/**
+ * One positional field of a coding scheme as the wizard parses it — *before*
+ * it becomes a category. Distinct from `js/models`' `CodingSchemeField`,
+ * which is the same field *after*: this one carries the raw candidate codes
+ * (`options`), not yet a resolved category key.
+ */
+export interface RawCodingSchemeField {
+    position: number;
+    label: string;
+    description?: string;
+    options: CodingSchemeOption[];
+    pattern?: string;
+    labels?: Record<string, string>;
+}
+/** The wizard's own coding-scheme shape, ahead of `suggestFromCodingScheme` resolving it into categories. */
+export interface RawCodingScheme {
+    name?: string;
+    /**
+     * Overrides the whole-code category's label, which otherwise defaults to `name` (e.g. a scheme
+     * named "Cuneco" gets a category labelled "Cuneco Code"). Set when the standard's own short code
+     * differs from its full name. Also feeds the key, unless `key` is set too.
+     */
+    code?: string;
+    /** Overrides the whole-code category's key outright, bypassing the `ClassificationCode_<slug>` derivation entirely. */
+    key?: string;
+    language?: string;
+    samples: string[];
+    separator: string;
+    fields: RawCodingSchemeField[];
+}
+export interface SuggestFromCodingSchemeRequest {
+    /** Project the request is scoped to. */
+    projectId: string;
+    scheme: RawCodingScheme;
+    /** The schema to extend, if one already exists. */
+    current?: ProjectSchema;
+    /**
+     * The languages every proposed category's labels come back in; falls back to `current`'s. The
+     * scheme's own language (`scheme.language`, else detected) is filed on top of these, so a
+     * German scheme keeps `Fachgebiet` whether or not the project declared German.
+     */
+    languages?: string[];
+}
+export interface SuggestFromCodingSchemeResponse {
+    schema: ProjectSchema;
+    notes?: string[];
+}
+/**
+ * One column of a document register as the model sees it: a heading and three counts.
+ *
+ * No values — those travel as whole rows (`SuggestFromColumnsRequest.rows`), because a
+ * register's columns are only legible together. What the counts say is the part no example can:
+ * `distinct` separates a five-value status column from a five-hundred-value taxonomy level
+ * whatever the rows happen to show.
+ */
+export interface ColumnCounts {
+    column: string;
+    /** Rows the file has, so a distinct count can be read as a ratio. */
+    rows: number;
+    /** Cells of this column that were empty. */
+    blanks?: number;
+    /** Distinct non-blank values in the whole column. */
+    distinct: number;
+}
+export interface SuggestFromColumnsRequest {
+    /** Project the request is scoped to. */
+    projectId: string;
+    columns: ColumnCounts[];
+    /**
+     * A few whole rows, picked as representative, keyed by heading. At most five are accepted.
+     *
+     * Whole rows rather than per-column lists because a value means what the values beside it say
+     * it means: `A1` next to a scale and a sheet number is a sheet size, and next to a discipline
+     * and a phase it is a code. Only the columns in `columns` — plus `fileColumn` — are carried; a
+     * column the user left out is left out of these rows too.
+     */
+    rows?: Record<string, string>[];
+    /** The schema these columns are read against — the categories a column can *match*. */
+    current?: ProjectSchema;
+    /** The column naming the file itself, which is never a thing the file is about. */
+    fileColumn?: string;
+    /** BCP-47 tags a proposed term is translated into. Pivot (`en`) always implied. */
+    languages?: string[];
+    /** How many entity catalogues triage may open. Same meaning and default as `from-prose`. */
+    maxCatalogs?: number;
+}
+/** One column's outcome. `categoryKey` indexes into `schema.entityCategories`. */
+export interface ColumnCategoryDecision {
+    column: string;
+    /** `catalog` is a curated term hydrated verbatim — always preferred over `new` when one fits. */
+    decision: 'match' | 'catalog' | 'new' | 'skip';
+    /** One sentence, for the person reviewing — present on the skips too. */
+    reason: string;
+    /** `match`: the existing category this column already is. */
+    matchedKey?: string;
+    /** `catalog` and `new`: the key of the category in `schema.entityCategories`. */
+    categoryKey?: string;
+    /** `catalog`: which catalogue the hydrated term came from. */
+    catalog?: string;
+}
+export interface SuggestFromColumnsResponse {
+    /** Exactly one per column given, in the same order. */
+    decisions: ColumnCategoryDecision[];
+    /** The proposed categories only — `current` is not folded in. */
+    schema: ProjectSchema;
+    notes: string[];
+}
+export interface SuggestPromptRequest {
+    /** Project the request is scoped to. */
+    projectId: string;
+    kind: 'category' | 'relation';
+    /** The term's key. */
+    key: string;
+    labels: Record<string, string>;
+    definition?: Record<string, string>;
+}
+export interface TranslateRequest {
+    /** Project the request is scoped to. */
+    projectId: string;
+    /** The word or phrase to translate. */
+    term: string;
+    /** The languages to translate into; pivot (`en`) always implied. */
+    languages: string[];
+}
+/** One entry per language asked for, plus the pivot. */
+export type TranslateResponse = Record<string, string>;
 /**
  * Client for the llm-tools guarded-LLM endpoints — small, single-purpose
  * backend calls that turn a prompt plus example data into a structured JSON
@@ -144,4 +361,49 @@ export declare class CueLlmTools {
      * same new category twice under different names).
      */
     suggestEntityCategoryBatch(request: SuggestEntityCategoryBatchRequest): Promise<SuggestEntityCategoryBatchResponse>;
+    /**
+     * Drafts a full {@link ProjectSchema} (or extends `current`) from a free-text
+     * description of the project's domain — the wizard's "describe it in prose" entry point.
+     */
+    suggestFromProse(request: SuggestFromProseRequest): Promise<SuggestFromProseResponse>;
+    /**
+     * The same draft `suggestFromProse` produces, from a handful of example-document page images
+     * instead of a prose description — the wizard's "upload example files" entry point. The caller
+     * renders each page to PNG and base64-encodes it; this method only relays the bytes.
+     */
+    suggestFromImages(request: SuggestFromImagesRequest): Promise<SuggestFromImagesResponse>;
+    /**
+     * Parses one positional segment of a client's numbering standard (e.g. a legend
+     * pasted from a table) into candidate codes, ready to become a {@link RawCodingSchemeField}.
+     */
+    parseCodingScheme(request: ParseCodingSchemeRequest): Promise<ParseCodingSchemeResponse>;
+    /**
+     * Drafts a full {@link ProjectSchema} (or extends `current`) from a parsed
+     * {@link RawCodingScheme} — the wizard's "derive it from a numbering standard" entry point.
+     */
+    suggestFromCodingScheme(request: SuggestFromCodingSchemeRequest): Promise<SuggestFromCodingSchemeResponse>;
+    /**
+     * Reads a document register's column headings as terms — which columns are categories the
+     * project already has, which name vocabularies it is missing, and which are not vocabularies
+     * at all.
+     *
+     * Send a profile, not a file: headings, counts and a sample of each column's distinct values.
+     * The caller already has a local answer from cue-ui's `sheetColumnsToProposal`; this one
+     * replaces it rather than merging with it, and what it adds is the part cardinality cannot
+     * see — that `Auftraggeber` is `Client` under another name, and that `Ebene 1`…`Ebene 4` are
+     * one taxonomy rather than four unrelated terms.
+     */
+    suggestFromColumns(request: SuggestFromColumnsRequest): Promise<SuggestFromColumnsResponse>;
+    /**
+     * Drafts an extraction/classification prompt for one category or relation term
+     * from its labels (and optional definition) — unwraps the backend's `{ prompt }`
+     * envelope so callers get the string directly.
+     */
+    suggestPrompt(request: SuggestPromptRequest): Promise<string>;
+    /**
+     * Translates one bare word or phrase into every requested language — no key, no
+     * definition, no merge against anything already there: for a caller that just has a
+     * string and wants it in more languages, e.g. a canonical's `value`.
+     */
+    translate(request: TranslateRequest): Promise<TranslateResponse>;
 }