@gamecrafters/base-ui 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Donald Lee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/build/components/accordion/Accordion.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+declare const _default: <As extends React.ElementType = "div">(props: Omit<import("../../utilities/polymorphic").PolymorphicProps<As, "div", {
+    value?: string[];
+    defaultValue?: string[];
+    multiple?: boolean;
+    disabled?: boolean;
+    headingLevel?: import("./Accordion.types").AccordionHeadingLevel;
+    className?: string;
+}>, "onChange"> & {
+    onChange?: (value: string[]) => void;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/accordion/Accordion.types.d.ts

@@ -0,0 +1,38 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type AccordionHeadingLevel = "h2" | "h3" | "h4" | "h5" | "h6";
+export type AccordionProps<As extends React.ElementType = "div"> = Omit<PolymorphicProps<As, "div", {
+    value?: string[];
+    defaultValue?: string[];
+    multiple?: boolean;
+    disabled?: boolean;
+    headingLevel?: AccordionHeadingLevel;
+    className?: string;
+}>, "onChange"> & {
+    onChange?: (value: string[]) => void;
+};
+export type AccordionItemProps<As extends React.ElementType = "div"> = PolymorphicProps<As, "div", {
+    value?: string;
+    disabled?: boolean;
+    className?: string;
+}>;
+export type AccordionHeaderProps = React.ComponentPropsWithoutRef<"button"> & {
+    headingLevel?: AccordionHeadingLevel;
+    className?: string;
+};
+export type AccordionPanelProps<As extends React.ElementType = "div"> = PolymorphicProps<As, "div", {
+    className?: string;
+}>;
+export type AccordionContextValue = {
+    open?: string[];
+    toggle?: (value: string) => void;
+    disabled?: boolean;
+    headingLevel?: AccordionHeadingLevel;
+};
+export type AccordionItemContextValue = {
+    headerId?: string;
+    panelId?: string;
+    isOpen?: boolean;
+    disabled?: boolean;
+    toggle?: () => void;
+};

package/build/components/accordion/AccordionContext.d.ts

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

package/build/components/accordion/AccordionHeader.d.ts

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

package/build/components/accordion/AccordionItem.d.ts

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

package/build/components/accordion/AccordionItemContext.d.ts

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

package/build/components/accordion/AccordionPanel.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/accordion/index.d.ts

@@ -0,0 +1,34 @@
+import AccordionHeader from "./AccordionHeader";
+import AccordionItem from "./AccordionItem";
+import AccordionPanel from "./AccordionPanel";
+export declare const Accordion: (<As extends React.ElementType = "div">(props: Omit<import("../../utilities/polymorphic").PolymorphicProps<As, "div", {
+    value?: string[];
+    defaultValue?: string[];
+    multiple?: boolean;
+    disabled?: boolean;
+    headingLevel?: import("./Accordion.types").AccordionHeadingLevel;
+    className?: string;
+}>, "onChange"> & {
+    onChange?: (value: string[]) => void;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Item: <As extends React.ElementType = "div">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "div" : As> & {
+        value?: string;
+        disabled?: boolean;
+        className?: string;
+    }, "as"> & {
+        as?: As | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Header: (props: Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+        headingLevel?: import("./Accordion.types").AccordionHeadingLevel;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Panel: <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 { AccordionItem, AccordionHeader, AccordionPanel };
+export { AccordionContext } from "./AccordionContext";
+export { AccordionItemContext } from "./AccordionItemContext";
+export * from "./Accordion.types";

package/build/components/action-bar/ActionBar.d.ts

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

package/build/components/action-bar/ActionBar.types.d.ts

@@ -0,0 +1,57 @@
+import type * as React from "react";
+import type { ActionListItemVariant, ActionListSelectEvent } from "../action-list";
+import type { ButtonProps, ButtonVisual } from "../button";
+import type { IconButtonProps } from "../icon-button";
+export type ActionBarSize = "small" | "medium" | "large";
+export type ActionBarGap = "none" | "condensed";
+type ActionBarAccessibleName = {
+    "aria-label": string;
+    "aria-labelledby"?: undefined;
+} | {
+    "aria-label"?: undefined;
+    "aria-labelledby": string;
+};
+export type ActionBarProps = {
+    size?: ActionBarSize;
+    children?: React.ReactNode;
+    flush?: boolean;
+    gap?: ActionBarGap;
+    className?: string;
+} & ActionBarAccessibleName;
+export type ActionBarButtonProps = ButtonProps;
+export type ActionBarIconButtonProps = IconButtonProps;
+export type ActionBarDividerProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type ActionBarGroupProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type ActionBarMenuItem = {
+    type?: "action";
+    label: string;
+    disabled?: boolean;
+    variant?: ActionListItemVariant;
+    leadingVisual?: ButtonVisual;
+    trailingVisual?: ButtonVisual | string;
+    onClick?: (event: ActionListSelectEvent) => void;
+    items?: ActionBarMenuItem[];
+} | {
+    type: "divider";
+};
+export type ActionBarMenuProps = Omit<IconButtonProps, "icon" | "aria-label" | "aria-labelledby"> & {
+    "aria-label": string;
+    icon: NonNullable<ButtonVisual>;
+    items: ActionBarMenuItem[];
+    overflowIcon?: ButtonVisual;
+    returnFocusRef?: React.RefObject<HTMLElement | null>;
+};
+export type ActionBarContextValue = {
+    size: ActionBarSize;
+    rootRef?: React.RefObject<HTMLElement | null>;
+    setOverflowing?: (index: number, overflowing: boolean) => void;
+};
+export type ActionBarItemContextValue = {
+    index?: number;
+    inGroup?: boolean;
+};
+export {};

package/build/components/action-bar/ActionBarButton.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement> & import("..").ButtonBaseProps & import("..").ButtonContentProps, "as"> & {
+    as?: "button" | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/action-bar/ActionBarContext.d.ts

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

package/build/components/action-bar/ActionBarDivider.d.ts

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

package/build/components/action-bar/ActionBarGroup.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { ActionBarGroupProps } from "./ActionBar.types";
+declare function ActionBarGroup(props: React.PropsWithChildren<ActionBarGroupProps>): React.JSX.Element;
+declare namespace ActionBarGroup {
+    var displayName: string;
+}
+export default ActionBarGroup;

package/build/components/action-bar/ActionBarIconButton.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import type { ActionBarIconButtonProps } from "./ActionBar.types";
+declare const _default: (props: ActionBarIconButtonProps & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/action-bar/ActionBarItemContext.d.ts

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

package/build/components/action-bar/ActionBarMenu.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+declare const _default: (props: Omit<import("..").IconButtonProps, "aria-label" | "aria-labelledby" | "icon"> & {
+    "aria-label": string;
+    icon: NonNullable<import("..").ButtonVisual>;
+    items: import("./ActionBar.types").ActionBarMenuItem[];
+    overflowIcon?: import("..").ButtonVisual;
+    returnFocusRef?: React.RefObject<HTMLElement | null>;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/action-bar/ActionBarMenuItems.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+import type { ActionBarMenuItem } from "./ActionBar.types";
+export declare const ActionBarMenuItems: ({ items }: {
+    items: ActionBarMenuItem[];
+}) => React.JSX.Element;

package/build/components/action-bar/index.d.ts

@@ -0,0 +1,25 @@
+import ActionBarBase from "./ActionBar";
+import ActionBarButton from "./ActionBarButton";
+import ActionBarDivider from "./ActionBarDivider";
+import ActionBarGroup from "./ActionBarGroup";
+import ActionBarIconButton from "./ActionBarIconButton";
+import ActionBarMenu from "./ActionBarMenu";
+export declare const ActionBar: typeof ActionBarBase & {
+    Button: (props: Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & import("..").ButtonBaseProps & import("..").ButtonContentProps, "as"> & {
+        as?: "button" | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    IconButton: (props: import("./ActionBar.types").ActionBarIconButtonProps & import("react").RefAttributes<any>) => React.ReactNode;
+    Divider: typeof ActionBarDivider;
+    Group: typeof ActionBarGroup;
+    Menu: (props: Omit<import("..").IconButtonProps, "aria-label" | "aria-labelledby" | "icon"> & {
+        "aria-label": string;
+        icon: NonNullable<import("..").ButtonVisual>;
+        items: import("./ActionBar.types").ActionBarMenuItem[];
+        overflowIcon?: import("..").ButtonVisual;
+        returnFocusRef?: React.RefObject<HTMLElement | null>;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { ActionBarButton, ActionBarIconButton, ActionBarDivider, ActionBarGroup, ActionBarMenu };
+export { ActionBarContext } from "./ActionBarContext";
+export { ActionBarItemContext } from "./ActionBarItemContext";
+export * from "./ActionBar.types";

package/build/components/action-bar/useActionBarItem.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+export declare const useActionBarItem: (ref: React.RefObject<HTMLElement | null>) => {
+    size: import("./ActionBar.types").ActionBarSize;
+    isOverflowing: boolean;
+};

package/build/components/action-list/ActionList.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+import type { ActionListVariant } from "./ActionList.types";
+declare const _default: <As extends React.ElementType = "ul">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "ul" : As> & {
+    variant?: ActionListVariant;
+    selectionVariant?: import("./ActionList.types").ActionListSelectionVariant;
+    showDividers?: boolean;
+    disableFocusZone?: boolean;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/action-list/ActionList.types.d.ts

@@ -0,0 +1,95 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+import type { ButtonVisual } from "../button";
+export type ActionListVariant = "inset" | "full";
+export type ActionListSelectionVariant = "single" | "multiple";
+export type ActionListItemVariant = "default" | "danger";
+export type ActionListItemSize = "medium" | "large";
+export type ActionListDescriptionVariant = "inline" | "block";
+export type ActionListGroupVariant = "subtle" | "filled";
+export type ActionListSelectEvent = React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>;
+export type ActionListProps<As extends React.ElementType = "ul"> = PolymorphicProps<As, "ul", {
+    variant?: ActionListVariant;
+    selectionVariant?: ActionListSelectionVariant;
+    showDividers?: boolean;
+    disableFocusZone?: boolean;
+    className?: string;
+}>;
+export type ActionListItemProps<As extends React.ElementType = never> = Omit<React.ComponentPropsWithoutRef<"li">, "onSelect"> & {
+    onSelect?: (event: ActionListSelectEvent) => void;
+    selected?: boolean;
+    active?: boolean;
+    variant?: ActionListItemVariant;
+    size?: ActionListItemSize;
+    disabled?: boolean;
+    loading?: boolean;
+    inactiveText?: string;
+    className?: string;
+    as?: As;
+};
+export type ActionListLinkItemProps<As extends React.ElementType = "a"> = Omit<ActionListItemProps<As>, "selected" | "loading" | "onSelect"> & Pick<React.ComponentPropsWithoutRef<"a">, "href" | "hrefLang" | "rel" | "target" | "download">;
+export type ActionListGroupProps = React.ComponentPropsWithoutRef<"li"> & {
+    variant?: ActionListGroupVariant;
+    selectionVariant?: ActionListSelectionVariant | false;
+    className?: string;
+};
+export type ActionListGroupHeadingProps = Omit<React.ComponentPropsWithoutRef<"h3">, "children"> & {
+    as?: "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
+    variant?: ActionListGroupVariant;
+    auxiliaryText?: string;
+    children?: React.ReactNode;
+    className?: string;
+};
+export type ActionListHeadingProps<As extends React.ElementType = "h3"> = PolymorphicProps<As, "h3", {
+    as: "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
+    visuallyHidden?: boolean;
+    className?: string;
+}>;
+export type ActionListDescriptionProps = React.ComponentPropsWithoutRef<"span"> & {
+    variant?: ActionListDescriptionVariant;
+    className?: string;
+};
+export type ActionListDividerProps = React.ComponentPropsWithoutRef<"li"> & {
+    className?: string;
+};
+export type ActionListSubItemProps = {
+    children?: React.ReactNode;
+};
+export type ActionListVisualProps = React.ComponentPropsWithoutRef<"span"> & {
+    className?: string;
+};
+export type ActionListTrailingActionProps = Omit<React.ComponentPropsWithoutRef<"button">, "children" | "aria-label" | "aria-labelledby"> & {
+    icon?: ButtonVisual;
+    label: string;
+    className?: string;
+};
+export type ActionListContextValue = {
+    variant?: ActionListVariant;
+    selectionVariant?: ActionListSelectionVariant;
+    showDividers?: boolean;
+    role?: React.AriaRole;
+    headingId?: string;
+};
+export type ActionListItemContextValue = {
+    variant?: ActionListItemVariant;
+    size?: ActionListItemSize;
+    disabled?: boolean;
+    inactive?: boolean;
+    inlineDescriptionId?: string;
+    blockDescriptionId?: string;
+    trailingVisualId?: string;
+};
+export type ActionListGroupContextValue = {
+    selectionVariant?: ActionListSelectionVariant | false;
+    groupHeadingId?: string;
+};
+export type ActionListContainerContextValue = {
+    container?: string;
+    listRole?: React.AriaRole;
+    listLabelledBy?: string;
+    selectionVariant?: ActionListSelectionVariant;
+    selectionAttribute?: "aria-selected" | "aria-checked";
+    afterSelect?: (event: ActionListSelectEvent) => void;
+    enableFocusZone?: boolean;
+    defaultTrailingVisual?: React.ReactNode;
+};

package/build/components/action-list/ActionListContainerContext.d.ts

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

package/build/components/action-list/ActionListContext.d.ts

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

package/build/components/action-list/ActionListDescription.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { ActionListDescriptionProps } from "./ActionList.types";
+declare function ActionListDescription(props: React.PropsWithChildren<ActionListDescriptionProps>): React.JSX.Element;
+declare namespace ActionListDescription {
+    var displayName: string;
+}
+export default ActionListDescription;

package/build/components/action-list/ActionListDivider.d.ts

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

package/build/components/action-list/ActionListGroup.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { ActionListGroupProps } from "./ActionList.types";
+declare function ActionListGroup(props: React.PropsWithChildren<ActionListGroupProps>): React.JSX.Element;
+declare namespace ActionListGroup {
+    var displayName: string;
+}
+export default ActionListGroup;

package/build/components/action-list/ActionListGroupContext.d.ts

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

package/build/components/action-list/ActionListGroupHeading.d.ts

@@ -0,0 +1,5 @@
+import type { ActionListGroupHeadingProps } from "./ActionList.types";
+import type { FCWithSlotMarker, SlotMarker } from "../../utilities/types/slots";
+export declare const groupHeadingSlot: SlotMarker;
+declare const GroupHeading: FCWithSlotMarker<ActionListGroupHeadingProps>;
+export default GroupHeading;

package/build/components/action-list/ActionListHeading.d.ts

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

package/build/components/action-list/ActionListItem.d.ts

@@ -0,0 +1,15 @@
+import * as React from "react";
+import type { ActionListItemSize, ActionListSelectEvent } from "./ActionList.types";
+declare const _default: <As extends React.ElementType = never>(props: Omit<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref">, "onSelect"> & {
+    onSelect?: (event: ActionListSelectEvent) => void;
+    selected?: boolean;
+    active?: boolean;
+    variant?: import("./ActionList.types").ActionListItemVariant;
+    size?: ActionListItemSize;
+    disabled?: boolean;
+    loading?: boolean;
+    inactiveText?: string;
+    className?: string;
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/action-list/ActionListItemContext.d.ts

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

package/build/components/action-list/ActionListLeadingVisual.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { ActionListVisualProps } from "./ActionList.types";
+declare function ActionListLeadingVisual(props: React.PropsWithChildren<ActionListVisualProps>): React.JSX.Element;
+declare namespace ActionListLeadingVisual {
+    var displayName: string;
+}
+export default ActionListLeadingVisual;

package/build/components/action-list/ActionListLinkItem.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const _default: <As extends React.ElementType = "a">(props: Omit<import("./ActionList.types").ActionListItemProps<As>, "onSelect" | "loading" | "selected"> & Pick<Omit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref">, "rel" | "href" | "download" | "hrefLang" | "target"> & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/action-list/ActionListSelection.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+type ActionListSelectionProps = {
+    selected?: boolean;
+    className?: string;
+};
+export declare const ActionListSelection: ({ selected, className }: ActionListSelectionProps) => React.JSX.Element | null;
+export {};

package/build/components/action-list/ActionListSubItem.d.ts

@@ -0,0 +1,6 @@
+import type { ActionListSubItemProps } from "./ActionList.types";
+declare function ActionListSubItem({ children }: ActionListSubItemProps): import("react").JSX.Element;
+declare namespace ActionListSubItem {
+    var displayName: string;
+}
+export default ActionListSubItem;

package/build/components/action-list/ActionListTrailingAction.d.ts

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

package/build/components/action-list/ActionListTrailingVisual.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { ActionListVisualProps } from "./ActionList.types";
+declare function ActionListTrailingVisual(props: React.PropsWithChildren<ActionListVisualProps>): React.JSX.Element;
+declare namespace ActionListTrailingVisual {
+    var displayName: string;
+}
+export default ActionListTrailingVisual;

package/build/components/action-list/ActionListVisual.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+import type { ActionListVisualProps } from "./ActionList.types";
+export declare const ActionListVisualContainer: ({ className, ...rest }: React.PropsWithChildren<ActionListVisualProps>) => React.JSX.Element;

package/build/components/action-list/index.d.ts

@@ -0,0 +1,59 @@
+import ActionListDescription from "./ActionListDescription";
+import ActionListDivider from "./ActionListDivider";
+import ActionListGroup from "./ActionListGroup";
+import ActionListGroupHeading from "./ActionListGroupHeading";
+import ActionListHeading from "./ActionListHeading";
+import ActionListItem from "./ActionListItem";
+import ActionListLeadingVisual from "./ActionListLeadingVisual";
+import ActionListLinkItem from "./ActionListLinkItem";
+import ActionListSubItem from "./ActionListSubItem";
+import ActionListTrailingAction from "./ActionListTrailingAction";
+import ActionListTrailingVisual from "./ActionListTrailingVisual";
+export declare const ActionList: (<As extends React.ElementType = "ul">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "ul" : As> & {
+    variant?: import("./ActionList.types").ActionListVariant;
+    selectionVariant?: import("./ActionList.types").ActionListSelectionVariant;
+    showDividers?: boolean;
+    disableFocusZone?: boolean;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Item: <As extends React.ElementType = never>(props: Omit<Omit<import("react").DetailedHTMLProps<import("react").LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref">, "onSelect"> & {
+        onSelect?: (event: import("./ActionList.types").ActionListSelectEvent) => void;
+        selected?: boolean;
+        active?: boolean;
+        variant?: import("./ActionList.types").ActionListItemVariant;
+        size?: import("./ActionList.types").ActionListItemSize;
+        disabled?: boolean;
+        loading?: boolean;
+        inactiveText?: string;
+        className?: string;
+        as?: As | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    LinkItem: <As extends React.ElementType = "a">(props: Omit<import("./ActionList.types").ActionListItemProps<As>, "onSelect" | "loading" | "selected"> & Pick<Omit<import("react").DetailedHTMLProps<import("react").AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref">, "rel" | "href" | "download" | "hrefLang" | "target"> & import("react").RefAttributes<any>) => React.ReactNode;
+    Group: typeof ActionListGroup;
+    GroupHeading: import("../../utilities/types/slots").FCWithSlotMarker<import("./ActionList.types").ActionListGroupHeadingProps>;
+    Heading: <As extends React.ElementType = "h3">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "h3" : As> & {
+        as: "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
+        visuallyHidden?: boolean;
+        className?: string;
+    }, "as"> & {
+        as?: As | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Description: typeof ActionListDescription;
+    Divider: typeof ActionListDivider;
+    LeadingVisual: typeof ActionListLeadingVisual;
+    TrailingVisual: typeof ActionListTrailingVisual;
+    TrailingAction: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "aria-label" | "aria-labelledby" | "children"> & {
+        icon?: import("..").ButtonVisual;
+        label: string;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    SubItem: typeof ActionListSubItem;
+};
+export { ActionListItem, ActionListLinkItem, ActionListGroup, ActionListGroupHeading, ActionListHeading, ActionListDescription, ActionListDivider, ActionListLeadingVisual, ActionListTrailingVisual, ActionListTrailingAction, ActionListSubItem, };
+export { ActionListContext } from "./ActionListContext";
+export { ActionListItemContext } from "./ActionListItemContext";
+export { ActionListGroupContext } from "./ActionListGroupContext";
+export { ActionListContainerContext } from "./ActionListContainerContext";
+export * from "./ActionList.types";

package/build/components/action-menu/ActionMenu.d.ts

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