@jfdevelops/react-multi-step-form 1.0.0-alpha.2 → 1.0.0-alpha.20

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

@@ -1,161 +0,0 @@
-import { Expand, HelperFnChosenSteps, StepNumbers, ValidStepKey } from '@jfdevelops/multi-step-form';
-import { ComponentPropsWithRef, JSX } from 'react';
-import { AnyResolvedStep, CreatedMultiStepFormComponent } from './step-schema';
-export declare namespace MultiStepFormSchemaConfig {
-    export const DEFAULT_FORM_ALIAS = "Form";
-    export type defaultEnabledFor = HelperFnChosenSteps.defaultStringOption;
-    export type defaultFormAlias = typeof DEFAULT_FORM_ALIAS;
-    export type formEnabledFor<TResolvedStep extends AnyResolvedStep> = HelperFnChosenSteps<TResolvedStep, StepNumbers<TResolvedStep>>;
-    type strippedResolvedSteps<T extends AnyResolvedStep> = {
-        [_ in keyof T]: Expand<Omit<T[_], 'createComponent' | 'createHelperFn'>>;
-    };
-    export type AvailableStepForForm<TResolvedStep extends AnyResolvedStep, TEnabledFor extends formEnabledFor<TResolvedStep>> = TEnabledFor extends defaultEnabledFor ? strippedResolvedSteps<TResolvedStep> : TEnabledFor extends [
-        ValidStepKey<StepNumbers<TResolvedStep>>,
-        ...ValidStepKey<StepNumbers<TResolvedStep>>[]
-    ] ? TEnabledFor[number] extends keyof TResolvedStep ? Pick<strippedResolvedSteps<TResolvedStep>, TEnabledFor[number]> : never : keyof TEnabledFor extends keyof TResolvedStep ? Expand<Pick<strippedResolvedSteps<TResolvedStep>, Extract<keyof TResolvedStep, keyof TEnabledFor>>> : never;
-    export type formCtx<TAlias extends string, TProps> = {
-        [_ in TAlias]: CreatedMultiStepFormComponent<TProps>;
-    };
-    export type renderFnData<TResolvedStep extends AnyResolvedStep, TEnabledFor extends formEnabledFor<TResolvedStep>> = {
-        /**
-         * The id for the form, either a custom one or the default one.
-         */
-        id: string;
-        /**
-         * The chosen steps that are available.
-         */
-        steps: Expand<AvailableStepForForm<TResolvedStep, TEnabledFor>>;
-    };
-    /**
-     * The configuration options for the `form` option.
-     */
-    export interface FormConfig<TResolvedStep extends AnyResolvedStep, TAlias extends string, TFormEnabledFor extends formEnabledFor<TResolvedStep>, TCustomFormProps extends object> {
-        /**
-         * The `id` for the form component.
-         *
-         * If there is no value provided, the default id will the **current step key**.
-         *
-         * @default `${currentStep}`
-         */
-        id?: string;
-        /**
-         * The "name" of the form component.
-         * @default 'Form'
-         * @example
-         * ```tsx
-         * const schema = createMultiStepFormSchema({
-         *  steps: {
-         *    step1: {
-         *      title: 'Step 1',
-         *      fields: {
-         *        firstName: {
-         *          defaultValue: ''
-         *       }
-         *     }
-         *   },
-         *   form: {
-         *    alias: 'MyCustomForm',
-         *    render() {
-         *      // return custom form component here
-         *     }
-         *   }
-         *  }
-         * })
-         *
-         * const Step1 = schema.stepSchema.step1.createComponent(
-         *  ({ ctx, MyCustomForm }, props: { children: ReactNode }) =>
-         *     // Notice how the form is available with its alias
-         *     <MyCustomFormName>{children}</MyCustomFormName>
-         *  )
-         * ```
-         */
-        alias?: TAlias;
-        /**
-         * If the form component should be accessible for each step when calling `createComponent`.
-         *
-         * If no value is given, the form will be accessible for all the steps.
-         */
-        enabledForSteps?: TFormEnabledFor;
-        /**
-         *
-         * @param data The data that is available for creating the custom form.
-         * @param props Props that can be used for the custom form.
-         * @returns An {@see JSX.Element} that is the custom form.
-         * @example
-         * ### With custom props
-         * ```tsx
-         * type CustomProps = {
-         *   title: string;
-         *   description?: string;
-         *   children: ReactNode;
-         * };
-         *
-         * const schema = createMultiStepFormSchema({
-         *  steps: {
-         *    step1: {
-         *      title: 'Step 1',
-         *      fields: {
-         *        firstName: {
-         *          defaultValue: ''
-         *       }
-         *     }
-         *   },
-         *   form: {
-         *    alias: 'MyCustomForm',
-         *    render(data, props: CustomProps) {
-         *      return (
-         *         <div>
-         *          <h1>{props.title}</h1>
-         *          <p>{props.description}</p>
-         *          <form>{props.children}</form>
-         *         </div>
-         *       );
-         *     }
-         *   }
-         *  }
-         * })
-         * ```
-         * ### Without custom props
-         * ```tsx
-         * const schema = createMultiStepFormSchema({
-         *  steps: {
-         *    step1: {
-         *      title: 'Step 1',
-         *      fields: {
-         *        firstName: {
-         *          defaultValue: ''
-         *       }
-         *     }
-         *   },
-         *   form: {
-         *    alias: 'MyCustomForm',
-         *    render(data, props) {
-         *      // The default type for `props` will be `ComponentPropsWithRef<'form'>`
-         *      // return custom form component here
-         *     }
-         *   }
-         *  }
-         * })
-         * ```
-         */
-        render: (data: renderFnData<TResolvedStep, TFormEnabledFor>, props: TCustomFormProps) => JSX.Element;
-    }
-    export interface Form<TResolvedStep extends AnyResolvedStep, TAlias extends string, TFormEnabledFor extends formEnabledFor<TResolvedStep>, TCustomFormProps extends object> {
-        form?: FormConfig<TResolvedStep, TAlias, TFormEnabledFor, TCustomFormProps>;
-    }
-    /**
-     * Compares {@linkcode enabledFor} to the {@linkcode target} to determine if the form
-     * should be available.
-     * @param target The target steps the form _should_ be available for.
-     * @param enabledFor The steps that the form _is_ enabled for.
-     * @returns A boolean representing if the form should be available.
-     */
-    export function isFormAvailable<TResolvedStep extends AnyResolvedStep, TTarget extends HelperFnChosenSteps<TResolvedStep, StepNumbers<TResolvedStep>>, TEnabledFor extends formEnabledFor<TResolvedStep>>(target: TTarget, enabledFor: TEnabledFor): boolean;
-    /**
-     * Creates a form component with a default id.
-     * @param id The default id for the form.
-     * @returns A form component with a default {@linkcode id}.
-     */
-    export function createDefaultForm(id: string): (props: Omit<ComponentPropsWithRef<"form">, "id">) => import("react/jsx-runtime").JSX.Element;
-    export {};
-}

package/dist/types/hooks/use-multi-step-form-data.d.ts

@@ -1,26 +0,0 @@
-import { AnyMultiStepFormSchema, MultiStepFormSchema } from '../schema';
-export type UseMultiStepFormDataOptions<TSchema extends AnyMultiStepFormSchema, TTarget extends keyof MultiStepFormSchema.resolvedStep<TSchema> = keyof MultiStepFormSchema.resolvedStep<TSchema>> = {
-    targetStep: TTarget;
-};
-export type UseMultiStepFormData<TSchema extends AnyMultiStepFormSchema, TResolvedStep extends MultiStepFormSchema.resolvedStep<TSchema> = MultiStepFormSchema.resolvedStep<TSchema>> = {
-    /**
-     * Returns the entire {@linkcode MultiStepFormSchema instance}.
-     */
-    (): TSchema;
-    /**
-     * Returns the data for the target step.
-     * @param stepNumber The step number to return.
-     * @throws {TypeError} If `options.stepNumber` is invalid.
-     */
-    <targetStep extends keyof TResolvedStep>(options: UseMultiStepFormDataOptions<TSchema, targetStep>): MultiStepFormSchema.getData<TSchema, targetStep>;
-    /**
-     * Returns the specified data from the {@linkcode MultiStepFormSchema} instance via the callback's return.
-     */
-    <data>(selector: (schema: TSchema) => data): data;
-};
-export declare function throwIfInvalidStepNumber<schema extends AnyMultiStepFormSchema>(schema: schema, targetStep: unknown): MultiStepFormSchema.stepNumbers<schema>;
-export declare function createMultiStepFormDataHook<schema extends AnyMultiStepFormSchema>(schema: schema): UseMultiStepFormData<schema>;
-declare function useMultiStepFormData<schema extends AnyMultiStepFormSchema>(schema: schema): schema;
-declare function useMultiStepFormData<schema extends AnyMultiStepFormSchema, targetStep extends keyof MultiStepFormSchema.resolvedStep<schema>>(schema: schema, options: UseMultiStepFormDataOptions<schema, targetStep>): MultiStepFormSchema.getData<schema, targetStep>;
-declare function useMultiStepFormData<schema extends AnyMultiStepFormSchema, data>(schema: schema, selector: (schema: schema) => data): data;
-export { useMultiStepFormData };

package/dist/types/index.d.ts

@@ -1,4 +0,0 @@
-export * from './schema';
-export * from './step-schema';
-export * from './create-context';
-export { useMultiStepFormData } from './hooks/use-multi-step-form-data';

package/dist/types/schema.d.ts

@@ -1,29 +0,0 @@
-import { CasingType, Constrain, CreateHelperFunctionOptionsBase, DefaultCasing, DefaultStorageKey, HelperFnChosenSteps, MultiStepFormSchemaOptions as MultiStepFormSchemaBaseOptions, MultiStepFormSchema as MultiStepFormSchemaCore, ResolvedStep as ResolvedStepCore, Step, StepNumbers } from '@jfdevelops/multi-step-form';
-import { ComponentPropsWithRef } from 'react';
-import { MultiStepFormSchemaConfig } from './form-config';
-import { CreateComponentCallback, CreatedMultiStepFormComponent, HelperFunctions, MultiStepFormStepSchema, ResolvedStep } from './step-schema';
-export type AnyMultiStepFormSchema = {
-    [x: string]: any;
-};
-export declare namespace MultiStepFormSchema {
-    /**
-     * Infer the resolved step from a {@linkcode MultiStepFormSchema}.
-     */
-    type resolvedStep<T extends AnyMultiStepFormSchema> = T['stepSchema']['value'];
-    /**
-     * Infer the {@linkcode MultiStepFormSchema}'s step numbers.
-     */
-    type stepNumbers<T extends AnyMultiStepFormSchema> = StepNumbers<resolvedStep<T>>;
-    /**
-     * Get the data for a specific step from a {@linkcode MultiStepFormSchema}.
-     */
-    type getData<T extends AnyMultiStepFormSchema, TTarget extends keyof resolvedStep<T>> = resolvedStep<T>[TTarget];
-}
-export interface MultiStepFormSchemaOptions<TStep extends Step<TCasing>, TCasing extends CasingType, TStorageKey extends string, TFormAlias extends string, TFormEnabledFor extends MultiStepFormSchemaConfig.formEnabledFor<TResolvedStep>, TFormProps extends object, TResolvedStep extends ResolvedStep<TStep, TCasing> = ResolvedStep<TStep, TCasing>> extends MultiStepFormSchemaBaseOptions<TStep, TCasing, TStorageKey>, MultiStepFormSchemaConfig.Form<TResolvedStep, TFormAlias, TFormEnabledFor, TFormProps> {
-}
-export declare class MultiStepFormSchema<step extends Step<casing>, casing extends CasingType = DefaultCasing, storageKey extends string = DefaultStorageKey, formAlias extends string = MultiStepFormSchemaConfig.defaultFormAlias, formEnabledFor extends MultiStepFormSchemaConfig.formEnabledFor<resolvedStep> = MultiStepFormSchemaConfig.defaultEnabledFor, formProps extends object = ComponentPropsWithRef<'form'>, resolvedStep extends ResolvedStep<step, casing> = ResolvedStep<step, casing>, stepNumbers extends StepNumbers<resolvedStep> = StepNumbers<resolvedStep>> extends MultiStepFormSchemaCore<step, casing, ResolvedStepCore<step, casing>, StepNumbers<ResolvedStepCore<step, casing>>, storageKey> implements HelperFunctions<resolvedStep, stepNumbers> {
-    stepSchema: MultiStepFormStepSchema<step, casing, storageKey, formAlias, formEnabledFor, formProps>;
-    constructor(config: MultiStepFormSchemaOptions<step, Constrain<casing, CasingType>, storageKey, formAlias, formEnabledFor, formProps>);
-    createComponent<chosenSteps extends HelperFnChosenSteps<resolvedStep, stepNumbers>, props = undefined>(options: CreateHelperFunctionOptionsBase<resolvedStep, stepNumbers, chosenSteps>, fn: CreateComponentCallback<resolvedStep, stepNumbers, chosenSteps, props>): CreatedMultiStepFormComponent<props>;
-}
-export declare function createMultiStepFormSchema<step extends Step<casing>, casing extends CasingType = DefaultCasing, storageKey extends string = DefaultStorageKey, formAlias extends string = MultiStepFormSchemaConfig.defaultFormAlias, formEnabledFor extends MultiStepFormSchemaConfig.formEnabledFor<resolvedStep> = MultiStepFormSchemaConfig.defaultEnabledFor, formProps extends object = ComponentPropsWithRef<'form'>, resolvedStep extends ResolvedStep<step, casing> = ResolvedStep<step, casing>, stepNumbers extends StepNumbers<resolvedStep> = StepNumbers<resolvedStep>>(options: MultiStepFormSchemaOptions<step, Constrain<casing, CasingType>, storageKey, formAlias, formEnabledFor, formProps>): MultiStepFormSchema<step, casing, storageKey, formAlias, formEnabledFor, formProps, resolvedStep, stepNumbers>;

package/dist/types/step-schema.d.ts

@@ -1,124 +0,0 @@
-import { CasingType, Constrain, CreateHelperFunctionOptionsBase, DefaultCasing, DefaultStorageKey, Expand, GetCurrentStep, GetFieldsForStep, HelperFnChosenSteps, HelperFnInputBase, MultiStepFormSchemaStepConfig as MultiStepFormSchemaStepBaseConfig, MultiStepFormStepSchema as MultiStepFormStepSchemaBase, Relaxed, ResolvedStep as ResolvedCoreStep, Step, StepNumbers, StrippedResolvedStep, Updater, ValidStepKey } from '@jfdevelops/multi-step-form';
-import { ComponentPropsWithRef, ReactNode } from 'react';
-import { Field } from './field';
-import { MultiStepFormSchemaConfig } from './form-config';
-export interface MultiStepFormSchemaStepConfig<TStep extends Step<TCasing>, TCasing extends CasingType, TStorageKey extends string, TFormAlias extends string, TFormEnabledFor extends MultiStepFormSchemaConfig.formEnabledFor<TResolvedStep>, TFormProps extends object, TResolvedStep extends ResolvedStep<TStep, TCasing> = ResolvedStep<TStep, TCasing>> extends MultiStepFormSchemaStepBaseConfig<TStep, TCasing, TStorageKey>, MultiStepFormSchemaConfig.Form<TResolvedStep, TFormAlias, TFormEnabledFor, TFormProps> {
-}
-export type CreateFunction<TArgs extends any[], TReturn = void> = (...args: TArgs) => TReturn;
-export type CreateComponent<TInput, TProps> = CreateFunction<[
-    input: TInput,
-    props: TProps
-], ReactNode>;
-export type CreateComponentCallback<TResolvedStep extends StrippedResolvedStep<AnyResolvedStep>, TSteps extends StepNumbers<TResolvedStep>, TChosenSteps extends HelperFnChosenSteps<TResolvedStep, TSteps>, TProps> = CreateComponent<HelperFnInputBase<TResolvedStep, TSteps, TChosenSteps>, TProps>;
-export type CreatedMultiStepFormComponent<TProps> = TProps extends undefined ? () => ReactNode : (props: TProps) => ReactNode;
-export type CreateComponentFn<TResolvedStep extends AnyResolvedStep, TStepNumbers extends StepNumbers<TResolvedStep>> = <chosenSteps extends HelperFnChosenSteps<TResolvedStep, TStepNumbers>, props = undefined>(options: CreateHelperFunctionOptionsBase<TResolvedStep, TStepNumbers, chosenSteps>, fn: CreateComponentCallback<TResolvedStep, TStepNumbers, chosenSteps, props>) => CreatedMultiStepFormComponent<props>;
-export declare namespace StepSpecificComponent {
-    type formComponent<TResolvedStep extends StrippedResolvedStep<AnyResolvedStep>, TSteps extends StepNumbers<TResolvedStep>, TChosenSteps extends HelperFnChosenSteps<TResolvedStep, TSteps>, TFormAlias extends string, TFormProps extends object, TFormEnabledFor extends MultiStepFormSchemaConfig.formEnabledFor<TResolvedStep>> = TFormEnabledFor extends MultiStepFormSchemaConfig.defaultEnabledFor ? MultiStepFormSchemaConfig.formCtx<TFormAlias, TFormProps> : TFormEnabledFor extends HelperFnChosenSteps.tupleNotation<ValidStepKey<TSteps>> ? TFormEnabledFor[number] extends keyof TResolvedStep ? TChosenSteps extends HelperFnChosenSteps.tupleNotation<ValidStepKey<TSteps>> ? TChosenSteps[number] extends keyof TResolvedStep ? TChosenSteps[number] extends TFormEnabledFor[number] ? MultiStepFormSchemaConfig.formCtx<TFormAlias, TFormProps> : {} : {} : {} : {} : keyof TFormEnabledFor extends keyof TResolvedStep ? TChosenSteps extends HelperFnChosenSteps.tupleNotation<ValidStepKey<TSteps>> ? TChosenSteps[number] extends keyof TResolvedStep ? TChosenSteps[number] extends keyof TFormEnabledFor ? MultiStepFormSchemaConfig.formCtx<TFormAlias, TFormProps> : {} : {} : {} : {};
-    type onInputChange<TResolvedStep extends AnyResolvedStep, TStepNumbers extends StepNumbers<TResolvedStep>, TTargetStep extends TStepNumbers> = <CurrentStepData extends GetCurrentStep<TResolvedStep, TTargetStep>, Field extends keyof CurrentStepData>(field: Field, updater: Updater<CurrentStepData[Field], Relaxed<CurrentStepData[Field]>>) => void;
-    interface Input<TResolvedStep extends StrippedResolvedStep<AnyResolvedStep>, TSteps extends StepNumbers<TResolvedStep>, TChosenSteps extends HelperFnChosenSteps<TResolvedStep, TSteps>> extends HelperFnInputBase<TResolvedStep, TSteps, TChosenSteps> {
-        /**
-         * A useful wrapper around `update` to update the specific field.
-         * @param field The field to update.
-         * @param updater The new value for the specified field.
-         */
-        onInputChange: <CurrentStepData extends GetCurrentStep<TResolvedStep, HelperFnChosenSteps.extractStepNumber<TResolvedStep, TSteps, TChosenSteps>>, Field extends keyof CurrentStepData>(field: Field, updater: Updater<CurrentStepData[Field], Relaxed<CurrentStepData[Field]>>) => void;
-        Field: Field.component<TResolvedStep, TSteps, HelperFnChosenSteps.extractStepNumber<TResolvedStep, TSteps, TChosenSteps>>;
-    }
-    type callback<TResolvedStep extends StrippedResolvedStep<AnyResolvedStep>, TSteps extends StepNumbers<TResolvedStep>, TChosenSteps extends HelperFnChosenSteps<TResolvedStep, TSteps>, TProps, TFormAlias extends string, TFormProps extends object, TFormEnabledFor extends MultiStepFormSchemaConfig.formEnabledFor<TResolvedStep>, TAdditionalInput extends object = {}> = CreateComponent<Input<TResolvedStep, TSteps, TChosenSteps> & formComponent<TResolvedStep, TSteps, TChosenSteps, TFormAlias, TFormProps, TFormEnabledFor> & TAdditionalInput, TProps>;
-    const DEFAULT_FORM_INSTANCE_ALIAS = "form";
-    type defaultFormInstanceAlias = typeof DEFAULT_FORM_INSTANCE_ALIAS;
-    type formInstanceOptions<TAlias extends string, TRenderInput, TReturn> = {
-        /**
-         * The name of the return value of the `render` method.
-         */
-        alias?: TAlias;
-        /**
-         * A function that renders/creates the form instance. This function will be called
-         * at the top level of the component, ensuring hooks are called in a valid React context.
-         *
-         * @param input - The input object containing context and default values
-         * @returns The form instance (typically from a hook like `useForm`)
-         *
-         * @example
-         * ```tsx
-         * useFormInstance: {
-         *   render({ defaultValues }) {
-         *     return useForm({
-         *       defaultValues,
-         *     });
-         *   },
-         * }
-         * ```
-         *
-         * **Verification**: The hook call is automatically verified:
-         * - Errors are caught and reported with helpful messages
-         * - In development, hook calls are logged to console.debug
-         * - The hook must be called at the component top level (enforced by the framework)
-         */
-        render: CreateFunction<[input: TRenderInput], TReturn>;
-    };
-    type options<TResolvedStep extends AnyResolvedStep, TSteps extends StepNumbers<TResolvedStep>, TTargetStep extends HelperFnChosenSteps<TResolvedStep, TSteps>, TFormInstanceAlias extends string, TFormInstance> = {
-        useFormInstance?: formInstanceOptions<TFormInstanceAlias, HelperFnInputBase<TResolvedStep, TSteps, TTargetStep> & {
-            /**
-             * An object containing all the default values for the current step.
-             */
-            defaultValues: Expand<ExtractedDefaultValues<TResolvedStep, TSteps, TTargetStep>>;
-        }, TFormInstance>;
-    };
-}
-export type CreateStepSpecificComponentCallback<TResolvedStep extends StrippedResolvedStep<AnyResolvedStep>, TSteps extends StepNumbers<TResolvedStep>, TChosenSteps extends HelperFnChosenSteps<TResolvedStep, TSteps>, TProps, TFormAlias extends string, TFormProps extends object, TFormEnabledFor extends MultiStepFormSchemaConfig.formEnabledFor<TResolvedStep>, TAdditionalInput extends object = {}> = StepSpecificComponent.callback<TResolvedStep, TSteps, TChosenSteps, TProps, TFormAlias, TFormProps, TFormEnabledFor, TAdditionalInput>;
-export type ExtractedDefaultValues<TResolvedStep extends AnyResolvedStep, TSteps extends StepNumbers<TResolvedStep>, TTargetStep extends HelperFnChosenSteps<TResolvedStep, TSteps>, TExtractedStepNumber extends number = HelperFnChosenSteps.extractStepNumber<TResolvedStep, TSteps, TTargetStep>, TFields extends GetFieldsForStep<TResolvedStep, ValidStepKey<TExtractedStepNumber>> = GetFieldsForStep<TResolvedStep, ValidStepKey<TExtractedStepNumber>>> = {
-    [field in keyof TFields]: TFields[field]['defaultValue'];
-};
-export interface StepSpecificCreateComponentFn<TResolvedStep extends AnyResolvedStep, TSteps extends StepNumbers<TResolvedStep>, TTargetStep extends HelperFnChosenSteps<TResolvedStep, TSteps>, TFormAlias extends string, TFormProps extends object, TFormEnabledFor extends MultiStepFormSchemaConfig.formEnabledFor<TResolvedStep>> {
-    /**
-     * A utility function to easily create a component for the current step.
-     * @param fn The callback function where the component is defined.
-     */
-    <props = undefined>(fn: CreateStepSpecificComponentCallback<TResolvedStep, TSteps, TTargetStep, props, TFormAlias, TFormProps, TFormEnabledFor>): CreatedMultiStepFormComponent<props>;
-    /**
-     * A utility function to easily create a component for the current step.
-     * @param options Specific config options for creating a component for the current step.
-     * @param fn The callback function where the component is defined.
-     * @returns The created component.
-     */
-    <formInstance, formInstanceAlias extends string = StepSpecificComponent.defaultFormInstanceAlias, props = undefined>(options: StepSpecificComponent.options<TResolvedStep, TSteps, TTargetStep, formInstanceAlias, formInstance>, fn: CreateStepSpecificComponentCallback<TResolvedStep, TSteps, TTargetStep, props, TFormAlias, TFormProps, TFormEnabledFor, {
-        [_ in formInstanceAlias]: formInstance;
-    }>): CreatedMultiStepFormComponent<props>;
-}
-export type ResolvedStep<TStep extends Step<TDefaultCasing>, TDefaultCasing extends CasingType = DefaultCasing, TResolvedStep extends ResolvedCoreStep<TStep, TDefaultCasing> = ResolvedCoreStep<TStep, TDefaultCasing>, TFormAlias extends string = MultiStepFormSchemaConfig.defaultFormAlias, TFormEnabledFor extends MultiStepFormSchemaConfig.formEnabledFor<TResolvedStep> = MultiStepFormSchemaConfig.defaultEnabledFor, TFormProps extends object = ComponentPropsWithRef<'form'>> = {
-    [stepKey in keyof TResolvedStep]: TResolvedStep[stepKey] & (stepKey extends ValidStepKey<StepNumbers<TResolvedStep>> ? {
-        createComponent: StepSpecificCreateComponentFn<TResolvedStep, StepNumbers<TResolvedStep>, [
-            stepKey
-        ], TFormAlias, TFormProps, TFormEnabledFor>;
-    } : {});
-};
-export type AnyResolvedStep = ResolvedStep<any, any, any>;
-export interface HelperFunctions<TResolvedStep extends AnyResolvedStep, TStepNumbers extends StepNumbers<TResolvedStep>> {
-    createComponent: CreateComponentFn<TResolvedStep, TStepNumbers>;
-}
-/**
- * Creates a default values object for the target step.
- * @param steps The steps schema.
- * @param targetStep The step to create the default values for.
- * @returns An object containing the field names and their default values.
- */
-export declare function createDefaultValues<resolvedStep extends AnyResolvedStep, stepNumbers extends StepNumbers<resolvedStep>, targetStep extends ValidStepKey<stepNumbers>>(steps: resolvedStep, targetStep: targetStep): Expand<ExtractedDefaultValues<resolvedStep, stepNumbers, [targetStep]>>;
-export declare class MultiStepFormStepSchema<step extends Step<casing>, casing extends CasingType = DefaultCasing, storageKey extends string = DefaultStorageKey, formAlias extends string = MultiStepFormSchemaConfig.defaultFormAlias, formEnabledFor extends MultiStepFormSchemaConfig.formEnabledFor<resolvedStep> = MultiStepFormSchemaConfig.defaultEnabledFor, formProps extends object = ComponentPropsWithRef<'form'>, core extends ResolvedCoreStep<step, casing> = ResolvedCoreStep<step, casing>, resolvedStep extends ResolvedStep<step, casing, core, formAlias, formEnabledFor, formProps> = ResolvedStep<step, casing, core, formAlias, formEnabledFor, formProps>, stepNumbers extends StepNumbers<resolvedStep> = StepNumbers<resolvedStep>> extends MultiStepFormStepSchemaBase<step, casing> implements HelperFunctions<resolvedStep, stepNumbers> {
-    value: resolvedStep;
-    constructor(config: MultiStepFormSchemaStepConfig<step, Constrain<casing, CasingType>, storageKey, formAlias, formEnabledFor, formProps>);
-    private createFormComponent;
-    private createStepSpecificComponentImpl;
-    private createStepSpecificComponentFactory;
-    private createComponentImpl;
-    private createComponentForStep;
-    /**
-     * A helper function to create a component for a specific step.
-     * @param options The options for creating the step specific component.
-     * @param fn A callback that is used for accessing the target step's data and defining
-     * any props that the component should have. This function must return a valid `JSX` element.
-     * @returns The created component for the step.
-     */
-    createComponent<chosenSteps extends HelperFnChosenSteps<resolvedStep, stepNumbers>, props = undefined>(options: CreateHelperFunctionOptionsBase<resolvedStep, stepNumbers, chosenSteps>, fn: CreateComponentCallback<resolvedStep, stepNumbers, chosenSteps, props>): CreatedMultiStepFormComponent<props>;
-    createDefaultValues<targetStep extends ValidStepKey<stepNumbers>>(targetStep: targetStep): Expand<ExtractedDefaultValues<resolvedStep, import('@jfdevelops/multi-step-form').ExtractStepFromKey<keyof resolvedStep extends infer T ? T extends keyof resolvedStep ? T extends string ? T : never : never : never>, [targetStep], HelperFnChosenSteps.extractStepNumber<resolvedStep, import('@jfdevelops/multi-step-form').ExtractStepFromKey<keyof resolvedStep extends infer T_1 ? T_1 extends keyof resolvedStep ? T_1 extends string ? T_1 : never : never : never>, [targetStep]>, GetFieldsForStep<resolvedStep, `step${HelperFnChosenSteps.extractStepNumber<resolvedStep, import('@jfdevelops/multi-step-form').ExtractStepFromKey<keyof resolvedStep extends infer T_2 ? T_2 extends keyof resolvedStep ? T_2 extends string ? T_2 : never : never : never>, [targetStep]>}`>>>;
-}