@ngis/plugin-ui 0.4.0

package/dist/src/api/scenes.d.ts

@@ -0,0 +1,251 @@
+import type { ResourceShareMode } from "./resources";
+import type { ApiRequestOptions } from "../lib/api";
+export type SceneScope = "mine" | "shared" | "public";
+export type SceneType = "MAP" | "ANALYSIS" | "GIS";
+export type SceneMapSubCategory = "FREEFORM" | "TEMPLATE";
+export type SceneAnalysisSubCategory = "LAYER_ANALYSIS" | "WORKFLOW_ANALYSIS" | "CODING_ANALYSIS" | "INSIGHT_ANALYSIS";
+/**
+ * Moved to `@/types/common` (F1 / W1.2) — re-exported here so existing
+ * `import type { PageResult } from "@/api/scenes"` call sites keep working.
+ */
+export type { PageResult } from "../types/common";
+export interface NgisScene {
+    id: string;
+    ownerId: string;
+    name: string;
+    type?: SceneType | string | null;
+    description?: string | null;
+    thumbnailFileId?: string | null;
+    configJson?: string | null;
+    /** True for an unsaved scratch scene (auto-deleted after the TTL window). */
+    ephemeral?: boolean | null;
+    purpose?: "STANDARD" | "GIS_WORKSPACE" | "PLUGIN_UI_LAB" | string | null;
+    generation?: number | null;
+    lastActiveAt?: string | null;
+    expiresAt?: string | null;
+    mapSubCategories?: SceneMapSubCategory[] | string[] | null;
+    analysisSubCategories?: SceneAnalysisSubCategory[] | string[] | null;
+    createdAt?: string | null;
+    updatedAt?: string | null;
+}
+export interface NgisPublicScene {
+    id: string;
+    sourceSceneId: string;
+    ownerId: string;
+    name: string;
+    configSnapshot?: string | null;
+    layersSnapshot?: string | null;
+    publishedAt?: string | null;
+}
+export interface PublicSceneSummary {
+    sceneId: string;
+    name: string;
+    ownerId?: string | null;
+    publishedAt?: string | null;
+}
+export interface PublicSceneDetail {
+    scene: NgisScene;
+    layers: NgisSceneLayer[];
+    resources: SceneResourceDto[];
+}
+export interface CreateSceneParams {
+    name: string;
+    type: SceneType;
+    description?: string;
+    mapSubCategories?: SceneMapSubCategory[];
+    analysisSubCategories?: SceneAnalysisSubCategory[];
+}
+export interface UpdateSceneParams {
+    name?: string;
+    description?: string;
+}
+export interface UpdateSceneCapabilitiesParams {
+    mapSubCategories?: SceneMapSubCategory[];
+    analysisSubCategories?: SceneAnalysisSubCategory[];
+}
+export interface SceneResourceDto {
+    id: string;
+    sceneId: string;
+    name: string;
+    originalFileId: string;
+    workingFileId?: string | null;
+    effectiveFileId: string;
+    snapshot?: boolean | null;
+    snapshotId?: string | null;
+    mode?: ResourceShareMode | string | null;
+    geometryType?: string | null;
+    bboxJson?: string | null;
+    addedAt?: string | null;
+    layerCount: number;
+    rendered: boolean;
+    datasetType?: string | null;
+    datasetStatus?: string | null;
+    /**
+     * Selection-safe projection supplied by the scene service: VECTOR | RASTER |
+     * FILE. Resource pickers must use this rather than fan out to Dataset APIs.
+     */
+    selectionType?: string | null;
+    /** AVAILABLE | MISSING | UNAVAILABLE | UNKNOWN. */
+    metadataState?: string | null;
+    ready?: boolean;
+    renderable?: boolean;
+}
+export interface ListSceneResourcesOptions {
+    /** Ask the scene service to refresh its bounded, persisted dataset summaries. */
+    refresh?: boolean;
+    signal?: AbortSignal;
+}
+export interface RegisterSceneResourceParams {
+    fileId: string;
+    name?: string;
+}
+export interface NgisSceneLayer {
+    id: string;
+    sceneId: string;
+    resourceId?: string | null;
+    name: string;
+    layerType?: string | null;
+    styleJson?: string | null;
+    visible?: boolean | null;
+    sortOrder?: number | null;
+    groupId?: string | null;
+}
+export interface AddSceneLayerParams {
+    resourceId?: string;
+    fileId?: string;
+    name: string;
+    layerType?: string;
+    styleJson?: string;
+}
+export interface UpdateSceneLayerParams {
+    name?: string;
+    visible?: boolean;
+    sortOrder?: number;
+    styleJson?: string;
+    groupId?: string;
+}
+export interface NgisSceneLayerGroup {
+    id: string;
+    sceneId: string;
+    parentId?: string | null;
+    name: string;
+    orderIndex?: number | null;
+}
+export interface CreateLayerGroupParams {
+    name: string;
+    parentId?: string;
+    orderIndex?: number;
+}
+export interface UpdateLayerGroupParams {
+    name?: string;
+    orderIndex?: number;
+}
+export interface SceneListResult {
+    items: NgisScene[];
+    total: number;
+}
+/** Response of `GET /api/scenes/gis/workspace` — the user's scratch GIS scene. */
+export interface GisWorkspaceResponse {
+    scene: NgisScene;
+    layerCount: number;
+}
+export interface PluginUiLabResponse {
+    scene: NgisScene;
+    generation: number;
+    resourceCount: number;
+    layerCount: number;
+    lastActiveAt: string;
+    expiresAt: string;
+    cleanupState?: string | null;
+    cleanupOperationId?: string | null;
+    cleanupPhase?: string | null;
+    cleanupError?: string | null;
+}
+export interface PluginUiLabSample {
+    id: string;
+    version: string;
+    name: string;
+    description?: string | null;
+    dataKind: string;
+    datasetType: string;
+    geometryType?: string | null;
+    ready: boolean;
+    renderable: boolean;
+    available: boolean;
+    unavailableReason?: string | null;
+}
+export interface PluginUiLabSampleLoadRequest {
+    expectedGeneration: number;
+    sampleIds: string[];
+}
+export interface PluginUiLabSampleLoadItem {
+    sampleId: string;
+    sampleVersion?: string | null;
+    status: "LOADED" | "ALREADY_PRESENT" | "FAILED" | string;
+    resource?: SceneResourceDto | null;
+    layerId?: string | null;
+    error?: string | null;
+}
+export interface PluginUiLabSampleLoadResponse {
+    generation: number;
+    items: PluginUiLabSampleLoadItem[];
+}
+export declare const scenesApi: {
+    listMine(page?: number, size?: number): Promise<SceneListResult>;
+    listShared(): Promise<SceneListResult>;
+    listPublic(page?: number, size?: number): Promise<SceneListResult>;
+    getPublic(sceneId: string): Promise<PublicSceneDetail>;
+    get(sceneId: string): Promise<NgisScene>;
+    /**
+     * The caller's first saved scene of a type, in the listing order
+     * `/api/scenes` itself returns. Scratch/lab scenes are not saved scenes.
+     * Continue through the listing so a matching type beyond the first page is
+     * not mistaken for an empty workspace.
+     */
+    findFirstScene(type: SceneType): Promise<NgisScene | null>;
+    /** The caller's first saved GIS scene, or `null` when they have none. */
+    findFirstGisScene(): Promise<NgisScene | null>;
+    /**
+     * Get-or-create the caller's single scratch GIS workspace scene
+     * (`type=GIS`, `ephemeral=true`). Also resets its inactivity TTL.
+     */
+    getGisWorkspace(): Promise<GisWorkspaceResponse>;
+    getPluginUiLab(signal?: AbortSignal): Promise<PluginUiLabResponse>;
+    resetPluginUiLab(generation: number, signal?: AbortSignal): Promise<PluginUiLabResponse>;
+    discardPluginUiLab(signal?: AbortSignal): Promise<void>;
+    listPluginUiLabSamples(signal?: AbortSignal): Promise<PluginUiLabSample[]>;
+    loadPluginUiLabSamples(request: PluginUiLabSampleLoadRequest, signal?: AbortSignal): Promise<PluginUiLabSampleLoadResponse>;
+    /** Clear the scratch GIS workspace in place (same id, layers/config wiped). */
+    resetGisWorkspace(): Promise<NgisScene>;
+    /**
+     * Promote a scratch scene to a permanent one (`ephemeral` → false). Optional
+     * `name` renames it. After this, the next `getGisWorkspace()` returns a fresh
+     * empty scratch.
+     */
+    promoteScene(sceneId: string, name?: string): Promise<NgisScene>;
+    create(params: CreateSceneParams): Promise<NgisScene>;
+    update(sceneId: string, params: UpdateSceneParams): Promise<NgisScene>;
+    updateConfig(sceneId: string, config: string | object): Promise<NgisScene>;
+    updateCapabilities(sceneId: string, params: UpdateSceneCapabilitiesParams): Promise<NgisScene>;
+    delete(sceneId: string): Promise<void>;
+    publish(sceneId: string): Promise<void>;
+    unpublish(sceneId: string): Promise<void>;
+    isPublished(sceneId: string): Promise<boolean>;
+    forkPublic(publicSceneId: string, folderId?: string | null): Promise<NgisScene>;
+    listResources(sceneId: string, options?: ListSceneResourcesOptions | AbortSignal): Promise<SceneResourceDto[]>;
+    registerResource(sceneId: string, params: RegisterSceneResourceParams, options?: ApiRequestOptions): Promise<SceneResourceDto>;
+    renameResource(sceneId: string, resourceId: string, name: string): Promise<SceneResourceDto>;
+    deleteResource(sceneId: string, resourceId: string, cascade?: boolean): Promise<void>;
+    updateResourceWorkingFile(sceneId: string, resourceId: string, fileId: string): Promise<SceneResourceDto>;
+    revertResourceWorkingFile(sceneId: string, resourceId: string): Promise<SceneResourceDto>;
+    listLayers(sceneId: string, signal?: AbortSignal): Promise<NgisSceneLayer[]>;
+    addLayer(sceneId: string, params: AddSceneLayerParams, options?: ApiRequestOptions): Promise<NgisSceneLayer>;
+    updateLayer(sceneId: string, layerId: string, params: UpdateSceneLayerParams, options?: ApiRequestOptions): Promise<NgisSceneLayer>;
+    renameLayer(sceneId: string, layerId: string, name: string): Promise<NgisSceneLayer>;
+    deleteLayer(sceneId: string, layerId: string, options?: ApiRequestOptions): Promise<void>;
+    reorderLayers(sceneId: string, layerIds: string[], options?: ApiRequestOptions): Promise<void>;
+    listLayerGroups(sceneId: string): Promise<NgisSceneLayerGroup[]>;
+    createLayerGroup(sceneId: string, params: CreateLayerGroupParams): Promise<NgisSceneLayerGroup>;
+    updateLayerGroup(sceneId: string, groupId: string, params: UpdateLayerGroupParams): Promise<NgisSceneLayerGroup>;
+    deleteLayerGroup(sceneId: string, groupId: string): Promise<void>;
+};

package/dist/src/api/users.d.ts

@@ -0,0 +1,22 @@
+export interface UserProfile {
+    id: string;
+    name?: string | null;
+    email?: string | null;
+    username?: string | null;
+    avatar?: string | null;
+    role?: string | null;
+}
+declare function fetchUserProfile(userId: string): Promise<UserProfile>;
+export declare function getUserDisplayName(profile: UserProfile | null, fallback: string): string;
+export declare const usersApi: {
+    /** The current authenticated user's profile. */
+    me(): Promise<UserProfile>;
+    /** Update the only editable text field exposed by the user service. */
+    updateMe(username: string): Promise<unknown>;
+    /** Upload the current user's avatar. The service returns its URL. */
+    uploadAvatar(file: File): Promise<string>;
+    /** Public profile for any user id (used to resolve owner names). */
+    getById: typeof fetchUserProfile;
+    getByIdSafe(userId: string): Promise<UserProfile | null>;
+};
+export {};

package/dist/src/api/workflows.d.ts

@@ -0,0 +1,191 @@
+import type { WorkflowDagConfig } from "../types/workflow";
+export type { WorkflowDagConfig, WorkflowDagEdge, WorkflowDagGraph, WorkflowDagNode, WorkflowDagScriptConfig, WorkflowDagScriptPort, WorkflowDagView, WorkflowDagViewEdge, WorkflowDagViewNode, WorkflowDagViewPosition, WorkflowDagViewport, } from "../types/workflow";
+export type WorkflowDefinitionStatus = "DRAFT" | "PUBLISHED";
+export type WorkflowInstanceStatus = "PENDING" | "RUNNING" | "COMPLETED" | "FAILED" | "CANCELLED";
+export type WorkflowTaskStatus = "PENDING" | "QUEUED" | "RUNNING" | "SUCCESS" | "FAILED" | "CANCELLED";
+export type WorkflowOutputTarget = "SCENE_LAYER" | "SCENE_RESOURCE" | "LIBRARY";
+export type WorkflowOutputIntegrationStatus = "PENDING" | "DONE" | "FAILED";
+export interface WorkflowDefinitionDto {
+    id: string;
+    name: string;
+    sceneId?: string | null;
+    status: WorkflowDefinitionStatus;
+    dagConfig: WorkflowDagConfig;
+    createdAt?: string | null;
+    updatedAt?: string | null;
+}
+export interface WorkflowInstanceDto {
+    id: string;
+    definitionId: string;
+    status: WorkflowInstanceStatus;
+    createdAt?: string | null;
+    updatedAt?: string | null;
+    startedAt?: string | null;
+    completedAt?: string | null;
+}
+export interface WorkflowTaskInstanceDto {
+    id?: string | null;
+    taskInstanceId?: string | null;
+    instanceId?: string | null;
+    nodeId: string;
+    status: WorkflowTaskStatus;
+    inputs?: Record<string, unknown> | null;
+    outputs?: Record<string, unknown> | null;
+    errorMessage?: string | null;
+}
+export interface WorkflowInstanceOutputDto {
+    nodeId: string;
+    fileId: string;
+    fileName?: string | null;
+    datasetType?: string | null;
+    primary?: boolean | null;
+    extracted?: boolean | null;
+    extractTarget?: WorkflowOutputTarget | null;
+    extractRef?: string | null;
+    integrationStatus?: WorkflowOutputIntegrationStatus | null;
+    integrationDetail?: string | null;
+}
+export interface WorkflowToolInputSlotDto {
+    slotKey: string;
+    name?: string | null;
+    description?: string | null;
+    dataType?: string | null;
+    bindNodeId?: string | null;
+    bindInputKey?: string | null;
+    optional?: boolean | null;
+}
+export interface WorkflowToolOutputSlotDto {
+    slotKey: string;
+    name?: string | null;
+    description?: string | null;
+    bindNodeId?: string | null;
+    /**
+     * **Added by Stage 14 Y6 (W4).** `ToolOutputSlot` has carried it since S11b
+     * (`ToolOutputSlot.java:8-18`); this type did not, so no client could publish
+     * one and every published tool's outputs served `data_type: "file"`.
+     *
+     * The chain: `inferDraft` builds output slots through the 4-arg constructor
+     * (`WorkflowToolSchemaService.java:67`) so an *inferred* slot is `null`,
+     * `compileToolSchema` then omits `x-data-type` (`:93`), and `ui_schema.py`'s
+     * `_resolve_data_type` falls back to `canonical_data_type(None) == "file"`. The
+     * generated dialog for a published recipe therefore showed a file picker where
+     * the author declared a raster. Pascal on the wire (F14.1) — see
+     * `ngisSlotDataType`.
+     */
+    dataType?: string | null;
+}
+export interface WorkflowToolDraftDto {
+    inputSlots: WorkflowToolInputSlotDto[];
+    outputSlots: WorkflowToolOutputSlotDto[];
+}
+export interface CreateWorkflowToolPayload {
+    definitionId: string;
+    name: string;
+    description?: string;
+    inputSlots: WorkflowToolInputSlotDto[];
+    outputSlots: WorkflowToolOutputSlotDto[];
+    summary?: string;
+    useCases?: string[];
+    synonyms?: string[];
+    domain?: string[];
+    operationType?: string[];
+}
+/**
+ * `WorkflowToolDto` (`WorkflowToolDto.java`).
+ *
+ * **The published tool's own id is `id`; `toolId` is a phantom** — the server
+ * record has no such component and never sends one. It is kept because it costs
+ * nothing and a reader may still be checking for it, but a caller that reads only
+ * `toolId` gets `undefined` on every publish. Stage 14 Y6 added the four real
+ * components that were missing, above all `registryVersion`.
+ */
+export interface WorkflowToolDto {
+    id?: string | null;
+    /** @deprecated The server sends `id`. See the note above. */
+    toolId?: string | null;
+    name?: string | null;
+    description?: string | null;
+    sourceDefinitionId?: string | null;
+    inputSlots?: WorkflowToolInputSlotDto[] | null;
+    outputSlots?: WorkflowToolOutputSlotDto[] | null;
+    visibility?: string | null;
+    status?: string | null;
+    /**
+     * The **model-registry** tool version, assigned by geoanalysis' `UpsertWorkflowTool`
+     * and written back inside the publish transaction
+     * (`WorkflowToolService.java:373-374`), so it is present on the publish
+     * response. This is the number a `tool`-kind extension version pins as
+     * `CreateReferenceVersionRequest.toolVersion` — a `Long` here and an `Integer`
+     * there — and it is **not** a node's `toolVersion` pin, which the same service
+     * re-resolves per node at publish.
+     */
+    registryVersion?: number | null;
+    [key: string]: unknown;
+}
+export interface InvokeWorkflowToolPayload {
+    inputs: Record<string, string>;
+    sceneId?: string;
+    outputMode?: "ADD_LAYER" | "UPDATE_RESOURCE" | "LIBRARY";
+    targetResourceId?: string;
+}
+export interface InvokeWorkflowToolResult {
+    instanceId: string;
+    status?: WorkflowInstanceStatus | null;
+}
+/**
+ * `PATCH /api/workflows/tools/{toolId}/visibility` — the sharing leg (Stage 14
+ * Y6, F14.6).
+ *
+ * `PublishToolRequest` carries **no** visibility: `publish` hardcodes
+ * `PRIVATE`/`ACTIVE` (`WorkflowToolService.java:120-121`), so making a published
+ * recipe visible to anyone else is always a second call. The values are
+ * case-sensitive and validated against `Set.of("PRIVATE","PUBLIC")`
+ * (`:156-158`), refusing with `"visibility must be PUBLIC or PRIVATE"`;
+ * `GROUP` — legal on an *extension* (`ExtensionVisibility`) — is **not** legal
+ * here, which is why this union is two values and not three.
+ */
+export type WorkflowToolVisibility = "PRIVATE" | "PUBLIC";
+export interface SetWorkflowToolVisibilityPayload {
+    visibility: WorkflowToolVisibility;
+}
+interface DefinitionMutationQuery {
+    name?: string | null;
+    sceneId?: string | null;
+    [key: string]: string | null | undefined;
+}
+interface ExtractOutputParams {
+    nodeId: string;
+    fileId?: string;
+    target: WorkflowOutputTarget;
+    sceneId?: string;
+    resourceId?: string;
+    name?: string;
+    folderId?: string;
+}
+export declare const workflowApi: {
+    createDefinition(query: DefinitionMutationQuery, dagConfig: WorkflowDagConfig): Promise<WorkflowDefinitionDto>;
+    updateDefinition(definitionId: string, query: DefinitionMutationQuery, dagConfig: WorkflowDagConfig): Promise<WorkflowDefinitionDto>;
+    listDefinitions(): Promise<WorkflowDefinitionDto[]>;
+    getDefinition(definitionId: string): Promise<WorkflowDefinitionDto>;
+    getToolDraft(definitionId: string): Promise<WorkflowToolDraftDto>;
+    publishDefinition(definitionId: string): Promise<WorkflowDefinitionDto>;
+    runDefinition(definitionId: string, globalContext?: Record<string, unknown>): Promise<WorkflowInstanceDto>;
+    getInstance(instanceId: string): Promise<WorkflowInstanceDto>;
+    getInstanceTasks(instanceId: string): Promise<WorkflowTaskInstanceDto[]>;
+    getInstanceChildren(instanceId: string): Promise<WorkflowInstanceDto[]>;
+    cancelInstance(instanceId: string): Promise<void>;
+    getInstanceOutputs(instanceId: string): Promise<WorkflowInstanceOutputDto[]>;
+    extractOutput(instanceId: string, payload: ExtractOutputParams): Promise<void>;
+    createTool(payload: CreateWorkflowToolPayload): Promise<WorkflowToolDto>;
+    invokeTool(toolId: string, payload: InvokeWorkflowToolPayload): Promise<InvokeWorkflowToolResult>;
+    /**
+     * Owner-only sharing. `200 WorkflowToolDto` — not `204`, and not the
+     * definition.
+     *
+     * The visibility change is propagated to the geoanalysis registry over gRPC
+     * inside the same transaction, and a registry failure is surfaced as a
+     * **`502`** rather than swallowed (`WorkflowToolService.java:162-171`), so a
+     * caller that treats any non-2xx as "not shared" is telling the truth.
+     */
+    setToolVisibility(toolId: string, visibility: WorkflowToolVisibility): Promise<WorkflowToolDto>;
+};

package/dist/src/components/plugin-ui/AttributeTable.d.ts

@@ -0,0 +1,26 @@
+import { type GisAttributeTableProps } from "../../features/gis/components/GisAttributeTable";
+import type { NgisHostAPI } from "../../sdk/host-api";
+/** The member the wrapper forwards straight through, typed from the source
+ *  of truth so a change to the grid's signature is a compile error here. */
+type ForwardedGridProps = Pick<GisAttributeTableProps, "onHighlight">;
+export interface AttributeTableProps {
+    /** The 0.4 facade — always the one `createGisPluginHostFactory` minted. */
+    host: NgisHostAPI;
+    /** The flow port id (F14.5). Also seeds the control's DOM id. */
+    id?: string;
+    /** Plugin-authored; rendered **literally** (F13.11). Falls back to the resolved
+     *  resource's own name for the grid's header when omitted. */
+    label?: string;
+    /** The `resource` in port's value — a **file** id (F14.5). Inside a `<Flow>`
+     *  this may be a reference (`"@dem"`); `"@@"` opens a literal. */
+    resource: string | null;
+    /**
+     * Optional map highlight. Supplied by an author who knows which layer draws
+     * this resource — see the header for why the facade cannot work that out. When
+     * absent, a selection that would have highlighted renders a reason.
+     */
+    onHighlight?: ForwardedGridProps["onHighlight"];
+    className?: string;
+}
+export declare function AttributeTable({ host, id, label, resource: resourceProp, onHighlight, className, }: AttributeTableProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/plugin-ui/BatchTable.d.ts

@@ -0,0 +1,47 @@
+import type { NgisHostAPI } from "../../sdk/host-api";
+import { type NgisBatchConfig, type NgisBatchRunReport } from "./batch-model";
+import { type NgisRecipe } from "./w4-contracts";
+export interface BatchTableProps {
+    host: NgisHostAPI;
+    /** Scope for every cell's node id (F14.5 / CORRECTION 10). Also the DOM id. */
+    id?: string;
+    /** Plugin-authored; rendered **literally** (F13.11). */
+    label?: string;
+    /** The one tool every row runs. `null` renders a reason, not an empty grid. */
+    toolId: string | null;
+    /**
+     * A published recipe whose **promoted inputs are the columns** (F14.21),
+     * through the seam's `recipeColumns`. A recipe input the published tool does
+     * not declare is surfaced, never silently dropped.
+     */
+    recipe?: NgisRecipe;
+    /** Rows to open with, when there is no `config`. At least one. */
+    rows?: number;
+    /**
+     * A saved batch, loaded when this value's identity changes. Parsed, so an
+     * unknown `batchVersion` **refuses** rather than best-efforting (F14.21).
+     */
+    config?: NgisBatchConfig | null;
+    /**
+     * Every change, as JSON-ready data — the save leg.
+     *
+     * The table does **not** write to `host.storage` itself, and that is a finding
+     * rather than a shortcut: `NgisStorageLeg` is one opaque blob per (user,
+     * extension) with no key namespace (`host-api.ts:118-127`), so a component that
+     * persisted itself there would overwrite the whole plugin's settings. The author
+     * owns the slot; this reports the value.
+     */
+    onConfigChange?: (config: NgisBatchConfig) => void;
+    /** Task ids, in row order, after a run. Only the rows that actually submitted. */
+    onSubmitted?: (taskIds: readonly string[]) => void;
+    /** One report per explicit run or retry, for host-owned summaries. */
+    onRunReport?: (report: NgisBatchRunReport) => void;
+    outputMode?: "ADD_LAYER" | "UPDATE_RESOURCE";
+    sceneId?: string | null;
+    /** Lab-scene optimistic fence. Ordinary scene batches leave this absent. */
+    expectedSceneGeneration?: number;
+    className?: string;
+    /** Class for portalled `<Select>` content. A table of Selects needs this. */
+    contentClassName?: string;
+}
+export declare function BatchTable({ host, id, label, toolId, recipe, rows, config, onConfigChange, onSubmitted, onRunReport, outputMode, sceneId, expectedSceneGeneration, className, contentClassName, }: BatchTableProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/plugin-ui/ChartCanvas.d.ts

@@ -0,0 +1,14 @@
+import type { NgisChartSpec } from "../../sdk/host-api";
+import { type NgisChartTheme } from "./stat-chart-model";
+export interface ChartCanvasProps {
+    spec: NgisChartSpec;
+    theme: NgisChartTheme;
+    /** The folded-pie tail's segment name — a host string, translated by the
+     *  caller, because this file holds no copy. */
+    otherLabel: string;
+    /** CSS height. Sized to include the axis band, so the card never grows a
+     *  nested scrollbar to reach the x labels. */
+    height?: number;
+    className?: string;
+}
+export declare function ChartCanvas({ spec, theme, otherLabel, height, className, }: ChartCanvasProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/plugin-ui/ExtentPicker.d.ts

@@ -0,0 +1,22 @@
+import type { NgisHostAPI } from "../../sdk/host-api";
+import type { NgisBounds } from "../../sdk/map-api";
+import { type NgisExtentMode } from "./picker-data";
+export interface ExtentPickerProps {
+    host: NgisHostAPI;
+    /** The flow port id (F14.5, `extent` kind). Also seeds the control's DOM id. */
+    id?: string;
+    /** Plugin-authored; rendered **literally** (F13.11). */
+    label?: string;
+    /** Default `"draw"`. `"choose"` renders the public draw/viewport choice. */
+    mode?: NgisExtentMode | "choose";
+    /**
+     * `manual` keeps the explicit capture button. `automatic` captures the
+     * viewport immediately and on camera changes, or starts a rectangle draw and
+     * commits whenever the draw snapshot changes.
+     */
+    capture?: "manual" | "automatic";
+    value: NgisBounds | null;
+    onChange: (value: NgisBounds | null) => void;
+    className?: string;
+}
+export declare function ExtentPicker({ host, id, label, mode, capture: captureBehavior, value, onChange, className, }: ExtentPickerProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/plugin-ui/FieldSelect.d.ts

@@ -0,0 +1,23 @@
+import type { NgisHostAPI } from "../../sdk/host-api";
+export interface FieldSelectProps {
+    host: NgisHostAPI;
+    /** The flow port id (F14.5). Also seeds the control's DOM id. */
+    id?: string;
+    /** Plugin-authored; rendered **literally** (F13.11). */
+    label?: string;
+    /**
+     * The parent resource port's current value — a **file id**. `null` while the
+     * parent is unbound, which is a state this control names rather than hides.
+     *
+     * Inside a `<Flow>` this may instead be a **reference** (`"@dem"`), which is
+     * resolved through the `parent` in port. `"@@"` opens a literal, for the file
+     * id that really does start with `@`.
+     */
+    parentFileId: string | null;
+    value: string | null;
+    onChange: (value: string | null) => void;
+    className?: string;
+    /** Class for the portalled `<Select>` content — see `ResourceSelect`. */
+    contentClassName?: string;
+}
+export declare function FieldSelect({ host, id, label, parentFileId, value, onChange, className, contentClassName, }: FieldSelectProps): import("react/jsx-runtime").JSX.Element;