@reformer/ui 1.0.0-beta.1

package/dist/form-array/FormArrayEmpty.d.ts

@@ -0,0 +1,22 @@
+import type { FormArrayEmptyProps } from './types';
+/**
+ * FormArray.Empty - Renders children only when array is empty
+ *
+ * @example Basic usage
+ * ```tsx
+ * <FormArray.Empty>
+ *   <p className="text-gray-500">No items added yet</p>
+ * </FormArray.Empty>
+ * ```
+ *
+ * @example With call to action
+ * ```tsx
+ * <FormArray.Empty>
+ *   <div className="text-center p-8">
+ *     <p>No properties</p>
+ *     <FormArray.AddButton>Add your first property</FormArray.AddButton>
+ *   </div>
+ * </FormArray.Empty>
+ * ```
+ */
+export declare function FormArrayEmpty({ children }: FormArrayEmptyProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/form-array/FormArrayItemIndex.d.ts

@@ -0,0 +1,24 @@
+import type { FormArrayItemIndexProps } from './types';
+/**
+ * FormArray.ItemIndex - Displays the index of current item (must be inside FormArray.List)
+ *
+ * @example Basic usage (1-based display)
+ * ```tsx
+ * <FormArray.List>
+ *   {() => (
+ *     <h4>Item #<FormArray.ItemIndex render={(i) => i + 1} /></h4>
+ *   )}
+ * </FormArray.List>
+ * ```
+ *
+ * @example Zero-based index
+ * ```tsx
+ * <FormArray.ItemIndex /> // Renders 0, 1, 2, ...
+ * ```
+ *
+ * @example Custom render
+ * ```tsx
+ * <FormArray.ItemIndex render={(index) => `Position: ${index + 1}`} />
+ * ```
+ */
+export declare function FormArrayItemIndex({ render }: FormArrayItemIndexProps): import("react/jsx-runtime").JSX.Element;

package/dist/form-array/FormArrayList.d.ts

@@ -0,0 +1,26 @@
+import type { FormFields } from '@reformer/core';
+import type { FormArrayListProps } from './types';
+/**
+ * FormArray.List - Iterates over array items and provides item context
+ *
+ * @example Basic usage
+ * ```tsx
+ * <FormArray.List>
+ *   {({ control, index, remove }) => (
+ *     <div>
+ *       <span>Item #{index + 1}</span>
+ *       <button onClick={remove}>Remove</button>
+ *       <ItemForm control={control} />
+ *     </div>
+ *   )}
+ * </FormArray.List>
+ * ```
+ *
+ * @example With custom container
+ * ```tsx
+ * <FormArray.List className="space-y-4" as="ul">
+ *   {(item) => <li><ItemForm control={item.control} /></li>}
+ * </FormArray.List>
+ * ```
+ */
+export declare function FormArrayList<T extends FormFields>({ children, className, as, }: FormArrayListProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/form-array/FormArrayRemoveButton.d.ts

@@ -0,0 +1,19 @@
+import type { FormArrayRemoveButtonProps } from './types';
+/**
+ * FormArray.RemoveButton - Button to remove current item (must be inside FormArray.List)
+ *
+ * @example Basic usage
+ * ```tsx
+ * <FormArray.List>
+ *   {({ control }) => (
+ *     <div>
+ *       <ItemForm control={control} />
+ *       <FormArray.RemoveButton className="text-red-500">
+ *         Remove
+ *       </FormArray.RemoveButton>
+ *     </div>
+ *   )}
+ * </FormArray.List>
+ * ```
+ */
+export declare function FormArrayRemoveButton({ children, ...props }: FormArrayRemoveButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/form-array/index.d.ts

@@ -0,0 +1,13 @@
+export { FormArray } from './FormArray';
+export type { FormArrayHandle } from './FormArray';
+export { FormArrayList } from './FormArrayList';
+export { FormArrayAddButton } from './FormArrayAddButton';
+export { FormArrayRemoveButton } from './FormArrayRemoveButton';
+export { FormArrayEmpty } from './FormArrayEmpty';
+export { FormArrayCount } from './FormArrayCount';
+export { FormArrayItemIndex } from './FormArrayItemIndex';
+export { useFormArray } from './useFormArray';
+export type { FormArrayItem, UseFormArrayReturn } from './useFormArray';
+export { FormArrayContext, FormArrayItemContext, useFormArrayContext, useFormArrayItemContext, } from './FormArrayContext';
+export type { FormArrayRootProps, FormArrayListProps, FormArrayItemRenderProps, FormArrayAddButtonProps, FormArrayRemoveButtonProps, FormArrayEmptyProps, FormArrayCountProps, FormArrayItemIndexProps, } from './types';
+export type { FormArrayContextValue, FormArrayItemContextValue } from './FormArrayContext';

package/dist/form-array/types.d.ts

@@ -0,0 +1,72 @@
+import type { ReactNode, ElementType } from 'react';
+import type { ArrayNode, FormFields, GroupNodeWithControls } from '@reformer/core';
+/**
+ * Props for FormArray.Root component
+ */
+export interface FormArrayRootProps<T extends FormFields> {
+    /** The ArrayNode control from the form */
+    control: ArrayNode<T>;
+    /** Child components */
+    children: ReactNode;
+}
+/**
+ * Props for FormArray.List component
+ */
+export interface FormArrayListProps<T extends FormFields> {
+    /** Render function for each item */
+    children: (item: FormArrayItemRenderProps<T>) => ReactNode;
+    /** Optional className for the list container */
+    className?: string;
+    /** Optional element type for the container (default: 'div') */
+    as?: ElementType;
+}
+/**
+ * Props passed to the render function in FormArray.List
+ */
+export interface FormArrayItemRenderProps<T extends FormFields> {
+    /** The form control for this item */
+    control: GroupNodeWithControls<T>;
+    /** Zero-based index of the item */
+    index: number;
+    /** Unique identifier for React key */
+    id: string | number;
+    /** Remove this item from the array */
+    remove: () => void;
+}
+/**
+ * Props for FormArray.AddButton component
+ */
+export interface FormArrayAddButtonProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'onClick'> {
+    /** Initial value for the new item */
+    initialValue?: Partial<FormFields>;
+    /** Custom render function for the button */
+    asChild?: boolean;
+}
+/**
+ * Props for FormArray.RemoveButton component
+ */
+export interface FormArrayRemoveButtonProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'onClick'> {
+    /** Custom render function for the button */
+    asChild?: boolean;
+}
+/**
+ * Props for FormArray.Empty component
+ */
+export interface FormArrayEmptyProps {
+    /** Content to show when array is empty */
+    children: ReactNode;
+}
+/**
+ * Props for FormArray.Count component
+ */
+export interface FormArrayCountProps {
+    /** Custom render function for the count */
+    render?: (count: number) => ReactNode;
+}
+/**
+ * Props for FormArray.ItemIndex component
+ */
+export interface FormArrayItemIndexProps {
+    /** Custom render function for the index (receives 0-based index) */
+    render?: (index: number) => ReactNode;
+}

package/dist/form-array/useFormArray.d.ts

@@ -0,0 +1,66 @@
+import { type ArrayNode, type FormFields, type GroupNodeWithControls } from '@reformer/core';
+/**
+ * Represents a single item in a form array with its control, index, and actions
+ */
+export interface FormArrayItem<T extends FormFields> {
+    /** The form control for this item */
+    control: GroupNodeWithControls<T>;
+    /** Zero-based index of the item in the array */
+    index: number;
+    /** Unique identifier for React key (uses internal id or falls back to index) */
+    id: string | number;
+    /** Remove this item from the array */
+    remove: () => void;
+}
+/**
+ * Return type for useFormArray hook
+ */
+export interface UseFormArrayReturn<T extends FormFields> {
+    /** Array of items with their controls and actions */
+    items: FormArrayItem<T>[];
+    /** Current number of items in the array */
+    length: number;
+    /** Whether the array is empty */
+    isEmpty: boolean;
+    /** Add a new item to the end of the array */
+    add: (value?: Partial<T>) => void;
+    /** Remove all items from the array */
+    clear: () => void;
+    /** Insert a new item at a specific index */
+    insert: (index: number, value?: Partial<T>) => void;
+}
+/**
+ * Headless hook for managing form arrays
+ *
+ * Provides reactive state and actions for form array manipulation
+ * without any UI - perfect for building custom array interfaces.
+ *
+ * @example Basic usage
+ * ```tsx
+ * function PropertyList() {
+ *   const { items, add, isEmpty } = useFormArray(form.properties);
+ *
+ *   return (
+ *     <div>
+ *       {items.map(({ control, index, remove, id }) => (
+ *         <div key={id}>
+ *           <span>Property #{index + 1}</span>
+ *           <button onClick={remove}>Remove</button>
+ *           <PropertyForm control={control} />
+ *         </div>
+ *       ))}
+ *       {isEmpty && <p>No properties added</p>}
+ *       <button onClick={() => add()}>Add Property</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example With initial values
+ * ```tsx
+ * const { add } = useFormArray(form.items);
+ * // Add item with pre-filled values
+ * add({ name: 'New Item', quantity: 1 });
+ * ```
+ */
+export declare function useFormArray<T extends FormFields>(control: ArrayNode<T>): UseFormArrayReturn<T>;

package/dist/form-array.d.ts

@@ -0,0 +1,2 @@
+export * from './form-array/index'
+export {}

package/dist/form-array.js

@@ -0,0 +1,15 @@
+import { F as o, b as t, g as m, e as s, d as e, h as y, f as A, a as F, c as n, u, i as x, j as C } from "./FormArray-K2YVvq1u.js";
+export {
+  o as FormArray,
+  t as FormArrayAddButton,
+  m as FormArrayContext,
+  s as FormArrayCount,
+  e as FormArrayEmpty,
+  y as FormArrayItemContext,
+  A as FormArrayItemIndex,
+  F as FormArrayList,
+  n as FormArrayRemoveButton,
+  u as useFormArray,
+  x as useFormArrayContext,
+  C as useFormArrayItemContext
+};

package/dist/form-navigation/FormNavigation.d.ts

@@ -0,0 +1,16 @@
+import { FormNavigationStep } from './FormNavigationStep';
+import { FormNavigationIndicator } from './FormNavigationIndicator';
+import { FormNavigationActions } from './FormNavigationActions';
+import { FormNavigationProgress } from './FormNavigationProgress';
+import type { FormNavigationHandle, FormNavigationProps } from './types';
+declare const FormNavigationBase: <T extends Record<string, any>>(props: FormNavigationProps<T> & {
+    ref?: React.ForwardedRef<FormNavigationHandle<T>>;
+}) => React.ReactElement;
+type FormNavigationComponent = typeof FormNavigationBase & {
+    Step: typeof FormNavigationStep;
+    Indicator: typeof FormNavigationIndicator;
+    Actions: typeof FormNavigationActions;
+    Progress: typeof FormNavigationProgress;
+};
+export declare const FormNavigation: FormNavigationComponent;
+export {};

package/dist/form-navigation/FormNavigationActions.d.ts

@@ -0,0 +1,113 @@
+import type { ReactNode } from 'react';
+/**
+ * Props for a navigation button (prev/next)
+ */
+export interface FormNavigationButtonProps {
+    /** Click handler */
+    onClick: () => void;
+    /** Whether the button is disabled */
+    disabled: boolean;
+}
+/**
+ * Props for the submit button
+ */
+export interface FormNavigationSubmitProps extends FormNavigationButtonProps {
+    /** Whether form is currently submitting */
+    isSubmitting: boolean;
+}
+/**
+ * Render props passed to children function
+ */
+export interface FormNavigationActionsRenderProps {
+    /** Props for the "Previous" button */
+    prev: FormNavigationButtonProps;
+    /** Props for the "Next" button */
+    next: FormNavigationButtonProps;
+    /** Props for the "Submit" button */
+    submit: FormNavigationSubmitProps;
+    /** Whether current step is the first step */
+    isFirstStep: boolean;
+    /** Whether current step is the last step */
+    isLastStep: boolean;
+    /** Whether validation is in progress */
+    isValidating: boolean;
+    /** Whether form is submitting */
+    isSubmitting: boolean;
+}
+/**
+ * Props for FormNavigation.Actions component
+ */
+export interface FormNavigationActionsProps {
+    /** Submit handler (called on last step) */
+    onSubmit?: () => void | Promise<void>;
+    /** Render function for custom UI */
+    children: (props: FormNavigationActionsRenderProps) => ReactNode;
+}
+/**
+ * FormNavigation.Actions - Headless component for navigation buttons
+ *
+ * Provides all necessary props and state for building custom navigation UI.
+ * No default UI - you build exactly what you need.
+ *
+ * ## Render Props
+ * - `prev` - props for Previous button (`onClick`, `disabled`)
+ * - `next` - props for Next button (`onClick`, `disabled`)
+ * - `submit` - props for Submit button (`onClick`, `disabled`, `isSubmitting`)
+ * - `isFirstStep` - hide prev button on first step
+ * - `isLastStep` - show submit instead of next on last step
+ * - `isValidating` - show loading state during validation
+ * - `isSubmitting` - show loading state during submission
+ *
+ * @example Basic usage
+ * ```tsx
+ * <FormNavigation.Actions onSubmit={handleSubmit}>
+ *   {({ prev, next, submit, isFirstStep, isLastStep }) => (
+ *     <div className="flex justify-between">
+ *       {!isFirstStep && (
+ *         <Button onClick={prev.onClick} disabled={prev.disabled}>
+ *           Back
+ *         </Button>
+ *       )}
+ *       <div className="flex-1" />
+ *       {!isLastStep ? (
+ *         <Button onClick={next.onClick} disabled={next.disabled}>
+ *           Next
+ *         </Button>
+ *       ) : (
+ *         <Button onClick={submit.onClick} disabled={submit.disabled}>
+ *           {submit.isSubmitting ? 'Submitting...' : 'Submit'}
+ *         </Button>
+ *       )}
+ *     </div>
+ *   )}
+ * </FormNavigation.Actions>
+ * ```
+ *
+ * @example With custom button component
+ * ```tsx
+ * <FormNavigation.Actions onSubmit={handleSubmit}>
+ *   {({ prev, next, submit, isFirstStep, isLastStep, isValidating }) => (
+ *     <ActionBar>
+ *       <ActionBar.Left>
+ *         {!isFirstStep && <IconButton icon="arrow-left" {...prev} />}
+ *       </ActionBar.Left>
+ *       <ActionBar.Right>
+ *         {isLastStep ? (
+ *           <PrimaryButton {...submit} loading={submit.isSubmitting}>
+ *             Submit Application
+ *           </PrimaryButton>
+ *         ) : (
+ *           <PrimaryButton {...next} loading={isValidating}>
+ *             Continue
+ *           </PrimaryButton>
+ *         )}
+ *       </ActionBar.Right>
+ *     </ActionBar>
+ *   )}
+ * </FormNavigation.Actions>
+ * ```
+ */
+export declare function FormNavigationActions({ onSubmit, children }: FormNavigationActionsProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace FormNavigationActions {
+    var displayName: string;
+}

package/dist/form-navigation/FormNavigationContext.d.ts

@@ -0,0 +1,42 @@
+import type { GroupNodeWithControls } from '@reformer/core';
+/**
+ * Context value for FormNavigation
+ * Shares navigation state and methods with child components
+ */
+export interface FormNavigationContextValue<T extends Record<string, any>> {
+    /** Current step (1-based) */
+    currentStep: number;
+    /** Total number of steps */
+    totalSteps: number;
+    /** Completed steps */
+    completedSteps: number[];
+    /** Is this the first step */
+    isFirstStep: boolean;
+    /** Is this the last step */
+    isLastStep: boolean;
+    /** Is validation in progress */
+    isValidating: boolean;
+    /** Is form submitting */
+    isSubmitting: boolean;
+    /** Form instance */
+    form: GroupNodeWithControls<T>;
+    /** Go to next step (with validation) */
+    goToNextStep: () => Promise<boolean>;
+    /** Go to previous step */
+    goToPreviousStep: () => void;
+    /** Go to specific step */
+    goToStep: (step: number) => boolean;
+}
+export declare const FormNavigationContext: import("react").Context<FormNavigationContextValue<any> | null>;
+/**
+ * Hook to access FormNavigation context
+ *
+ * @example
+ * ```tsx
+ * function MyStepComponent() {
+ *   const { currentStep, isLastStep } = useFormNavigation();
+ *   // ...
+ * }
+ * ```
+ */
+export declare function useFormNavigation<T extends Record<string, any>>(): FormNavigationContextValue<T>;

package/dist/form-navigation/FormNavigationIndicator.d.ts

@@ -0,0 +1,113 @@
+import type { ReactNode } from 'react';
+/**
+ * Step definition for the indicator
+ */
+export interface FormNavigationIndicatorStep {
+    /** Step number (1-based) */
+    number: number;
+    /** Step title/label */
+    title: string;
+    /** Optional icon */
+    icon?: string;
+}
+/**
+ * Enriched step with state information
+ */
+export interface FormNavigationIndicatorStepWithState extends FormNavigationIndicatorStep {
+    /** Whether this is the current step */
+    isCurrent: boolean;
+    /** Whether this step is completed */
+    isCompleted: boolean;
+    /** Whether user can navigate to this step */
+    canNavigate: boolean;
+}
+/**
+ * Render props passed to children function
+ */
+export interface FormNavigationIndicatorRenderProps {
+    /** Steps with their current state */
+    steps: FormNavigationIndicatorStepWithState[];
+    /** Navigate to a specific step */
+    goToStep: (step: number) => boolean;
+    /** Current step number */
+    currentStep: number;
+    /** Total number of steps */
+    totalSteps: number;
+    /** Completed step numbers */
+    completedSteps: number[];
+}
+/**
+ * Props for FormNavigation.Indicator component
+ */
+export interface FormNavigationIndicatorProps {
+    /** Step definitions */
+    steps: FormNavigationIndicatorStep[];
+    /** Render function for custom UI */
+    children: (props: FormNavigationIndicatorRenderProps) => ReactNode;
+}
+/**
+ * FormNavigation.Indicator - Headless component for step indicator
+ *
+ * Provides step data with state for building custom step indicators.
+ * No default UI - you build exactly what you need.
+ *
+ * ## Render Props
+ * - `steps` - array of steps with state (`isCurrent`, `isCompleted`, `canNavigate`)
+ * - `goToStep` - function to navigate to a step
+ * - `currentStep` - current step number
+ * - `totalSteps` - total number of steps
+ * - `completedSteps` - array of completed step numbers
+ *
+ * @example Basic stepper
+ * ```tsx
+ * <FormNavigation.Indicator steps={STEPS}>
+ *   {({ steps, goToStep }) => (
+ *     <nav className="flex gap-2">
+ *       {steps.map((step) => (
+ *         <button
+ *           key={step.number}
+ *           onClick={() => goToStep(step.number)}
+ *           disabled={!step.canNavigate}
+ *           className={cn(
+ *             'px-4 py-2 rounded',
+ *             step.isCurrent && 'bg-blue-500 text-white',
+ *             step.isCompleted && 'bg-green-100',
+ *             !step.canNavigate && 'opacity-50 cursor-not-allowed'
+ *           )}
+ *         >
+ *           {step.icon} {step.title}
+ *         </button>
+ *       ))}
+ *     </nav>
+ *   )}
+ * </FormNavigation.Indicator>
+ * ```
+ *
+ * @example With progress line
+ * ```tsx
+ * <FormNavigation.Indicator steps={STEPS}>
+ *   {({ steps, goToStep }) => (
+ *     <div className="flex items-center">
+ *       {steps.map((step, index) => (
+ *         <Fragment key={step.number}>
+ *           <StepCircle
+ *             active={step.isCurrent}
+ *             completed={step.isCompleted}
+ *             onClick={() => step.canNavigate && goToStep(step.number)}
+ *           >
+ *             {step.isCompleted ? '✓' : step.number}
+ *           </StepCircle>
+ *           {index < steps.length - 1 && (
+ *             <StepLine completed={step.isCompleted} />
+ *           )}
+ *         </Fragment>
+ *       ))}
+ *     </div>
+ *   )}
+ * </FormNavigation.Indicator>
+ * ```
+ */
+export declare function FormNavigationIndicator({ steps, children }: FormNavigationIndicatorProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace FormNavigationIndicator {
+    var displayName: string;
+}

package/dist/form-navigation/FormNavigationProgress.d.ts

@@ -0,0 +1,83 @@
+import type { ReactNode } from 'react';
+/**
+ * Render props passed to children function
+ */
+export interface FormNavigationProgressRenderProps {
+    /** Current step number (1-based) */
+    current: number;
+    /** Total number of steps */
+    total: number;
+    /** Completion percentage (0-100) */
+    percent: number;
+    /** Number of completed steps */
+    completedCount: number;
+    /** Whether on first step */
+    isFirstStep: boolean;
+    /** Whether on last step */
+    isLastStep: boolean;
+}
+/**
+ * Props for FormNavigation.Progress component
+ */
+export interface FormNavigationProgressProps {
+    /** Render function for custom UI */
+    children: (props: FormNavigationProgressRenderProps) => ReactNode;
+}
+/**
+ * FormNavigation.Progress - Headless component for progress display
+ *
+ * Provides progress data for building custom progress indicators.
+ * No default UI - you build exactly what you need.
+ *
+ * ## Render Props
+ * - `current` - current step number
+ * - `total` - total number of steps
+ * - `percent` - completion percentage (0-100)
+ * - `completedCount` - number of completed steps
+ * - `isFirstStep` - whether on first step
+ * - `isLastStep` - whether on last step
+ *
+ * @example Simple text progress
+ * ```tsx
+ * <FormNavigation.Progress>
+ *   {({ current, total, percent }) => (
+ *     <div className="text-sm text-gray-600">
+ *       Step {current} of {total} ({percent}% complete)
+ *     </div>
+ *   )}
+ * </FormNavigation.Progress>
+ * ```
+ *
+ * @example Progress bar
+ * ```tsx
+ * <FormNavigation.Progress>
+ *   {({ percent, current, total }) => (
+ *     <div className="space-y-2">
+ *       <div className="flex justify-between text-sm">
+ *         <span>Step {current}/{total}</span>
+ *         <span>{percent}%</span>
+ *       </div>
+ *       <div className="h-2 bg-gray-200 rounded-full overflow-hidden">
+ *         <div
+ *           className="h-full bg-blue-500 transition-all"
+ *           style={{ width: `${percent}%` }}
+ *         />
+ *       </div>
+ *     </div>
+ *   )}
+ * </FormNavigation.Progress>
+ * ```
+ *
+ * @example Circular progress
+ * ```tsx
+ * <FormNavigation.Progress>
+ *   {({ percent }) => (
+ *     <CircularProgress value={percent} />
+ *   )}
+ * </FormNavigation.Progress>
+ * ```
+ */
+export declare function FormNavigationProgress({ children }: FormNavigationProgressProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace FormNavigationProgress {
+    var displayName: string;
+}

package/dist/form-navigation/FormNavigationStep.d.ts

@@ -0,0 +1,37 @@
+import type { ComponentType } from 'react';
+import type { GroupNodeWithControls } from '@reformer/core';
+/**
+ * Props for FormNavigation.Step component
+ */
+export interface FormNavigationStepProps<T extends Record<string, any>> {
+    /** Component to render for this step */
+    component: ComponentType<{
+        control: GroupNodeWithControls<T>;
+    } & Record<string, unknown>>;
+    /** Form control to pass to the component */
+    control: GroupNodeWithControls<T>;
+    /** Any additional props to pass to the component */
+    [key: string]: unknown;
+}
+/**
+ * Internal props that include the step index (set by parent FormNavigation)
+ */
+export interface FormNavigationStepInternalProps<T extends Record<string, any>> extends FormNavigationStepProps<T> {
+    /** Step index (1-based), set internally by FormNavigation */
+    _stepIndex?: number;
+}
+/**
+ * FormNavigation.Step - renders a step component when it's the current step
+ *
+ * @example
+ * ```tsx
+ * <FormNavigation ref={navRef} form={form} config={config}>
+ *   <FormNavigation.Step component={Step1} control={form} />
+ *   <FormNavigation.Step component={Step2} control={form} extraProp="value" />
+ * </FormNavigation>
+ * ```
+ */
+export declare function FormNavigationStep<T extends Record<string, any>>({ component: Component, control, _stepIndex, ...restProps }: FormNavigationStepInternalProps<T>): import("react/jsx-runtime").JSX.Element | null;
+export declare namespace FormNavigationStep {
+    var displayName: string;
+}