@antscorp/antsomi-ui 1.3.4 → 1.3.5-alpha.2

package/es/types/components/organism/DataTable/hooks/useDataTableListing/useDataTableListing.d.ts

@@ -0,0 +1,62 @@
+import React from 'react';
+import { useGetColumnMetrics, useGetFilterMetricList, useGetModifyColumnList, useGetSavedFilterList, useGetSearchListing, useGetTableListing } from '@antscorp/antsomi-ui/es/queries';
+import { UseDataTableListingProps } from './types';
+import { FilterItem, FilterProps, TColumnActionButton, TGridViewActionButton, TSearchActionButton, TableProps, TGridViewKeys, TGroupByActionButton } from '../../types';
+import { PaginationProps } from '../../components';
+import { SorterResult } from 'antd/es/table/interface';
+interface TUseDataTableListing<TTableType = any> {
+    modifyColumn: TColumnActionButton;
+    filter: FilterProps;
+    pagination: PaginationProps;
+    table: TableProps<TTableType>;
+    search: TSearchActionButton;
+    gridView: TGridViewActionButton;
+    groupBy: TGroupByActionButton;
+    /**
+     * This selectedRowKeys is deprecated. Use selectedRow.keys instead.
+     * @deprecated
+     */
+    selectedRowKeys: React.Key[];
+    selectedRow: {
+        keys: React.Key[];
+        rows: TTableType[];
+    };
+    queries: {
+        getTableListing: ReturnType<typeof useGetTableListing>;
+        getModifyColumnList: ReturnType<typeof useGetModifyColumnList>;
+        getSavedFilterList: ReturnType<typeof useGetSavedFilterList>;
+        getColumnMetrics: ReturnType<typeof useGetColumnMetrics>;
+        getFilterMetricList: ReturnType<typeof useGetFilterMetricList>;
+        getSearchListing: ReturnType<typeof useGetSearchListing>;
+    };
+    /**
+     * Function to refetch table listing
+     * @returns void
+     */
+    refetchTableListing: () => void;
+    onChangeSelectedRow: (selectedRowKeys: React.Key[], selectedRows?: TTableType[]) => void;
+    setDatTableListingState: React.Dispatch<React.SetStateAction<TState<TTableType>>>;
+}
+type TState<TTableType = any> = {
+    filters?: FilterItem[];
+    selectedFilterId?: string | number;
+    pagination: PaginationProps;
+    table: TableProps<TTableType>;
+    groupBy: {
+        selectedKey?: string;
+        expandedKeys?: Record<any, boolean>;
+    };
+    selectedRowKeys: React.Key[];
+    selectedRow: {
+        keys: React.Key[];
+        rows: TTableType[];
+    };
+    searchValue?: string;
+    sorter?: SorterResult<TTableType>;
+    selectedFilterItem?: FilterItem;
+    expandedRowKeys?: React.Key[];
+    /** Mode view of data table listing */
+    modeView?: TGridViewKeys;
+};
+export declare function useDataTableListing<TTableType = Record<string, any>, TSearchType = any>(props: UseDataTableListingProps<TTableType, TSearchType>): TUseDataTableListing<TTableType>;
+export {};

package/es/types/components/organism/DataTable/hooks/useDataTableStore.d.ts

@@ -0,0 +1,28 @@
+import { StoreApi } from 'zustand';
+import { DataTableProps, DataTableStore } from '../types';
+/**
+ * Custom React hook to create and manage a data table store.
+ *
+ * This hook initializes a data table store using the provided properties.
+ * It uses a `useRef` to ensure the store is only created once and retains
+ * its reference across re-renders.
+ *
+ * @template TTableDataType - The type of data the table will manage.
+ *
+ * @param {DataTableProps<TTableDataType>} [props] - Optional properties to initialize the data table store.
+ *
+ * @returns {StoreApi<DataTableStore> | null} - Returns the data table store instance if successfully created, otherwise returns null.
+ *
+ * @example
+ * // Example usage within a component
+ * function MyComponent() {
+ *   const dataTableStore = useDataTableStore<MyDataType>({ /* props *\/ });
+ *
+ *   if (!dataTableStore) {
+ *     return <div>Loading...</div>;
+ *   }
+ *
+ *   // Use dataTableStore for further operations
+ * }
+ */
+export declare function useDataTableStore<TTableDataType>(props?: DataTableProps<TTableDataType>): StoreApi<DataTableStore>;

package/es/types/components/organism/DataTable/index.d.ts

@@ -0,0 +1,4 @@
+export { DataTable } from './DataTable';
+export type { DataTableProps, TableProps as DataTableTable, SavedFilter, SavedFilterItem, FilterMetricItem as FilterMetic, TSearchItem, FilterItem, FilterProps, } from './types';
+export { useDataTableListing } from './hooks';
+export { CDP_DATA_TABLE_SAMPLE, METRICS as FILTER_METRICS } from './constants';

package/es/types/components/organism/DataTable/providers/AntdTableConfigProvider.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { ConfigProviderProps } from 'antd';
+interface AntdConfigProviderV2Props extends ConfigProviderProps {
+}
+export declare const AntdTableConfigProvider: React.FC<AntdConfigProviderV2Props>;
+export declare const dataTableGlobalToken: (Partial<import("antd/es/theme/internal").AliasToken> & Partial<import("../types").TDataTableToken>) | undefined;
+export {};

package/es/types/components/organism/DataTable/providers/DataTableProvider.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { StoreApi } from 'zustand';
+import { DataTableStore } from '../types';
+interface DataTableProviderProps {
+    store: StoreApi<DataTableStore>;
+}
+export declare const DataTableProvider: React.FC<React.PropsWithChildren<DataTableProviderProps>>;
+export {};

package/es/types/components/organism/DataTable/providers/index.d.ts

@@ -0,0 +1 @@
+export * from './AntdTableConfigProvider';

package/es/types/components/organism/DataTable/stores/index.d.ts

@@ -0,0 +1,2 @@
+import { DataTableState, DataTableStore } from '../types';
+export declare const createDataTableStore: (initProps?: Partial<DataTableState<any>>) => import("zustand").StoreApi<DataTableStore<any>>;

package/es/types/components/organism/DataTable/styled/index.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+export declare const DataTableWrapper: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const IconButton: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const ActionButton: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("antd/es/button/button").ButtonProps & import("react").RefAttributes<HTMLElement>> & {
+    Group: import("react").FC<import("antd/es/button").ButtonGroupProps>;
+}, any, {
+    $hide?: boolean | undefined;
+}, never>;
+export declare const FilterMetricLabel: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("antd/es/flex/interface").FlexProps<import("antd/es/_util/type").AnyObject> & import("react").RefAttributes<HTMLElement>>, any, {}, never>;
+export declare const DataTableContent: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const FilterButton: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const GroupByExpandButton: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("antd/es/flex/interface").FlexProps<import("antd/es/_util/type").AnyObject> & import("react").RefAttributes<HTMLElement>>, any, {}, never>;

package/es/types/components/organism/DataTable/types/filter.d.ts

@@ -0,0 +1,56 @@
+import { MatchesAnyItem } from '../../../molecules';
+import { FILTER_ACTION_KEYS } from '../constants/filter';
+import { TActionButton, TConfirmResponse } from '@antscorp/antsomi-ui/es/types';
+export type TActionFilterButtonKey<T extends string[] = []> = (typeof FILTER_ACTION_KEYS)[keyof typeof FILTER_ACTION_KEYS] | T[number];
+export interface SavedFilterItem {
+    id: string;
+    name: string;
+    removable?: boolean;
+}
+export interface FilterMetricItem {
+    id: string | number;
+    name: string;
+    dataType?: string;
+    children?: FilterMetricItem[];
+    operators?: {
+        label: string;
+        value: string;
+    }[];
+}
+export interface SavedFilter {
+    list?: SavedFilterItem[];
+    selected?: string | number;
+    onRemove?: (savedFilter: SavedFilterItem) => Promise<TConfirmResponse>;
+    onSelect?: (savedFilter: SavedFilterItem) => void;
+}
+export interface FilterItem {
+    column: string | number;
+    dataType?: string;
+    operator: string;
+    type?: number;
+    value: any;
+}
+export type TOnSaveFilterArgs = {
+    existSavedFilter?: SavedFilterItem;
+    name: string;
+    filters: FilterItem[];
+};
+export type TFilterActionButton<T extends TActionFilterButtonKey> = TActionButton & T extends 'CLOSE' ? {} : {};
+export interface FilterProps<TActionKey extends string[] = []> {
+    isFilterActive?: boolean;
+    savedFilter?: SavedFilter;
+    filterMetrics?: FilterMetricItem[];
+    filters?: FilterItem[];
+    matchesAny?: {
+        list?: MatchesAnyItem[];
+        isLoading?: boolean;
+    };
+    actionButtons?: Partial<Record<TActionFilterButtonKey<TActionKey>, TActionButton>>;
+    onChangeFilters?: (filters: FilterItem[]) => void;
+    onSaveFilter?: (args: TOnSaveFilterArgs) => Promise<TConfirmResponse>;
+    /** Handle callback when filter condition changed */
+    onChangeFilterCondition?: (filterItem: FilterItem) => void;
+    /** Handle callback when matches any load more */
+    onMatchesAnyLoadMore?: (metricId?: FilterMetricItem['id']) => void;
+}
+export type TApiFilter = Record<string, any>[];

package/es/types/components/organism/DataTable/types/index.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="react" />
+import { TableProps as AntdTableProps } from 'antd';
+import { StoreApi } from 'zustand';
+import { ToolbarProps } from './toolbar';
+import { FilterProps } from './filter';
+import { PaginationProps } from '../components';
+export interface TableProps<T> extends AntdTableProps<T> {
+    columnWidths?: Record<number, number>;
+    onColumnResize?: (data: {
+        index: number;
+        width: number;
+    }) => void;
+}
+export interface ModifyColumnProps {
+}
+export interface DataTableProps<TTableDataType = any> extends Partial<DataTableState<TTableDataType>> {
+    contentRender?: () => React.ReactNode;
+    store?: StoreApi<DataTableStore<any>> | null;
+    className?: string;
+}
+export interface DataTableState<TTableDataType> {
+    name: string;
+    modifyColumn: ModifyColumnProps;
+    filter: FilterProps;
+    toolbar: ToolbarProps;
+    table: TableProps<TTableDataType>;
+    pagination: PaginationProps;
+}
+export interface DataTableStore<TTableDataType = any> {
+    name: string;
+    modifyColumn: ModifyColumnProps;
+    filter: FilterProps;
+    toolbar: ToolbarProps;
+    table: TableProps<TTableDataType>;
+    pagination: PaginationProps;
+    setState: (newState: Partial<DataTableState<TTableDataType>>) => void;
+    setModifyColumn: (modifyColumn: RecursivePartial<ModifyColumnProps>) => void;
+    setFilter: (filter: Partial<FilterProps>) => void;
+    setPagination: (pagination: Partial<PaginationProps>) => void;
+    setToolbar: (toolbar: Partial<ToolbarProps>) => void;
+    setTable: (table: Partial<TableProps<TTableDataType>>) => void;
+}
+export * from './theme';
+export * from './toolbar';
+export * from './filter';

package/es/types/components/organism/DataTable/types/theme.d.ts

@@ -0,0 +1,10 @@
+import { ThemeConfig } from 'antd';
+import { AliasToken } from 'antd/es/theme/internal';
+export type TDataTableToken = {
+    toolbarHeight: number;
+    toolbarPadding: string;
+    filterToolbarColor: string;
+};
+export interface DataTableThemeConfig extends Omit<ThemeConfig, 'token'> {
+    token?: Partial<AliasToken> & Partial<TDataTableToken>;
+}

package/es/types/components/organism/DataTable/types/toolbar.d.ts

@@ -0,0 +1,87 @@
+import { ReactNode } from 'react';
+import { DropdownProps } from 'antd';
+import { ItemType } from 'antd/es/menu/hooks/useItems';
+import { GRID_VIEW_KEYS, TOOLBAR_ACTION_KEYS } from '../constants';
+import { AddButtonProps } from '../components/AddButton';
+import { TActionButton, TConfirmResponse } from '@antscorp/antsomi-ui/es/types';
+import { TOperatorKey } from '@antscorp/antsomi-ui/es/types/condition';
+import { ModifyColumnMetric } from '../../ModifyColumnModal';
+import { SavedModifyColumnItem, TOnSaveModifyColumnArgs } from '../../ModifyColumnModal/types';
+import { TextProps } from 'antd/es/typography/Text';
+import { TemplateListingProps } from '../../../template';
+export type TActionToolbarButtonKey<T extends string[] = []> = (typeof TOOLBAR_ACTION_KEYS)[keyof typeof TOOLBAR_ACTION_KEYS] | T[number];
+export type TGridViewKeys = (typeof GRID_VIEW_KEYS)[keyof typeof GRID_VIEW_KEYS];
+export type TSearchItem = {
+    id: string | number;
+    label: string;
+    link?: string;
+    icon?: ReactNode;
+    [key: string]: any;
+};
+export type TSelectedRowButton = TActionButton & {
+    dropdownProps?: DropdownProps;
+};
+/**
+ * Represents a search action button, extending the base functionality of `TActionButton`.
+ *
+ * @typedef {TActionButton} TSearchActionButton
+ *
+ * @property {TSearchItem[]} [searchList] - An optional list of search items.
+ * @property {string} [objectName] - An optional name for the object being searched show in filter section.
+ * @property {(valueSearch: string) => void} [onSearch] - An optional callback function triggered when a search is performed, taking the search value as a parameter.
+ */
+export type TSearchActionButton = TActionButton & {
+    searchList?: TSearchItem[];
+    objectName?: string;
+    isClientSearch?: boolean;
+    isAddFilterFromSearchItem?: boolean;
+    addFilterInfo?: {
+        metricId?: string | number;
+        operator: TOperatorKey;
+    };
+    searchItemProps?: TextProps;
+    loading?: boolean;
+    itemSearchRender?: (item: TSearchItem, index: number, node: ReactNode) => React.ReactNode;
+    onSearch?: (valueSearch: string) => void;
+    onClickSearchItem?: (item: TSearchItem, index: number) => void;
+};
+export type TColumnActionButton = TActionButton & {
+    modalTitle?: string;
+    savedModifyColumn?: {
+        list: SavedModifyColumnItem[];
+        selected?: string | number;
+        loading?: boolean;
+        onRemove?: (savedFilter: SavedModifyColumnItem) => Promise<TConfirmResponse>;
+        onSelect?: (savedFilter: SavedModifyColumnItem) => void;
+    };
+    metrics?: ModifyColumnMetric[];
+    onApply?: (args: TOnSaveModifyColumnArgs) => Promise<TConfirmResponse>;
+};
+export type TGridViewActionButton = TActionButton & {
+    /** The mode of the grid view. Ex: '' */
+    mode?: TGridViewKeys;
+    templateListingProps?: TemplateListingProps;
+    /** The callback function to change the mode of the grid view. */
+    onChangeMode?: (mode: TGridViewKeys) => void;
+};
+export type TGroupByActionButton = TActionButton & {
+    selectedKey?: string;
+    options: ItemType[];
+    onChange: (key: string) => void;
+};
+export type TToolbarActionButton<TActionKey extends string[] = [], ActionKey extends TActionToolbarButtonKey<TActionKey> = TActionToolbarButtonKey<TActionKey>> = ActionKey extends 'SEARCH' ? TSearchActionButton : ActionKey extends 'COLUMN' ? TColumnActionButton : ActionKey extends 'GRID_VIEW' ? TGridViewActionButton : ActionKey extends 'GROUP_BY' ? TGroupByActionButton : TActionButton;
+export type TCollapse = {
+    collapsed?: boolean;
+    onCollapse?: (collapsed: boolean) => void;
+};
+export interface ToolbarProps<TActionKey extends string[] = []> {
+    show?: boolean;
+    addButton?: AddButtonProps | ((node: ReactNode) => ReactNode);
+    actionButtons?: {
+        [K in TActionToolbarButtonKey<TActionKey>]?: TToolbarActionButton<TActionKey, K>;
+    };
+    selectedRowButtons?: Record<string, TSelectedRowButton>;
+    collapse?: TCollapse;
+    /** The right content of the toolbar. */
+    rightContent?: ReactNode;
+}

package/es/types/components/organism/DataTable/utils/filter.d.ts

@@ -0,0 +1,97 @@
+import React from 'react';
+import { MenuProps } from 'antd';
+import { FilterItem, FilterMetricItem, TApiFilter } from '../types';
+import { SavedFilter } from '@antscorp/antsomi-ui/es/models/DataTable/SavedFilter';
+import { FilterProps } from '../..';
+import { TFormatFilterValue } from '../hooks/useDataTableListing/types';
+type MenuItem = Required<MenuProps>['items'][number];
+type TSerializeFilterMetricsToMenuItems = {
+    filterMetrics: FilterMetricItem[];
+    level?: number;
+    onSelectFilterMetric?: MenuProps['onSelect'];
+    onClickFilterMetric?: (filterMetric: FilterMetricItem) => void;
+};
+type TRenderValueField = {
+    filterMetric: FilterMetricItem;
+    operator: string;
+    value?: any;
+    matchesAny?: FilterProps['matchesAny'];
+    onChangeValue?: (value: any) => void;
+    onLoadMore?: () => void;
+};
+type TGetFilterMetricByName = {
+    filterMetrics: FilterMetricItem[];
+    name: string;
+};
+export declare const serializeFilterMetricsToMenuItems: ({ filterMetrics, level, onSelectFilterMetric, onClickFilterMetric, }: TSerializeFilterMetricsToMenuItems) => MenuItem[];
+/**
+ * Flattens an array of filter metrics, including their nested children, into a single-level array.
+ *
+ * @param {FilterMetric[]} filterMetrics - The array of filter metrics to flatten. Each filter metric can contain
+ *                                         nested children which will also be included in the flattened result.
+ * @returns {FilterMetric[]} A single-level array of filter metrics, including all nested children.
+ *
+ * @example
+ * // Given the following input:
+ * const filterMetrics = [
+ *   {
+ *     id: 1,
+ *     name: 'Metric 1',
+ *     children: [
+ *       {
+ *         id: 2,
+ *         name: 'Metric 1.1',
+ *         children: []
+ *       },
+ *       {
+ *         id: 3,
+ *         name: 'Metric 1.2',
+ *         children: [
+ *           {
+ *             id: 4,
+ *             name: 'Metric 1.2.1',
+ *             children: []
+ *           }
+ *         ]
+ *       }
+ *     ]
+ *   },
+ *   {
+ *     id: 5,
+ *     name: 'Metric 2',
+ *     children: []
+ *   }
+ * ];
+ *
+ * // The output will be:
+ * const result = flatFilterMetrics(filterMetrics);
+ * // result will be:
+ * // [
+ * //   { id: 2, name: 'Metric 1.1', children: [] },
+ * //   { id: 4, name: 'Metric 1.2.1', children: [] },
+ * //   { id: 3, name: 'Metric 1.2', children: [...] },
+ * //   { id: 1, name: 'Metric 1', children: [...] },
+ * //   { id: 5, name: 'Metric 2', children: [] }
+ * // ]
+ */
+export declare const flatFilterMetrics: (filterMetrics: FilterMetricItem[]) => FilterMetricItem[];
+export declare const renderValueField: ({ filterMetric, operator, value, matchesAny, onLoadMore, onChangeValue, }: TRenderValueField) => React.JSX.Element | null;
+/**
+ * Retrieves a filter metric by its name from a collection of filter metrics.
+ *
+ * @typedef {Object} Metric
+ * @property {string} name - The name of the metric.
+ * @property {any} [otherProperties] - Other properties of the metric.
+ *
+ * @typedef {Object} TGetFilterMetricByName
+ * @property {Metric[]} filterMetrics - An array of filter metrics.
+ * @property {string} name - The name of the metric to find.
+ *
+ * @param {TGetFilterMetricByName} params - The parameters containing filter metrics and the name of the metric to find.
+ * @returns {Metric|undefined} The metric with the specified name, or undefined if not found.
+ */
+export declare const getFilterMetricByName: ({ filterMetrics, name, }: TGetFilterMetricByName) => FilterMetricItem | undefined;
+export declare const mapFiltersToRules: (filters: FilterItem[]) => SavedFilter['rules'];
+export declare const mapRulesToFilters: (rules: SavedFilter['rules']) => FilterItem[];
+export declare const mapFiltersToApiFilters: (filters: FilterItem[], includeDataType?: boolean, formatFilterValue?: TFormatFilterValue) => TApiFilter;
+export {};

package/es/types/components/organism/DataTable/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './filter';

package/es/types/components/organism/FilterSetting/components/common/InputArray/index.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface InputArrayProps {
+    value: string[];
+    onChange: (v: InputArrayProps['value']) => void;
+    required?: boolean;
+    focused?: boolean;
+}
+export declare const InputArray: React.FC<InputArrayProps>;
+export {};

package/es/types/components/organism/FilterSetting/components/common/InputArray/styled.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+export declare const StyledSelect: import("styled-components").StyledComponent<{
+    (props: import("@antscorp/antsomi-ui/es/components/molecules").SelectV2Props): import("react").JSX.Element;
+    defaultProps: {
+        suffixIcon: import("react").JSX.Element;
+        filterOption: (input: any, option: any) => boolean;
+        tagRender: (props: any) => import("react").JSX.Element;
+        containerStyle: {};
+        labelStyle: {};
+        clearIcon: import("react").JSX.Element;
+    };
+}, any, {}, never>;

package/es/types/components/organism/FilterSetting/components/common/InputBoolean/index.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { SelectProps } from '@antscorp/antsomi-ui/es/components/molecules/Select';
+interface InputBooleanProps extends SelectProps {
+    value: string;
+    onChange: (v: InputBooleanProps['value']) => void;
+}
+export declare const InputBoolean: React.FC<InputBooleanProps>;
+export {};

package/es/types/components/organism/FilterSetting/components/common/InputCalendar/index.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { TOperatorValue } from '@antscorp/antsomi-ui/es/components/atoms/InputDynamic/types';
+interface InputCalendarProps {
+    value: string | number | null;
+    required?: boolean;
+    focused?: boolean;
+    operator?: TOperatorValue;
+    onChange: (v: InputCalendarProps['value']) => void;
+}
+export declare const InputCalendar: React.FC<InputCalendarProps>;
+export {};

package/es/types/components/organism/FilterSetting/components/common/InputCalendarBetween/index.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface InputCalendarBetweenProps {
+    value: string;
+    required?: boolean;
+    focused?: boolean;
+    onChange: (v: InputCalendarBetweenProps['value']) => void;
+}
+export declare const InputCalendarBetween: React.FC<InputCalendarBetweenProps>;
+export {};

package/es/types/components/organism/FilterSetting/components/common/InputDateTimeAgo/index.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+type TimeUnit = 'DAY' | 'HOUR';
+interface InputDateTimeAgoProps {
+    value: string | number;
+    timeUnit?: TimeUnit;
+    onChangeMultipleValue: ({ value, time_unit, }: {
+        value?: InputDateTimeAgoProps['value'];
+        time_unit?: InputDateTimeAgoProps['timeUnit'];
+    }) => void;
+    required?: boolean;
+}
+export declare const InputDateTimeAgo: React.FC<InputDateTimeAgoProps>;
+export {};

package/es/types/components/organism/FilterSetting/components/common/InputDateTimeBetweenAgo/index.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+interface InputDateTimeBetweenAgoProps {
+    value: string;
+    timeUnit?: string;
+    onChange: ({ value, time_unit, }: {
+        value?: InputDateTimeBetweenAgoProps['value'];
+        time_unit?: InputDateTimeBetweenAgoProps['timeUnit'];
+    }) => void;
+}
+export declare const InputDateTimeBetweenAgo: React.FC<InputDateTimeBetweenAgoProps>;
+export {};

package/es/types/components/organism/FilterSetting/components/common/InputNumber/index.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface InputNumberProps {
+    value: string | number;
+    onChange: (val: InputNumberProps['value']) => void;
+}
+export declare const InputNumber: React.FC<InputNumberProps>;
+export {};

package/es/types/components/organism/FilterSetting/components/common/InputNumberBetween/index.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface InputNumberBetweenProps {
+    value: string;
+    onChange: (val: InputNumberBetweenProps['value']) => void;
+}
+export declare const InputNumberBetween: React.FC<InputNumberBetweenProps>;
+export {};

package/es/types/components/organism/FilterSetting/components/common/InputOrSelect/index.d.ts

@@ -0,0 +1,79 @@
+import React from 'react';
+import { CustomerMetadata, EventBoFieldMetadata, VisitorMetadata } from '@antscorp/antsomi-ui/es/components/atoms/InputDynamic/types';
+type Value = string | null;
+type ValueType = 'event' | 'normal' | 'customer' | 'visitor' | string;
+type BOField = {
+    label: string;
+    value: string;
+    dataType: string;
+};
+interface InputOrSelectProps {
+    value: Value;
+    eventMetadata: EventBoFieldMetadata;
+    visitorMetadata: VisitorMetadata;
+    customerMetadata: CustomerMetadata;
+    valueType: ValueType;
+    onChangeMultipleValue: ({ value, event_metadata, visitor_metadata, customer_metadata, value_type, }: {
+        value?: InputOrSelectProps['value'];
+        event_metadata?: InputOrSelectProps['eventMetadata'];
+        visitor_metadata?: InputOrSelectProps['visitorMetadata'];
+        customer_metadata?: InputOrSelectProps['customerMetadata'];
+        value_type?: InputOrSelectProps['valueType'];
+    }) => void;
+    dataType: string | null;
+    businessObject?: Record<string, string>;
+    boFieldOptions?: BOField[];
+    useBo?: boolean;
+    hideSelectField?: boolean;
+}
+export declare const InputOrSelect: React.FC<InputOrSelectProps>;
+interface ModalSelectProps {
+    isModalVisible: boolean;
+    valueType: ValueType;
+    handleOk: ({ valueType, metaData }: {
+        valueType: any;
+        metaData: any;
+    }) => void;
+    handleCancel: () => void;
+    eventMetadata: EventBoFieldMetadata;
+    customerMetadata: CustomerMetadata;
+    visitorMetadata: VisitorMetadata;
+    businessObject?: Record<string, string>;
+    boFieldOptions?: BOField[];
+    defaultIsBo?: boolean;
+    onError?: (errorMsg: string) => void;
+}
+export declare const ModalSelect: React.FC<ModalSelectProps>;
+export declare const StyledAutoComplete: import("styled-components").StyledComponent<(<ValueType = any, OptionType extends import("rc-select/lib/Select").DefaultOptionType | import("rc-select/lib/Select").BaseOptionType = import("rc-select/lib/Select").DefaultOptionType>(props: import("antd").AutoCompleteProps<ValueType, OptionType> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<import("antd").RefSelectProps>) => React.ReactElement<any, string | React.JSXElementConstructor<any>>) & {
+    displayName?: string | undefined;
+    Option: import("rc-select/lib/Option").OptionFC;
+    _InternalPanelDoNotUseOrYouWillBeFired: (props: import("antd/es/_util/type").AnyObject) => React.JSX.Element;
+}, any, {}, never>;
+export declare const StyledDropdown: import("styled-components").StyledComponent<"div", any, {
+    $isSearching: boolean;
+}, never>;
+export declare const StyledSelect: import("styled-components").StyledComponent<{
+    (props: import("@antscorp/antsomi-ui/es/components/molecules").SelectV2Props): React.JSX.Element;
+    defaultProps: {
+        suffixIcon: React.JSX.Element;
+        filterOption: (input: any, option: any) => boolean;
+        tagRender: (props: any) => React.JSX.Element;
+        containerStyle: {};
+        labelStyle: {};
+        clearIcon: React.JSX.Element;
+    };
+}, any, any, never>;
+export declare const StyledTreeSelect: import("styled-components").StyledComponent<(<ValueType = any, OptionType extends import("rc-tree-select/lib/TreeSelect").DefaultOptionType | import("rc-tree-select/lib/TreeSelect").BaseOptionType = import("rc-tree-select/lib/TreeSelect").DefaultOptionType>(props: import("antd").TreeSelectProps<ValueType, OptionType> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<import("antd").RefSelectProps>) => React.ReactElement<any, string | React.JSXElementConstructor<any>>) & {
+    displayName?: string | undefined;
+    TreeNode: React.FC<import("rc-tree-select/lib/TreeNode").TreeNodeProps>;
+    SHOW_ALL: "SHOW_ALL";
+    SHOW_PARENT: "SHOW_PARENT";
+    SHOW_CHILD: "SHOW_CHILD";
+    _InternalPanelDoNotUseOrYouWillBeFired: (props: import("antd/es/_util/type").AnyObject) => React.JSX.Element;
+}, any, {}, never>;
+export declare const StyledSearch: import("styled-components").StyledComponent<React.ForwardRefExoticComponent<import("antd/lib/input/Search").SearchProps & React.RefAttributes<import("antd").InputRef>>, any, {}, never>;
+export {};

package/es/types/components/organism/FilterSetting/components/common/InputSelectMulti/ColumnSuggestion/index.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { DataSelect } from '..';
+interface ColumnContent {
+    data: DataSelect;
+    extendValue?: any;
+    onChange: (value: any) => void;
+    onChangeRemoveExtend: (value: any) => void;
+}
+export declare const ColumnSuggestion: React.FC<ColumnContent>;
+export declare const WrapperContent: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const List: import("styled-components").StyledComponent<"ul", any, {}, never>;
+export declare const ListItem: import("styled-components").StyledComponent<"li", any, {}, never>;
+export declare const Span: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const TextField: import("styled-components").StyledComponent<React.FC<import("../../../../../../atoms/Text").TextProps>, any, {}, never>;
+export {};