react-crud-mui 0.2.39 → 0.2.41

package/dist/components/detail-page/components/DetailPageCommands.d.ts

@@ -1,36 +1,27 @@
-import { ReactNode } from 'react';
-import { FieldValues } from 'react-hook-form';
-import { LoadingButtonProps } from '@mui/lab/LoadingButton';
-import { MoreButtonItem } from '../../more-button/MoreButton';
-import { CloseReason, CommandsPosition } from '../../page/Page';
+import { PropsWithChildren, ReactNode } from 'react';
+import { UseFormReturn } from '../../form/hooks/useForm';
+import { CloseReason } from '../../page/Page';
+import { DetailPageCommandsFlag } from '../hooks/useDetailPageStates';
 import { SaveMode } from '../pages/DetailPageData';
-export interface DetailPageCommandsFlag {
-    copy?: boolean;
-    save?: boolean;
-    savecreate?: boolean;
-    saveclose?: boolean;
-    discardchanges?: boolean;
-    delete?: boolean;
-    close?: boolean;
-    navigate?: boolean;
-    create?: boolean;
-}
-export interface DetailPageCommandsExtraProps {
-    save?: LoadingButtonProps;
-    discardchanges?: LoadingButtonProps;
-    delete?: LoadingButtonProps;
-    close?: LoadingButtonProps;
-    navigate?: LoadingButtonProps;
-    create?: LoadingButtonProps;
-}
-export interface DetailPageCommandsOptions {
-    visible: DetailPageCommandsFlag;
-    disabled: DetailPageCommandsFlag;
-    loading?: boolean;
-    isNew: boolean;
-    isDisabled?: boolean;
-}
-export type DetailPageCommandsState = {
+import { StepPane } from './DetailPageStepsHeader';
+export type DetailPageStandartCommandsOptions = {
+    saveCommandMode?: SaveMode;
+    createCommandLabel?: ReactNode;
+    saveCommandLabel?: ReactNode;
+};
+export type DetailPageStepCommandsOptions = {
+    nextButtonTitle?: React.ReactNode;
+    prevButtonTitle?: React.ReactNode;
+    showNextButton?: boolean;
+    showPrevButton?: boolean;
+    currentKey: React.Key;
+    name: string;
+    activeStepIndex: number;
+    steps: StepPane[];
+    currentForm?: UseFormReturn;
+};
+export type DetailPageCommandsOptions = DetailPageStandartCommandsOptions & DetailPageStepCommandsOptions;
+export type DetailPageStandartCommandsEvents = {
     onSave?: () => void;
     onSaveCreate?: () => void;
     onCreate?: () => void;
@@ -39,40 +30,15 @@ export type DetailPageCommandsState = {
     onDelete?: () => void;
     onClose?: (reason?: CloseReason) => void;
     onSaveClose?: () => void;
-    saveCommandMode?: SaveMode;
-    createCommandLabel?: ReactNode;
-    commandsPosition?: CommandsPosition;
-};
-export type DetailPageCommandsLayoutContents = {
-    save: ReactNode;
-    create: ReactNode;
-    discardChanges: ReactNode;
-    delete: ReactNode;
-    close: ReactNode;
-    content: ReactNode;
-    renderMoreCommand: (items: MoreButtonItem[]) => ReactNode;
-    extra?: ReactNode;
 };
-export type DetailPageCommmandsSettings<TModel extends FieldValues = FieldValues> = {
-    content: ReactNode;
-    layout: DetailPageCommandsLayoutContents;
-    props: DetailPageCommandsState & DetailPageCommandsOptions;
-    data?: TModel;
+export type DetailPageStepCommandsEvents = {
+    onNextClick?: () => void;
+    onPrevClick?: () => void;
 };
-export interface DetailPageCommandsProps<TModel extends FieldValues = FieldValues> extends DetailPageCommandsState {
-    onCommands?: (props: DetailPageCommmandsSettings<TModel>) => ReactNode;
-    onExtraCommands?: () => ReactNode;
-    commandsExtraProps?: DetailPageCommandsExtraProps;
-    data?: TModel;
-}
-export declare enum DetailPageCommandNames {
-    SAVE = "save",
-    CREATE = "create",
-    COPY = "copy",
-    DISCARD = "discard",
-    DELETE = "delete",
-    CLOSE = "close",
-    NAVIGATE = "navigate"
-}
-declare function DetailPageCommands<TModel extends FieldValues = FieldValues>(props: DetailPageCommandsProps<TModel>): import("react/jsx-runtime").JSX.Element;
+export type DetailPageCommandsProps = DetailPageStandartCommandsEvents & DetailPageStepCommandsEvents & {
+    options: DetailPageCommandsOptions;
+    mode: 'standard' | 'steps';
+    moreCommands?: Partial<Record<keyof DetailPageCommandsFlag, true>>;
+} & PropsWithChildren;
+declare function DetailPageCommands(props: DetailPageCommandsProps): import("react/jsx-runtime").JSX.Element;
 export default DetailPageCommands;

package/dist/components/detail-page/components/DetailPageDefaultLayout.d.ts

@@ -8,10 +8,8 @@ export type DetailPageLayoutProps = {
     content?: ReactNode;
     stepsContent?: ReactNode;
     autoSaveContent?: ReactNode;
-    valuesChangeContent?: ReactNode;
-    errorsContent?: ReactNode;
     options: DetailPageLayoutOptions;
 };
 type DetailPageDefaultLayoutProps = DetailPageLayoutProps;
-declare function DetailPageDefaultLayout({ content, stepsContent, autoSaveContent, valuesChangeContent, errorsContent, }: DetailPageDefaultLayoutProps): import("react/jsx-runtime").JSX.Element;
+declare function DetailPageDefaultLayout({ content, stepsContent, autoSaveContent, }: DetailPageDefaultLayoutProps): import("react/jsx-runtime").JSX.Element;
 export default DetailPageDefaultLayout;

package/dist/components/detail-page/components/DetailPageDrawerCommands.d.ts

@@ -1,3 +1,3 @@
-import { DetailPageCommmandsSettings } from './DetailPageCommands';
-declare function DetailPageDrawerCommands({ layout, props }: DetailPageCommmandsSettings): import("react/jsx-runtime").JSX.Element;
+import { DetailPageCommandsProps } from './DetailPageCommands';
+declare function DetailPageDrawerCommands(props: DetailPageCommandsProps): import("react/jsx-runtime").JSX.Element;
 export default DetailPageDrawerCommands;

package/dist/components/detail-page/components/DetailPageProvider.d.ts

@@ -0,0 +1,10 @@
+import { default as React, PropsWithChildren } from 'react';
+import { FieldValues } from 'react-hook-form';
+import { DetailPageContentProps } from '../pages/DetailPageContent';
+export type DetailPageContextType<TModel extends FieldValues = FieldValues> = Pick<DetailPageContentProps<TModel>, 'loading' | 'enableClose' | 'enableCopy' | 'enableCreate' | 'enableDelete' | 'enableDiscardChanges' | 'enableSave' | 'reason' | 'disabled' | 'data' | 'activeSegmentIndex'> & {
+    onSave: () => void;
+    setActiveSegmentIndex: (index: number) => void;
+};
+export declare const DetailPageContext: React.Context<DetailPageContextType<FieldValues> | null>;
+declare function DetailPageProvider({ children, data, reason, loading, enableCopy, enableCreate, enableClose, enableDiscardChanges, enableDelete, onSave, enableSave, disabled, activeSegmentIndex, setActiveSegmentIndex, }: PropsWithChildren & DetailPageContextType): import("react/jsx-runtime").JSX.Element;
+export default DetailPageProvider;

package/dist/components/detail-page/components/DetailPageStepForm.d.ts

@@ -0,0 +1,13 @@
+import { PropsWithChildren } from 'react';
+import { DefaultValues, FieldValues, Path } from 'react-hook-form';
+import { z } from 'zod';
+interface DetailPageStepContentProps<TModel extends FieldValues> {
+    schema?: z.ZodType<TModel>;
+    defaultValues?: DefaultValues<TModel>;
+    name: Path<TModel>;
+}
+/**
+ * This component is used to create a form for each step in the detail page.
+ */
+declare function DetailPageStepForm<TModel extends FieldValues>({ schema, name, children, defaultValues, }: DetailPageStepContentProps<TModel> & PropsWithChildren): import("react/jsx-runtime").JSX.Element;
+export default DetailPageStepForm;

package/dist/components/detail-page/components/DetailPageStepsHeader.d.ts

@@ -0,0 +1,21 @@
+import { default as React, ReactNode } from 'react';
+import { DefaultValues, FieldValues, Path, PathValue } from 'react-hook-form';
+import { StepProps } from '@mui/material/Step';
+import { StepLabelProps } from '@mui/material/StepLabel';
+import { StepperProps } from '@mui/material/Stepper';
+import { z } from 'zod';
+export interface DetailPageStepsHeaderProps<TModel extends FieldValues = FieldValues> extends Omit<StepperProps, 'onChange'> {
+    items: StepPane<TModel>[];
+    status?: StepStatus;
+}
+export type StepPane<TModel extends FieldValues = FieldValues, TFieldStepName extends Path<TModel> = Path<TModel>> = Omit<StepProps & StepLabelProps, 'children' | 'key'> & {
+    name?: TFieldStepName;
+    key: React.Key;
+    schema?: z.ZodType<PathValue<TModel, TFieldStepName>>;
+    defaultValues?: DefaultValues<PathValue<TModel, TFieldStepName>>;
+    label: ReactNode;
+    children: ReactNode;
+};
+export type StepStatus = 'wait' | 'process' | 'finish' | 'error';
+declare function DetailPageStepsHeader<TModel extends FieldValues = FieldValues>({ activeStep, items, ...stepperProps }: DetailPageStepsHeaderProps<TModel>): import("react/jsx-runtime").JSX.Element;
+export default DetailPageStepsHeader;

package/dist/components/detail-page/hooks/useDetailPage.d.ts

@@ -1,10 +1,4 @@
-import { default as React } from 'react';
 import { FieldValues } from 'react-hook-form';
-import { DetailPageContentProps } from '../pages/DetailPageContent';
-export type DetailPageContextType<TModel extends FieldValues = FieldValues> = Pick<DetailPageContentProps<TModel>, 'loading' | 'enableClose' | 'enableCopy' | 'enableCreate' | 'enableDelete' | 'enableDiscardChanges' | 'enableSave' | 'reason' | 'disabled' | 'data' | 'activeSegmentIndex'> & {
-    onSave: () => void;
-    setActiveSegmentIndex: (index: number) => void;
-};
-export declare const DetailPageContext: React.Context<DetailPageContextType<FieldValues> | null>;
+import { DetailPageContextType } from '../components/DetailPageProvider';
 declare const useDetailPage: <TModel extends FieldValues = FieldValues>() => DetailPageContextType<TModel>;
 export default useDetailPage;

package/dist/components/detail-page/hooks/useDetailPageModal.d.ts

@@ -427,7 +427,6 @@ declare function useDetailPageModal<TModel extends FieldValues>({ models, unique
     readonly moreOptions?: import('../../..').MoreButtonProps["options"];
     readonly useHeaderIconWrapper?: boolean;
     readonly tabs?: import('../../..').TabPane[];
-    readonly onValuesChange?: ((values: Partial<TModel>) => void) | undefined;
     readonly error?: import('../../utils').ServerError;
     readonly footerContent?: import('react').ReactNode;
     readonly moreContent?: import('react').ReactNode;
@@ -456,22 +455,22 @@ declare function useDetailPageModal<TModel extends FieldValues>({ models, unique
     readonly enableSave?: boolean;
     readonly reason?: NeedDataReason;
     readonly activeSegmentIndex?: number;
-    readonly onCommands?: ((props: import('../components/DetailPageCommands').DetailPageCommmandsSettings<TModel>) => import('react').ReactNode) | undefined;
-    readonly onExtraCommands?: () => import('react').ReactNode;
     readonly createCommandLabel?: import('react').ReactNode;
+    readonly saveCommandLabel?: import('react').ReactNode;
+    readonly onCommands?: (props: import('../components/DetailPageCommands').DetailPageCommandsProps) => import('react').ReactNode;
+    readonly onExtraCommands?: () => import('react').ReactNode;
     readonly alerts?: import('../../page/hooks/useNormalizeMessages').Message[];
     readonly onSegmentChanged?: (index: number) => void;
     readonly hotkeyScopes?: string;
     readonly onCreate?: () => void;
     readonly onSave?: import('../pages/DetailPageData').DataEvent<TModel, import('../pages/DetailPageData').SavePayload<TModel>> | undefined;
     readonly onDiscardChanges?: () => void;
-    readonly onFormErrors?: ((errors: import('react-hook-form').FieldErrors<TModel>, isValid?: boolean) => void) | undefined;
     readonly onContentLayout?: (props: import('../components/DetailPageDefaultLayout').DetailPageLayoutProps) => React.ReactNode;
     readonly onWrapperLayout?: (props: import('../pages/DetailPageContent').DetailPageWrapperLayoutProps) => React.ReactNode;
     readonly defaultSaveMode?: import('../pages/DetailPageData').SaveMode;
-    readonly steps?: import('../components/DetailPageSteps').StepPane[];
-    readonly customSteps?: React.ComponentType<import('../components/DetailPageSteps').DetailPageStepsProps>;
-    readonly stepsProps?: Partial<import('../components/DetailPageSteps').DetailPageStepsProps>;
+    readonly steps?: import('../components/DetailPageStepsHeader').StepPane<TModel>[] | undefined;
+    readonly customSteps?: React.ComponentType<import('../components/DetailPageStepsHeader').DetailPageStepsHeaderProps>;
+    readonly stepsProps?: Partial<import('../components/DetailPageStepsHeader').DetailPageStepsHeaderProps>;
     readonly showSuccessMessages?: boolean;
     readonly onAfterSave?: ((result: void | Awaited<TModel> | undefined, variables: import('../pages/DetailPageData').SavePayload<TModel>, form: import('../../form/hooks/useForm').UseFormReturn<TModel>) => void) | undefined;
     readonly onAfterDelete?: ((variables: import('../pages/DetailPageData').DeletePayload<TModel>, form: import('../../form/hooks/useForm').UseFormReturn<TModel>) => void) | undefined;

package/dist/components/detail-page/hooks/useDetailPageStates.d.ts

@@ -1,13 +1,26 @@
+export interface DetailPageCommandsFlag {
+    copy?: boolean;
+    save?: boolean;
+    savecreate?: boolean;
+    saveclose?: boolean;
+    discardchanges?: boolean;
+    delete?: boolean;
+    close?: boolean;
+    navigate?: boolean;
+    create?: boolean;
+    prev?: boolean;
+    next?: boolean;
+}
+export interface DetailPageCommandsOptions {
+    visible: DetailPageCommandsFlag;
+    disabled: DetailPageCommandsFlag;
+    loading?: boolean;
+    isNew: boolean;
+    isDisabled?: boolean;
+}
 /**
  * Returns buttons props depending on validation,loading etc
  * Beware of rerender when state of form changes
  */
-declare function useDetailPageStates(): {
-    formStates: import('react-hook-form').UseFormStateReturn<import('react-hook-form').FieldValues>;
-    visible: import('../components/DetailPageCommands').DetailPageCommandsFlag;
-    disabled: import('../components/DetailPageCommands').DetailPageCommandsFlag;
-    loading?: boolean;
-    isNew: boolean;
-    isDisabled?: boolean;
-};
+declare function useDetailPageStates(): DetailPageCommandsOptions;
 export default useDetailPageStates;

package/dist/components/detail-page/pages/DetailPage.d.ts

@@ -1,7 +1,8 @@
 import { FieldValues } from 'react-hook-form';
+import { default as DetailPageCommands } from '../components/DetailPageCommands';
 import { default as DetailPageDefaultLayout } from '../components/DetailPageDefaultLayout';
 import { default as DetailPageHeader } from '../components/DetailPageHeader';
-import { default as DetailPageSteps } from '../components/DetailPageSteps';
+import { default as DetailPageStepsHeader } from '../components/DetailPageStepsHeader';
 import { NeedDataReason } from './DetailPageContent';
 import { default as DetailPageDrawer } from './DetailPageDrawer';
 import { DetailPageFormProps } from './DetailPageForm';
@@ -22,6 +23,7 @@ declare namespace DetailPage {
     var Drawer: typeof DetailPageDrawer;
     var Route: typeof DetailPageRoute;
     var Layout: typeof DetailPageDefaultLayout;
-    var Steps: typeof DetailPageSteps;
+    var Steps: typeof DetailPageStepsHeader;
+    var Commands: typeof DetailPageCommands;
 }
 export default DetailPage;

package/dist/components/detail-page/pages/DetailPageContent.d.ts

@@ -1,13 +1,14 @@
 import { default as React, ReactNode } from 'react';
-import { FieldErrors, FieldValues } from 'react-hook-form';
+import { FieldValues } from 'react-hook-form';
+import { UseFormReturn } from '../../form/hooks/useForm';
 import { Message } from '../../page/hooks/useNormalizeMessages';
 import { PageProps } from '../../page/Page';
 import { ServerError } from '../../utils';
 import { AutoSaveOptions } from '../components/AutoSave';
-import { DetailPageCommandsProps } from '../components/DetailPageCommands';
+import { DetailPageCommandsProps, DetailPageStandartCommandsOptions } from '../components/DetailPageCommands';
 import { DetailPageLayoutProps } from '../components/DetailPageDefaultLayout';
 import { DetailPageHeaderProps } from '../components/DetailPageHeader';
-import { DetailPageStepsProps, StepPane } from '../components/DetailPageSteps';
+import { DetailPageStepsHeaderProps, StepPane } from '../components/DetailPageStepsHeader';
 import { SaveMode } from './DetailPageData';
 export type NeedDataReason = 'create' | 'fetch' | 'copy' | 'view';
 export type DetailPageWrapperLayoutProps = {
@@ -16,7 +17,19 @@ export type DetailPageWrapperLayoutProps = {
     commandsContent: ReactNode;
     alertsContent: ReactNode;
 };
-export interface DetailPageContentProps<TModel extends FieldValues> extends Omit<PageProps, 'commandsContent' | 'alertsContent' | 'autoSave' | 'onHeader' | 'tabExtraContent'>, Pick<DetailPageCommandsProps<TModel>, 'onCommands' | 'onExtraCommands' | 'createCommandLabel'> {
+export interface DetailPageContentProps<TModel extends FieldValues> extends Omit<PageProps, 'commandsContent' | 'alertsContent' | 'autoSave' | 'onHeader' | 'tabExtraContent'>, Pick<DetailPageStandartCommandsOptions, 'createCommandLabel' | 'saveCommandLabel'> {
+    /**
+     * Custom commands node
+     */
+    onCommands?: (props: DetailPageCommandsProps) => ReactNode;
+    /**
+     * Extra commands positioned left side in commands section
+     */
+    onExtraCommands?: () => ReactNode;
+    /**
+     * Main rhf instance of page
+     */
+    form: UseFormReturn<TModel>;
     data?: TModel;
     /**
      * External error indicator
@@ -74,16 +87,6 @@ export interface DetailPageContentProps<TModel extends FieldValues> extends Omit
      * Custom header function
      */
     onHeader?: (props: DetailPageHeaderProps) => ReactNode;
-    /**
-     * Values change tracker
-     * MUST BE MEMOIZED
-     */
-    onValuesChange?: (values: Partial<TModel>) => void;
-    /**
-     * Error tracker,called when form errors has changed
-     * MUST BE MEMOIZED
-     */
-    onFormErrors?: (errors: FieldErrors<TModel>, isValid?: boolean) => void;
     /**
      * Page opening reason Default create.
      */
@@ -116,22 +119,28 @@ export interface DetailPageContentProps<TModel extends FieldValues> extends Omit
      * Having called "onSave" once changing form values
      */
     autoSave?: boolean | AutoSaveOptions;
+    /**
+     *  Custom content layout
+     */
     onContentLayout?: (props: DetailPageLayoutProps) => React.ReactNode;
     onWrapperLayout?: (props: DetailPageWrapperLayoutProps) => React.ReactNode;
+    /**
+     *Default save mode (save,saveclose,savecreate) default is 'save'
+     */
     defaultSaveMode?: SaveMode;
     /**
      * Steps definitons
      */
-    steps?: StepPane[];
+    steps?: StepPane<TModel>[];
     /**
      * Custom steps component
      */
-    customSteps?: React.ComponentType<DetailPageStepsProps>;
+    customSteps?: React.ComponentType<DetailPageStepsHeaderProps>;
     /**
      * Optional steps props
      */
-    stepsProps?: Partial<DetailPageStepsProps>;
+    stepsProps?: Partial<DetailPageStepsHeaderProps>;
     tabExtraContent?: ReactNode | ((data?: TModel) => ReactNode);
 }
-declare function DetailPageContent<TModel extends FieldValues>({ activeSegmentIndex, alerts, autoSave, children, commandsPosition, customSteps: CustomSteps, createCommandLabel, data, defaultSaveMode, disabled, disableShortCuts, enableClose, enableCopy, enableCreate, enableDelete, enableDiscardChanges, enableSave, error, hotkeyScopes, loading, onClose, onCommands, onContentLayout, onCopy, onCreate, onDelete, onDiscardChanges, onFormErrors, onSegmentChanged, onExtraCommands, onHeader, onSave, onSaveClose, onSaveCreate, onValuesChange, onWrapperLayout, reason, showHeader, steps, stepsProps, tabExtraContent, ...pageProps }: DetailPageContentProps<TModel>): import("react/jsx-runtime").JSX.Element;
+declare function DetailPageContent<TModel extends FieldValues>({ activeSegmentIndex, alerts, autoSave, children, commandsPosition, customSteps: CustomSteps, createCommandLabel, data, defaultSaveMode, disabled, disableShortCuts, enableClose, enableCopy, enableCreate, enableDelete, enableDiscardChanges, enableSave, error, form, hotkeyScopes, loading, onClose, onCommands, onContentLayout, onCopy, onCreate, onDelete, onDiscardChanges, onSegmentChanged, onExtraCommands, onHeader, onSave, onSaveClose, onSaveCreate, onWrapperLayout, reason, saveCommandLabel, showHeader, steps, stepsProps, tabExtraContent, ...pageProps }: DetailPageContentProps<TModel>): import("react/jsx-runtime").JSX.Element;
 export default DetailPageContent;

package/dist/components/detail-page/pages/DetailPageData.d.ts

@@ -19,7 +19,6 @@ export interface DeletePayload<TModel extends FieldValues = FieldValues> extends
     data?: TModel;
 }
 export interface DetailPageDataProps<TModel extends FieldValues> extends Omit<DetailPageContentProps<TModel>, 'onSave' | 'onDelete' | 'onDiscardChanges' | 'onCopy' | 'onSaveCreate' | 'onSaveClose'> {
-    form: UseFormReturn<TModel>;
     /**
      * Save event
      * @returns if returns data,either in promise or object will bind to form data

package/dist/components/detail-page/pages/DetailPageForm.d.ts

@@ -5,7 +5,7 @@ import { DeepNullable } from '../../utils';
 import { NeedDataReason } from './DetailPageContent';
 import { DetailPageDataProps } from './DetailPageData';
 export type DefaultDataFn<TModel extends FieldValues> = (reason: NeedDataReason, data?: TModel) => DeepNullable<TModel> | Promise<DeepNullable<TModel>>;
-export type DefaultData<TModel extends FieldValues> = DeepNullable<TModel> | DefaultDataFn<TModel>;
+export type DefaultData<TModel extends FieldValues = FieldValues> = DeepNullable<TModel> | DefaultDataFn<TModel>;
 export interface DetailPageFormProps<TModel extends FieldValues> extends Omit<DetailPageDataProps<TModel>, 'form'> {
     form?: UseFormReturn<TModel>;
     schema?: z.ZodType<TModel>;
@@ -13,5 +13,5 @@ export interface DetailPageFormProps<TModel extends FieldValues> extends Omit<De
     defaultValues?: DefaultData<TModel>;
     formProps?: Partial<UseFormProps<TModel>>;
 }
-declare function DetailPageForm<TModel extends FieldValues>({ activeSegmentIndex, schema, defaultValues, validationOptions, data, reason, formProps, ...dpProps }: DetailPageFormProps<TModel>): import("react/jsx-runtime").JSX.Element;
+declare function DetailPageForm<TModel extends FieldValues>({ activeSegmentIndex, data, defaultValues, formProps, reason, schema, validationOptions, ...dpProps }: DetailPageFormProps<TModel>): import("react/jsx-runtime").JSX.Element;
 export default DetailPageForm;

package/dist/components/form/components/FormCollectionProvider.d.ts

@@ -0,0 +1,15 @@
+import { default as React, PropsWithChildren } from 'react';
+import { FieldValues } from 'react-hook-form';
+import { UseFormReturn } from '../hooks/useForm';
+export interface FormCollectionContextType {
+    forms?: Map<string, UseFormReturn>;
+    registerForm?: (data: FormData) => void;
+    unRegisterForm?: (name: string) => void;
+}
+export declare const FormCollectionContext: React.Context<FormCollectionContextType>;
+export type FormData<TFieldValues extends FieldValues = FieldValues> = {
+    name: string;
+    form: UseFormReturn<TFieldValues>;
+};
+declare function FormCollectionProvider({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;
+export default FormCollectionProvider;

package/dist/components/form/hooks/index.d.ts

@@ -11,4 +11,5 @@ export { default as useArrayFieldHelpers } from './useArrayFieldHelpers';
 export { default as useUniqueFieldsInArray } from './useUniqueFieldsInArray';
 export { default as useFormInitEffect } from './useFormInitEffect';
 export { default as useFieldWithContext } from './useFieldWithContext';
+export { default as useFormCollectionContext } from './useFormCollectionContext';
 export { UNIQUE_IDENTIFIER_FIELD_NAME } from './useArrayFieldHelpers';

package/dist/components/form/hooks/useForm.d.ts

@@ -12,7 +12,7 @@ export type ValidationOptions<TFieldValues extends FieldValues = FieldValues> =
 export interface UseFormOptions<TFieldValues extends FieldValues> extends UseFormProps<TFieldValues> {
     schema?: z.ZodType<Partial<TFieldValues>>;
 }
-export interface UseFormReturn<TFieldValues extends FieldValues> extends ReactHookFormUseFormReturn<TFieldValues> {
+export interface UseFormReturn<TFieldValues extends FieldValues = FieldValues> extends ReactHookFormUseFormReturn<TFieldValues> {
     /**
      * Shortcut method for handleSubmit()()
      * @returns Returns form model when validation successed

package/dist/components/form/hooks/useFormCollectionContext.d.ts

@@ -0,0 +1,3 @@
+import { FormCollectionContextType } from '../components/FormCollectionProvider';
+declare function useFormCollectionContext(): Required<FormCollectionContextType>;
+export default useFormCollectionContext;

package/dist/components/form/hooks/useRegisterForm.d.ts

@@ -0,0 +1,8 @@
+import { FieldValues, Path } from 'react-hook-form';
+import { UseFormReturn } from './useForm';
+interface UseRegisterFormOptions<TFieldValues extends FieldValues> {
+    name: Path<TFieldValues>;
+    form: UseFormReturn<TFieldValues>;
+}
+declare function useRegisterForm<TFieldValues extends FieldValues>({ name, form, }: UseRegisterFormOptions<TFieldValues>): void;
+export default useRegisterForm;

package/dist/components/page/Page.d.ts

@@ -11,7 +11,7 @@ import { default as PageProvider, PaddingSize } from './components/PageProvider'
 import { default as PageDrawer } from './PageDrawer';
 import { default as PageModal } from './PageModal';
 export type CloseReason = 'backdrop' | 'close-button' | 'action';
-export type CommandsPosition = 'top-right' | 'top-left' | 'bottom-left' | 'bottom-right' | 'bottom' | 'top';
+export type CommandsPosition = 'top-right' | 'top-left' | 'bottom-left' | 'bottom-right' | 'bottom-between' | 'top-between' | 'bottom' | 'top';
 export type TabsPosition = 'in-center' | 'in-subrow';
 export interface PageProps extends HeaderProps {
     commandsContent?: ReactNode;