@apia/components 4.0.8 → 4.0.11

package/dist/index.d.ts

@@ -11,7 +11,7 @@ export { INotification, TDispatchedNotification } from '@apia/notifications';
 import { MenuItemProps, ControlledMenuProps } from '@szhsin/react-menu';
 export { ControlledMenuProps, MenuItemProps } from '@szhsin/react-menu';
 
-type TModalSize = 'editGrid' | 'sm' | 'md' | 'md-fixed' | 'lg' | 'lg-fixed' | 'xl' | 'xl-fixed' | 'xxl' | 'xxxl' | 'xxxl-fixed' | 'flex' | 'cal' | 'finder';
+type TModalSize = 'editGrid' | 'sm' | 'md' | 'md-fixed' | 'lg' | 'lg-fixed' | 'xl' | 'xl-fixed' | 'xxl' | 'xxxl' | 'xxxl-fixed' | 'flex' | 'cal' | 'finder' | 'fileModal';
 type TApiaButtonType = 'primary' | 'primary-sm' | 'secondary' | 'light-secondary' | 'secondary-sm' | 'danger' | 'danger-sm' | 'outline' | 'outline-sm' | 'warning' | 'warning-sm' | 'link';
 
 interface IDialogHeader {
@@ -236,6 +236,7 @@ declare class ApiaUtilModalHandler {
 declare class ApiaUtilModals {
     #private;
     constructor();
+    close(id: string): void;
     open(props: TOpenModal): ApiaUtilModalHandler;
     Component: () => React$1.JSX.Element;
 }
@@ -264,6 +265,7 @@ declare class Tab<TabType extends TTab = TTab> {
      */
     close(force?: boolean): Promise<boolean>;
     open(): void;
+    toggle(isShown?: boolean): void;
 }
 declare class TabsController<TabType extends TTab = TTab> {
     #private;
@@ -281,16 +283,18 @@ declare class TabsController<TabType extends TTab = TTab> {
     /**
      * Obviamente agrega un tab al listado de tabs
      */
-    append(tab: TabType): void;
+    append(tab: TabType, closeOthers?: boolean): void;
     closeAll(closeFixedTabsAsWell?: boolean, force?: boolean): Promise<void>;
     closeOpenTab(force?: boolean): void;
     closeToRight(targetId: string, force?: boolean): Promise<void>;
     closeToLeft(targetId: string, force?: boolean): Promise<void>;
     closeOthers(targetId: string, force?: boolean): Promise<void>;
     closeTab(tabId: string, force?: boolean): Promise<boolean>;
+    private checkAtLeastOneOpen;
+    toggleTab(tabId: string, isShown?: boolean): Promise<void>;
     focusNextTab(): Tab<TabType> | null;
     focusPreviousTab(): Tab<TabType> | null;
-    focusTab(tabId: string): void;
+    focusTab(tabId: string, closeOthers?: boolean): void;
     getTabElement(tabId: string): Element | null;
     handleKeyDown(ev: React__default.KeyboardEvent): void;
     openNextTab(): Tab<TabType> | null;
@@ -298,7 +302,7 @@ declare class TabsController<TabType extends TTab = TTab> {
     /**
      * Se utiliza para hacer que el tab aparezca visible en el listado
      */
-    openTab(tabId: string): void;
+    openTab(tabId: string, closeOthers?: boolean): void;
 }
 
 type TOrientation = 'horizontal' | 'vertical';
@@ -306,6 +310,7 @@ type TabsControllerProps<TabType extends TTab> = {
     id: string;
     initialTabs?: TabType[];
     getController?: (controller: TabsController) => unknown;
+    initialState?: Pick<Partial<TTabsListState<TabType>>, 'isMultiple'>;
     onCloseTab?: (tan: Tab) => void;
     orientation: TOrientation;
 };
@@ -313,6 +318,7 @@ type TTab = {
     addEvent?: (ev: 'onFocusTab', cb: (ev: {
         stop: () => void;
     }) => unknown) => unknown;
+    asAccordion?: boolean;
     content: React__default.FunctionComponent<{
         tab: Tab;
     }>;
@@ -374,7 +380,13 @@ type TTabLabelRenderer = (props: {
     tab: Tab<TTab>;
 }) => React__default.ReactElement;
 type TTabsListState<TabType extends TTab> = {
-    openTabs: Set<Tab<TabType>>;
+    isMultiple: boolean;
+    openTabsHistory: Set<Tab<TabType>>;
+    /**
+     * If this property is true, then it could never happen that all tabs are closed.
+     * The TabsController will open the first available tab when no tab is open.
+     */
+    showAtLeastOneTab: boolean;
     tabs: Map<string, Tab<TabType>>;
     timestamp: number;
 };
@@ -385,7 +397,9 @@ declare const TabsContent: ((props: Omit<BoxProps, 'children'>) => React$1.JSX.E
     displayName: string;
 };
 
-declare const Tabs: ({ id, getController, initialTabs, orientation, ...props }: TabsControllerProps<TTab> & Omit<BoxProps, 'id' | 'as' | 'role'>, ref: React__default.ForwardedRef<HTMLDivElement>) => React__default.JSX.Element | null;
+declare function useTabsContext(): TabsController<TTab> | null;
+
+declare const Tabs: ({ id, getController, initialTabs, orientation, initialState, ...props }: TabsControllerProps<TTab> & Omit<BoxProps, 'id' | 'as' | 'role'>, ref: React__default.ForwardedRef<HTMLDivElement>) => React__default.JSX.Element | null;
 
 declare class ApiaUtilTabsController {
     get currentTab(): Tab<TTab>;
@@ -626,6 +640,7 @@ type TSubmenu = {
     items: TMenuItems;
 };
 type TMenuItem = (MenuItemProps & {
+    icon?: TIconName;
     key: string;
 }) | 'separator' | TSubmenu;
 type TMenuItems = TMenuItem[];
@@ -751,7 +766,7 @@ type AutocompleteProps = {
      * Si este flag es true, la búsqueda se realiza con .toLowerCase() en el valor y en la cadena de búsqueda.
      */
     caseInsensitive?: boolean;
-    onChange?: (value: string, controller: AutocompleteController) => unknown;
+    onChange?: (value: string, controller: AutocompleteController) => void | Promise<boolean>;
     /**
      * Si se pasa una función de búsqueda, cuando el usuario busque se llamará a esta función para determinar qué opciones deberán mostrarse. Las opciones devueltas deberán tener filtered !== true para mostrarse.
      *
@@ -778,6 +793,7 @@ type AutocompleteState = {
     loading: boolean;
     showValue: string;
     value: string;
+    width: number;
 };
 /**
  * El componente buscará dentro de las opciones disponibles cuando el usuario realice una búsqueda en el cuadro de texto. Para ello, compara cada opción contra str según:
@@ -826,7 +842,7 @@ declare class AutocompleteController {
     toggleOpen(): void;
     search(str: string): void;
     selectFocused(): void;
-    setValue(value: string): void;
+    setValue(value: string): Promise<void>;
     tooltipRef: ApiaUtilTooltip | null;
 }
 
@@ -1240,6 +1256,7 @@ interface ICollapsiblePanel {
     label: React.ReactNode;
     rememberCollapsedState?: boolean;
     titleButtons?: React.ReactNode;
+    collapseIconToRight?: boolean;
 }
 
 declare const CollapsiblePanel: React__default.ForwardRefExoticComponent<ICollapsiblePanel & React__default.RefAttributes<HTMLDivElement>>;
@@ -1365,6 +1382,10 @@ declare const LoaderSpinner: ((props: {
     displayName: string;
 };
 
+declare const ListSkeletonLoader: ({ items }: {
+    items?: number | undefined;
+}) => React$1.JSX.Element;
+
 type TModalContext = {
     changeTitle: (newTitle: string) => void;
     close: () => unknown;
@@ -1782,5 +1803,388 @@ declare const SortableList: ((props: {
     displayName: string;
 };
 
-export { Accordion, AccordionContext, AccordionItem, AccordionItemButton, AccordionItemContent, AccordionItemContext, AlertModal, ApiaFilter, ApiaUtil, ApiaUtilModalHandler, ApiaUtilTooltip, AutoEllipsis, Autocomplete, type AutocompleteCmpProps, AutocompleteController, type AutocompleteOption, type AutocompleteProps, BaseButton, CalendarModal, Captcha, Checkbox, CollapsiblePanel, Confirm, ConfirmModal, ContainerWithHeader, DateInput, DefaultAccordionItemButton, DefaultIconRenderer, DefaultTabsLabelRenderer, DialogButtonBar, FieldErrorMessage, FieldLabel, type IAccordionItemButton, type IAccordionItemProps, type IAccordionProps, type IAlert, type IApiaFilter, type ICalendarModal, type IConfirm, type IDialogButtonBar, type IDialogHeader, type IField, type IFieldErrorMessage, type IIconInput, type IOverlay, type IRequiredMark, type IResponsiveComponent, type ISimpleButton, IconButton, IconInput, IconsList, LabelBox, LinearLoader, Listbox, ListboxItem, LoaderSpinner, Modal, NumberInput, Overlay, ProgressBar, RequiredMark, ScreenLocker, SimpleButton, SortableList, SortableListItem, type TAccordionHandler, type TAccordionItemButton, type TApiaButtonType, type TApiaIconButton, type TCheckbox, type TDateProps, type TFieldLabel, type TGetTabsController, type TIcon, type TIconButton, type TIconRenderer, type TIconSize, type TIconsList, type TListbox, type TMenuItem, type TModal, type TModalSize, type TNumberInput, type TNumberInputChangeEvent, type TOnClickNode, type TOnConfirmSelection, type TOnSelectionChange, type TOpenModal, type TSubmenu, type TTab, type TTabLabelRenderer as TTabRenderer, type TToolbarIconButton as TToolDefinition, type TTooltip, type TUseModalConfiguration, Tab, Tabs, TabsContent, TabsController, TabsList, Toolbar, ToolbarController, ToolbarIconButton, ToolbarInput, ToolbarSelect, ToolbarSeparator, ToolbarTextButton, UnstyledSortableList, WaiTypeAhead, getFieldErrorStyles, getFieldTouchedStyles, importComponent, makeResponsiveComponent, parseNumberInputValueToNumber, parseNumberValueToNumberInput, useAccordionContext, useModal, useModalContext, useOtherTagButton };
+declare class TableParameter extends Parameter<ITableParameterProps> {
+    constructor(params: ITableParameterProps);
+}
+
+declare class ParametersGroup implements ParameterObject {
+    component?: string;
+    name: string;
+    parameters: Record<string, TableParameter>;
+    selection: Set<number>;
+    constructor(params: {
+        name: string;
+        parameters: Record<string, IParameter>;
+        component?: string;
+    });
+    removeAll(): void;
+    asPayloadElement(): Record<string, any>;
+}
+
+declare class FilterDTO<T extends IFilterDTOState = IFilterDTOState> {
+    type: string;
+    state: T;
+    isTd: boolean;
+    ref: HTMLElement | null;
+    constructor(params: T, filterType?: TFilterType, isTd?: boolean);
+    private isCheckBox;
+    getStoreValue(): TFilterValue | undefined;
+    getValue(): TFilterValue | undefined;
+    getValueTypeLabel(): string;
+    setMultipleValue(value: string | Date | number, idx?: number): void;
+    setValue(value: string | number | Date): void;
+    private resolveMultipleValueInPayload;
+    asPayloadElement(): TFilterPayload;
+    asFilterValue(): IFilterValue | null;
+    getInputType(): "text" | "date" | "number";
+    removeMultipleValue(value: TFilterValue): void;
+    isUndefined(value: TFilterValue): boolean;
+    Component: (({ renderers, multipleInputBoxProps, }: {
+        renderers?: {
+            input?: FC<InputProps & {
+                label?: string | undefined;
+            }> | undefined;
+        } | undefined;
+        multipleInputBoxProps?: BoxProps | undefined;
+    }) => React$1.JSX.Element) & {
+        displayName: string;
+    };
+    getLabel(): string;
+    validate(): boolean;
+    clear(): void;
+    hasFilledValue(): boolean | TFilterValue | undefined;
+}
+
+declare class FilterConditionDTO {
+    state: IFilterCondition;
+    parent: FilterDTO;
+    private allowedOps;
+    private static opLabels;
+    constructor(props: IFilterCondition, type: TFilterValueType, parent: FilterDTO);
+    getLabelByFilterOp(): {
+        text: string;
+        title: string;
+    };
+    getOpMap(): Record<TFilterOp, {
+        text: string;
+        title: string;
+    }>;
+    setOp(op: TFilterOp): void;
+    Component: (() => React$1.JSX.Element) & {
+        displayName: string;
+    };
+}
+
+type ParameterPossibleValue = {
+    text: string;
+    value: string;
+};
+interface ParameterObject extends Payload {
+}
+interface Payload {
+    asPayloadElement(): any;
+}
+type TParameterType = 'input' | 'check' | 'combo' | 'group' | 'hidden' | 'label' | 'text_area' | 'mdl_attribute' | 'mdl_doc_type' | 'mdl_entity' | 'mdl_metadata' | 'mdl_ai_connector' | 'mdl_ai_embeddings_model' | 'mdl_ai_completion_model';
+type TVisualizationType = 'I' | 'C';
+type TFilterOp = 'EQUAL' | 'STARTS_WITH' | 'ENDS_WITH' | 'CONTAINS' | 'DISTINCT' | 'NOT_STARTS_WITH' | 'NOT_ENDS_WITH' | 'NOT_CONTAINS' | 'NOT_NULL' | 'NULL' | 'LOWER_THAN' | 'LOWER_OR_EQUAL_THAN' | 'GREATER_THAN' | 'GREATER_OR_EQUAL_THAN' | 'IN' | 'NOT_IN' | 'RANGE';
+type TFilterType = 'U' | 'F';
+type TFilterValueType = 'S' | 'D' | 'N';
+interface IFilterValue {
+    condition: TFilterOp;
+    value?: string | number | Date;
+    type: TFilterValueType;
+}
+type TFilterPayload = Omit<IFilterDTOState, 'filterCondition'> & {
+    filterCondition: TFilterOp;
+};
+type TFilterValue = string | number | Date;
+interface IFilterDTOState {
+    visualizationType: TVisualizationType;
+    filterCondition: FilterConditionDTO;
+    value?: TFilterValue;
+    multipleValue?: TFilterValue[];
+    name: string;
+    title: string;
+    semSerDatSouid?: number;
+    valueType: TFilterValueType;
+    refId: number;
+    hasFixedType: boolean;
+    id: number;
+    filterType: TFilterType;
+    validationError?: string;
+}
+interface IFilterCondition {
+    label?: string;
+    op: TFilterOp;
+}
+interface IParameter {
+    component?: string;
+    description: string;
+    name: string;
+    possibleValues?: ParameterPossibleValue | ParameterPossibleValue[];
+    required: boolean;
+    title: string;
+    type: TParameterType;
+    values: string[];
+}
+interface IParametersGroup {
+    name: string;
+    parameters: Record<string, IParameter>;
+}
+interface ITableParameterProps extends IParameter {
+    cssProps: Record<'TH', TCssProps>;
+}
+type TCssProps = {
+    backgroundColor?: string;
+    width?: string;
+    color?: string;
+};
+type ParameterType = 'input' | 'check' | 'combo' | 'custom';
+type ParameterRendererProps = {
+    index?: number;
+    parameter: Parameter;
+};
+type ParameterRenderer = FC<ParameterRendererProps>;
+type ParametersGroupRenderer = FC<{
+    group: ParametersGroup;
+}>;
+type ParametersDefinition = Record<string, IParameter>;
+
+declare class Parameter<T extends IParameter = IParameter> implements ParameterObject {
+    state: T & {
+        validationError?: string;
+    };
+    constructor(params: T);
+    clear(): void;
+    getValues(): string[];
+    private removeEmptyValues;
+    setValue(value: string, index?: number): void;
+    addValue(value: string): void;
+    setValues(values: string[], index?: number): void;
+    removeValue(value: string): void;
+    asPayloadElement(): string[] | null;
+    includes(value: string): boolean;
+    validate(): boolean;
+}
+
+declare const ParameterRender: (({ index, omitLabel, parameter, }: {
+    index: number;
+    omitLabel?: boolean | undefined;
+    parameter: Parameter;
+}) => string | React$1.JSX.Element | null) & {
+    displayName: string;
+};
+
+type ParametersMap = Record<string, ParameterObject>;
+declare const Parameters: (({ label, ownerName, parameters, }: {
+    label?: ReactNode;
+    ownerName?: string | undefined;
+    parameters?: ParametersMap | undefined;
+}) => React$1.JSX.Element | undefined) & {
+    displayName: string;
+};
+
+declare function isParametersGroup(param: IParameter | IParametersGroup): param is IParametersGroup;
+declare class ParametersStore {
+    private static instance;
+    static getInstance(): ParametersStore;
+    private parameters;
+    private constructor();
+    /**
+     * Takes the string generated by the ParametersStore in the server
+     * and assigns it to the current parameters
+     */
+    fromResponse(owner: string, response: string): void;
+    static getParametersFromResponse(response: string): Record<string, ParameterObject>;
+    static getParametersFromObject(response: Record<string, IParameter | IParametersGroup>): Record<string, ParameterObject>;
+    /**
+     * Returns the parameters for a given owner name.
+     */
+    getParameters(ownerName: string): Record<string, ParameterObject>;
+    /**
+     * Returns an object that can be used to submit the parameters to the server
+     * in a format that the ParametersStore in the server expects.
+     */
+    getSubmitValue(owner: string): string;
+    /**
+     * Resets the parameters store.
+     */
+    reset(): void;
+    static validate(parameters: Record<string, ParameterObject>): boolean;
+}
+
+declare const ParametersTable: ParametersGroupRenderer;
+
+declare class FiltersStore {
+    private static instance;
+    available: Record<string, FilterDTO<IFilterDTOState>>;
+    fixed: Record<string, FilterDTO<IFilterDTOState>>;
+    dynamic: Record<string, FilterDTO<IFilterDTOState>>;
+    private constructor();
+    /**
+     * Takes the string generated by the ParametersStore in the server
+     * and assigns it to the current filters
+     */
+    static getFiltersFromResponse(response: string, from?: 'fixed' | 'dynamic' | 'available'): Record<string, FilterDTO<IFilterDTOState>>;
+    static setFiltersFromObject(response: {
+        available: Record<string, FilterDTO<IFilterDTOState>>;
+        fixed: Record<string, FilterDTO<IFilterDTOState>>;
+        dynamic: Record<string, FilterDTO<IFilterDTOState>>;
+    }): void;
+    static getFiltersFromObject(response: Record<string, FilterDTO>): Record<string, FilterDTO<IFilterDTOState>>;
+    /**
+     * Returns the filters for a given name.
+     */
+    static getFilter(name: string, type?: TFilterType): FilterDTO<IFilterDTOState>;
+    /**
+     * Set filter into store given owner name
+     */
+    static setFilter(value: FilterDTO<IFilterDTOState>, type?: TFilterType, replace?: boolean): void;
+    /**
+     * Remove into store given owner name
+     */
+    static removeFilter(x: FilterDTO<IFilterDTOState>, type?: TFilterType): void;
+    /**
+     * Resets the parameters store.
+     */
+    static reset(): void;
+    static size(): number;
+    static setFilters(filters: Record<string, FilterDTO<IFilterDTOState>>, type?: TFilterType): void;
+    static filters(type?: TFilterType): Record<string, FilterDTO<IFilterDTOState>>;
+    static parseFiltersAsFilterValue(values: FilterDTO[]): Record<string, IFilterValue>;
+    static getFiltersAsFilterValue(type?: TFilterType): Record<string, IFilterValue>;
+    static getAllFilters(includeAvailable?: boolean): FilterDTO<IFilterDTOState>[];
+    static values(type?: TFilterType): FilterDTO<IFilterDTOState>[];
+    static entries(type?: TFilterType): [string, FilterDTO<IFilterDTOState>][];
+    static keys(type?: TFilterType): string[];
+    static getFiltersById(id: number): Promise<Record<string, FilterDTO<IFilterDTOState>>>;
+    static asPayloadElement(): TFilterPayload[];
+    static validate(): boolean;
+}
+
+interface IReplacer<ContentType, ReturnType> {
+    /**
+     * This regExp will be used by the templater to determine if it should call
+     * the parse function or not.
+     */
+    match: RegExp;
+    /**
+     * The parse method should take the RegExpMatchArray and the value of the
+     * original attribute and return whatever the replacer is intended for.
+     * */
+    parse: (result: RegExpMatchArray, value: ContentType) => ReturnType;
+}
+/**
+ * The Attribute parsers are intended to parse some attributes whose names
+ * match in one of the following array items' match property. If the match
+ * property matches the attribute name, the parse function will be called with
+ * the result of the match and the original Value passed to that attribute.
+ * This way, it can be modified not only the name but the value as well.
+ */
+declare const AttributeParsers: IReplacer<string, {
+    newName: string;
+    newValue: unknown;
+}[] | null>[];
+
+interface IAlterDefaultOptions {
+    /**
+     * It's possible to replace some attributes and parse the value with
+     * a specific replacement function you provide, in order to provide
+     * custom behavior to the template.
+     *
+     * @example
+     *
+     * attributeParsers: [
+     *  {
+     *    match: /^data-say-([\w]+)$/,
+     *    parse: (matchResult, originalValue) => ({ newName: 'onLoad', newValue:
+     *    () => alert(matchResult[1]) })
+     *  }
+     * ]
+     */
+    attributeParsers?: typeof AttributeParsers;
+    /**
+     * It's possible to replace some attributes with this property. Each
+     * attribute will be searched in the dictionary and if it's found,
+     * then it will be replaced with the value which pairs that key.
+     *
+     * @example
+     *
+     * attributesReplacement: {
+     *  class: 'className' // Very common in react, it's implemented by default
+     * }
+     */
+    attributesReplacement?: Record<string, string>;
+    /**
+     * With this parameter the templater shouts to the console the important
+     * events it goes through.
+     */
+    debug?: boolean;
+    /**
+     * It's possible to filter some attributes passing an array of undesired
+     * values
+     *
+     * @example
+     *
+     * filterAttributes: ['data-dangerous']
+     */
+    filterAttributes?: string[];
+    /**
+     * WARNING: If
+     *
+     * The props object can be accessed from the template, in this way,
+     * it's possible to pass any kind of javascript data to be used
+     * when generating the template's structure.
+     */
+    props?: Record<string, unknown>;
+}
+type TTemplateParser = (document: Document) => void;
+declare global {
+    interface Window {
+        onPreParseTemplate: TTemplateParser;
+    }
+}
+declare class Templater {
+    #private;
+    private static _instance;
+    static get instance(): Templater;
+    isDownloadingTemplate: boolean;
+    templates: Record<string, string>;
+    private constructor();
+    private initTemplates;
+    /**
+     * This method parses the string looking for <script class="context"> tags
+     * and placeholders, run that code and make the replacements in the template
+     * string.
+     *
+     * @param content The HTML string
+     */
+    private parseContent;
+    /**
+     * This method takes a template from the HTML Document and parses it to React
+     * Components.
+     *
+     * @param name The name of the template you are looking for, it must be specified as
+     * data-template="name" in the HTML element you want to use as template.
+     * @param options This argument allows you to alter the behavior of the parser, for example
+     * to replace some attribute names, parse some attributes with a custom parser function or
+     * discard some attributes. See the type IAlterDefaultOptions to get more information
+     *
+     * @returns A ReactComponent as the result of the parsed HTML template.
+     */
+    getTemplateByName(name: string, options?: IAlterDefaultOptions): string | JSX.Element | JSX.Element[];
+    /**
+     * This method parses a string in HTML to React Components.
+     *
+     * @param content The HTML string to parse to React Components
+     * @param options This argument allows you to alter the behavior of the parser, for example
+     * to replace some attribute names, parse some attributes with a custom parser function or
+     * discard some attributes. See the type IAlterDefaultOptions to get more information
+     *
+     * @returns A ReactComponent as the result of the parsed HTML template.
+     */
+    parseString(content: string, options?: IAlterDefaultOptions): string | JSX.Element | JSX.Element[];
+}
+
+export { Accordion, AccordionContext, AccordionItem, AccordionItemButton, AccordionItemContent, AccordionItemContext, AlertModal, ApiaFilter, ApiaUtil, ApiaUtilModalHandler, ApiaUtilTooltip, AutoEllipsis, Autocomplete, type AutocompleteCmpProps, AutocompleteController, type AutocompleteOption, type AutocompleteProps, BaseButton, CalendarModal, Captcha, Checkbox, CollapsiblePanel, Confirm, ConfirmModal, ContainerWithHeader, DateInput, DefaultAccordionItemButton, DefaultIconRenderer, DefaultTabsLabelRenderer, DialogButtonBar, FieldErrorMessage, FieldLabel, FilterConditionDTO, FilterDTO, FiltersStore, type IAccordionItemButton, type IAccordionItemProps, type IAccordionProps, type IAlert, type IApiaFilter, type ICalendarModal, type IConfirm, type IDialogButtonBar, type IDialogHeader, type IField, type IFieldErrorMessage, type IFilterCondition, type IFilterDTOState, type IFilterValue, type IIconInput, type IOverlay, type IParameter, type IParametersGroup, type IRequiredMark, type IResponsiveComponent, type ISimpleButton, type ITableParameterProps, IconButton, IconInput, IconsList, LabelBox, LinearLoader, ListSkeletonLoader, Listbox, ListboxItem, LoaderSpinner, Modal, NumberInput, Overlay, Parameter, type ParameterObject, type ParameterPossibleValue, ParameterRender, type ParameterRenderer, type ParameterRendererProps, type ParameterType, Parameters, type ParametersDefinition, ParametersGroup, type ParametersGroupRenderer, ParametersStore, ParametersTable, type Payload, ProgressBar, RequiredMark, ScreenLocker, SimpleButton, SortableList, SortableListItem, type TAccordionHandler, type TAccordionItemButton, type TApiaButtonType, type TApiaIconButton, type TCheckbox, type TCssProps, type TDateProps, type TFieldLabel, type TFilterOp, type TFilterPayload, type TFilterType, type TFilterValue, type TFilterValueType, type TGetTabsController, type TIcon, type TIconButton, type TIconRenderer, type TIconSize, type TIconsList, type TListbox, type TMenuItem, type TModal, type TModalSize, type TNumberInput, type TNumberInputChangeEvent, type TOnClickNode, type TOnConfirmSelection, type TOnSelectionChange, type TOpenModal, type TParameterType, type TSubmenu, type TTab, type TTabLabelRenderer as TTabRenderer, type TToolbarIconButton as TToolDefinition, type TTooltip, type TUseModalConfiguration, type TVisualizationType, Tab, Tabs, TabsContent, TabsController, TabsList, Templater, Toolbar, ToolbarController, ToolbarIconButton, ToolbarInput, ToolbarSelect, ToolbarSeparator, ToolbarTextButton, UnstyledSortableList, WaiTypeAhead, getFieldErrorStyles, getFieldTouchedStyles, importComponent, isParametersGroup, makeResponsiveComponent, parseNumberInputValueToNumber, parseNumberValueToNumberInput, useAccordionContext, useModal, useModalContext, useOtherTagButton, useTabsContext };
 //# sourceMappingURL=index.d.ts.map