@spark-ui/components 17.2.2 → 17.2.3-beta.1

package/dist/src/chip/ChipIcon.d.ts

@@ -0,0 +1,8 @@
+import { ComponentPropsWithoutRef, Ref } from 'react';
+export type ChipIconProps = ComponentPropsWithoutRef<'span'> & {
+    ref?: Ref<HTMLSpanElement>;
+};
+export declare const ChipIcon: {
+    ({ children, className, ref: forwardedRef }: ChipIconProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/chip/ChipLeadingIcon.d.ts

@@ -0,0 +1,9 @@
+import { Ref } from 'react';
+import { ChipIconProps } from './ChipIcon';
+export type ChipLeadingIconProps = ChipIconProps & {
+    ref?: Ref<HTMLSpanElement>;
+};
+export declare const ChipLeadingIcon: {
+    ({ className, ref: forwardedRef, ...props }: ChipLeadingIconProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/chip/ChipTrailingIcon.d.ts

@@ -0,0 +1,9 @@
+import { Ref } from 'react';
+import { ChipIconProps } from './ChipIcon';
+export type ChipTrailingIconProps = ChipIconProps & {
+    ref?: Ref<HTMLSpanElement>;
+};
+export declare const ChipTrailingIcon: {
+    ({ className, ref: forwardedRef, ...props }: ChipTrailingIconProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/chip/index.d.mts

@@ -0,0 +1,15 @@
+import { Chip as Root } from './Chip';
+import { ChipClearButton } from './ChipClearButton';
+import { ChipContent } from './ChipContent';
+import { ChipLeadingIcon } from './ChipLeadingIcon';
+import { ChipTrailingIcon } from './ChipTrailingIcon';
+export declare const Chip: typeof Root & {
+    Content: typeof ChipContent;
+    LeadingIcon: typeof ChipLeadingIcon;
+    TrailingIcon: typeof ChipTrailingIcon;
+    ClearButton: typeof ChipClearButton;
+};
+export { type ChipClearButtonProps } from './ChipClearButton';
+export { type ChipContentProps } from './ChipContent';
+export { type ChipLeadingIconProps } from './ChipLeadingIcon';
+export { type ChipTrailingIconProps } from './ChipTrailingIcon';

package/dist/src/chip/index.d.ts

@@ -0,0 +1,15 @@
+import { Chip as Root } from './Chip';
+import { ChipClearButton } from './ChipClearButton';
+import { ChipContent } from './ChipContent';
+import { ChipLeadingIcon } from './ChipLeadingIcon';
+import { ChipTrailingIcon } from './ChipTrailingIcon';
+export declare const Chip: typeof Root & {
+    Content: typeof ChipContent;
+    LeadingIcon: typeof ChipLeadingIcon;
+    TrailingIcon: typeof ChipTrailingIcon;
+    ClearButton: typeof ChipClearButton;
+};
+export { type ChipClearButtonProps } from './ChipClearButton';
+export { type ChipContentProps } from './ChipContent';
+export { type ChipLeadingIconProps } from './ChipLeadingIcon';
+export { type ChipTrailingIconProps } from './ChipTrailingIcon';

package/dist/src/chip/useChipContext.d.ts

@@ -0,0 +1,4 @@
+import { ChipProps } from './Chip';
+export type ChipsContextType = Pick<ChipProps, 'disabled' | 'design' | 'intent' | 'onClear'>;
+export declare const ChipContext: import('react').Context<ChipsContextType>;
+export declare const useChipContext: () => ChipsContextType;

package/dist/src/chip/useChipElement.d.ts

@@ -0,0 +1,41 @@
+import { ElementType, ForwardRefExoticComponent, HTMLAttributes, KeyboardEvent, MouseEvent, ReactNode, RefAttributes } from 'react';
+interface ReturnedValue {
+    Element: ForwardRefExoticComponent<HTMLAttributes<HTMLElement> & {
+        children?: ReactNode;
+    } & RefAttributes<HTMLElement>> | ElementType;
+    chipProps: {
+        type: 'button';
+        'aria-pressed'?: boolean;
+        'data-state'?: 'on' | 'off';
+        onClick: (event: MouseEvent<HTMLButtonElement>) => void;
+        onKeyDown?: (event: KeyboardEvent<HTMLButtonElement>) => void;
+        disabled?: boolean;
+        children: ReactNode;
+    } | {
+        'aria-disabled'?: boolean;
+        children: ReactNode;
+        onKeyDown?: (event: KeyboardEvent<HTMLButtonElement>) => void;
+    };
+    compoundElements: {
+        leadingIcon: ReactNode;
+        trailingIcon: ReactNode;
+        content: ReactNode;
+        clearButton: ReactNode;
+    };
+}
+export declare const useChipElement: ({ onClick, asChild, pressed, defaultPressed, disabled, value, defaultValue, children, onClear, }: {
+    onClick?: (event: MouseEvent<HTMLButtonElement>, args: {
+        pressed: boolean;
+        value?: string | number | readonly string[];
+    }) => void;
+    onKeyDown?: (event: KeyboardEvent<HTMLButtonElement>) => void;
+    asChild?: boolean;
+    pressed?: boolean;
+    defaultPressed?: boolean;
+    value?: string | number | readonly string[];
+    defaultValue?: string | number | readonly string[];
+    disabled?: boolean;
+    children?: ReactNode;
+    onClear?: (event?: MouseEvent<HTMLButtonElement>) => void;
+}) => ReturnedValue;
+export {};

package/dist/src/chip/variants/dashed.d.ts

@@ -0,0 +1,45 @@
+export declare const dashedVariants: readonly [{
+    readonly intent: "main";
+    readonly design: "dashed";
+    readonly class: string[];
+}, {
+    readonly intent: "support";
+    readonly design: "dashed";
+    readonly class: string[];
+}, {
+    readonly intent: "accent";
+    readonly design: "dashed";
+    readonly class: string[];
+}, {
+    readonly intent: "success";
+    readonly design: "dashed";
+    readonly class: string[];
+}, {
+    readonly intent: "alert";
+    readonly design: "dashed";
+    readonly class: string[];
+}, {
+    readonly intent: "danger";
+    readonly design: "dashed";
+    readonly class: string[];
+}, {
+    readonly intent: "info";
+    readonly design: "dashed";
+    readonly class: string[];
+}, {
+    readonly intent: "neutral";
+    readonly design: "dashed";
+    readonly class: string[];
+}, {
+    readonly intent: "surface";
+    readonly design: "dashed";
+    readonly class: string[];
+}, {
+    readonly design: "dashed";
+    readonly hasClearButton: false;
+    readonly class: string[];
+}, {
+    readonly design: "dashed";
+    readonly hasClearButton: true;
+    readonly class: string[];
+}];

package/dist/src/chip/variants/index.d.mts

@@ -0,0 +1,3 @@
+export { outlinedVariants } from './outlined';
+export { tintedVariants } from './tinted';
+export { dashedVariants } from './dashed';

package/dist/src/chip/variants/index.d.ts

@@ -0,0 +1,3 @@
+export { outlinedVariants } from './outlined';
+export { tintedVariants } from './tinted';
+export { dashedVariants } from './dashed';

package/dist/src/chip/variants/outlined.d.ts

@@ -0,0 +1,45 @@
+export declare const outlinedVariants: readonly [{
+    readonly design: "outlined";
+    readonly intent: "main";
+    readonly class: string[];
+}, {
+    readonly design: "outlined";
+    readonly intent: "support";
+    readonly class: string[];
+}, {
+    readonly intent: "accent";
+    readonly design: "outlined";
+    readonly class: string[];
+}, {
+    readonly design: "outlined";
+    readonly intent: "success";
+    readonly class: string[];
+}, {
+    readonly intent: "alert";
+    readonly design: "outlined";
+    readonly class: string[];
+}, {
+    readonly design: "outlined";
+    readonly intent: "danger";
+    readonly class: string[];
+}, {
+    readonly design: "outlined";
+    readonly intent: "info";
+    readonly class: string[];
+}, {
+    readonly design: "outlined";
+    readonly intent: "neutral";
+    readonly class: string[];
+}, {
+    readonly design: "outlined";
+    readonly intent: "surface";
+    readonly class: string[];
+}, {
+    readonly design: "outlined";
+    readonly hasClearButton: false;
+    readonly class: string[];
+}, {
+    readonly design: "outlined";
+    readonly hasClearButton: true;
+    readonly class: string[];
+}];

package/dist/src/chip/variants/tinted.d.ts

@@ -0,0 +1,45 @@
+export declare const tintedVariants: readonly [{
+    readonly intent: "main";
+    readonly design: "tinted";
+    readonly class: string[];
+}, {
+    readonly intent: "support";
+    readonly design: "tinted";
+    readonly class: string[];
+}, {
+    readonly intent: "accent";
+    readonly design: "tinted";
+    readonly class: string[];
+}, {
+    readonly intent: "success";
+    readonly design: "tinted";
+    readonly class: string[];
+}, {
+    readonly intent: "alert";
+    readonly design: "tinted";
+    readonly class: string[];
+}, {
+    readonly intent: "danger";
+    readonly design: "tinted";
+    readonly class: string[];
+}, {
+    readonly intent: "info";
+    readonly design: "tinted";
+    readonly class: string[];
+}, {
+    readonly intent: "neutral";
+    readonly design: "tinted";
+    readonly class: string[];
+}, {
+    readonly intent: "surface";
+    readonly design: "tinted";
+    readonly class: string[];
+}, {
+    readonly design: "tinted";
+    readonly hasClearButton: false;
+    readonly class: string[];
+}, {
+    readonly design: "tinted";
+    readonly hasClearButton: true;
+    readonly class: string[];
+}];

package/dist/src/circular-meter/CircularMeter.d.ts

@@ -0,0 +1,34 @@
+import { Meter as BaseMeter } from '@base-ui/react/meter';
+import { ComponentProps, PropsWithChildren, Ref } from 'react';
+import { MeterIndicatorStylesProps } from '../meter/MeterTrack.styles';
+import { CircularMeterStylesProps } from './CircularMeter.styles';
+export type CircularMeterSize = 'sm' | 'md' | 'lg' | 'xl';
+export interface CircularMeterProps extends Omit<ComponentProps<typeof BaseMeter.Root>, 'render'>, Pick<MeterIndicatorStylesProps, 'intent'>, CircularMeterStylesProps {
+    /**
+     * Size of the circle.
+     *
+     * - `sm`: 24px diameter, 4px stroke width
+     * - `md`: 64px diameter, 8px stroke width
+     * - `lg`: 96px diameter, 8px stroke width
+     * - `xl`: 128px diameter, 8px stroke width
+     *
+     * Defaults to `md`.
+     */
+    size?: CircularMeterSize;
+    /**
+     * Change the default rendered element for the one passed as a child, merging their props and behavior.
+     */
+    asChild?: boolean;
+    ref?: Ref<HTMLDivElement>;
+    /**
+     * Orientation of the circular meter.
+     *
+     * - `vertical`: Elements are stacked vertically (default)
+     * - `horizontal`: Elements are arranged horizontally
+     */
+    orientation?: 'vertical' | 'horizontal';
+}
+export declare const CircularMeter: {
+    ({ className, value, max, min, size: sizeProp, intent, orientation, children, ref, ...others }: PropsWithChildren<CircularMeterProps>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/circular-meter/CircularMeter.styles.d.ts

@@ -0,0 +1,5 @@
+import { VariantProps } from 'class-variance-authority';
+export declare const circularMeterStyles: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type CircularMeterStylesProps = VariantProps<typeof circularMeterStyles>;

package/dist/src/circular-meter/CircularMeterContent.d.ts

@@ -0,0 +1,6 @@
+import { ComponentProps, PropsWithChildren } from 'react';
+export type CircularMeterContentProps = ComponentProps<'div'> & PropsWithChildren;
+export declare const CircularMeterContent: {
+    ({ className, children, ...others }: CircularMeterContentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/circular-meter/CircularMeterContext.d.ts

@@ -0,0 +1,36 @@
+import { MeterIndicatorStylesProps } from '../meter/MeterTrack.styles';
+import { CircularMeterSize } from './CircularMeter';
+export interface CircularMeterContextValue {
+    value: number;
+    max: number;
+    min: number;
+    intent: MeterIndicatorStylesProps['intent'];
+    onLabelId: (id?: string) => void;
+    /**
+     * Size variant of the circular meter.
+     */
+    sizeProp: CircularMeterSize;
+    /**
+     * Orientation of the circular meter.
+     */
+    orientation: 'vertical' | 'horizontal';
+    /**
+     * Diameter of the SVG circle in pixels.
+     */
+    size: number;
+    /**
+     * Radius of the SVG circle in pixels.
+     */
+    radius: number;
+    /**
+     * Circumference of the SVG circle in pixels.
+     */
+    circumference: number;
+    /**
+     * Stroke width of the SVG circle in pixels.
+     */
+    strokeWidth: number;
+}
+export declare const CircularMeterContext: import('react').Context<CircularMeterContextValue | null>;
+export declare const ID_PREFIX = ":circular-meter";
+export declare const useCircularMeter: () => CircularMeterContextValue;

package/dist/src/circular-meter/CircularMeterLabel.d.ts

@@ -0,0 +1,7 @@
+import { Meter as BaseMeter } from '@base-ui/react/meter';
+import { ComponentProps } from 'react';
+export type CircularMeterLabelProps = Omit<ComponentProps<typeof BaseMeter.Label>, 'render'>;
+export declare const CircularMeterLabel: {
+    ({ id: idProp, children, className, ref: forwardedRef, ...others }: CircularMeterLabelProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/circular-meter/CircularMeterTrack.d.ts

@@ -0,0 +1,8 @@
+import { Meter as BaseMeter } from '@base-ui/react/meter';
+import { ComponentProps, PropsWithChildren } from 'react';
+export declare const useCircularMeterTrack: () => boolean;
+export type CircularMeterTrackProps = Omit<ComponentProps<typeof BaseMeter.Track>, 'render'> & PropsWithChildren;
+export declare const CircularMeterTrack: {
+    ({ className, children, ...others }: CircularMeterTrackProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/circular-meter/CircularMeterValue.d.ts

@@ -0,0 +1,7 @@
+import { Meter as BaseMeter } from '@base-ui/react/meter';
+import { ComponentProps, PropsWithChildren } from 'react';
+export type CircularMeterValueProps = Omit<ComponentProps<typeof BaseMeter.Value>, 'render'>;
+export declare const CircularMeterValue: {
+    ({ className, children, ...others }: PropsWithChildren<CircularMeterValueProps>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/circular-meter/index.d.mts

@@ -0,0 +1,16 @@
+import { CircularMeter as Root } from './CircularMeter';
+import { CircularMeterContent } from './CircularMeterContent';
+import { CircularMeterLabel } from './CircularMeterLabel';
+import { CircularMeterTrack } from './CircularMeterTrack';
+import { CircularMeterValue } from './CircularMeterValue';
+export declare const CircularMeter: typeof Root & {
+    Content: typeof CircularMeterContent;
+    Label: typeof CircularMeterLabel;
+    Track: typeof CircularMeterTrack;
+    Value: typeof CircularMeterValue;
+};
+export { type CircularMeterProps } from './CircularMeter';
+export { type CircularMeterContentProps } from './CircularMeterContent';
+export { type CircularMeterLabelProps } from './CircularMeterLabel';
+export { type CircularMeterTrackProps } from './CircularMeterTrack';
+export { type CircularMeterValueProps } from './CircularMeterValue';

package/dist/src/circular-meter/index.d.ts

@@ -0,0 +1,16 @@
+import { CircularMeter as Root } from './CircularMeter';
+import { CircularMeterContent } from './CircularMeterContent';
+import { CircularMeterLabel } from './CircularMeterLabel';
+import { CircularMeterTrack } from './CircularMeterTrack';
+import { CircularMeterValue } from './CircularMeterValue';
+export declare const CircularMeter: typeof Root & {
+    Content: typeof CircularMeterContent;
+    Label: typeof CircularMeterLabel;
+    Track: typeof CircularMeterTrack;
+    Value: typeof CircularMeterValue;
+};
+export { type CircularMeterProps } from './CircularMeter';
+export { type CircularMeterContentProps } from './CircularMeterContent';
+export { type CircularMeterLabelProps } from './CircularMeterLabel';
+export { type CircularMeterTrackProps } from './CircularMeterTrack';
+export { type CircularMeterValueProps } from './CircularMeterValue';

package/dist/src/circular-meter/useIntersectionAnimation.d.ts

@@ -0,0 +1,26 @@
+import { RefObject } from 'react';
+export interface UseIntersectionAnimationOptions {
+    /**
+     * The threshold at which the callback should be triggered.
+     * A value of 0 means as soon as any part of the element is visible.
+     * A value of 1 means the entire element must be visible.
+     * @default 0.1
+     */
+    threshold?: number;
+    /**
+     * The root margin for the Intersection Observer.
+     * This can be used to trigger the animation before the element enters the viewport.
+     * @default undefined
+     */
+    rootMargin?: string;
+}
+/**
+ * Hook to trigger an animation callback when an element enters the viewport.
+ * The callback is only triggered once, when the element first becomes visible.
+ *
+ * @param elementRef - Reference to the element to observe
+ * @param onIntersect - Callback to execute when the element enters the viewport
+ * @param options - Configuration options for the Intersection Observer
+ * @returns Whether the animation has been triggered
+ */
+export declare function useIntersectionAnimation(elementRef: RefObject<Element | null>, onIntersect: () => void, options?: UseIntersectionAnimationOptions): boolean;

package/dist/src/collapsible/Content.d.ts

@@ -0,0 +1,12 @@
+import { Collapsible } from '@base-ui/react/collapsible';
+import { ComponentProps } from 'react';
+export interface ContentProps extends ComponentProps<typeof Collapsible.Panel> {
+    /**
+     * Change the default rendered element for the one passed as a child, merging their props and behavior.
+     */
+    asChild?: boolean;
+}
+export declare const Content: {
+    ({ asChild, className, children, hiddenUntilFound, ...props }: ContentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/collapsible/Root.d.ts

@@ -0,0 +1,12 @@
+import { Collapsible } from '@base-ui/react/collapsible';
+import { ComponentProps } from 'react';
+export interface RootProps extends ComponentProps<typeof Collapsible.Root> {
+    /**
+     * Change the default rendered element for the one passed as a child, merging their props and behavior.
+     */
+    asChild?: boolean;
+}
+export declare const Root: {
+    ({ asChild, children, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/collapsible/Trigger.d.ts

@@ -0,0 +1,11 @@
+import { ComponentProps } from 'react';
+export interface TriggerProps extends ComponentProps<'button'> {
+    /**
+     * Change the default rendered element for the one passed as a child, merging their props and behavior.
+     */
+    asChild?: boolean;
+}
+export declare const Trigger: {
+    ({ asChild, children, ...props }: TriggerProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/collapsible/index.d.mts

@@ -0,0 +1,7 @@
+import { Content } from './Content';
+import { Root } from './Root';
+import { Trigger } from './Trigger';
+export declare const Collapsible: typeof Root & {
+    Trigger: typeof Trigger;
+    Content: typeof Content;
+};

package/dist/src/collapsible/index.d.ts

@@ -0,0 +1,7 @@
+import { Content } from './Content';
+import { Root } from './Root';
+import { Trigger } from './Trigger';
+export declare const Collapsible: typeof Root & {
+    Trigger: typeof Trigger;
+    Content: typeof Content;
+};

package/dist/src/collapsible/useRenderSlot.d.ts

@@ -0,0 +1,3 @@
+export declare function useRenderSlot(asChild: boolean, defaultTag: string): (({ ...props }: {
+    [x: string]: any;
+}) => import("react/jsx-runtime").JSX.Element) | undefined;

package/dist/src/combobox/Combobox.d.ts

@@ -0,0 +1,6 @@
+import { ComboboxContextProps } from './ComboboxContext';
+export type ComboboxProps = ComboboxContextProps;
+export declare const Combobox: {
+    ({ children, ...props }: ComboboxProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/combobox/ComboboxClearButton.d.ts

@@ -0,0 +1,9 @@
+import { ComponentPropsWithoutRef, Ref } from 'react';
+export interface ClearButtonProps extends ComponentPropsWithoutRef<'button'> {
+    'aria-label': string;
+    ref?: Ref<HTMLButtonElement>;
+}
+export declare const ClearButton: {
+    ({ className, tabIndex, onClick, ref, ...others }: ClearButtonProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/combobox/ComboboxContext.d.ts

@@ -0,0 +1,108 @@
+import { Dispatch, PropsWithChildren, RefObject, SetStateAction } from 'react';
+import { ComboboxItem, DownshiftState, ItemsMap } from './types';
+export interface ComboboxContextState extends DownshiftState {
+    itemsMap: ItemsMap;
+    filteredItemsMap: ItemsMap;
+    highlightedItem: ComboboxItem | undefined;
+    hasPopover: boolean;
+    areSelectedItemsInTrigger: boolean;
+    multiple: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+    wrap?: boolean;
+    state?: 'error' | 'alert' | 'success';
+    lastInteractionType: 'mouse' | 'keyboard';
+    setHasPopover: Dispatch<SetStateAction<boolean>>;
+    setAreSelectedItemsInTrigger: Dispatch<SetStateAction<boolean>>;
+    setLastInteractionType: (type: 'mouse' | 'keyboard') => void;
+    setOnInputValueChange: Dispatch<SetStateAction<((v: string) => void) | null>>;
+    innerInputRef: RefObject<HTMLInputElement | null>;
+    triggerAreaRef: RefObject<HTMLDivElement | null>;
+    isLoading?: boolean;
+    isTyping?: boolean;
+    setIsTyping: Dispatch<SetStateAction<boolean>>;
+}
+export type ComboboxContextCommonProps = PropsWithChildren<{
+    /**
+     * The controlled open state of the select. Must be used in conjunction with `onOpenChange`.
+     */
+    open?: boolean;
+    /**
+     * Event handler called when the open state of the select changes.
+     */
+    onOpenChange?: (isOpen: boolean) => void;
+    /**
+     * The open state of the select when it is initially rendered. Use when you do not need to control its open state.
+     */
+    defaultOpen?: boolean;
+    /**
+     * Use `state` prop to assign a specific state to the combobox, choosing from: `error`, `alert` and `success`. By doing so, the outline styles will be updated.
+     */
+    state?: 'error' | 'alert' | 'success';
+    /**
+     * When true, prevents the user from interacting with the combobox.
+     */
+    disabled?: boolean;
+    /**
+     * Sets the combobox as interactive or not.
+     */
+    readOnly?: boolean;
+    /**
+     * When true, the items will be filtered depending on the value of the input (not case-sensitive).
+     */
+    filtering?: 'none' | 'auto' | 'strict';
+    /**
+     * By default, the combobox will clear or restore the input value to the selected item value on blur.
+     */
+    allowCustomValue?: boolean;
+    /**
+     * In multiple selection, many selected items might be displayed. Be default, the combobox trigger will expand vertically to display them all.
+     * If you wish to keep every item on a single line, disabled this property.
+     */
+    wrap?: boolean;
+    /**
+     * Display a spinner to indicate to the user that the combobox is loading results for .
+     */
+    isLoading?: boolean;
+}>;
+interface ComboboxPropsSingle {
+    /**
+     * Prop 'multiple' indicating whether multiple values are allowed.
+     */
+    multiple?: false;
+    /**
+     * The value of the select when initially rendered. Use when you do not need to control the state of the select.
+     */
+    defaultValue?: string;
+    /**
+     * The controlled value of the select. Should be used in conjunction with `onValueChange`.
+     */
+    value?: string | null;
+    /**
+     * Event handler called when the value changes.
+     */
+    onValueChange?: (value: string) => void;
+}
+interface ComboboxPropsMultiple {
+    /**
+     * Prop 'multiple' indicating whether multiple values are allowed.
+     */
+    multiple: true;
+    /**
+     * The value of the select when initially rendered. Use when you do not need to control the state of the select.
+     */
+    defaultValue?: string[];
+    /**
+     * The controlled value of the select. Should be used in conjunction with `onValueChange`.
+     */
+    value?: string[];
+    /**
+     * Event handler called when the value changes.
+     */
+    onValueChange?: (value: string[]) => void;
+}
+export type ComboboxContextProps = ComboboxContextCommonProps & (ComboboxPropsSingle | ComboboxPropsMultiple);
+export declare const ID_PREFIX = ":combobox";
+export declare const ComboboxProvider: ({ children, state: stateProp, allowCustomValue, filtering, disabled: disabledProp, multiple, readOnly: readOnlyProp, wrap, value: controlledValue, defaultValue, onValueChange, open: controlledOpen, defaultOpen, onOpenChange, isLoading, }: ComboboxContextProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useComboboxContext: () => ComboboxContextState;
+export {};

package/dist/src/combobox/ComboboxDisclosure.d.ts

@@ -0,0 +1,13 @@
+import { ComponentProps, Ref } from 'react';
+import { IconButton } from '../icon-button';
+interface DisclosureProps extends Omit<ComponentProps<typeof IconButton>, 'aria-label'> {
+    className?: string;
+    closedLabel: string;
+    openedLabel: string;
+    ref?: Ref<HTMLButtonElement>;
+}
+export declare const Disclosure: {
+    ({ className, closedLabel, openedLabel, intent, design, size, ref: forwardedRef, ...props }: DisclosureProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export {};

package/dist/src/combobox/ComboboxEmpty.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode, Ref } from 'react';
+interface EmptyProps {
+    className?: string;
+    children: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+}
+export declare const Empty: {
+    ({ className, children, ref: forwardedRef }: EmptyProps): import("react/jsx-runtime").JSX.Element | null;
+    displayName: string;
+};
+export {};