@gamecrafters/base-ui 0.0.1

package/build/components/toast/Toast.types.d.ts

@@ -0,0 +1,78 @@
+import type * as React from "react";
+export type ToastVariant = "default" | "success" | "error" | "warning" | "info" | "loading";
+export type ToastPosition = "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right";
+export type ToastSwipeDirection = "top" | "right" | "bottom" | "left";
+export type ToastCloseReason = "timeout" | "close-button" | "action" | "cancel" | "swipe" | "dismiss";
+export type ToastActionDescriptor = {
+    label: React.ReactNode;
+    onClick?: (event: React.MouseEvent<HTMLButtonElement>) => void;
+};
+export type ToastAction = ToastActionDescriptor | React.ReactNode;
+export type ToastOptions = {
+    id?: string;
+    description?: React.ReactNode;
+    duration?: number;
+    icon?: React.ReactNode;
+    action?: ToastAction;
+    cancel?: ToastAction;
+    closeButton?: boolean;
+    dismissible?: boolean;
+    richColors?: boolean;
+    important?: boolean;
+    onDismiss?: (toast: ToastItem) => void;
+    onAutoClose?: (toast: ToastItem) => void;
+    className?: string;
+};
+export type ToastItem = ToastOptions & {
+    id: string;
+    variant: ToastVariant;
+    title?: React.ReactNode;
+    render?: (toast: ToastItem) => React.ReactNode;
+    dismissed?: boolean;
+    revision: number;
+};
+export type ToastPromiseMessage<T> = React.ReactNode | ((value: T) => React.ReactNode);
+export type ToastPromiseMessages<T> = {
+    loading: React.ReactNode;
+    success: ToastPromiseMessage<T>;
+    error: ToastPromiseMessage<unknown>;
+};
+export type ToastIcons = Partial<Record<ToastVariant, React.ReactNode>>;
+export type ToasterProps = React.ComponentPropsWithoutRef<"ol"> & {
+    position?: ToastPosition;
+    expand?: boolean;
+    visibleToasts?: number;
+    toastOptions?: ToastOptions;
+    duration?: number;
+    closeButton?: boolean;
+    richColors?: boolean;
+    gap?: number;
+    offset?: number | string;
+    mobileOffset?: number | string;
+    width?: number | string;
+    hotkey?: string[];
+    swipeDirections?: ToastSwipeDirection[];
+    icons?: ToastIcons;
+    containerAriaLabel?: string;
+    className?: string;
+};
+export type ToastPlace = {
+    index: number;
+    offset: number;
+};
+export type ToastDefaults = Required<Pick<ToastOptions, "duration" | "closeButton" | "richColors" | "dismissible">> & Pick<ToastOptions, "important" | "className">;
+export type ToastProps = {
+    toast: ToastItem;
+    place: ToastPlace;
+    position: ToastPosition;
+    height: number;
+    frontHeight: number;
+    stackSize: number;
+    expanded: boolean;
+    visible: boolean;
+    paused: boolean;
+    swipeDirections: ToastSwipeDirection[];
+    icons?: ToastIcons;
+    defaults: ToastDefaults;
+    onHeight: (id: string, height: number) => void;
+};

package/build/components/toast/Toaster.d.ts

@@ -0,0 +1,21 @@
+import * as React from "react";
+import type { ToastPosition, ToastSwipeDirection } from "./Toast.types";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & {
+    position?: ToastPosition;
+    expand?: boolean;
+    visibleToasts?: number;
+    toastOptions?: import("./Toast.types").ToastOptions;
+    duration?: number;
+    closeButton?: boolean;
+    richColors?: boolean;
+    gap?: number;
+    offset?: number | string;
+    mobileOffset?: number | string;
+    width?: number | string;
+    hotkey?: string[];
+    swipeDirections?: ToastSwipeDirection[];
+    icons?: Partial<Record<import("./Toast.types").ToastVariant, React.ReactNode>>;
+    containerAriaLabel?: string;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

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

@@ -0,0 +1,3 @@
+export { default as Toaster } from "./Toaster";
+export { toast } from "./toastStore";
+export * from "./Toast.types";

package/build/components/toast/toastStore.d.ts

@@ -0,0 +1,20 @@
+import type * as React from "react";
+import type { ToastItem, ToastOptions, ToastPromiseMessages } from "./Toast.types";
+export declare const subscribeToToasts: (onStoreChange: () => void) => () => void;
+export declare const getToasts: () => ToastItem[];
+export declare const getServerToasts: () => ToastItem[];
+export declare const dismissToast: (id?: string) => string | undefined;
+export declare const removeToast: (id: string) => void;
+export declare const clearToasts: () => void;
+export declare const toast: ((title: React.ReactNode, options?: ToastOptions) => string) & {
+    message: (title: React.ReactNode, options?: ToastOptions) => string;
+    success: (title: React.ReactNode, options?: ToastOptions) => string;
+    error: (title: React.ReactNode, options?: ToastOptions) => string;
+    warning: (title: React.ReactNode, options?: ToastOptions) => string;
+    info: (title: React.ReactNode, options?: ToastOptions) => string;
+    loading: (title: React.ReactNode, options?: ToastOptions) => string;
+    custom: (render: (toast: ToastItem) => React.ReactNode, options?: ToastOptions) => string;
+    promise: <T>(input: Promise<T> | (() => Promise<T>), messages: ToastPromiseMessages<T>, options?: ToastOptions) => string;
+    dismiss: (id?: string) => string | undefined;
+    getToasts: () => ToastItem[];
+};

package/build/components/toggle-switch/ToggleSwitch.d.ts

@@ -0,0 +1,21 @@
+import * as React from "react";
+import type { ToggleSwitchSize, ToggleSwitchStatusLabelPosition } from "./ToggleSwitch.types";
+export declare const DEFAULT_TOGGLE_SWITCH_LOADING_LABEL_DELAY = 2000;
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onChange"> & {
+    "aria-labelledby": string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+    onChange?: (checked: boolean) => void;
+    onClick?: React.MouseEventHandler;
+    size?: ToggleSwitchSize;
+    statusLabelPosition?: ToggleSwitchStatusLabelPosition;
+    loadingLabelDelay?: number;
+    loadingLabel?: string;
+    buttonType?: import("./ToggleSwitch.types").ToggleSwitchButtonType;
+    buttonLabelOn?: string;
+    buttonLabelOff?: string;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/toggle-switch/ToggleSwitch.types.d.ts

@@ -0,0 +1,21 @@
+import type * as React from "react";
+export type ToggleSwitchSize = "small" | "medium";
+export type ToggleSwitchStatusLabelPosition = "start" | "end";
+export type ToggleSwitchButtonType = "button" | "submit" | "reset";
+export type ToggleSwitchProps = Omit<React.ComponentPropsWithoutRef<"div">, "onChange"> & {
+    "aria-labelledby": string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+    onChange?: (checked: boolean) => void;
+    onClick?: React.MouseEventHandler;
+    size?: ToggleSwitchSize;
+    statusLabelPosition?: ToggleSwitchStatusLabelPosition;
+    loadingLabelDelay?: number;
+    loadingLabel?: string;
+    buttonType?: ToggleSwitchButtonType;
+    buttonLabelOn?: string;
+    buttonLabelOff?: string;
+    className?: string;
+};

package/build/components/toggle-switch/index.d.ts

@@ -0,0 +1,2 @@
+export { default as ToggleSwitch, DEFAULT_TOGGLE_SWITCH_LOADING_LABEL_DELAY } from "./ToggleSwitch";
+export * from "./ToggleSwitch.types";

package/build/components/token/IssueLabelToken.d.ts

@@ -0,0 +1,15 @@
+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> & {
+    size?: import("./Token.types").TokenSize;
+    isSelected?: boolean;
+    onRemove?: () => void;
+    disabled?: boolean;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & {
+    text: React.ReactNode;
+    fillColor?: string;
+    hideRemoveButton?: boolean;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/token/Token.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+import type { ButtonVisual } from "../button";
+import type { TokenSize } from "./Token.types";
+declare const _default: <As extends React.ElementType = "span">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "span" : As> & {
+    size?: TokenSize;
+    isSelected?: boolean;
+    onRemove?: () => void;
+    disabled?: boolean;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & {
+    text: React.ReactNode;
+    leadingVisual?: ButtonVisual;
+    hideRemoveButton?: boolean;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/token/Token.types.d.ts

@@ -0,0 +1,37 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+import type { ButtonVisual } from "../button";
+export type TokenSize = "small" | "medium" | "large" | "xlarge";
+export type TokenBaseProps<As extends React.ElementType = "span"> = PolymorphicProps<As, "span", {
+    size?: TokenSize;
+    isSelected?: boolean;
+    onRemove?: () => void;
+    disabled?: boolean;
+    className?: string;
+}>;
+export type TokenProps<As extends React.ElementType = "span"> = TokenBaseProps<As> & {
+    text: React.ReactNode;
+    leadingVisual?: ButtonVisual;
+    hideRemoveButton?: boolean;
+};
+export type IssueLabelTokenProps<As extends React.ElementType = "span"> = TokenBaseProps<As> & {
+    text: React.ReactNode;
+    fillColor?: string;
+    hideRemoveButton?: boolean;
+};
+export type TokenTextProps<As extends React.ElementType = "span"> = PolymorphicProps<As, "span", {
+    interactive?: boolean;
+    className?: string;
+}>;
+export type TokenRemoveButtonProps = Omit<React.ComponentPropsWithoutRef<"button">, "children" | "aria-label" | "aria-labelledby"> & {
+    size?: TokenSize;
+    isParentInteractive?: boolean;
+    className?: string;
+};
+export type TokenInteractiveProps = {
+    as?: React.ElementType;
+    onClick?: React.MouseEventHandler<HTMLElement>;
+    onFocus?: React.FocusEventHandler<HTMLElement>;
+    tabIndex?: number;
+    disabled?: boolean;
+};

package/build/components/token/TokenBase.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+import type { TokenInteractiveProps, TokenSize } from "./Token.types";
+export declare const DEFAULT_TOKEN_SIZE: TokenSize;
+export declare const isTokenInteractive: ({ as, onClick, onFocus, tabIndex, disabled, }: TokenInteractiveProps) => boolean;
+declare const _default: <As extends React.ElementType = "span">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "span" : As> & {
+    size?: TokenSize;
+    isSelected?: boolean;
+    onRemove?: () => void;
+    disabled?: boolean;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & {
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/token/TokenRemoveButton.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { TokenRemoveButtonProps } from "./Token.types";
+declare function TokenRemoveButton(props: TokenRemoveButtonProps): React.JSX.Element;
+declare namespace TokenRemoveButton {
+    var displayName: string;
+}
+export default TokenRemoveButton;

package/build/components/token/TokenText.d.ts

@@ -0,0 +1,10 @@
+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> & {
+    interactive?: boolean;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & {
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

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

@@ -0,0 +1,7 @@
+export { default as Token } from "./Token";
+export { default as IssueLabelToken } from "./IssueLabelToken";
+export { default as TokenBase, DEFAULT_TOKEN_SIZE, isTokenInteractive } from "./TokenBase";
+export { default as TokenText } from "./TokenText";
+export { default as TokenRemoveButton } from "./TokenRemoveButton";
+export { getIssueLabelColors, DEFAULT_ISSUE_LABEL_FILL_COLOR, type IssueLabelColors, type IssueLabelPalette, } from "./issueLabelColor";
+export * from "./Token.types";

package/build/components/token/issueLabelColor.d.ts

@@ -0,0 +1,13 @@
+export type IssueLabelPalette = {
+    background: string;
+    foreground: string;
+    border: string;
+    ring: string;
+    backgroundHover: string;
+};
+export type IssueLabelColors = {
+    light: IssueLabelPalette;
+    dark: IssueLabelPalette;
+};
+export declare const DEFAULT_ISSUE_LABEL_FILL_COLOR = "#999999";
+export declare const getIssueLabelColors: (fillColor: string) => IssueLabelColors;

package/build/components/tooltip/Tooltip.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+import type { TooltipDelay, TooltipDirection } from "./Tooltip.types";
+declare const _default: (props: Omit<React.HTMLAttributes<HTMLElement>, "children"> & {
+    text: string;
+    direction?: TooltipDirection;
+    type?: import("./Tooltip.types").TooltipType;
+    delay?: TooltipDelay;
+    className?: string;
+} & {
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/tooltip/Tooltip.types.d.ts

@@ -0,0 +1,14 @@
+import type * as React from "react";
+export type TooltipDirection = "nw" | "n" | "ne" | "e" | "se" | "s" | "sw" | "w";
+export type TooltipType = "label" | "description";
+export type TooltipDelay = "short" | "medium" | "long";
+export type TooltipProps = React.PropsWithChildren<Omit<React.HTMLAttributes<HTMLElement>, "children"> & {
+    text: string;
+    direction?: TooltipDirection;
+    type?: TooltipType;
+    delay?: TooltipDelay;
+    className?: string;
+}>;
+export type TooltipContextValue = {
+    tooltipId?: string;
+};

package/build/components/tooltip/TooltipContext.d.ts

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

package/build/components/tooltip/anchoredPosition.d.ts

@@ -0,0 +1,15 @@
+export type AnchorSide = "outside-top" | "outside-right" | "outside-bottom" | "outside-left";
+export type AnchorAlignment = "start" | "center" | "end";
+export type AnchoredPositionOptions = {
+    side: AnchorSide;
+    align: AnchorAlignment;
+    anchorOffset?: number;
+    alignmentOffset?: number;
+};
+export type AnchoredPosition = {
+    top: number;
+    left: number;
+    anchorSide: AnchorSide;
+    anchorAlign: AnchorAlignment;
+};
+export declare const getAnchoredPosition: (floating: HTMLElement, anchor: HTMLElement, { side, align, anchorOffset, alignmentOffset, }: AnchoredPositionOptions) => AnchoredPosition;

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

@@ -0,0 +1,5 @@
+export { default as Tooltip } from "./Tooltip";
+export { TooltipContext } from "./TooltipContext";
+export { getAnchoredPosition } from "./anchoredPosition";
+export type { AnchorSide, AnchorAlignment, AnchoredPosition, AnchoredPositionOptions, } from "./anchoredPosition";
+export * from "./Tooltip.types";

package/build/components/topic-tag/TopicTag.d.ts

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

package/build/components/topic-tag/TopicTag.types.d.ts

@@ -0,0 +1,8 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type TopicTagProps<As extends React.ElementType = "a"> = PolymorphicProps<As, "a", {
+    className?: string;
+}>;
+export type TopicTagGroupProps<As extends React.ElementType = "div"> = PolymorphicProps<As, "div", {
+    className?: string;
+}>;

package/build/components/topic-tag/TopicTagGroup.d.ts

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

package/build/components/topic-tag/index.d.ts

@@ -0,0 +1,14 @@
+import TopicTagGroup from "./TopicTagGroup";
+export declare const TopicTag: (<As extends React.ElementType = "a">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "a" : As> & {
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Group: <As extends React.ElementType = "div">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "div" : As> & {
+        className?: string;
+    }, "as"> & {
+        as?: As | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { TopicTagGroup };
+export * from "./TopicTag.types";

package/build/components/tree-view/TreeView.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const _default: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & {
+    children?: React.ReactNode;
+    flat?: boolean;
+    truncate?: boolean;
+    className?: string;
+} & React.RefAttributes<any>>;
+export default _default;

package/build/components/tree-view/TreeView.types.d.ts

@@ -0,0 +1,60 @@
+import type * as React from "react";
+import type { DistributiveOmit } from "../../utilities/polymorphic";
+import type { ButtonVisual } from "../button";
+export type TreeViewSubTreeState = "initial" | "loading" | "done" | "error";
+export type TreeViewVisualChildren = React.ReactNode | ((props: {
+    isExpanded: boolean;
+}) => React.ReactNode);
+export type TreeViewSecondaryAction = {
+    label: string;
+    onClick: () => void;
+    icon: NonNullable<ButtonVisual>;
+    count?: number | string;
+    className?: string;
+};
+export type TreeViewProps = React.ComponentPropsWithoutRef<"ul"> & {
+    children?: React.ReactNode;
+    flat?: boolean;
+    truncate?: boolean;
+    className?: string;
+};
+type TreeViewItemBaseProps = {
+    id: string;
+    children?: React.ReactNode;
+    current?: boolean;
+    defaultExpanded?: boolean;
+    expanded?: boolean | null;
+    onExpandedChange?: (expanded: boolean) => void;
+    onSelect?: (event: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>) => void;
+    containIntrinsicSize?: string;
+    secondaryActions?: TreeViewSecondaryAction[];
+    className?: string;
+};
+export type TreeViewItemProps<As extends React.ElementType = "li"> = DistributiveOmit<React.ComponentPropsWithoutRef<React.ElementType extends As ? "li" : As>, "as" | "onSelect"> & TreeViewItemBaseProps & {
+    as?: As;
+};
+export type TreeViewSubTreeProps = {
+    children?: React.ReactNode;
+    state?: TreeViewSubTreeState;
+    count?: number;
+    "aria-label"?: string;
+};
+export type TreeViewVisualProps = {
+    children?: TreeViewVisualChildren;
+    label?: string;
+};
+export type TreeViewTrailingActionProps = {
+    items: TreeViewSecondaryAction[];
+    shortcutText: string;
+};
+export type TreeViewActionDialogProps = {
+    items: TreeViewSecondaryAction[];
+    onClose?: () => void;
+};
+export type TreeViewErrorDialogProps = {
+    children?: React.ReactNode;
+    title?: string;
+    onRetry?: () => void;
+    onDismiss?: () => void;
+};
+export {};

package/build/components/tree-view/TreeViewActionDialog.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { TreeViewActionDialogProps } from "./TreeView.types";
+declare function TreeViewActionDialog(props: TreeViewActionDialogProps): React.JSX.Element;
+declare namespace TreeViewActionDialog {
+    var displayName: string;
+}
+export default TreeViewActionDialog;

package/build/components/tree-view/TreeViewContext.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+export type TreeViewRootContextValue = {
+    announceUpdate: (message: string) => void;
+    expandedStateCache: React.RefObject<Map<string, boolean> | null>;
+    scrollElementIntoView: (element: Element | null | undefined) => void;
+};
+export declare const TreeViewRootContext: React.Context<TreeViewRootContextValue>;
+export type TreeViewItemContextValue = {
+    itemId: string;
+    level: number;
+    isSubTreeEmpty: boolean;
+    setIsSubTreeEmpty: React.Dispatch<React.SetStateAction<boolean>>;
+    isExpanded: boolean;
+    setIsExpanded: (isExpanded: boolean) => void;
+    leadingVisualId: string;
+    trailingVisualId: string;
+    trailingActionId: string;
+};
+export declare const TreeViewItemContext: React.Context<TreeViewItemContextValue>;
+export declare const TreeViewLoadingPlaceholderContext: React.Context<boolean>;

package/build/components/tree-view/TreeViewDirectoryIcon.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+declare function TreeViewDirectoryIcon(): React.JSX.Element;
+declare namespace TreeViewDirectoryIcon {
+    var displayName: string;
+}
+export default TreeViewDirectoryIcon;

package/build/components/tree-view/TreeViewErrorDialog.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { TreeViewErrorDialogProps } from "./TreeView.types";
+declare function TreeViewErrorDialog(props: TreeViewErrorDialogProps): React.JSX.Element;
+declare namespace TreeViewErrorDialog {
+    var displayName: string;
+}
+export default TreeViewErrorDialog;

package/build/components/tree-view/TreeViewItem.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+declare const _default: <As extends React.ElementType = "li">(props: import("../../utilities/polymorphic").DistributiveOmit<React.PropsWithoutRef<React.ComponentProps<React.ElementType<any, keyof React.JSX.IntrinsicElements> extends As ? "li" : As>>, "as" | "onSelect"> & {
+    id: string;
+    children?: React.ReactNode;
+    current?: boolean;
+    defaultExpanded?: boolean;
+    expanded?: boolean | null;
+    onExpandedChange?: (expanded: boolean) => void;
+    onSelect?: (event: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>) => void;
+    containIntrinsicSize?: string;
+    secondaryActions?: import("./TreeView.types").TreeViewSecondaryAction[];
+    className?: string;
+} & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/tree-view/TreeViewLeadingAction.d.ts

@@ -0,0 +1,6 @@
+import type { TreeViewVisualProps } from "./TreeView.types";
+declare function TreeViewLeadingAction(props: TreeViewVisualProps): import("react").JSX.Element;
+declare namespace TreeViewLeadingAction {
+    var displayName: string;
+}
+export default TreeViewLeadingAction;

package/build/components/tree-view/TreeViewLeadingVisual.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { TreeViewVisualProps } from "./TreeView.types";
+declare function TreeViewLeadingVisual(props: TreeViewVisualProps): React.JSX.Element;
+declare namespace TreeViewLeadingVisual {
+    var displayName: string;
+}
+export default TreeViewLeadingVisual;

package/build/components/tree-view/TreeViewSubTree.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { TreeViewSubTreeProps } from "./TreeView.types";
+declare function TreeViewSubTree(props: TreeViewSubTreeProps): React.JSX.Element | null;
+declare namespace TreeViewSubTree {
+    var displayName: string;
+}
+export default TreeViewSubTree;

package/build/components/tree-view/TreeViewTrailingAction.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { TreeViewTrailingActionProps } from "./TreeView.types";
+declare function TreeViewTrailingAction(props: TreeViewTrailingActionProps): React.JSX.Element;
+declare namespace TreeViewTrailingAction {
+    var displayName: string;
+}
+export default TreeViewTrailingAction;

package/build/components/tree-view/TreeViewTrailingVisual.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { TreeViewVisualProps } from "./TreeView.types";
+declare function TreeViewTrailingVisual(props: TreeViewVisualProps): React.JSX.Element;
+declare namespace TreeViewTrailingVisual {
+    var displayName: string;
+}
+export default TreeViewTrailingVisual;

package/build/components/tree-view/TreeViewVisual.d.ts

@@ -0,0 +1,15 @@
+import * as React from "react";
+import type { TreeViewVisualChildren } from "./TreeView.types";
+export declare const classes: {
+    visual: string;
+    hidden: string;
+};
+export declare const renderVisualChildren: (children: TreeViewVisualChildren, isExpanded: boolean) => React.ReactNode;
+export type TreeViewVisualContainerProps = {
+    children?: TreeViewVisualChildren;
+    label?: string;
+    labelId?: string;
+    className: string;
+    "data-component": string;
+};
+export declare const TreeViewVisualContainer: (props: TreeViewVisualContainerProps) => React.JSX.Element;