@vef-framework/starter 2.0.11 → 2.1.0

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

@@ -0,0 +1,105 @@
+import { TableColumn } from '@vef-framework/components';
+import { DragDropEvents, PaginationParams, StoreProviderProps, UseStore, UnboundStore } from '@vef-framework/core';
+import { EventEmitter, Key } from '@vef-framework/shared';
+import { ReactNode, ComponentType } from 'react';
+import { OrderSpec } from '../../types';
+import { ProTableEvents } from './event';
+/**
+ * Column setting configuration
+ */
+export interface ColumnSetting {
+    /**
+     * Column unique identifier
+     */
+    id: Key;
+    /**
+     * Column display title
+     */
+    title: ReactNode;
+    /**
+     * Column fixed position
+     */
+    fixed?: "start" | "end" | false;
+    /**
+     * Column width in pixels
+     */
+    width?: number;
+    /**
+     * Whether the column is visible
+     */
+    visible: boolean;
+    /**
+     * Original column index for reference
+     */
+    originalIndex: number;
+}
+/**
+ * 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;
+    /**
+     * Column settings state for customization
+     */
+    columnSettings: ColumnSetting[];
+    /**
+     * Original column settings for reset functionality
+     */
+    originalColumnSettings: ColumnSetting[];
+    /**
+     * Initialize column settings from columns prop
+     */
+    initColumnSettings: (columns: TableColumn[]) => void;
+    /**
+     * Set column settings directly
+     */
+    setColumnSettings: (settings: ColumnSetting[]) => void;
+    /**
+     * Reorder columns by drag event
+     */
+    reorderColumns: (event: Parameters<DragDropEvents["dragend"]>[0]) => void;
+    /**
+     * Toggle column fixed state
+     */
+    setColumnFixed: (id: Key, fixed: "start" | "end" | false) => void;
+    /**
+     * Update column width
+     */
+    setColumnWidth: (id: Key, width: number) => void;
+    /**
+     * Toggle column visibility
+     */
+    setColumnVisible: (id: Key, visible: boolean) => void;
+    /**
+     * Reset column settings to original state
+     *
+     * @param clearStorage - Optional callback to clear localStorage
+     */
+    resetColumnSettings: (clearStorage?: () => void) => void;
+}
+export declare function getColumnId(column: TableColumn, index: number): string;
+export declare function createColumnSetting(column: TableColumn, index: number): ColumnSetting;
+export declare const ProTableStoreProvider: ComponentType<StoreProviderProps<never>>, useProTableStore: UseStore<ProTableState>, useProTableStoreApi: <TStrictState extends ProTableState = ProTableState>() => UnboundStore<TStrictState>;

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

@@ -0,0 +1,103 @@
+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';
+/**
+ * Configuration for column settings feature
+ */
+export interface ColumnSettingsConfig {
+    /**
+     * Storage key for persisting column settings to localStorage.
+     * If provided, settings will be saved with key: `__VEF_PRO_TABLE_COLUMN_SETTINGS__${storageKey}`
+     * If not provided, settings will not be persisted.
+     */
+    storageKey?: string;
+}
+/**
+ * Column settings prop type.
+ * - `false`: Disable column settings feature, hide settings icon
+ * - `ColumnSettingsConfig`: Enable column settings with optional persistence
+ */
+export type ColumnSettingsProp = false | ColumnSettingsConfig;
+/**
+ * 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/src/components/router-provider/context.d.ts

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

package/dist/types/src/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>): React.ReactNode;
+export { RouterContextHookProvider, type RouterContext, type UseRouterContext } from './context';
+export { type RouterProviderProps } from './props';

package/dist/types/src/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/src/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/src/components/theme-config-provider/index.d.ts

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

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

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

package/dist/types/src/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/src/constants/event.d.ts

@@ -0,0 +1,3 @@
+export declare const RELOAD_PAGE_EVENT = "__vef_reload_page_event";
+export declare const ACCESS_DENIED_EVENT = "__vef_access_denied_event";
+export declare const UNAUTHENTICATED_EVENT = "__vef_unauthenticated_event";

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

@@ -0,0 +1,4 @@
+export { ACCESS_DENIED_EVENT, RELOAD_PAGE_EVENT, UNAUTHENTICATED_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';

package/dist/types/src/constants/router.d.ts

@@ -0,0 +1,6 @@
+export declare const LOGIN_ROUTE_PATH = "/login";
+export declare const LOGIN_ROUTE_ID = "/_common/login";
+export declare const INDEX_ROUTE_PATH = "/";
+export declare const INDEX_ROUTE_ID = "/_layout";
+export declare const ACCESS_DENIED_ROUTE_PATH = "/access-denied";
+export declare const ACCESS_DENIED_ROUTE_ID = "/_common/access-denied";

package/dist/types/src/constants/storage.d.ts

@@ -0,0 +1,2 @@
+export declare const STORAGE_KEY_PREFIX_STORE = "__VEF_STORE__";
+export declare const STORAGE_KEY_SUFFIX_STORE = "__";

package/dist/types/src/constants/symbols.d.ts

@@ -0,0 +1,2 @@
+export declare const SYMBOL_PAGINATION: unique symbol;
+export declare const SYMBOL_SORT: unique symbol;

package/dist/types/src/helpers/api.d.ts

@@ -0,0 +1,6 @@
+import { HttpClientOptions, QueryClientOptions, ApiClient } from '@vef-framework/core';
+export interface ApiClientOptions {
+    http: Pick<HttpClientOptions, "baseUrl" | "timeout" | "okCode" | "tokenExpiredCode" | "refreshToken">;
+    query?: Pick<QueryClientOptions, "gcTime" | "staleTime">;
+}
+export declare function createApiClient({ http, query }: ApiClientOptions): ApiClient;

package/dist/types/src/helpers/app-version.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+export interface AppChangelog {
+    version: string;
+    date?: string;
+    description?: string;
+    changes?: string[];
+}
+export interface AppVersionNotificationOptions {
+    enabled?: boolean;
+    basePath?: string;
+    checkInterval?: number;
+    title?: ReactNode;
+    description?: ReactNode;
+    confirmText?: ReactNode;
+    cancelText?: ReactNode;
+    onConfirm?: () => void;
+    onCancel?: () => void;
+}
+export declare function setupAppVersionNotification(options?: AppVersionNotificationOptions): (() => void) | undefined;

package/dist/types/src/helpers/app.d.ts

@@ -0,0 +1,11 @@
+import { AnyRouter, RegisteredRouter } from '@tanstack/react-router';
+import { AppProps, UseRouterContext } from '../components';
+export interface AppOptions<TRouter extends AnyRouter = RegisteredRouter, TDehydrated extends Record<string, unknown> = Record<string, unknown>> {
+    strictMode?: boolean;
+    useRouterContext?: UseRouterContext<TRouter, TDehydrated>;
+}
+export interface AppInstance {
+    render: (props: AppProps) => void;
+    unmount: () => void;
+}
+export declare function createApp<TRouter extends AnyRouter = RegisteredRouter, TDehydrated extends Record<string, unknown> = Record<string, unknown>>({ strictMode, useRouterContext }?: AppOptions<TRouter, TDehydrated>): AppInstance;

package/dist/types/src/helpers/auth.d.ts

@@ -0,0 +1,2 @@
+import { AnyRouter } from '@tanstack/react-router';
+export declare function handleClientLogout(router: AnyRouter): Promise<void>;

package/dist/types/src/helpers/event.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from '@vef-framework/shared';
+export declare const eventEmitter: EventEmitter<{
+    __vef_reload_page_event: string;
+    __vef_access_denied_event: void;
+    __vef_unauthenticated_event: void;
+}>;
+export declare function dispatchCustomEvent<T = unknown>(type: string, options?: CustomEventInit<T>): boolean;
+export declare function reloadPage(key: string): void;
+export declare function emitAccessDenied(): void;
+export declare function emitUnauthenticated(): void;

package/dist/types/src/helpers/index.d.ts

@@ -0,0 +1,7 @@
+export { createApiClient, type ApiClientOptions } from './api';
+export { createApp } from './app';
+export { setupAppVersionNotification, type AppChangelog, type AppVersionNotificationOptions } from './app-version';
+export { handleClientLogout } from './auth';
+export { dispatchCustomEvent, eventEmitter, reloadPage } from './event';
+export { extractQueryParams, noopMutationFn } from './query';
+export { createRouter, type RouterOptions } from './router';

package/dist/types/src/helpers/query.d.ts

@@ -0,0 +1,13 @@
+import { PaginationParams } from '@vef-framework/core';
+import { AnyObject, MaybeUndefined } from '@vef-framework/shared';
+import { OrderSpec } from '../types';
+import { SYMBOL_PAGINATION, SYMBOL_SORT } from '../constants';
+export declare function noopMutationFn<TResult = unknown, TArgs extends unknown[] = unknown[]>(..._args: TArgs): Promise<TResult>;
+export declare namespace noopMutationFn {
+    var key: string;
+}
+export declare function extractQueryParams<TParams extends AnyObject>(queryParams: TParams): {
+    params: Omit<TParams, typeof SYMBOL_PAGINATION | typeof SYMBOL_SORT>;
+    pagination: MaybeUndefined<PaginationParams>;
+    sort: MaybeUndefined<OrderSpec[]>;
+};

package/dist/types/src/helpers/router.d.ts

@@ -0,0 +1,10 @@
+import { AnyRouteWithContext } from '@tanstack/react-router';
+import { RouterContext } from '../types';
+import { RouterCore } from '@tanstack/router-core';
+import { RouterHistory } from '@tanstack/history';
+export interface RouterOptions {
+    history: "hash" | "browser";
+    routeTree: AnyRouteWithContext<RouterContext>;
+    context: RouterContext;
+}
+export declare function createRouter({ history, routeTree, context }: RouterOptions): RouterCore<AnyRouteWithContext<RouterContext>, "never", true, RouterHistory, Record<string, any>>;

package/dist/types/src/hooks/index.d.ts

@@ -0,0 +1 @@
+export { useRouteFullPath } from './use-route-full-path';

package/dist/types/src/hooks/use-route-full-path.d.ts

@@ -0,0 +1 @@
+export declare function useRouteFullPath(): string;

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

@@ -0,0 +1,6 @@
+export { createCrudKit, Crud, CrudPage, FlexCard, FormDrawer, FormModal, OperationButtonGroup, Page, ProSearch, ProTable, ProTableSubscriber, useViewportHeight, type CrudActionButtonGroupProps, type CrudBasicFormScene, type CrudBasicSceneFormValues, type CrudFormMutationFns, type CrudFormScene, type CrudKit, type CrudOperationButtonGroupProps, type CrudPageProps, type CrudProps, type FlexCardProps, type FormDrawerProps, type FormModalProps, type LoginParams, type LoginResult, type OperationButtonGroupProps, type OperationColumnConfig, type PageProps, type PaginatedQueryParams, type ParamsWithPagination, type ParamsWithSort, type ProSearchProps, type ProTableProps, type ProTableRef, type ProTableState, type ProTableSubscriberProps, type QueryParams, type RowSelectionConfig } from './components';
+export * from './constants';
+export * from './helpers';
+export * from './routes';
+export * from './stores';
+export type * from './types';

package/dist/types/src/models/index.d.ts

@@ -0,0 +1 @@
+export type { AuthTokens } from '@vef-framework/core';

package/dist/types/src/routes/access-denied.d.ts

@@ -0,0 +1,11 @@
+import { AnyRouter, ParsedLocation } from '@tanstack/react-router';
+import { AccessDenied } from '../components';
+export declare function createAccessDeniedRouteOptions(): {
+    readonly component: typeof AccessDenied;
+    readonly beforeLoad: ({ location, context: { router } }: {
+        location: ParsedLocation;
+        context: {
+            router: AnyRouter;
+        };
+    }) => void;
+};

package/dist/types/src/routes/index.d.ts

@@ -0,0 +1,4 @@
+export { createAccessDeniedRouteOptions } from './access-denied';
+export { createLayoutRouteOptions } from './layout';
+export { createLoginRouteOptions } from './login';
+export { createRootRouteOptions } from './root';

package/dist/types/src/routes/layout.d.ts

@@ -0,0 +1,22 @@
+import { ParsedLocation } from '@tanstack/react-router';
+import { Awaitable, Except } from '@vef-framework/shared';
+import { LayoutProps, Error, NotFound } from '../components';
+import { UserInfo } from '../types';
+interface LayoutRouteOptions extends Except<LayoutProps, "children"> {
+    fetchUserInfo: () => Awaitable<UserInfo>;
+}
+export declare function createLayoutRouteOptions({ fetchUserInfo, ...layoutProps }: LayoutRouteOptions): {
+    readonly beforeLoad: ({ location }: {
+        location: ParsedLocation;
+    }) => void;
+    readonly loader: ({ location }: {
+        location: ParsedLocation;
+    }) => Promise<void>;
+    readonly pendingComponent: () => import("@emotion/react/jsx-runtime").JSX.Element;
+    readonly errorComponent: typeof Error;
+    readonly notFoundComponent: typeof NotFound;
+    readonly component: () => import("@emotion/react/jsx-runtime").JSX.Element;
+    readonly staleTime: number;
+    readonly shouldReload: false;
+};
+export {};

package/dist/types/src/routes/login.d.ts

@@ -0,0 +1,13 @@
+import { LoginProps } from '../components';
+import { z } from '@vef-framework/shared';
+export declare function createLoginRouteOptions(props: LoginProps): {
+    readonly validateSearch: z.ZodObject<{
+        redirect: z.ZodCatch<z.ZodDefault<z.ZodOptional<z.ZodString>>>;
+    }, z.core.$strip>;
+    readonly beforeLoad: ({ search }: {
+        search: {
+            redirect: string;
+        };
+    }) => void;
+    readonly component: () => import("@emotion/react/jsx-runtime").JSX.Element;
+};

package/dist/types/src/routes/root.d.ts

@@ -0,0 +1,8 @@
+interface RootProps {
+    appTitle: string;
+}
+export declare function createRootRouteOptions({ appTitle }: RootProps): {
+    readonly component: () => import("@emotion/react/jsx-runtime").JSX.Element;
+    readonly ssr: false;
+};
+export {};

package/dist/types/src/stores/app.d.ts

@@ -0,0 +1,14 @@
+import { MenuItem } from '@vef-framework/components';
+import { AuthTokens, UseBoundStoreWithPersist } from '@vef-framework/core';
+import { Except } from '@vef-framework/shared';
+import { UserInfo, UserMenu } from '../types';
+export interface AppState {
+    isAuthenticated: boolean;
+    authTokens?: Readonly<AuthTokens>;
+    userInfo?: Readonly<Except<UserInfo, "permTokens">>;
+    userMenuMap?: Readonly<Map<string, Readonly<UserMenu>>>;
+    menuPathMap?: Readonly<Map<string, readonly string[]>>;
+    menuItems?: ReadonlyArray<Readonly<MenuItem>>;
+    permTokens?: Readonly<Set<string>>;
+}
+export declare const useAppStore: UseBoundStoreWithPersist<AppState>;

package/dist/types/src/stores/index.d.ts

@@ -0,0 +1,6 @@
+export { useAppStore } from './app';
+export type { AppState } from './app';
+export { useTabStore } from './tab';
+export type { Tab, TabState } from './tab';
+export { useThemeStore } from './theme';
+export type { ColorScheme, ThemeColors, ThemeState } from './theme';

package/dist/types/src/stores/tab.d.ts

@@ -0,0 +1,22 @@
+import { AnyObject } from '@vef-framework/shared';
+import { UseBoundStoreWithPersist } from '@vef-framework/core';
+export interface Tab {
+    id: string;
+    fullPath: string;
+    params: AnyObject;
+    search: AnyObject;
+    label: string;
+}
+export interface TabState {
+    activeTabId?: string;
+    tabs: Tab[];
+    setActiveTabId: (id: string) => void;
+    setTabs: (tabs: Tab[]) => void;
+    addTab: (tab: Tab) => void;
+    removeTab: (id: string, navigate: (tab?: Tab) => void) => void;
+    removeAllTabs: (navigate: (tab?: Tab) => void) => void;
+    removeAllTabsExcept: (id: string, navigate: (tab?: Tab) => void) => void;
+    removeLeftTabs: (id: string, navigate: (tab?: Tab) => void) => void;
+    removeRightTabs: (id: string, navigate: (tab?: Tab) => void) => void;
+}
+export declare const useTabStore: UseBoundStoreWithPersist<TabState>;

package/dist/types/src/stores/theme.d.ts

@@ -0,0 +1,16 @@
+import { Orientation, SemanticColor } from '@vef-framework/components';
+import { UseBoundStoreWithPersist } from '@vef-framework/core';
+export type ColorScheme = "system" | "light" | "dark";
+export type ThemeColors = Record<SemanticColor, string>;
+export interface ThemeState {
+    isThemeConfigVisible: boolean;
+    colorScheme: ColorScheme;
+    colors: ThemeColors;
+    isGrayscaleMode: boolean;
+    isColorBlindMode: boolean;
+    isMenuAccordionMode: boolean;
+    menuLayout: Orientation;
+    isSidebarCollapsed: boolean;
+    isMainContentMaximum: boolean;
+}
+export declare const useThemeStore: UseBoundStoreWithPersist<ThemeState>;

package/dist/types/src/types/api.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Base identifiable entity with unique identifier
+ *
+ * @template TId - Identifier type, defaults to string
+ */
+export interface IdEntity<TId = string> {
+    /**
+     * Unique identifier of the entity
+     */
+    id: TId;
+}
+/**
+ * Entity with creation tracking information
+ * Extends IdEntity with creation timestamp and creator details
+ *
+ * @template TId - Identifier type, defaults to string
+ * @template TDate - Date type, defaults to string (compatible with most API response formats)
+ */
+export interface CreatedEntity<TId = string, TDate = string> extends IdEntity<TId> {
+    /**
+     * Creation timestamp
+     */
+    createdAt: TDate;
+    /**
+     * Creator user ID
+     */
+    createdBy: TId;
+    /**
+     * Creator user name
+     */
+    createdByName: string;
+}
+/**
+ * Auditable entity with complete creation and update tracking information
+ * Extends CreatedEntity with update timestamp and updater details
+ * Suitable for business entities that require full audit trails
+ *
+ * @template TId - Identifier type, defaults to string
+ * @template TDate - Date type, defaults to string (compatible with most API response formats)
+ */
+export interface AuditedEntity<TId = string, TDate = string> extends CreatedEntity<TId, TDate> {
+    /**
+     * Last update timestamp
+     */
+    updatedAt: TDate;
+    /**
+     * Last updater user ID
+     */
+    updatedBy: TId;
+    /**
+     * Last updater user name
+     */
+    updatedByName: string;
+}
+/**
+ * Wrapper type for batch operations (create/update)
+ * Provides a convenient way to define parameters for APIs that handle multiple items at once
+ *
+ * @template T - The type of items in the batch operation
+ * @example
+ * ```typescript
+ * // API parameter for batch creating users
+ * interface CreateManyUsersParams extends Many<CreateUserParams> {}
+ *
+ * // API parameter for batch updating products
+ * interface UpdateManyProductsParams extends Many<UpdateProductParams> {}
+ * ```
+ */
+export interface Many<T> {
+    /**
+     * List of items to be processed in the batch operation
+     */
+    list: T[];
+}

package/dist/types/src/types/common.d.ts

@@ -0,0 +1,23 @@
+import { LiteralUnion, MaybeNull } from '@vef-framework/shared';
+export type Gender = "male" | "female" | "unknown";
+export type UserMenuType = LiteralUnion<"directory" | "menu" | "view" | "report", string>;
+export interface UserMenu {
+    type: UserMenuType;
+    path: string;
+    name: string;
+    icon?: MaybeNull<string>;
+    meta?: MaybeNull<Record<string, unknown>>;
+    children?: MaybeNull<UserMenu[]>;
+}
+export interface UserInfo {
+    id: string;
+    name: string;
+    gender: Gender;
+    avatar?: MaybeNull<string>;
+    permTokens: string[];
+    menus: UserMenu[];
+}
+export interface OrderSpec {
+    column: string;
+    direction: "asc" | "desc";
+}

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

@@ -0,0 +1,3 @@
+export type * from './api';
+export type * from './common';
+export type * from './router';

package/dist/types/src/types/router.d.ts

@@ -0,0 +1,5 @@
+import { AnyRouter } from '@tanstack/react-router';
+export interface RouterContext {
+    router: AnyRouter;
+    routeTitle?: string;
+}