@salt-ds/lab 1.0.0-alpha.0

package/dist-types/pagination/RegularControls.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+export interface RegularControlsProps {
+    count: number;
+    page: number;
+    onPageChange: (page: number) => void;
+    boundaryCount?: number;
+    siblingCount?: number;
+}
+export declare function RegularControls({ page, count, onPageChange, siblingCount, boundaryCount, }: RegularControlsProps): JSX.Element;

package/dist-types/pagination/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Pagination";
+export * from "./Paginator";
+export * from "./GoToInput";

package/dist-types/pagination/usePagination.d.ts

@@ -0,0 +1,2 @@
+export declare type PageRange = [number, number];
+export declare function usePagination(page: number, count: number, boundaryCount: number, siblingCount: number): readonly [PageRange | undefined, PageRange, PageRange | undefined];

package/dist-types/pagination/usePaginationContext.d.ts

@@ -0,0 +1 @@
+export declare const usePaginationContext: () => import("./PaginationContext").PaginationContext;

package/dist-types/pagination/utils.d.ts

@@ -0,0 +1 @@
+export declare const withBaseName: import("@salt-ds/core").ClassNamePrefixer;

package/dist-types/panel/Panel.d.ts

@@ -0,0 +1,20 @@
+import { HTMLAttributes } from "react";
+import "./Panel.css";
+/**
+ * Panel component that acts as wrapper around a node
+ *
+ * @example
+ * const PanelExample = () => (
+ *   <Panel>
+ *     <p>This is a panel around some text.</p>
+ *   </Panel>
+ * );
+ *
+ */
+export interface PanelProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * Styling variant; defaults to "primary".
+     */
+    variant?: "primary" | "secondary";
+}
+export declare const Panel: import("react").ForwardRefExoticComponent<PanelProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/panel/index.d.ts

@@ -0,0 +1 @@
+export * from "./Panel";

package/dist-types/parent-child-item/ParentChildItem.d.ts

@@ -0,0 +1,32 @@
+import { HTMLAttributes } from "react";
+import { flexItemAlignment, ResponsiveProp } from "@salt-ds/core";
+import "./ParentChildItem.css";
+export declare type SlideDirection = "top" | "bottom" | "left" | "right";
+export interface ParentChildItemProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * Allows the alignment specified by parent to be overridden for individual items, default is "start".
+     */
+    align?: flexItemAlignment;
+    /**
+     * Disable all animations.
+     */
+    disableAnimations?: boolean;
+    /**
+     * Direction for slide animations.
+     */
+    direction?: SlideDirection;
+    /**
+     * Defines the ability for an item to grow x times more compared to it's siblings, default is 0.
+     */
+    grow?: ResponsiveProp<number>;
+    /**
+     * Determines whether the component is stacked
+     */
+    isStacked?: boolean;
+    /**
+     * Defines the ability for an item to shrink x times more compared to it's siblings, default is 1.
+  
+     */
+    shrink?: ResponsiveProp<number>;
+}
+export declare const ParentChildItem: import("react").ForwardRefExoticComponent<ParentChildItemProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/parent-child-item/index.d.ts

@@ -0,0 +1 @@
+export * from "./ParentChildItem";

package/dist-types/parent-child-layout/ParentChildLayout.d.ts

@@ -0,0 +1,37 @@
+import { Breakpoints, FlexLayoutProps } from "@salt-ds/core";
+import { ElementType, HTMLAttributes, ReactNode } from "react";
+import "./ParentChildLayout.css";
+export declare type StackedViewElement = "parent" | "child";
+declare type Orientation = "horizontal" | "vertical";
+export interface ParentChildLayoutProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * Breakpoint at which the parent and child will stack.
+     */
+    stackedAtBreakpoint?: keyof Breakpoints;
+    /**
+     * Change element that is displayed when in staked view.
+     */
+    stackedViewElement?: StackedViewElement;
+    /**
+     * Disable all animations.
+     */
+    disableAnimations?: boolean;
+    /**
+     * Orientation for slide animations.
+     */
+    orientation?: Orientation;
+    /**
+     * Controls the space between columns.
+     */
+    gap?: FlexLayoutProps<ElementType>["gap"];
+    /**
+     * Parent component to be rendered
+     */
+    parent: ReactNode;
+    /**
+     * Child component to be rendered
+     */
+    child: ReactNode;
+}
+export declare const ParentChildLayout: import("react").ForwardRefExoticComponent<ParentChildLayoutProps & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/dist-types/parent-child-layout/index.d.ts

@@ -0,0 +1 @@
+export * from "./ParentChildLayout";

package/dist-types/pill/ClosablePill.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { PillBaseProps } from "./PillBase";
+export interface ClosablePillProps extends Omit<PillBaseProps, "clickable"> {
+    /**
+     * Clickable Pill is not supported by Closable variant.
+     */
+    clickable?: false;
+}
+export declare const ClosablePill: import("react").ForwardRefExoticComponent<PillBaseProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/pill/Pill.d.ts

@@ -0,0 +1,16 @@
+import { ForwardedRef, ReactElement } from "react";
+import { ClosablePillProps } from "./ClosablePill";
+import { PillBaseProps } from "./PillBase";
+import { SelectablePillProps } from "./SelectablePill";
+import "./Pill.css";
+export declare type PillVariant = "basic" | "closable" | "selectable";
+export interface PillVariantProps<T extends PillVariant = "basic"> {
+    /**
+     * Determines the variant of pill
+     */
+    variant?: T;
+}
+export declare type PillProps<T extends PillVariant = "basic"> = T extends "closable" ? ClosablePillProps & PillVariantProps<T> : T extends "basic" ? PillBaseProps & PillVariantProps<T> : SelectablePillProps & PillVariantProps<T>;
+export declare const Pill: <T extends PillVariant = "basic">(p: PillProps<T> & {
+    ref?: ForwardedRef<HTMLDivElement> | undefined;
+}) => ReactElement<PillProps<T>, string | import("react").JSXElementConstructor<any>>;

package/dist-types/pill/PillBase.d.ts

@@ -0,0 +1,53 @@
+import { HTMLAttributes, ReactElement, ReactEventHandler, SyntheticEvent } from "react";
+import { TooltipProps } from "../tooltip";
+import "./Pill.css";
+export interface PillBaseProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * Props passed to the tooltip
+     */
+    TooltipProps?: Partial<TooltipProps>;
+    /**
+     * Defines a human-readable, author-localized description for the role of an element.
+     *
+     * This should be in favour of aria-label for `Pill`
+     **/
+    "aria-roledescription"?: string;
+    /**
+     * Clickable variation. Use 'onClick' for callback.
+     */
+    clickable?: boolean;
+    /**
+     * Shows delete icon. Use `onDelete` for callback.
+     */
+    deletable?: boolean;
+    /**
+     * Override the default delete icon element. Shown only if `deletable` is set.
+     */
+    deleteIcon?: ReactElement;
+    /**
+     * If `true`, the pill will be disabled.
+     */
+    disabled?: boolean;
+    /**
+     * Whether the pill is been highlighted.
+     * If `true`, the pill will display Tooltip when text within is truncated.
+     */
+    highlighted?: boolean;
+    /**
+     * Icon element.
+     */
+    icon?: ReactElement;
+    /**
+     * The content of the label.
+     */
+    label?: string;
+    /**
+     * Callback function fired when pill is clicked.
+     */
+    onClick?: (event: SyntheticEvent<HTMLDivElement>) => void;
+    /**
+     * Callback function fired when the delete icon is clicked. Used when `deletable` is true.
+     */
+    onDelete?: ReactEventHandler<HTMLElement>;
+}
+export declare const PillBase: import("react").ForwardRefExoticComponent<PillBaseProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/pill/SelectablePill.d.ts

@@ -0,0 +1,17 @@
+import { SyntheticEvent } from "react";
+import { PillBaseProps } from "./PillBase";
+export interface SelectablePillProps extends Omit<PillBaseProps, "onChange"> {
+    /**
+     * Controls whether the selectable pill is checked
+     */
+    checked?: boolean;
+    /**
+     * Uncontrolled prop to determine initial state of selectable pill
+     */
+    defaultChecked?: boolean;
+    /**
+     * Callback when checked state is changed
+     */
+    onChange?: (event: SyntheticEvent, checked: boolean) => void;
+}
+export declare const SelectablePill: import("react").ForwardRefExoticComponent<SelectablePillProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/pill/constants.d.ts

@@ -0,0 +1 @@
+export declare const pillBaseName = "saltPill";

package/dist-types/pill/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Pill";
+export * from "./ClosablePill";
+export * from "./SelectablePill";

package/dist-types/pill/internal/DeleteButton.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { ButtonProps } from "@salt-ds/core";
+export interface DeleteButtonProps extends ButtonProps {
+    /**
+     * Active state.
+     */
+    active?: boolean;
+}
+export declare const DeleteButton: (props: DeleteButtonProps) => JSX.Element;

package/dist-types/pill/internal/DivButton.d.ts

@@ -0,0 +1,12 @@
+import { ComponentPropsWithoutRef } from "react";
+export interface DivButtonProps extends ComponentPropsWithoutRef<"div"> {
+    /**
+     * If `true`, the button will be disabled.
+     */
+    disabled?: boolean;
+    /**
+     * If `true`, the button will be focusable when disabled.
+     */
+    focusableWhenDisabled?: boolean;
+}
+export declare const DivButton: import("react").ForwardRefExoticComponent<DivButtonProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/pill/internal/PillCheckbox.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import "./PillCheckbox.css";
+export declare const PillCheckbox: (props: {
+    checked?: boolean;
+}) => JSX.Element;

package/dist-types/popper/index.d.ts

@@ -0,0 +1 @@
+export * from "./useFloatingUI";

package/dist-types/popper/useFloatingUI.d.ts

@@ -0,0 +1,5 @@
+import type { Props } from "@floating-ui/react-dom-interactions";
+import { useFloating } from "@floating-ui/react-dom-interactions";
+export declare type UseFloatingUIProps = Partial<Pick<Props, "placement" | "strategy" | "middleware" | "open" | "onOpenChange">>;
+export declare const DEFAULT_FLOATING_UI_MIDDLEWARE: import("@floating-ui/react-dom-interactions").Middleware[];
+export declare function useFloatingUI(props: UseFloatingUIProps): ReturnType<typeof useFloating>;

package/dist-types/portal/Portal.d.ts

@@ -0,0 +1,29 @@
+import { ReactNode } from "react";
+export interface PortalProps {
+    /**
+     * The children to render into the `container`.
+     */
+    children?: ReactNode;
+    /**
+     * An HTML element, component instance, or function that returns either.
+     * The `container` will have the portal children appended to it.
+     *
+     * By default, it uses the body of the top-level document object,
+     * so it's simply `document.body` most of the time.
+     */
+    container?: Element | (() => Element | null) | null;
+    /**
+     * Disable the portal behavior.
+     * The children stay within it's parent DOM hierarchy.
+     */
+    disablePortal?: boolean;
+    /**
+     * If this node does not exist on the document, it will be created for you.
+     */
+    id?: string;
+}
+/**
+ * Portals provide a first-class way to render children into a DOM node
+ * that exists outside the DOM hierarchy of the parent component.
+ */
+export declare const Portal: import("react").ForwardRefExoticComponent<PortalProps & import("react").RefAttributes<HTMLElement>>;

package/dist-types/portal/index.d.ts

@@ -0,0 +1 @@
+export * from "./Portal";

package/dist-types/progress/CircularProgress/CircularProgress.d.ts

@@ -0,0 +1,67 @@
+import { HTMLAttributes, ReactElement } from "react";
+import { InfoRendererProps } from "../LinearProgress/LinearProgress";
+import "./CircularProgress.css";
+export declare const SIZE_OPTIONS: {
+    small: {
+        container: number;
+    };
+    medium: {
+        container: number;
+    };
+    large: {
+        container: number;
+    };
+};
+export interface CircularProgressProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * A label for accessibility
+     */
+    "aria-label"?: string;
+    /**
+     * The className(s) of the component
+     */
+    className?: string;
+    /**
+     * Disabled flag, true when the component is disabled.
+     */
+    disabled?: boolean;
+    /**
+     * Render props callback to render info panel.
+     * @param function({ value, unit, getValueProps })
+     */
+    renderInfo?: (props: Pick<InfoRendererProps<any, any>, "value" | "unit" | "getValueProps">) => ReactElement<InfoRendererProps<any, any>>;
+    /**
+     * If `true`, the info panel will be displayed.
+     */
+    showInfo?: boolean;
+    /**
+     * The size of the circle
+     * (small, medium, large)
+     */
+    size?: "small" | "medium" | "large";
+    /**
+     * Default unit is`%`
+     */
+    unit?: string;
+    /**
+     * The value of the progress indicator for the determinate and static variants.
+     * Value between 0 and 100.
+     */
+    value?: number;
+    /**
+     * The variant to use.
+     * Use indeterminate or query when there is no progress value.
+     */
+    variant?: "determinate" | "indeterminate" | "static";
+}
+/**
+ * Circular progress bar with an optional Info element, showing the current value
+ * The default Info element can be rendered by setting `unit` and `value` props.
+ * A custom Info element can be rendered using the `renderInfo` callback.
+ * The render props callback is of the form
+ * @param {string} unit the unit of the progress info
+ * @param {number} value the value of the progress info
+ * @param {string} variant the variant to use.
+ * @param {function} getValueProps function callback that returns the value props
+ */
+export declare const CircularProgress: import("react").ForwardRefExoticComponent<CircularProgressProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/progress/CircularProgress/CircularProgressParts.d.ts

@@ -0,0 +1,14 @@
+import { CSSProperties, ReactNode } from "react";
+import "./CircularProgress.css";
+export declare const SIZE = 44;
+export declare const circularGradientId = "salt-circular-progress-gradient";
+export declare const ViewBox: (props: {
+    children?: ReactNode;
+}) => JSX.Element;
+export declare const LinearGradient: () => JSX.Element;
+export interface CircleProps {
+    strokeWidth: number;
+    style?: CSSProperties;
+    className?: string;
+}
+export declare const Circle: ({ strokeWidth, style, className }: CircleProps) => JSX.Element;

package/dist-types/progress/Info.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export interface InfoProps {
+    className: string;
+    unit: string;
+    value: number;
+}
+export declare const Info: ({ className, value, unit }: InfoProps) => JSX.Element;

package/dist-types/progress/LinearProgress/LinearProgress.d.ts

@@ -0,0 +1,59 @@
+import { HTMLAttributes, ReactElement } from "react";
+import "./LinearProgress.css";
+export interface InfoRendererProps<T, U> {
+    unit: string;
+    value: number;
+    getUnitProps?: (props: T) => {
+        className: string;
+    } & T;
+    getValueProps: (props: U) => {
+        className: string;
+    } & U;
+}
+export interface LinearProgressProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * The className(s) of the component.
+     */
+    className?: string;
+    /**
+     * Disabled flag, true when the component is disabled.
+     */
+    disabled?: boolean;
+    /**
+     * render props callback to render info panel.
+     */
+    renderInfo?: (props: Pick<InfoRendererProps<any, any>, "value" | "unit" | "getValueProps" | "getUnitProps">) => ReactElement<InfoRendererProps<any, any>>;
+    /**
+     * If `true`, the info panel will be displayed.
+     */
+    showInfo?: boolean;
+    /**
+     * The size of the line, default is 'small'.
+     */
+    size?: "small" | "medium" | "large";
+    /**
+     * Default unit is`%`.
+     */
+    unit?: string;
+    /**
+     * The value of the progress indicator for the determinate and static variants.
+     * Value between 0 and 100.
+     */
+    value?: number;
+    /**
+     * The variant to use.
+     * Use indeterminate or query when there is no progress value.
+     */
+    variant?: "determinate" | "indeterminate" | "query";
+}
+/**
+ * Linear progress bar with an optional Info element, showing the current value
+ * The default Info element can be rendered by setting `unit` and `value` props.
+ * A custom Info element can be rendered using the `renderInfo` callback.
+ * The render props callback is of the form
+ * @param {string} unit the unit of the progress info
+ * @param {number} value the value of the progress info
+ * @param {function} getUnitProps function callback that returns the unit props
+ * @param {function} getValueProps function callback that returns the value props
+ */
+export declare const LinearProgress: import("react").ForwardRefExoticComponent<LinearProgressProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/progress/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./CircularProgress/CircularProgress";
+export * from "./LinearProgress/LinearProgress";

package/dist-types/query-input/QueryInput.d.ts

@@ -0,0 +1,18 @@
+import { HTMLAttributes } from "react";
+import { QueryInputCategory, QueryInputItem } from "./queryInputTypes";
+import { BooleanOperator } from "./useQueryInput";
+import "./QueryInput.css";
+export interface QueryInputProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    disabled?: boolean;
+    categories: QueryInputCategory[];
+    selectedItems?: QueryInputItem[];
+    onChange?: (items: QueryInputItem[]) => void;
+    defaultSelectedItems?: QueryInputItem[];
+    showCategory?: boolean;
+    autoClose?: boolean;
+    displayedItemCount?: number;
+    booleanOperator?: BooleanOperator;
+    onBooleanOperatorChange?: (newOperator: BooleanOperator) => void;
+    defaultBooleanOperator?: BooleanOperator;
+}
+export declare const QueryInput: import("react").ForwardRefExoticComponent<QueryInputProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/query-input/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./queryInputTypes";
+export * from "./QueryInput";
+export * from "./useQueryInput";

package/dist-types/query-input/internal/CategoryList.d.ts

@@ -0,0 +1,10 @@
+import { Dispatch, SetStateAction } from "react";
+import { QueryInputCategory } from "../queryInputTypes";
+export interface CategoryListProps {
+    categories: QueryInputCategory[];
+    rootWidth: number;
+    onCategorySelect: (category: QueryInputCategory | null) => void;
+    highlightedCategoryIndex?: number;
+    setHighlightedCategoryIndex: Dispatch<SetStateAction<number>>;
+}
+export declare function CategoryList(props: CategoryListProps): JSX.Element;

package/dist-types/query-input/internal/CategoryListContext.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export interface CategoryListContext {
+    width: number;
+}
+export declare const CategoryListContext: import("react").Context<CategoryListContext | undefined>;
+export declare function useCategoryListContext(): CategoryListContext;

package/dist-types/query-input/internal/CategoryListItem.d.ts

@@ -0,0 +1,6 @@
+import { ListItemProps, ListItemType } from "../../list";
+import { QueryInputCategory } from "../queryInputTypes";
+export interface CategoryListItemProps extends ListItemProps<QueryInputCategory> {
+    category: QueryInputCategory;
+}
+export declare const CategoryListItem: ListItemType<QueryInputCategory>;

package/dist-types/query-input/internal/QueryInputBody.d.ts

@@ -0,0 +1,24 @@
+import { ChangeEventHandler, FocusEventHandler, KeyboardEventHandler, Ref, SyntheticEvent } from "react";
+import { ChangeHandler } from "../../tokenized-input";
+import { QueryInputItem } from "../queryInputTypes";
+import { BooleanOperator } from "../useQueryInput";
+export interface QueryInputBodyProps {
+    inputRef: Ref<HTMLInputElement>;
+    disabled?: boolean;
+    showCategory?: boolean;
+    selectedItems: QueryInputItem[];
+    onBlur: FocusEventHandler<HTMLInputElement>;
+    onFocus: FocusEventHandler<HTMLInputElement>;
+    onInputFocus: FocusEventHandler<HTMLInputElement>;
+    onInputBlur: FocusEventHandler<HTMLInputElement>;
+    onInputClick: (event: SyntheticEvent) => void;
+    onInputClear: () => void;
+    inputValue?: string;
+    onInputChange: ChangeEventHandler<HTMLInputElement>;
+    isFocused?: boolean;
+    onSelectedItemsChange: ChangeHandler<QueryInputItem>;
+    onKeyDown: KeyboardEventHandler<HTMLInputElement | HTMLButtonElement>;
+    booleanOperator: BooleanOperator;
+    onBooleanOperatorChange: (newBooleanOperator: BooleanOperator) => void;
+}
+export declare const QueryInputBody: import("react").ForwardRefExoticComponent<QueryInputBodyProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/query-input/internal/SearchList.d.ts

@@ -0,0 +1,13 @@
+import { Dispatch, SetStateAction } from "react";
+import { QueryInputCategory, QueryInputItem } from "../queryInputTypes";
+import "../QueryInput.css";
+export interface SearchListProps {
+    inputValue?: string;
+    selectedItems?: QueryInputItem[];
+    onChange: (items: QueryInputItem[]) => void;
+    rootWidth: number;
+    highlightedIndex?: number;
+    visibleCategories: QueryInputCategory[];
+    setHighlightedIndex: Dispatch<SetStateAction<number>>;
+}
+export declare function SearchList(props: SearchListProps): JSX.Element;

package/dist-types/query-input/internal/ValueList.d.ts

@@ -0,0 +1,12 @@
+import { QueryInputCategory } from "../queryInputTypes";
+import { Dispatch, SetStateAction } from "react";
+export interface ValueListProps {
+    category: QueryInputCategory | null;
+    rootWidth: number;
+    onBack: () => void;
+    selectedValues: string[];
+    onValueToggle: (category: QueryInputCategory, value: string) => void;
+    highlightedValueIndex?: number;
+    setHighlightedValueIndex: Dispatch<SetStateAction<number>>;
+}
+export declare function ValueList(props: ValueListProps): JSX.Element;

package/dist-types/query-input/internal/ValueSelector.d.ts

@@ -0,0 +1,23 @@
+import { Dispatch, Ref, SetStateAction } from "react";
+import { QueryInputCategory, QueryInputItem } from "../queryInputTypes";
+export interface ValueSelectorProps {
+    isOpen: boolean;
+    anchorElement: HTMLElement | null;
+    popperRef: Ref<HTMLDivElement>;
+    inputValue?: string;
+    categories: QueryInputCategory[];
+    selectedCategory: QueryInputCategory | null;
+    onSelectedCategoryChange: (category: QueryInputCategory | null) => void;
+    width: number;
+    selectedItems: QueryInputItem[];
+    onValueToggle: (category: QueryInputCategory, value: string) => void;
+    onSearchListChange: (items: QueryInputItem[]) => void;
+    highlightedIndex?: number;
+    visibleCategories: QueryInputCategory[];
+    highlightedCategoryIndex?: number;
+    highlightedValueIndex?: number;
+    setHighlightedIndex: Dispatch<SetStateAction<number>>;
+    setHighlightedCategoryIndex: Dispatch<SetStateAction<number>>;
+    setHighlightedValueIndex: Dispatch<SetStateAction<number>>;
+}
+export declare function ValueSelector(props: ValueSelectorProps): JSX.Element | null;

package/dist-types/query-input/internal/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./CategoryList";
+export * from "./CategoryListContext";
+export * from "./CategoryListItem";
+export * from "./QueryInputBody";
+export * from "./SearchList";
+export * from "./usePopperStatus";
+export * from "./ValueList";
+export * from "./ValueSelector";

package/dist-types/query-input/internal/usePopperStatus.d.ts

@@ -0,0 +1,13 @@
+import { FocusEvent, KeyboardEvent } from "react";
+export interface UsePopperStatusProps {
+    initialOpen?: boolean;
+    autoClose?: boolean;
+}
+export declare function usePopperStatus(props: UsePopperStatusProps): {
+    isOpen: boolean;
+    onKeyDown: (event: KeyboardEvent) => void;
+    onFocus: (event: FocusEvent) => void;
+    onBlur: (event: FocusEvent) => void;
+    onChange: () => void;
+    onClick: () => void;
+};

package/dist-types/query-input/queryInputTypes.d.ts

@@ -0,0 +1,8 @@
+export interface QueryInputCategory {
+    name: string;
+    values: string[];
+}
+export interface QueryInputItem {
+    category: string | null;
+    value: string;
+}