fastapi-rtk 2.1.4 → 2.2.0

package/dist/core/lib/Tables/NextGenDataGrid/types.d.ts

@@ -0,0 +1,428 @@
+import { ApiContextValue } from 'fastapi-rtk/contexts';
+import { ActionIconProps, BoxProps, FlexProps, GroupProps, HighlightProps, StackProps, TooltipProps } from '@mantine/core';
+import { MRT_Cell, MRT_Column, MRT_ColumnDef, MRT_DefinedTableOptions, MRT_Row, MRT_RowData, MRT_TableInstance, MRT_TableOptions } from '../../../../.external/lib/mantine-react-table';
+import { ReactNode, RefObject } from 'react';
+import { StoreApi, UseBoundStore } from '../../../../.external/lib/zustand';
+import { DeleteProps } from '../../ActionIcons/Delete/types';
+import { EditProps } from '../../ActionIcons/Edit/types';
+import { ViewProps } from '../../ActionIcons/View/types';
+import { AddDialogProps, DeleteDialogProps, EditDialogProps, ViewDialogProps } from '../../Dialogs/types';
+import { BulkActions } from '../../hooks/api/types';
+import { AuthContextValue } from '../../hooks/auth/types';
+import { GridCustomizer } from '../DataGrid/Main/types';
+import { SelectionStore } from './components/OptimizedMRT_RowSelectColumn/types';
+import { OnClickEntry, Optimizations } from './hooks/types';
+export interface NextGenTableRefs {
+    /** Zustand store backing the optimized row selection column. */
+    selectionStoreRef: RefObject<UseBoundStore<StoreApi<SelectionStore>>>;
+    /** The defined table options, kept current for the optimized selection column. */
+    optionsRef: RefObject<MRT_DefinedTableOptions<MRT_RowData>>;
+    /** The active optimization flags for the grid. */
+    optimizationsRef: RefObject<(NextGenDataGridOptimizationProps & Optimizations) | undefined>;
+}
+export interface NextGenTableOptions {
+    /** Props for the wrapper `Box` around the table container. */
+    mantineTableContainerWrapperProps?: BoxProps;
+    /** Renders custom actions in the center of the top toolbar. */
+    renderTopToolbarCenterActions?: (props: {
+        table: MRT_TableInstance<MRT_RowData>;
+    }) => ReactNode;
+}
+export interface NextGenTableInstance<TData extends MRT_RowData = MRT_RowData> extends MRT_TableInstance<TData> {
+    refs: MRT_TableInstance<TData>['refs'] & NextGenTableRefs;
+    options: MRT_TableInstance<TData>['options'] & NextGenTableOptions;
+}
+export interface FallbackWrapperProps {
+    /** The fallback element to render if children are not provided. */
+    fallback?: ReactNode;
+    /** The arguments to pass to the children function if it is a function. */
+    functionProps: Record<string, any>;
+    /** The children to render, which can be a React node or a function. */
+    children?: ReactNode | ((functionProps: Record<string, any>) => ReactNode);
+}
+export interface NextGenDataGridChildrenProps {
+    /** MantineReactTable instance. */
+    table: MRT_TableInstance<MRT_RowData>;
+}
+export interface NextGenDataGridFilterStateProps {
+    /** Filter value. When provided, the value will be synchronized with the inner filter state. */
+    value?: any;
+    /** Callback when the inner filter value changes. */
+    onChange: (value: any) => void;
+    /** Callback when the operator changes. */
+    onOprChange?: (props: {
+        value: any;
+        opr: string;
+    }) => void;
+}
+export interface NextGenDataGridFilterSyncProps {
+    /** Function to compare values for synchronization. Defaults to strict equality (`===`). */
+    equals?: (a: any, b: any) => boolean;
+    /** Debounce delay in milliseconds for synchronization. Defaults to `DEBOUNCE_DELAY`. */
+    delay?: number;
+}
+export interface NextGenDataGridMRTProps {
+    /** The cell object. */
+    cell: MRT_Cell<MRT_RowData>;
+    /** The column object. */
+    column: MRT_Column<MRT_RowData>;
+    /** The rendered cell value. */
+    renderedCellValue: number | ReactNode | string;
+    /** The rendered column index. */
+    renderedColumnIndex?: number;
+    /** The rendered row index. */
+    renderedRowIndex?: number;
+    /** The row object. */
+    row: MRT_Row<MRT_RowData>;
+    /** The row ref. */
+    rowRef?: RefObject<HTMLTableRowElement>;
+    /** The MantineReactTable instance. */
+    table: MRT_TableInstance<MRT_RowData>;
+}
+export interface NextGenDataGridBodyCellHighlightProps {
+    /** API instance. */
+    api: ApiContextValue;
+    /** Auth instance. */
+    auth: AuthContextValue;
+    /** Row data. */
+    data: MRT_RowData;
+    /** Column properties. */
+    colProps: NextGenDataGridBodyProps;
+    /** MantineReactTable props. */
+    mrtProps: NextGenDataGridMRTProps;
+}
+export interface NextGenDataGridBodyCellTruncateProps {
+    /** The original value before truncation. An array of strings if the value is split on a separator. */
+    original: string | string[];
+    /** The truncated value. An array of strings if separated, null if no truncation is applied. */
+    truncated?: string | string[] | null;
+}
+export interface NextGenDataGridBodyCellCellProps {
+    /** The value of the cell, either `string` or `string[]`. */
+    value: string | string[];
+    /** The truncate object containing the original and truncated value. */
+    truncate: NextGenDataGridBodyCellTruncateProps;
+    /** The highlight keywords to highlight in the cell value. */
+    highlight: string[];
+}
+export interface NextGenDataGridBodyCellComponentProps {
+    /** The value of the cell, either `string` or `string[]`. */
+    value: string | string[];
+}
+export interface NextGenDataGridBodyCellProps {
+    /** API instance. */
+    api: ApiContextValue;
+    /** Auth instance. */
+    auth: AuthContextValue;
+    /** Row data. */
+    data: MRT_RowData;
+    /** Column properties. */
+    colProps: NextGenDataGridBodyProps;
+    /** MantineReactTable props. */
+    mrtProps: NextGenDataGridMRTProps;
+    /** Array of highlight keywords. */
+    highlights: string[];
+    /** The cell object containing the value, truncate and highlight. */
+    cell: NextGenDataGridBodyCellCellProps;
+    /** Props for the cell component. */
+    componentProps: NextGenDataGridBodyCellComponentProps;
+}
+export interface NextGenDataGridQuickFiltersComponentComponentProps {
+    /** The current quick filter value. */
+    value: string;
+    /** Callback when the quick filter value changes. */
+    onChange: (value: string) => void;
+    /** The quick filters data. */
+    data: {
+        label: string;
+        value: any;
+    }[];
+}
+export interface NextGenDataGridQuickFiltersComponentProps {
+    /** API instance. */
+    api: ApiContextValue;
+    /** Auth instance. */
+    auth: AuthContextValue;
+    /** MantineReactTable props. */
+    mrtProps: NextGenDataGridMRTProps;
+    /** Props for the quick filters component. */
+    componentProps: NextGenDataGridQuickFiltersComponentComponentProps;
+}
+export interface NextGenDataGridHeaderParameters {
+    /** API instance. */
+    api: ApiContextValue;
+    /** Auth instance. */
+    auth: AuthContextValue;
+    /** MantineReactTable props. */
+    mrtProps: NextGenDataGridMRTProps;
+}
+export interface NextGenDataGridHeaderFilterComponentParameters {
+    /** API instance. */
+    api: ApiContextValue;
+    /** Auth instance. */
+    auth: AuthContextValue;
+    /** MantineReactTable props. */
+    mrtProps: NextGenDataGridMRTProps;
+    /** Props for the filter component. */
+    componentProps: Record<string, any>;
+}
+export interface NextGenDataGridHeaderFilterMenuPropsParameters {
+    /** The header label. */
+    label: string;
+    /** Whether the filter is disabled. */
+    disabled: boolean;
+    /** The number of active filters. */
+    indicator: number;
+    /** Props for the action icon. */
+    actionIconProps: Partial<ActionIconProps>;
+    /** Callback when the filter menu icon is clicked. */
+    onClick: (event: React.MouseEvent<HTMLElement>) => void;
+}
+export interface NextGenDataGridHeaderFilterMenuParameters {
+    /** API instance. */
+    api: ApiContextValue;
+    /** Auth instance. */
+    auth: AuthContextValue;
+    /** MantineReactTable props. */
+    mrtProps: NextGenDataGridMRTProps;
+    /** Props for the filter menu component. */
+    componentProps: NextGenDataGridHeaderFilterMenuPropsParameters;
+}
+export interface NextGenDataGridHeaderFilterModeDescriptionParameters {
+    /** API instance. */
+    api: ApiContextValue;
+    /** Auth instance. */
+    auth: AuthContextValue;
+    /** MantineReactTable props. */
+    mrtProps: NextGenDataGridMRTProps;
+    /** Props for the filter mode description component. */
+    componentProps: {
+        value: string;
+    };
+}
+export interface NextGenDataGridHeaderProps {
+    /** Customize the header that is shown above the filter. */
+    component?: ReactNode | ((props: NextGenDataGridHeaderParameters) => ReactNode);
+    /** Enables the filter menu that can change the filter mode. Located on the right side of the filter. */
+    enableFilterModes?: boolean;
+    /**
+     * Customize the filter component. When `enableFilterModes` is enabled, this will be a key-value pair object where the
+     * key is the filter operator and the value is the filter component.
+     */
+    filterComponent?: ReactNode | ((props: NextGenDataGridHeaderFilterComponentParameters) => ReactNode) | {
+        [operator: string]: ReactNode | ((props: NextGenDataGridHeaderFilterComponentParameters) => ReactNode);
+    };
+    /**
+     * Props for the filter component. When `enableFilterModes` is enabled, this will be a key-value pair object where the
+     * key is the filter operator and the value is the filter component props.
+     */
+    filterProps?: Record<string, any> | ((props: NextGenDataGridHeaderParameters) => Record<string, any>) | Record<string, Record<string, any> | ((props: NextGenDataGridHeaderParameters) => Record<string, any>)>;
+    /** Manage filter state externally. */
+    filterState?: NextGenDataGridFilterStateProps;
+    /** Options for synchronizing filter state with other components. */
+    filterSync?: NextGenDataGridFilterSyncProps;
+    /** Customize the filter menu action icon beside the filter. Defaults to `Filter Menu` with icon `IconFilterCog`. */
+    filterMenu?: ReactNode | ((props: NextGenDataGridHeaderFilterMenuParameters) => ReactNode);
+    /** Customize the description below the filter when `enableFilterModes` is enabled. */
+    filterModeDescription?: ReactNode | ((props: NextGenDataGridHeaderFilterModeDescriptionParameters) => ReactNode);
+    /** Whether to update the query params when the filter is applied. Default is true. */
+    updateQueryParams?: boolean;
+    /** Whether to store the filter state in local storage. Defaults to false. */
+    withLocalStorage?: boolean;
+    /** The key to use for local storage when `withLocalStorage` is enabled. */
+    localStorageKey?: string;
+    /** Sets the default operator for the filter. The filter component may change based on the operator. */
+    defaultOpr?: string;
+}
+export interface NextGenDataGridBodyProps {
+    /** Customize the component within the body. */
+    component?: ReactNode | ((props: NextGenDataGridBodyCellProps) => ReactNode);
+    /** Separate the value of a column into multiple rows. */
+    separator?: string;
+    /** Truncate the value of a column to a certain length. */
+    truncate?: number;
+    /** Additional highlight keywords to highlight in the cell value. */
+    highlight?: string | string[] | ((props: NextGenDataGridBodyCellHighlightProps) => string | string[]);
+    /** Props for the tooltip component that is shown when the value is truncated. */
+    tooltipProps?: TooltipProps | ((props: NextGenDataGridBodyCellProps & NextGenDataGridBodyCellComponentProps) => TooltipProps);
+    /** Props for the highlight component. */
+    highlightProps?: HighlightProps | ((props: NextGenDataGridBodyCellProps & NextGenDataGridBodyCellComponentProps) => HighlightProps);
+    /** Only applies to the `actions` special key. Props forwarded to the default row `View` action icon. */
+    viewProps?: Partial<ViewProps>;
+    /** Only applies to the `actions` special key. Props forwarded to the default row `Edit` action icon. */
+    editProps?: Partial<EditProps>;
+    /** Only applies to the `actions` special key. Props forwarded to the default row `Delete` action icon. */
+    deleteProps?: Partial<DeleteProps>;
+}
+export interface NextGenDataGridFormProps<TDialogProps = Partial<AddDialogProps>> {
+    /** Initial view mode for the form. Defaults to `normal`. */
+    initialView?: 'normal' | 'fullScreen' | 'overlay';
+    /** Props forwarded to the underlying dialog component (`AddDialog` / `EditDialog` / `ViewDialog` / `DeleteDialog`). */
+    dialogProps?: TDialogProps;
+}
+export interface JSONFormsCustomizerProps {
+    /** Props passed down to the Mantine Input component. */
+    props?: Record<string, any> | ((props: Record<string, any>) => Record<string, any>);
+    /** Component to override the default input component. */
+    component?: ReactNode | ((props: Record<string, any>) => ReactNode);
+}
+/**
+ * Either a component that fully replaces the built-in toolbar button, or `{ component, props }` to replace the
+ * component while forwarding `props` to the original fallback. Pass `null` to hide the button.
+ */
+export type NextGenDataGridToolbarCustomizerEntry = ReactNode | {
+    component: ReactNode;
+    props: Record<string, any>;
+};
+export interface NextGenDataGridToolbarProps {
+    /** Overrides for the built-in toolbar buttons, keyed by button name. Pass `null` for a key to hide that button. */
+    customizer?: {
+        toggleGlobalFilter?: NextGenDataGridToolbarCustomizerEntry;
+        filter?: NextGenDataGridToolbarCustomizerEntry;
+        refresh?: NextGenDataGridToolbarCustomizerEntry;
+        add?: NextGenDataGridToolbarCustomizerEntry;
+        download?: NextGenDataGridToolbarCustomizerEntry;
+        showHideColumns?: NextGenDataGridToolbarCustomizerEntry;
+        toggleDensePadding?: NextGenDataGridToolbarCustomizerEntry;
+        toggleFullScreen?: NextGenDataGridToolbarCustomizerEntry;
+    };
+    /** Extra components inserted into the internal (right-side) toolbar. Keys are 1-based string positions. */
+    custom?: {
+        [position: string]: ReactNode;
+    };
+    /** Custom components rendered on the left of the top toolbar. Mutually exclusive with `quickFilters`. */
+    leftToolbar?: {
+        custom?: {
+            [position: string]: ReactNode;
+        };
+    };
+    /** Custom components rendered in the center of the top toolbar. */
+    centerToolbar?: {
+        custom?: {
+            [position: string]: ReactNode;
+        };
+    };
+    /** Props forwarded to the selection / grouped alert banner shown below the toolbar. */
+    alertBanner?: NextGenDataGridAlertBannerProps;
+}
+export interface NextGenDataGridAlertBannerRenderParameters {
+    /** MantineReactTable instance. */
+    table: MRT_TableInstance<MRT_RowData>;
+}
+export interface NextGenDataGridAlertBannerContentParameters extends NextGenDataGridAlertBannerRenderParameters {
+    /** Selected-rows alert MRT renders by default. */
+    selectedAlert: ReactNode;
+    /** Grouped-rows alert MRT renders by default. */
+    groupedAlert: ReactNode;
+}
+export interface NextGenDataGridAlertBannerWrapperProps {
+    /** Props for the outer Mantine `Flex` wrapper. */
+    flex?: Partial<FlexProps>;
+    /** Props for the inner Mantine `Group` wrapper. */
+    group?: Partial<GroupProps>;
+    /** Props for the Mantine `Stack` that holds the default banner content. */
+    stack?: Partial<StackProps>;
+}
+export interface NextGenDataGridAlertBannerProps {
+    /** Content rendered to the left of the banner. */
+    left?: ReactNode | ((parameters: NextGenDataGridAlertBannerRenderParameters) => ReactNode);
+    /** Content rendered to the right of the banner. */
+    right?: ReactNode | ((parameters: NextGenDataGridAlertBannerRenderParameters) => ReactNode);
+    /** Override the default selected / grouped alert content. */
+    renderToolbarAlertBannerContent?: ReactNode | ((parameters: NextGenDataGridAlertBannerContentParameters) => ReactNode);
+    /** Props for the banner's wrapper components. */
+    wrapperProps?: NextGenDataGridAlertBannerWrapperProps;
+}
+export interface NextGenDataGridOptimizationProps {
+    /** Whether to optimize for selection. */
+    selection?: boolean;
+    /** Ref for the selection value to synchronize with external components when `selection` optimization is enabled. */
+    selectionValueRef?: RefObject<string[]>;
+    /** Whether to optimize for loading state. Defaults to `true`. */
+    loading?: boolean;
+}
+export interface NextGenDataGridQuickFilter {
+    /** The displayed label. */
+    name: string;
+    /** The filter clauses applied when the segment is selected. */
+    value: {
+        col: string;
+        opr: string;
+        value: any;
+    }[];
+}
+export interface NextGenDataGridProps extends Omit<BoxProps, 'children'> {
+    /** Children to render inside the DataGrid. */
+    children?: (props: NextGenDataGridChildrenProps) => ReactNode;
+    /** Whether to fetch data on mount. Default is true. */
+    fetchOnMount?: boolean;
+    /** Whether to hide the toolbar. */
+    hideToolbar?: boolean;
+    /** Whether to hide the per-row actions column (edit / view / delete buttons). */
+    hideActions?: boolean;
+    /** Whether to hide the pagination. */
+    hidePagination?: boolean;
+    /** Whether to hide the error dialog. */
+    hideError?: boolean;
+    /** Callback for checkbox selection. */
+    onSelectCheckbox?: (ids: string[]) => void;
+    /** Callback for row click. The id is the row's `getItemId` result (a `PrimaryKey`, or `undefined` when the row has no id). */
+    onClickEntry?: OnClickEntry;
+    /** Bulk actions object. */
+    bulkActions?: BulkActions;
+    /** MantineReactTable props. Merged as overrides over the grid's generated options. */
+    table?: Partial<MRT_TableOptions<MRT_RowData>> | ((props: MRT_TableOptions<MRT_RowData>) => Partial<MRT_TableOptions<MRT_RowData>>);
+    /** Quick filters shown in the top-left of the toolbar as a `SegmentedControl`. Mutually exclusive with `toolbar.leftToolbar`. */
+    quickFilters?: NextGenDataGridQuickFilter[];
+    /** Custom quick filters component. */
+    quickFiltersComponent?: ReactNode | ((props: NextGenDataGridQuickFiltersComponentProps) => ReactNode);
+    /** Whether to render a border around the table's Mantine `Paper` wrapper. */
+    withBorder?: boolean;
+    /** Column props for the table. */
+    columnProps?: Record<string, MRT_ColumnDef<MRT_RowData, unknown> | ((props: MRT_ColumnDef<MRT_RowData, unknown>) => MRT_ColumnDef<MRT_RowData, unknown>)>;
+    /** Header props for the table. */
+    header?: {
+        [column: string]: NextGenDataGridHeaderProps;
+    };
+    /** Body props for the table. */
+    body?: {
+        [column: string]: NextGenDataGridBodyProps;
+    };
+    /** Form props for the table. */
+    form?: {
+        add?: NextGenDataGridFormProps<Partial<AddDialogProps>> & JSONFormsCustomizerProps;
+        edit?: NextGenDataGridFormProps<Partial<EditDialogProps>> & JSONFormsCustomizerProps;
+        view?: NextGenDataGridFormProps<Partial<ViewDialogProps>> & JSONFormsCustomizerProps;
+        delete?: NextGenDataGridFormProps<Partial<DeleteDialogProps>> & JSONFormsCustomizerProps;
+    };
+    /** Toolbar configuration for the table. */
+    toolbar?: NextGenDataGridToolbarProps;
+    /** Text filter separator for the table. Default is ';'. */
+    textFilterSeparator?: string;
+    /** Enables the advanced filters that allow multiple filters per column. */
+    enableAdvancedFilters?: boolean;
+    /** Props forwarded to the outer Mantine `Box` that wraps the whole table. */
+    wrapperProps?: BoxProps;
+    /** Whether to memoize the filters and body cells. Defaults to `false` (no memoization). */
+    memo?: boolean | 'filters' | 'cells';
+    /** Whether to only query the visible columns from the backend. Defaults to `false`. */
+    queryOnlyVisibleColumns?: boolean;
+    /** Optimization options for the table. */
+    optimizations?: NextGenDataGridOptimizationProps & Optimizations;
+    /** Body separator for the table. */
+    bodySeparator?: string;
+    /** Body truncate for the table. */
+    bodyTruncate?: number;
+    /** Header customizer for the table. */
+    headerCustomizer?: GridCustomizer;
+    /** Body customizer for the table. */
+    bodyCustomizer?: GridCustomizer;
+    /** Toolbar customizer for the table. */
+    toolbarCustomizer?: NextGenDataGridToolbarProps['custom'];
+    /** Hide add button for the table. */
+    hideAdd?: boolean;
+    /** Hide download button for the table. */
+    hideDownload?: boolean;
+    /** Hide filter button for the table. */
+    hideFilter?: boolean;
+}

package/dist/core/lib/Tables/NextGenDataGrid/utils.d.ts

@@ -1,5 +1,19 @@
-export function fromFilterToFilterFn(columnId: string, operator: string, filterPrefix?: boolean): string;
-export function fromFilterFnToFilter(filterKey?: string): {
+/**
+ * Converts a column ID and operator into a filterFn string.
+ *
+ * @param columnId - The ID of the column.
+ * @param operator - The operator.
+ * @param filterPrefix - Whether to prefix the filterFn with 'filter'.
+ * @returns The generated filterFn string.
+ */
+export declare const fromFilterToFilterFn: (columnId: string, operator: string, filterPrefix?: boolean) => string;
+/**
+ * Converts a filterFn string into an object with column and operator properties.
+ *
+ * @param filterKey - The filterFn string, which may start with 'filter', in the format `{col}*{operator}`.
+ * @returns An object containing the column and operator.
+ */
+export declare const fromFilterFnToFilter: (filterKey?: string) => {
     col: string;
     operator: string;
 };

package/dist/core/lib/Wrappers/ApiProvider/ApiProvider.d.ts

@@ -1,85 +1,17 @@
+import { ComponentType } from 'react';
+import { ApiProviderProps, WithApiProviderOptions } from './types';
 /**
- * @typedef {Object} ApiProviderProps
- * @property {string} [resource_name] - The name of the resource to be used in the API path
- * @property {Record<string, any>} [initialQueryParams] - The initial query parameters to be used in the API requests
- * @property {string} [relation] - The relation to be used in the API requests
- * @property {boolean} [fetchInfo] - Whether to fetch the `info` for the API requests when the component mounts
- * @property {boolean} [clearInfoOnRefetch] - Whether to clear the `info` on refetch
- * @property {boolean} [clearDataOnRefetch] - Whether to clear the `data` on refetch
- * @property {boolean} [refetchInfoBasedOnLang] - Whether to refetch the `info` when the language changes. Defaults to true.
- * @property {boolean} [refetchDataBasedOnLang] - Whether to refetch the `data` when the language changes. Defaults to true.
- * @property {boolean} [resetQueryParamsOnPathChange] - Whether to reset the `queryParams` on path change
- * @property {Record<string, any>} [infoQueryProps] - The react-query props for the info query
- * @property {Record<string, any>} [dataQueryProps] - The react-query props for the data query
- * @property {Record<string, any>} [streamingQueryProps] - The react-query props for the streaming (infinite) query
- * @property {boolean} [streaming] - Whether to enable streaming for the API requests
- * @property {ReactNode} children - The children to be rendered inside the provider
+ * Provides the API context, bulk actions context, and form contexts to its children.
  */
+export declare function ApiProvider(props: ApiProviderProps): import("react/jsx-runtime").JSX.Element;
 /**
- * ApiProvider component that wraps the application and provides the API context, bulk actions context, and form contexts.
- * @param {ApiProviderProps} props
- * @returns {React.ReactNode}
+ * Higher-order component to wrap a component with ApiProvider.
+ *
+ * @param apiProviderProps - The props to be passed to the ApiProvider or a function that returns them.
+ * @param Component - The component to be wrapped.
+ * @param options - Additional options for the HOC.
+ * @returns The wrapped component.
  */
-export function ApiProvider({ resource_name, initialQueryParams, relation, fetchInfo, clearInfoOnRefetch, clearDataOnRefetch, refetchInfoBasedOnLang, refetchDataBasedOnLang, resetQueryParamsOnPathChange, infoQueryProps, dataQueryProps, streamingQueryProps, streaming, children, }: ApiProviderProps): React.ReactNode;
-export function withApiProvider(apiProviderProps: ApiProviderProps | ((props: any) => ApiProviderProps), Component: React.ComponentType, options?: {
+export declare const withApiProvider: <P extends object>(apiProviderProps: ApiProviderProps | ((props: P) => ApiProviderProps), Component: ComponentType<P>, options?: WithApiProviderOptions) => ComponentType<P> & {
     displayName?: string;
-    forwardRef?: boolean;
-}): React.ComponentType;
-export type ApiProviderProps = {
-    /**
-     * - The name of the resource to be used in the API path
-     */
-    resource_name?: string;
-    /**
-     * - The initial query parameters to be used in the API requests
-     */
-    initialQueryParams?: Record<string, any>;
-    /**
-     * - The relation to be used in the API requests
-     */
-    relation?: string;
-    /**
-     * - Whether to fetch the `info` for the API requests when the component mounts
-     */
-    fetchInfo?: boolean;
-    /**
-     * - Whether to clear the `info` on refetch
-     */
-    clearInfoOnRefetch?: boolean;
-    /**
-     * - Whether to clear the `data` on refetch
-     */
-    clearDataOnRefetch?: boolean;
-    /**
-     * - Whether to refetch the `info` when the language changes. Defaults to true.
-     */
-    refetchInfoBasedOnLang?: boolean;
-    /**
-     * - Whether to refetch the `data` when the language changes. Defaults to true.
-     */
-    refetchDataBasedOnLang?: boolean;
-    /**
-     * - Whether to reset the `queryParams` on path change
-     */
-    resetQueryParamsOnPathChange?: boolean;
-    /**
-     * - The react-query props for the info query
-     */
-    infoQueryProps?: Record<string, any>;
-    /**
-     * - The react-query props for the data query
-     */
-    dataQueryProps?: Record<string, any>;
-    /**
-     * - The react-query props for the streaming (infinite) query
-     */
-    streamingQueryProps?: Record<string, any>;
-    /**
-     * - Whether to enable streaming for the API requests
-     */
-    streaming?: boolean;
-    /**
-     * - The children to be rendered inside the provider
-     */
-    children: ReactNode;
 };

package/dist/core/lib/Wrappers/ApiProvider/Contexts/ApiContext.d.ts

@@ -1,5 +1 @@
-export const ApiContextProvider: import('react').ComponentType<{
-    value: any;
-    children: any;
-}>;
-export const useApiProvider: (options?: SafeContextOptions) => any;
+export { ApiContextProvider, useApiProvider } from 'fastapi-rtk/contexts';

package/dist/core/lib/Wrappers/ApiProvider/Contexts/BulkActionsContext.d.ts

@@ -1,5 +1,2 @@
-export const BulkActionsContextProvider: import('react').ComponentType<{
-    value: any;
-    children: any;
-}>;
-export const useBulkActionsProvider: (options?: SafeContextOptions) => any;
+import { BulkActionsContextValue } from '../../../hooks/api/types';
+export declare const BulkActionsContextProvider: import('react').Provider<BulkActionsContextValue | null>, useBulkActionsProvider: (options?: import('fastapi-rtk/utils').SafeContextOptions<BulkActionsContextValue>) => BulkActionsContextValue;

package/dist/core/lib/Wrappers/ApiProvider/Contexts/FormContext.d.ts

@@ -1,20 +1,5 @@
-export const FormContextViewProvider: import('react').ComponentType<{
-    value: any;
-    children: any;
-}>;
-export const useFormViewProvider: (options?: SafeContextOptions) => any;
-export const FormContextAddProvider: import('react').ComponentType<{
-    value: any;
-    children: any;
-}>;
-export const useFormAddProvider: (options?: SafeContextOptions) => any;
-export const FormContextEditProvider: import('react').ComponentType<{
-    value: any;
-    children: any;
-}>;
-export const useFormEditProvider: (options?: SafeContextOptions) => any;
-export const FormContextDeleteProvider: import('react').ComponentType<{
-    value: any;
-    children: any;
-}>;
-export const useFormDeleteProvider: (options?: SafeContextOptions) => any;
+import { FormsContextValue } from '../../../hooks/api/types';
+export declare const FormContextViewProvider: import('react').Provider<FormsContextValue<import('../../../../../.external/lib/mantine-react-table').MRT_RowData> | null>, useFormViewProvider: (options?: import('fastapi-rtk/utils').SafeContextOptions<FormsContextValue<import('../../../../../.external/lib/mantine-react-table').MRT_RowData>>) => FormsContextValue<import('../../../../../.external/lib/mantine-react-table').MRT_RowData>;
+export declare const FormContextAddProvider: import('react').Provider<FormsContextValue<import('../../../../../.external/lib/mantine-react-table').MRT_RowData> | null>, useFormAddProvider: (options?: import('fastapi-rtk/utils').SafeContextOptions<FormsContextValue<import('../../../../../.external/lib/mantine-react-table').MRT_RowData>>) => FormsContextValue<import('../../../../../.external/lib/mantine-react-table').MRT_RowData>;
+export declare const FormContextEditProvider: import('react').Provider<FormsContextValue<import('../../../../../.external/lib/mantine-react-table').MRT_RowData> | null>, useFormEditProvider: (options?: import('fastapi-rtk/utils').SafeContextOptions<FormsContextValue<import('../../../../../.external/lib/mantine-react-table').MRT_RowData>>) => FormsContextValue<import('../../../../../.external/lib/mantine-react-table').MRT_RowData>;
+export declare const FormContextDeleteProvider: import('react').Provider<FormsContextValue<import('../../../../../.external/lib/mantine-react-table').MRT_RowData> | null>, useFormDeleteProvider: (options?: import('fastapi-rtk/utils').SafeContextOptions<FormsContextValue<import('../../../../../.external/lib/mantine-react-table').MRT_RowData>>) => FormsContextValue<import('../../../../../.external/lib/mantine-react-table').MRT_RowData>;