kelt-ui-kit-react 2.0.3 → 2.0.4

package/README.md

@@ -1,5 +1,31 @@
 # Getting Started with Create React App
 
+## Address search
+
+Use the `ADDRESS` field type to add geocoding directly to an address field.
+The user can keep any manually entered value, while selecting a suggestion can
+populate the rest of the form:
+
+```tsx
+{
+	name: "adresse1",
+	label: "Adresse",
+	type: TypeInputEnum.ADDRESS,
+	value: "",
+	addressSearch: {
+		mapAddress: (address) => ({
+			adresse1: address.addressLine,
+			codePostal: address.postalCode,
+			ville: address.city,
+			paysIso2: address.countryCode,
+		}),
+	},
+};
+```
+
+Use `addressSearch.provider` to inject another service implementing
+`GeocodingProvider`. The default provider does not require an API key.
+
 This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app).
 
 ## Available Scripts

package/dist/addressSearch/AddressSearch.d.ts

@@ -0,0 +1,20 @@
+import { GeocodedAddress, GeocodingProvider } from '../geocoding/geocoding.interface';
+
+export interface AddressSearchProps {
+    id?: string;
+    className?: string;
+    label?: string;
+    placeholder?: string;
+    value?: string;
+    disabled?: boolean;
+    minimumQueryLength?: number;
+    debounceTime?: number;
+    limit?: number;
+    provider?: GeocodingProvider;
+    allowManualEntry?: boolean;
+    manualEntryLabel?: string;
+    onChange?: (value: string) => void;
+    onManualEntry?: (addressLine: string) => void;
+    onSelect: (address: GeocodedAddress) => void;
+}
+export declare const AddressSearch: ({ id, className, label, placeholder, value, disabled, minimumQueryLength, debounceTime, limit, provider, allowManualEntry, manualEntryLabel, onChange, onManualEntry, onSelect, }: AddressSearchProps) => import("react/jsx-runtime").JSX.Element;

package/dist/addressSearch/AddressSearch.view.d.ts

@@ -0,0 +1 @@
+export declare const AddressSearchView: () => import("react/jsx-runtime").JSX.Element;

package/dist/badge/Badge.d.ts

@@ -4,9 +4,7 @@ export type BadgeInterface = {
     className?: string;
     onClick?: (e: React.MouseEvent) => void;
     title?: string;
-    color?: string;
-    onRemove?: (e: React.MouseEvent) => void;
     sizeIcon?: IconSizeEnum;
     classIcon?: string;
 };
-export declare const Badge: ({ className, onClick, color, title, onRemove, sizeIcon, classIcon, }: BadgeInterface) => import("react/jsx-runtime").JSX.Element;
+export declare const Badge: ({ className, onClick, title, sizeIcon, classIcon, }: BadgeInterface) => import("react/jsx-runtime").JSX.Element;

package/dist/button/Button.d.ts

@@ -1,3 +1,3 @@
 import { ButtonInterface } from './button.interface';
 
-export declare const Button: ({ className, onClick, badge, title, sizeIcon, id, classIcon, positionicon, disabled, }: ButtonInterface) => import("react/jsx-runtime").JSX.Element;
+export declare const Button: ({ className, onClick, badge, title, sizeIcon, id, classIcon, positionicon, disabled, style, }: ButtonInterface) => import("react/jsx-runtime").JSX.Element;

package/dist/button/button.interface.d.ts

@@ -5,12 +5,13 @@ export interface ButtonInterface {
     className?: string;
     badge?: BadgeInterface;
     id?: string;
-    onClick?: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    onClick?: (e: React.MouseEvent) => void;
     title: string;
     classIcon?: string;
     positionicon?: number;
     disabled?: boolean;
     sizeIcon?: IconSizeEnum;
+    style?: React.CSSProperties;
 }
 export interface buttonActionInterface {
     icon?: string;

package/dist/card/Card.d.ts

@@ -1,6 +1,7 @@
 import { PositionOverlay } from '../overlayPanel/OverlayPanel';
 import { CardInterface } from './card.interface';
 import { CardActionInterface } from './cardAction.interface';
+import { GridResponsive } from '../grid/grid.interface';
 
 type CardProps = {
     item: CardInterface;
@@ -11,6 +12,8 @@ type CardProps = {
     children?: JSX.Element;
     customAction?: JSX.Element;
     positionOverlay?: PositionOverlay;
+    /** Largeur sur laquelle se basent les breakpoints du footer, défaut : "app" */
+    responsive?: GridResponsive;
 };
-export declare const Card: ({ item, actions, className, handleClick, onClose, customAction, positionOverlay, children, }: CardProps) => JSX.Element;
+export declare const Card: ({ item, actions, className, handleClick, onClose, customAction, positionOverlay, responsive, children, }: CardProps) => JSX.Element;
 export {};

package/dist/dataTable/DataTable.d.ts

@@ -1,16 +1,5 @@
-import { DataTableActionsInterface, DataTableColumnsInterface } from './dataTable.interface';
+import { dataTableActionsInterface, dataTableColumnsInterface } from './dataTable.interface';
 
-export type DataTableDateRangeFilterValue = {
-    startDate: string;
-    endDate: string;
-};
-export type FilterValue = string | number | boolean | string[] | DataTableDateRangeFilterValue | null;
-export type DataTableFilterState = Record<string, FilterValue>;
-export type DataTableSortDirection = "asc" | "desc";
-export type DataTableSortState = {
-    key: string;
-    direction: DataTableSortDirection;
-};
 export type DataTableProps<T> = {
     id: string;
     name?: string;
@@ -19,19 +8,27 @@ export type DataTableProps<T> = {
     element?: JSX.Element;
     data: T[];
     emptyMessage?: string;
-    actions?: DataTableActionsInterface<T>[];
-    columns: DataTableColumnsInterface<T>[];
-    onFiltersChange?: (next: DataTableFilterState) => void;
-    onSortChange?: (next: DataTableSortState | null) => void;
+    actionsColumnWidth?: number;
+    actions?: dataTableActionsInterface<T>[];
+    footerAction?: (props: {
+        close: () => void;
+        selectedRows: T[];
+    }) => JSX.Element;
+    columns: dataTableColumnsInterface<T>[];
     loading?: boolean;
     onRowClick?: (row: any) => void;
     onColumnClick?: (column: any) => void;
-    onEditColumnByOverlay?: (row: T) => void;
     onLoadMore?: () => void;
     hasMore?: boolean;
     onSelectionChange?: (selectedRows: T[]) => void;
+    autoFocusFirstEditable?: boolean;
     hideToggleAll?: boolean;
     limitSelect?: number;
     getRowId?: (row: T) => string | number;
+    onRowStyle?: (row: T) => React.CSSProperties | undefined;
+    onRowClassName?: (row: T) => string | undefined;
+    rowStyle?: (row: T) => React.CSSProperties | undefined;
+    rowClassName?: (row: T) => string | undefined;
+    mobileCardView?: boolean;
 };
 export declare function DataTable<T>(props: DataTableProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/dataTable/dataTable.interface.d.ts

@@ -1,53 +1,48 @@
 import { HTMLInputTypeAttribute } from 'react';
-import { EnumerableType } from '../_core/type/generiqueType';
-import { TypeInputEnum } from '../form/form.enum';
 
-export interface DataTableColumnsInterface<T> {
+export interface dataTableColumnsInterface<T> {
     id: string;
     label: string;
-    key?: string;
-    name?: string;
-    sticky?: boolean;
     minWidth?: number;
     maxWidth?: number;
     width?: number;
     align?: "right" | "left" | "center";
-    alignText?: "right" | "left" | "center";
     format?: (value: any) => string;
     sortable?: boolean;
     filterable?: boolean;
-    filterDataEnum?: EnumerableType[];
-    filterType?: TypeInputEnum;
+    filterValue?: string;
     editable?: boolean;
-    isUpdatable?: boolean;
+    enterToNextColumn?: boolean;
     options?: {
         label: string;
         value: string;
     }[];
-    displayOverlay?: boolean;
-    onEditable?: (value: any, row: T) => boolean;
-    onChange?: (value: any, row: T) => void;
-    onEditByOverlay?: (value: any, row: T) => void;
     onEdit?: (value: any, row: T) => void;
+    onEnter?: (value: any, row: T) => void;
     onDisable?: (row: T) => boolean;
-    onEditTrigger?: "change" | "enter";
     onRowStyle?: (row: T) => React.CSSProperties;
-    renderComponent?: (value: any, row: T) => JSX.Element;
-    openClickCell?: boolean;
-    handleClickCell?: (e: React.MouseEvent<HTMLTableCellElement>, row: T) => void;
-    renderClickCellComponent?: (value: any, row: T) => JSX.Element;
-    type: HTMLInputTypeAttribute | "select";
-    children?: DataTableColumnsInterface<T>[];
+    type: HTMLInputTypeAttribute | "select" | "image";
+    imageAlt?: (row: T) => string;
+    imageStyle?: React.CSSProperties;
+    imageSrc?: (row: T) => string;
+    showStepButtons?: boolean | ((row: T) => boolean);
+    stepControls?: boolean | ((row: T) => boolean);
+    withStepControls?: boolean | ((row: T) => boolean);
+    step?: number;
+    min?: number;
+    max?: number;
 }
-export interface DataTableActionsInterface<T> {
+export interface dataTableActionsInterface<T> {
     id: string;
     label: string;
     type: "button" | "link" | "icon";
     classIcon?: string;
-    onClick: (row: T) => void;
+    onClick: (row: T, rowIndex?: number) => void;
     shouldDisplay?: (row: T) => boolean;
     disabled?: boolean;
     labelButton?: (row: T) => string;
     visible?: boolean;
-    width?: number;
+    width?: string | number;
+    minWidth?: string | number;
+    focusNextRow?: boolean;
 }

package/dist/dataTable/dataTableActions/DataTableAction.d.ts

@@ -1,9 +1,11 @@
-import { DataTableActionsInterface } from '../dataTable.interface';
+import { dataTableActionsInterface } from '../dataTable.interface';
 
 type DataTableActionProps = {
-    action: DataTableActionsInterface<any>;
+    action: dataTableActionsInterface<any>;
     row: any;
+    rowIndex?: number;
     index?: number;
+    onFocusNextRow?: (rowIndex: number) => void;
 };
-export declare const DataTableAction: ({ action, row, index, }: DataTableActionProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const DataTableAction: ({ action, row, rowIndex, index, onFocusNextRow, }: DataTableActionProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/dataTable/dataTableColumn/DataTableColumn.d.ts

@@ -1,15 +1,9 @@
-import { DataTableSortDirection } from '../DataTable';
-import { DataTableColumnsInterface } from '../dataTable.interface';
+import { dataTableColumnsInterface } from '../dataTable.interface';
 
-export declare function DataTableColumn<T>({ column, idx, onColumnClick, hasNestedColumns, isFilterVisible, onToggleFilterVisibility, currentSortDirection, onToggleSort, stickyLeft, stickyTop, }: {
-    hasNestedColumns: boolean;
-    column: DataTableColumnsInterface<T>;
+type DataTableColumnProps = {
+    column: dataTableColumnsInterface<any>;
     idx: number;
-    onColumnClick?: (column: DataTableColumnsInterface<T>) => void;
-    isFilterVisible?: boolean;
-    onToggleFilterVisibility?: (column: DataTableColumnsInterface<T>) => void;
-    currentSortDirection?: DataTableSortDirection | null;
-    onToggleSort?: (column: DataTableColumnsInterface<T>) => void;
-    stickyLeft?: number;
-    stickyTop?: number;
-}): import("react/jsx-runtime").JSX.Element;
+    onColumnClick?: (column: dataTableColumnsInterface<any>) => void;
+};
+export declare const DataTableColumn: ({ column, idx, onColumnClick, }: DataTableColumnProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/dataTable/dataTableLoading/DataTableLoading.d.ts

@@ -1,5 +1,7 @@
 type DataTableLoadingProps = {
+    columns: any[];
+    actions: any[];
     emptyMessage?: string;
 };
-export declare const DataTableLoading: ({ emptyMessage }: DataTableLoadingProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DataTableLoading: ({ columns, actions, emptyMessage, }: DataTableLoadingProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/dataTable/dataTableRow/DataTableRow.d.ts

@@ -1,11 +1,12 @@
-import { DataTableColumnsInterface } from '../dataTable.interface';
+import { dataTableColumnsInterface } from '../dataTable.interface';
 
 type DataTableRowProps = {
-    column: DataTableColumnsInterface<any>;
+    column: dataTableColumnsInterface<any>;
     idx: number;
+    rowIndex: number;
     row: any;
-    onEditColumnByOverlay?: (row: any) => void;
-    stickyLeft?: number;
+    container?: "cell" | "card";
+    onEnterNextColumn?: (columnIndex: number, rowIndex: number) => void;
 };
-export declare const DataTableRow: ({ column, idx, row, onEditColumnByOverlay, stickyLeft, }: DataTableRowProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DataTableRow: ({ column, idx, rowIndex, row, container, onEnterNextColumn, }: DataTableRowProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/expands/Expands.d.ts

@@ -6,6 +6,7 @@ type ExpandProps = {
     onChange?: (item: ExpandInterface) => void;
     currentItem?: ExpandInterface;
     showArrow?: boolean;
+    catchfocusCapture?: boolean;
 };
 export declare const Expands: (props: ExpandProps) => import("react/jsx-runtime").JSX.Element;
 export type { ExpandProps };

package/dist/expands/expand/expand.d.ts

@@ -5,6 +5,7 @@ export type ExpandProps = {
     item: ExpandInterface;
     className?: string;
     showArrow?: boolean;
-    onChange?: (item: ExpandInterface) => void;
+    catchfocusCapture?: boolean;
+    onChange: (item: ExpandInterface) => void;
 };
-export declare const Expand: ({ currentExpand, item, className, showArrow, onChange, }: ExpandProps) => JSX.Element;
+export declare const Expand: ({ currentExpand, item, className, showArrow, catchfocusCapture, onChange, }: ExpandProps) => JSX.Element;

package/dist/form/Form.d.ts

@@ -1,5 +1,6 @@
 import { default as React } from 'react';
-import { FormInterface, FormValuesInterface } from './form.interface';
+import { FormInterface, FormMode, FormSection, FormValuesInterface } from './form.interface';
+import { GridBreakpoints, GridResponsive } from '../grid/grid.interface';
 
 export type FormProps<T extends {
     [key: string]: string | number | boolean | Date | string[];
@@ -10,8 +11,15 @@ export type FormProps<T extends {
     hideSubmit?: boolean;
     autoComplete?: string;
     children?: React.ReactNode;
-    initialForm: FormInterface[];
+    initialForm?: FormInterface[];
+    sections?: FormSection[];
     disabledSubmit?: boolean;
+    mode?: FormMode;
+    /** Largeur sur laquelle se basent les breakpoints des champs (col), défaut : "app" */
+    responsive?: GridResponsive;
+    /** Place le bouton submit dans la grid (dernière ligne) avec ces tailles de col.
+     *  Ignoré si les champs n'utilisent pas la grid : le bouton reste dans le footer. */
+    submitCol?: GridBreakpoints;
     onSubmit?: (values: FormValuesInterface<T>) => void;
     onChange?: (values: FormValuesInterface<T>) => void;
 };

package/dist/form/form.enum.d.ts

@@ -1,4 +1,5 @@
 export declare enum TypeInputEnum {
+    ADDRESS = "address",
     TEXT = "text",
     BUTTON = "button",
     EMAIL = "email",
@@ -8,7 +9,7 @@ export declare enum TypeInputEnum {
     CHECKBOX = "checkbox",
     RADIO = "radio",
     DATE = "date",
-    DATERANGE = "daterange",
     SELECT = "select",
-    TEXTAREA = "textarea"
+    TEXTAREA = "textarea",
+    PRICE = "price"
 }

package/dist/form/form.interface.d.ts

@@ -1,5 +1,8 @@
 import { TypeInputEnum } from './form.enum';
+import { GridBreakpoints } from '../grid/grid.interface';
+import { GeocodedAddress, GeocodingProvider } from '../geocoding/geocoding.interface';
 
+export type FormMode = "read" | "edit";
 export type FormValuesInterface<T extends {
     [key: string]: string | number | boolean | Date | string[];
 }> = Partial<{
@@ -9,8 +12,13 @@ export interface FormCondition {
     errorMessage: string;
     regex: string;
 }
+export interface FormSection {
+    title?: React.ReactNode;
+    fields: FormInterface[];
+    className?: string;
+}
 export interface FormInterface {
-    value: string | number | boolean | Date;
+    value: string | number | boolean | Date | string[];
     id?: string;
     label?: string;
     focus?: boolean;
@@ -29,10 +37,21 @@ export interface FormInterface {
         label: string;
     }[];
     className?: string;
+    col?: GridBreakpoints;
+    addressSearch?: {
+        minimumQueryLength?: number;
+        debounceTime?: number;
+        limit?: number;
+        provider?: GeocodingProvider;
+        manualEntryLabel?: string;
+        mapAddress?: (address: GeocodedAddress) => Record<string, string | number | boolean | Date | string[]>;
+        onSelect?: (address: GeocodedAddress) => void;
+    };
+    formatReadValue?: (value: string | number | boolean | Date | string[]) => React.ReactNode;
     autoComplete?: string;
     step?: string;
     onChange?: (value: string | number | boolean | Date | string[], name?: string) => void;
-    onRequired?: (value: string | number | boolean | Date) => boolean;
-    onDisabled?: (value: string | number | boolean | Date) => boolean;
+    onRequired?: (value: string | number | boolean | Date | string[]) => boolean;
+    onDisabled?: (value: string | number | boolean | Date | string[]) => boolean;
     onInvalid?: (e: React.ChangeEvent<HTMLInputElement>) => void;
 }

package/dist/form/input/Input.d.ts

@@ -12,15 +12,12 @@ export interface InputProps {
     disabled?: boolean;
     autoFocus?: boolean;
     required?: boolean;
-    disabledDebounce?: boolean;
     minLength?: number;
     maxLength?: number;
-    width?: string;
     autoComplete?: string;
     step?: string;
     tabIndex?: number;
     checked?: boolean;
-    showClearButton?: boolean;
     handleKeyDown?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
     onChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
     onBlur?: (e: React.FocusEvent<HTMLInputElement>) => void;

package/dist/form/inputNumber/InputNumber.d.ts

@@ -5,8 +5,10 @@ export type InputNumberProps = {
     value?: string;
     placeholder?: string;
     className?: string;
+    pattern?: string;
     disabled?: boolean;
     required?: boolean;
+    inputMode?: "numeric" | "decimal";
     autoFocus?: boolean;
     maxLength?: number;
     autoComplete?: string;

package/dist/geocoding/GeocodingService.d.ts

@@ -0,0 +1,13 @@
+import { GeocodedAddress, GeocodingProvider, GeocodingSearchOptions } from './geocoding.interface';
+
+export interface GeocodingServiceOptions {
+    baseUrl?: string;
+    fetcher?: typeof fetch;
+}
+export declare class GeocodingService implements GeocodingProvider {
+    private readonly baseUrl;
+    private readonly fetcher;
+    constructor(options?: GeocodingServiceOptions);
+    search(query: string, options?: GeocodingSearchOptions): Promise<GeocodedAddress[]>;
+}
+export declare const geocodingService: GeocodingService;

package/dist/geocoding/geocoding.interface.d.ts

@@ -0,0 +1,20 @@
+export interface GeocodedAddress {
+    id: string;
+    label: string;
+    addressLine: string;
+    postalCode: string;
+    city: string;
+    cityCode?: string;
+    countryCode: string;
+    longitude: number;
+    latitude: number;
+    score?: number;
+    type?: string;
+}
+export interface GeocodingSearchOptions {
+    limit?: number;
+    signal?: AbortSignal;
+}
+export interface GeocodingProvider {
+    search(query: string, options?: GeocodingSearchOptions): Promise<GeocodedAddress[]>;
+}

package/dist/grid/Grid.d.ts

@@ -1,9 +1,12 @@
-import { GridInterface } from './grid.interface';
+import { GridInterface, GridResponsive } from './grid.interface';
+import { GridGap } from './row/Row';
 
 type GridProps = {
     items: GridInterface[];
     className?: string;
     scroll?: boolean;
+    gap?: GridGap;
+    responsive?: GridResponsive;
 };
-export declare const Grid: ({ items, className, scroll }: GridProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Grid: ({ items, className, scroll, gap, responsive, }: GridProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/grid/col/Col.d.ts

@@ -1,9 +1,6 @@
-/// <reference types="react" />
-type ColProps = {
-    xs?: number;
-    sm?: number;
-    md?: number;
-    lg?: number;
+import { GridBreakpoints } from '../grid.interface';
+
+type ColProps = GridBreakpoints & {
     children: React.ReactNode;
 };
 export declare const Col: React.FC<ColProps>;

package/dist/grid/col/colStyled/ColStyled.d.ts

@@ -1,9 +1,12 @@
-/// <reference types="react" />
+import { GridColumnSpan, GridResponsive } from '../../grid.interface';
+
 type ColStyledProps = {
-    $xs?: number;
-    $sm?: number;
-    $md?: number;
-    $lg?: number;
+    $responsive: GridResponsive;
+    $xs?: GridColumnSpan;
+    $sm?: GridColumnSpan;
+    $md?: GridColumnSpan;
+    $lg?: GridColumnSpan;
+    $xl?: GridColumnSpan;
 };
 export declare const ColStyled: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, ColStyledProps>> & string;
 export {};

package/dist/grid/grid.interface.d.ts

@@ -1,8 +1,23 @@
 /// <reference types="react" />
-export interface GridInterface {
-    sm?: number;
-    xs?: number;
-    md?: number;
-    lg?: number;
+/**
+ * Largeur de référence pour les breakpoints des Col :
+ * - "app" (défaut) : le conteneur app-container
+ * - "viewport" : la fenêtre (@media)
+ * - "row" : la Row elle-même (utile pour une grid dans une card, un panneau...)
+ */
+export type GridResponsive = "app" | "viewport" | "row";
+/**
+ * Nombre de colonnes sur 12, ou "auto" : la colonne partage la place restante
+ * de la ligne à parts égales avec les autres "auto" (ex. 5 champs sur une ligne).
+ */
+export type GridColumnSpan = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | "auto";
+export interface GridBreakpoints {
+    xs?: GridColumnSpan;
+    sm?: GridColumnSpan;
+    md?: GridColumnSpan;
+    lg?: GridColumnSpan;
+    xl?: GridColumnSpan;
+}
+export interface GridInterface extends GridBreakpoints {
     children: React.ReactNode;
 }

package/dist/grid/row/Row.d.ts

@@ -1,8 +1,15 @@
+import { GridResponsive } from '../grid.interface';
 
+export type GridGap = boolean | number | string;
+export declare const RowResponsiveContext: import('react').Context<GridResponsive>;
 type RowProps = {
     children: React.ReactNode;
     className?: string;
     scroll?: boolean;
+    /** true (défaut) : gap par défaut, false : pas de gap, number : px, string : valeur CSS ("1rem") */
+    gap?: GridGap;
+    /** Largeur sur laquelle se basent les breakpoints des Col (défaut : "app") */
+    responsive?: GridResponsive;
 };
 export declare const Row: React.FC<RowProps>;
 export {};

package/dist/header/Header.d.ts

@@ -1,3 +1,3 @@
 import { HeaderInterface } from './header.interface';
 
-export declare const Header: ({ children, logo, onClickMenu, userChildren, positionFixed, onClickLogo, showBackNavigation, onClickBackNavigation, }: HeaderInterface) => JSX.Element;
+export declare const Header: ({ children, logo, onClickMenu, userChildren, positionFixed, overlayClassName, onClickLogo, showBackNavigation, onClickBackNavigation, }: HeaderInterface) => JSX.Element;

package/dist/header/header.interface.d.ts

@@ -1,11 +1,12 @@
 /// <reference types="react" />
 export interface HeaderInterface {
-    logo?: string;
+    logo?: React.ReactNode;
     children?: React.ReactNode;
     positionFixed?: boolean;
     onClickMenu?: () => void;
     userChildren?: React.ReactNode;
     onClickLogo?: () => void;
+    overlayClassName?: string;
     showBackNavigation?: boolean;
     onClickBackNavigation?: () => void;
 }

package/dist/icon/Icon.d.ts

@@ -1,3 +1,3 @@
 import { IconInterface } from './icon.interface';
 
-export declare const Icon: ({ classIcon, size, onClick, }: IconInterface) => JSX.Element;
+export declare const Icon: ({ classIcon, size }: IconInterface) => JSX.Element;

package/dist/icon/icon.interface.d.ts

@@ -3,5 +3,4 @@ import { IconSizeEnum } from './iconSize.enum';
 export interface IconInterface {
     classIcon: string;
     size?: IconSizeEnum;
-    onClick?: (e: React.MouseEvent) => void;
 }

package/dist/index.d.ts

@@ -11,11 +11,12 @@ export { useToken } from './_core/hooks/useToken';
 export { useValidate } from './_core/hooks/useValidate';
 export { WidgetSupport } from './_core/hooks/widgetSupport';
 export { ButtonAction } from './action/ButtonAction';
+export { AddressSearch } from './addressSearch/AddressSearch';
+export type { AddressSearchProps } from './addressSearch/AddressSearch';
 export { Badge } from './badge/Badge';
 export { Button } from './button/Button';
 export { ButtonActions } from './button/buttonActions/ButtonActions';
 export { ButtonFile } from './button/buttonFile/ButtonFile';
-export { ButtonFilters } from './button/buttonFilters/ButtonFilters';
 export { Card } from './card/Card';
 export { Carousel } from './carousel/Carousel';
 export { Damier } from './damier/Damier';
@@ -25,11 +26,14 @@ export { Expands } from './expands/Expands';
 export { FilAriane } from './filAriane/FilAriane';
 export { DynamicForm } from './form/Form';
 export { TypeInputEnum } from './form/form.enum';
+export type { FormMode, FormSection } from './form/form.interface';
 export { Input } from './form/input/Input';
 export { InputNumber } from './form/inputNumber/InputNumber';
 export { InputPrice } from './form/inputPrice/InputPrice';
 export { TextArea } from './form/textArea/TextArea';
 export { Grid } from './grid/Grid';
+export { GeocodingService, geocodingService, } from './geocoding/GeocodingService';
+export type { GeocodedAddress, GeocodingProvider, GeocodingSearchOptions, } from './geocoding/geocoding.interface';
 export { Header } from './header/Header';
 export { Icon } from './icon/Icon';
 export { IconSizeEnum } from './icon/iconSize.enum';