import { TypeDefault as BaseTypeDefault, CellRenderContext, ColumnEditorContext } from '@toolbox-web/grid';
import { FilterPanelParams } from '@toolbox-web/grid/plugins/filtering';
import { FC, ReactNode } from 'react';
/**
 * Type default configuration for React applications.
 *
 * Defines default renderer, editor, and editorParams for a data type
 * using React function components.
 *
 * @example
 * ```tsx
 * import type { TypeDefault } from '@toolbox-web/grid-react';
 *
 * const countryDefault: TypeDefault<Employee, string> = {
 *   renderer: (ctx) => <CountryFlag code={ctx.value} />,
 *   editor: (ctx) => (
 *     <CountrySelect value={ctx.value} onSelect={ctx.commit} />
 *   ),
 * };
 * ```
 */
export interface TypeDefault<TRow = unknown, TValue = unknown> {
    /** React component/function for rendering cells of this type */
    renderer?: (ctx: CellRenderContext<TRow, TValue>) => ReactNode;
    /** React component/function for editing cells of this type */
    editor?: (ctx: ColumnEditorContext<TRow, TValue>) => ReactNode;
    /** Default editorParams for this type */
    editorParams?: Record<string, unknown>;
    /**
     * Custom filter panel renderer for this type. Requires FilteringPlugin.
     *
     * Returns JSX to render as the custom filter panel content.
     * The rendered content is mounted into the filter panel container.
     *
     * @example
     * ```tsx
     * filterPanelRenderer: (params) => (
     *   <MyFilterPanel
     *     field={params.field}
     *     uniqueValues={params.uniqueValues}
     *     onApply={(values) => params.applySetFilter(values)}
     *     onClear={params.clearFilter}
     *   />
     * )
     * ```
     */
    filterPanelRenderer?: (params: FilterPanelParams) => ReactNode;
}
/**
 * Type defaults registry - a map of type names to their defaults.
 */
export type TypeDefaultsMap = Record<string, TypeDefault>;
/**
 * Props for the GridTypeProvider component.
 */
export interface GridTypeProviderProps {
    /**
     * Type defaults to provide to all descendant grids.
     *
     * @example
     * ```tsx
     * const typeDefaults = {
     *   country: {
     *     renderer: (ctx) => <CountryBadge value={ctx.value} />,
     *     editor: (ctx) => <CountrySelect value={ctx.value} onCommit={ctx.commit} />
     *   },
     *   status: {
     *     renderer: (ctx) => <StatusBadge value={ctx.value} />
     *   }
     * };
     *
     * <GridTypeProvider defaults={typeDefaults}>
     *   <App />
     * </GridTypeProvider>
     * ```
     */
    defaults: TypeDefaultsMap;
    children: ReactNode;
}
/**
 * Provides application-wide type defaults for all descendant grids.
 *
 * Wrap your application (or part of it) with this provider to make
 * type-level renderers and editors available to all DataGrid components.
 *
 * @example
 * ```tsx
 * // App.tsx or main.tsx
 * import { GridTypeProvider, type TypeDefaultsMap } from '@toolbox-web/grid-react';
 *
 * const typeDefaults: TypeDefaultsMap = {
 *   country: {
 *     renderer: (ctx) => <CountryBadge code={ctx.value} />,
 *     editor: (ctx) => (
 *       <CountrySelect
 *         value={ctx.value}
 *         onSelect={(v) => ctx.commit(v)}
 *       />
 *     )
 *   },
 *   date: {
 *     renderer: (ctx) => formatDate(ctx.value),
 *     editor: (ctx) => <DatePicker value={ctx.value} onCommit={ctx.commit} />
 *   }
 * };
 *
 * function App() {
 *   return (
 *     <GridTypeProvider defaults={typeDefaults}>
 *       <Dashboard />
 *     </GridTypeProvider>
 *   );
 * }
 * ```
 *
 * Any DataGrid with columns using `type: 'country'` will automatically
 * use the registered renderer/editor.
 */
export declare const GridTypeProvider: FC<GridTypeProviderProps>;
/**
 * Hook to access the type defaults from context.
 *
 * @returns The type defaults map, or null if not within a GridTypeProvider
 */
export declare function useGridTypeDefaults(): TypeDefaultsMap | null;
/**
 * Hook to get type defaults for a specific type.
 *
 * @param type - The type name to look up
 * @returns The type defaults, or undefined if not found
 *
 * @example
 * ```tsx
 * function MyComponent() {
 *   const countryDefaults = useTypeDefault('country');
 *   // countryDefaults?.renderer, countryDefaults?.editor
 * }
 * ```
 */
export declare function useTypeDefault<TRow = unknown, TValue = unknown>(type: string): TypeDefault<TRow, TValue> | undefined;
/**
 * Creates a BaseTypeDefault that the grid can use from a React type default.
 *
 * This converts React render functions into grid-compatible renderer/editor functions.
 * Used internally by ReactGridAdapter.
 *
 * @internal
 */
export declare function typeDefaultToBaseTypeDefault<TRow = unknown>(typeDefault: TypeDefault<TRow>, renderReactNode: (node: ReactNode) => HTMLElement): BaseTypeDefault<TRow>;
/**
 * Wraps a React filter panel renderer into a vanilla FilterPanelRenderer.
 *
 * Mounts react content into the filter panel container element.
 * Automatically unmounts the previous root when a new panel opens.
 *
 * @internal
 */
export declare function wrapReactFilterPanelRenderer(reactFn: (params: FilterPanelParams) => ReactNode, renderReactNode: (node: ReactNode) => HTMLElement): (container: HTMLElement, params: FilterPanelParams) => void;
/**
 * Internal context for passing the type defaults to the adapter.
 * Used by DataGrid to communicate with ReactGridAdapter.
 * @internal
 */
export declare const GridTypeContextInternal: import('react').Context<TypeDefaultsMap | null>;
//# sourceMappingURL=grid-type-registry.d.ts.map