@vef-framework/starter 1.0.135 → 2.0.2

package/dist/types/components/page/index.d.ts

@@ -0,0 +1,4 @@
+import { PageProps } from './props';
+export declare function Page({ className, aside, asideClassName, asideWidth, header, headerClassName, footer, footerClassName, actionBar, actionBarClassName, scrollable, children }: PageProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export { type PageProps } from './props';
+export { useViewportHeight } from './viewport-context';

package/dist/types/components/page/props.d.ts

@@ -0,0 +1,51 @@
+import { Length } from '@vef-framework/components';
+import { PropsWithChildren, ReactNode } from 'react';
+/**
+ * The props of the Page component.
+ */
+export interface PageProps extends PropsWithChildren {
+    /**
+     * The class name of the main content of the page.
+     */
+    className?: string;
+    /**
+     * The aside content of the page.
+     */
+    aside?: ReactNode;
+    /**
+     * The class name of the aside.
+     */
+    asideClassName?: string;
+    /**
+     * The width of the aside.
+     */
+    asideWidth?: Length;
+    /**
+     * The header of the page.
+     */
+    header?: ReactNode;
+    /**
+     * The class name of the header.
+     */
+    headerClassName?: string;
+    /**
+     * The footer of the page.
+     */
+    footer?: ReactNode;
+    /**
+     * The class name of the footer.
+     */
+    footerClassName?: string;
+    /**
+     * The action bar of the page.
+     */
+    actionBar?: ReactNode;
+    /**
+     * The class name of the action bar.
+     */
+    actionBarClassName?: string;
+    /**
+     * Whether the page main content is scrollable.
+     */
+    scrollable?: boolean;
+}

package/dist/types/components/page/scroll-content.d.ts

@@ -0,0 +1,8 @@
+import { PropsWithChildren, ReactNode } from 'react';
+interface ScrollContentProps extends PropsWithChildren {
+    className?: string;
+    actionBar?: ReactNode;
+    actionBarClassName?: string;
+}
+export declare function ScrollContent({ className, actionBar, actionBarClassName, children }: ScrollContentProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/page/styles.d.ts

@@ -0,0 +1,11 @@
+import { SerializedStyles } from '@emotion/serialize';
+export declare const page: SerializedStyles;
+export declare const aside: SerializedStyles;
+export declare const main: SerializedStyles;
+export declare const header: SerializedStyles;
+export declare const content: SerializedStyles;
+export declare const defaultContent: SerializedStyles;
+export declare const scrollWrapper: SerializedStyles;
+export declare const scrollContainer: SerializedStyles;
+export declare const footer: SerializedStyles;
+export declare const actionBar: SerializedStyles;

package/dist/types/components/page/use-page-key.d.ts

@@ -0,0 +1 @@
+export declare function usePageKey(): number;

package/dist/types/components/page/viewport-context.d.ts

@@ -0,0 +1,7 @@
+import { Provider } from 'react';
+/**
+ * Hook to get the viewport height from Page component.
+ * Must be used within Page component with scrollable prop set to true.
+ */
+export declare function useViewportHeight(): number;
+export declare const ViewportProvider: Provider<number | null>;

package/dist/types/components/pro-search/components/advanced-search-toggler.d.ts

@@ -0,0 +1,7 @@
+import { MemoExoticComponent } from 'react';
+interface AdvancedSearchTogglerProps {
+    isVisible: boolean;
+    onToggle: () => void;
+}
+export declare const AdvancedSearchToggler: MemoExoticComponent<({ isVisible, onToggle }: AdvancedSearchTogglerProps) => import("@emotion/react/jsx-runtime").JSX.Element>;
+export {};

package/dist/types/components/pro-search/components/advanced-search.d.ts

@@ -0,0 +1,6 @@
+import { PropsWithChildren, MemoExoticComponent } from 'react';
+interface AdvancedSearchProps {
+    isVisible: boolean;
+}
+export declare const AdvancedSearch: MemoExoticComponent<({ children, isVisible }: PropsWithChildren<AdvancedSearchProps>) => import("@emotion/react/jsx-runtime").JSX.Element>;
+export {};

package/dist/types/components/pro-search/components/index.d.ts

@@ -0,0 +1,3 @@
+export { AdvancedSearch } from './advanced-search';
+export { AdvancedSearchToggler } from './advanced-search-toggler';
+export { SearchActions } from './search-actions';

package/dist/types/components/pro-search/components/search-actions.d.ts

@@ -0,0 +1,22 @@
+import { ProSearchProps } from '../props';
+import { MemoExoticComponent } from 'react';
+interface SearchActionsProps {
+    /**
+     * Loading state
+     */
+    loading?: boolean;
+    /**
+     * Search button props
+     */
+    searchButtonProps?: ProSearchProps<never>["searchButtonProps"];
+    /**
+     * Reset button props, or false to hide the reset button
+     */
+    resetButtonProps?: ProSearchProps<never>["resetButtonProps"];
+    /**
+     * Callback when search is reset
+     */
+    onReset?: () => void;
+}
+export declare const SearchActions: MemoExoticComponent<({ loading, searchButtonProps, resetButtonProps, onReset }: SearchActionsProps) => import("@emotion/react/jsx-runtime").JSX.Element>;
+export {};

package/dist/types/components/pro-search/index.d.ts

@@ -0,0 +1,5 @@
+import { Awaitable } from '@vef-framework/shared';
+import { FC, ReactNode } from 'react';
+import { ProSearchProps } from './props';
+export declare const ProSearch: (<TValues = unknown>(props: ProSearchProps<TValues>) => Awaitable<ReactNode>) & Pick<FC, "displayName">;
+export type { ProSearchProps } from './props';

package/dist/types/components/pro-search/props.d.ts

@@ -0,0 +1,66 @@
+import { ResetButtonProps, SubmitButtonProps } from '@vef-framework/components';
+import { Except } from '@vef-framework/shared';
+import { ReactNode } from 'react';
+/**
+ * Props for the ProSearch component
+ *
+ * @template TValues - The type of the search form values
+ */
+export interface ProSearchProps<TValues = unknown> {
+    /**
+     * CSS class name
+     */
+    className?: string;
+    /**
+     * Default search values
+     */
+    defaultValues?: TValues;
+    /**
+     * Extra content on the left side
+     */
+    extra?: ReactNode;
+    /**
+     * Basic search content
+     */
+    basicSearch?: ReactNode;
+    /**
+     * Advanced search content
+     */
+    advancedSearch?: ReactNode;
+    /**
+     * Disabled state
+     */
+    disabled?: boolean;
+    /**
+     * Loading state
+     */
+    loading?: boolean;
+    /**
+     * Search button props
+     */
+    searchButtonProps?: Except<SubmitButtonProps, "onSubmit" | "disabled" | "loading">;
+    /**
+     * Reset button props, or false to hide the reset button
+     */
+    resetButtonProps?: Except<ResetButtonProps, "onReset" | "disabled" | "loading"> | false;
+    /**
+     * Callback when search values change
+     */
+    onSearch?: (values: NoInfer<TValues>) => void;
+    /**
+     * Callback when search is reset
+     */
+    onReset?: (defaultValues?: NoInfer<TValues>) => void;
+    /**
+     * Whether advanced search is visible by default (uncontrolled)
+     */
+    defaultAdvancedSearchVisible?: boolean;
+    /**
+     * Whether advanced search is visible (controlled)
+     */
+    advancedSearchVisible?: boolean;
+    /**
+     * Callback when advanced search visibility changes
+     */
+    onAdvancedSearchVisibleChange?: (visible: boolean) => void;
+}

package/dist/types/components/pro-search/styles.d.ts

@@ -0,0 +1,6 @@
+import { SerializedStyles } from '@emotion/serialize';
+export declare const content: SerializedStyles;
+export declare const contentLeft: SerializedStyles;
+export declare const contentRight: SerializedStyles;
+export declare const advancedSearchToggler: SerializedStyles;
+export declare const advancedSearch: SerializedStyles;

package/dist/types/components/pro-table/components/index.d.ts

@@ -0,0 +1,4 @@
+export { OperationButtonGroup, type OperationButtonGroupProps } from './operation-button-group';
+export { ProTableRefHolder } from './ref';
+export { NonPaginatedTable, PaginatedTable } from './table';
+export { TableSubscriber, type TableSubscriberProps } from './table-subscriber';

package/dist/types/components/pro-table/components/operation-button-group.d.ts

@@ -0,0 +1,7 @@
+import { FC, ReactNode } from 'react';
+import { ProTableState } from '../store';
+export interface OperationButtonGroupProps<TSelected = NoInfer<ProTableState>> {
+    selector?: (state: NoInfer<ProTableState>) => TSelected;
+    children: ((state: NoInfer<TSelected>) => ReactNode) | ReactNode;
+}
+export declare const OperationButtonGroup: (<TSelected = NoInfer<ProTableState>>(props: OperationButtonGroupProps<TSelected>) => ReactNode) & Pick<FC, "displayName">;

package/dist/types/components/pro-table/components/ref.d.ts

@@ -0,0 +1,3 @@
+import { PropsWithRef } from '@vef-framework/components';
+import { ProTableRef } from '../types';
+export declare function ProTableRefHolder({ ref }: PropsWithRef<ProTableRef>): null;

package/dist/types/components/pro-table/components/table-subscriber.d.ts

@@ -0,0 +1,9 @@
+import { FC, ReactNode } from 'react';
+import { ProTableState } from '../store';
+export interface TableSubscriberProps<TSelected = NoInfer<ProTableState>, TRow = unknown> {
+    selector?: (state: NoInfer<ProTableState> & {
+        data: readonly TRow[];
+    }) => TSelected;
+    children: ((state: NoInfer<TSelected>) => ReactNode) | ReactNode;
+}
+export declare const TableSubscriber: (<TSelected = NoInfer<ProTableState>>(props: TableSubscriberProps<TSelected>) => ReactNode) & Pick<FC, "displayName">;

package/dist/types/components/pro-table/components/table-summary.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode, NamedExoticComponent } from 'react';
+interface TableSummaryProps {
+    summary: ReactNode;
+    data: readonly unknown[];
+}
+export declare const TableSummary: NamedExoticComponent<TableSummaryProps>;
+export {};

package/dist/types/components/pro-table/components/table-title.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode, NamedExoticComponent } from 'react';
+interface TableTitleProps {
+    title: ReactNode;
+    data: readonly unknown[];
+}
+export declare const TableTitle: NamedExoticComponent<TableTitleProps>;
+export {};

package/dist/types/components/pro-table/components/table.d.ts

@@ -0,0 +1,6 @@
+import { NonPaginatedProTableProps, PaginatedProTableProps } from '../props';
+type PaginatedTableProps<TRow extends object, TParams extends object> = Pick<PaginatedProTableProps<TRow, TParams>, "className" | "style" | "queryFn" | "queryEnabled" | "queryParams" | "columns" | "rowKey" | "rowSelection" | "showSequenceColumn" | "operationColumn" | "selectedRowKeys" | "virtual" | "title" | "summary" | "onSelectedRowKeysChange">;
+type NonPaginatedTableProps<TRow extends object, TParams extends object> = Pick<NonPaginatedProTableProps<TRow, TParams>, "className" | "style" | "queryFn" | "queryEnabled" | "queryParams" | "columns" | "rowKey" | "rowSelection" | "showSequenceColumn" | "operationColumn" | "selectedRowKeys" | "virtual" | "title" | "summary" | "onSelectedRowKeysChange">;
+export declare function PaginatedTable<TRow extends object, TParams extends object>({ className, style, queryFn, columns, rowKey, rowSelection, queryEnabled, queryParams, showSequenceColumn, operationColumn, selectedRowKeys, virtual, title, summary, onSelectedRowKeysChange }: PaginatedTableProps<TRow, TParams>): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare function NonPaginatedTable<TRow extends object, TParams extends object>({ className, style, queryFn, columns, rowKey, rowSelection, queryEnabled, queryParams, showSequenceColumn, operationColumn, selectedRowKeys, virtual, title, summary, onSelectedRowKeysChange }: NonPaginatedTableProps<TRow, TParams>): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/pro-table/context.d.ts

@@ -0,0 +1,3 @@
+import { Provider } from 'react';
+export declare const DataProvider: Provider<readonly unknown[]>;
+export declare function useData(): readonly unknown[];

package/dist/types/components/pro-table/event.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter } from '@vef-framework/shared';
+export type ProTableEvents = {
+    /**
+     * Trigger table data refetch
+     */
+    refetch: void;
+    /**
+     * Emitted when table starts loading data
+     */
+    loading: void;
+    /**
+     * Emitted when table finishes loading data
+     */
+    loaded: void;
+};
+export declare function createEventEmitter(): EventEmitter<ProTableEvents>;

package/dist/types/components/pro-table/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { useRowSelection } from './use-row-selection';
+export { useTableColumns } from './use-table-columns';

package/dist/types/components/pro-table/hooks/use-row-selection.d.ts

@@ -0,0 +1,12 @@
+import { TableRowSelection } from '@vef-framework/components';
+import { Key } from '@vef-framework/shared';
+import { RowSelectionConfig } from '../types';
+/**
+ * Hook to create row selection configuration for ProTable
+ *
+ * @param config - The row selection configuration
+ * @param selectedRowKeys - The currently selected row keys
+ * @param onSelectedRowKeysChange - Callback when selected row keys change
+ * @returns The table row selection configuration
+ */
+export declare function useRowSelection<TRow extends object>(config: RowSelectionConfig<TRow> | true | undefined, selectedRowKeys?: Key[], onSelectedRowKeysChange?: (selectedRowKeys: Key[], selectedRows: TRow[]) => void): TableRowSelection<TRow> | undefined;

package/dist/types/components/pro-table/hooks/use-table-columns.d.ts

@@ -0,0 +1,11 @@
+import { TableColumn } from '@vef-framework/components';
+import { OperationColumnConfig } from '../types';
+/**
+ * The hook to use the table columns.
+ *
+ * @param tableColumns - The columns of the table.
+ * @param operationColumn - The operation column of the table.
+ * @param showSequenceColumn - Whether to show the sequence column. Default is true.
+ * @returns The table columns.
+ */
+export declare function useTableColumns<TRow extends object>(tableColumns: Array<TableColumn<TRow>>, operationColumn?: OperationColumnConfig<TRow>, showSequenceColumn?: boolean): Array<TableColumn<TRow>>;

package/dist/types/components/pro-table/index.d.ts

@@ -0,0 +1,11 @@
+import { Awaitable } from '@vef-framework/shared';
+import { FC, ReactNode } from 'react';
+import { ProTableProps } from './props';
+import { ProTableRef } from './types';
+export declare const ProTable: (<TRow extends object, TParams extends object>(props: ProTableProps<TRow, TParams> & {
+    ref?: React.Ref<ProTableRef>;
+}) => Awaitable<ReactNode>) & Pick<FC, "displayName">;
+export { OperationButtonGroup, TableSubscriber as ProTableSubscriber, type OperationButtonGroupProps, type TableSubscriberProps as ProTableSubscriberProps } from './components';
+export type { ProTableProps } from './props';
+export type { ProTableState } from './store';
+export type { OperationColumnConfig, ParamsWithPagination, ParamsWithSort, ProTableRef, RowSelectionConfig } from './types';

package/dist/types/components/pro-table/props.d.ts

@@ -0,0 +1,118 @@
+import { TableColumn } from '@vef-framework/components';
+import { PaginationResult, QueryFunction } from '@vef-framework/core';
+import { DeepKeys, Key } from '@vef-framework/shared';
+import { CSSProperties, ReactNode } from 'react';
+import { OperationColumnConfig, ParamsWithPagination, ParamsWithSort, RowSelectionConfig } from './types';
+/**
+ * Base props for ProTable component
+ *
+ * @template TRow - The type of table row data
+ * @template TParams - The type of query parameters
+ */
+interface BaseProTableProps<TRow, TParams> {
+    /**
+     * Class name for the table container
+     */
+    className?: string;
+    /**
+     * Inline styles for the table container
+     */
+    style?: CSSProperties;
+    /**
+     * Table column definitions
+     */
+    columns: Array<TableColumn<NoInfer<TRow>>>;
+    /**
+     * Whether to show the sequence (row number) column. Default is true.
+    */
+    showSequenceColumn?: boolean;
+    /**
+      * Row key extractor: either a deep key of the row model or a function
+    */
+    rowKey?: DeepKeys<NoInfer<TRow>> | ((row: NoInfer<TRow>) => Key);
+    /**
+     * Enable virtual scrolling for the table to improve performance with large datasets
+     * @default false
+     */
+    virtual?: boolean;
+    /**
+   * Currently selected row keys
+   */
+    selectedRowKeys?: Key[];
+    /**
+     * Operation column configuration for per-row actions
+     */
+    operationColumn?: OperationColumnConfig<NoInfer<TRow>>;
+    /**
+     * Row selection configuration
+     * - `true`: Enable row selection with default configuration
+     * - `RowSelectionConfig<TRow>`: Enable row selection with custom configuration
+     * - `undefined`: Disable row selection (default)
+     */
+    rowSelection?: RowSelectionConfig<NoInfer<TRow>> | true;
+    /**
+     * Function to determine whether the query should be enabled
+     */
+    queryEnabled?: (params?: TParams) => boolean;
+    /**
+     * Query parameters that trigger re-fetching when changed.
+     */
+    queryParams?: TParams;
+    /**
+     * Custom header content to be rendered above the title
+     */
+    header?: ReactNode;
+    /**
+     * Title to be displayed above the table
+     */
+    title?: ReactNode;
+    /**
+     * Summary information to be displayed below the table
+     */
+    summary?: ReactNode;
+    /**
+     * Custom footer content to be rendered below the summary
+     */
+    footer?: ReactNode;
+    /**
+     * Callback when selected row keys change
+     */
+    onSelectedRowKeysChange?: (keys: Key[], rows: TRow[]) => void;
+}
+/**
+ * Props for paginated ProTable
+ *
+ * @template TRow - The type of table row data
+ * @template TParams - The type of query parameters
+ */
+export interface PaginatedProTableProps<TRow, TParams> extends BaseProTableProps<TRow, TParams> {
+    /**
+     * Enable pagination mode. Default is true.
+     */
+    isPaginated?: true;
+    /**
+     * Query function for fetching paginated data
+     */
+    queryFn: QueryFunction<PaginationResult<TRow>, ParamsWithSort<ParamsWithPagination<TParams>>>;
+}
+/**
+ * Props for non-paginated ProTable
+ *
+ * @template TRow - The type of table row data
+ * @template TParams - The type of query parameters
+ */
+export interface NonPaginatedProTableProps<TRow, TParams> extends BaseProTableProps<TRow, TParams> {
+    /**
+     * Disable pagination mode for this variant
+     */
+    isPaginated: false;
+    /**
+     * Query function for fetching the full list data
+     */
+    queryFn: QueryFunction<TRow[], ParamsWithSort<TParams>>;
+}
+/**
+ * Discriminated union of paginated and non-paginated ProTable props
+ */
+export type ProTableProps<TRow, TParams> = PaginatedProTableProps<TRow, TParams> | NonPaginatedProTableProps<TRow, TParams>;
+export {};

package/dist/types/components/pro-table/store.d.ts

@@ -0,0 +1,35 @@
+import { PaginationParams, StoreProviderProps, UseStore, UnboundStore } from '@vef-framework/core';
+import { EventEmitter } from '@vef-framework/shared';
+import { OrderSpec } from '../../types';
+import { ProTableEvents } from './event';
+import { ComponentType } from 'react';
+/**
+ * State for the ProTable component
+ */
+export interface ProTableState {
+    /**
+     * Internal event bus used for cross-part communication within ProTable.
+     */
+    eventEmitter: EventEmitter<ProTableEvents>;
+    /**
+     * Current pagination parameters
+     */
+    paginationParams: PaginationParams;
+    /**
+     * Update pagination parameters
+     */
+    setPaginationParams: (params: PaginationParams) => void;
+    /**
+     * Current sort order specifications
+     */
+    sort: OrderSpec[];
+    /**
+     * Update sort order specifications
+     */
+    setSort: (sort: OrderSpec[]) => void;
+    /**
+     * Refetch data with current query params, current pagination and sort parameters
+     */
+    refetch: () => void;
+}
+export declare const ProTableStoreProvider: ComponentType<StoreProviderProps<never>>, useProTableStore: UseStore<ProTableState>, useProTableStoreApi: <TStrictState extends ProTableState = ProTableState>() => UnboundStore<TStrictState>;

package/dist/types/components/pro-table/types.d.ts

@@ -0,0 +1,86 @@
+import { Length } from '@vef-framework/components';
+import { PaginationParams } from '@vef-framework/core';
+import { Key } from '@vef-framework/shared';
+import { ReactNode } from 'react';
+import { SYMBOL_PAGINATION, SYMBOL_SORT } from '../../constants';
+import { OrderSpec } from '../../types';
+/**
+ * Imperative handle for ProTable component.
+ * Exposed via ref to allow parent components to programmatically control the table.
+ */
+export interface ProTableRef {
+    /**
+     * Manually trigger a data refetch.
+     * Useful when you need to refresh the table data after external changes.
+     */
+    refetch: () => void;
+    /**
+     * Register a callback to be invoked when table starts loading data
+     */
+    onLoading: (callback: () => void) => () => void;
+    /**
+     * Register a callback to be invoked when table finishes loading data
+     */
+    onLoaded: (callback: () => void) => () => void;
+}
+/**
+ * Represents request parameters enhanced with pagination metadata.
+ */
+export type ParamsWithPagination<TParams> = TParams & {
+    [SYMBOL_PAGINATION]?: PaginationParams;
+};
+/**
+ * Represents request parameters enhanced with sort metadata.
+ */
+export type ParamsWithSort<TParams> = TParams & {
+    [SYMBOL_SORT]?: OrderSpec[];
+};
+/**
+ * Configuration for the operation column which renders per-row actions
+ */
+export interface OperationColumnConfig<TRow> {
+    /**
+     * Column width. Accepts any valid `Length` value.
+     */
+    width?: Length;
+    /**
+     * Column header title. Can be plain text or a React node.
+     */
+    title?: ReactNode;
+    /**
+     * Permission tokens required to display the operation content.
+     * Use this to conditionally hide actions based on authorization.
+     */
+    permTokens?: string[];
+    /**
+     * Render function for the operation cell of a row.
+     * Receives the current row data and its index, and should return a React node
+     * that contains operation elements (e.g., buttons, menus).
+     */
+    render: (row: TRow, index: number) => ReactNode;
+}
+/**
+ * The configuration for the row selection of the table.
+ */
+export interface RowSelectionConfig<TRow> {
+    /**
+     * If set, row selection will be disabled for the row with the function returns true
+     */
+    rowSelectDisabled?: (model: TRow) => boolean;
+    /**
+     * Keep the selection keys in list even the key not exist in `dataSource` anymore
+     */
+    checkStrictly?: boolean;
+    /**
+     * Whether hide select all checkbox
+     */
+    hideSelectAll?: boolean;
+    /**
+     * Keep the selection keys in list even the key not exist in `dataSource` anymore
+     */
+    preserveSelectedRowKeys?: boolean;
+    /**
+     * The default selected row keys
+     */
+    defaultSelectedRowKeys?: Key[];
+}

package/dist/types/components/router-provider/context.d.ts

@@ -0,0 +1,6 @@
+import { AnyRouter, RegisteredRouter, RouterProps } from '@tanstack/react-router';
+import { MaybeNull } from '@vef-framework/shared';
+import { Provider } from 'react';
+export type UseRouterContext<TRouter extends AnyRouter = RegisteredRouter, TDehydrated extends Record<string, any> = Record<string, any>> = () => NonNullable<RouterProps<TRouter, TDehydrated>["context"]>;
+export declare function useRouterContextHook(): MaybeNull<UseRouterContext<AnyRouter, Record<string, any>>>;
+export declare const RouterContextHookProvider: Provider<MaybeNull<UseRouterContext<AnyRouter, Record<string, any>>>>;

package/dist/types/components/router-provider/index.d.ts

@@ -0,0 +1,5 @@
+import { AnyRouter, RegisteredRouter } from '@tanstack/react-router';
+import { RouterProviderProps } from './props';
+export declare function RouterProvider<TRouter extends AnyRouter = RegisteredRouter, TDehydrated extends Record<string, any> = Record<string, any>>({ router }: RouterProviderProps<TRouter, TDehydrated>): import("@emotion/react/jsx-runtime").JSX.Element;
+export { RouterContextHookProvider, type UseRouterContext } from './context';
+export { type RouterProviderProps } from './props';

package/dist/types/components/router-provider/props.d.ts

@@ -0,0 +1,7 @@
+import { AnyRouter, RegisteredRouter } from '@tanstack/react-router';
+import { AppProps } from '../app';
+/**
+ * The props for the RouterProvider component.
+ */
+export interface RouterProviderProps<TRouter extends AnyRouter = RegisteredRouter, TDehydrated extends Record<string, any> = Record<string, any>> extends Pick<AppProps<TRouter, TDehydrated>, "router"> {
+}

package/dist/types/components/theme-config-provider/global-style.d.ts

@@ -0,0 +1,2 @@
+import { SerializedStyles } from '@emotion/serialize';
+export declare const globalStyle: SerializedStyles;

package/dist/types/components/theme-config-provider/index.d.ts

@@ -0,0 +1,2 @@
+import { PropsWithChildren } from 'react';
+export declare function ThemeConfigProvider({ children }: PropsWithChildren): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/types/components/theme-config-provider/use-color-mode-effect.d.ts

@@ -0,0 +1 @@
+export declare function useColorModeEffect(): void;

package/dist/types/components/theme-config-provider/use-theme-config.d.ts

@@ -0,0 +1,2 @@
+import { ThemeConfig } from '@vef-framework/components';
+export declare function useThemeConfig(): ThemeConfig;

package/dist/types/constants/event.d.ts

@@ -0,0 +1,4 @@
+/**
+ * The event type for reloading the page.
+ */
+export declare const RELOAD_PAGE_EVENT = "__vef_reload_page_event";

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

@@ -0,0 +1,4 @@
+export { RELOAD_PAGE_EVENT } from './event';
+export { ACCESS_DENIED_ROUTE_ID, ACCESS_DENIED_ROUTE_PATH, INDEX_ROUTE_ID, INDEX_ROUTE_PATH, LOGIN_ROUTE_ID, LOGIN_ROUTE_PATH } from './router';
+export { STORAGE_KEY_PREFIX_STORE, STORAGE_KEY_SUFFIX_STORE } from './storage';
+export { SYMBOL_PAGINATION, SYMBOL_SORT } from './symbols';