@mintplayer/ng-spark 22.23.0 → 22.25.0

package/types/mintplayer-ng-spark-po-form.d.ts

@@ -1,23 +1,22 @@
-import * as _angular_core from '@angular/core';
-import { Type } from '@angular/core';
-import { CdkDragDrop } from '@angular/cdk/drag-drop';
-import { Color } from '@mintplayer/ng-bootstrap';
-import { InMemoryTreeSelectProvider, TreeNode } from '@mintplayer/ng-bootstrap/tree-select';
-import * as _mintplayer_ng_spark_models from '@mintplayer/ng-spark/models';
-import { PersistentObject, EntityType, ValidationError, RefreshOverlay, QueryResultItem, LookupReference, EntityAttributeDefinition, EntityPermissions, ELookupDisplayType, EReferenceDisplayType, AttributeTab, AttributeGroup, LookupReferenceValue, RuleFailure } from '@mintplayer/ng-spark/models';
-import { DatatableSettings } from '@mintplayer/ng-bootstrap/datatable';
-import { PaginationResponse } from '@mintplayer/pagination';
-
+import * as i0 from "@angular/core";
+import { Type } from "@angular/core";
+import { CdkDragDrop } from "@angular/cdk/drag-drop";
+import { Color } from "@mintplayer/ng-bootstrap";
+import { InMemoryTreeSelectProvider, TreeNode } from "@mintplayer/ng-bootstrap/tree-select";
+import { AttributeGroup, AttributeTab, ELookupDisplayType, EReferenceDisplayType, EntityAttributeDefinition, EntityPermissions, EntityType, LookupReference, LookupReferenceValue, PersistentObject, QueryResultItem, RefreshOverlay, RefreshTrigger, RuleFailure, ValidationError } from "@mintplayer/ng-spark/models";
+import { SparkResolvedRowRenderer } from "@mintplayer/ng-spark/renderers";
+import { DatatableSettings } from "@mintplayer/ng-bootstrap/datatable";
+import { PaginationResponse } from "@mintplayer/pagination";
 /** What the coordinator needs from its host, so it can be tested without mounting a form. */
 interface RefreshCoordinatorHost {
-    /** POSTs the object and resolves with the reshaped one. */
-    send(triggeredBy: string): Promise<PersistentObject>;
-    /** Values as they are right now — read at dispatch time to snapshot what is being sent. */
-    currentValues(): Record<string, any>;
-    /** Applies a settled response. Not called for a superseded one. */
-    apply(response: PersistentObject, sent: Record<string, any>): void;
-    /** Surfaced so the host can show a busy affordance. Never used to disable fields. */
-    setBusy(busy: boolean): void;
+  /** POSTs the object and resolves with the reshaped one. */
+  send(triggeredBy: string): Promise<PersistentObject>;
+  /** Values as they are right now — read at dispatch time to snapshot what is being sent. */
+  currentValues(): Record<string, any>;
+  /** Applies a settled response. Not called for a superseded one. */
+  apply(response: PersistentObject, sent: Record<string, any>): void;
+  /** Surfaced so the host can show a busy affordance. Never used to disable fields. */
+  setBusy(busy: boolean): void;
 }
 /**
  * Serializes refreshes for **one** form instance and drops superseded ones.
@@ -32,308 +31,437 @@ interface RefreshCoordinatorHost {
  * response *will* arrive. It is discarded by sequence number rather than prevented.
  */
 declare class RefreshCoordinator {
-    private readonly host;
-    private queue;
-    private sequence;
-    private settled;
-    private pending;
-    constructor(host: RefreshCoordinatorHost);
-    /** Whether a refresh is in flight. */
-    get isRefreshing(): boolean;
-    /**
-     * Marks `attributeName` as needing a refresh without sending one — for free-text editors, which
-     * would otherwise issue a request per keystroke. Flushed by {@link blur} or {@link flush}.
-     */
-    markPending(attributeName: string): void;
-    /** Sends a pending refresh for `attributeName`, if one was marked. */
-    blur(attributeName: string): Promise<void>;
-    /**
-     * Sends every refresh still marked pending. Called before save, so a value typed and never blurred
-     * — the user tabbing straight to the save button — is still reflected before the object goes.
-     */
-    flush(): Promise<void>;
-    /** Sends a refresh immediately — discrete editors, where every change is a committed one. */
-    trigger(attributeName: string): Promise<void>;
+  private readonly host;
+  private queue;
+  private sequence;
+  private settled;
+  private pending;
+  /** Debounce timers for `ValueChanged` free text, keyed by path. A path here is also in `pending`. */
+  private timers;
+  constructor(host: RefreshCoordinatorHost);
+  /** Whether a refresh is in flight. */
+  get isRefreshing(): boolean;
+  /**
+   * Marks `attributeName` as needing a refresh without sending one — for free-text editors, which
+   * would otherwise issue a request per keystroke. Flushed by {@link blur} or {@link flush}.
+   */
+  markPending(attributeName: string): void;
+  /**
+   * Routes a change by its {@link RefreshDispatch}: send now, send once typing pauses, or wait for
+   * blur. The one entry point a form needs, so the three editors' policies live here.
+   */
+  dispatch(attributeName: string, mode: RefreshDispatch): Promise<void>;
+  /** Sends a pending refresh for `attributeName`, if one was marked (or is waiting on its debounce). */
+  blur(attributeName: string): Promise<void>;
+  /**
+   * Sends every refresh still marked pending, including any waiting on a debounce. Called before
+   * save, so a value typed and never blurred — the user tabbing straight to the save button — is
+   * still reflected before the object goes.
+   */
+  flush(): Promise<void>;
+  /** Drops every pending mark and debounce timer without sending — the form is going away. */
+  dispose(): void;
+  /**
+   * Sends a refresh — immediately for discrete editors, where every change is a committed one.
+   *
+   * With `debounceMs`, the send waits until `attributeName` has been quiet for that long; each call
+   * restarts the wait, so a burst of keystrokes costs one request. Until it fires, the path counts as
+   * pending, so {@link blur} and {@link flush} send it straight away instead of waiting out the timer.
+   */
+  trigger(attributeName: string, options?: {
+    debounceMs?: number;
+  }): Promise<void>;
+  private clearTimer;
 }
-
+/** How long `ValueChanged` free text waits for typing to pause before refreshing — like the search box. */
+declare const SPARK_REFRESH_DEBOUNCE_MS = 300;
+/** The subset of an attribute definition that decides how its editor behaves. */
+interface RefreshTriggerShape {
+  dataType?: string;
+  lookupReferenceType?: string;
+  isArray?: boolean;
+  triggersRefresh?: RefreshTrigger;
+}
+/** When a change sends its refresh: on the change itself, on blur, or never. */
+type EffectiveRefreshTrigger = 'change' | 'blur' | 'none';
+/** How {@link RefreshCoordinator.dispatch} handles a change. */
+type RefreshDispatch = 'immediate' | 'debounced' | 'blur';
+/**
+ * Resolves the declared `triggersRefresh` against the editor the attribute renders as.
+ *
+ * - `None` / absent → `'none'`.
+ * - `Auto` → `'change'` for a discrete editor, `'blur'` for free text (the original behaviour).
+ * - `ValueChanged` → `'change'` (debounced for free text — see {@link refreshDispatch}).
+ * - `Blur` → `'blur'`, except on a discrete editor, which has no meaningful blur and so acts as
+ *   `ValueChanged`. The server's `--spark-verify-model` warns about that declaration.
+ */
+declare function effectiveTrigger(attr: RefreshTriggerShape | undefined): EffectiveRefreshTrigger;
+/**
+ * How a change to `attr` is sent, or `null` when it sends nothing. A `'change'` trigger on free
+ * text is debounced; on a discrete editor it is immediate.
+ */
+declare function refreshDispatch(attr: RefreshTriggerShape | undefined): RefreshDispatch | null;
+/** Whether the change to `attr` is sent immediately (a discrete editor with a change trigger). */
+declare function triggersImmediately(attr: RefreshTriggerShape | undefined): boolean;
+/**
+ * Editors where every change is a deliberate, committed one. Everything else is free text, where
+ * firing per keystroke would be unacceptable.
+ *
+ * ⚠️ This asks how the attribute is **rendered**, not what its `dataType` says, and the difference
+ * is not academic. A lookup attribute carries the data type of its *key* — Fleet's `Car.Status` is
+ * `dataType: "string"` with `lookupReferenceType: "CarStatus"` — so keying on `dataType` alone
+ * classifies a `<bs-select>` as free text. It then waits for a blur that a select never emits, and
+ * the refresh simply never fires: no request, no error, nothing to see.
+ */
+declare function isDiscreteEditor(attr: RefreshTriggerShape | undefined): boolean;
+/** Empty overlay, so callers do not have to spell the type. */
+declare const NO_OVERLAY: RefreshOverlay;
 /**
  * A refresh a form embedded in another form is asking its host to issue on its behalf.
  *
- * `immediate` mirrors the distinction the host's own editors make: a discrete editor fires on
- * change, free text only marks itself pending and fires on blur.
+ * `dispatch` carries the decision the child's own editor made from its declared `triggersRefresh`
+ * — send now, send once typing pauses, or wait for blur — so the host applies exactly the semantics
+ * it would have applied to an editor of its own.
  */
-interface NestedTriggerRequest {
-    /** The full path the server addresses, e.g. `Gate.ProjectMode`. */
-    path: string;
-    immediate: boolean;
+export interface NestedTriggerRequest {
+  /** The full path the server addresses, e.g. `Gate.ProjectMode`. */
+  path: string;
+  dispatch: RefreshDispatch;
 }
-declare class SparkPoFormComponent {
-    private readonly sparkService;
-    private readonly translations;
-    private readonly rendererRegistry;
-    entityType: _angular_core.InputSignal<EntityType | null>;
-    formData: _angular_core.ModelSignal<Record<string, any>>;
-    validationErrors: _angular_core.InputSignal<ValidationError[]>;
-    showButtons: _angular_core.InputSignal<boolean>;
-    isSaving: _angular_core.InputSignal<boolean>;
-    parentId: _angular_core.InputSignal<string | undefined>;
-    parentType: _angular_core.InputSignal<string | undefined>;
-    save: _angular_core.OutputEmitterRef<void>;
-    cancel: _angular_core.OutputEmitterRef<void>;
-    /**
-     * The type id to refresh against. Absent means refresh is unavailable — the form still renders and
-     * edits normally, so a host that has not opted in loses nothing.
-     */
-    objectTypeId: _angular_core.InputSignal<string | undefined>;
-    /** The id of the object being edited; absent for a create. */
-    objectId: _angular_core.InputSignal<string | undefined>;
-    /**
-     * Set when this form renders a single embedded AsDetail object inside a host form: the name of
-     * the attribute holding it, e.g. `"Gate"`. Presence of a prefix switches the form from issuing
-     * its own refreshes to reporting them upward, because an embedded object is not something the
-     * server can be asked about on its own — the request must describe, and be authorized against,
-     * the object that owns it.
-     */
-    triggerPathPrefix: _angular_core.InputSignal<string | null>;
-    /** Raised instead of self-issuing when {@link triggerPathPrefix} is set. */
-    nestedTriggerRequested: _angular_core.OutputEmitterRef<NestedTriggerRequest>;
-    /** Blur counterpart, flushing a trigger the host only marked pending. */
-    nestedTriggerBlurred: _angular_core.OutputEmitterRef<string>;
-    /**
-     * What the last refresh changed about each attribute's presentation, keyed by attribute name.
-     *
-     * Deliberately NOT folded back into `entityType`. All option loading hangs off one effect keyed on
-     * `entityType` identity and `SparkService` caches nothing, so re-setting it would re-issue every
-     * reference query and lookup fetch on every refresh; mutating it in place would not re-render at
-     * all.
-     *
-     * ⚠️ A `model`, not a plain signal, because the page that owns the save has to see it. This form
-     * renders from the overlaid attribute list; `spark-po-edit` and `spark-po-create` build the
-     * payload from their own copy of the same filter. While the overlay stopped here, those two
-     * filtered on the attribute's state *as loaded* — so an attribute a refresh hook revealed was
-     * rendered, filled in by the user, and then silently left out of the save. When the same hook also
-     * made it required (the ordinary case — a field appears *because* it is now needed) the server
-     * refused the save for the very field the user had just filled, and the form became a dead end
-     * with no way forward from inside it.
-     */
-    refreshOverlay: _angular_core.ModelSignal<RefreshOverlay>;
-    isRefreshing: _angular_core.WritableSignal<boolean>;
-    colors: typeof Color;
-    referenceOptions: _angular_core.WritableSignal<Record<string, QueryResultItem[]>>;
-    referenceProviders: _angular_core.WritableSignal<Record<string, InMemoryTreeSelectProvider>>;
-    referenceNodes: _angular_core.WritableSignal<Record<string, Record<string, TreeNode>>>;
-    asDetailTypes: _angular_core.WritableSignal<Record<string, EntityType>>;
-    lookupReferenceOptions: _angular_core.WritableSignal<Record<string, LookupReference>>;
-    editingAsDetailAttr: _angular_core.WritableSignal<EntityAttributeDefinition | null>;
-    asDetailFormData: _angular_core.WritableSignal<Record<string, any>>;
-    showAsDetailModal: _angular_core.WritableSignal<boolean>;
-    editingArrayIndex: _angular_core.WritableSignal<number | null>;
-    asDetailPermissions: _angular_core.WritableSignal<Record<string, EntityPermissions>>;
-    /**
-     * What the server said when it refused to construct or release a row.
-     *
-     * A local signal rather than the `validationErrors` input, because this is the one class of error
-     * the form raises on its own behalf: `validationErrors` is owned by the host (po-edit / po-create)
-     * and arrives from a save. Cleared at the start of each lifecycle call, so a stale refusal never
-     * outlives the click that caused it.
-     *
-     * Keyed by attribute name so a message renders against the grid it came from. A single global
-     * alert would have been less code and worse: a form with two detail grids would show one grid's
-     * refusal above the other, and the user's next click is on the grid, not the top of the page.
-     */
-    rowLifecycleErrors: _angular_core.WritableSignal<Record<string, ValidationError[]>>;
-    /** The refusal to render under `attrName`'s grid, if any. */
-    rowLifecycleErrorsFor(attrName: string): ValidationError[];
-    asDetailReferenceOptions: _angular_core.WritableSignal<Record<string, Record<string, QueryResultItem[]>>>;
-    ELookupDisplayType: typeof ELookupDisplayType;
-    EReferenceDisplayType: typeof EReferenceDisplayType;
-    /**
-     * Every attribute this form could ever need option data for — including ones the model hides,
-     * because a refresh may reveal them.
-     *
-     * Read by the option-loading effect, and deliberately independent of `refreshOverlay`: the loaders
-     * read this synchronously, so an overlay dependency here would make every refresh re-issue every
-     * reference query and lookup fetch. That is the whole reason the overlay is a separate signal.
-     */
-    optionSourceAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
-    editableAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
-    private static readonly DEFAULT_TAB;
-    ungroupedAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
-    resolvedTabs: _angular_core.Signal<AttributeTab[]>;
-    groupsForTab(tab: AttributeTab): AttributeGroup[];
-    attrsForGroup(group: AttributeGroup): EntityAttributeDefinition[];
-    constructor();
-    private toRecord;
-    loadReferenceOptions(): Promise<void>;
-    /**
-     * Stable TreeNode[] value per multi-reference attribute, derived from the id array
-     * in formData and the resolved node map. Recomputes only when formData or the node
-     * map changes, so binding it into <bs-tree-select> doesn't churn on every CD pass.
-     * Ids without a resolved node fall back to a label of the id itself.
-     */
-    referenceTreeValues: _angular_core.Signal<Record<string, TreeNode[]>>;
-    getReferenceProvider(attr: EntityAttributeDefinition): InMemoryTreeSelectProvider | undefined;
-    onReferenceTreeChange(attr: EntityAttributeDefinition, value: TreeNode | TreeNode[] | null): void;
-    loadAsDetailTypes(): Promise<void>;
-    loadLookupReferenceOptions(): Promise<void>;
-    getLookupOptions(attr: EntityAttributeDefinition): LookupReferenceValue[];
-    onReferenceValueChange(attr: EntityAttributeDefinition, id: string | null): void;
-    onLookupValueChange(attr: EntityAttributeDefinition, key: string | null): void;
-    getEditRendererComponent(attr: EntityAttributeDefinition): Type<any> | null;
-    getEditRendererInputs(component: Type<any>, attr: EntityAttributeDefinition): Record<string, any>;
-    /** Column renderer for a cell of an AsDetail sub-table (so embedded rows honor `col.renderer` too). */
-    getAsDetailCellRendererComponent(col: EntityAttributeDefinition): Type<any> | null;
-    getAsDetailCellRendererInputs(component: Type<any>, row: Record<string, any>, col: EntityAttributeDefinition): Record<string, any>;
-    /** Edit-renderer for an inline AsDetail cell (so inline editing honors `col.renderer`, not just display). */
-    getAsDetailCellEditRenderer(col: EntityAttributeDefinition): Type<any> | null;
-    getAsDetailCellEditRendererInputs(component: Type<any>, row: Record<string, any>, col: EntityAttributeDefinition): Record<string, any>;
-    /**
-     * Rules evaluated in the browser, against the *effective* metadata — so a rule a refresh hook
-     * imposed is visible before the round-trip rather than only after the server rejects the save.
-     */
-    clientRuleFailures: _angular_core.Signal<RuleFailure[]>;
-    hasError(attrName: string): boolean;
-    private inlineErrorPath;
-    hasInlineError(attr: EntityAttributeDefinition, rowIndex: number, col: EntityAttributeDefinition): boolean;
-    inlineErrorMessage(attr: EntityAttributeDefinition, rowIndex: number, col: EntityAttributeDefinition): string | null;
-    /**
-     * The single funnel every scalar / boolean / inline-cell edit passes through.
-     *
-     * `attr` is optional because some editors have nothing useful to say about which attribute moved.
-     * A caller that knows should always say so — without it no refresh can fire.
-     */
-    onFieldChange(attr?: EntityAttributeDefinition): void;
-    /**
-     * A trigger inside an AsDetail row. Addressed by the same `{attr}[{index}].{col}` path the inline
-     * validation errors already use, so the server can tell which row asked without a second
-     * addressing scheme being invented for it.
-     */
-    onInlineCellChange(attr: EntityAttributeDefinition, rowIndex: number, col: EntityAttributeDefinition): void;
-    /**
-     * Which embedded target the in-flight refresh belongs to, if any.
-     *
-     * ⚠️ Tagged, not a nullable `rowIndex`. The two arms write to different places — a row inside
-     * `formData`, versus the modal's working copy in `asDetailFormData` — and an index that happens
-     * to be absent is not the same statement as "this attribute holds one object". With a nullable
-     * index, a row refresh carrying a bad index would fall silently into the object arm.
-     */
-    private pendingNestedTrigger;
-    /**
-     * A trigger inside a single embedded AsDetail object, raised by the modal's recursive form.
-     *
-     * The child form does not issue the request itself, for two reasons that both bite. Its
-     * `entityType` is the embedded type, so a payload built there describes `GateSettings` while the
-     * request must describe the Repository that owns it. And nested AsDetail types carry no rights of
-     * their own — the server authorizes a nested refresh on the OWNING type — so a child-issued
-     * request would be asking the wrong question of security.json.
-     */
-    onEmbeddedTrigger(attributeName: string, event: NestedTriggerRequest): void;
-    /** Blur counterpart of {@link onEmbeddedTrigger}, for the child's free-text editors. */
-    onEmbeddedTriggerBlur(path: string): void;
-    /**
-     * Applies a refresh that ran against a detail row: the row's own values, and the column metadata
-     * for the grid it lives in.
-     *
-     * The column metadata comes from `asDetailTypes` — a different signal from `entityType` — which is
-     * why a nested response cannot go through the top-level overlay.
-     *
-     * ⚠️ The row array is mutated in place rather than replaced. Rows are tracked by index, so handing
-     * the template a new array destroys and rebuilds every row's DOM and takes focus with it, mid-edit.
-     */
-    private applyNestedResponse;
-    onInlineCellBlur(attr: EntityAttributeDefinition, rowIndex: number, col: EntityAttributeDefinition): void;
-    /** Blur handler for free-text editors — sends the refresh their keystrokes only marked pending. */
-    onFieldBlur(attr: EntityAttributeDefinition): void;
-    private noteChange;
-    /** `Gate.ProjectMode` — the index-free counterpart of the inline grid's `Jobs[1].Kind`. */
-    private nestedTriggerPath;
-    private canRefresh;
-    /**
-     * Per-instance, never a service: the retry-action modal renders its own `spark-po-form`, and a
-     * refresh may carry a retry operation — so a refresh can open a modal containing a form that
-     * refreshes. A shared coordinator would let the nested form supersede this one's request.
-     */
-    protected readonly refreshCoordinator: RefreshCoordinator;
-    private buildRefreshPayload;
-    /**
-     * The values to post, with the open modal's working copy substituted for the attribute it edits.
-     *
-     * ⚠️ Without this the server receives the embedded object as it was when the modal opened — `{}`
-     * for a gate that has never been set — and the hook decides against values the user cannot see it
-     * ignoring. `formData` deliberately does not hold the in-progress edit (cancelling the modal has
-     * to discard it), so the refresh has to reach into `asDetailFormData` instead. Only the attribute
-     * under edit is substituted; everything else is the form's own state.
-     */
-    private embeddedValues;
-    /**
-     * Folds replaced option lists into the signals the editors already read, so a refreshed dropdown
-     * renders through the same path as a loaded one.
-     *
-     * `undefined` means the hook did not touch this attribute's options and the loaded set stands; an
-     * empty array means it deliberately left none. Collapsing the two would blank every dropdown the
-     * hook never mentioned.
-     */
-    private applyRefreshedOptions;
-    /** Sends anything still pending, so a typed-but-never-blurred trigger is reflected before save. */
-    flushPendingRefresh(): Promise<void>;
-    onSave(): Promise<void>;
-    onCancel(): void;
-    openAsDetailEditor(attr: EntityAttributeDefinition): void;
-    saveAsDetailObject(): void;
-    closeAsDetailModal(): void;
-    /**
-     * Whether `attr`'s row type asks the server before a row is added or removed.
-     *
-     * Read off the ROW type, never the parent. `asDetailTypes` already resolves it from the Query-gated
-     * catalogue first and the parent's `detailTypes` second, and the flag survives the server-side
-     * pruning of the embedded copy, so both sources give the same answer.
-     */
-    private roundTripsRowLifecycle;
-    /** The type id to address the row type by on the wire. */
-    private rowTypeId;
-    /**
-     * How to name the PARENT's type on the wire.
-     *
-     * ⚠️ The fallback must be the type **id**, never `clrType`. The server resolves this through
-     * `ModelLoader.ResolveEntityType`, which accepts a GUID or a declared alias and nothing else — so
-     * a CLR name resolves to null and the request is refused, indistinguishably from an unknown type.
-     * The user would see "the server refused this change" on a perfectly ordinary Add.
-     *
-     * It is a live path, not a theoretical one: `spark-po-create` binds no `parentType` (there is no
-     * parent route segment on a create page), so every host that creates an object with an opted-in
-     * detail grid lands here.
-     */
-    private parentTypeForWire;
-    /**
-     * Builds the dict a new row starts from: `{}` as before, or the object the server constructed.
-     *
-     * Returns null when the server refused — the caller must then add nothing, which is the whole
-     * difference between a veto and a message.
-     */
-    private buildNewRow;
-    /**
-     * Asks whether a stored row may be removed. True when it may — including every case where there
-     * is nothing to ask about: a type that has not opted in, a parent that has never been saved, or a
-     * row with no key yet because it was added in this same editing session and never persisted.
-     */
-    private mayRemoveRow;
-    /**
-     * Turns a rejected lifecycle call into something the user can read.
-     *
-     * The envelope puts validation errors under `result`, the same place the save path reads them
-     * from — reading `error.error.errors` matched nothing and made every veto silent.
-     */
-    private clearRowLifecycleError;
-    private captureRowLifecycleError;
-    addInlineRow(attr: EntityAttributeDefinition): Promise<void>;
-    addArrayItem(attr: EntityAttributeDefinition): Promise<void>;
-    editArrayItem(attr: EntityAttributeDefinition, index: number): void;
-    removeArrayItem(attr: EntityAttributeDefinition, index: number): Promise<void>;
-    onAsDetailReorder(attr: EntityAttributeDefinition, event: CdkDragDrop<Record<string, any>[]>): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkPoFormComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkPoFormComponent, "spark-po-form", never, { "entityType": { "alias": "entityType"; "required": false; "isSignal": true; }; "formData": { "alias": "formData"; "required": false; "isSignal": true; }; "validationErrors": { "alias": "validationErrors"; "required": false; "isSignal": true; }; "showButtons": { "alias": "showButtons"; "required": false; "isSignal": true; }; "isSaving": { "alias": "isSaving"; "required": false; "isSignal": true; }; "parentId": { "alias": "parentId"; "required": false; "isSignal": true; }; "parentType": { "alias": "parentType"; "required": false; "isSignal": true; }; "objectTypeId": { "alias": "objectTypeId"; "required": false; "isSignal": true; }; "objectId": { "alias": "objectId"; "required": false; "isSignal": true; }; "triggerPathPrefix": { "alias": "triggerPathPrefix"; "required": false; "isSignal": true; }; "refreshOverlay": { "alias": "refreshOverlay"; "required": false; "isSignal": true; }; }, { "formData": "formDataChange"; "save": "save"; "cancel": "cancel"; "nestedTriggerRequested": "nestedTriggerRequested"; "nestedTriggerBlurred": "nestedTriggerBlurred"; "refreshOverlay": "refreshOverlayChange"; }, never, never, true, never>;
+export declare class SparkPoFormComponent {
+  private readonly sparkService;
+  private readonly translations;
+  protected readonly rendererRegistry: import("@mintplayer/ng-spark/renderers").SparkAttributeRendererRegistration[];
+  entityType: import("@angular/core").InputSignal<EntityType | null>;
+  formData: import("@angular/core").ModelSignal<Record<string, any>>;
+  validationErrors: import("@angular/core").InputSignal<ValidationError[]>;
+  showButtons: import("@angular/core").InputSignal<boolean>;
+  isSaving: import("@angular/core").InputSignal<boolean>;
+  parentId: import("@angular/core").InputSignal<string | undefined>;
+  parentType: import("@angular/core").InputSignal<string | undefined>;
+  save: import("@angular/core").OutputEmitterRef<void>;
+  cancel: import("@angular/core").OutputEmitterRef<void>;
+  /**
+   * The type id to refresh against. Absent means refresh is unavailable — the form still renders and
+   * edits normally, so a host that has not opted in loses nothing.
+   */
+  objectTypeId: import("@angular/core").InputSignal<string | undefined>;
+  /** The id of the object being edited; absent for a create. */
+  objectId: import("@angular/core").InputSignal<string | undefined>;
+  /**
+   * Set when this form renders a single embedded AsDetail object inside a host form: the name of
+   * the attribute holding it, e.g. `"Gate"`. Presence of a prefix switches the form from issuing
+   * its own refreshes to reporting them upward, because an embedded object is not something the
+   * server can be asked about on its own — the request must describe, and be authorized against,
+   * the object that owns it.
+   */
+  triggerPathPrefix: import("@angular/core").InputSignal<string | null>;
+  /** Raised instead of self-issuing when {@link triggerPathPrefix} is set. */
+  nestedTriggerRequested: import("@angular/core").OutputEmitterRef<NestedTriggerRequest>;
+  /** Blur counterpart, flushing a trigger the host only marked pending. */
+  nestedTriggerBlurred: import("@angular/core").OutputEmitterRef<string>;
+  /**
+   * What the last refresh changed about each attribute's presentation, keyed by attribute name.
+   *
+   * Deliberately NOT folded back into `entityType`. All option loading hangs off one effect keyed on
+   * `entityType` identity and `SparkService` caches nothing, so re-setting it would re-issue every
+   * reference query and lookup fetch on every refresh; mutating it in place would not re-render at
+   * all.
+   *
+   * ⚠️ A `model`, not a plain signal, because the page that owns the save has to see it. This form
+   * renders from the overlaid attribute list; `spark-po-edit` and `spark-po-create` build the
+   * payload from their own copy of the same filter. While the overlay stopped here, those two
+   * filtered on the attribute's state *as loaded* — so an attribute a refresh hook revealed was
+   * rendered, filled in by the user, and then silently left out of the save. When the same hook also
+   * made it required (the ordinary case — a field appears *because* it is now needed) the server
+   * refused the save for the very field the user had just filled, and the form became a dead end
+   * with no way forward from inside it.
+   */
+  refreshOverlay: import("@angular/core").ModelSignal<RefreshOverlay>;
+  isRefreshing: import("@angular/core").WritableSignal<boolean>;
+  colors: typeof Color;
+  referenceOptions: import("@angular/core").WritableSignal<Record<string, QueryResultItem[]>>;
+  referenceProviders: import("@angular/core").WritableSignal<Record<string, InMemoryTreeSelectProvider>>;
+  referenceNodes: import("@angular/core").WritableSignal<Record<string, Record<string, TreeNode>>>;
+  asDetailTypes: import("@angular/core").WritableSignal<Record<string, EntityType>>;
+  lookupReferenceOptions: import("@angular/core").WritableSignal<Record<string, LookupReference>>;
+  editingAsDetailAttr: import("@angular/core").WritableSignal<EntityAttributeDefinition | null>;
+  asDetailFormData: import("@angular/core").WritableSignal<Record<string, any>>;
+  showAsDetailModal: import("@angular/core").WritableSignal<boolean>;
+  editingArrayIndex: import("@angular/core").WritableSignal<number | null>;
+  asDetailPermissions: import("@angular/core").WritableSignal<Record<string, EntityPermissions>>;
+  /**
+   * What the server said when it refused to construct or release a row.
+   *
+   * A local signal rather than the `validationErrors` input, because this is the one class of error
+   * the form raises on its own behalf: `validationErrors` is owned by the host (po-edit / po-create)
+   * and arrives from a save. Cleared at the start of each lifecycle call, so a stale refusal never
+   * outlives the click that caused it.
+   *
+   * Keyed by attribute name so a message renders against the grid it came from. A single global
+   * alert would have been less code and worse: a form with two detail grids would show one grid's
+   * refusal above the other, and the user's next click is on the grid, not the top of the page.
+   */
+  rowLifecycleErrors: import("@angular/core").WritableSignal<Record<string, ValidationError[]>>;
+  /** The refusal to render under `attrName`'s grid, if any. */
+  rowLifecycleErrorsFor(attrName: string): ValidationError[];
+  asDetailReferenceOptions: import("@angular/core").WritableSignal<Record<string, Record<string, QueryResultItem[]>>>;
+  ELookupDisplayType: typeof ELookupDisplayType;
+  EReferenceDisplayType: typeof EReferenceDisplayType;
+  /**
+   * Every attribute this form could ever need option data for — including ones the model hides,
+   * because a refresh may reveal them.
+   *
+   * Read by the option-loading effect, and deliberately independent of `refreshOverlay`: the loaders
+   * read this synchronously, so an overlay dependency here would make every refresh re-issue every
+   * reference query and lookup fetch. That is the whole reason the overlay is a separate signal.
+   */
+  optionSourceAttributes: import("@angular/core").Signal<EntityAttributeDefinition[]>;
+  editableAttributes: import("@angular/core").Signal<EntityAttributeDefinition[]>;
+  private static readonly DEFAULT_TAB;
+  ungroupedAttributes: import("@angular/core").Signal<EntityAttributeDefinition[]>;
+  resolvedTabs: import("@angular/core").Signal<AttributeTab[]>;
+  groupsForTab(tab: AttributeTab): AttributeGroup[];
+  attrsForGroup(group: AttributeGroup): EntityAttributeDefinition[];
+  constructor();
+  private toRecord;
+  loadReferenceOptions(): Promise<void>;
+  /**
+   * Stable TreeNode[] value per multi-reference attribute, derived from the id array
+   * in formData and the resolved node map. Recomputes only when formData or the node
+   * map changes, so binding it into <bs-tree-select> doesn't churn on every CD pass.
+   * Ids without a resolved node fall back to a label of the id itself.
+   */
+  referenceTreeValues: import("@angular/core").Signal<Record<string, TreeNode[]>>;
+  getReferenceProvider(attr: EntityAttributeDefinition): InMemoryTreeSelectProvider | undefined;
+  onReferenceTreeChange(attr: EntityAttributeDefinition, value: TreeNode | TreeNode[] | null): void;
+  loadAsDetailTypes(): Promise<void>;
+  loadLookupReferenceOptions(): Promise<void>;
+  getLookupOptions(attr: EntityAttributeDefinition): LookupReferenceValue[];
+  onReferenceValueChange(attr: EntityAttributeDefinition, id: string | null): void;
+  onLookupValueChange(attr: EntityAttributeDefinition, key: string | null): void;
+  getEditRendererComponent(attr: EntityAttributeDefinition): Type<any> | null;
+  getEditRendererInputs(component: Type<any>, attr: EntityAttributeDefinition): Record<string, any>;
+  /** Column renderer for a cell of an AsDetail sub-table (so embedded rows honor `col.renderer` too). */
+  getAsDetailCellRendererComponent(col: EntityAttributeDefinition): Type<any> | null;
+  /** Inputs of an AsDetail row renderer (`rowComponent`): the row and the object being edited. */
+  getRowRendererInputs(renderer: SparkResolvedRowRenderer, row: Record<string, any>): Record<string, any>;
+  getAsDetailCellRendererInputs(component: Type<any>, row: Record<string, any>, col: EntityAttributeDefinition): Record<string, any>;
+  /** Edit-renderer for an inline AsDetail cell (so inline editing honors `col.renderer`, not just display). */
+  getAsDetailCellEditRenderer(col: EntityAttributeDefinition): Type<any> | null;
+  getAsDetailCellEditRendererInputs(component: Type<any>, row: Record<string, any>, col: EntityAttributeDefinition): Record<string, any>;
+  /**
+   * Rules evaluated in the browser, against the *effective* metadata — so a rule a refresh hook
+   * imposed is visible before the round-trip rather than only after the server rejects the save.
+   */
+  clientRuleFailures: import("@angular/core").Signal<RuleFailure[]>;
+  hasError(attrName: string): boolean;
+  private inlineErrorPath;
+  hasInlineError(attr: EntityAttributeDefinition, rowIndex: number, col: EntityAttributeDefinition): boolean;
+  inlineErrorMessage(attr: EntityAttributeDefinition, rowIndex: number, col: EntityAttributeDefinition): string | null;
+  /**
+   * The single funnel every scalar / boolean / inline-cell edit passes through.
+   *
+   * `attr` is optional because some editors have nothing useful to say about which attribute moved.
+   * A caller that knows should always say so — without it no refresh can fire.
+   */
+  onFieldChange(attr?: EntityAttributeDefinition): void;
+  /**
+   * A trigger inside an AsDetail row. Addressed by the same `{attr}[{index}].{col}` path the inline
+   * validation errors already use, so the server can tell which row asked without a second
+   * addressing scheme being invented for it.
+   */
+  onInlineCellChange(attr: EntityAttributeDefinition, rowIndex: number, col: EntityAttributeDefinition): void;
+  /**
+   * Which embedded target the in-flight refresh belongs to, if any.
+   *
+   * ⚠️ Tagged, not a nullable `rowIndex`. The two arms write to different places — a row inside
+   * `formData`, versus the modal's working copy in `asDetailFormData` — and an index that happens
+   * to be absent is not the same statement as "this attribute holds one object". With a nullable
+   * index, a row refresh carrying a bad index would fall silently into the object arm.
+   */
+  private pendingNestedTrigger;
+  /**
+   * A trigger inside a single embedded AsDetail object, raised by the modal's recursive form.
+   *
+   * The child form does not issue the request itself, for two reasons that both bite. Its
+   * `entityType` is the embedded type, so a payload built there describes `GateSettings` while the
+   * request must describe the Repository that owns it. And nested AsDetail types carry no rights of
+   * their own — the server authorizes a nested refresh on the OWNING type — so a child-issued
+   * request would be asking the wrong question of security.json.
+   */
+  onEmbeddedTrigger(attributeName: string, event: NestedTriggerRequest): void;
+  /** Blur counterpart of {@link onEmbeddedTrigger}, for the child's free-text editors. */
+  onEmbeddedTriggerBlur(path: string): void;
+  /**
+   * Applies a refresh that ran against a detail row: the row's own values, and the column metadata
+   * for the grid it lives in.
+   *
+   * The column metadata comes from `asDetailTypes` — a different signal from `entityType` — which is
+   * why a nested response cannot go through the top-level overlay.
+   *
+   * ⚠️ The row array is mutated in place rather than replaced. Rows are tracked by index, so handing
+   * the template a new array destroys and rebuilds every row's DOM and takes focus with it, mid-edit.
+   */
+  private applyNestedResponse;
+  onInlineCellBlur(attr: EntityAttributeDefinition, rowIndex: number, col: EntityAttributeDefinition): void;
+  /**
+   * Blur handler for free-text editors — sends the refresh their keystrokes only marked pending, or
+   * cuts short a `ValueChanged` debounce that is still waiting.
+   */
+  onFieldBlur(attr: EntityAttributeDefinition): void;
+  private noteChange;
+  /** `Gate.ProjectMode` — the index-free counterpart of the inline grid's `Jobs[1].Kind`. */
+  private nestedTriggerPath;
+  private canRefresh;
+  /**
+   * Per-instance, never a service: the retry-action modal renders its own `spark-po-form`, and a
+   * refresh may carry a retry operation — so a refresh can open a modal containing a form that
+   * refreshes. A shared coordinator would let the nested form supersede this one's request.
+   */
+  protected readonly refreshCoordinator: RefreshCoordinator;
+  private buildRefreshPayload;
+  /**
+   * The values to post, with the open modal's working copy substituted for the attribute it edits.
+   *
+   * ⚠️ Without this the server receives the embedded object as it was when the modal opened — `{}`
+   * for a gate that has never been set — and the hook decides against values the user cannot see it
+   * ignoring. `formData` deliberately does not hold the in-progress edit (cancelling the modal has
+   * to discard it), so the refresh has to reach into `asDetailFormData` instead. Only the attribute
+   * under edit is substituted; everything else is the form's own state.
+   */
+  private embeddedValues;
+  /**
+   * Folds replaced option lists into the signals the editors already read, so a refreshed dropdown
+   * renders through the same path as a loaded one.
+   *
+   * `undefined` means the hook did not touch this attribute's options and the loaded set stands; an
+   * empty array means it deliberately left none. Collapsing the two would blank every dropdown the
+   * hook never mentioned.
+   */
+  private applyRefreshedOptions;
+  /** Sends anything still pending, so a typed-but-never-blurred trigger is reflected before save. */
+  flushPendingRefresh(): Promise<void>;
+  onSave(): Promise<void>;
+  onCancel(): void;
+  openAsDetailEditor(attr: EntityAttributeDefinition): void;
+  saveAsDetailObject(): void;
+  closeAsDetailModal(): void;
+  /**
+   * Whether `attr`'s row type asks the server before a row is added or removed.
+   *
+   * Read off the ROW type, never the parent. `asDetailTypes` already resolves it from the Query-gated
+   * catalogue first and the parent's `detailTypes` second, and the flag survives the server-side
+   * pruning of the embedded copy, so both sources give the same answer.
+   */
+  private roundTripsRowLifecycle;
+  /** The type id to address the row type by on the wire. */
+  private rowTypeId;
+  /**
+   * How to name the PARENT's type on the wire.
+   *
+   * ⚠️ The fallback must be the type **id**, never `clrType`. The server resolves this through
+   * `ModelLoader.ResolveEntityType`, which accepts a GUID or a declared alias and nothing else — so
+   * a CLR name resolves to null and the request is refused, indistinguishably from an unknown type.
+   * The user would see "the server refused this change" on a perfectly ordinary Add.
+   *
+   * It is a live path, not a theoretical one: `spark-po-create` binds no `parentType` (there is no
+   * parent route segment on a create page), so every host that creates an object with an opted-in
+   * detail grid lands here.
+   */
+  private parentTypeForWire;
+  /**
+   * Builds the dict a new row starts from: `{}` as before, or the object the server constructed.
+   *
+   * Returns null when the server refused — the caller must then add nothing, which is the whole
+   * difference between a veto and a message.
+   */
+  private buildNewRow;
+  /**
+   * Asks whether a stored row may be removed. True when it may — including every case where there
+   * is nothing to ask about: a type that has not opted in, a parent that has never been saved, or a
+   * row with no key yet because it was added in this same editing session and never persisted.
+   */
+  private mayRemoveRow;
+  /**
+   * Turns a rejected lifecycle call into something the user can read.
+   *
+   * The envelope puts validation errors under `result`, the same place the save path reads them
+   * from — reading `error.error.errors` matched nothing and made every veto silent.
+   */
+  private clearRowLifecycleError;
+  private captureRowLifecycleError;
+  addInlineRow(attr: EntityAttributeDefinition): Promise<void>;
+  addArrayItem(attr: EntityAttributeDefinition): Promise<void>;
+  editArrayItem(attr: EntityAttributeDefinition, index: number): void;
+  removeArrayItem(attr: EntityAttributeDefinition, index: number): Promise<void>;
+  onAsDetailReorder(attr: EntityAttributeDefinition, event: CdkDragDrop<Record<string, any>[]>): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkPoFormComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkPoFormComponent, "spark-po-form", never, {
+    "entityType": {
+      "alias": "entityType";
+      "required": false;
+      "isSignal": true;
+    };
+    "formData": {
+      "alias": "formData";
+      "required": false;
+      "isSignal": true;
+    };
+    "validationErrors": {
+      "alias": "validationErrors";
+      "required": false;
+      "isSignal": true;
+    };
+    "showButtons": {
+      "alias": "showButtons";
+      "required": false;
+      "isSignal": true;
+    };
+    "isSaving": {
+      "alias": "isSaving";
+      "required": false;
+      "isSignal": true;
+    };
+    "parentId": {
+      "alias": "parentId";
+      "required": false;
+      "isSignal": true;
+    };
+    "parentType": {
+      "alias": "parentType";
+      "required": false;
+      "isSignal": true;
+    };
+    "objectTypeId": {
+      "alias": "objectTypeId";
+      "required": false;
+      "isSignal": true;
+    };
+    "objectId": {
+      "alias": "objectId";
+      "required": false;
+      "isSignal": true;
+    };
+    "triggerPathPrefix": {
+      "alias": "triggerPathPrefix";
+      "required": false;
+      "isSignal": true;
+    };
+    "refreshOverlay": {
+      "alias": "refreshOverlay";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "formData": "formDataChange";
+    "save": "save";
+    "cancel": "cancel";
+    "nestedTriggerRequested": "nestedTriggerRequested";
+    "nestedTriggerBlurred": "nestedTriggerBlurred";
+    "refreshOverlay": "refreshOverlayChange";
+  }, never, never, true, never>;
 }
-
 /**
  * Reusable Reference value picker: a readonly textbox showing the current selection's
  * breadcrumb/name plus a "…" button that opens a searchable modal grid over the candidate
@@ -344,70 +472,127 @@ declare class SparkPoFormComponent {
  * CLR type); the component lazily loads that EntityType's metadata on first open to render
  * the grid's column headers. Emits the picked id via `valueChange`.
  */
-declare class SparkReferencePickerComponent {
-    private readonly sparkService;
-    private readonly lang;
-    /** Currently selected referenced id (or null when unset). */
-    value: _angular_core.InputSignal<string | null>;
-    /** Candidate items to pick from (the full query result, pre-loaded by the parent). */
-    options: _angular_core.InputSignal<QueryResultItem[]>;
-    /** Target entity type's CLR type name; used to load the grid's column headers. */
-    referenceType: _angular_core.InputSignal<string | undefined>;
-    /** Renders the field with the Bootstrap is-invalid state. */
-    isInvalid: _angular_core.InputSignal<boolean>;
-    /** Optional id forwarded to the readonly input (for label association). */
-    inputId: _angular_core.InputSignal<string | undefined>;
-    /** Optional resolved label appended to the modal header ("Select {title}"). */
-    title: _angular_core.InputSignal<string>;
-    valueChange: _angular_core.OutputEmitterRef<string | null>;
-    colors: typeof Color;
-    showModal: _angular_core.WritableSignal<boolean>;
-    entityType: _angular_core.WritableSignal<EntityType | null>;
-    pagination: _angular_core.WritableSignal<PaginationResponse<QueryResultItem> | undefined>;
-    settings: _angular_core.WritableSignal<DatatableSettings>;
-    searchTerm: string;
-    visibleAttributes: _angular_core.Signal<_mintplayer_ng_spark_models.EntityAttributeDefinition[]>;
-    rows: _angular_core.Signal<QueryResultItem[]>;
-    displayValue: _angular_core.Signal<string>;
-    open(): Promise<void>;
-    onSearchChange(): void;
-    applyFilter(): void;
-    clearSearch(): void;
-    select(item: QueryResultItem): void;
-    close(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkReferencePickerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkReferencePickerComponent, "spark-reference-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "referenceType": { "alias": "referenceType"; "required": false; "isSignal": true; }; "isInvalid": { "alias": "isInvalid"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+export declare class SparkReferencePickerComponent {
+  private readonly sparkService;
+  private readonly lang;
+  /** Currently selected referenced id (or null when unset). */
+  value: import("@angular/core").InputSignal<string | null>;
+  /** Candidate items to pick from (the full query result, pre-loaded by the parent). */
+  options: import("@angular/core").InputSignal<QueryResultItem[]>;
+  /** Target entity type's CLR type name; used to load the grid's column headers. */
+  referenceType: import("@angular/core").InputSignal<string | undefined>;
+  /** Renders the field with the Bootstrap is-invalid state. */
+  isInvalid: import("@angular/core").InputSignal<boolean>;
+  /** Optional id forwarded to the readonly input (for label association). */
+  inputId: import("@angular/core").InputSignal<string | undefined>;
+  /** Optional resolved label appended to the modal header ("Select {title}"). */
+  title: import("@angular/core").InputSignal<string>;
+  valueChange: import("@angular/core").OutputEmitterRef<string | null>;
+  colors: typeof Color;
+  showModal: import("@angular/core").WritableSignal<boolean>;
+  entityType: import("@angular/core").WritableSignal<EntityType | null>;
+  pagination: import("@angular/core").WritableSignal<PaginationResponse<QueryResultItem> | undefined>;
+  settings: import("@angular/core").WritableSignal<DatatableSettings>;
+  searchTerm: string;
+  visibleAttributes: import("@angular/core").Signal<import("@mintplayer/ng-spark/models").EntityAttributeDefinition[]>;
+  rows: import("@angular/core").Signal<QueryResultItem[]>;
+  displayValue: import("@angular/core").Signal<string>;
+  open(): Promise<void>;
+  onSearchChange(): void;
+  applyFilter(): void;
+  clearSearch(): void;
+  select(item: QueryResultItem): void;
+  close(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkReferencePickerComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkReferencePickerComponent, "spark-reference-picker", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": false;
+      "isSignal": true;
+    };
+    "referenceType": {
+      "alias": "referenceType";
+      "required": false;
+      "isSignal": true;
+    };
+    "isInvalid": {
+      "alias": "isInvalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "inputId": {
+      "alias": "inputId";
+      "required": false;
+      "isSignal": true;
+    };
+    "title": {
+      "alias": "title";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "valueChange": "valueChange";
+  }, never, never, true, never>;
 }
-
 /**
  * Reusable LookupReference value picker: a readonly textbox showing the current selection's
  * translated label plus a "…" button that opens a searchable modal list over the active
  * `options`. Per-instance state, so it serves both top-level lookup attributes (display type
  * Modal) and individual inline AsDetail lookup cells. Emits the picked key via `valueChange`.
  */
-declare class SparkLookupPickerComponent {
-    /** Currently selected lookup key (or null when unset). */
-    value: _angular_core.InputSignal<string | null>;
-    /** Active lookup values to pick from. */
-    options: _angular_core.InputSignal<LookupReferenceValue[]>;
-    /** Renders the field with the Bootstrap is-invalid state. */
-    isInvalid: _angular_core.InputSignal<boolean>;
-    /** Optional id forwarded to the readonly input (for label association). */
-    inputId: _angular_core.InputSignal<string | undefined>;
-    /** Optional resolved label appended to the modal header ("Select {title}"). */
-    title: _angular_core.InputSignal<string>;
-    valueChange: _angular_core.OutputEmitterRef<string | null>;
-    colors: typeof Color;
-    showModal: _angular_core.WritableSignal<boolean>;
-    searchTerm: _angular_core.WritableSignal<string>;
-    displayValue: _angular_core.Signal<string>;
-    filteredItems: _angular_core.Signal<LookupReferenceValue[]>;
-    open(): void;
-    select(item: LookupReferenceValue): void;
-    close(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkLookupPickerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkLookupPickerComponent, "spark-lookup-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "isInvalid": { "alias": "isInvalid"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
-}
-
-export { SparkLookupPickerComponent, SparkPoFormComponent, SparkReferencePickerComponent };
-export type { NestedTriggerRequest };
+export declare class SparkLookupPickerComponent {
+  /** Currently selected lookup key (or null when unset). */
+  value: import("@angular/core").InputSignal<string | null>;
+  /** Active lookup values to pick from. */
+  options: import("@angular/core").InputSignal<LookupReferenceValue[]>;
+  /** Renders the field with the Bootstrap is-invalid state. */
+  isInvalid: import("@angular/core").InputSignal<boolean>;
+  /** Optional id forwarded to the readonly input (for label association). */
+  inputId: import("@angular/core").InputSignal<string | undefined>;
+  /** Optional resolved label appended to the modal header ("Select {title}"). */
+  title: import("@angular/core").InputSignal<string>;
+  valueChange: import("@angular/core").OutputEmitterRef<string | null>;
+  colors: typeof Color;
+  showModal: import("@angular/core").WritableSignal<boolean>;
+  searchTerm: import("@angular/core").WritableSignal<string>;
+  displayValue: import("@angular/core").Signal<string>;
+  filteredItems: import("@angular/core").Signal<LookupReferenceValue[]>;
+  open(): void;
+  select(item: LookupReferenceValue): void;
+  close(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkLookupPickerComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkLookupPickerComponent, "spark-lookup-picker", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": false;
+      "isSignal": true;
+    };
+    "isInvalid": {
+      "alias": "isInvalid";
+      "required": false;
+      "isSignal": true;
+    };
+    "inputId": {
+      "alias": "inputId";
+      "required": false;
+      "isSignal": true;
+    };
+    "title": {
+      "alias": "title";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "valueChange": "valueChange";
+  }, never, never, true, never>;
+}