mlform 0.1.2 → 0.1.4

package/dist/types/src/design-system/types.d.ts

@@ -0,0 +1,225 @@
+import { ComponentKey, MlfTokenKey } from './contract';
+export type DesignSystemScheme = "light" | "dark";
+export type DesignSystemMode = "light" | "dark" | "auto" | "inherit";
+export type Density = "compact" | "comfortable" | "spacious";
+export type Motion = "none" | "subtle" | "standard";
+export type EffectiveModeSource = "explicit" | "system" | "host-attribute" | "host-style" | "host-resolver" | "theme-fallback" | "default";
+export type DesignSystemWarningCode = "unknown-theme-id" | "unknown-recipe-id" | "invalid-theme-variant" | "unknown-token-key" | "misplaced-component-token" | "broken-token-reference";
+export interface DesignSystemWarning {
+    code: DesignSystemWarningCode;
+    message: string;
+    path?: string;
+    value?: string;
+}
+/**
+ * Utility type for token maps with IDE autocompletion for all `--mlf-*` keys.
+ *
+ * Use this when authoring custom themes, recipes, or overrides to get
+ * completion suggestions and catch typos in token key names. Structurally
+ * compatible with `Record<string, string>` — accepts any CSS custom property.
+ *
+ * ```ts
+ * const myTheme: ThemeManifest = {
+ *   id: "brand",
+ *   label: "Brand",
+ *   schemes: {
+ *     light: {
+ *       tokens: {
+ *         "--mlf-color-accent": "#c0392b",  // ← autocomplete + typo detection
+ *       } satisfies Partial<TokenMap>,
+ *     },
+ *   },
+ * };
+ * ```
+ */
+export type TokenMap = Partial<Record<MlfTokenKey, string>> & {
+    [key: string]: string;
+};
+export type ComponentTokenKey<K extends ComponentKey = ComponentKey> = `--mlf-${K}-${string}`;
+export type GlobalTokenKey = Exclude<MlfTokenKey, ComponentTokenKey>;
+export type GlobalTokenMap = Partial<Record<GlobalTokenKey, string>>;
+export type ComponentTokenMap<K extends ComponentKey> = Partial<Record<ComponentTokenKey<K>, string>>;
+export interface ThemeScheme {
+    /**
+     * Informational — declares the intended scheme for this slot.
+     * Does NOT affect scheme resolution; the resolved scheme is determined
+     * by `mode`, the media query, or parent inheritance.
+     */
+    colorScheme?: DesignSystemScheme;
+    tokens: Record<string, string>;
+}
+/**
+ * A named variant of a base scheme. Variants overlay additional tokens
+ * on top of a base scheme's tokens — use for accessibility variants
+ * (e.g. `"high-contrast-light"`, `"high-contrast-dark"`) or brand variants.
+ */
+export interface ThemeVariant {
+    /** Which base scheme this variant extends. */
+    baseScheme: DesignSystemScheme;
+    /** Additional tokens overlaid on the base scheme's tokens. */
+    tokens: Record<string, string>;
+}
+export interface ThemeManifest {
+    id: string;
+    label: string;
+    schemes: {
+        light: ThemeScheme;
+        dark?: ThemeScheme;
+    };
+    /**
+     * Additional scheme variants that overlay base scheme tokens.
+     * Keyed by arbitrary variant names (e.g. `"high-contrast-light"`,
+     * `"high-contrast-dark"`). Each variant specifies a `baseScheme` and
+     * additional tokens applied on top.
+     *
+     * When `prefersMoreContrast` is detected and no explicit `variant` is set,
+     * the resolver auto-selects `"high-contrast-${effectiveScheme}"` if present.
+     */
+    variants?: Record<string, ThemeVariant>;
+    /**
+     * Tokens applied to both schemes before scheme-specific tokens.
+     * Use for values that don't change between light and dark (e.g. brand fonts,
+     * static radii). Scheme tokens win over `sharedTokens` when keys collide.
+     */
+    sharedTokens?: Record<string, string>;
+}
+export interface ComponentManifest {
+    tokens: Record<string, string>;
+}
+export interface RecipeManifest {
+    id: string;
+    label: string;
+    density: Density;
+    motion: Motion;
+    tokens?: Record<string, string>;
+    components?: Partial<Record<ComponentKey, ComponentManifest>>;
+}
+export interface DesignSystemOverrides {
+    density?: Density;
+    motion?: Motion;
+    tokens?: Record<string, string>;
+    components?: Partial<Record<ComponentKey, Partial<ComponentManifest>>>;
+}
+export interface DesignSystemConfig {
+    mode?: DesignSystemMode;
+    theme?: string | ThemeManifest;
+    recipe?: string | RecipeManifest;
+    /**
+     * Select a named theme variant (e.g. `"high-contrast-light"`). When set,
+     * the variant's tokens overlay the resolved base scheme tokens only when the
+     * variant's `baseScheme` matches the effective scheme. Mismatches emit an
+     * `"invalid-theme-variant"` warning and the variant is ignored.
+     *
+     * When omitted and `prefersMoreContrast` is active, the resolver
+     * auto-selects `"high-contrast-${effectiveScheme}"` if it exists in the theme.
+     */
+    variant?: string;
+    overrides?: DesignSystemOverrides;
+    hostSchemeResolver?: (host: HTMLElement) => DesignSystemScheme | null;
+    strict?: boolean;
+    onWarning?: (warning: DesignSystemWarning) => void;
+}
+export interface ResolvedComponentConfig {
+    tokens: Record<string, string>;
+}
+export interface ResolvedDesignSystem {
+    requestedMode: DesignSystemMode;
+    effectiveScheme: DesignSystemScheme;
+    effectiveModeSource: EffectiveModeSource;
+    themeId: string;
+    /** The active theme variant, or `null` if no variant is applied. */
+    variant: string | null;
+    recipeId: string;
+    density: Density;
+    motion: Motion;
+    tokens: Record<string, string>;
+    tokenOverrides: Record<string, string>;
+    components: Record<ComponentKey, ResolvedComponentConfig>;
+    warnings: DesignSystemWarning[];
+}
+export interface ResolveDesignSystemRuntimeOptions {
+    inheritedScheme?: DesignSystemScheme | null;
+    inheritedSource?: Extract<EffectiveModeSource, "host-attribute" | "host-style" | "host-resolver">;
+    systemScheme?: DesignSystemScheme;
+    /** When true and `motion` is not explicitly overridden, effective motion collapses to `"none"`. */
+    prefersReducedMotion?: boolean;
+    /** When true and `density` is not explicitly overridden, effective density becomes `"spacious"`. */
+    prefersMoreContrast?: boolean;
+    /**
+     * When true, Windows High Contrast Mode (or equivalent `forced-colors: active`)
+     * is active. Color tokens are remapped to CSS system colors so the browser's
+     * forced-color palette is respected.
+     */
+    forcedColors?: boolean;
+}
+export type DesignSystemRegistryChangeType = "theme-registered" | "theme-removed" | "recipe-registered" | "recipe-removed";
+export interface DesignSystemRegistryChangeEvent {
+    type: DesignSystemRegistryChangeType;
+    id: string;
+}
+export type DesignSystemRegistryChangeListener = (event: DesignSystemRegistryChangeEvent) => void;
+export interface DesignSystemRegistry {
+    registerTheme(theme: ThemeManifest): DesignSystemRegistry;
+    registerRecipe(recipe: RecipeManifest): DesignSystemRegistry;
+    /**
+     * Register a variant for an existing theme without re-registering the
+     * entire theme. If the theme does not exist yet, the variant is stored
+     * and will be attached when the theme is later registered.
+     */
+    registerVariant(themeId: string, variantId: string, variant: ThemeVariant): DesignSystemRegistry;
+    removeTheme(id: string): DesignSystemRegistry;
+    removeRecipe(id: string): DesignSystemRegistry;
+    getTheme(id: string): ThemeManifest | undefined;
+    getRecipe(id: string): RecipeManifest | undefined;
+    listThemes(): ThemeManifest[];
+    listRecipes(): RecipeManifest[];
+    clone(): DesignSystemRegistry;
+    onChange(listener: DesignSystemRegistryChangeListener): () => void;
+}
+/**
+ * Strategy for animating design-system transitions (theme/scheme switches).
+ *
+ * - `"none"` — instant switch (default).
+ * - `"view-transition"` — uses the View Transitions API (`document.startViewTransition`)
+ *   when available; falls back to instant switch. Stale transitions are ignored
+ *   when a newer update supersedes them.
+ * - A custom function receives the update callback and is responsible for
+ *   calling it (e.g. wrapping in a CSS transition or animation). It may return
+ *   cleanup function and should observe `context.signal` for cancellation.
+ */
+export interface DesignSystemTransitionContext {
+    host: HTMLElement;
+    resolved: ResolvedDesignSystem;
+    previous: ResolvedDesignSystem | null;
+    signal: AbortSignal;
+}
+export type DesignSystemTransition = "none" | "view-transition" | ((apply: () => void, context: DesignSystemTransitionContext) => void | (() => void));
+export interface DesignSystemControllerOptions {
+    host: HTMLElement;
+    registry?: DesignSystemRegistry;
+    getConfig: () => DesignSystemConfig;
+    onChange?: (resolved: ResolvedDesignSystem) => void;
+    /** When true, seed controller state from matching SSR/inline DOM before first refresh. */
+    hydrate?: boolean;
+    /**
+     * How to animate when the resolved design system changes. Defaults to `"none"`.
+     */
+    transition?: DesignSystemTransition;
+}
+export interface AttachDesignSystemOptions {
+    config?: DesignSystemConfig;
+    registry?: DesignSystemRegistry;
+    onChange?: (resolved: ResolvedDesignSystem) => void;
+    /** How to animate when the resolved design system changes. Defaults to `"none"`. */
+    transition?: DesignSystemTransition;
+}
+export interface AttachedDesignSystem {
+    readonly host: HTMLElement;
+    readonly registry: DesignSystemRegistry;
+    readonly config: DesignSystemConfig;
+    readonly resolved: ResolvedDesignSystem | null;
+    update(config: DesignSystemConfig): void;
+    replace(config: DesignSystemConfig): void;
+    reset(): void;
+    disconnect(): void;
+}

package/dist/types/src/engine/builtins/fields/boolean.d.ts

@@ -0,0 +1,8 @@
+import { BaseFieldConfig, FieldDefinition } from '../../types';
+type BooleanFieldConfig = BaseFieldConfig & {
+    kind: "boolean";
+    trueLabel?: string;
+    falseLabel?: string;
+};
+export declare const booleanFieldDefinition: FieldDefinition<BooleanFieldConfig, boolean>;
+export {};

package/dist/types/src/engine/builtins/fields/category.d.ts

@@ -0,0 +1,11 @@
+import { BaseFieldConfig, FieldDefinition } from '../../types';
+type CategoryOption = string | {
+    label: string;
+    value: string;
+};
+type CategoryFieldConfig = BaseFieldConfig & {
+    kind: "category";
+    options: CategoryOption[];
+};
+export declare const categoryFieldDefinition: FieldDefinition<CategoryFieldConfig, string | null>;
+export {};

package/dist/types/src/engine/builtins/fields/date.d.ts

@@ -0,0 +1,9 @@
+import { BaseFieldConfig, FieldDefinition } from '../../types';
+type DateFieldConfig = BaseFieldConfig & {
+    kind: "date";
+    min?: string;
+    max?: string;
+    step?: number;
+};
+export declare const dateFieldDefinition: FieldDefinition<DateFieldConfig, Date | null>;
+export {};

package/dist/types/src/engine/builtins/fields/long-text.d.ts

@@ -0,0 +1,10 @@
+import { BaseFieldConfig, FieldDefinition } from '../../types';
+type LongTextFieldConfig = BaseFieldConfig & {
+    kind: "long-text";
+    placeholder?: string;
+    minLength?: number;
+    maxLength?: number;
+    rows?: number;
+};
+export declare const longTextFieldDefinition: FieldDefinition<LongTextFieldConfig, string>;
+export {};

package/dist/types/src/engine/builtins/fields/multi-choice.d.ts

@@ -0,0 +1,12 @@
+import { BaseFieldConfig, FieldDefinition } from '../../types';
+type MultiChoiceOption = string | {
+    label: string;
+    value: string;
+};
+type MultiChoiceFieldConfig = BaseFieldConfig & {
+    kind: "multi-choice";
+    options: MultiChoiceOption[];
+    layout?: "horizontal" | "vertical";
+};
+export declare const multiChoiceFieldDefinition: FieldDefinition<MultiChoiceFieldConfig, string[]>;
+export {};

package/dist/types/src/engine/builtins/fields/number.d.ts

@@ -0,0 +1,11 @@
+import { BaseFieldConfig, FieldDefinition } from '../../types';
+type NumberFieldConfig = BaseFieldConfig & {
+    kind: "number";
+    min?: number;
+    max?: number;
+    step?: number;
+    unit?: string;
+    placeholder?: string;
+};
+export declare const numberFieldDefinition: FieldDefinition<NumberFieldConfig, number | string | null>;
+export {};

package/dist/types/src/engine/builtins/fields/rating.d.ts

@@ -0,0 +1,9 @@
+import { BaseFieldConfig, FieldDefinition } from '../../types';
+type RatingFieldConfig = BaseFieldConfig & {
+    kind: "rating";
+    min?: number;
+    max: number;
+    step?: number;
+};
+export declare const ratingFieldDefinition: FieldDefinition<RatingFieldConfig, number | null>;
+export {};

package/dist/types/src/engine/builtins/fields/series.d.ts

@@ -0,0 +1,20 @@
+import { BaseFieldConfig, FieldDefinition } from '../../types';
+type SeriesPoint = {
+    field1: unknown;
+    field2: unknown;
+};
+type SeriesSubFieldConfig = {
+    kind: string;
+    label: string;
+    required?: boolean;
+    [key: string]: unknown;
+};
+type SeriesFieldConfig = BaseFieldConfig & {
+    kind: "series";
+    field1: SeriesSubFieldConfig;
+    field2: SeriesSubFieldConfig;
+    minPoints?: number;
+    maxPoints?: number;
+};
+export declare const seriesFieldDefinition: FieldDefinition<SeriesFieldConfig, SeriesPoint[]>;
+export {};

package/dist/types/src/engine/builtins/fields/single-choice.d.ts

@@ -0,0 +1,12 @@
+import { BaseFieldConfig, FieldDefinition } from '../../types';
+type SingleChoiceOption = string | {
+    label: string;
+    value: string;
+};
+type SingleChoiceFieldConfig = BaseFieldConfig & {
+    kind: "single-choice";
+    options: SingleChoiceOption[];
+    layout?: "horizontal" | "vertical";
+};
+export declare const singleChoiceFieldDefinition: FieldDefinition<SingleChoiceFieldConfig, string | null>;
+export {};

package/dist/types/src/engine/builtins/fields/text.d.ts

@@ -0,0 +1,10 @@
+import { BaseFieldConfig, FieldDefinition } from '../../types';
+type TextFieldConfig = BaseFieldConfig & {
+    kind: "text";
+    placeholder?: string;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+};
+export declare const textFieldDefinition: FieldDefinition<TextFieldConfig, string>;
+export {};

package/dist/types/src/engine/builtins/index.d.ts

@@ -0,0 +1,97 @@
+import { Registry } from '../types';
+import { booleanFieldDefinition } from './fields/boolean';
+import { categoryFieldDefinition } from './fields/category';
+import { dateFieldDefinition } from './fields/date';
+import { longTextFieldDefinition } from './fields/long-text';
+import { multiChoiceFieldDefinition } from './fields/multi-choice';
+import { numberFieldDefinition } from './fields/number';
+import { ratingFieldDefinition } from './fields/rating';
+import { seriesFieldDefinition } from './fields/series';
+import { singleChoiceFieldDefinition } from './fields/single-choice';
+import { textFieldDefinition } from './fields/text';
+import { classifierReportDefinition } from './reports/classifier';
+import { regressorReportDefinition } from './reports/regressor';
+export { booleanFieldDefinition, categoryFieldDefinition, classifierReportDefinition, dateFieldDefinition, longTextFieldDefinition, multiChoiceFieldDefinition, numberFieldDefinition, ratingFieldDefinition, regressorReportDefinition, seriesFieldDefinition, singleChoiceFieldDefinition, textFieldDefinition, };
+export declare const builtinFieldDefinitions: readonly [import('..').FieldDefinition<import('..').BaseFieldConfig & {
+    kind: "text";
+    placeholder?: string;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+}, string>, import('..').FieldDefinition<import('..').BaseFieldConfig & {
+    kind: "number";
+    min?: number;
+    max?: number;
+    step?: number;
+    unit?: string;
+    placeholder?: string;
+}, string | number | null>, import('..').FieldDefinition<import('..').BaseFieldConfig & {
+    kind: "boolean";
+    trueLabel?: string;
+    falseLabel?: string;
+}, boolean>, import('..').FieldDefinition<import('..').BaseFieldConfig & {
+    kind: "category";
+    options: (string | {
+        label: string;
+        value: string;
+    })[];
+}, string | null>, import('..').FieldDefinition<import('..').BaseFieldConfig & {
+    kind: "date";
+    min?: string;
+    max?: string;
+    step?: number;
+}, Date | null>, import('..').FieldDefinition<import('..').BaseFieldConfig & {
+    kind: "series";
+    field1: {
+        [key: string]: unknown;
+        kind: string;
+        label: string;
+        required?: boolean;
+    };
+    field2: {
+        [key: string]: unknown;
+        kind: string;
+        label: string;
+        required?: boolean;
+    };
+    minPoints?: number;
+    maxPoints?: number;
+}, {
+    field1: unknown;
+    field2: unknown;
+}[]>, import('..').FieldDefinition<import('..').BaseFieldConfig & {
+    kind: "long-text";
+    placeholder?: string;
+    minLength?: number;
+    maxLength?: number;
+    rows?: number;
+}, string>, import('..').FieldDefinition<import('..').BaseFieldConfig & {
+    kind: "single-choice";
+    options: (string | {
+        label: string;
+        value: string;
+    })[];
+    layout?: "horizontal" | "vertical";
+}, string | null>, import('..').FieldDefinition<import('..').BaseFieldConfig & {
+    kind: "multi-choice";
+    options: (string | {
+        label: string;
+        value: string;
+    })[];
+    layout?: "horizontal" | "vertical";
+}, string[]>, import('..').FieldDefinition<import('..').BaseFieldConfig & {
+    kind: "rating";
+    min?: number;
+    max: number;
+    step?: number;
+}, number | null>];
+export declare const builtinReportDefinitions: readonly [import('..').ReportDefinition<import('..').BaseReportConfig & {
+    kind: "classifier";
+    labels?: string[];
+    details?: boolean;
+}>, import('..').ReportDefinition<import('..').BaseReportConfig & {
+    kind: "regressor";
+    unit?: string;
+    precision?: number;
+}>];
+export declare const createBuiltinRegistry: () => Registry;

package/dist/types/src/engine/builtins/reports/classifier.d.ts

@@ -0,0 +1,8 @@
+import { BaseReportConfig, ReportDefinition } from '../../types';
+type ClassifierReportConfig = BaseReportConfig & {
+    kind: "classifier";
+    labels?: string[];
+    details?: boolean;
+};
+export declare const classifierReportDefinition: ReportDefinition<ClassifierReportConfig>;
+export {};

package/dist/types/src/engine/builtins/reports/regressor.d.ts

@@ -0,0 +1,8 @@
+import { BaseReportConfig, ReportDefinition } from '../../types';
+type RegressorReportConfig = BaseReportConfig & {
+    kind: "regressor";
+    unit?: string;
+    precision?: number;
+};
+export declare const regressorReportDefinition: ReportDefinition<RegressorReportConfig>;
+export {};

package/dist/types/src/engine/builtins/shared.d.ts

@@ -0,0 +1,49 @@
+import { BaseFieldConfig, BaseReportConfig, DeclarativeFieldCondition, NormalizedFieldConfig, SubmitResult } from '../types';
+import * as z from "zod";
+export declare const uiSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+export declare const baseFieldShape: {
+    id: z.ZodOptional<z.ZodString>;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    disabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    hidden: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    readOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    disabledWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<(context: unknown) => boolean, (context: unknown) => boolean>, z.ZodType<DeclarativeFieldCondition, unknown, z.core.$ZodTypeInternals<DeclarativeFieldCondition, unknown>>]>>;
+    hiddenWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<(context: unknown) => boolean, (context: unknown) => boolean>, z.ZodType<DeclarativeFieldCondition, unknown, z.core.$ZodTypeInternals<DeclarativeFieldCondition, unknown>>]>>;
+    readOnlyWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<(context: unknown) => boolean, (context: unknown) => boolean>, z.ZodType<DeclarativeFieldCondition, unknown, z.core.$ZodTypeInternals<DeclarativeFieldCondition, unknown>>]>>;
+    asyncValidationDebounceMs: z.ZodOptional<z.ZodNumber>;
+    inactiveFieldPolicy: z.ZodOptional<z.ZodEnum<{
+        include: "include";
+        omit: "omit";
+        "reset-on-hide": "reset-on-hide";
+    }>>;
+    valuePath: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    ui: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+};
+export declare const baseReportShape: {
+    id: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    ui: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+};
+export declare const optionSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    label: z.ZodString;
+    value: z.ZodString;
+}, z.core.$strip>]>;
+export declare const resolveLegacyOutput: (result: SubmitResult, kind: string) => unknown;
+export declare const makeFieldDescriptor: (component: string, config: NormalizedFieldConfig, valueExtras: Record<string, unknown>) => {
+    component: string;
+    props: {
+        id: string;
+        kind: string;
+        label: string;
+        description: string;
+        required: boolean;
+        disabled: boolean;
+    };
+};
+export type BuiltinFieldConfig = BaseFieldConfig;
+export type BuiltinReportConfig = BaseReportConfig;

package/dist/types/src/engine/comparison.d.ts

@@ -0,0 +1,2 @@
+export declare const toComparablePrimitive: (value: unknown) => number | string | bigint | null;
+export declare const compareComparable: (left: unknown, right: unknown) => -1 | 0 | 1 | null;

package/dist/types/src/engine/constants.d.ts

@@ -0,0 +1,51 @@
+export declare const builtinReportKinds: {
+    readonly classifier: "classifier";
+    readonly regressor: "regressor";
+};
+export declare const builtinLegacyOutputTypes: {
+    readonly classifier: "classifier";
+    readonly regressor: "regressor";
+};
+export declare const builtinFieldKinds: {
+    readonly text: "text";
+    readonly number: "number";
+    readonly boolean: "boolean";
+    readonly category: "category";
+    readonly date: "date";
+    readonly series: "series";
+    readonly longText: "long-text";
+    readonly singleChoice: "single-choice";
+    readonly multiChoice: "multi-choice";
+    readonly rating: "rating";
+};
+export declare const builtinReportLabels: {
+    readonly classifier: "Classifier report";
+    readonly regressor: "Regressor report";
+};
+export declare const builtinReportFallbacks: {
+    readonly unknownPrediction: "Unknown";
+    readonly classifierClassLabel: (index: number) => string;
+};
+export declare const builtinValidationMessages: {
+    readonly invalidNumber: "Value must be a valid number.";
+    readonly textPatternMismatch: "Value does not match the expected pattern.";
+    readonly booleanRequired: "This field must be accepted.";
+    readonly categoryOptionMismatch: "Value must match one of the available options.";
+    readonly invalidTextLengthRange: "Minimum length cannot exceed maximum length.";
+    readonly invalidNumericRange: "Minimum value cannot exceed maximum value.";
+    readonly invalidDateRange: "Minimum date cannot be after maximum date.";
+    readonly invalidPointCountRange: "Minimum number of points cannot exceed maximum number of points.";
+    readonly minLength: (value: number) => string;
+    readonly maxLength: (value: number) => string;
+    readonly minValue: (value: number) => string;
+    readonly maxValue: (value: number) => string;
+    readonly stepValue: (value: number) => string;
+    readonly dateOnOrAfter: (value: string) => string;
+    readonly dateOnOrBefore: (value: string) => string;
+    readonly stepDate: (value: number) => string;
+    readonly minPoints: (value: number) => string;
+    readonly maxPoints: (value: number) => string;
+    readonly timestampsUnique: "Timestamps must be unique.";
+    readonly timestampsAscending: "Timestamps must be sorted in ascending order.";
+    readonly timestampsDescending: "Timestamps must be sorted in descending order.";
+};

package/dist/types/src/engine/declarative/explanation.d.ts

@@ -0,0 +1,2 @@
+import { DeclarativeExplanationKind, ExplanationConfig, ExplanationDefinition } from '../types';
+export declare const defineExplanationKind: <TConfig extends ExplanationConfig, TResult>(kind: DeclarativeExplanationKind<TConfig, TResult>) => ExplanationDefinition<TConfig>;

package/dist/types/src/engine/declarative/field.d.ts

@@ -0,0 +1,2 @@
+import { DeclarativeFieldKind, FieldConfig, FieldDefinition } from '../types';
+export declare const defineFieldKind: <TConfig extends FieldConfig, TValue>(kind: DeclarativeFieldKind<TConfig, TValue>) => FieldDefinition<TConfig, TValue>;

package/dist/types/src/engine/declarative/presentation.d.ts

@@ -0,0 +1,61 @@
+export type PresentationTone = "neutral" | "info" | "success" | "warning" | "danger";
+export interface PresentationSummary {
+    title?: string;
+    description?: string;
+    value?: unknown;
+    badge?: string;
+    tone?: PresentationTone;
+}
+export interface PresentationTextNode {
+    type: "text";
+    label?: string;
+    value: unknown;
+    tone?: PresentationTone;
+}
+export interface PresentationMetricNode {
+    type: "metric";
+    label: string;
+    value: unknown;
+    hint?: string;
+    tone?: PresentationTone;
+}
+export interface PresentationKeyValueEntry {
+    label: string;
+    value: unknown;
+}
+export interface PresentationKeyValueNode {
+    type: "kv";
+    label?: string;
+    entries: PresentationKeyValueEntry[] | Record<string, unknown>;
+}
+export interface PresentationListNode {
+    type: "list";
+    label?: string;
+    items: unknown[];
+    ordered?: boolean;
+}
+export interface PresentationTableNode {
+    type: "table";
+    label?: string;
+    columns: string[];
+    rows: Array<Record<string, unknown> | unknown[]>;
+}
+export interface PresentationBadgeNode {
+    type: "badge";
+    label: string;
+    tone?: PresentationTone;
+}
+export interface PresentationNoticeNode {
+    type: "notice";
+    title?: string;
+    body: unknown;
+    tone?: PresentationTone;
+}
+export interface PresentationJsonNode {
+    type: "json";
+    label?: string;
+    value: unknown;
+}
+export type PresentationNode = PresentationTextNode | PresentationMetricNode | PresentationKeyValueNode | PresentationListNode | PresentationTableNode | PresentationBadgeNode | PresentationNoticeNode | PresentationJsonNode;
+export type PresentationContent = PresentationNode | PresentationNode[];
+export declare const toPresentationNodes: (value: PresentationContent | undefined) => PresentationNode[];

package/dist/types/src/engine/declarative/report.d.ts

@@ -0,0 +1,2 @@
+import { DeclarativeReportKind, ReportConfig, ReportDefinition } from '../types';
+export declare const defineReportKind: <TConfig extends ReportConfig, TPayload>(kind: DeclarativeReportKind<TConfig, TPayload>) => ReportDefinition<TConfig>;

package/dist/types/src/engine/equality.d.ts

@@ -0,0 +1,4 @@
+export declare const defaultEquality: <T>(previous: T, next: T) => boolean;
+export declare const shallowArrayEquality: <T>(previous: readonly T[], next: readonly T[]) => boolean;
+export declare const shallowObjectEquality: (previous: Record<string, unknown>, next: Record<string, unknown>) => boolean;
+export declare const shallowEquality: <T>(previous: T, next: T) => boolean;