@gamecrafters/base-ui 0.0.23 → 0.0.25

package/build/components/avatar/Avatar.d.ts

@@ -1,7 +1,7 @@
 import * as React from "react";
 import type { AvatarShape } from "./Avatar.types";
 export declare const DEFAULT_AVATAR_SIZE = 20;
-declare const _default: <As extends React.ElementType = "img">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "img" : As> & {
+declare const _default: <As extends React.ElementType = "span">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "span" : As> & {
     size?: import("./Avatar.types").AvatarSize;
     shape?: AvatarShape;
     className?: string;

package/build/components/avatar/Avatar.types.d.ts

@@ -4,7 +4,7 @@ import type { PolymorphicProps } from "../../utilities/polymorphic";
 export type AvatarSize = number | ResponsiveValue<number>;
 export type AvatarShape = "circle" | "square";
 export type AvatarLoadingStatus = "idle" | "loading" | "loaded" | "error";
-export type AvatarProps<As extends React.ElementType = "img"> = PolymorphicProps<As, "img", {
+export type AvatarProps<As extends React.ElementType = "span"> = PolymorphicProps<As, "span", {
     size?: AvatarSize;
     shape?: AvatarShape;
     className?: string;

package/build/components/avatar/index.d.ts

@@ -1,7 +1,7 @@
 import { DEFAULT_AVATAR_SIZE } from "./Avatar";
 import AvatarFallback from "./AvatarFallback";
 import AvatarImage from "./AvatarImage";
-export declare const Avatar: (<As extends React.ElementType = "img">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "img" : As> & {
+export declare const Avatar: (<As extends React.ElementType = "span">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "span" : As> & {
     size?: import("./Avatar.types").AvatarSize;
     shape?: import("./Avatar.types").AvatarShape;
     className?: string;

package/build/components/avatar-stack/AvatarStack.d.ts

@@ -1,14 +1,15 @@
 import * as React from "react";
 import type { AvatarShape, AvatarSize } from "../avatar/Avatar.types";
-import type { AvatarStackAlign, AvatarStackVariant } from "./AvatarStack.types";
-declare const _default: <As extends React.ElementType = "span">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "span" : As> & {
+import type { AvatarStackAlign, AvatarStackChild, AvatarStackVariant } from "./AvatarStack.types";
+declare const _default: <As extends React.ElementType = "span">(props: import("../../utilities/polymorphic").DistributiveOmit<import("../../utilities/polymorphic").PolymorphicProps<As, "span", {
     variant?: AvatarStackVariant;
     shape?: AvatarShape;
     size?: AvatarSize;
     align?: AvatarStackAlign;
     disableExpand?: boolean;
     className?: string;
-}, "as"> & {
+}>, "as" | "children"> & {
     as?: As | undefined;
+    children?: AvatarStackChild | AvatarStackChild[];
 } & React.RefAttributes<any>) => React.ReactNode;
 export default _default;

package/build/components/avatar-stack/AvatarStack.types.d.ts

@@ -1,13 +1,17 @@
 import type * as React from "react";
-import type { AvatarShape, AvatarSize } from "../avatar/Avatar.types";
-import type { PolymorphicProps } from "../../utilities/polymorphic";
+import type { AvatarProps, AvatarShape, AvatarSize } from "../avatar/Avatar.types";
+import type { DistributiveOmit, PolymorphicProps } from "../../utilities/polymorphic";
 export type AvatarStackVariant = "cascade" | "stack";
 export type AvatarStackAlign = "left" | "right";
-export type AvatarStackProps<As extends React.ElementType = "span"> = PolymorphicProps<As, "span", {
+export type AvatarStackChild = React.ReactElement<AvatarProps>;
+export type AvatarStackProps<As extends React.ElementType = "span"> = DistributiveOmit<PolymorphicProps<As, "span", {
     variant?: AvatarStackVariant;
     shape?: AvatarShape;
     size?: AvatarSize;
     align?: AvatarStackAlign;
     disableExpand?: boolean;
     className?: string;
-}>;
+}>, "as" | "children"> & {
+    as?: As;
+    children?: AvatarStackChild | AvatarStackChild[];
+};

package/build/components/combobox/Combobox.d.ts

@@ -0,0 +1,36 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "defaultValue" | "onSelect"> & {
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+    onSelect?: (value: string) => void;
+    inputValue?: string;
+    defaultInputValue?: string;
+    onInputValueChange?: (inputValue: string) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    highlightedValue?: string | null;
+    defaultHighlightedValue?: string | null;
+    onHighlightChange?: (highlightedValue: string | null) => void;
+    multiple?: boolean;
+    closeOnSelect?: boolean;
+    selectionBehavior?: import("./Combobox.types").ComboboxSelectionBehavior;
+    inputBehavior?: import("./Combobox.types").ComboboxInputBehavior;
+    allowCustomValue?: boolean;
+    loopFocus?: boolean;
+    openOnClick?: boolean;
+    openOnChange?: boolean;
+    openOnKeyPress?: boolean;
+    filter?: import("./Combobox.types").ComboboxFilter;
+    shouldFilter?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    invalid?: boolean;
+    required?: boolean;
+    placeholder?: string;
+    name?: string;
+    form?: string;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/combobox/Combobox.types.d.ts

@@ -0,0 +1,146 @@
+import type * as React from "react";
+import type { ButtonVisual } from "../button";
+import type { TextInputProps } from "../text-input";
+import type { AnchorAlignment, AnchorSide } from "../tooltip/anchoredPosition";
+export type ComboboxInputBehavior = "none" | "autohighlight" | "autocomplete";
+export type ComboboxSelectionBehavior = "replace" | "clear" | "preserve";
+export type ComboboxFilter = (label: string, inputValue: string) => boolean;
+export type ComboboxItemEntry = {
+    value: string;
+    label: string;
+    id: string;
+    groupId?: string;
+    disabled: boolean;
+};
+export type ComboboxContextValue = {
+    inputId: string;
+    labelId: string;
+    listId: string;
+    getItemId: (value: string) => string | undefined;
+    inputValue: string;
+    completion: string;
+    onType: (inputValue: string) => void;
+    setInputValue: (inputValue: string) => void;
+    value: string[];
+    isSelected: (value: string) => boolean;
+    select: (value: string) => void;
+    clear: () => void;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    openAt: (end: "first" | "last") => void;
+    highlightedValue: string | null;
+    setHighlightedValue: (value: string | null) => void;
+    moveHighlight: (step: number) => void;
+    entries: ComboboxItemEntry[];
+    register: (entry: ComboboxItemEntry) => void;
+    unregister: (value: string) => void;
+    matches: string[];
+    isMatch: (value: string) => boolean;
+    multiple: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+    invalid: boolean;
+    required: boolean;
+    placeholder?: string;
+    inputBehavior: ComboboxInputBehavior;
+    openOnClick: boolean;
+    openOnKeyPress: boolean;
+    inputRef: React.RefObject<HTMLInputElement | null>;
+    controlRef: React.RefObject<HTMLDivElement | null>;
+    contentRef: React.RefObject<HTMLDivElement | null>;
+};
+export type ComboboxItemGroupContextValue = {
+    groupId: string;
+    labelId: string;
+};
+export type ComboboxItemContextValue = {
+    value: string;
+    selected: boolean;
+    highlighted: boolean;
+    disabled: boolean;
+};
+export type ComboboxProps = Omit<React.ComponentPropsWithoutRef<"div">, "onSelect" | "defaultValue"> & {
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+    onSelect?: (value: string) => void;
+    inputValue?: string;
+    defaultInputValue?: string;
+    onInputValueChange?: (inputValue: string) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    highlightedValue?: string | null;
+    defaultHighlightedValue?: string | null;
+    onHighlightChange?: (highlightedValue: string | null) => void;
+    multiple?: boolean;
+    closeOnSelect?: boolean;
+    selectionBehavior?: ComboboxSelectionBehavior;
+    inputBehavior?: ComboboxInputBehavior;
+    allowCustomValue?: boolean;
+    loopFocus?: boolean;
+    openOnClick?: boolean;
+    openOnChange?: boolean;
+    openOnKeyPress?: boolean;
+    filter?: ComboboxFilter;
+    shouldFilter?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    invalid?: boolean;
+    required?: boolean;
+    placeholder?: string;
+    name?: string;
+    form?: string;
+    className?: string;
+};
+export type ComboboxLabelProps = React.ComponentPropsWithoutRef<"label"> & {
+    className?: string;
+};
+export type ComboboxControlProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type ComboboxInputProps = Omit<TextInputProps, "value" | "defaultValue" | "type" | "placeholder" | "disabled" | "readOnly" | "required"> & {
+    className?: string;
+};
+type ComboboxTriggerOwnProps = {
+    icon?: NonNullable<ButtonVisual>;
+    className?: string;
+};
+export type ComboboxTriggerProps = Omit<React.ComponentPropsWithoutRef<"button">, "aria-labelledby"> & ComboboxTriggerOwnProps;
+export type ComboboxClearTriggerProps = ComboboxTriggerProps;
+export type ComboboxPositionerProps = React.ComponentPropsWithoutRef<"div"> & {
+    side?: AnchorSide;
+    align?: AnchorAlignment;
+    portalContainerName?: string;
+    className?: string;
+};
+export type ComboboxContentProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type ComboboxListProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type ComboboxItemGroupProps = React.ComponentPropsWithoutRef<"div"> & {
+    forceMount?: boolean;
+    className?: string;
+};
+export type ComboboxItemGroupLabelProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type ComboboxItemProps = Omit<React.ComponentPropsWithoutRef<"div">, "onSelect"> & {
+    value: string;
+    label?: string;
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    className?: string;
+};
+export type ComboboxItemTextProps = React.ComponentPropsWithoutRef<"span"> & {
+    className?: string;
+};
+export type ComboboxItemIndicatorProps = React.ComponentPropsWithoutRef<"span"> & {
+    className?: string;
+};
+export type ComboboxEmptyProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export {};

package/build/components/combobox/ComboboxClearTrigger.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "aria-labelledby"> & {
+    icon?: NonNullable<import("..").ButtonVisual>;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/combobox/ComboboxContent.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/combobox/ComboboxContext.d.ts

@@ -0,0 +1,4 @@
+import type { ComboboxContextValue, ComboboxItemContextValue, ComboboxItemGroupContextValue } from "./Combobox.types";
+export declare const ComboboxContext: import("react").Context<ComboboxContextValue | null>;
+export declare const ComboboxItemGroupContext: import("react").Context<ComboboxItemGroupContextValue | null>;
+export declare const ComboboxItemContext: import("react").Context<ComboboxItemContextValue | null>;

package/build/components/combobox/ComboboxControl.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/combobox/ComboboxEmpty.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/combobox/ComboboxInput.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<import("..").TextInputProps, "value" | "defaultValue" | "disabled" | "type" | "placeholder" | "readOnly" | "required"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/combobox/ComboboxItem.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onSelect"> & {
+    value: string;
+    label?: string;
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/combobox/ComboboxItemGroup.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    forceMount?: boolean;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/combobox/ComboboxItemGroupLabel.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/combobox/ComboboxItemIndicator.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/combobox/ComboboxItemText.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/combobox/ComboboxLabel.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/combobox/ComboboxList.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/combobox/ComboboxPositioner.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    side?: import("..").AnchorSide;
+    align?: import("..").AnchorAlignment;
+    portalContainerName?: string;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/combobox/ComboboxTrigger.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "aria-labelledby"> & {
+    icon?: NonNullable<import("..").ButtonVisual>;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/combobox/index.d.ts

@@ -0,0 +1,104 @@
+import ComboboxClearTrigger from "./ComboboxClearTrigger";
+import ComboboxContent from "./ComboboxContent";
+import ComboboxControl from "./ComboboxControl";
+import ComboboxEmpty from "./ComboboxEmpty";
+import ComboboxInput from "./ComboboxInput";
+import ComboboxItem from "./ComboboxItem";
+import ComboboxItemGroup from "./ComboboxItemGroup";
+import ComboboxItemGroupLabel from "./ComboboxItemGroupLabel";
+import ComboboxItemIndicator from "./ComboboxItemIndicator";
+import ComboboxItemText from "./ComboboxItemText";
+import ComboboxLabel from "./ComboboxLabel";
+import ComboboxList from "./ComboboxList";
+import ComboboxPositioner from "./ComboboxPositioner";
+import ComboboxTrigger from "./ComboboxTrigger";
+export declare const Combobox: ((props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "defaultValue" | "onSelect"> & {
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+    onSelect?: (value: string) => void;
+    inputValue?: string;
+    defaultInputValue?: string;
+    onInputValueChange?: (inputValue: string) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    highlightedValue?: string | null;
+    defaultHighlightedValue?: string | null;
+    onHighlightChange?: (highlightedValue: string | null) => void;
+    multiple?: boolean;
+    closeOnSelect?: boolean;
+    selectionBehavior?: import("./Combobox.types").ComboboxSelectionBehavior;
+    inputBehavior?: import("./Combobox.types").ComboboxInputBehavior;
+    allowCustomValue?: boolean;
+    loopFocus?: boolean;
+    openOnClick?: boolean;
+    openOnChange?: boolean;
+    openOnKeyPress?: boolean;
+    filter?: import("./Combobox.types").ComboboxFilter;
+    shouldFilter?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    invalid?: boolean;
+    required?: boolean;
+    placeholder?: string;
+    name?: string;
+    form?: string;
+    className?: string;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Label: (props: Omit<import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Control: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Input: (props: Omit<import("..").TextInputProps, "value" | "defaultValue" | "disabled" | "type" | "placeholder" | "readOnly" | "required"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Trigger: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "aria-labelledby"> & {
+        icon?: NonNullable<import("..").ButtonVisual>;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    ClearTrigger: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "aria-labelledby"> & {
+        icon?: NonNullable<import("..").ButtonVisual>;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Positioner: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        side?: import("..").AnchorSide;
+        align?: import("..").AnchorAlignment;
+        portalContainerName?: string;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Content: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    List: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    ItemGroup: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        forceMount?: boolean;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    ItemGroupLabel: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Item: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onSelect"> & {
+        value: string;
+        label?: string;
+        disabled?: boolean;
+        onSelect?: (value: string) => void;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    ItemText: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    ItemIndicator: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Empty: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { ComboboxLabel, ComboboxControl, ComboboxInput, ComboboxTrigger, ComboboxClearTrigger, ComboboxPositioner, ComboboxContent, ComboboxList, ComboboxItemGroup, ComboboxItemGroupLabel, ComboboxItem, ComboboxItemText, ComboboxItemIndicator, ComboboxEmpty, };
+export { ComboboxContext, ComboboxItemContext, ComboboxItemGroupContext } from "./ComboboxContext";
+export * from "./Combobox.types";

package/build/components/index.d.ts

@@ -29,6 +29,7 @@ export * from "./clipboard";
 export * from "./code";
 export * from "./code-block";
 export * from "./collapsible";
+export * from "./combobox";
 export * from "./command-palette";
 export * from "./confirmation-dialog";
 export * from "./counter-label";
@@ -104,6 +105,7 @@ export * from "./state-label";
 export * from "./statistic-card";
 export * from "./status";
 export * from "./steps";
+export * from "./swap";
 export * from "./table-of-contents";
 export * from "./tabs";
 export * from "./text";
@@ -115,5 +117,6 @@ export * from "./toggle-switch";
 export * from "./token";
 export * from "./tooltip";
 export * from "./topic-tag";
+export * from "./tour";
 export * from "./tree-view";
 export * from "./truncate";

package/build/components/swap/Swap.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+import type { SwapTransition } from "./Swap.types";
+declare const _default: <As extends React.ElementType = "span">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "span" : As> & {
+    swap?: boolean;
+    transition?: SwapTransition;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/swap/Swap.types.d.ts

@@ -0,0 +1,19 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type SwapIndicatorType = "on" | "off";
+export type SwapTransition = "fade" | "flip" | "rotate" | "scale" | "none";
+export type SwapProps<As extends React.ElementType = "span"> = PolymorphicProps<As, "span", {
+    swap?: boolean;
+    transition?: SwapTransition;
+    className?: string;
+}>;
+type SwapIndicatorOwnProps = {
+    type: SwapIndicatorType;
+    className?: string;
+};
+export type SwapIndicatorProps<As extends React.ElementType = "span"> = PolymorphicProps<As, "span", SwapIndicatorOwnProps>;
+export type SwapIndicatorElementProps = PolymorphicProps<"span", "span", SwapIndicatorOwnProps>;
+export type SwapContextValue = {
+    swap?: boolean;
+};
+export {};

package/build/components/swap/SwapContext.d.ts

@@ -0,0 +1,2 @@
+import type { SwapContextValue } from "./Swap.types";
+export declare const SwapContext: import("react").Context<SwapContextValue>;

package/build/components/swap/SwapIndicator.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const _default: <As extends React.ElementType = "span">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "span" : As> & {
+    type: import("./Swap.types").SwapIndicatorType;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/swap/index.d.ts

@@ -0,0 +1,18 @@
+import SwapIndicator from "./SwapIndicator";
+export declare const Swap: (<As extends React.ElementType = "span">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "span" : As> & {
+    swap?: boolean;
+    transition?: import("./Swap.types").SwapTransition;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Indicator: <As extends React.ElementType = "span">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "span" : As> & {
+        type: import("./Swap.types").SwapIndicatorType;
+        className?: string;
+    }, "as"> & {
+        as?: As | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { SwapIndicator };
+export { SwapContext } from "./SwapContext";
+export * from "./Swap.types";

package/build/components/tour/Tour.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import type { TourProps } from "./Tour.types";
+export declare const DEFAULT_SPOTLIGHT_OFFSET = 4;
+export declare const DEFAULT_SPOTLIGHT_RADIUS = 8;
+declare function Tour(props: TourProps): React.JSX.Element;
+declare namespace Tour {
+    var displayName: string;
+}
+export default Tour;