dinocollab-core 2.2.13 → 2.2.15

package/dist/types/filter-bar/menu/create-form-field-datetime.d.ts

@@ -0,0 +1,53 @@
+import type { FC } from 'react';
+import type { TDateLogic } from '../types';
+import type { IFieldMenuConfig, IFilterMenuFormProps } from './types';
+/** Date logic options available in `single` mode. */
+export type TDateSingleLogic = Exclude<TDateLogic, 'range'>;
+/** The MUI picker variant to render inside the filter menu. */
+export type TDateTimePickerType = 'date' | 'datetime' | 'time';
+/**
+ * Selection mode for the DateTime filter.
+ * - `'single'` — one value per Apply; values accumulate with OR / AND logic.
+ * - `'range'` — two pickers (From / To); always stores exactly `[fromISO, toISO]`.
+ */
+export type TDateTimeMode = 'single' | 'range';
+/** Props for the `FormFieldDateTime` component returned by `createFormFieldDateTime`. Extends the base filter-menu form props. */
+export interface IFormFieldDateTimeProps<T> extends IFilterMenuFormProps<T> {
+}
+/** Parameters passed to `createFormFieldDateTime` to configure the generated component. */
+export interface IFormFieldDateTimeParam<T> {
+    /** Optional field-level configuration overrides. */
+    config?: IFieldMenuConfig<T>;
+    /**
+     * Controls which MUI picker is rendered.
+     * - `'date'` → `DatePicker` (default)
+     * - `'datetime'` → `DateTimePicker`
+     * - `'time'` → `TimePicker`
+     * @default 'datetime'
+     */
+    pickerType?: TDateTimePickerType;
+    /**
+     * Controls the selection mode.
+     * - `'single'` (default) — one value per Apply click; multiple values accumulate with OR / AND logic.
+     * - `'range'` — two pickers (From / To); always stores exactly `[fromISO, toISO]`.
+     * @default 'single'
+     */
+    mode?: TDateTimeMode;
+}
+/**
+ * Factory function that creates a `FormFieldDateTime` filter-menu component.
+ *
+ * The generated component renders a date / time picker inside a popper/menu panel.
+ * It supports two selection modes:
+ * - **single** (default) — user picks one value per submission; values accumulate
+ *   and an OR / AND logic toggle appears when more than one value is active.
+ * - **range** — two pickers rendered (From / To); always stores exactly
+ *   `[fromISO, toISO]`, replacing any previous range on each Apply.
+ *
+ * All stored values are ISO 8601 strings (`TFieldValid = string`).
+ *
+ * @param params - Static configuration (picker type, mode, optional field config override)
+ * @returns A React FC ready to be used as a date/time filter-menu field component
+ */
+declare function createFormFieldDateTime<T>(params?: IFormFieldDateTimeParam<T>): FC<IFormFieldDateTimeProps<T>>;
+export default createFormFieldDateTime;

package/dist/types/filter-bar/menu/create-form-field-select-multiple.d.ts

@@ -1,13 +1,30 @@
 import type { FC } from 'react';
 import type { IFieldSelectOption } from './create-form-field-select';
 import type { IFieldMenuConfig, IFilterMenuFormProps } from './types';
+/** Props for the `FormFieldSelectMultiple` component returned by `createFormFieldSelectMultiple`. Extends the base filter-menu form props. */
 export interface IFormFieldSelectMultipleProps<T> extends IFilterMenuFormProps<T> {
 }
+/** Parameters passed to `createFormFieldSelectMultiple` to configure the generated component. */
 export interface IFormFieldSelectMultipleParam<T> {
     /** Optional configuration for the form field */
     config?: IFieldMenuConfig<T>;
     /** List of options for the select field */
     options: IFieldSelectOption[];
 }
+/**
+ * Factory function that creates a `FormFieldSelectMultiple` filter-menu component.
+ *
+ * The generated component renders a checkbox list of options inside a
+ * popper/menu panel, allowing the user to select **multiple values** at once.
+ * It supports:
+ * - Controlled checkbox state to prevent uncontrolled→controlled React warnings
+ * - OR / AND logic toggle when more than one value is applied
+ * - Chip viewers showing the currently applied values
+ * - Built-in validation via an optional `validator` prop
+ * - A loading overlay that disables interaction while `isLoading` is true
+ *
+ * @param params - Static configuration (option list, optional field config override)
+ * @returns A React FC ready to be used as a multi-select filter-menu field component
+ */
 declare function createFormFieldSelectMultiple<T>(params?: IFormFieldSelectMultipleParam<T>): FC<IFormFieldSelectMultipleProps<T>>;
 export default createFormFieldSelectMultiple;

package/dist/types/filter-bar/menu/create-form-field-select.d.ts

@@ -1,17 +1,34 @@
 import { FC } from 'react';
 import type { IFieldMenuConfig, IFilterMenuFormProps } from './types';
 import type { TFieldValid } from '../types';
+/** Props for the `FormFieldSelect` component returned by `createFormFieldSelect`. Extends the base filter-menu form props. */
 export interface IFormFieldSelectProps<T> extends IFilterMenuFormProps<T> {
 }
+/** A single option item rendered as a radio button inside the select filter menu. */
 export interface IFieldSelectOption {
     value: TFieldValid;
     label?: string;
 }
+/** Parameters passed to `createFormFieldSelect` to configure the generated component. */
 export interface IFormFieldSelectParams<T> {
     /** Optional configuration for the form field */
     config?: IFieldMenuConfig<T>;
     /** List of options for the select field */
     options: IFieldSelectOption[];
 }
+/**
+ * Factory function that creates a `FormFieldSelect` filter-menu component.
+ *
+ * The generated component renders a radio-button list of options inside a
+ * popper/menu panel. It supports:
+ * - Single or multi-value selection (controlled by `config.singleValue`)
+ * - OR / AND logic toggle when more than one value is selected
+ * - Chip viewers showing the currently applied values
+ * - Built-in validation via an optional `validator` prop
+ * - A loading overlay that disables interaction while `isLoading` is true
+ *
+ * @param params - Static configuration (option list, optional field config override)
+ * @returns A React FC ready to be used as a filter-menu field component
+ */
 declare function createFormFieldSelect<T>(params: IFormFieldSelectParams<T>): FC<IFormFieldSelectProps<T>>;
 export default createFormFieldSelect;

package/dist/types/filter-bar/menu/create-form-field-string.d.ts

@@ -1,10 +1,26 @@
 import type { FC } from 'react';
 import type { IFieldMenuConfig, IFilterMenuFormProps } from './types';
+/** Props for the `FormFieldString` component returned by `createFormFieldString`. Extends the base filter-menu form props. */
 export interface IFormFieldStringProps<T> extends IFilterMenuFormProps<T> {
 }
+/** Parameters passed to `createFormFieldString` to configure the generated component. */
 export interface IFormFieldStringParam<T> {
     /** Optional configuration for the form field */
     config?: IFieldMenuConfig<T>;
 }
+/**
+ * Factory function that creates a `FormFieldString` filter-menu component.
+ *
+ * The generated component renders a free-text input inside a popper/menu panel,
+ * letting the user type arbitrary string values as filter criteria. It supports:
+ * - OR / AND logic toggle when more than one value is applied
+ * - Chip viewers showing the currently applied values
+ * - Auto-focus and input reset after each successful submission
+ * - Built-in validation via an optional `validator` prop
+ * - A loading overlay that disables interaction while `isLoading` is true
+ *
+ * @param params - Static configuration (optional field config override)
+ * @returns A React FC ready to be used as a free-text filter-menu field component
+ */
 declare function createFormFieldString<T>(params?: IFormFieldStringParam<T>): FC<IFormFieldStringProps<T>>;
 export default createFormFieldString;

package/dist/types/filter-bar/menu/create.d.ts

@@ -1,7 +1,24 @@
 import type { FC } from 'react';
 import type { IFilterMenuProps } from './types';
 import type { IFilterMenuConfig } from './types';
+/**
+ * Factory function that creates a `FilterMenu` component from a static field configuration.
+ *
+ * The generated component renders a badge icon button that opens a popper panel with:
+ * - A **field list** view — lists all configured filter fields with applied-value counts
+ * - A **field form** view — renders the appropriate input component for the selected field
+ * - A **quick-search** field (opt-out via `enableQuickSearch: false`)
+ * - OR / AND logic toggle support per field
+ * - "Clear All" action to reset all active filters at once
+ *
+ * All state (open/close, selected field) is local; filter values are read/written through
+ * `FilterBarContext` via `useFilterActions`.
+ *
+ * @param config - Static filter-menu configuration (fields, validation, slots, etc.)
+ * @returns A React FC ready to be dropped anywhere inside a `FilterBarProvider`
+ */
 export declare function createFilterMenu<T>(config: IFilterMenuConfig<T>): FC<IFilterMenuProps<T>>;
+/** CSS class names used by the `FilterMenu` component for external style overrides. */
 export declare const filterMenuClasses: {
     root: string;
     input: string;

package/dist/types/filter-bar/menu/types.d.ts

@@ -1,11 +1,16 @@
 import type { ComponentType } from 'react';
 import type { BoxProps, PopperProps } from '@mui/material';
 import type { FormValidator, IFormValidatorConfig } from '../../form/validator';
-import type { TFieldModelValid, TFieldType, TFieldValid, TFieldValue } from '../types';
+import type { TFieldModelValid, TFieldType, TFieldValid, TFieldValue, TLogic } from '../types';
 export interface IFieldMenuConfig<T> {
     field: TFieldType<T>;
     label?: string;
+    /** If true, the form will only allow a single value to be added for the field */
     singleValue?: boolean;
+    /** Default logic for combining multiple values for the field */
+    defaultLogic?: TLogic;
+    /** Tooltip for the field */
+    tooltip?: string | ((values?: TFieldValid[]) => string);
     /** Default form component for the field is `String` */
     FormComponent?: ComponentType<IFilterMenuFormProps<T>>;
 }

package/dist/types/filter-bar/types.d.ts

@@ -59,6 +59,7 @@ export type TFieldSort<T> = {
  * @vi Dinh nghia cac kieu co ban cho he thong filter bar, bao gom gia tri filter, kieu field va cau truc tong the cua filter state.
  */
 export type TLogic = 'and' | 'or';
+export type TDateLogic = 'before' | 'after' | 'on' | 'range';
 /**
  * @en
  * - Structure for storing filter values and their logical relationship (AND/OR) for each field.
@@ -68,6 +69,8 @@ export type TLogic = 'and' | 'or';
 export type TFieldValue = {
     /** Logical operator for combining values within this field. Default is 'and'. */
     logic?: TLogic;
+    /** Logical operator for date-specific filtering. Optional. */
+    dateLogic?: TDateLogic;
     values: TFieldValid[];
 };
 /**

package/dist/types/form/create.date-expired.d.ts

@@ -1,16 +1,21 @@
 import React from 'react';
-import { TextFieldProps, SwitchProps } from '@mui/material';
+import { TextFieldProps, SwitchProps, BoxProps } from '@mui/material';
 import { IFormInputBase } from './types';
 interface ISlots<T> {
+    rootProps?: BoxProps;
+    switchProps?: SwitchProps;
+    textFieldProps?: Partial<TextFieldProps>;
+}
+interface IDateExpiredConfig<T> extends ISlots<T> {
+    defaultValue?: any;
     /** @default string */
-    type?: 'number' | 'string';
+    inputType?: 'number' | 'string';
     textFieldProps?: Partial<TextFieldProps>;
-    switchProps?: SwitchProps;
     switchChecked?: boolean;
     switchCheckedGetter?: (value: any, model?: Partial<T>) => boolean;
 }
-interface IProps<T> extends IFormInputBase<T> {
+interface IProps<T> extends IFormInputBase<T>, IDateExpiredConfig<T> {
     slots?: ISlots<T>;
 }
-declare function CreateDateExpired<T>(params?: ISlots<T>): React.ComponentType<IProps<T>>;
+declare function CreateDateExpired<T>(param?: IDateExpiredConfig<T>): React.ComponentType<IProps<T>>;
 export default CreateDateExpired;

package/dist/types/form/create.form-base.d.ts

@@ -15,6 +15,7 @@ export interface IFormBaseConfigs<T> {
 export interface IFormBaseParams<T> extends IFormBaseConfigs<T> {
 }
 export interface IFormBaseProps<T> extends PropsWithChildren, IFormBaseConfigs<T> {
+    className?: string;
     onSubmit: (data: Partial<T>, e: React.FormEvent<HTMLFormElement>) => Promise<void>;
     onError?: (error: IPartialError<T>) => void;
     slots?: IFormBaseSlots;

package/dist/types/form/create.form-grid-layout.d.ts

@@ -9,13 +9,13 @@ export interface IFormGridLayoutConfig<T> {
     placeholder?: string;
     sizes?: RegularBreakpoints;
     defaultValue?: any;
+    className?: string;
     inputElement?: ComponentType<IFormInputBase<T>>;
 }
 export type IPreSubmitEvent<T> = (value: Partial<T>, oldValue?: T) => Partial<T>;
 export interface IFormGridLayoutMergedConfigs<T> {
-    hiddenFields?: Partial<Record<keyof T, boolean>>;
-    getHiddenFields?: (state: Partial<T>, model?: Partial<T>) => Partial<Record<keyof T, boolean>>;
-    disabledFields?: Partial<Record<keyof T, boolean>>;
+    hiddenFields?: Partial<Record<keyof T, boolean>> | ((state: Partial<T>, model?: Partial<T>) => Partial<Record<keyof T, boolean>>);
+    disabledFields?: Partial<Record<keyof T, boolean>> | ((state: Partial<T>, model?: Partial<T>) => Partial<Record<keyof T, boolean>>);
 }
 export interface IFormGridLayoutSlots<T> extends IFormGridLayoutMergedConfigs<T> {
     action?: ComponentType<IFormBase<T>>;
@@ -26,13 +26,14 @@ export interface IFormGridLayoutSlots<T> extends IFormGridLayoutMergedConfigs<T>
         Success?: boolean;
         Fail?: boolean;
     };
-    contentProps?: BoxProps;
+    rootProps?: BoxProps;
     preSubmit?: IPreSubmitEvent<T>;
     formSlots?: IFormBaseSlots;
 }
 export interface IFormGridLayoutParams<T> extends IFormGridLayoutSlots<T> {
     configs: IFormGridLayoutConfig<T>[];
     validate: FormValidator<Partial<T>>;
+    autoHeight?: boolean;
 }
 export interface IFormGridLayoutProps<T> {
     data?: T;
@@ -42,6 +43,7 @@ export interface IFormGridLayoutProps<T> {
     onClose?: () => void;
     sx?: SxProps<Theme>;
     slots?: IFormGridLayoutSlots<T>;
+    autoHeight?: boolean;
 }
 export interface IFormGridLayoutState {
     loadding?: boolean;

package/dist/types/form/create.form-grid-layout.units.d.ts

@@ -1,12 +1,18 @@
-import React, { ReactNode } from 'react';
+import { FC, ReactNode } from 'react';
 import { IFormBase } from './types';
-export declare const ContentWrap: import("@emotion/styled").StyledComponent<import("@mui/system").BoxOwnProps<import("@mui/material").Theme> & Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
-    ref?: ((instance: HTMLDivElement | null) => void) | React.RefObject<HTMLDivElement> | null | undefined;
+export declare const formGridLayoutClasses: {
+    root: string;
+    form: string;
+    bottomBar: string;
+    autoHeight: string;
+};
+export declare const FormGridLayoutStyled: import("@emotion/styled").StyledComponent<import("@mui/system").BoxOwnProps<import("@mui/material").Theme> & Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
 }, keyof import("@mui/system").BoxOwnProps<import("@mui/material").Theme>> & import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme>, {}, {}>;
 export interface IFormBottomBarProps<T> extends IFormBase<T> {
     before?: ReactNode;
 }
-export declare function CreateFormBottomBar<T>(): React.FC<IFormBottomBarProps<T>>;
-export declare const FormBottomBarWrap: import("@emotion/styled").StyledComponent<import("@mui/system").BoxOwnProps<import("@mui/material").Theme> & Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
-    ref?: ((instance: HTMLDivElement | null) => void) | React.RefObject<HTMLDivElement> | null | undefined;
+export declare function CreateFormBottomBar<T>(): FC<IFormBottomBarProps<T>>;
+export declare const FormBottomBarWrap: import("@emotion/styled").StyledComponent<import("@mui/system").BoxOwnProps<import("@mui/material").Theme> & Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
 }, keyof import("@mui/system").BoxOwnProps<import("@mui/material").Theme>> & import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme>, {}, {}>;

package/dist/types/form/create.select-simple.d.ts

@@ -1,6 +1,6 @@
 import type { ComponentType } from 'react';
 import type { SelectProps } from '@mui/material';
-import { IFormInputBase } from './types';
+import type { IFormInputBase } from '../form/types';
 import type { IRichTooltipPanelConfig } from '../components/rich-tooltip';
 export interface ISelectSimpleOption<T extends string = string> {
     name: string;
@@ -11,10 +11,12 @@ export interface ISelectSimpleSlots {
 }
 export interface ISelectSimpleProps<T> extends Partial<IFormInputBase<T>> {
     options?: ISelectSimpleOption[];
+    value?: any;
     onChange?: (value: ISelectSimpleOption) => void;
     slots?: ISelectSimpleSlots;
     fullWidth?: boolean;
     tooltip?: IRichTooltipPanelConfig;
+    endAdornment?: React.ReactNode;
 }
 export interface ISelectSimpleState {
     value?: string;
@@ -22,6 +24,14 @@ export interface ISelectSimpleState {
 export interface ISelectSimpleParams extends ISelectSimpleSlots {
     options?: ISelectSimpleOption[];
     tooltip?: IRichTooltipPanelConfig;
+    endAdornment?: React.ReactNode;
 }
-declare function CreateSelectSimple<T>(args?: ISelectSimpleParams): ComponentType<ISelectSimpleProps<T>>;
-export default CreateSelectSimple;
+declare function createSelectSimple<T>(args?: ISelectSimpleParams): ComponentType<ISelectSimpleProps<T>>;
+export default createSelectSimple;
+export declare const selectSimpleClasses: {
+    root: string;
+    tooltipWrap: string;
+    small: string;
+    tooltip: string;
+    endAdornment: string;
+};

package/dist/types/form/create.select-with-api.d.ts

@@ -1,6 +1,6 @@
-import type { ComponentType } from 'react';
-import type { TextFieldProps, AutocompleteRenderOptionState } from '@mui/material';
+/// <reference types="react" />
 import { IFormInputBase } from './types';
+import type { FilterOptionsState, TextFieldProps, AutocompleteRenderOptionState } from '@mui/material';
 import type { IRichTooltipPanelConfig } from '../components/rich-tooltip';
 export interface ISelectWithApiOption<TOther = any> {
     Id: string;
@@ -30,5 +30,57 @@ export interface ISelectWithApiParams<O extends ISelectWithApiOption> {
     tooltip?: IRichTooltipPanelConfig;
     renderOption?: (props: React.HTMLAttributes<HTMLElement>, option: O, state: AutocompleteRenderOptionState) => React.ReactNode;
 }
-declare const CreateSelectWithApi: <T, O extends ISelectWithApiOption<any> = ISelectWithApiOption<any>>(params?: ISelectWithApiParams<O> | undefined) => ComponentType<ISelectWithApiProps<T, O>>;
-export default CreateSelectWithApi;
+export interface ISelectWithApiHandle {
+    clear: () => void;
+}
+declare function createSelectWithApi<T, O extends ISelectWithApiOption = ISelectWithApiOption>(params?: ISelectWithApiParams<O>): {
+    new (props: ISelectWithApiProps<T, O>): {
+        abortController: {
+            signalController: AbortController;
+        };
+        refInput: HTMLInputElement | null;
+        existedIds: string[];
+        componentDidMount(): void;
+        componentWillUnmount(): void;
+        componentDidUpdate(prevProps: Readonly<ISelectWithApiProps<T, O>>): void;
+        render(): import("react/jsx-runtime").JSX.Element;
+        renderTooltip: () => import("react/jsx-runtime").JSX.Element | null;
+        getRootClasses: () => string;
+        getFetchDataFunc: () => ISelectWithApiFetchData<O>;
+        getWrappedRenderOption: () => ((props: any, option: O, state: AutocompleteRenderOptionState) => import("react/jsx-runtime").JSX.Element) | undefined;
+        timer: {
+            _timer: number;
+            _second: number;
+            callback: (value: string) => Promise<void>;
+            start: (text: string) => void;
+            clear: () => void;
+        };
+        fetchData: () => Promise<void>;
+        handleChange: (_: React.SyntheticEvent, value: O | null) => void;
+        handleInputChange: (_: React.SyntheticEvent, value: string) => void;
+        fillterOptions: (options: O[], state: FilterOptionsState<O>) => O[];
+        getLabel: () => string | number | boolean | import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | undefined;
+        getDefaultValue: () => any;
+        getOptionsFilter<O_1 extends ISelectWithApiOption<any> = ISelectWithApiOption<any>>(options: O_1[], existedId?: string[]): O_1[];
+        clear: () => void;
+        context: unknown;
+        setState<K extends keyof ISelectWithApiState<O>>(state: ISelectWithApiState<O> | ((prevState: Readonly<ISelectWithApiState<O>>, props: Readonly<ISelectWithApiProps<T, O>>) => ISelectWithApiState<O> | Pick<ISelectWithApiState<O>, K> | null) | Pick<ISelectWithApiState<O>, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<ISelectWithApiProps<T, O>>;
+        state: Readonly<ISelectWithApiState<O>>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<ISelectWithApiProps<T, O>>, nextState: Readonly<ISelectWithApiState<O>>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<ISelectWithApiProps<T, O>>, prevState: Readonly<ISelectWithApiState<O>>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<ISelectWithApiProps<T, O>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ISelectWithApiProps<T, O>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<ISelectWithApiProps<T, O>>, nextState: Readonly<ISelectWithApiState<O>>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<ISelectWithApiProps<T, O>>, nextState: Readonly<ISelectWithApiState<O>>, nextContext: any): void;
+    };
+    contextType?: import("react").Context<any> | undefined;
+};
+export default createSelectWithApi;

package/dist/types/form/dino-form.d.ts

@@ -5,7 +5,8 @@ import CreateInputFile from './create.input.file';
 import CreateTextEditor from './create.text-editor';
 import createColorPicker from './create.color-picker';
 import CreateDateExpired from './create.date-expired';
-import CreateSelectSimple from './create.select-simple';
+import createSelectSimple from './create.select-simple';
+import createSelectWithApi from './create.select-with-api';
 import createInputImageFile from './create.input.image-file';
 import CreateAutocompleteChip from './create.autocomplete.chips';
 declare class DinoFormBase {
@@ -28,8 +29,8 @@ declare class DinoFormBase {
     createInputFile: typeof CreateInputFile;
     createInputImageFile: typeof createInputImageFile;
     createInput: <T>(params?: import("./create.input").IInputParams<T> | undefined) => import("react").ComponentType<import("./create.input").IInputProps<T>>;
-    createSelectSimple: typeof CreateSelectSimple;
-    createSelectWithApi: <T, O extends import("./create.select-with-api").ISelectWithApiOption<any> = import("./create.select-with-api").ISelectWithApiOption<any>>(params?: import("./create.select-with-api").ISelectWithApiParams<O> | undefined) => import("react").ComponentType<import("./create.select-with-api").ISelectWithApiProps<T, O>>;
+    createSelectSimple: typeof createSelectSimple;
+    createSelectWithApi: typeof createSelectWithApi;
     createTextEditor: typeof CreateTextEditor;
 }
 declare const DinoForm: DinoFormBase;

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

@@ -3,8 +3,9 @@ export { default as FormValidator } from './validator';
 export * from './validator';
 export { default as DinoForm } from './dino-form';
 export { getErrorMessage, convertFormDataToJson, validateCsvModel } from './helpers';
-export type { ISelectWithApiOption, ISelectWithApiFetchData, ISelectWithApiParams } from './create.select-with-api';
+export type { ISelectWithApiOption, ISelectWithApiFetchData, ISelectWithApiParams, ISelectWithApiHandle } from './create.select-with-api';
 export type { InputBaseImage } from './create.input';
 export type { ISelectSimpleOption } from './create.select-simple';
 export * from './decorator';
 export * from './decorator.form';
+export { formGridLayoutClasses } from './create.form-grid-layout.units';

package/dist/types/table/helpers.d.ts

@@ -1,9 +1,6 @@
 import { GridFilterModel, GridSortModel } from '@mui/x-data-grid';
 import { GridInitialStateCommunity } from '@mui/x-data-grid/models/gridStateCommunity';
 import { ICustomGridSortModel, ITableQueryParams, ITableQueryDetail } from './types';
-export declare const dinoTableClasses: {
-    whiteSpacePre: string;
-};
 export interface ITableQueryParamModel {
     table?: string;
 }

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

@@ -3,6 +3,6 @@ export * from './model-filter';
 export * from './create.action-row';
 export * from './create.table';
 export { default as DinoTable } from './dino';
-export { dinoTableClasses } from './helpers';
+export { dinoTableClasses } from './styled';
 export type { IStatusCellConfig } from './ui.units';
 export type { IExportCsvOptionsModel } from './csv-export-helper';

package/dist/types/table/styled.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+export declare const dinoTableClasses: {
+    root: string;
+    whiteSpacePre: string;
+};
+export declare const TableStyled: import("@emotion/styled").StyledComponent<import("@mui/system").BoxOwnProps<import("@mui/material").Theme> & import("@mui/material/OverridableComponent").CommonProps & Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, keyof import("@mui/material/OverridableComponent").CommonProps | keyof import("@mui/system").BoxOwnProps<import("@mui/material").Theme>> & import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme>, {}, {}>;

package/dist/types/table/toolbar-pannel.d.ts

@@ -25,6 +25,11 @@ export interface IToolbarPannelProps {
     exportCsvOptions?: IExportCsvOptionsModel;
 }
 declare class ToolbarPannel extends Component<React.PropsWithChildren<IToolbarPannelProps>> {
+    private _popperObserver;
+    private _elementObserver;
+    private _observedPopper;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
     render(): import("react/jsx-runtime").JSX.Element;
     renderTitle: () => import("react/jsx-runtime").JSX.Element;
     renderEndAdornment: () => import("react/jsx-runtime").JSX.Element;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dinocollab-core",
-  "version": "2.2.13",
+  "version": "2.2.15",
   "description": "Dinocollab core - libraries for building collaborative applications with React 18",
   "main": "dist/index.js",
   "module": "dist/index.js",