@luscii-healthtech/web-ui 0.0.0-alpha.2fcd0e9

package/dist/components/CheckBoxListModal/CheckboxListModal.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="react" />
+import { CheckboxGroupItemProps } from "../CheckboxList/CheckboxList.types";
+export type Item = {
+    group?: string;
+    isPinned?: boolean;
+} & Pick<CheckboxGroupItemProps, "id" | "label" | "isChecked" | "isDisabled">;
+export interface Group {
+    title?: string;
+    items: Item[];
+}
+interface CheckboxListModalTexts {
+    title: string;
+    confirmLabel: string;
+    cancelLabel: string;
+    searchPlaceHolder?: string;
+    emptyState: string;
+}
+export interface CheckboxListModalProps {
+    texts: CheckboxListModalTexts;
+    initialItems: Array<Item>;
+    isLoadingInitialItems?: boolean;
+    isOpen: boolean;
+    onSave: (newItems: Item[]) => void;
+    onCloseClick: () => void;
+    filterItem: (item: Item, searchQuery: string) => boolean;
+    className?: string;
+    hasSearch: boolean;
+}
+export declare const CheckboxListModal: ({ texts, initialItems, isLoadingInitialItems, isOpen, onSave, onCloseClick, filterItem, hasSearch, }: CheckboxListModalProps) => JSX.Element;
+export {};

package/dist/components/Checkbox/Checkbox.d.ts

@@ -0,0 +1,64 @@
+import React from "react";
+import "./Checkbox.scss";
+export interface CheckboxProps {
+    /**
+     * ID used for semantic targeting, as can be used in attributes like `<label htmlFor="some-id">`.
+     */
+    id?: string;
+    /**
+     * The visible text labeling the checkbox element.
+     */
+    text?: string;
+    /**
+     * Helper text that adds some more information on what the option means, or inform
+     * the user about the consequences of the checkbox.
+     *
+     * Only works if the `renderLabel` prop isn't set.
+     */
+    explanation?: string;
+    /**
+     * Shows a different checkbox variant. `type="switch"` shows a switch-like component
+     * without a visual label.
+     */
+    type?: "regular" | "switch";
+    /**
+     * Set the value.
+     * Same as `checked` on `<input type="checkbox" />`.
+     */
+    isChecked?: boolean;
+    /**
+     * Value for when it is not clear if the state of this checkbox
+     * is "checked" or not (for hierarchical checkboxes).
+     */
+    isIndeterminate?: boolean;
+    /**
+     * Disallow the user to change the checkbox value.
+     * Same as `disabled` on `<input type="checkbox" />`.
+     */
+    isDisabled?: boolean;
+    /**
+     * The name that the value of the checkbox will be associated with.
+     * Same as `name` on `<input type="checkbox" />`.
+     */
+    name?: string;
+    /**
+     * This can be used to retrieve the value it is referring to through onChange.
+     */
+    value?: string;
+    onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    className?: string;
+    classNameCheckboxLabel?: string;
+    /**
+     * Visually show that the currently selected value has an issue the user needs to attend to.
+     */
+    error?: boolean;
+    innerRef?: React.Ref<HTMLInputElement>;
+    /**
+     * Renders a completely custom label. Can change its contents or
+     * appearance based on the props of the checkbox item.
+     *
+     * Overrides the `text` prop.
+     */
+    renderLabel?: (props: CheckboxProps) => JSX.Element | null;
+}
+export declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLInputElement>>;

package/dist/components/CheckboxList/CheckboxGroup.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { CheckboxGroupProps } from "./CheckboxList.types";
+export declare const CheckboxGroup: ({ title, items, onChange, className, isCollapsed, collapsible, }: CheckboxGroupProps) => JSX.Element;

package/dist/components/CheckboxList/CheckboxList.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { CheckboxListProps } from "./CheckboxList.types";
+export { CheckboxListProps };
+export declare const CheckboxList: ({ groups, onChange, className, }: CheckboxListProps) => JSX.Element;

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

@@ -0,0 +1,74 @@
+export declare enum CheckboxState {
+    CHECKED = "checked",
+    INDETERMINATE = "indeterminate",
+    UNCHECKED = "unchecked"
+}
+export interface CheckboxListProps {
+    /**
+     * An array of items to render as checkboxes. Each item can be a single item or a group. When the
+     * title isn't specified, the group will render as a non-collapsible list. This is the way to
+     * render a regular list of checkboxes.
+     *
+     * @example
+     * Single list of checkboxes without visual grouping.
+     *
+     * ```tsx
+     * const groups = [{
+     *   items: [
+     *     {
+     *       id: "1",
+     *       label: "Item 1",
+     *     },
+     *     {
+     *       id: "2",
+     *       label: "Item 2",
+     *     },
+     *   ],
+     * }]
+     * ```
+     */
+    groups: CheckboxGroup[];
+    onChange: (event: CheckboxChangeEvent) => void;
+    className?: string;
+}
+type WithCollapsible = {
+    /**
+     * When `false` will prevent the checkbox list from being collapsed (also disabling clicking to expand/collapse)
+     * in the component and it will be displayed expanded by default.
+     * @default true
+     */
+    collapsible?: boolean;
+};
+export type CheckboxGroupProps = CheckboxGroup & {
+    onChange: (event: CheckboxChangeEvent) => void;
+    className?: string;
+} & WithCollapsible;
+export interface CheckboxGroupItemProps extends CheckboxListItem {
+    onChange: (event: CheckboxChangeEvent) => void;
+}
+export interface CheckboxListItem {
+    id: string;
+    label: string;
+    isChecked?: boolean;
+    isDisabled?: boolean;
+    className?: string;
+}
+export type CheckboxGroup = {
+    /**
+     * When the title isn't specified, the group will render as a non-collapsible list.
+     */
+    title?: string;
+    /**
+     * The checkbox items to be shown inside of this group.
+     */
+    items: CheckboxListItem[];
+    /**
+     * Whether the group is initially collapsed or not.
+     */
+    isCollapsed?: boolean;
+} & WithCollapsible;
+export interface CheckboxChangeEvent {
+    id: string;
+    newCheckedValue: boolean;
+}
+export {};

package/dist/components/CheckboxList/CheckboxListItem.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { CheckboxGroupItemProps } from "./CheckboxList.types";
+export declare const CheckboxListItem: ({ id, label, isChecked, isDisabled, onChange, className, }: CheckboxGroupItemProps) => JSX.Element;

package/dist/components/ConfirmationDialog/ConfirmationDialog.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { ConfirmationDialogProps } from "./types/ConfirmationDialog.types";
+export declare const ConfirmationDialog: React.FC<ConfirmationDialogProps>;

package/dist/components/ConfirmationDialog/ConfirmationDialogChoices.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { ConfirmationDialogChoice, ConfirmationDialogProps } from "./types/ConfirmationDialog.types";
+export declare const ConfirmationDialogChoices: React.FC<{
+    choices: ConfirmationDialogProps["choices"];
+    onChoiceChangeCallback?: (choice: ConfirmationDialogChoice) => void;
+    selectedChoice?: ConfirmationDialogChoice;
+}>;

package/dist/components/ConfirmationDialog/ConfirmationDialogMessage.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+export declare const ConfirmationDialogMessage: React.FC<{
+    message: string | string[];
+}>;

package/dist/components/ConfirmationDialog/ConfirmationDialogTitle.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { ConfirmationDialogTitleProps } from "./types/ConfirmationDialog.types";
+export declare const ConfirmationDialogTitle: React.FC<ConfirmationDialogTitleProps>;

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

@@ -0,0 +1,41 @@
+/// <reference types="react" />
+import type { IconKey, IconProps } from "../../Icons/types/IconProps.type";
+import type { NotificationBannerColor } from "../../NotificationBanner/NotificationBanner";
+interface ConfirmationDialogTexts {
+    message: string | string[];
+    confirmLabel: string;
+    cancelLabel: string;
+}
+export interface ConfirmationDialogChoice<T extends string = string> {
+    text: string;
+    value: T;
+    description?: string;
+    displaysInfo?: {
+        level: NotificationBannerColor;
+        text: string;
+    };
+}
+export interface ConfirmationDialogProps {
+    texts: ConfirmationDialogTexts;
+    isOpen: boolean;
+    onCancel: () => void;
+    onConfirm: (choice?: ConfirmationDialogChoice) => void;
+    isProcessing?: boolean;
+    withTitle?: {
+        title: string;
+        icon?: React.FC<IconProps> | IconKey;
+    };
+    choices?: {
+        defaultChoice?: ConfirmationDialogChoice["value"];
+        onChoiceChange: (choice: ConfirmationDialogChoice) => void;
+        options: {
+            0: ConfirmationDialogChoice;
+            1: ConfirmationDialogChoice;
+        } & ConfirmationDialogChoice[];
+    };
+    dataTestId?: string;
+}
+export interface ConfirmationDialogTitleProps {
+    title: ConfirmationDialogProps["withTitle"];
+}
+export {};

package/dist/components/Container/FlexColumn.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { FlexContainerProps } from "./types/FlexContainerProps.type";
+/**
+ * Container to be used for layouting instead of divs around the project.
+ * The spacing here has been coded according to our guidelines.
+ */
+export declare const FlexColumn: React.FC<FlexContainerProps>;

package/dist/components/Container/FlexContainer.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { FlexContainerBaseProps } from "./types/FlexContainerProps.type";
+/**
+ * Container to be used for layouting instead of divs around the project.
+ * The spacing here has been coded according to our guidelines.
+ */
+export declare const FlexContainer: React.FC<FlexContainerBaseProps & {
+    type: "column" | "row";
+}>;

package/dist/components/Container/FlexRow.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { FlexContainerProps } from "./types/FlexContainerProps.type";
+/**
+ * Container to be used for layouting instead of divs around the project.
+ * The spacing here has been coded according to our guidelines.
+ */
+export declare const FlexRow: React.FC<FlexContainerProps>;

package/dist/components/Container/types/FlexContainerProps.type.d.ts

@@ -0,0 +1,26 @@
+import React from "react";
+type Spacing = "tiny" | "none" | "small" | "medium" | "large";
+type FlexContainerBase = {
+    alignItems?: "center" | "start" | "end";
+    justifyContent?: "center" | "start" | "end" | "between";
+    position?: "static" | "fixed" | "absolute" | "relative" | "sticky";
+    verticalSpacing?: Spacing;
+    horizontalSpacing?: Spacing;
+    /**
+     * Applies the default padding (`"ui-p-4"`) inside the container.
+     */
+    hasPadding?: boolean;
+    backgroundColor?: string;
+    /**
+     * If `true`, will make the flexbox full width and not size itui-relative to its content.
+     * @default true
+     */
+    stretch?: boolean;
+};
+export type FlexContainerBaseProps = FlexContainerBase & {
+    children: React.ReactNode;
+};
+export type FlexContainerProps = Omit<FlexContainerBaseProps, "verticalSpacing" | "horizontalSpacing"> & {
+    spacing?: Spacing;
+};
+export {};

package/dist/components/Divider/Divider.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+type DividerProps = {
+    dark?: boolean;
+};
+export declare const Divider: React.FC<DividerProps>;
+export {};

package/dist/components/DragHandle/DragHandle.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+declare const DragHandle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLButtonElement> & {
+    grabbing: boolean;
+    disabled?: boolean | undefined;
+    dataTestId?: string | undefined;
+} & React.RefAttributes<HTMLButtonElement>>;
+export default DragHandle;

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

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export type DragHandleProps = React.HTMLAttributes<HTMLButtonElement> & {
+    grabbing: boolean;
+    disabled?: boolean;
+    dataTestId?: string;
+};

package/dist/components/DragHandle/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./DragHandle";
+export type { DragHandleProps } from "./DragHandle.types";

package/dist/components/Dropzone/Dropzone.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import "./Dropzone.scss";
+import type { DropzoneProps, DropzonePresentationProps } from "./Dropzone.types";
+export declare const DropzonePresentation: React.FC<DropzonePresentationProps>;
+export declare const Dropzone: React.FC<DropzoneProps>;
+export default Dropzone;

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

@@ -0,0 +1,33 @@
+import { ReactNode, Ref } from "react";
+import type { IconKey } from "../Icons/types/IconProps.type";
+export type DropzonePresentationProps = {
+    /**
+     * Message shown to the user hinting how to use the component
+     * Usually something like "Click or Drag"
+     */
+    message?: string;
+    /**
+     * @deprecated
+     * Dropzones no longer support icons
+     */
+    icon?: IconKey;
+    isHighlighted?: boolean;
+    isClickable?: boolean;
+    ref?: Ref<HTMLDivElement>;
+    children?: ReactNode;
+    className?: string;
+    dataTestId?: string;
+    /**
+     * @deprecated
+     * use alignMessage instead
+     */
+    horizontal?: boolean;
+    alignMessage?: "left" | "center";
+};
+export type DropzoneProps = Omit<DropzonePresentationProps, "isHighlighted" | "isClickable"> & {
+    draggableIdentifier: string | number;
+    disabled?: boolean;
+    data?: Record<string, unknown>;
+    dataTestId?: string;
+    onClick?: React.HTMLAttributes<HTMLButtonElement>["onClick"];
+};

package/dist/components/Dropzone/index.d.ts

@@ -0,0 +1,2 @@
+export { Dropzone, DropzonePresentation } from "./Dropzone";
+export type { DropzoneProps } from "./Dropzone.types";

package/dist/components/EmptyListMessage/EmptyListMessage.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+declare const imageSrc: {
+    "no-open-alerts": string;
+    "search-not-found": string;
+    "no-notes-found": string;
+};
+interface EmptyListMessageProps {
+    text: string;
+    imageName?: keyof typeof imageSrc;
+    dataTestId?: string;
+    className?: string;
+}
+export declare const EmptyListMessage: ({ text, imageName, dataTestId, className, }: EmptyListMessageProps) => JSX.Element;
+export {};

package/dist/components/FilterBar/ActiveFilters.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { CategorizedFilters, FilterBarLocalization, OnFilterBarFilterChange } from "./FilterBarProps.type";
+type ActiveFiltersProps = {
+    filters: CategorizedFilters;
+    onRemoveActiveFilter: OnFilterBarFilterChange;
+    localization: Pick<FilterBarLocalization, "filtersLabel">;
+};
+export declare const ActiveFilters: React.FC<ActiveFiltersProps>;
+export {};

package/dist/components/FilterBar/FilterBar.d.ts

@@ -0,0 +1,96 @@
+import { ReactElement } from "react";
+import { CategorizedFilters, FilterBarLocalization, TransformedSortingOptions } from "./FilterBarProps.type";
+type FilterBarProps<SortableEntity extends object> = {
+    /**
+     * A list of grouped filters to be displayed in the FilterBar.
+     *
+     * This is an array with items shaped as:
+     * ```ts
+     * type CategorizedFilter = {
+     *    key: string;
+     *    label: string;
+     *    options: TransformedFilterOptions;
+     * }
+     * ```
+     *
+     * You can choose to manually create this option or use the `getFilterGroups` helper function that will do the same
+     * for you based on your data.
+     *
+     * @example
+     *
+     * If you decided to use the `getFilterGroups` function:
+     *
+     *
+     * ```ts
+     * const items = []; // any list of object you are working with
+     *
+     * // the list of filter generators, the `filterValuePredicate` will be the displayed
+     * // value in the filter dropdown, so you can map and transform it to any custom string if necessary, or use
+     * // the value from the object entry
+     *
+     * const filterGenerators: FilterGenerator<TShirtFromApi>[] = [
+     *   {
+     *     id: "brand",
+     *     label: "Brand",
+     *     filterValuePredicate: (tshirt) => tshirt.brand,
+     *   },
+     *   {
+     *     id: "size",
+     *     label: "Size",
+     *     filterValuePredicate: (tshirt) => tshirt.size,
+     *   },
+     *   {
+     *     id: "color",
+     *     label: "Color",
+     *     filterValuePredicate: (tshirt) => tshirt.color,
+     *   },
+     * ];
+     *
+     * const categorizedFilters = getFilterGroups(items, filterGenerators);
+     * ```
+     *
+     *
+     * A compliant entry in the `categorizedFilters` has a shape like the object below:
+     *
+     *
+     * ```json
+     * {
+     *  "key": "color",
+     *  "label": "Color",
+     *  "options": [
+     *     {
+     *         "isChecked": false,
+     *         "id": "yellow",
+     *         "label": "yellow",
+     *         "value": "yellow"
+     *     },
+     *     {
+     *         "isChecked": false,
+     *         "id": "red",
+     *         "label": "red",
+     *         "value": "red"
+     *     },
+     *     {
+     *         "isChecked": false,
+     *         "id": "green",
+     *         "label": "green",
+     *         "value": "green"
+     *     }
+     *   ]
+     * }
+     *```
+     */
+    categorizedFilters: CategorizedFilters;
+    /**
+     * For more details, see {@link TransformedSortingOptions}.
+     */
+    sortingOptions: TransformedSortingOptions<SortableEntity>;
+    onFilterChange: (updatedFilters: CategorizedFilters) => void;
+    onSortingChange: (updatedSortingOptions: TransformedSortingOptions<SortableEntity>) => void;
+    /**
+     * See {@link FilterBarLocalization}.
+     */
+    localization: FilterBarLocalization;
+};
+export declare const FilterBar: <SortableEntity extends object>({ localization, categorizedFilters, sortingOptions, ...props }: FilterBarProps<SortableEntity>) => ReactElement | null;
+export {};

package/dist/components/FilterBar/FilterBar.utils.d.ts

@@ -0,0 +1,32 @@
+import { CategorizedFilters, FilterGenerator, TransformedSortingOptions } from "./FilterBarProps.type";
+/**
+ * Generates the list of filters based on the data (see this as what you'd like to be filtered in your component).
+ *
+ * @param dataToGenerateFiltersFrom  - The data (list of entities) that will be used to create the filters.
+ * @param groupers a list of functions used to create the filters dropdown
+ * @returns {CategorisedFilters} a list of filters properly grouped.
+ */
+export declare function getFilterGroups<T extends unknown[]>(dataToGenerateFiltersFrom: T, groupers: FilterGenerator<T[number]>[]): CategorizedFilters;
+/**
+ *
+ * @param filterKey the key of the categorized filter (eg. color, size, brand) - which one of them are you gonna check.
+ * @param categorizedFilters the array of categorized filters the FilterBar component needs
+ * @param attributeGetter the getter to retrieve the attribute to be filtered on, this allow maximum flexibility on how to process
+ * filters on any level of nesting if necessary.
+ * @returns a predicate to be used in the filter function
+ * @example
+ *
+ *   const sizeFilterPredicate = createFilterPredicate<TShirtFromApi>("size", filtersOptions, (item) => item.meta.size);
+ *   const filteredBySize = items.filter(sizeFilterPredicate);
+ *
+ */
+export declare const createFilterPredicate: <T extends object>(filterKey: string, categorizedFilters: CategorizedFilters, attributeGetter: (item: T) => string) => (item: T) => boolean;
+/**
+ * Creates a sorting function to be used on a specific object attribute.
+ *
+ * @param getter the getter function to retrieve the attribute used in the sorting
+ * @param order if ascending or descending
+ * @returns the sorting comparer function to be used in Array.sort
+ */
+export declare const createSortingComparer: <T extends object>(getter: (item: T) => string | number, order?: "asc" | "desc") => (itemA: T, itemB: T) => number;
+export declare const applySorting: <T extends object[]>(sortable: T, sortingOptions: TransformedSortingOptions<T[number]>) => T;

package/dist/components/FilterBar/FilterBarProps.type.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The object used to create a filter dropdown in the component.
+ * This is used based on the dataset passed to FilterBar, so we always calculate the filters
+ * looking at the data.
+ */
+export type FilterGenerator<SortableEntity> = {
+    id: string;
+    label: string;
+    /**
+     *
+     * @param data the value from the dataset entry that will be used for the filter
+     * @returns the string value for the desired filter
+     *
+     * @example
+     *
+     * ```ts
+     * {
+          id: "brand",
+          label: "Brand",
+          filterValuePredicate: (tshirt: TShirtFromApi) => tshirt.brand,
+       }
+     * ```
+     * in the above, all unique values from `brand` will be used to populate the `Brand` filter.
+     */
+    filterValuePredicate: (data: SortableEntity) => string;
+};
+/**
+ * Allows customization of labels related to filter.
+ *
+ */
+export type FilterBarLocalization = {
+    /**
+     * The string prefix displayed when a sorting value is selected in the menu.
+     *
+     * @default "Sorted by:"
+     * @example
+     *
+     * `sortedByLabel`: "Sorted by: "
+     *
+     * Example of sorting options
+     * - Name
+     * - Email (selected)
+     * - Date of birth
+     *
+     * UI shows: `Sorted by: Email`.
+     */
+    sortedByLabel: string;
+    /**
+     * The string for unselected state of the sorting options.
+     *
+     * @default "Sort"
+     */
+    sortLabel: string;
+    /**
+     * The string for the active filters and the mobile filter menu label.
+     *
+     * @default "Filters"
+     */
+    filtersLabel: string;
+};
+export type TransformedFilterOption = {
+    id: string;
+    label: string;
+    value: string;
+    isChecked: boolean;
+};
+export type TransformedFilterOptions = TransformedFilterOption[];
+type CategorizedFilter = {
+    key: string;
+    label: string;
+    options: TransformedFilterOptions;
+};
+export type CategorizedFilters = CategorizedFilter[];
+export type TransformedSortingOption<SortableEntity extends object> = {
+    id: string;
+    label: string;
+    value: string;
+    isChecked: boolean;
+    sortingCompare: (itemA: SortableEntity, itemB: SortableEntity) => number;
+};
+export type TransformedSortingOptions<SortableEntity extends object> = TransformedSortingOption<SortableEntity>[];
+export type OnFilterBarFilterChange = (params: {
+    changedFilterOption: TransformedFilterOption;
+}) => void;
+export type OnFilterBarSortingChange<SortableEntity extends object> = (changedSortingOption: TransformedSortingOption<SortableEntity>) => void;
+export {};

package/dist/components/FilterBar/FiltersMenus.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import { CategorizedFilters, OnFilterBarFilterChange } from "./FilterBarProps.type";
+type FiltersMenusProps = {
+    filters: CategorizedFilters;
+    onFilterOptionChange: OnFilterBarFilterChange;
+};
+export declare const FiltersMenus: React.FC<FiltersMenusProps>;
+export {};

package/dist/components/FilterBar/SortMenu.d.ts

@@ -0,0 +1,9 @@
+import { ReactElement } from "react";
+import { FilterBarLocalization, OnFilterBarSortingChange, TransformedSortingOption } from "./FilterBarProps.type";
+type SortMenuProps<SortableEntity extends object> = {
+    localization: FilterBarLocalization;
+    sortingOptions: TransformedSortingOption<SortableEntity>[];
+    onSortOptionChange: OnFilterBarSortingChange<SortableEntity>;
+};
+export declare const SortMenu: <SortableEntity extends object>(props: SortMenuProps<SortableEntity>) => ReactElement | null;
+export {};

package/dist/components/FilterBar/index.d.ts

@@ -0,0 +1,2 @@
+export { FilterBar } from "./FilterBar";
+export * as FilterBarUtils from "./FilterBar.utils";