@zeyos/zx 4.3.0 → 4.4.0

package/dist/types/components/filter-panel/filter-panel.d.ts

@@ -0,0 +1,449 @@
+import { Component } from '../../core/component.js';
+import { NumberField } from '../number-field/number-field.js';
+export type FilterPanelEdge = 'from' | 'to';
+export type FilterPanelKind = 'text' | 'select' | 'date' | 'number';
+export type FilterPanelMode = 'draft' | 'live';
+export type FilterPanelSerialize = 'seconds' | 'ms' | 'iso' | ((date: Date, edge: FilterPanelEdge) => unknown);
+export type FilterPanelOption = {
+    /**
+     * Option value, emitted unchanged.
+     */
+    value: unknown;
+    /**
+     * Visible label; defaults to the value.
+     */
+    label?: string;
+};
+export type FilterPanelField = {
+    /**
+     * One of `text`, `select`, `date`, `date:range`, `int`, `float`, `number`,
+     * `int:range`, `float:range`, `number:range`. Any other type renders as a labelled placeholder
+     * naming it and is left out of the value.
+     */
+    type: string;
+    /**
+     * Visible filter name; defaults to the field key.
+     */
+    label?: string;
+    /**
+     * Select
+     * options. `{value, label}` and `{ID, name}` are both understood, as are bare primitives.
+     */
+    options?: Array<FilterPanelOption | Record<string, unknown> | string | number>;
+    /**
+     * Lowest accepted number, applied to both range edges.
+     */
+    min?: number | null;
+    /**
+     * Highest accepted number, applied to both range edges.
+     */
+    max?: number | null;
+    /**
+     * Number increment; defaults to 1 for `int` and 0.01 for `float`.
+     */
+    step?: number;
+    /**
+     * Placeholder for the text and number inputs.
+     */
+    placeholder?: string;
+    /**
+     * Forces the select filter's search box on or off, overriding the
+     * eight-option threshold.
+     */
+    search?: boolean;
+};
+export type FilterPanelSpec = {
+    /**
+     * Control family the type belongs to.
+     */
+    kind: FilterPanelKind;
+    /**
+     * Whether the type carries a `from`/`to` pair.
+     */
+    range: boolean;
+    /**
+     * Whether a number type is whole-valued.
+     */
+    integer: boolean;
+};
+export type FilterPanelApplyDetail = {
+    /**
+     * Committed filter values, pruned and serialized.
+     */
+    value: Record<string, unknown>;
+};
+export type FilterPanelChangeDetail = {
+    /**
+     * The draft as it would be applied.
+     */
+    value: Record<string, unknown>;
+    /**
+     * Field that moved, or null when the whole value was replaced.
+     */
+    field: string | null;
+};
+export type FilterPanelOptions = {
+    /**
+     * Field metadata exactly as a list
+     * response publishes it. An empty map is the ordinary case, not an error: it renders `emptyText`.
+     */
+    fields?: Record<string, FilterPanelField>;
+    /**
+     * Display order by field key; omitted keeps object order.
+     * Keys the map does not declare are ignored, and fields the order omits follow in map order.
+     */
+    order?: string[] | null;
+    /**
+     * Applied filters. The draft starts as a copy.
+     */
+    value?: Record<string, unknown>;
+    /**
+     * `'draft'` collects edits until `apply()`; `'live'`
+     * applies every committed edit.
+     */
+    mode?: FilterPanelMode;
+    /**
+     * How a date leaves the component. A range's
+     * lower bound takes the start of its day and its upper bound the end, so a one-day range matches.
+     */
+    serialize?: FilterPanelSerialize;
+    /**
+     * Text shown when `fields` is empty; null resolves
+     * `filterPanel.empty`.
+     */
+    emptyText?: string | null;
+    /**
+     * Localized messages.
+     */
+    msg?: Record<string, string> | Record<string, Record<string, string>>;
+    /**
+     * Apply listener.
+     */
+    onapply?: (event: CustomEvent<FilterPanelApplyDetail>) => void;
+    /**
+     * Change listener.
+     */
+    onchange?: (event: CustomEvent<FilterPanelChangeDetail>) => void;
+};
+/** @typedef {'from'|'to'} FilterPanelEdge */
+/** @typedef {'text'|'select'|'date'|'number'} FilterPanelKind */
+/** @typedef {'draft'|'live'} FilterPanelMode */
+/** @typedef {'seconds'|'ms'|'iso'|((date: Date, edge: FilterPanelEdge) => unknown)} FilterPanelSerialize */
+/**
+ * @typedef {Object} FilterPanelOption
+ * @property {unknown} value Option value, emitted unchanged.
+ * @property {string} [label] Visible label; defaults to the value.
+ */
+/**
+ * @typedef {Object} FilterPanelField
+ * @property {string} type One of `text`, `select`, `date`, `date:range`, `int`, `float`, `number`,
+ *   `int:range`, `float:range`, `number:range`. Any other type renders as a labelled placeholder
+ *   naming it and is left out of the value.
+ * @property {string} [label] Visible filter name; defaults to the field key.
+ * @property {Array<FilterPanelOption|Record<string, unknown>|string|number>} [options] Select
+ *   options. `{value, label}` and `{ID, name}` are both understood, as are bare primitives.
+ * @property {number|null} [min] Lowest accepted number, applied to both range edges.
+ * @property {number|null} [max] Highest accepted number, applied to both range edges.
+ * @property {number} [step] Number increment; defaults to 1 for `int` and 0.01 for `float`.
+ * @property {string} [placeholder] Placeholder for the text and number inputs.
+ * @property {boolean} [search] Forces the select filter's search box on or off, overriding the
+ *   eight-option threshold.
+ */
+/**
+ * @typedef {Object} FilterPanelSpec
+ * @property {FilterPanelKind} kind Control family the type belongs to.
+ * @property {boolean} range Whether the type carries a `from`/`to` pair.
+ * @property {boolean} integer Whether a number type is whole-valued.
+ */
+/**
+ * @typedef {Object} FilterPanelApplyDetail
+ * @property {Record<string, unknown>} value Committed filter values, pruned and serialized.
+ */
+/**
+ * @typedef {Object} FilterPanelChangeDetail
+ * @property {Record<string, unknown>} value The draft as it would be applied.
+ * @property {string|null} field Field that moved, or null when the whole value was replaced.
+ */
+/**
+ * @typedef {Object} FilterPanelOptions
+ * @property {Record<string, FilterPanelField>} [fields={}] Field metadata exactly as a list
+ *   response publishes it. An empty map is the ordinary case, not an error: it renders `emptyText`.
+ * @property {string[]|null} [order=null] Display order by field key; omitted keeps object order.
+ *   Keys the map does not declare are ignored, and fields the order omits follow in map order.
+ * @property {Record<string, unknown>} [value={}] Applied filters. The draft starts as a copy.
+ * @property {FilterPanelMode} [mode='draft'] `'draft'` collects edits until `apply()`; `'live'`
+ *   applies every committed edit.
+ * @property {FilterPanelSerialize} [serialize='seconds'] How a date leaves the component. A range's
+ *   lower bound takes the start of its day and its upper bound the end, so a one-day range matches.
+ * @property {string|null} [emptyText=null] Text shown when `fields` is empty; null resolves
+ *   `filterPanel.empty`.
+ * @property {Record<string, string>|Record<string, Record<string, string>>} [msg] Localized messages.
+ * @property {(event: CustomEvent<FilterPanelApplyDetail>) => void} [onapply] Apply listener.
+ * @property {(event: CustomEvent<FilterPanelChangeDetail>) => void} [onchange] Change listener.
+ */
+/**
+ * Declarative filter form built from the field metadata a list endpoint publishes, producing the
+ * query object that endpoint expects back.
+ *
+ * It is neither of the other two filter components: `DataFilter` filters rows that are already in
+ * the browser, and `Filter` builds an operator AST. This one turns `{key: {type, label, options}}`
+ * into controls and gives back `{key: value}` — pruned to the constraints that are actually set,
+ * with `0` counted as one of them.
+ *
+ * Draft mode is the default because a control that applies on change reflows the list underneath
+ * the panel being read, and costs a request per edit. `'live'` is the deliberate opt-in.
+ *
+ * Each control family commits at its own natural granularity: text filters on every keystroke,
+ * dates when the picker produces a complete date, checkboxes immediately, and numbers when
+ * `NumberField` commits them (blur, Enter, or a step) rather than half-typed.
+ *
+ * @fires FilterPanel#apply
+ * @fires FilterPanel#change
+ * @extends {Component<FilterPanelOptions>}
+ */
+export declare class FilterPanel extends Component<FilterPanelOptions> {
+    _createdRoot: boolean;
+    _snapshot: import("../../core/dom.js").TargetSnapshot;
+    _restored: boolean;
+    _entries: any[];
+    _children: any[];
+    _writing: boolean;
+    _draft: {};
+    _applied: {};
+    _appliedDraft: string;
+    _fields: {
+        key: string;
+        field: FilterPanelField;
+        spec: FilterPanelSpec | null;
+    }[];
+    static cssName: string;
+    /** @type {FilterPanelOptions} */
+    static defaults: FilterPanelOptions;
+    /** @returns {HTMLElement} Panel root. */
+    render(): HTMLElement;
+    /**
+     * Returns the applied value: only the constraints that are set, with dates serialized through
+     * `serialize`. Unknown field types are never part of it.
+     * @returns {Record<string, unknown>}
+     */
+    getValue(): Record<string, unknown>;
+    /**
+     * Replaces both the applied value and the draft the controls show. Accepts what `getValue()`
+     * returns as well as raw input values, so a value that survived a URL round-trip goes back in.
+     * @param {Record<string, unknown>} value Filter values keyed by field.
+     * @returns {this}
+     * @fires FilterPanel#change
+     */
+    setValue(value: Record<string, unknown>): this;
+    /**
+     * Commits the draft. In live mode every committed edit already does this; calling it directly is
+     * how a host forces a reload with the values that are on screen.
+     * @returns {this}
+     * @fires FilterPanel#apply
+     */
+    apply(): this;
+    /**
+     * Restores the controls to the `value` the panel was constructed with **without committing**, so
+     * the filters in force stay in force. This is the Cancel half of a sheet: the panel goes back to
+     * showing what is being filtered by. Contrast `clear()`, which commits. In live mode there is no
+     * uncommitted draft to hold back, so there it applies like any other edit.
+     * @returns {this}
+     * @fires FilterPanel#change
+     * @fires FilterPanel#apply
+     */
+    reset(): this;
+    /**
+     * Empties every control **and commits**, in both modes. "Clear the filters" has one meaning, and
+     * leaving a list filtered behind a panel showing no filters is not it — the records look missing
+     * and nothing on screen explains why. Contrast `reset()`, which restores the controls without
+     * committing. The price is one unfiltered load at the moment the button is pressed, which is
+     * also the feedback that says the filters are gone.
+     * @returns {this}
+     * @fires FilterPanel#change
+     * @fires FilterPanel#apply
+     */
+    clear(): this;
+    /** Destroys the composed controls and puts an enhanced target back as found. @returns {void} */
+    destroy(): void;
+    /** @returns {HTMLElement} The actions row. */
+    _buildActions(): HTMLElement;
+    /**
+     * @param {string} key Field key.
+     * @param {FilterPanelField} field Field metadata.
+     * @param {FilterPanelSpec|null} spec Resolved type, or null when the type is unknown.
+     * @returns {HTMLElement}
+     */
+    _buildField(key: string, field: FilterPanelField, spec: FilterPanelSpec | null): HTMLElement;
+    /**
+     * @param {string} key Field key.
+     * @param {FilterPanelField} field Field metadata.
+     * @param {string} label Visible filter name.
+     * @returns {Element} The checklist root.
+     */
+    _buildSelect(key: string, field: FilterPanelField, label: string): Element;
+    /**
+     * @param {string} key Field key.
+     * @param {FilterPanelField} field Field metadata.
+     * @param {string} label Visible filter name.
+     * @returns {Element[]}
+     */
+    _buildText(key: string, field: FilterPanelField, label: string): Element[];
+    /**
+     * @param {string} key Field key.
+     * @param {FilterPanelField} field Field metadata.
+     * @param {string} label Visible filter name.
+     * @param {FilterPanelSpec} spec Resolved type.
+     * @returns {Element[]}
+     */
+    _buildDate(key: string, field: FilterPanelField, label: string, spec: FilterPanelSpec): Element[];
+    /**
+     * @param {string} value Initial `YYYY-MM-DD` value.
+     * @param {Record<string, unknown>} props Extra properties.
+     * @returns {HTMLInputElement}
+     */
+    _dateInput(value: string, props: Record<string, unknown>): HTMLInputElement;
+    /**
+     * @param {string} key Field key.
+     * @param {FilterPanelField} field Field metadata.
+     * @param {string} label Visible filter name.
+     * @param {FilterPanelSpec} spec Resolved type.
+     * @returns {Element[]}
+     */
+    _buildNumber(key: string, field: FilterPanelField, label: string, spec: FilterPanelSpec): Element[];
+    /**
+     * @param {FilterPanelField} field Field metadata.
+     * @param {FilterPanelSpec} spec Resolved type.
+     * @param {string} name Accessible name for the spinbutton.
+     * @param {number|null} value Initial value.
+     * @returns {NumberField}
+     */
+    _numberField(field: FilterPanelField, spec: FilterPanelSpec, name: string, value: number | null): NumberField;
+    /** @param {FilterPanelEdge} edge Range edge. @returns {string} */
+    _edgeLabel(edge: FilterPanelEdge): string;
+    /** @param {string} label Filter name. @param {FilterPanelEdge} edge Range edge. @returns {string} */
+    _edgeName(label: string, edge: FilterPanelEdge): string;
+    /** @param {string} key Field key. @param {unknown} value Raw draft value. @returns {void} */
+    _edited(key: string, value: unknown): void;
+    /**
+     * @param {string} key Field key.
+     * @param {FilterPanelEdge} edge Range edge.
+     * @param {unknown} value Raw edge value.
+     * @returns {void}
+     */
+    _editedEdge(key: string, edge: FilterPanelEdge, value: unknown): void;
+    /** @param {string} key Field key. @returns {void} */
+    _afterEdit(key: string): void;
+    /**
+     * Keeps a composed control's own bubbling DOM events off the panel root. `Checklist` and
+     * `NumberField` both emit `zx-change`, which is a name this panel uses with a different detail,
+     * so a host listening on the panel root would otherwise see two shapes of one event. They stay
+     * available on the control's own root, exactly where that control put them.
+     * @param {Component} child Composed control.
+     * @returns {void}
+     */
+    _isolate(child: Component): void;
+    /**
+     * @param {Record<string, unknown>} draft Replacement draft.
+     * @param {{commit?: boolean}} [options={}] Set `commit` to apply the replacement as well.
+     * @returns {this}
+     */
+    _replaceDraft(draft: Record<string, unknown>, { commit }?: {
+        commit?: boolean;
+    }): this;
+    /** @param {Record<string, unknown>} value The draft value becoming the applied one. @returns {void} */
+    _commit(value: Record<string, unknown>): void;
+    /** @returns {Record<string, unknown>} The draft, serialized and pruned. */
+    _draftValue(): Record<string, unknown>;
+    /** Pushes the draft back into the controls without re-entering the edit path. @returns {void} */
+    _writeControls(): void;
+    /** @param {Record<string, unknown>} [value] The draft value, when it is already at hand. @returns {void} */
+    _syncActions(value?: Record<string, unknown>): void;
+    /**
+     * Resolves a message through the host translator, falling back to the built-in English text.
+     * @param {string} key Message key.
+     * @param {string} fallback Built-in text, with `%1`-style placeholders.
+     * @param {...unknown} args Interpolation values.
+     * @returns {string}
+     */
+    _message(key: string, fallback: string, ...args: unknown[]): string;
+}
+/**
+ * Committed filter values, ready to send to the list endpoint. In draft mode this is the Apply
+ * button or `apply()`; in live mode it is every committed edit.
+ * @event FilterPanel#apply
+ * @type {CustomEvent<FilterPanelApplyDetail>}
+ */
+/**
+ * Any change to the draft, with the field that moved (null when the whole value was replaced).
+ * `value` is the draft as it would be applied.
+ * @event FilterPanel#change
+ * @type {CustomEvent<FilterPanelChangeDetail>}
+ */
+/**
+ * Resolves a declared field type. Returns null for a type the panel cannot render, which is what
+ * makes an unknown type a visible placeholder rather than a guess.
+ * @param {unknown} type Declared type.
+ * @returns {FilterPanelSpec|null}
+ */
+export declare function parseFieldType(type: unknown): FilterPanelSpec | null;
+/**
+ * Whether a value is a constraint rather than an absent one. `0` is a value; `''`, `null`,
+ * `undefined`, `NaN`, `[]` and `{from: null, to: null}` are not.
+ * @param {unknown} value Candidate value.
+ * @returns {boolean}
+ */
+export declare function isActiveValue(value: unknown): boolean;
+/**
+ * Drops every entry that is not a constraint, and every inactive edge of a range, so an
+ * open-ended range emits only the bound it has.
+ * @param {Record<string, unknown>} value Candidate values keyed by field.
+ * @returns {Record<string, unknown>}
+ */
+export declare function pruneValue(value: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Converts anything a calendar day can arrive as — a `YYYY-MM-DD` string, an ISO timestamp, a
+ * `Date`, Unix seconds or milliseconds — into the local calendar day a native date input holds.
+ * Numbers below 1e11 are read as seconds, which is the boundary between the two epochs in use.
+ * @param {unknown} value Candidate day.
+ * @returns {string} `YYYY-MM-DD`, or an empty string when there is no day in it.
+ */
+export declare function toDateInput(value: unknown): string;
+/**
+ * Serializes one calendar day at one edge of a range. The `from` edge takes the first instant of
+ * its local day and the `to` edge the last, so a range whose ends name the same day still matches
+ * everything recorded on it.
+ * @param {unknown} day Calendar day in any form `toDateInput()` accepts.
+ * @param {FilterPanelEdge} edge Which end of the range the day is.
+ * @param {FilterPanelSerialize} [serialize='seconds'] Output format, or a function receiving the
+ *   edge instant as a `Date`.
+ * @returns {unknown} The serialized day, or null when there is no day.
+ */
+export declare function serializeDate(day: unknown, edge: FilterPanelEdge, serialize?: FilterPanelSerialize): unknown;
+/**
+ * Normalizes declared select options. `{value, label}`, `{ID, name}`, and bare primitives all
+ * arrive from one instance or another.
+ * @param {unknown} options Declared options.
+ * @returns {Array<{value: unknown, label: string}>}
+ */
+export declare function normalizeOptions(options: unknown): Array<{
+    value: unknown;
+    label: string;
+}>;
+/**
+ * Converts incoming values into the internal draft shape the controls hold: trimmed text, canonical
+ * option values, `YYYY-MM-DD` days, and finite numbers. Fields with an unknown type are left out.
+ * Running it on a draft returns the same draft, so it is safe on either shape.
+ * @param {Record<string, unknown>|null|undefined} value Incoming values keyed by field.
+ * @param {Record<string, FilterPanelField>} fields Field metadata.
+ * @returns {Record<string, unknown>}
+ */
+export declare function toDraft(value: Record<string, unknown> | null | undefined, fields: Record<string, FilterPanelField>): Record<string, unknown>;
+/**
+ * Turns values into the query object a list endpoint is sent: only the constraints that are set,
+ * dates serialized at the right edge, unknown field types excluded.
+ * @param {Record<string, unknown>|null|undefined} value Values keyed by field, raw or drafted.
+ * @param {Record<string, FilterPanelField>} fields Field metadata.
+ * @param {FilterPanelSerialize} [serialize='seconds'] Date output format.
+ * @returns {Record<string, unknown>}
+ */
+export declare function serializeFilterValue(value: Record<string, unknown> | null | undefined, fields: Record<string, FilterPanelField>, serialize?: FilterPanelSerialize): Record<string, unknown>;

package/dist/types/components/kanban-view/kanban-card.d.ts

@@ -0,0 +1,138 @@
+export type KanbanRecord = Record<string, any>;
+export type KanbanIndicator = {
+    /**
+     * Visible text.
+     */
+    label: string;
+    /**
+     * Semantic intent.
+     */
+    tone?: 'neutral' | 'accent' | 'success' | 'warning' | 'danger' | 'info';
+    /**
+     * Optional leading icon name, used instead of the status dot.
+     */
+    icon?: string | null;
+    /**
+     * Whether a leading status dot is drawn.
+     */
+    dot?: boolean;
+    /**
+     * Native title, useful when the label alone is terse.
+     */
+    title?: string;
+};
+export type KanbanProgress = {
+    /**
+     * Completed amount, clamped into `[0, max]`.
+     */
+    value: number;
+    /**
+     * Amount that counts as finished.
+     */
+    max: number;
+    /**
+     * Rounded completion percentage.
+     */
+    percent: number;
+    /**
+     * Visible meter label, or null for the caller's default.
+     */
+    label: string | null;
+};
+export type KanbanAssignee = {
+    /**
+     * Person's name, used as the accessible label.
+     */
+    name: string;
+    /**
+     * Safe image URL, or null for the initials fallback.
+     */
+    src: string | null;
+    /**
+     * Fallback initials.
+     */
+    initials: string;
+};
+/**
+ * Normalizes one indicator value into the descriptor the badge is built from. A plain value
+ * becomes the label and looks its tone up in the supplied map, so an application expresses
+ * "High means danger" as data rather than as a renderer.
+ * @param {unknown} value Raw field value, descriptor, or null.
+ * @param {Record<string, string>} [tones={}] Value-to-tone map.
+ * @returns {KanbanIndicator|null} Descriptor, or null when there is nothing to show.
+ */
+export declare function resolveKanbanIndicator(value: unknown, tones?: Record<string, string>): KanbanIndicator | null;
+/**
+ * Builds one indicator badge.
+ * @param {KanbanIndicator} indicator Normalized descriptor.
+ * @returns {HTMLElement} Badge element.
+ */
+export declare function createKanbanIndicator(indicator: KanbanIndicator): HTMLElement;
+/**
+ * Normalizes a completion value against an explicit scale. The scale is never guessed: a `0.72`
+ * on a 0–100 board is seven-tenths of a percent, and only the application knows which it meant.
+ * @param {unknown} value Raw field value, or `{value, max, label}`.
+ * @param {number} [max=100] Amount that counts as finished.
+ * @returns {KanbanProgress|null} Descriptor, or null when there is nothing to show.
+ */
+export declare function resolveKanbanProgress(value: unknown, max?: number): KanbanProgress | null;
+/**
+ * Builds the card's completion meter. The track is the accessible progress element itself, so the
+ * value is available without depending on the visible percentage text.
+ * @param {KanbanProgress} progress Normalized descriptor.
+ * @param {string} label Meter label.
+ * @param {string} valueText Formatted readout drawn opposite the label.
+ * @returns {HTMLElement} Meter element.
+ */
+export declare function createKanbanProgress(progress: KanbanProgress, label: string, valueText: string): HTMLElement;
+/**
+ * Normalizes one or more responsible people. Names, name lists, and descriptor objects all
+ * resolve to the same shape, and an unsafe image URL degrades to initials rather than failing.
+ * @param {unknown} value Raw field value.
+ * @returns {KanbanAssignee[]} Normalized people, in the order supplied.
+ */
+export declare function resolveKanbanAssignees(value: unknown): KanbanAssignee[];
+/**
+ * Splits a list of people into the faces that are drawn and the number the overflow chip stands
+ * for. Exists as one function so the slice and the chip can never be computed from different
+ * normalizations of the same option — a fractional limit used to floor every face away while the
+ * chip still counted from the raw value.
+ * @param {number} max Requested face count.
+ * @param {number} total People available.
+ * @returns {{shown:number,hidden:number}} Normalized split.
+ */
+export declare function kanbanAvatarLimit(max: number, total: number): {
+    shown: number;
+    hidden: number;
+};
+/**
+ * Builds the assignee avatar group. The group carries one accessible name listing everyone,
+ * including the people behind the overflow chip, and the chips themselves are hidden so a screen
+ * reader announces the list once rather than once per face.
+ * @param {KanbanAssignee[]} people Normalized people.
+ * @param {number} max Faces drawn before the overflow chip.
+ * @param {string} groupLabel Accessible name for the whole group.
+ * @param {(count: number) => string} overflowLabel Text for the overflow chip, given how many
+ * people it stands for. The count is derived here so it can never disagree with the slice.
+ * @returns {HTMLElement|null} Group element, or null when nobody is assigned.
+ */
+export declare function createKanbanAvatars(people: KanbanAssignee[], max: number, groupLabel: string, overflowLabel: (count: number) => string): HTMLElement | null;
+/**
+ * Builds the card's head row: what the record is, and how urgent it is.
+ * @param {Object} parts Row content.
+ * @param {string|null} parts.entityIcon Icon name, or null.
+ * @param {string} parts.identifier Record key, or an empty string.
+ * @param {{indicator:Node|KanbanIndicator|null,prefix:string}[]} parts.flags Trailing indicators,
+ * each with the visually hidden text that names what it measures.
+ * @param {string} parts.identifierPrefix Visually hidden text read before the record key.
+ * @returns {HTMLElement|null} Head row, or null when it would be empty.
+ */
+export declare function createKanbanCardHead(parts: {
+    entityIcon: string | null;
+    identifier: string;
+    flags: {
+        indicator: Node | KanbanIndicator | null;
+        prefix: string;
+    }[];
+    identifierPrefix: string;
+}): HTMLElement | null;