import { JSX, ReactElement } from 'react';
import * as Yup from 'yup';
import { AutocompleteRenderOptionState } from '@mui/material/Autocomplete';
import { GridColDef, GridFilterModel, GridSortModel } from '@mui/x-data-grid';
import { DateView } from '@mui/x-date-pickers';
import { Control, FieldErrors, UseFormGetValues, UseFormSetValue } from 'react-hook-form';
import { SxProps, Theme } from '@mui/material/styles';
import { OnEditModelType } from '../context/APIWrapperContext';
import { ServerEndPoint } from '../context/DRFReactBySchemaContext';
import { AlertColor } from '@mui/material/Alert';
export type Id = string | number | null;
export type IdNotNull = string | number;
export type GenericValue = any;
type TypedFieldKey<T> = Extract<keyof T, string>;
export type FieldKey<T extends TField = void> = T extends void ? string : NoInfer<TypedFieldKey<T>>;
export type TField = Record<string, GenericValue> | void;
export type Item<T extends TField = void> = T extends void ? Record<string, GenericValue> : T;
export type PartialItem<T extends TField = void> = T extends void ? Record<string, GenericValue> : Partial<Record<keyof T, T[Extract<keyof T, string>]> & {
    id?: Id;
}>;
export type AutocompleteItem = {
    id: IdNotNull;
    label: string;
};
export type OptionsACItem = AutocompleteItem | ChoiceItem;
export type FieldOptionsAC = OptionsACItem[];
type BaseOptionsAC = Record<string, FieldOptionsAC>;
type TypedOptionsAC<T extends TField> = Partial<Record<FieldKey<T>, FieldOptionsAC>>;
export type OptionsAC<T extends TField = void> = T extends void ? BaseOptionsAC : TypedOptionsAC<T>;
type BaseOptionsACWithLoaders = Record<string, FieldOptionsAC | (() => Promise<FieldOptionsAC>)>;
type TypedOptionsACWithLoaders<T extends TField> = Partial<Record<FieldKey<T>, FieldOptionsAC | (() => Promise<FieldOptionsAC>)>>;
export type OptionsACWithLoaders<T extends TField = void> = T extends void ? BaseOptionsACWithLoaders : TypedOptionsACWithLoaders<T>;
interface BasePaginatedResult {
    count: number;
    next: number;
    previous: number;
    sum_rows: null | Record<string, number>;
    results: Item[];
}
interface TypedPaginatedResult<T extends TField> {
    count: number;
    next: number;
    previous: number;
    sum_rows: null | Partial<Record<FieldKey<T>, number>>;
    results: T[];
}
export type PaginatedResult<T extends TField = void> = T extends void ? BasePaginatedResult : TypedPaginatedResult<T>;
export interface PaginationModel {
    page: number;
    pageSize: number;
    filter?: GridFilterModel;
    sort?: GridSortModel;
    queryParams?: string[];
}
type BaseSchemaType = Record<string, Field>;
type TypedSchemaType<T extends TField> = Partial<Record<FieldKey<T>, Field>>;
export type SchemaType<T extends TField = void> = T extends void ? BaseSchemaType : TypedSchemaType<T>;
export interface SchemaOptionsType<T extends TField = void> {
    schema: SchemaType<T>;
    verbose_name: string;
    verbose_name_plural: string;
}
export type SchemaOptionsSingleActionType = Omit<SchemaOptionsType, 'actions'> & {
    action: {
        POST: SchemaType;
    };
};
export type ModelOptionsType<T extends TField = void> = Omit<SchemaOptionsType<T>, 'actions' | 'renders' | 'parses'>;
export type SchemaLoader = () => Promise<{
    default: SchemaOptionsType;
}>;
export type SchemasType = Record<string, SchemaOptionsType | SchemaLoader>;
export type ChoiceValue = IdNotNull;
/** Minimal metadata extracted from a model schema. */
export interface ModelMeta {
    verboseName: string;
    verboseNamePlural: string;
}
interface BaseChoiceItem {
    value: ChoiceValue;
    display_name: string;
}
interface TypedChoiceItem<T> {
    value: T;
    display_name: string;
}
export type ChoiceItem<T = void> = T extends void ? BaseChoiceItem : TypedChoiceItem<T>;
type FieldChild = {
    children?: SchemaType;
    choices?: ChoiceItem[];
};
type FieldType = 'string' | 'email' | 'date' | 'datetime' | 'nested object' | 'field' | 'choice' | 'boolean' | 'decimal' | 'float' | 'file' | 'file upload' | 'image' | 'image upload' | 'number' | 'integer' | 'password' | 'array' | 'list' | 'slug' | 'multiple choice' | 'point' | 'polygon' | 'multipoint' | 'multipolygon' | 'geometrycollection';
export type GeometryFieldType = Extract<FieldType, 'point' | 'polygon' | 'multipoint' | 'multipolygon' | 'geometrycollection'>;
/** A tile-layer configuration for the geometry map picker. */
export interface LayerConfig {
    title: string;
    url: string;
    attribution: string;
}
export interface Field {
    type: FieldType;
    label: string;
    child?: FieldChild;
    children?: SchemaType;
    model_default?: GenericValue;
    model_required?: boolean;
    choices?: ChoiceItem[];
    max_length?: number | string;
    max_digits?: number;
    decimal_places?: number;
    read_only?: boolean;
    is_currency?: boolean;
    prefix?: string;
    suffix?: string;
    related_editable?: boolean;
    validators_regex?: Item[];
    many?: boolean;
    date_views?: DateView[];
    required?: boolean;
    ui_required?: boolean;
    disabled?: boolean;
    help_text?: string;
    model_multiline?: boolean;
    max_file_size?: number;
    allowed_mime_types?: string[];
    style?: Record<string, string>;
    pattern_format?: string;
    conditional_visible?: string[] | string[][];
}
export type GridEnrichedBySchemaColDef<T extends TField = void> = Omit<GridColDef<Item<T>>, 'field'> & {
    field: FieldKey<T>;
    isIndexField?: boolean;
    creatable?: boolean;
    disabled?: boolean;
    orderable?: boolean;
    patternFormat?: string;
    uiRequired?: boolean;
};
export type CustomColumnOperations<T extends TField = void> = (p: GridEnrichedBySchemaColDef<T>) => GridEnrichedBySchemaColDef<T> | Promise<GridEnrichedBySchemaColDef<T>>;
type BaseMinWidthFields = Record<string, number>;
type TypedMinWidthFields<T extends TField> = Partial<Record<FieldKey<T>, number>> & {
    actions?: number;
};
export type MinWidthFields<T extends TField = void> = T extends void ? BaseMinWidthFields : TypedMinWidthFields<T>;
type BaseSumRowsTotals = Record<string, number>;
type TypedSumRowsTotals<T extends TField> = Partial<Record<FieldKey<T>, number>>;
export type SumRowsTotals<T extends TField = void> = T extends void ? BaseSumRowsTotals : TypedSumRowsTotals<T>;
export interface DataSchemaColumnsType<T extends TField = void> {
    data: Item<T>[];
    schema: SchemaType<T>;
    modelOptions: ModelOptionsType<T>;
    rowCount?: number;
    sumRowsTotals?: null | SumRowsTotals<T>;
    columns?: GridEnrichedBySchemaColDef<T>[];
}
export interface ItemSchemaColumnsType<T extends TField = void> {
    data: Item<T>;
    schema: SchemaType<T>;
    modelOptions: ModelOptionsType<T>;
    columns?: GridEnrichedBySchemaColDef<T>[];
}
export interface CommonFieldProps<T extends TField = void> {
    value?: GenericValue;
    multiline?: boolean;
    setValue?: UseFormSetValue<Item<T>>;
    getValues?: UseFormGetValues<Item<T>>;
    fieldKey?: FieldKey<T>;
    labelKey?: FieldKey<T>;
    index?: number;
    optionsAC?: OptionsAC<T>;
    optionsModel?: FieldKey<T>;
    getOptionLabel?: (option: Item<T> | string) => string;
    renderOption?: (props: React.HTMLAttributes<HTMLLIElement>, option: Item<T>, state: AutocompleteRenderOptionState) => React.ReactNode;
    onEditModel?: <U extends TField = void>(x: OnEditModelType<U>) => void;
    fieldsLayout?: FormFieldLayout<T>[];
    multiple?: boolean;
    sx?: SxProps<Theme>;
    options?: Item<T>[];
    isSemaphoric?: boolean;
    label?: string;
    onValueChange?: (x: GenericValue) => void;
    decimalScale?: number;
    type?: React.HTMLInputTypeAttribute;
    autoComplete?: string;
    minRows?: number;
    optionIdKey?: string;
    optionLabelKey?: string;
    disabled?: boolean;
}
type BaseFieldsProps = Record<string, CommonFieldProps>;
type TypedFieldsProps<T extends TField> = Partial<Record<FieldKey<T>, CommonFieldProps<T>>>;
export type FieldsProps<T extends TField = void> = T extends void ? BaseFieldsProps : TypedFieldsProps<T>;
type BaseDetailFieldsProps = Record<string, DetailCommonFieldProps>;
type TypedDetailFieldsProps<T extends TField> = Partial<Record<FieldKey<T>, DetailCommonFieldProps<T>>>;
export type DetailFieldsProps<T extends TField = void> = T extends void ? BaseDetailFieldsProps : TypedDetailFieldsProps<T>;
export type FieldBySchemaProps<T extends TField = void> = Omit<CommonFieldProps<T>, 'value' | 'onEditModel'> & {
    onEditModel?: <U extends TField = void>(x: OnEditModelType<U>) => void;
    name: FieldKey<T>;
    schema: SchemaType<T>;
    control: Control<Item<T>, GenericValue, Item<T>>;
    errors: FieldErrors<Item<T>>;
    autoFocus?: boolean;
};
export interface DetailFieldBySchemaProps extends ExtraSxCommonFieldProps {
    fieldKey: FieldKey;
    fieldSchema?: Field;
    value: FormattedItemValue;
    optionIdKey?: string;
    optionLabelKey?: string;
}
type LinkProps = {
    to: string | object;
    href?: string;
    state?: object;
    className?: string;
    style?: React.CSSProperties;
    children?: React.ReactNode;
} & React.AnchorHTMLAttributes<HTMLAnchorElement>;
export type LinkComponentType = React.ComponentType<LinkProps>;
export type FieldList<T extends TField = void> = T extends void ? string[] : Extract<keyof T, string>[];
export type AddParametersToEnd<TFunction extends (...args: GenericValue) => GenericValue, TParameters extends [...args: GenericValue]> = (...args: [...Parameters<TFunction>, ...TParameters]) => ReturnType<TFunction>;
export type ActionType = 'editInline' | 'remove' | 'edit' | 'view';
/**
 * A custom per-row action supplied directly in the `actions` prop, as an object
 * (icon + click handler) instead of one of the built-in string action types.
 * When rendered in the grid's actions column it becomes a single icon button
 * that calls `handleClick(rowItem)` when clicked. Works for any list/grid,
 * regardless of whether row selection (checkboxes) is enabled.
 */
export interface CustomRowAction<T extends TField = void> {
    icon: ReactElement;
    label?: string;
    handleClick: (item: Item<T> | undefined) => void;
}
/** Actions accepted by the grid's actions column: built-in strings or a custom
 * row action object. */
export type RowAction<T extends TField = void> = ActionType | CustomRowAction<T>;
/** Read-only grid actions: navigation 'edit'/'view' or a custom row action (no 'editInline'/'remove'). */
export type NonEditableRowAction<T extends TField = void> = 'edit' | 'view' | CustomRowAction<T>;
export interface CustomAction<T extends TField = void> {
    key: string;
    icon: ReactElement;
    label: string;
    handleClick: (item: Item<T> | undefined) => undefined;
}
export type BulkUpdateData<T extends TField = void> = (newData: Item<T>[]) => Promise<{
    id: Id;
    success: boolean;
}[]>;
export type BulkDeleteData = (ids: Id[]) => Promise<{
    id: Id;
    success: boolean;
}[]>;
export type OnSelectActionCustom<T extends TField = void> = (selectedData: Item<T>[], bulkUpdateData: BulkUpdateData<T>) => void;
export type OnSelectActionTypes = OnSelectActionCustom | 'bulkDelete' | 'bulkCreate';
export type OnSelectActions = {
    title: string;
    action: OnSelectActionTypes;
};
interface BaseCustomFormField {
    key: string;
    CustomElement: (x: CommonFieldProps) => JSX.Element;
}
interface TypedCustomFormField<T extends TField> {
    key: FieldKey<T>;
    CustomElement: (x: CommonFieldProps) => JSX.Element;
}
export type CustomFormField<T extends TField = void> = T extends void ? BaseCustomFormField : TypedCustomFormField<T>;
interface BaseFormFieldLayout {
    title?: string;
    rows?: (string | (string | CustomFormField)[] | CustomFormField)[];
    customLabels?: Record<string, string>;
    CustomElement?: React.ReactNode;
}
interface TypedFormFieldLayout<T extends TField> {
    title?: string;
    rows?: (FieldKey<T> | (FieldKey<T> | CustomFormField<T>)[] | CustomFormField<T>)[];
    customLabels?: Partial<Record<FieldKey<T>, string>>;
    CustomElement?: React.ReactNode;
}
export type FormFieldLayout<T extends TField = void> = T extends void ? BaseFormFieldLayout : TypedFormFieldLayout<T>;
type BaseCustomFormFieldLayouts = Record<string, BaseFormFieldLayout[]>;
type TypedCustomFormFieldLayouts<T extends TField> = Partial<Record<FieldKey<T>, BaseFormFieldLayout[]>>;
export type CustomFormFieldLayouts<T extends TField = void> = T extends void ? BaseCustomFormFieldLayouts : TypedCustomFormFieldLayouts<T>;
export declare enum FormSaveActions {
    EXIT_ON_SAVE = "exitOnSave",
    SAVE_AND_CONTINUE = "saveAndContinue",
    SAVE_AND_CREATE_NEW = "saveAndCreateNew"
}
export interface ExtraSxCommonFieldProps {
    sxSection?: SxProps<Theme>;
    sxSectionTitle?: SxProps<Theme>;
    sxRow?: SxProps<Theme>;
    sxRowMultiple?: SxProps<Theme>;
    sxField?: SxProps<Theme>;
    sxLabel?: SxProps<Theme>;
    sxValue?: SxProps<Theme>;
    sxValueList?: SxProps<Theme>;
    sxValueListItem?: SxProps<Theme>;
    sxValueListItemText?: SxProps<Theme>;
}
export type DetailCommonFieldProps<T extends TField = void> = CommonFieldProps<T> & ExtraSxCommonFieldProps;
interface CustomDetailField<T extends TField = void> {
    key: FieldKey<T>;
    CustomElement: (x: DetailCommonFieldProps) => JSX.Element;
}
export type DetailFieldLayoutRows<T extends TField = void> = (FieldKey<T> | (FieldKey<T> | CustomDetailField<T>)[] | CustomDetailField<T>)[];
export interface DetailFieldLayout<T extends TField = void> extends ExtraSxCommonFieldProps {
    title?: string;
    rows?: DetailFieldLayoutRows<T>;
    CustomElement?: React.ReactNode;
    isAccordion?: boolean;
    isAccordionOpen?: boolean;
}
export interface DetailBySchemaProps<T extends TField = void> extends ExtraSxCommonFieldProps {
    values: Item<T>;
    schema: SchemaType<T>;
    columns: GridEnrichedBySchemaColDef<T>[];
    loading?: boolean;
    editLink?: string;
    editLabel?: string;
    fieldsLayout?: DetailFieldLayout<T>[];
    hiddenFields?: FieldList<T>;
    fieldsProps?: DetailFieldsProps<T>;
    elevation?: number;
}
export type OnSuccessEvent = React.MouseEventHandler<HTMLButtonElement>;
export interface TargetApiParams<T extends TField = void> {
    path: string;
    serverEndPoint: ServerEndPoint | null;
    data: Item<T>;
    id: Id;
    contentType?: 'application/json' | 'multipart/form-data';
}
export type TargetApiParamsLocal<T extends TField = void> = Omit<TargetApiParams<T>, 'serverEndPoint'>;
export type TargetApiPostParams<T extends TField = void> = Omit<TargetApiParams<T>, 'id'>;
export type TargetApiPostParamsLocal<T extends TField = void> = Omit<TargetApiPostParams<T>, 'serverEndPoint'>;
interface BaseSumRowsType {
    rows: SumRowsItem[];
    severity?: AlertColor;
}
interface TypedSumRowsType<T extends TField> {
    rows: SumRowsItem<T>[];
    severity?: AlertColor;
}
export type SumRowsType<T extends TField = void> = T extends void ? BaseSumRowsType : TypedSumRowsType<T>;
interface SumRowsItem<T extends TField = void> {
    field: FieldKey<T>;
    prefix?: string;
    suffix?: string;
    isCount?: boolean;
}
export interface GetGenericModelListProps<T extends TField = void> {
    model: string;
    serverEndPoint: ServerEndPoint | null;
    id?: Id;
    relatedModel?: string;
    relatedModelId?: Id;
    columnFields?: FieldList<T>;
    creatableFields?: FieldList<T>;
    disabledFields?: FieldList<T>;
    isInBatches?: boolean;
    loadedSchema?: SchemaType<T>;
    loadedModelOptions?: ModelOptionsType<T>;
    page?: number;
    filter?: GridFilterModel;
    queryParams?: string[];
    sort?: GridSortModel;
    sumRows?: SumRowsType<T>;
    schemas?: SchemasType;
}
export type GetGenericModelListPropsLocal<T extends TField = void> = Omit<GetGenericModelListProps<T>, 'serverEndPoint'>;
export type GetGenericModelProps = {
    model: string;
    serverEndPoint: ServerEndPoint | null;
    id?: Id;
    relatedModel?: string;
    relatedModelId?: string;
    schemas?: SchemasType;
};
export type GetGenericModelPropsLocal = Omit<GetGenericModelProps, 'serverEndPoint'>;
export type FormattedItemValue = {
    title: string;
    valueStr: string;
    value: GenericValue;
};
export type FormattedItem = Record<string, FormattedItemValue>;
export type formattedData = {
    item: FormattedItem;
    id: Id;
}[];
export interface MobileListRenderItemInfo {
    item: FormattedItem;
    index: number;
    id: Id;
}
export type MobileListRenderItemType = (info: MobileListRenderItemInfo) => ReactElement | null;
export type GenericYupValidator = Yup.StringSchema | Yup.NumberSchema | Yup.AnyObjectSchema | Yup.MixedSchema<GenericValue | null | undefined, Yup.AnyObject, undefined, ''> | Yup.DateSchema | Yup.BooleanSchema | Yup.ArraySchema<any, any, any, any>;
type BaseExtraValidators = Record<string, GenericYupValidator>;
type TypedExtraValidators<T extends TField> = Partial<Record<FieldKey<T>, GenericYupValidator>>;
export type ExtraValidators<T extends TField = void> = T extends void ? BaseExtraValidators : TypedExtraValidators<T>;
export type ConditionalVisible = {
    target: string;
    source: string;
    sourceValue: GenericValue;
};
export type { OnEditModelType };
export interface UpdateDataBySchema<T extends TField = void> {
    model: string;
    modelObjectId: Id;
    data: Item<T>;
    schema: SchemaType<T>;
    path?: string | null;
}
export type FormWatchObject<T extends TField = void> = T extends void ? Item : Partial<T>;
export interface WatchEditingRowValuesProps<T extends TField = void> {
    rowEditingValues?: Partial<Item<T>>;
    setRowEditingValues: (p: Partial<Item<T>>) => void;
}
export type WatchEditingRowValues<T extends TField = void> = (p: WatchEditingRowValuesProps<T>) => void | Promise<void>;
//# sourceMappingURL=index.d.ts.map