mlform 0.1.7 → 0.1.9

package/dist/types/kit/layout-helpers.d.ts

@@ -0,0 +1,29 @@
+import { ExplanationController, FieldController, ReportController } from '../runtime';
+import { FormLayoutNode } from './types';
+export type LayoutReferenceMaps = {
+    fieldStepIds: Map<string, string>;
+    reportStepIds: Map<string, string>;
+    explanationStepIds: Map<string, string>;
+    fieldTabIds: Map<string, string>;
+    reportTabIds: Map<string, string>;
+    explanationTabIds: Map<string, string>;
+    fieldIdsInLayout: Set<string>;
+    reportIdsInLayout: Set<string>;
+    explanationIdsInLayout: Set<string>;
+};
+export type EntityMaps = {
+    fieldIds: Set<string>;
+    reportIds: Set<string>;
+    explanationIds: Set<string>;
+};
+export declare const createEntityMaps: (fields: readonly FieldController[], reports: readonly ReportController[], explanations: readonly ExplanationController[]) => EntityMaps;
+export declare const createReferenceMaps: () => LayoutReferenceMaps;
+export declare const nextNodeId: (prefix: string, preferred: string | undefined, counts: Map<string, number>) => string;
+export declare const assertKnownField: (fieldId: string, entities: EntityMaps) => void;
+export declare const assertKnownReport: (reportId: string, entities: EntityMaps) => void;
+export declare const assertKnownExplanation: (explanationId: string, entities: EntityMaps) => void;
+export declare const markField: (fieldId: string, maps: LayoutReferenceMaps, stepId: string | null, tabId: string | null) => void;
+export declare const markReport: (reportId: string, maps: LayoutReferenceMaps, stepId: string | null, tabId: string | null) => void;
+export declare const markExplanation: (explanationId: string, maps: LayoutReferenceMaps, stepId: string | null, tabId: string | null) => void;
+export declare const createDefaultSinglePageNodes: (fields: readonly FieldController[], explanations: readonly ExplanationController[], reports: readonly ReportController[]) => FormLayoutNode[];
+export declare const assertAllFieldsCovered: (fields: readonly FieldController[], maps: LayoutReferenceMaps) => void;

package/dist/types/kit/layout-node-render.d.ts

@@ -0,0 +1,18 @@
+import { nothing, TemplateResult } from 'lit';
+import { PrimitiveText } from '../primitives/constants';
+import { PrimitiveRegistry } from '../primitives/types';
+import { FormViewSnapshot, ResolvedFormLayoutNode } from './types';
+type RenderLayoutNodeOptions = {
+    node: ResolvedFormLayoutNode;
+    snapshot: FormViewSnapshot;
+    registry: PrimitiveRegistry | undefined;
+    primitiveText?: PrimitiveText;
+    sectionClass: string;
+    sectionCopyClass: string;
+    sectionTitleClass: string;
+    sectionDescriptionClass: string;
+    childrenClass: string;
+    groupBaseClass: string;
+};
+export declare const renderLayoutNode: ({ node, snapshot, registry, primitiveText, sectionClass, sectionCopyClass, sectionTitleClass, sectionDescriptionClass, childrenClass, groupBaseClass, }: RenderLayoutNodeOptions) => TemplateResult | typeof nothing;
+export {};

package/dist/types/kit/layout-node-resolver.d.ts

@@ -0,0 +1,3 @@
+import { FormLayoutNode, ResolvedFormLayoutNode } from './types';
+import { EntityMaps, LayoutReferenceMaps } from './layout-helpers';
+export declare const resolveNodes: (nodes: FormLayoutNode[], entities: EntityMaps, maps: LayoutReferenceMaps, nodeIds: Map<string, number>, stepId: string | null, tabId: string | null) => ResolvedFormLayoutNode[];

package/dist/types/kit/layout-types.d.ts

@@ -0,0 +1,124 @@
+export interface FormLayoutSectionNode {
+    kind: "section";
+    id?: string;
+    title?: string;
+    description?: string;
+    children: FormLayoutNode[];
+}
+export interface FormLayoutGroupNode {
+    kind: "group";
+    id?: string;
+    columns?: 1 | 2 | 3;
+    children: FormLayoutNode[];
+}
+export interface FormLayoutFieldNode {
+    kind: "field";
+    field: string;
+}
+export interface FormLayoutReportNode {
+    kind: "report";
+    report: string;
+}
+export interface FormLayoutExplanationNode {
+    kind: "explanation";
+    explanation: string;
+}
+export type FormLayoutNode = FormLayoutSectionNode | FormLayoutGroupNode | FormLayoutFieldNode | FormLayoutReportNode | FormLayoutExplanationNode;
+export interface SinglePageLayoutConfig {
+    kind?: "single-page";
+    children?: FormLayoutNode[];
+}
+export interface WizardStepConfig {
+    id?: string;
+    title: string;
+    description?: string;
+    children: FormLayoutNode[];
+}
+export interface WizardLayoutConfig {
+    kind: "wizard";
+    steps: WizardStepConfig[];
+}
+export interface TabLayoutConfig {
+    id?: string;
+    title: string;
+    description?: string;
+    children: FormLayoutNode[];
+}
+export interface TabsLayoutConfig {
+    kind: "tabs";
+    tabs: TabLayoutConfig[];
+}
+export interface AccordionSectionConfig {
+    id?: string;
+    title: string;
+    description?: string;
+    children: FormLayoutNode[];
+    defaultOpen?: boolean;
+}
+export interface AccordionLayoutConfig {
+    kind: "accordion";
+    sections: AccordionSectionConfig[];
+}
+export type FormLayoutConfig = SinglePageLayoutConfig | WizardLayoutConfig | TabsLayoutConfig | AccordionLayoutConfig;
+export interface ResolvedFormLayoutSectionNode {
+    kind: "section";
+    id: string;
+    title?: string;
+    description?: string;
+    children: ResolvedFormLayoutNode[];
+}
+export interface ResolvedFormLayoutGroupNode {
+    kind: "group";
+    id: string;
+    columns?: 1 | 2 | 3;
+    children: ResolvedFormLayoutNode[];
+}
+export interface ResolvedFormLayoutFieldNode {
+    kind: "field";
+    field: string;
+}
+export interface ResolvedFormLayoutReportNode {
+    kind: "report";
+    report: string;
+}
+export interface ResolvedFormLayoutExplanationNode {
+    kind: "explanation";
+    explanation: string;
+}
+export type ResolvedFormLayoutNode = ResolvedFormLayoutSectionNode | ResolvedFormLayoutGroupNode | ResolvedFormLayoutFieldNode | ResolvedFormLayoutReportNode | ResolvedFormLayoutExplanationNode;
+export interface ResolvedSinglePageLayout {
+    kind: "single-page";
+    children: ResolvedFormLayoutNode[];
+}
+export interface ResolvedWizardStep {
+    id: string;
+    title: string;
+    description?: string;
+    children: ResolvedFormLayoutNode[];
+}
+export interface ResolvedWizardLayout {
+    kind: "wizard";
+    steps: ResolvedWizardStep[];
+}
+export interface ResolvedTabLayout {
+    id: string;
+    title: string;
+    description?: string;
+    children: ResolvedFormLayoutNode[];
+}
+export interface ResolvedTabsLayout {
+    kind: "tabs";
+    tabs: ResolvedTabLayout[];
+}
+export interface ResolvedAccordionSection {
+    id: string;
+    title: string;
+    description?: string;
+    defaultOpen: boolean;
+    children: ResolvedFormLayoutNode[];
+}
+export interface ResolvedAccordionLayout {
+    kind: "accordion";
+    sections: ResolvedAccordionSection[];
+}
+export type ResolvedFormLayout = ResolvedSinglePageLayout | ResolvedWizardLayout | ResolvedTabsLayout | ResolvedAccordionLayout;

package/dist/types/kit/layout-utils.d.ts

@@ -0,0 +1,9 @@
+import { ResolvedFormLayout, ResolvedFormLayoutNode } from './types';
+export interface LayoutReferences {
+    fields: string[];
+    reports: string[];
+    explanations: string[];
+}
+export declare const walkLayoutNodes: (layout: ResolvedFormLayout, visitor: (node: ResolvedFormLayoutNode) => void) => void;
+export declare const flattenLayoutNodes: (layout: ResolvedFormLayout) => ResolvedFormLayoutNode[];
+export declare const collectLayoutReferences: (layout: ResolvedFormLayout) => LayoutReferences;

package/dist/types/kit/layout.d.ts

@@ -0,0 +1,8 @@
+import { ExplanationController, FieldController, ReportController } from '../runtime';
+import { LayoutReferenceMaps } from './layout-helpers';
+import { FormLayoutConfig, ResolvedFormLayout } from './types';
+export interface ResolvedLayoutResult {
+    layout: ResolvedFormLayout;
+    maps: LayoutReferenceMaps;
+}
+export declare const resolveFormLayout: (layout: FormLayoutConfig | undefined, fields: readonly FieldController[], reports: readonly ReportController[], explanations: readonly ExplanationController[]) => ResolvedLayoutResult;

package/dist/types/{src/kit/types.d.ts → kit/mount-types.d.ts}

@@ -1,7 +1,7 @@
-import { AttachedDesignSystem, DesignSystemConfig, DesignSystemRegistry, ResolvedDesignSystem } from '../../design-system';
-import { FormController, FormHooks, FormSchema, FormValidator, InactiveFieldPolicy, Registry, Transport } from '../../engine';
-import { PrimitiveContainerStrategy, PrimitiveLayout, PrimitiveRegistry, PrimitiveReportTransport, PrimitiveTextOverrides } from '../../primitives';
-export type { ApiKeyAuthOptions, AuthOptions, BearerAuthOptions, CacheOptions, CapabilityRequirement, CircuitBreakerOptions, CircuitBreakerSharedState, CircuitBreakerStateSnapshot, CustomAuthOptions, DedupOptions, FanoutTransportFailure, FanoutTransportOptions, FanoutTransportResult, FallbackTransportFailure, FallbackTransportOptions, GraphqlTransportOptions, GrpcSessionTransportOptions, GrpcStreamTransportOptions, GrpcTransportOptions, GrpcUnaryTransportOptions, HedgedTransportOptions, JsonTransportMethod, JsonTransportOptions, LoadBalancingTransportOptions, PipelineStage, PipelineTransportOptions, QuorumFanoutTransportOptions, RateLimitLeaseRequest, RateLimitOptions, RacingTransportOptions, RetryOptions, RoutingTransportOptions, SessionTransportOptions, SharedRateLimiter, SharedRateLimiterLease, SseTransportOptions, TransportCacheEntry, TransportCacheStore, TransportCollection, TransportContextAuthOptions, TransportHealthSnapshot, TransportHealthState, TransportLogOptions, TransportMetricsOptions, TransportMiddleware, TransportTelemetryEvent, TransportTraceOptions, WebSocketSessionTransportOptions, WeightedRoutingTransportOptions, } from '../../transport';
+import { AttachedDesignSystem, DesignSystemConfig, DesignSystemRegistry, ResolvedDesignSystem } from '../design-system';
+import { FormController, FormHooks, FormSchema, FormValidator, InactiveFieldPolicy, Registry, Transport } from '../runtime';
+import { PrimitiveContainerStrategy, PrimitiveLayout, PrimitiveRegistry, PrimitiveReportTransport, PrimitiveTextOverrides } from '../primitives';
+import { PresentationRegistry } from '../presentation';
 export interface KitDesignSystemSnapshot extends Omit<DesignSystemConfig, "mode" | "theme" | "recipe"> {
     mode: NonNullable<DesignSystemConfig["mode"]>;
     theme: NonNullable<DesignSystemConfig["theme"]>;
@@ -18,6 +18,7 @@ export interface MountFormOptions {
     schema: FormSchema;
     transport: Transport;
     registry?: Registry;
+    presentationRegistry?: PresentationRegistry;
     primitiveRegistry?: PrimitiveRegistry;
     designSystemRegistry?: DesignSystemRegistry;
     designSystem?: DesignSystemConfig;
@@ -42,6 +43,7 @@ export interface MountedForm {
     readonly form: FormController;
     readonly host: HTMLElement;
     readonly engineRegistry: Registry;
+    readonly presentationRegistry: PresentationRegistry;
     readonly primitiveRegistry: PrimitiveRegistry;
     readonly designSystemRegistry: DesignSystemRegistry;
     readonly designSystem: AttachedDesignSystem;

package/dist/types/kit/panel-nav.d.ts

@@ -0,0 +1,9 @@
+export interface PanelState {
+    kind: "wizard-step" | "tab" | "accordion-section";
+    index: number;
+    count: number;
+    currentId: string;
+    canGoNext: boolean;
+    canGoPrev: boolean;
+}
+export declare const createIndexedPanelState: (kind: PanelState["kind"], index: number, ids: readonly string[]) => PanelState | null;

package/dist/types/{src/questionnaire/primitives/components → kit}/step-indicator.d.ts

@@ -1,6 +1,6 @@
 import { LitElement } from 'lit';
-import { questionnaireTagNames } from '../../constants';
-export declare class QuestionnaireStepIndicatorElement extends LitElement {
+import { kitTagNames } from './constants';
+export declare class KitStepIndicatorElement extends LitElement {
     static styles: import('lit').CSSResult;
     accessor current: number;
     accessor total: number;
@@ -9,6 +9,6 @@ export declare class QuestionnaireStepIndicatorElement extends LitElement {
 }
 declare global {
     interface HTMLElementTagNameMap {
-        [questionnaireTagNames.stepIndicator]: QuestionnaireStepIndicatorElement;
+        [kitTagNames.stepIndicator]: KitStepIndicatorElement;
     }
 }

package/dist/types/kit/tabs-root-styles.d.ts

@@ -0,0 +1 @@
+export declare const tabsRootStyles: import('lit').CSSResult;

package/dist/types/kit/tabs-root.d.ts

@@ -0,0 +1,24 @@
+import { LitElement } from 'lit';
+import { PrimitiveText } from '../primitives/constants';
+import { PrimitiveRegistry } from '../primitives/types';
+import { kitTagNames } from './constants';
+import { FormViewController } from './types';
+export declare class KitTabsElement extends LitElement {
+    #private;
+    static styles: import('lit').CSSResult;
+    accessor view: FormViewController | undefined;
+    accessor registry: PrimitiveRegistry | undefined;
+    accessor primitiveText: PrimitiveText;
+    accessor submitLabel: string;
+    accessor validatingLabel: string;
+    accessor submittingLabel: string;
+    private accessor snapshot;
+    protected willUpdate(changed: Map<string, unknown>): void;
+    disconnectedCallback(): void;
+    render(): import('lit').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        [kitTagNames.tabs]: KitTabsElement;
+    }
+}

package/dist/types/kit/tabs.d.ts

@@ -0,0 +1,2 @@
+import { MountTabsFormOptions, MountedTabsForm } from './types';
+export declare const mountTabsForm: (container: HTMLElement, options: MountTabsFormOptions) => MountedTabsForm;

package/dist/types/kit/types.d.ts

@@ -0,0 +1,5 @@
+export type { FormLayoutNode, FormLayoutSectionNode, FormLayoutGroupNode, FormLayoutFieldNode, FormLayoutReportNode, FormLayoutExplanationNode, SinglePageLayoutConfig, WizardStepConfig, WizardLayoutConfig, TabLayoutConfig, TabsLayoutConfig, AccordionSectionConfig, AccordionLayoutConfig, FormLayoutConfig, ResolvedFormLayoutNode, ResolvedFormLayoutSectionNode, ResolvedFormLayoutGroupNode, ResolvedFormLayoutFieldNode, ResolvedFormLayoutReportNode, ResolvedFormLayoutExplanationNode, ResolvedSinglePageLayout, ResolvedWizardStep, ResolvedWizardLayout, ResolvedTabLayout, ResolvedTabsLayout, ResolvedAccordionSection, ResolvedAccordionLayout, ResolvedFormLayout, } from './layout-types';
+export type { KitDesignSystemSnapshot, KitLabels, MountFormOptions, MountedForm, } from './mount-types';
+export type { WizardState, TabsState, AccordionState, FormViewFieldItem, FormViewReportItem, FormViewExplanationItem, FormViewState, FormViewSnapshot, CreateFormViewOptions, FormViewController, WizardMountUiOptions, MountWizardFormOptions, MountedWizardForm, TabsMountUiOptions, MountTabsFormOptions, MountedTabsForm, AccordionMountUiOptions, MountAccordionFormOptions, MountedAccordionForm, LayoutReferences, PanelState, } from './view-types';
+export type { WizardLabels, WizardTextOverrides } from './wizard-constants';
+export type { ApiKeyAuthOptions, AuthOptions, BearerAuthOptions, CacheOptions, CapabilityRequirement, CircuitBreakerOptions, CircuitBreakerSharedState, CircuitBreakerStateSnapshot, CustomAuthOptions, DedupOptions, FanoutTransportFailure, FanoutTransportOptions, FanoutTransportResult, FallbackTransportFailure, FallbackTransportOptions, GraphqlTransportOptions, GrpcSessionTransportOptions, GrpcStreamTransportOptions, GrpcTransportOptions, GrpcUnaryTransportOptions, HedgedTransportOptions, JsonTransportMethod, JsonTransportOptions, LoadBalancingTransportOptions, PipelineStage, PipelineTransportOptions, QuorumFanoutTransportOptions, RateLimitLeaseRequest, RateLimitOptions, RacingTransportOptions, RetryOptions, RoutingTransportOptions, SessionTransportOptions, SharedRateLimiter, SharedRateLimiterLease, SseTransportOptions, TransportCacheEntry, TransportCacheStore, TransportCollection, TransportContextAuthOptions, TransportHealthSnapshot, TransportHealthState, TransportLogOptions, TransportMetricsOptions, TransportMiddleware, TransportTelemetryEvent, TransportTraceOptions, WebSocketSessionTransportOptions, WeightedRoutingTransportOptions, } from '../transport';

package/dist/types/kit/view-layout-state.d.ts

@@ -0,0 +1,14 @@
+import { AccordionState, FormViewState, TabsState, WizardState, ResolvedFormLayout } from './types';
+type LayoutStateOptions = {
+    layout: ResolvedFormLayout;
+    stepIndex: number;
+    activeTabIndex: number;
+    openSectionIds: Set<string>;
+    formState: FormViewState["form"];
+};
+export declare const getWizardState: ({ layout, stepIndex, formState, }: LayoutStateOptions) => WizardState | null;
+export declare const getTabsState: ({ layout, activeTabIndex }: LayoutStateOptions) => TabsState | null;
+export declare const getAccordionState: ({ layout, openSectionIds, }: LayoutStateOptions) => AccordionState | null;
+export declare const createFormViewState: (options: LayoutStateOptions) => FormViewState;
+export declare const isVisibleInLayout: (layout: ResolvedFormLayout, stepIndex: number, activeTabIndex: number, openSectionIds: Set<string>, stepId: string | null, tabId: string | null) => boolean;
+export {};

package/dist/types/kit/view-navigation.d.ts

@@ -0,0 +1,8 @@
+import { FormController } from '../runtime';
+import { ResolvedLayoutResult } from './layout';
+export declare const validateCurrentWizardStep: (form: FormController, resolvedLayout: ResolvedLayoutResult, stepIndex: number) => Promise<boolean>;
+export declare const getActiveLayoutNodes: (resolvedLayout: ResolvedLayoutResult, stepIndex: number, activeTabIndex: number, openSectionIds: Set<string>) => import('./layout-types').ResolvedFormLayoutNode[];
+export declare const assertAccordionSection: (resolvedLayout: ResolvedLayoutResult, accordionSections: readonly {
+    id: string;
+}[], sectionId: string) => void;
+export declare const assertAccordionLayout: (resolvedLayout: ResolvedLayoutResult) => void;

package/dist/types/kit/view-snapshot-cache.d.ts

@@ -0,0 +1,14 @@
+import { PresentationRegistry } from '../presentation';
+import { FormController } from '../runtime';
+import { ResolvedLayoutResult } from './layout';
+import { FormViewSnapshot } from './types';
+type SnapshotCacheOptions = {
+    form: FormController;
+    presentationRegistry: PresentationRegistry;
+    resolvedLayout: ResolvedLayoutResult;
+    getStepIndex: () => number;
+    getActiveTabIndex: () => number;
+    getOpenSectionIds: () => Set<string>;
+};
+export declare const createFormViewSnapshotCache: ({ form, presentationRegistry, resolvedLayout, getStepIndex, getActiveTabIndex, getOpenSectionIds, }: SnapshotCacheOptions) => (() => FormViewSnapshot);
+export {};

package/dist/types/kit/view-snapshot.d.ts

@@ -0,0 +1,15 @@
+import { PresentationRegistry } from '../presentation';
+import { FormController } from '../runtime';
+import { FormViewSnapshot } from './types';
+import { ResolvedLayoutResult } from './layout';
+type BuildSnapshotOptions = {
+    form: FormController;
+    presentationRegistry: PresentationRegistry;
+    resolvedLayout: ResolvedLayoutResult;
+    stepIndex: number;
+    activeTabIndex: number;
+    openSectionIds: Set<string>;
+};
+export declare const buildFormViewSnapshot: ({ form, presentationRegistry, resolvedLayout, stepIndex, activeTabIndex, openSectionIds, }: BuildSnapshotOptions) => FormViewSnapshot;
+export declare const createViewState: (form: FormController, layout: ResolvedLayoutResult["layout"], stepIndex: number, activeTabIndex: number, openSectionIds: Set<string>) => import('./view-types').FormViewState;
+export {};

package/dist/types/kit/view-types.d.ts

@@ -0,0 +1,172 @@
+import { DesignSystemConfig, DesignSystemRegistry, ResolvedDesignSystem, AttachedDesignSystem } from '../design-system';
+import { ExplanationDescriptor, FieldDescriptor, PresentationRegistry, ReportDescriptor } from '../presentation';
+import { ExplanationController, ExplanationStateSnapshot, FieldController, FieldStateSnapshot, FormController, FormState, FormValidationResult, Registry, ReportController, ReportStateSnapshot, SubmitOptions, SubmitResult } from '../runtime';
+import { PrimitiveRegistry, PrimitiveTextOverrides } from '../primitives';
+import { LayoutReferences } from './layout-utils';
+import { FormLayoutConfig, ResolvedFormLayout, ResolvedFormLayoutNode } from './layout-types';
+import { MountFormOptions, KitLabels } from './mount-types';
+import { PanelState } from './panel-nav';
+import { WizardLabels, WizardTextOverrides } from './wizard-constants';
+export interface WizardState {
+    stepIndex: number;
+    stepCount: number;
+    currentStepId: string;
+    canNext: boolean;
+    canPrev: boolean;
+    isLastStep: boolean;
+}
+export interface TabsState {
+    activeTabIndex: number;
+    tabCount: number;
+    currentTabId: string;
+    canGoNext: boolean;
+    canGoPrev: boolean;
+}
+export interface AccordionState {
+    openSectionIds: string[];
+    sectionCount: number;
+}
+export interface FormViewFieldItem {
+    id: string;
+    kind: string;
+    config: FieldController["config"];
+    controller: FieldController;
+    state: FieldStateSnapshot;
+    descriptor: FieldDescriptor;
+    stepId: string | null;
+    tabId: string | null;
+    visibleInLayout: boolean;
+}
+export interface FormViewReportItem {
+    id: string;
+    kind: string;
+    config: ReportController["config"];
+    controller: ReportController;
+    state: ReportStateSnapshot;
+    descriptor: ReportDescriptor | null;
+    stepId: string | null;
+    tabId: string | null;
+    visibleInLayout: boolean;
+}
+export interface FormViewExplanationItem {
+    id: string;
+    kind: string;
+    config: ExplanationController["config"];
+    controller: ExplanationController;
+    state: ExplanationStateSnapshot;
+    descriptor: ExplanationDescriptor | null;
+    stepId: string | null;
+    tabId: string | null;
+    visibleInLayout: boolean;
+}
+export interface FormViewState {
+    form: FormState;
+    wizard: WizardState | null;
+    tabs: TabsState | null;
+    accordion: AccordionState | null;
+}
+export interface FormViewSnapshot {
+    form: FormState;
+    layout: ResolvedFormLayout;
+    fields: FormViewFieldItem[];
+    reports: FormViewReportItem[];
+    explanations: FormViewExplanationItem[];
+    wizard: WizardState | null;
+    tabs: TabsState | null;
+    accordion: AccordionState | null;
+}
+export interface CreateFormViewOptions extends Omit<MountFormOptions, "layout"> {
+    layout?: FormLayoutConfig;
+}
+export interface FormViewController {
+    readonly form: FormController;
+    readonly engineRegistry: Registry;
+    readonly presentationRegistry: PresentationRegistry;
+    readonly primitiveRegistry: PrimitiveRegistry;
+    readonly designSystemRegistry: DesignSystemRegistry;
+    readonly state: FormViewState;
+    getSnapshot(): FormViewSnapshot;
+    getNodeById(id: string): ResolvedFormLayoutNode | undefined;
+    getField(id: string): FormViewFieldItem | undefined;
+    getReport(id: string): FormViewReportItem | undefined;
+    getExplanation(id: string): FormViewExplanationItem | undefined;
+    getVisibleFields(): FormViewFieldItem[];
+    getVisibleReports(): FormViewReportItem[];
+    getVisibleExplanations(): FormViewExplanationItem[];
+    getActiveLayoutNodes(): ResolvedFormLayoutNode[];
+    getLayoutReferences(): LayoutReferences;
+    validate(): Promise<FormValidationResult>;
+    submit(options?: SubmitOptions): Promise<SubmitResult>;
+    reset(): void;
+    subscribe(listener: (snapshot: FormViewSnapshot) => void): () => void;
+    nextStep(): Promise<boolean>;
+    prevStep(): void;
+    goToStep(stepId: string): Promise<boolean>;
+    setActiveTab(tabId: string): void;
+    nextTab(): boolean;
+    prevTab(): boolean;
+    toggleSection(sectionId: string): void;
+    openSection(sectionId: string): void;
+    closeSection(sectionId: string): void;
+    openAllSections(): void;
+    closeAllSections(): void;
+}
+export interface WizardMountUiOptions {
+    labels?: WizardLabels;
+    text?: WizardTextOverrides;
+    primitiveText?: PrimitiveTextOverrides;
+    designSystem?: DesignSystemConfig;
+    designSystemRegistry?: DesignSystemRegistry;
+    onDesignSystemChange?: (resolved: ResolvedDesignSystem) => void;
+}
+export type MountWizardFormOptions = ({
+    view: FormViewController;
+} & WizardMountUiOptions) | (CreateFormViewOptions & WizardMountUiOptions & {
+    layout: import('./layout-types').WizardLayoutConfig;
+});
+export interface MountedWizardForm {
+    readonly view: FormViewController;
+    readonly form: FormController;
+    readonly host: HTMLElement;
+    readonly designSystem: AttachedDesignSystem;
+    unmount(): void;
+}
+export interface TabsMountUiOptions {
+    labels?: KitLabels;
+    primitiveText?: PrimitiveTextOverrides;
+    designSystem?: DesignSystemConfig;
+    designSystemRegistry?: DesignSystemRegistry;
+    onDesignSystemChange?: (resolved: ResolvedDesignSystem) => void;
+}
+export type MountTabsFormOptions = ({
+    view: FormViewController;
+} & TabsMountUiOptions) | (CreateFormViewOptions & TabsMountUiOptions & {
+    layout: import('./layout-types').TabsLayoutConfig;
+});
+export interface MountedTabsForm {
+    readonly view: FormViewController;
+    readonly form: FormController;
+    readonly host: HTMLElement;
+    readonly designSystem: AttachedDesignSystem;
+    unmount(): void;
+}
+export interface AccordionMountUiOptions {
+    labels?: KitLabels;
+    primitiveText?: PrimitiveTextOverrides;
+    designSystem?: DesignSystemConfig;
+    designSystemRegistry?: DesignSystemRegistry;
+    onDesignSystemChange?: (resolved: ResolvedDesignSystem) => void;
+}
+export type MountAccordionFormOptions = ({
+    view: FormViewController;
+} & AccordionMountUiOptions) | (CreateFormViewOptions & AccordionMountUiOptions & {
+    layout: import('./layout-types').AccordionLayoutConfig;
+});
+export interface MountedAccordionForm {
+    readonly view: FormViewController;
+    readonly form: FormController;
+    readonly host: HTMLElement;
+    readonly designSystem: AttachedDesignSystem;
+    unmount(): void;
+}
+export type { LayoutReferences, PanelState };

package/dist/types/kit/view.d.ts

@@ -0,0 +1,8 @@
+import { PresentationRegistry } from '../presentation';
+import { CreateFormViewOptions, FormViewController } from './types';
+type InternalCreateFormViewOptions = CreateFormViewOptions & {
+    presentationRegistry?: PresentationRegistry;
+    behaviors?: import('../runtime').RuntimeBehavior[];
+};
+export declare const createFormView: (options: InternalCreateFormViewOptions) => FormViewController;
+export {};

package/dist/types/kit/wizard-constants.d.ts

@@ -0,0 +1,19 @@
+export interface WizardLabels {
+    prev?: string;
+    next?: string;
+    submit?: string;
+    validating?: string;
+    submitting?: string;
+}
+export interface WizardText {
+    stepLabel: (current: number, total: number) => string;
+    prevLabel: string;
+    nextLabel: string;
+    submitLabel: string;
+    validatingLabel: string;
+    submittingLabel: string;
+}
+export type WizardTextOverrides = Partial<WizardText>;
+export declare const defaultWizardLabels: Required<WizardLabels>;
+export declare const wizardStaticText: WizardText;
+export declare const resolveWizardText: (overrides?: WizardTextOverrides) => WizardText;

package/dist/types/kit/wizard-root-styles.d.ts

@@ -0,0 +1 @@
+export declare const wizardRootStyles: import('lit').CSSResult;

package/dist/types/kit/wizard-root.d.ts

@@ -0,0 +1,23 @@
+import { LitElement } from 'lit';
+import { PrimitiveText } from '../primitives/constants';
+import { PrimitiveRegistry } from '../primitives/types';
+import { kitTagNames } from './constants';
+import { FormViewController } from './types';
+export declare class KitWizardElement extends LitElement {
+    #private;
+    static styles: import('lit').CSSResult;
+    accessor view: FormViewController | undefined;
+    accessor registry: PrimitiveRegistry | undefined;
+    accessor primitiveText: PrimitiveText;
+    accessor labels: Required<import('./wizard-constants').WizardLabels>;
+    accessor text: import('./wizard-constants').WizardText;
+    private accessor snapshot;
+    protected willUpdate(changed: Map<string, unknown>): void;
+    disconnectedCallback(): void;
+    render(): import('lit').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        [kitTagNames.wizard]: KitWizardElement;
+    }
+}

package/dist/types/kit/wizard.d.ts

@@ -0,0 +1,2 @@
+import { MountWizardFormOptions, MountedWizardForm } from './types';
+export declare const mountWizardForm: (container: HTMLElement, options: MountWizardFormOptions) => MountedWizardForm;

package/dist/types/packs/default.d.ts

@@ -0,0 +1,2 @@
+import { RegistryPack } from './shared';
+export declare const createDefaultRegistryPack: () => RegistryPack;

package/dist/types/packs/index.d.ts

@@ -0,0 +1,3 @@
+export { createDefaultRegistryPack } from './default';
+export { createMlRegistryPack } from './ml';
+export type { RegistryPack } from './shared';

package/dist/types/packs/ml.d.ts

@@ -0,0 +1,2 @@
+import { RegistryPack } from './shared';
+export declare const createMlRegistryPack: () => RegistryPack;

package/dist/types/packs/shared.d.ts

@@ -0,0 +1,24 @@
+import { ExplanationPresenter, FieldPresenter, PresentationRegistry, ReportPresenter } from '../presentation';
+import { RuntimeBehavior } from '../runtime';
+import { ExplanationConfig, FieldConfig, Registry, ReportConfig } from '../schema';
+type DescriptorCapableFieldDefinition = {
+    kind: string;
+    describe?: FieldPresenter<FieldConfig, unknown>["describe"];
+};
+type DescriptorCapableReportDefinition = {
+    kind: string;
+    describe?: ReportPresenter<ReportConfig>["describe"];
+};
+type DescriptorCapableExplanationDefinition = {
+    kind: string;
+    describe?: ExplanationPresenter<ExplanationConfig>["describe"];
+};
+export type RegistryPack = {
+    registry: Registry;
+    presentationRegistry: PresentationRegistry;
+    behaviors: RuntimeBehavior[];
+};
+export declare const registerFieldPresenterFromDefinition: (presentationRegistry: PresentationRegistry, definition: DescriptorCapableFieldDefinition) => void;
+export declare const registerReportPresenterFromDefinition: (presentationRegistry: PresentationRegistry, definition: DescriptorCapableReportDefinition) => void;
+export declare const registerExplanationPresenterFromDefinition: (presentationRegistry: PresentationRegistry, definition: DescriptorCapableExplanationDefinition) => void;
+export {};

package/dist/types/presentation/define-explanation-kind.d.ts

@@ -0,0 +1,11 @@
+import { ExplanationConfig, ExplanationDefinition, NormalizedExplanationConfig } from '../schema';
+import { DeclarativeExplanationKind, ExplanationDescriptor, ExplanationDescriptorContext, ExplanationPresenter } from './index';
+export type DefinedExplanationKind<TConfig extends ExplanationConfig, _TResult> = {
+    kind: string;
+    schema: import('zod').ZodType<TConfig>;
+    transport: ExplanationDefinition<TConfig>["transport"];
+    describe?: (config: NormalizedExplanationConfig<TConfig>, context: ExplanationDescriptorContext) => ExplanationDescriptor | null;
+    definition: ExplanationDefinition<TConfig>;
+    presenter: ExplanationPresenter<TConfig>;
+};
+export declare const defineExplanationKind: <TConfig extends ExplanationConfig, TResult>(kind: DeclarativeExplanationKind<TConfig, TResult>) => DefinedExplanationKind<TConfig, TResult>;