@spark-ui/components 10.0.0

package/dist/collapsible/index.d.ts

@@ -0,0 +1,60 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as collapsible from '@zag-js/collapsible';
+import { ComponentProps, Ref, ComponentPropsWithoutRef } from 'react';
+
+interface CollapsibleProps extends ComponentProps<'div'> {
+    /**
+     * Change the default rendered element for the one passed as a child, merging their props and behavior.
+     */
+    asChild?: boolean;
+    /**
+     * The open state of the collapsible when it is initially rendered. Use when you do not need to control its open state.
+     */
+    defaultOpen?: boolean;
+    /**
+     * When `true`, prevents the user from interacting with the collapsible.
+     */
+    disabled?: boolean;
+    /**
+     * Event handler called when the open state of the collapsible changes.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * The controlled open state of the collapsible. Must be used in conjunction with `onOpenChange`.
+     */
+    open?: boolean;
+    /**
+     * The ids of the elements in the collapsible. Useful for composition
+     */
+    ids?: collapsible.Props['ids'];
+    ref?: Ref<HTMLDivElement>;
+}
+declare const Collapsible$1: {
+    ({ asChild, children, defaultOpen, disabled, onOpenChange, open, ids, ref, ...props }: CollapsibleProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface CollapsibleContentProps extends ComponentPropsWithoutRef<'div'> {
+    asChild?: boolean;
+    ref?: Ref<HTMLDivElement>;
+}
+declare const Content: {
+    ({ asChild, className, children, ref, ...props }: CollapsibleContentProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface CollapsibleTriggerProps extends ComponentPropsWithoutRef<'button'> {
+    asChild?: boolean;
+    ref?: Ref<HTMLButtonElement>;
+}
+declare const Trigger: {
+    ({ asChild, children, ref, ...props }: CollapsibleTriggerProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const Collapsible: typeof Collapsible$1 & {
+    Trigger: typeof Trigger;
+    Content: typeof Content;
+};
+
+export { Collapsible, type CollapsibleContentProps, type CollapsibleProps, type CollapsibleTriggerProps };

package/dist/collapsible/index.js

@@ -0,0 +1,140 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/collapsible/index.ts
+var collapsible_exports = {};
+__export(collapsible_exports, {
+  Collapsible: () => Collapsible2
+});
+module.exports = __toCommonJS(collapsible_exports);
+
+// src/collapsible/Collapsible.tsx
+var collapsible = __toESM(require("@zag-js/collapsible"));
+var import_react2 = require("@zag-js/react");
+var import_react3 = require("react");
+
+// src/slot/Slot.tsx
+var import_radix_ui = require("radix-ui");
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var Slottable = import_radix_ui.Slot.Slottable;
+var Slot = ({ ref, ...props }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_radix_ui.Slot.Root, { ref, ...props });
+};
+
+// src/collapsible/Collapsible.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var CollapsibleContext = (0, import_react3.createContext)(null);
+var Collapsible = ({
+  asChild = false,
+  children,
+  defaultOpen = false,
+  disabled = false,
+  onOpenChange,
+  open,
+  ids,
+  ref,
+  ...props
+}) => {
+  const service = (0, import_react2.useMachine)(collapsible.machine, {
+    open,
+    defaultOpen,
+    disabled,
+    id: (0, import_react3.useId)(),
+    ids,
+    onOpenChange(details) {
+      onOpenChange?.(details.open);
+    }
+  });
+  const api = collapsible.connect(service, import_react2.normalizeProps);
+  const Component = asChild ? Slot : "div";
+  const mergedProps = (0, import_react2.mergeProps)(api.getRootProps(), props);
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(CollapsibleContext.Provider, { value: api, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Component, { "data-spark-component": "collapsible", ref, ...mergedProps, children }) });
+};
+Collapsible.displayName = "Collapsible";
+var useCollapsibleContext = () => {
+  const context = (0, import_react3.useContext)(CollapsibleContext);
+  if (!context) {
+    throw Error("useCollapsibleContext must be used within a Collapsible provider");
+  }
+  return context;
+};
+
+// src/collapsible/CollapsibleContent.tsx
+var import_react4 = require("@zag-js/react");
+var import_class_variance_authority = require("class-variance-authority");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var Content = ({
+  asChild = false,
+  className,
+  children,
+  ref,
+  ...props
+}) => {
+  const { getContentProps } = useCollapsibleContext();
+  const Component = asChild ? Slot : "div";
+  const contentProps = getContentProps();
+  const mergedProps = (0, import_react4.mergeProps)(contentProps, {
+    className: (0, import_class_variance_authority.cx)(
+      "overflow-hidden",
+      "motion-reduce:animate-none!",
+      "[&[hidden]]:hidden",
+      "data-[state=open]:animate-standalone-collapse-in data-[state=closed]:animate-standalone-collapse-out",
+      className
+    ),
+    ...props
+  });
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Component, { ref, "data-spark-component": "collapsible-content", ...mergedProps, children });
+};
+Content.displayName = "Collapsible.Content";
+
+// src/collapsible/CollapsibleTrigger.tsx
+var import_react5 = require("@zag-js/react");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var Trigger = ({ asChild = false, children, ref, ...props }) => {
+  const collapsibleContext = useCollapsibleContext();
+  const Component = asChild ? Slot : "button";
+  const mergedProps = (0, import_react5.mergeProps)(collapsibleContext.getTriggerProps(), props);
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Component, { ref, "data-spark-component": "collapsible-trigger", ...mergedProps, children });
+};
+Trigger.displayName = "Collapsible.Trigger";
+
+// src/collapsible/index.ts
+var Collapsible2 = Object.assign(Collapsible, {
+  Trigger,
+  Content
+});
+Collapsible2.displayName = "Collapsible";
+Trigger.displayName = "Collapsible.Trigger";
+Content.displayName = "Collapsible.Content";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Collapsible
+});
+//# sourceMappingURL=index.js.map

package/dist/collapsible/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/collapsible/index.ts","../../src/collapsible/Collapsible.tsx","../../src/slot/Slot.tsx","../../src/collapsible/CollapsibleContent.tsx","../../src/collapsible/CollapsibleTrigger.tsx"],"sourcesContent":["import { Collapsible as Root } from './Collapsible'\nimport { Content } from './CollapsibleContent'\nimport { Trigger } from './CollapsibleTrigger'\n\nexport const Collapsible: typeof Root & {\n  Trigger: typeof Trigger\n  Content: typeof Content\n} = Object.assign(Root, {\n  Trigger,\n  Content,\n})\n\nCollapsible.displayName = 'Collapsible'\nTrigger.displayName = 'Collapsible.Trigger'\nContent.displayName = 'Collapsible.Content'\n\nexport { type CollapsibleProps } from './Collapsible'\nexport { type CollapsibleContentProps } from './CollapsibleContent'\nexport { type CollapsibleTriggerProps } from './CollapsibleTrigger'\n","import * as collapsible from '@zag-js/collapsible'\nimport { mergeProps, normalizeProps, type PropTypes, useMachine } from '@zag-js/react'\nimport { type ComponentProps, createContext, Ref, useContext, useId } from 'react'\n\nimport { Slot } from '../slot'\n\nexport interface CollapsibleProps extends ComponentProps<'div'> {\n  /**\n   * Change the default rendered element for the one passed as a child, merging their props and behavior.\n   */\n  asChild?: boolean\n  /**\n   * The open state of the collapsible when it is initially rendered. Use when you do not need to control its open state.\n   */\n  defaultOpen?: boolean\n  /**\n   * When `true`, prevents the user from interacting with the collapsible.\n   */\n  disabled?: boolean\n  /**\n   * Event handler called when the open state of the collapsible changes.\n   */\n  onOpenChange?: (open: boolean) => void\n  /**\n   * The controlled open state of the collapsible. Must be used in conjunction with `onOpenChange`.\n   */\n  open?: boolean\n  /**\n   * The ids of the elements in the collapsible. Useful for composition\n   */\n  ids?: collapsible.Props['ids']\n  ref?: Ref<HTMLDivElement>\n}\n\nconst CollapsibleContext = createContext<collapsible.Api<PropTypes> | null>(null)\n\nexport const Collapsible = ({\n  asChild = false,\n  children,\n  defaultOpen = false,\n  disabled = false,\n  onOpenChange,\n  open,\n  ids,\n  ref,\n  ...props\n}: CollapsibleProps) => {\n  const service = useMachine(collapsible.machine, {\n    open,\n    defaultOpen,\n    disabled,\n    id: useId(),\n    ids,\n    onOpenChange(details) {\n      onOpenChange?.(details.open)\n    },\n  })\n  const api = collapsible.connect(service, normalizeProps)\n  const Component = asChild ? Slot : 'div'\n\n  const mergedProps = mergeProps(api.getRootProps(), props)\n\n  return (\n    <CollapsibleContext.Provider value={api}>\n      <Component data-spark-component=\"collapsible\" ref={ref} {...mergedProps}>\n        {children}\n      </Component>\n    </CollapsibleContext.Provider>\n  )\n}\n\nCollapsible.displayName = 'Collapsible'\n\nexport const useCollapsibleContext = () => {\n  const context = useContext(CollapsibleContext)\n\n  if (!context) {\n    throw Error('useCollapsibleContext must be used within a Collapsible provider')\n  }\n\n  return context\n}\n","import { Slot as RadixSlot } from 'radix-ui'\nimport {\n  cloneElement,\n  HTMLAttributes,\n  isValidElement,\n  PropsWithChildren,\n  ReactNode,\n  Ref,\n} from 'react'\n\nexport const Slottable = RadixSlot.Slottable\n\nexport type SlotProps = PropsWithChildren<HTMLAttributes<HTMLElement>> & {\n  ref?: Ref<HTMLElement>\n}\n\nexport const Slot = ({ ref, ...props }: SlotProps) => {\n  return <RadixSlot.Root ref={ref} {...props} />\n}\n\n/**\n * When using Radix `Slot` component, it will consider its first child to merge its props with.\n * In some cases, you might need to wrap the top child with additional markup without breaking this behaviour.\n */\nexport const wrapPolymorphicSlot = (\n  asChild: boolean | undefined,\n  children: ReactNode,\n  callback: (children: ReactNode) => ReactNode\n) => {\n  if (!asChild) return callback(children) // If polymorphic behaviour is not used, we keep the original children\n\n  return isValidElement(children)\n    ? cloneElement(\n        children,\n        undefined,\n        callback((children.props as { children: ReactNode }).children)\n      )\n    : null\n}\n","import { mergeProps } from '@zag-js/react'\nimport { cx } from 'class-variance-authority'\nimport { type ComponentPropsWithoutRef, Ref } from 'react'\n\nimport { Slot } from '../slot'\nimport { useCollapsibleContext } from './Collapsible'\n\nexport interface CollapsibleContentProps extends ComponentPropsWithoutRef<'div'> {\n  asChild?: boolean\n  ref?: Ref<HTMLDivElement>\n}\n\nexport const Content = ({\n  asChild = false,\n  className,\n  children,\n  ref,\n  ...props\n}: CollapsibleContentProps) => {\n  const { getContentProps } = useCollapsibleContext()\n\n  const Component = asChild ? Slot : 'div'\n  const contentProps = getContentProps()\n  const mergedProps = mergeProps(contentProps, {\n    className: cx(\n      'overflow-hidden',\n      'motion-reduce:animate-none!',\n      '[&[hidden]]:hidden',\n      'data-[state=open]:animate-standalone-collapse-in data-[state=closed]:animate-standalone-collapse-out',\n      className\n    ),\n    ...props,\n  })\n\n  return (\n    <Component ref={ref} data-spark-component=\"collapsible-content\" {...mergedProps}>\n      {children}\n    </Component>\n  )\n}\n\nContent.displayName = 'Collapsible.Content'\n","import { mergeProps } from '@zag-js/react'\nimport { type ComponentPropsWithoutRef, Ref } from 'react'\n\nimport { Slot } from '../slot'\nimport { useCollapsibleContext } from './Collapsible'\n\nexport interface CollapsibleTriggerProps extends ComponentPropsWithoutRef<'button'> {\n  asChild?: boolean\n  ref?: Ref<HTMLButtonElement>\n}\n\nexport const Trigger = ({ asChild = false, children, ref, ...props }: CollapsibleTriggerProps) => {\n  const collapsibleContext = useCollapsibleContext()\n  const Component = asChild ? Slot : 'button'\n  const mergedProps = mergeProps(collapsibleContext.getTriggerProps(), props)\n\n  return (\n    <Component ref={ref} data-spark-component=\"collapsible-trigger\" {...mergedProps}>\n      {children}\n    </Component>\n  )\n}\n\nTrigger.displayName = 'Collapsible.Trigger'\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,qBAAAA;AAAA;AAAA;;;ACAA,kBAA6B;AAC7B,IAAAC,gBAAuE;AACvE,IAAAA,gBAA2E;;;ACF3E,sBAAkC;AAClC,mBAOO;AASE;AAPF,IAAM,YAAY,gBAAAC,KAAU;AAM5B,IAAM,OAAO,CAAC,EAAE,KAAK,GAAG,MAAM,MAAiB;AACpD,SAAO,4CAAC,gBAAAA,KAAU,MAAV,EAAe,KAAW,GAAG,OAAO;AAC9C;;;AD8CM,IAAAC,sBAAA;AA9BN,IAAM,yBAAqB,6BAAiD,IAAI;AAEzE,IAAM,cAAc,CAAC;AAAA,EAC1B,UAAU;AAAA,EACV;AAAA,EACA,cAAc;AAAA,EACd,WAAW;AAAA,EACX;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,GAAG;AACL,MAAwB;AACtB,QAAM,cAAU,0BAAuB,qBAAS;AAAA,IAC9C;AAAA,IACA;AAAA,IACA;AAAA,IACA,QAAI,qBAAM;AAAA,IACV;AAAA,IACA,aAAa,SAAS;AACpB,qBAAe,QAAQ,IAAI;AAAA,IAC7B;AAAA,EACF,CAAC;AACD,QAAM,MAAkB,oBAAQ,SAAS,4BAAc;AACvD,QAAM,YAAY,UAAU,OAAO;AAEnC,QAAM,kBAAc,0BAAW,IAAI,aAAa,GAAG,KAAK;AAExD,SACE,6CAAC,mBAAmB,UAAnB,EAA4B,OAAO,KAClC,uDAAC,aAAU,wBAAqB,eAAc,KAAW,GAAG,aACzD,UACH,GACF;AAEJ;AAEA,YAAY,cAAc;AAEnB,IAAM,wBAAwB,MAAM;AACzC,QAAM,cAAU,0BAAW,kBAAkB;AAE7C,MAAI,CAAC,SAAS;AACZ,UAAM,MAAM,kEAAkE;AAAA,EAChF;AAEA,SAAO;AACT;;;AEjFA,IAAAC,gBAA2B;AAC3B,sCAAmB;AAkCf,IAAAC,sBAAA;AAvBG,IAAM,UAAU,CAAC;AAAA,EACtB,UAAU;AAAA,EACV;AAAA,EACA;AAAA,EACA;AAAA,EACA,GAAG;AACL,MAA+B;AAC7B,QAAM,EAAE,gBAAgB,IAAI,sBAAsB;AAElD,QAAM,YAAY,UAAU,OAAO;AACnC,QAAM,eAAe,gBAAgB;AACrC,QAAM,kBAAc,0BAAW,cAAc;AAAA,IAC3C,eAAW;AAAA,MACT;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,IACA,GAAG;AAAA,EACL,CAAC;AAED,SACE,6CAAC,aAAU,KAAU,wBAAqB,uBAAuB,GAAG,aACjE,UACH;AAEJ;AAEA,QAAQ,cAAc;;;ACzCtB,IAAAC,gBAA2B;AAiBvB,IAAAC,sBAAA;AANG,IAAM,UAAU,CAAC,EAAE,UAAU,OAAO,UAAU,KAAK,GAAG,MAAM,MAA+B;AAChG,QAAM,qBAAqB,sBAAsB;AACjD,QAAM,YAAY,UAAU,OAAO;AACnC,QAAM,kBAAc,0BAAW,mBAAmB,gBAAgB,GAAG,KAAK;AAE1E,SACE,6CAAC,aAAU,KAAU,wBAAqB,uBAAuB,GAAG,aACjE,UACH;AAEJ;AAEA,QAAQ,cAAc;;;AJnBf,IAAMC,eAGT,OAAO,OAAO,aAAM;AAAA,EACtB;AAAA,EACA;AACF,CAAC;AAEDA,aAAY,cAAc;AAC1B,QAAQ,cAAc;AACtB,QAAQ,cAAc;","names":["Collapsible","import_react","RadixSlot","import_jsx_runtime","import_react","import_jsx_runtime","import_react","import_jsx_runtime","Collapsible"]}

package/dist/collapsible/index.mjs

@@ -0,0 +1,8 @@
+import {
+  Collapsible
+} from "../chunk-FGOZHKBT.mjs";
+import "../chunk-4F5DOL57.mjs";
+export {
+  Collapsible
+};
+//# sourceMappingURL=index.mjs.map

package/dist/collapsible/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/combobox/index.d.mts

@@ -0,0 +1,285 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Dispatch, SetStateAction, RefObject, PropsWithChildren, ComponentPropsWithoutRef, Ref, ComponentProps, ReactNode, HTMLAttributes, ReactElement } from 'react';
+import { UseComboboxReturnValue, UseMultipleSelectionReturnValue } from 'downshift';
+import { IconButton } from '../icon-button/index.mjs';
+import { Popover as Popover$1 } from '../popover/index.mjs';
+import '../button/index.mjs';
+import 'class-variance-authority/types';
+import 'class-variance-authority';
+import 'radix-ui';
+
+interface ComboboxItem {
+    disabled: boolean;
+    value: string;
+    text: string;
+}
+type ItemsMap = Map<string, ComboboxItem>;
+type DownshiftState = UseComboboxReturnValue<ComboboxItem> & UseMultipleSelectionReturnValue<ComboboxItem>;
+
+interface ComboboxContextState extends DownshiftState {
+    itemsMap: ItemsMap;
+    filteredItemsMap: ItemsMap;
+    highlightedItem: ComboboxItem | undefined;
+    hasPopover: boolean;
+    multiple: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+    wrap?: boolean;
+    state?: 'error' | 'alert' | 'success';
+    lastInteractionType: 'mouse' | 'keyboard';
+    setHasPopover: 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>>;
+}
+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;
+}
+type ComboboxContextProps = ComboboxContextCommonProps & (ComboboxPropsSingle | ComboboxPropsMultiple);
+declare const ComboboxProvider: ({ children, state: stateProp, allowCustomValue, filtering, disabled: disabledProp, multiple, readOnly: readOnlyProp, wrap, value: controlledValue, defaultValue, onValueChange, open: controlledOpen, defaultOpen, onOpenChange, isLoading, }: ComboboxContextProps) => react_jsx_runtime.JSX.Element;
+declare const useComboboxContext: () => ComboboxContextState;
+
+type ComboboxProps = ComboboxContextProps;
+declare const Combobox$1: {
+    ({ children, ...props }: ComboboxProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface ClearButtonProps extends ComponentPropsWithoutRef<'button'> {
+    'aria-label': string;
+    ref?: Ref<HTMLButtonElement>;
+}
+declare const ClearButton: {
+    ({ className, tabIndex, onClick, ref, ...others }: ClearButtonProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface DisclosureProps extends Omit<ComponentProps<typeof IconButton>, 'aria-label'> {
+    className?: string;
+    closedLabel: string;
+    openedLabel: string;
+    ref?: Ref<HTMLButtonElement>;
+}
+declare const Disclosure: {
+    ({ className, closedLabel, openedLabel, intent, design, size, ref: forwardedRef, ...props }: DisclosureProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface EmptyProps {
+    className?: string;
+    children: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+}
+declare const Empty: {
+    ({ className, children, ref: forwardedRef }: EmptyProps): react_jsx_runtime.JSX.Element | null;
+    displayName: string;
+};
+
+interface GroupProps {
+    children: ReactNode;
+    className?: string;
+    ref?: Ref<HTMLDivElement>;
+}
+declare const Group: {
+    ({ children, ref: forwardedRef, ...props }: GroupProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+type InputPrimitiveProps = ComponentPropsWithoutRef<'input'>;
+interface InputProps extends Omit<InputPrimitiveProps, 'value' | 'placeholder'> {
+    className?: string;
+    placeholder?: string;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    ref?: Ref<HTMLInputElement>;
+}
+declare const Input: {
+    ({ "aria-label": ariaLabel, className, placeholder, value, defaultValue, onValueChange, ref: forwardedRef, ...props }: InputProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface ItemProps extends HTMLAttributes<HTMLLIElement> {
+    disabled?: boolean;
+    value: string;
+    children: ReactNode;
+    className?: string;
+    ref?: Ref<HTMLLIElement>;
+}
+declare const Item: {
+    ({ children, ref: forwardedRef, ...props }: ItemProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface ItemIndicatorProps {
+    children?: ReactNode;
+    className?: string;
+    label?: string;
+    ref?: Ref<HTMLSpanElement>;
+}
+declare const ItemIndicator: {
+    ({ className, children, label, ref: forwardedRef, }: ItemIndicatorProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface ItemsProps extends ComponentPropsWithoutRef<'ul'> {
+    children: ReactNode;
+    className?: string;
+    ref?: Ref<HTMLUListElement>;
+}
+declare const Items: {
+    ({ children, className, ref: forwardedRef, ...props }: ItemsProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface ItemTextProps {
+    children: string;
+    className?: string;
+    ref?: Ref<HTMLSpanElement>;
+}
+declare const ItemText: {
+    ({ children, className, ref: forwardedRef }: ItemTextProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface LabelProps {
+    children: string;
+    className?: string;
+    ref?: Ref<HTMLDivElement>;
+}
+declare const Label: {
+    ({ children, className, ref: forwardedRef }: LabelProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const LeadingIcon: {
+    ({ children }: {
+        children: ReactElement;
+    }): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface PopoverProps extends ComponentProps<typeof Popover$1.Content> {
+    ref?: Ref<HTMLDivElement>;
+}
+declare const Popover: {
+    ({ children, matchTriggerWidth, sideOffset, className, ref: forwardedRef, ...props }: PopoverProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const Portal: typeof Popover$1.Portal;
+
+declare const SelectedItems: {
+    (): react_jsx_runtime.JSX.Element | null;
+    displayName: string;
+};
+
+interface TriggerProps {
+    className?: string;
+    children: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+}
+declare const Trigger: {
+    ({ className, children, ref: forwardedRef }: TriggerProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const Combobox: typeof Combobox$1 & {
+    Group: typeof Group;
+    Item: typeof Item;
+    Items: typeof Items;
+    ItemText: typeof ItemText;
+    ItemIndicator: typeof ItemIndicator;
+    Label: typeof Label;
+    Popover: typeof Popover;
+    Trigger: typeof Trigger;
+    LeadingIcon: typeof LeadingIcon;
+    Empty: typeof Empty;
+    Input: typeof Input;
+    Disclosure: typeof Disclosure;
+    SelectedItems: typeof SelectedItems;
+    ClearButton: typeof ClearButton;
+    Portal: typeof Portal;
+};
+
+export { Combobox, ComboboxProvider, useComboboxContext };