@konoma-development/react-components 0.0.1

package/dist/components/form/checkbox.d.ts

@@ -0,0 +1,4 @@
+import { FormFieldProps } from './types';
+export default function Checkbox<DataType>({ classesFilled, classesError, classesEmpty, labelClassesFilled, labelClassesError, labelClassesEmpty, iconClassesFilled, value, defaultValue, 
+/** UNUSED, only listed so that the typing for onInput does not clash with the onInput event of the input */
+onInput, onChange, label, indeterminate, disabled, className, name, error, ...props }: FormFieldProps<DataType>): import("react/jsx-runtime").JSX.Element;

package/dist/components/form/checkboxList.d.ts

@@ -0,0 +1,2 @@
+import { FormFieldProps } from './types';
+export default function CheckboxList<DataType>({ labelClasses, wrapperClasses, classes, classesError, errorClasses, childClasses, label, error, name, options, required, labelPosition, values, onChange, }: FormFieldProps<DataType>): import("react/jsx-runtime").JSX.Element;

package/dist/components/form/form.d.ts

@@ -0,0 +1,14 @@
+import { JSX, Ref } from 'react';
+export declare const ErrorContext: import('react').Context<{
+    errors: Record<string, string[]>;
+    setErrors: (errors: Record<string, string[]>) => void;
+}>;
+export default function Form<DataType>({ children, className, validators, data, formRef, onValidation, onSubmit, }: {
+    formRef?: Ref<HTMLFormElement>;
+    children: JSX.Element[] | JSX.Element;
+    className?: string;
+    data: DataType;
+    validators: Record<keyof DataType, ((value: string | number | boolean | null) => string)[]>;
+    onValidation?: (errors: Record<keyof DataType, string[]>) => void;
+    onSubmit: () => Promise<void>;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/form/formField.d.ts

@@ -0,0 +1,23 @@
+import { default as Checkbox } from './checkbox';
+import { default as CheckboxList } from './checkboxList';
+import { default as Input } from './input';
+import { default as PhoneInput } from './phoneInput';
+import { default as RadioButtonGroup } from './radiobuttonGroup';
+import { default as Select } from './select';
+import { default as TagList } from './tagList';
+import { default as Textarea } from './textarea';
+import { FormFieldProps } from './types';
+declare const FormFieldComponents: {
+    checkbox: typeof Checkbox;
+    checkboxList: typeof CheckboxList;
+    input: typeof Input;
+    radioButtonGroup: typeof RadioButtonGroup;
+    select: typeof Select;
+    textarea: typeof Textarea;
+    tagList: typeof TagList;
+    phoneInput: typeof PhoneInput;
+};
+export default function FormField<DataType>({ component, value, defaultValue, name, options, onChange, ...props }: FormFieldProps<DataType> & {
+    component: keyof typeof FormFieldComponents;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,2 @@
+import { FormFieldProps } from './types';
+export default function Input<DataType>({ classes, wrapperClasses, labelClasses, iconLeftClasses, iconRightClasses, errorClasses, classesError, classesNeutral, additionalClassesIconLeft, additionalClassesIconRight, wrapperRightClasses, label, iconLeftPath, iconLeftName, iconRightPath, iconRightName, textRight, centered, error, required, name, value, mask, defaultValue, placeholder, className, onIconRightClick, onIconLeftClick, onChange, onClick, onKeyDown, onBlur, ...props }: FormFieldProps<DataType>): import("react/jsx-runtime").JSX.Element;

package/dist/components/form/phoneInput.d.ts

@@ -0,0 +1,2 @@
+import { FormFieldProps } from './types';
+export default function PhoneInput<DataType>({ classes, wrapperClasses, labelClasses, wrapperLeftClasses, errorClasses, classesError, classesNeutral, label, centered, error, required, name, value, defaultValue, className, onChange, onClick, onKeyDown, onBlur, ...props }: FormFieldProps<DataType>): import("react/jsx-runtime").JSX.Element;

package/dist/components/form/radiobuttonGroup.d.ts

@@ -0,0 +1,4 @@
+import { FormFieldProps, Option } from './types';
+export default function RadioButtonGroup<DataType>({ classes, controlClasses, optionClasses, labelClasses, classesFilled, classesEmpty, wrapperClasses, labelWrapperClasses, errorClasses, options, error, required, value, label, name, arrangement, onChange, }: FormFieldProps<DataType> & {
+    options: Option[];
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/form/select.d.ts

@@ -0,0 +1,2 @@
+import { FormFieldProps } from './types';
+export default function Select<DataType>({ classes, errorClasses, labelClasses, labelWrapperClasses, classesNeutral, classesError, focusClasses, controlClasses, optionClasses, optionSelectedClasses, optionFocusedClasses, valueClasses, placeholderClasses, wrapperClasses, indicatorClasses, valueContainerClasses, options, placeholder, className, required, error, defaultValue, searchable, label, name, isClearable, disabled, noValue, allowCustomValues, customValueLabel, menuPortalTarget, isMulti, onInput, onKeyDown, onChange, ...props }: FormFieldProps<DataType>): import("react/jsx-runtime").JSX.Element;

package/dist/components/form/tagList.d.ts

@@ -0,0 +1,2 @@
+import { FormFieldProps } from './types';
+export default function TagList<DataType>({ classes, wrapperClasses, labelClasses, errorClasses, classesError, classesNeutral, label, error, required, values, addTagTitle, onChange, className, }: FormFieldProps<DataType>): import("react/jsx-runtime").JSX.Element;

package/dist/components/form/textarea.d.ts

@@ -0,0 +1,4 @@
+import { FormFieldProps } from './types';
+export default function Textarea<DataType>({ classes, classesNeutral, classesError, errorClasses, labelClasses, hintClasses, wrapperClasses, resizeClasses, resizeIconClasses, controlClasses, labelWrapperClasses, classesDisabled, resizeIconPath, resizeIconName, label, error, required, initialHeight, maxLength, replacements, name, value, disabled, defaultValue, maxLengthLabel, 
+/** UNUSED, only listed so that the typing for onInput does not clash with the onInput event of the textarea */
+onInput, onChange, ...props }: FormFieldProps<DataType>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,132 @@
+import { ChangeEvent, HTMLInputTypeAttribute, JSX, MouseEvent } from 'react';
+type LabelPosition = 'top' | 'bottom' | 'left' | 'right';
+export type FormValue = string | number | boolean | Option;
+export interface Option {
+    value: FormValue;
+    label: string | number;
+}
+/** Classes for the form components. Not all classes have effects in all components. Properties that start with 'class-' apply to the component in general, other properties apply to specific parts of the component */
+export interface Classes {
+    /** Never has a default value and can be used to assign arbitrary additional classes. The exact node that receives these classes differs from component to component */
+    className?: string;
+    /** Base classes, usually assigned to the control */
+    classes?: string;
+    /** Base classes, assigned directly to the control. Might be needed in case of more complex nesting */
+    controlClasses?: string;
+    /** Used for components that have specific styling when in neutral state */
+    classesNeutral?: string;
+    /** Used for components that have specific styling when empty */
+    classesEmpty?: string;
+    classesDisabled?: string;
+    /** Used for components that have specific styling when in error */
+    classesError?: string;
+    /** Used for components that have specific styling when filled */
+    classesFilled?: string;
+    /** Used for the label in components that have specific styling when empty */
+    labelClassesEmpty?: string;
+    /** Used for the label in components that have specific styling when in error */
+    labelClassesError?: string;
+    /** Used for the label in components that have specific styling when filled */
+    labelClassesFilled?: string;
+    /** General classes for the label */
+    labelClasses?: string;
+    /** Needed in case of nested label */
+    labelWrapperClasses?: string;
+    /** Used for the icon in components that have specific styling when filled */
+    iconClassesFilled?: string;
+    /** General classes for the wrapper */
+    wrapperClasses?: string;
+    /** General classes for the icon on the left */
+    iconLeftClasses?: string;
+    /** General classes for the icon on the right */
+    iconRightClasses?: string;
+    /** General classes for the error message */
+    errorClasses?: string;
+    /** Additional classes for the control when an icon is present on the left */
+    additionalClassesIconLeft?: string;
+    /** Additional classes for the control when an icon is present on the right */
+    additionalClassesIconRight?: string;
+    /** General classes for hints placed within the component */
+    hintClasses?: string;
+    /** General classes for the resize element */
+    resizeClasses?: string;
+    /** General classes for the icon within the resize element */
+    resizeIconClasses?: string;
+    /** Classes to be applied to all values for components with multiple possible values */
+    optionClasses?: string;
+    /** Classes to be applied to the wrapper for elements on the left side */
+    wrapperLeftClasses?: string;
+    /** Classes to be applied to the wrapper for elements on the right side */
+    wrapperRightClasses?: string;
+    focusClasses?: string;
+    optionFocusedClasses?: string;
+    optionSelectedClasses?: string;
+    valueClasses?: string;
+    placeholderClasses?: string;
+    indicatorClasses?: string;
+    valueContainerClasses?: string;
+}
+export interface FormFieldProps<DataType> extends Classes {
+    allowCustomValues?: boolean;
+    customValueLabel?: string;
+    arrangement?: 'horizontal' | 'vertical';
+    centered?: boolean;
+    autoFocus?: boolean;
+    childClasses?: {
+        [key in keyof Classes]?: string;
+    };
+    defaultValue?: FormValue;
+    disabled?: boolean;
+    error?: string[];
+    forgotPWText?: string;
+    iconLeftPath?: string;
+    iconLeftName?: string;
+    iconRightPath?: string;
+    iconRightName?: string;
+    indeterminate?: boolean;
+    isClearable?: boolean;
+    replacements?: Record<string, string>;
+    label?: string | JSX.Element;
+    labelPosition?: LabelPosition;
+    maxLength?: number;
+    maxLengthLabel?: string;
+    name?: keyof DataType;
+    options?: Option[];
+    placeholder?: string;
+    required?: boolean;
+    resizeIconPath?: string;
+    resizeIconName?: string;
+    addTagTitle?: string;
+    searchable?: boolean;
+    textRight?: string;
+    type?: HTMLInputTypeAttribute;
+    initialHeight?: number;
+    mask?: Mask | Mask[];
+    min?: number;
+    max?: number;
+    /** Used for components that bind to one value */
+    value?: FormValue;
+    /** Used for components that bind to multiple values */
+    values?: FormValue[];
+    /** Used for selects that have no visible selected value */
+    noValue?: boolean;
+    isMulti?: boolean;
+    valueTransformer?: (value: FormValue) => FormValue;
+    /** Used to place the dropdown element of a Select */
+    menuPortalTarget?: HTMLElement;
+    forgotPWAction?: (event: React.MouseEvent<HTMLButtonElement>) => void;
+    onBlur?: (event: React.FocusEvent<HTMLElement>) => void;
+    onFocus?: (event: React.FocusEvent<HTMLElement>) => void;
+    onChange?: (value: FormValue | FormValue[], event?: ChangeEvent) => void;
+    onInput?: (value: FormValue, event?: InputEvent) => void;
+    onClick?: (e: MouseEvent) => void;
+    onIconRightClick?: () => void;
+    onIconLeftClick?: () => void;
+    onKeyDown?: (event: React.KeyboardEvent<HTMLElement>) => void;
+}
+export declare const positionClasses: Record<LabelPosition, string>;
+export type Mask = string | RegExp | {
+    mask: Mask;
+    definitions?: Record<string, RegExp>;
+};
+export {};

package/dist/components/form/validators.d.ts

@@ -0,0 +1,2 @@
+export declare function required(message?: string): (value: string | number | boolean | null) => string;
+export declare function email(message?: string): (value: string | number | boolean | null) => string;

package/dist/components/table/FilterContext.d.ts

@@ -0,0 +1,4 @@
+export declare const FilterContext: import('react').Context<{
+    filters: Record<string, string>;
+    setFilters: (errors: Record<string, string>) => Promise<void>;
+}>;

package/dist/components/table/column.d.ts

@@ -0,0 +1,54 @@
+import { JSX } from 'react';
+import { TableColumn } from './table';
+export interface ColumnClasses {
+    resizableClasses?: string;
+    resizableComponentWrapperClasses?: string;
+    resizableComponentWithFiltersClasses?: string;
+    resizableComponentNoFiltersClasses?: string;
+    resizableComponentStaticClasses?: string;
+    resizableComponentHoveringClasses?: string;
+    resizableComponentClasses?: string;
+    headerWrapperClasses?: string;
+    headerWrapperSortingClasses?: string;
+    headerIconClasses?: string;
+    filterWrapperClasses?: string;
+    filterInputClasses?: string;
+    cellClasses?: string;
+    rowStaticClasses?: string;
+    rowHoveringClasses?: string;
+    firstColumnRowClasses?: string;
+    intermediateColumnRowClasses?: string;
+    lastColumnRowClasses?: string;
+}
+export default function Column<DataType>({ column, data, cellRenderer, index, dragType, tableHasFilters, isFirst, isLast, headerWrapperClasses, headerWrapperSortingClasses, headerIconClasses, filterWrapperClasses, filterInputClasses, cellClasses, rowStaticClasses, rowHoveringClasses, firstColumnRowClasses, intermediateColumnRowClasses, lastColumnRowClasses, filterComponent, hoveredRowIds, onRowHoverEnter, onRowHoverLeave, onRowClick, onRowDoubleClick, onSort, onDragEnd, moveColumn, }: {
+    column: TableColumn<DataType>;
+    data: DataType[];
+    cellRenderer?: {
+        [key in keyof DataType]?: (data: DataType) => JSX.Element;
+    };
+    index: number;
+    dragType: string;
+    tableHasFilters: boolean;
+    headerWrapperClasses?: string;
+    headerWrapperSortingClasses?: string;
+    headerIconClasses?: string;
+    filterWrapperClasses?: string;
+    filterInputClasses?: string;
+    cellClasses?: string;
+    rowStaticClasses?: string;
+    firstColumnRowClasses?: string;
+    intermediateColumnRowClasses?: string;
+    lastColumnRowClasses?: string;
+    isFirst: boolean;
+    isLast: boolean;
+    rowHoveringClasses?: string;
+    filterComponent?: JSX.Element;
+    hoveredRowIds: number[];
+    onRowHoverEnter?: (index: number) => void;
+    onRowHoverLeave?: (index: number) => void;
+    onRowClick?: (data: DataType) => void;
+    onRowDoubleClick?: (data: DataType) => void;
+    onSort?: (column: TableColumn<DataType>) => void;
+    onDragEnd?: (dragIndex: number, hoverIndex: number) => void;
+    moveColumn: (dragIndex: number, hoverIndex: number) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/table/columnChooser.d.ts

@@ -0,0 +1,17 @@
+import { ExtendedRefs, FloatingContext } from '@floating-ui/react';
+import { TableColumn } from './table';
+export default function ColumnChooser<DataType>({ columns, context, refs, floatingStyles, wrapperClasses, headerClasses, columnsWrapperClasses, entryClasses, visibleColumnClasses, hiddenColumnClasses, columnsLabel, updateColumns, getFloatingProps, }: {
+    columns: TableColumn<DataType>[];
+    context: FloatingContext;
+    refs: ExtendedRefs<unknown>;
+    floatingStyles: React.CSSProperties;
+    wrapperClasses?: string;
+    headerClasses?: string;
+    columnsWrapperClasses?: string;
+    visibleColumnClasses?: string;
+    hiddenColumnClasses?: string;
+    entryClasses?: string;
+    columnsLabel?: string;
+    updateColumns: (column: TableColumn<DataType>) => void;
+    getFloatingProps: () => Record<string, unknown>;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/table/columnChooserEntry.d.ts

@@ -0,0 +1,9 @@
+export default function ColumnChooserEntry<DataType>({ title, id, visibleColumns, entryClasses, visibleColumnClasses, hiddenColumnClasses, updateColumns, }: {
+    title: string;
+    id: keyof DataType;
+    entryClasses: string;
+    visibleColumnClasses: string;
+    hiddenColumnClasses: string;
+    visibleColumns: (keyof DataType)[];
+    updateColumns: (id: keyof DataType) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/table/pagination.d.ts

@@ -0,0 +1,16 @@
+export interface PaginationClasses {
+    activeIconClasses: string;
+    inactiveIconClasses: string;
+    wrapperClasses: string;
+    resultsClasses: string;
+    resultsTextClasses: string;
+    controlClasses: string;
+}
+export default function Pagination({ wrapperClasses, resultsClasses, resultsTextClasses, xToY, }: {
+    currentLoaded: number;
+    currentTotal: number;
+    wrapperClasses?: string;
+    resultsClasses?: string;
+    resultsTextClasses?: string;
+    xToY?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/table/table.d.ts

@@ -0,0 +1,60 @@
+import { JSX } from 'react';
+import { ColumnClasses } from './column';
+import { PaginationClasses } from './pagination';
+export interface TableColumn<DataType> {
+    id: keyof DataType;
+    title: string | JSX.Element;
+    initialWidth?: string | number;
+    hidden?: boolean;
+    sorting?: '+' | '-' | undefined;
+    sortKey?: string;
+    filterKey?: string;
+    onClick?: () => void;
+    allowResize?: boolean;
+    filterable?: boolean;
+    grow?: boolean;
+}
+export default function Table<DataType extends {
+    dragRef?: React.RefObject<HTMLDivElement>;
+}>({ noDataClasses, paginationClasses, columnsCenter, columnsRight, columnsLeft, cellRenderer, filters, data, pagination, totalRows, noEntryLabel, allowReorder, onMoveRow, onRowClick, onRowDoubleClick, onScroll, onUpdateFilters, }: {
+    wrapperClasses?: string;
+    columnsWrapperClasses?: string;
+    columnsLeftClasses?: string;
+    columnsCenterClasses?: string;
+    columnsRightClasses?: string;
+    noDataClasses?: string;
+    paginationClasses?: PaginationClasses;
+    columnClasses?: ColumnClasses;
+    columnsCenter: TableColumn<DataType>[];
+    columnsRight?: TableColumn<DataType>[];
+    columnsLeft?: TableColumn<DataType>[];
+    cellRenderer?: {
+        [key in keyof DataType]?: (data: DataType & {
+            dragRef?: React.RefObject<HTMLDivElement>;
+        }) => JSX.Element;
+    };
+    filterComponent?: {
+        [key in keyof DataType]?: (data: DataType) => JSX.Element;
+    };
+    filters?: Record<string, string>;
+    showFilters?: boolean;
+    data: DataType[];
+    pagination?: boolean;
+    totalRows: number;
+    noEntryLabel?: string;
+    allowReorder?: boolean;
+    onMoveRow?: (dragIndex: number, hoverIndex: number) => void;
+    onScroll?: (event: React.UIEvent<HTMLDivElement>) => void;
+    onFirstPage?: () => void;
+    onPreviousPage?: () => void;
+    onNextPage?: () => void;
+    onLastPage?: () => void;
+    toPage?: (page: number) => void;
+    onRowClick?: (data: DataType) => void;
+    onRowDoubleClick?: (data: DataType) => void;
+    onSort?: (column: TableColumn<DataType>) => void;
+    onUpdateFilters?: (filters: Record<string, string>) => Promise<void>;
+    onUpdateColumnsLeft?: (columns: TableColumn<DataType>[], updateMeta?: boolean) => void;
+    onUpdateColumnsCenter?: (columns: TableColumn<DataType>[], updateMeta?: boolean) => void;
+    onUpdateColumnsRight?: (columns: TableColumn<DataType>[], updateMeta?: boolean) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/table/tableActions.d.ts

@@ -0,0 +1,11 @@
+export default function TableActions({ children, classes }: {
+    children: React.ReactNode;
+    classes?: string;
+}): import("react/jsx-runtime").JSX.Element;
+type TableActionVariant = 'error' | 'success' | 'warning' | 'default';
+export declare function TableActionEntry({ text, variant, onClick, }: {
+    text: string;
+    variant?: TableActionVariant;
+    onClick: () => void;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,4 @@
+export interface DataTypeBase {
+    actions: string;
+    id: number;
+}

package/dist/components/ui/button.d.ts

@@ -0,0 +1,28 @@
+import { MouseEvent } from 'react';
+export default function Button({ className, classesBase, classesPrimary, classesSecondary, classesActiveSecondary, classesError, classesAlert, loadingClassesBase, loadingClassesPrimary, loadingClassesSecondary, loadingClassesActiveSecondary, loadingClassesError, loadingClassesAlert, iconLeftClasses, iconRightClasses, type, variant, label, loading, disabled, iconLeftPath, iconLeftName, iconRightPath, iconRightName, onClick, }: {
+    classesBase?: string;
+    classesPrimary?: string;
+    classesSecondary?: string;
+    classesActiveSecondary?: string;
+    classesError?: string;
+    classesAlert?: string;
+    loadingClassesBase?: string;
+    loadingClassesPrimary?: string;
+    loadingClassesSecondary?: string;
+    loadingClassesActiveSecondary?: string;
+    loadingClassesError?: string;
+    loadingClassesAlert?: string;
+    iconLeftClasses?: string;
+    iconRightClasses?: string;
+    disabled?: boolean;
+    className?: string;
+    type?: 'button' | 'submit' | 'reset';
+    variant: 'primary' | 'secondary' | 'error' | 'alert' | 'active-secondary';
+    label: string;
+    loading?: boolean;
+    iconLeftPath?: string;
+    iconLeftName?: string;
+    iconRightPath?: string;
+    iconRightName?: string;
+    onClick?: (e: MouseEvent) => Promise<void> | void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/icon.d.ts

@@ -0,0 +1,5 @@
+import { HTMLProps, SVGProps } from 'react';
+export default function Icon({ path, name, ...props }: (HTMLProps<HTMLElement> | SVGProps<SVGSVGElement>) & {
+    name?: string;
+    path?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/loadingIndicator.d.ts

@@ -0,0 +1,3 @@
+export default function LoadingIndicator({ className }: {
+    className: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/modal.d.ts

@@ -0,0 +1,21 @@
+import { default as Button } from './button';
+export default function Modal({ backdropClasses, contentClasses, headerWrapperClasses, footerWrapperClasses, footerLeftClasses, footerRightClasses, titleClasses, closeWrapperClasses, iconClasses, children, headerContent, footerContent, title, footerActions, hasCloseIcon, onClose, }: {
+    backdropClasses?: string;
+    contentClasses?: string;
+    headerWrapperClasses?: string;
+    footerWrapperClasses?: string;
+    footerLeftClasses?: string;
+    footerRightClasses?: string;
+    titleClasses?: string;
+    closeWrapperClasses?: string;
+    iconClasses?: string;
+    children: React.ReactNode;
+    headerContent?: React.ReactNode;
+    footerContent?: React.ReactNode;
+    title?: string;
+    footerActions?: (React.ComponentProps<typeof Button> & {
+        position: 'left' | 'right';
+    })[];
+    hasCloseIcon?: boolean;
+    onClose: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/tabs.d.ts

@@ -0,0 +1,20 @@
+interface Tab<DataType> {
+    id: DataType;
+    label: string;
+    count: number;
+}
+export default function Tabs<DataType>({ wrapperClasses, tabActiveClasses, tabInactiveClasses, countActiveClasses, countInactiveClasses, tabBaseClasses, countBaseClasses, activeMarkerClass, showCounts, tabs, active, onClick, }: {
+    wrapperClasses?: string;
+    tabActiveClasses?: string;
+    tabInactiveClasses?: string;
+    countActiveClasses?: string;
+    countInactiveClasses?: string;
+    tabBaseClasses?: string;
+    countBaseClasses?: string;
+    activeMarkerClass?: string;
+    showCounts?: boolean;
+    tabs: Tab<DataType>[];
+    active: DataType;
+    onClick: (tab: DataType) => void;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/tag.d.ts

@@ -0,0 +1,14 @@
+export default function Tag({ wrapperClasses, titleClasses, iconLeftClasses, iconRightClasses, iconLeftPath, iconLeftName, iconRightPath, iconRightName, title, onClick, onClickIconLeft, onClickIconRight, }: {
+    wrapperClasses?: string;
+    titleClasses?: string;
+    iconLeftClasses?: string;
+    iconRightClasses?: string;
+    iconLeftPath?: string;
+    iconLeftName?: string;
+    iconRightPath?: string;
+    iconRightName?: string;
+    title: string;
+    onClick?: () => void;
+    onClickIconLeft?: () => void;
+    onClickIconRight?: () => void;
+}): import("react/jsx-runtime").JSX.Element;