@apia/components 0.3.6 → 1.0.1

package/cleanDist.json

@@ -1,3 +1,3 @@
 {
-  "cleanDist": 0.7360778446735086
+  "cleanDist": 0.9483910757295941
 }

package/dist/index.d.ts

@@ -1,9 +1,19 @@
-import { ThemeUIStyleObject, IconButtonProps, ButtonProps, ThemeUICSSObject, InputProps, BoxProps } from '@apia/theme';
-import { TModify, TId, TApiaFilter, TApiaFilterValue, IOnFocusConfiguration, TFocusRetriever, EventEmitter } from '@apia/util';
 import * as React$1 from 'react';
-import React__default, { ChangeEventHandler, MouseEvent, KeyboardEvent, ReactNode, FC, Ref, FunctionComponent, ForwardedRef, ComponentType, RefObject } from 'react';
+import React__default, { ChangeEventHandler, MouseEvent as MouseEvent$1, KeyboardEvent, ReactNode, FC, Ref, FunctionComponent, ForwardedRef, ComponentType, RefObject } from 'react';
+import { ThemeUIStyleObject, IconButtonProps, ButtonProps, ThemeUICSSObject, InputProps, BoxProps } from '@apia/theme';
+import { TModify, TId, TApiaFilter, TApiaFilterValue, IOnFocusConfiguration, TFocusRetriever, EventEmitter, PropsStore } from '@apia/util';
 import { TIconType, TIconName } from '@apia/icons';
 import { Args } from 'react-cool-portal';
+import * as _apia_notifications from '@apia/notifications';
+import { TNotificationId, INotification, TDispatchedNotification, TNotificationSelector } from '@apia/notifications';
+export { INotification, TDispatchedNotification } from '@apia/notifications';
+import * as _apia_components from '@apia/components';
+import { MenuItemProps, ControlledMenuProps } from '@szhsin/react-menu';
+export { ControlledMenuProps, MenuItemProps } from '@szhsin/react-menu';
+
+declare const ApiaChat: ((props: object) => React$1.JSX.Element) & {
+    displayName: string;
+};
 
 type TModalSize = 'editGrid' | 'sm' | 'md' | 'md-fixed' | 'lg' | 'lg-fixed' | 'xl' | 'xl-fixed' | 'xxl' | 'xxxl' | 'xxxl-fixed' | 'flex' | 'cal' | 'finder';
 type TApiaButtonType = 'primary' | 'primary-sm' | 'secondary' | 'light-secondary' | 'secondary-sm' | 'danger' | 'danger-sm' | 'outline' | 'outline-sm' | 'warning' | 'warning-sm' | 'link';
@@ -207,7 +217,7 @@ declare global {
         AMOUNT_DECIMAL_ZEROS: string;
         CHAR_DECIMAL_SEPARATOR: string;
         CHAR_THOUS_SEPARATOR: string;
-        ADD_THOUSAND_SEPARATOR: string;
+        ADD_THOUSAND_SEPARATOR: boolean;
     }
 }
 declare function parseNumberInputValueToNumber(value: string): number;
@@ -281,7 +291,7 @@ interface IAccordionItemButton {
      * presiona espacio sobre el botón del acordeón.
      */
     onChange?: (checked: boolean) => unknown;
-    onClick?: (ev: MouseEvent) => unknown;
+    onClick?: (ev: MouseEvent$1) => unknown;
     onUserPressEnter?: (ev: KeyboardEvent) => unknown;
     rightButtons?: ReactNode;
     rightIcons?: TIconName[] | TIconName;
@@ -381,6 +391,7 @@ interface IApiaFilter {
 declare const ApiaFilter: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<IApiaFilter & React$1.RefAttributes<HTMLInputElement | HTMLSelectElement>>>;
 
 interface ICollapsiblePanel {
+    'aria-hidden'?: boolean;
     children: React.ReactNode;
     className?: string;
     closedIcon?: TIconType | TIconName;
@@ -394,6 +405,7 @@ interface ICollapsiblePanel {
     onOpen?: (ev?: React.MouseEvent) => void | Promise<boolean>;
     openIcon?: TIconType | TIconName;
     label: React.ReactNode;
+    rememberCollapsedState?: boolean;
     titleButtons?: React.ReactNode;
 }
 
@@ -490,8 +502,8 @@ type TListbox = {
      * su aspecto
      */
     unstyled?: boolean;
-    onClickNode?: (ev: MouseEvent<HTMLElement>) => unknown;
-    onDoubleClickNode?: (ev: MouseEvent<HTMLElement>) => unknown;
+    onClickNode?: (ev: MouseEvent$1<HTMLElement>) => unknown;
+    onDoubleClickNode?: (ev: MouseEvent$1<HTMLElement>) => unknown;
     /**
      * Este evento es lanzado cuando el usuario estando en foco en la lista
      * presiona:
@@ -519,7 +531,7 @@ type TOnSelectionChange = {
     focusedElement: HTMLElement;
     selectedElements: HTMLElement[];
 };
-type TOnClickNode = MouseEvent;
+type TOnClickNode = MouseEvent$1;
 
 declare const Listbox: React$1.MemoExoticComponent<((props: TListbox) => React$1.JSX.Element) & {
     displayName: string;
@@ -967,11 +979,11 @@ type TIconsList<P = Record<string, unknown>> = {
     /**
      * Este callback es llamado cuando se hace click en un ícono
      */
-    onIconClick?: (ev: MouseEvent<HTMLElement>, icon: TIcon<P>) => unknown;
+    onIconClick?: (ev: MouseEvent$1<HTMLElement>, icon: TIcon<P>) => unknown;
     /**
      * Este callback es llamado cuando se hace doble click en un ícono
      */
-    onIconDoubleClick?: (ev: MouseEvent<HTMLElement>, icon: TIcon<P>) => unknown;
+    onIconDoubleClick?: (ev: MouseEvent$1<HTMLElement>, icon: TIcon<P>) => unknown;
     /**
      * Este método se usa para obtener detalles de un ícono. Es llamado cuando se
      * hace foco o cuando se posiciona el mouse en un ícono. Si no está declarado
@@ -1018,8 +1030,29 @@ declare const IconsList: {
     displayName: string;
 };
 
+/**
+ * Permite importar un componente en forma dinámica con ruta relativa a
+ * /customComponents
+ */
 declare function importComponent<T = unknown>(path: string): React$1.LazyExoticComponent<ComponentType<T>>;
 
+type TClickListener = () => unknown;
+type TItemState = Pick<TToolDefinition, 'disabled' | 'toggled'>;
+declare class ToolbarController extends EventEmitter<{
+    pressEnter: string;
+    updateItemState: string;
+}> {
+    eventListeners: Record<string, TClickListener[]>;
+    itemsState: Record<string, TItemState>;
+    hooks: {
+        useItemState: (id: string, initialState: TItemState) => TItemState;
+    };
+    setItemState: (id: string, newState: Partial<TItemState>) => void;
+    Context: ({ children }: {
+        children: ReactNode;
+    }) => React$1.JSX.Element;
+}
+
 type TToolEventState = {
     isToggled: boolean;
 };
@@ -1027,7 +1060,7 @@ type TSeparator = {
     separator: true;
 };
 type TToolDefinition = {
-    action: (props: TToolEventState) => unknown;
+    action: (props: TToolEventState, controller: ToolbarController) => unknown;
     /**
      * Si se pasa allowToggle y no se pasa toggled ( ni en true ni en false ),
      * entonces el estado de toggle será controlado internamente en el toolbar
@@ -1049,24 +1082,12 @@ type TToolDefinition = {
      */
     toggled?: boolean;
 };
-type TTool = TToolDefinition | TSeparator;
-
-type TClickListener = () => unknown;
-type TItemState = Pick<TToolDefinition, 'disabled' | 'toggled'>;
-declare class ToolbarController extends EventEmitter<{
-    pressEnter: string;
-    updateItemState: string;
-}> {
-    eventListeners: Record<string, TClickListener[]>;
-    itemsState: Record<string, TItemState>;
-    hooks: {
-        useItemState: (id: string, initialState: TItemState) => TItemState;
-    };
-    setItemState: (id: string, newState: Partial<TItemState>) => void;
-    Context: ({ children }: {
-        children: ReactNode;
-    }) => React$1.JSX.Element;
-}
+type TToolInput = {
+    inputProps?: InputProps;
+    label?: string;
+    type: 'input';
+};
+type TTool = TToolDefinition | TSeparator | TToolInput;
 
 declare const ToolbarItem: (props: TTool) => React$1.JSX.Element;
 
@@ -1081,6 +1102,250 @@ declare const Toolbar: ((props: {
     displayName: string;
 };
 
+declare const TabsList: ({ arrowsBehavior, }: {
+    arrowsBehavior?: "open" | "focus" | undefined;
+}) => React__default.JSX.Element;
+
+declare class TabsController<AdditionalPropsType extends Record<string, unknown> = Record<string, unknown>, TabType extends TTab<AdditionalPropsType> = TTab<AdditionalPropsType>> {
+    #private;
+    private props;
+    propsStore: PropsStore<TTab<AdditionalPropsType>>;
+    stateKey: string;
+    get stateStore(): PropsStore<TTabsListState>;
+    get activeTabs(): TId[];
+    get tabsList(): TId[];
+    constructor(name: string, props: TTabs<AdditionalPropsType>, initialTabs?: TabType[]);
+    /**
+     * Obviamente agrega un tab al listado de tabs
+     */
+    append(tab: Omit<TabType, 'tabAdditionalProps'> & Partial<Pick<TabType, 'tabAdditionalProps'>>): void;
+    closeAll(closeFixedTabsAsWell?: boolean, force?: boolean): Promise<void>;
+    closeToRight(targetId: TId): Promise<void>;
+    closeToLeft(targetId: TId): Promise<void>;
+    closeOthers(targetId: TId): Promise<void>;
+    closeTab(tabId: TId, force?: boolean): Promise<boolean>;
+    focusNextTab(): TId | null;
+    focusPreviousTab(): TId | null;
+    focusTab(tabId: TId): void;
+    getTabById(tabId: TId): TTab<AdditionalPropsType>;
+    getTabElement(tabId: TId): Element | null;
+    handleKeyDown(ev: React__default.KeyboardEvent): void;
+    openNextTab(): TId | null;
+    openPreviousTab(): TId | null;
+    get state(): TTabsListState;
+    /**
+     * Se utiliza para hacer que el tab aparezca visible en el listado
+     *
+     * @param justThis Normalmente las tabs se abren de a una, pero si este parámetro se pasa en false, es posible abrir más de una a la vez.
+     */
+    openTab(tabId: TId, justThis?: boolean): void;
+}
+
+type TTab<AdditionalPropsType extends Record<string, unknown> = Record<string, unknown>> = {
+    addEvent?: (ev: 'onFocusTab', cb: (ev: {
+        stop: () => void;
+    }) => unknown) => unknown;
+    content: React__default.FunctionComponent<{
+        tab: TTab<AdditionalPropsType>;
+    }>;
+    icon?: TIconName | TIconType;
+    /**
+     * El id es importante ya que se utiliza por temas de accesibilidad. Es
+     * importante asegurarse de que sea único.
+     */
+    id: TId;
+    isClosable?: boolean;
+    isDisabled?: boolean;
+    /**
+     * Los tabs que estén marcados como fixed aparecerán al inicio del listado.
+     */
+    isFixed?: boolean;
+    isFocused?: boolean;
+    /**
+     * Si se marca como iconTab, se oculta el label y solamente se muestra el
+     * ícono.
+     */
+    isIconTab?: boolean;
+    isLoading?: boolean;
+    isOpen?: boolean;
+    /**
+     * Cuando se cierra un tab que tiene un método onBeforeClose, el mismo será
+     * llamado y deberá devolver un boolean o un string. Si devuelve true, se
+     * cierra. Si devuelve false, se muestra un cartel de confirmación genérico y
+     * si se devuelve un string, se muestra un cartel de confirmación con el
+     * string devuelto. En caso de que el usuario confirme el cuadro de diálogo,
+     * el tab será cerrado de todas formas. Es decir, no hay forma de evitar que
+     * el tab sea cerrado si el usuario decide continuar con la acción. Para
+     * evitar que un tab sea cerrado, debe pasarse isClosable=false
+     */
+    onBeforeClose?: () => boolean | string | Promise<boolean | string>;
+    /**
+     * Este callback será llamado cada vez que el tab sea abierto
+     */
+    onFocus?: (ev: TTab<AdditionalPropsType>) => unknown;
+    /**
+     * Es el texto que se va a mostrar en el tab
+     */
+    label: string;
+    labelRenderer?: TTabRenderer;
+    /**
+     * Se pueden pasar propiedades adicionales que serán recibidas en cada
+     * evento, de forma de poder compartir piezas de información útiles en las
+     * distintas partes de la aplicación.
+     */
+    tabAdditionalProps: AdditionalPropsType;
+    tabId: TId;
+    title?: string;
+};
+type TTabs<AdditionalPropsType extends Record<string, unknown> = Record<string, unknown>> = {
+    getHandler?: (handler: TabsController<AdditionalPropsType>) => unknown;
+    /**
+     * Este id se utiliza para asignar un prefijo a los ids de los distintos
+     * grupos de tabs, de forma que aún habiendo dos tabs con mismo id en
+     * distintos grupos, el id generado sea distinto.
+     */
+    id: TId;
+    /**
+     * Permite abrir varias tabs al mismo tiempo
+     */
+    isMultiple?: boolean;
+    /**
+     * Este evento es llamado cada vez que un tab fue cerrado. En caso de que el
+     * callback onRequestClose haya sido provisto, el orden de llamado es:
+     * onRequestClose === true ? onCloseTab : doNothing
+     */
+    onCloseTab?: (tab: TTab<AdditionalPropsType>) => unknown;
+    /**
+     * Este evento es llamado cada vez que un tab es abierto por acción del
+     * usuario, es decir, cuando se hace click en su label y éste es mostrado.
+     */
+    onOpenTab?: (tab: TTab<AdditionalPropsType>) => unknown;
+    /**
+     * Este callback es llamado cada vez que se hace click en el botón cerrar. Se
+     * utiliza para permitir o denegar el cierre del tab, por lo que debe
+     * retornar un boolean o una promesa de booleano. Es útil por ejemplo para
+     * abrir un cuadro de diálogo de confirmación antes de continuar.
+     */
+    onRequestClose?: (tab: TTab<AdditionalPropsType>) => boolean | Promise<boolean>;
+    orientation?: 'horizontal' | 'vertical';
+    /**
+     * Esta prop solo será tomada en cuenta al montar. Para agregar tabs luego,
+     * es necesario hacer uso de getHandler.
+     */
+    initialTabs?: TTab<AdditionalPropsType>[];
+};
+type TTabRenderer<AdditionalPropsType extends Record<string, unknown> = Record<string, unknown>> = (props: {
+    tab: TTab<AdditionalPropsType>;
+}) => React__default.ReactElement;
+type TTabsListState = {
+    focusedTab: TId | null;
+    openTabs: TId[];
+    tabs: TId[];
+    timestamp: number;
+};
+
+declare const DefaultTabsLabelRenderer: TTabRenderer;
+
+declare const TabsContent: (props: Omit<BoxProps, 'children'>) => React__default.JSX.Element;
+
+declare const Tabs: <AdditionalPropsType extends Record<string, unknown> = Record<string, unknown>>({ id, onCloseTab, onOpenTab, onRequestClose, className, orientation, getHandler, initialTabs, isMultiple, onKeyDown, ...props }: TTabs<AdditionalPropsType> & Omit<BoxProps, "id" | "role" | "as">, ref: React__default.ForwardedRef<HTMLDivElement>) => React__default.JSX.Element;
+
+type TOpenModal = Pick<TModal, 'NavBar' | 'Portal' | 'children' | 'className' | 'hideCloseButton' | 'initialFocusGetter' | 'initialFocusConfiguration' | 'maxWidth' | 'noHeader' | 'onExited' | 'shouldCloseOnEsc' | 'shouldCloseOnOverlayClick' | 'size' | 'stretch' | 'title' | 'variant'> & {
+    id?: string;
+};
+
+declare class ApiaUtilModalHandler {
+    private id;
+    private modals;
+    constructor(id: string, modals: ApiaUtilModals);
+    close(): void;
+}
+declare class ApiaUtilModals extends EventEmitter<{
+    close: string;
+    closeAll: boolean;
+    open: TOpenModal;
+}> {
+    #private;
+    constructor();
+    open(props: TOpenModal): ApiaUtilModalHandler;
+    Component: () => React$1.JSX.Element;
+}
+
+declare class ApiaUtilNotifications {
+    close: (id: TNotificationId | INotification) => void;
+    closeAll: () => void;
+    notify: (notification: TDispatchedNotification) => void;
+    useSelector: (selector: TNotificationSelector<any>) => INotification<_apia_notifications.TNotificationType>[];
+    Component: () => React$1.JSX.Element;
+}
+
+declare global {
+    interface Window {
+        TAB_ID: string;
+    }
+    interface HTMLIFrameElement {
+        tabId: TId;
+    }
+}
+declare class ApiaUtilCurrentTab {
+    /**
+     * Este método se usa para establecer un callback que será llamado al momento
+     * de cerrar la pestaña. Este callback podrá devolver false indicando que hay
+     * cambios no guardados, en cuyo caso el sistema alertará al usuario acerca de
+     * ello con un cartel de confirmación.
+     */
+    canClose(cb: () => boolean): void;
+    changeTitle(newTitle: string): void;
+    /**
+     * El parámetro force sirve para las situaciones en las que el tab podría
+     * preguntar si se desean perder los cambios. En caso de que se pase en true,
+     * no se preguntará nada y se cerrará la pestaña.
+     */
+    close(force?: boolean): void;
+    getId(): TId;
+    getProps(): _apia_components.TTab<Record<string, unknown>>;
+    udpate(props: Partial<Partial<TTab>>): void;
+}
+
+declare class ApiaUtilTabsController {
+    currentTab: ApiaUtilCurrentTab;
+    closeTab(tabId: string, force?: boolean): void;
+    getHandler(): _apia_components.TabsController<Record<string, unknown>, _apia_components.TTab<Record<string, unknown>>>;
+    /**
+     * openApiaTab y openTab son sinónimos.
+     */
+    openTab(title: string, url: string): void;
+}
+
+type TApiaUtilConfirm = Pick<IConfirm, 'additionalButtons' | 'additionalButtonsOnRight' | 'cancelButtonText' | 'children' | 'className' | 'confirmButtonText' | 'confirmButtonVariant' | 'contentRef' | 'hideCancelButton' | 'hideConfirmButton' | 'title' | 'variant'>;
+type TApiaUtilInnerConfirm = TApiaUtilConfirm & {
+    id: string;
+} & Pick<IConfirm, 'onCancel' | 'onConfirm'>;
+type TAlert = {
+    children: ReactNode;
+    title: string;
+};
+type TApiaUtilInnerAlert = TAlert & {
+    onClose: () => unknown;
+    id: string;
+};
+declare class ApiaUtilDialogs extends EventEmitter<{
+    alert: TApiaUtilInnerAlert;
+    confirm: TApiaUtilInnerConfirm;
+}> {
+    #private;
+    alert(props: TAlert): Promise<void>;
+    confirm(props: TApiaUtilConfirm): Promise<boolean>;
+    Component: () => React$1.JSX.Element;
+}
+
+declare class ApiaUtilParsers {
+    addThousSeparator(nStr: string | number): string;
+    apiaNumber(pValue: number): number | string;
+    jsNumber(value: string): number | string;
+    parseBool(val: string): boolean;
+}
+
 type TAttachToElement = (() => HTMLElement) | RefObject<HTMLElement>;
 type TPreferredOrientationX = 'left' | 'right';
 type TPreferredOrientationY = 'top' | 'bottom';
@@ -1108,12 +1373,12 @@ type TTooltip = {
      * Indica si el tooltip se cierra al desplazar el puntero del mouse fuera del
      * tooltip. Valor por defecto: true.
      */
-    closeOnMouseLeaveTooltip?: boolean;
+    closeOnMouseLeaveTooltip?: boolean | ((ev: MouseEvent) => boolean);
     /**
      * Indica si el tooltip se cierra al desplazar el puntero del mouse fuera del
      * elemento al que el tooltip está anclado. Valor por defecto: true.
      */
-    closeOnMouseLeaveAttachedElement?: boolean;
+    closeOnMouseLeaveAttachedElement?: boolean | ((ev: MouseEvent) => boolean);
     /**
      * Indica si el tooltip se cierra al hacerle click. Valor por defecto: false.
      */
@@ -1122,12 +1387,16 @@ type TTooltip = {
      * Indica si el tooltip se cierra al hacer click fuera de él. Valor por
      * defecto: true.
      */
-    closeOnClickOut?: boolean;
+    closeOnClickOut?: boolean | ((ev: MouseEvent) => boolean);
     /**
      * Indica si el tooltip se cierra al hacer scroll en un elemento externo al
      * tooltip. Valor por defecto: true.
      */
     closeOnScrollOut?: boolean;
+    /**
+     * Por defecto está en true. Cierra los demás tooltips al abrirse
+     */
+    closeOthers?: boolean;
     /**
      * Permite determinar sobre qué elemento se abre el tooltip
      */
@@ -1143,6 +1412,7 @@ type TTooltip = {
      * parámetros preferredOrientationX y preferredOrientationY.
      */
     attachToElementAnchorPoint?: TAttachToElementAnchorPoint;
+    attachToMousePosition?: boolean;
     /**
      * Permite indicar que el tooltip se abrirá en un punto específico. En caso
      * de no indicar anchorPoint ni attachToElement se abrirá en {0,0}
@@ -1189,18 +1459,79 @@ type TTooltip = {
     variant?: string;
 };
 
-type TTooltipEvents = {
-    open: TTooltip;
-    close: void;
+declare class ApiaUtilTooltip {
+    props: TTooltip;
+    id: string;
+    constructor(props: TTooltip);
+    close(): void;
+}
+
+declare class AutomaticTooltip {
+    #private;
+    ref: (el: HTMLElement | null) => void;
+    constructor(tooltip?: Partial<TTooltip> | null);
+    update: (tooltip: Partial<TTooltip>) => void;
+}
+
+declare class ApiaUtilTooltips extends EventEmitter<{
+    changedList: ApiaUtilTooltip[];
+}> {
+    #private;
+    tooltips: ApiaUtilTooltip[];
+    constructor();
+    /**
+     * Permite crear un tooltip que se abrirá automáticamente al estar parado
+     * sobre un elemento durante 300ms
+     */
+    useHover: (tooltip?: Partial<TTooltip>) => AutomaticTooltip;
+    close: (id: string) => void;
+    closeAll: () => void;
+    open: (tooltip: TTooltip) => ApiaUtilTooltip;
+    Component: () => React$1.JSX.Element;
+}
+
+type TSubmenu = {
+    label: string;
+    items: TMenuItems;
 };
-declare const tooltipsHandler: <K extends keyof TTooltipEvents>(ev: K, args: TTooltipEvents[K]) => void;
-declare const TooltipsProvider: React$1.FC<object>;
-declare function useTooltip(tooltip?: TTooltip): {
-    close: () => void;
-    open: (otherProps?: Partial<TTooltip>) => void;
-    toggle: (otherProps?: Partial<TTooltip>) => void;
-};
+type TMenuItem = (MenuItemProps & {
+    key: string;
+}) | 'separator' | TSubmenu;
+type TMenuItems = TMenuItem[];
+declare class ApiaUtilMenu extends EventEmitter<{
+    toggle: boolean;
+}> {
+    #private;
+    open: ({ menuProps, items, }: {
+        menuProps: ControlledMenuProps;
+        items: TMenuItems;
+    }) => void;
+    Component: () => React$1.JSX.Element;
+}
 
-declare const Tooltip: ({ anchorPoint, attachToElement, attachToElementAnchorPoint, children, className, closeOnClick, closeOnClickOut, closeOnEscape, closeOnMouseLeaveTooltip, closeOnMouseLeaveAttachedElement, closeOnScrollOut, minSize, onClose, preferredOrientationX, preferredOrientationY, preferredSize, variant, }: TTooltip) => React$1.JSX.Element;
+declare class ApiaUtilMouse extends EventEmitter<{
+    updatePosition: {
+        x: number;
+        y: number;
+    };
+}> {
+    x: number;
+    y: number;
+    constructor();
+}
+
+declare class ApiaUtil {
+    #private;
+    constructor();
+    dialogs: ApiaUtilDialogs;
+    menu: ApiaUtilMenu;
+    modals: ApiaUtilModals;
+    mouse: ApiaUtilMouse;
+    notifications: ApiaUtilNotifications;
+    parsers: ApiaUtilParsers;
+    tabs: ApiaUtilTabsController;
+    tooltips: ApiaUtilTooltips;
+    Component: () => React$1.JSX.Element;
+}
 
-export { Accordion, AccordionContext, AccordionItem, AccordionItemButton, AccordionItemContent, AccordionItemContext, AlertModal, ApiaFilter, AutoEllipsis, BaseButton, CalendarModal, Captcha, Checkbox, CollapsiblePanel, Confirm, ConfirmModal, DateInput, DefaultAccordionItemButton, DefaultIconRenderer, DialogButtonBar, FieldErrorMessage, FieldLabel, IAccordionItemButton, IAccordionItemProps, IAccordionProps, IAlert, IApiaFilter, ICalendarModal, IConfirm, IDialogButtonBar, IDialogHeader, IField, IFieldErrorMessage, IIconInput, IOverlay, IRequiredMark, IResponsiveComponent, ISimpleButton, IconButton, IconInput, IconsList, LinearLoader, Listbox, ListboxItem, LoaderSpinner, Modal, NumberInput, Overlay, ProgressBar, RequiredMark, ScreenLock, SimpleButton, TAccordionHandler, TAccordionItemButton, TApiaButtonType, TApiaIconButton, TCheckbox, TDateProps, TFieldLabel, TIcon, TIconButton, TIconRenderer, TIconSize, TIconsList, TListbox, TModal, TModalSize, TNumberInput, TNumberInputChangeEvent, TOnClickNode, TOnConfirmSelection, TOnSelectionChange, TTool, TTooltip, TTooltipEvents, TUseModalConfiguration, Toolbar, ToolbarController, ToolbarItem, Tooltip, TooltipsProvider, WaiTypeAhead, getFieldErrorStyles, getFieldTouchedStyles, importComponent, makeResponsiveComponent, parseNumberInputValueToNumber, parseNumberValueToNumberInput, tooltipsHandler, useAccordionContext, useModal, useModalContext, useOtherTagButton, useTooltip };
+export { Accordion, AccordionContext, AccordionItem, AccordionItemButton, AccordionItemContent, AccordionItemContext, AlertModal, ApiaChat, ApiaFilter, ApiaUtil, ApiaUtilModalHandler, ApiaUtilTooltip, AutoEllipsis, BaseButton, CalendarModal, Captcha, Checkbox, CollapsiblePanel, Confirm, ConfirmModal, DateInput, DefaultAccordionItemButton, DefaultIconRenderer, DefaultTabsLabelRenderer, DialogButtonBar, FieldErrorMessage, FieldLabel, IAccordionItemButton, IAccordionItemProps, IAccordionProps, IAlert, IApiaFilter, ICalendarModal, IConfirm, IDialogButtonBar, IDialogHeader, IField, IFieldErrorMessage, IIconInput, IOverlay, IRequiredMark, IResponsiveComponent, ISimpleButton, IconButton, IconInput, IconsList, LinearLoader, Listbox, ListboxItem, LoaderSpinner, Modal, NumberInput, Overlay, ProgressBar, RequiredMark, ScreenLock, SimpleButton, TAccordionHandler, TAccordionItemButton, TApiaButtonType, TApiaIconButton, TCheckbox, TDateProps, TFieldLabel, TIcon, TIconButton, TIconRenderer, TIconSize, TIconsList, TListbox, TMenuItem, TModal, TModalSize, TNumberInput, TNumberInputChangeEvent, TOnClickNode, TOnConfirmSelection, TOnSelectionChange, TOpenModal, TSubmenu, TTab, TTabRenderer, TTool, TToolDefinition, TUseModalConfiguration, Tabs, TabsContent, TabsController, TabsList, Toolbar, ToolbarController, ToolbarItem, WaiTypeAhead, getFieldErrorStyles, getFieldTouchedStyles, importComponent, makeResponsiveComponent, parseNumberInputValueToNumber, parseNumberValueToNumberInput, useAccordionContext, useModal, useModalContext, useOtherTagButton };