@gamecrafters/base-ui 0.0.1

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

@@ -0,0 +1,29 @@
+import type * as React from "react";
+import type { AnchoredOverlayAnchorProps, AnchoredOverlayProps } from "../anchored-overlay/AnchoredOverlay.types";
+import type { ButtonProps } from "../button";
+export type ActionMenuCloseGesture = "anchor-click" | "click-outside" | "escape" | "close-button" | "tab" | "item-select" | "arrow-left";
+export type ActionMenuProps = {
+    children: React.ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    anchorRef?: React.RefObject<HTMLElement | null>;
+};
+export type ActionMenuAnchorProps = React.HTMLAttributes<HTMLElement> & {
+    children: React.ReactElement;
+    id?: string;
+};
+export type ActionMenuButtonProps<As extends React.ElementType = "button"> = ButtonProps<As>;
+export type ActionMenuOverlayProps = Pick<AnchoredOverlayProps, "align" | "side" | "width" | "height" | "variant" | "preventOverflow" | "className"> & {
+    children: React.ReactNode;
+    "aria-labelledby"?: string;
+    returnFocusRef?: React.RefObject<HTMLElement | null>;
+};
+export type ActionMenuContextValue = {
+    anchorRef: React.RefObject<HTMLElement | null>;
+    renderAnchor: ((props: AnchoredOverlayAnchorProps) => React.ReactElement) | null;
+    anchorId?: string;
+    open: boolean;
+    onOpen?: () => void;
+    onClose?: (gesture: ActionMenuCloseGesture) => void;
+    isSubmenu?: boolean;
+};

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

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

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

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { ActionMenuButtonProps } from "./ActionMenu.types";
+declare function ActionMenuButton<As extends React.ElementType = "button">(props: ActionMenuButtonProps<As>): React.JSX.Element;
+declare namespace ActionMenuButton {
+    var displayName: string;
+}
+export default ActionMenuButton;

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

@@ -0,0 +1,2 @@
+import type { ActionMenuContextValue } from "./ActionMenu.types";
+export declare const ActionMenuContext: import("react").Context<ActionMenuContextValue | undefined>;

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

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

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

@@ -0,0 +1,14 @@
+import { ActionListDivider } from "../action-list";
+import ActionMenuBase from "./ActionMenu";
+import ActionMenuAnchor from "./ActionMenuAnchor";
+import ActionMenuButton from "./ActionMenuButton";
+import ActionMenuOverlay from "./ActionMenuOverlay";
+export declare const ActionMenu: typeof ActionMenuBase & {
+    Anchor: typeof ActionMenuAnchor;
+    Button: typeof ActionMenuButton;
+    Overlay: typeof ActionMenuOverlay;
+    Divider: typeof ActionListDivider;
+};
+export { ActionMenuAnchor, ActionMenuButton, ActionMenuOverlay };
+export { ActionMenuContext } from "./ActionMenuContext";
+export * from "./ActionMenu.types";

package/build/components/alert/Alert.d.ts

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

package/build/components/alert/Alert.types.d.ts

@@ -0,0 +1,7 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type AlertVariant = "default" | "success" | "warning" | "danger";
+export type AlertProps<As extends React.ElementType = "div"> = PolymorphicProps<As, "div", {
+    variant?: AlertVariant;
+    className?: string;
+}>;

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

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

package/build/components/anchored-overlay/AnchoredOverlay.d.ts

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

package/build/components/anchored-overlay/AnchoredOverlay.types.d.ts

@@ -0,0 +1,58 @@
+import type * as React from "react";
+import type { FocusTrapOptions } from "../../hooks/useFocusTrap";
+import type { ResponsiveValue } from "../../hooks/useResponsive";
+import type { AnchorAlignment, AnchoredPosition, AnchorSide } from "../tooltip/anchoredPosition";
+export type AnchoredOverlayOpenGesture = "anchor-click" | "anchor-key-press";
+export type AnchoredOverlayCloseGesture = "anchor-click" | "click-outside" | "escape" | "close-button";
+export type AnchoredOverlayWidth = "xsmall" | "small" | "medium" | "large" | "xlarge" | "auto";
+export type AnchoredOverlayHeight = "small" | "medium" | "large" | "xlarge" | "auto";
+export type AnchoredOverlayVariant = ResponsiveValue<"anchored", "anchored" | "fullscreen">;
+export type AnchoredOverlayAnchorProps = {
+    ref: React.Ref<any>;
+    id: string;
+    "aria-haspopup": "true";
+    "aria-expanded": boolean;
+    tabIndex: number;
+    onClick: React.MouseEventHandler<HTMLElement>;
+    onKeyDown: React.KeyboardEventHandler<HTMLElement>;
+};
+export type AnchoredOverlayAnchorRenderer = (props: AnchoredOverlayAnchorProps) => React.ReactElement;
+export type AnchoredOverlayOverlayProps = Omit<React.ComponentPropsWithRef<"div">, "children"> & {
+    portalContainerName?: string;
+};
+export type AnchoredOverlayFocusTrapSettings = Omit<FocusTrapOptions, "containerRef">;
+export type AnchoredOverlayCloseButtonProps = Omit<React.ComponentPropsWithRef<"button">, "children" | "onClick" | "aria-labelledby">;
+type AnchoredOverlayPropsWithAnchor = {
+    renderAnchor: AnchoredOverlayAnchorRenderer;
+    anchorRef?: React.RefObject<HTMLElement | null>;
+    anchorId?: string;
+};
+type AnchoredOverlayPropsWithoutAnchor = {
+    renderAnchor: null;
+    anchorRef: React.RefObject<HTMLElement | null>;
+    anchorId?: string;
+};
+export type AnchoredOverlayAnchorConfig = AnchoredOverlayPropsWithAnchor | AnchoredOverlayPropsWithoutAnchor;
+export type AnchoredOverlayBaseProps = React.PropsWithChildren<{
+    open: boolean;
+    onOpen?: (gesture: AnchoredOverlayOpenGesture, event?: React.KeyboardEvent<HTMLElement>) => void;
+    onClose?: (gesture: AnchoredOverlayCloseGesture) => void;
+    side?: AnchorSide;
+    align?: AnchorAlignment;
+    anchorOffset?: number;
+    alignmentOffset?: number;
+    width?: AnchoredOverlayWidth;
+    height?: AnchoredOverlayHeight;
+    overlayProps?: AnchoredOverlayOverlayProps;
+    focusTrapSettings?: AnchoredOverlayFocusTrapSettings;
+    preventOverflow?: boolean;
+    variant?: AnchoredOverlayVariant;
+    displayCloseButton?: boolean;
+    closeButtonProps?: AnchoredOverlayCloseButtonProps;
+    onPositionChange?: (event: {
+        position: AnchoredPosition;
+    }) => void;
+    className?: string;
+}>;
+export type AnchoredOverlayProps = AnchoredOverlayBaseProps & AnchoredOverlayAnchorConfig;
+export {};

package/build/components/anchored-overlay/index.d.ts

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

package/build/components/autocomplete/Autocomplete.d.ts

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

package/build/components/autocomplete/Autocomplete.types.d.ts

@@ -0,0 +1,77 @@
+import type * as React from "react";
+import type { Merge } from "../../utilities/polymorphic";
+import type { ActionListDescriptionVariant, ActionListItemVariant } from "../action-list";
+import type { TextInputProps } from "../text-input";
+import type { AnchorAlignment, AnchorSide } from "../tooltip/anchoredPosition";
+export type AutocompleteSelectionVariant = "single" | "multiple";
+export type AutocompleteVisual = React.ElementType | React.ReactNode;
+export type AutocompleteOverlayWidth = "xsmall" | "small" | "medium" | "large" | "xlarge" | "auto" | "anchor";
+export type AutocompleteOverlayHeight = "small" | "medium" | "large" | "xlarge" | "auto";
+export type AutocompleteOverlayMaxHeight = "small" | "medium" | "large" | "xlarge";
+export type AutocompleteItem = Merge<Omit<React.ComponentPropsWithoutRef<"li">, "onSelect">, {
+    id: string;
+    text?: string;
+    description?: string;
+    descriptionVariant?: ActionListDescriptionVariant;
+    leadingVisual?: AutocompleteVisual;
+    trailingVisual?: AutocompleteVisual;
+    variant?: ActionListItemVariant;
+    disabled?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+}>;
+export type AutocompleteAddNewItem<T extends AutocompleteItem = AutocompleteItem> = {
+    item: T;
+    onAdd: (item: T) => void;
+};
+export type AutocompleteProps = React.PropsWithChildren<{
+    id?: string;
+}>;
+export type AutocompleteInputProps<As extends React.ElementType = never> = Merge<TextInputProps, {
+    as?: As;
+    openOnFocus?: boolean;
+}>;
+export type AutocompleteMenuProps<T extends AutocompleteItem = AutocompleteItem> = {
+    items: T[];
+    selectedItemIds?: string[];
+    selectionVariant?: AutocompleteSelectionVariant;
+    filter?: (item: T, index: number) => boolean;
+    sortOnClose?: (itemIdA: string, itemIdB: string) => number;
+    emptyStateText?: React.ReactNode | false;
+    addNewItem?: AutocompleteAddNewItem<T>;
+    loading?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onSelectedChange?: (items: T[]) => void;
+    customScrollContainerRef?: React.RefObject<HTMLElement | null>;
+    "aria-labelledby": string;
+    className?: string;
+};
+export type AutocompleteOverlayProps = Omit<React.ComponentPropsWithoutRef<"div">, "children"> & {
+    menuAnchorRef?: React.RefObject<HTMLElement | null>;
+    side?: AnchorSide;
+    align?: AnchorAlignment;
+    width?: AutocompleteOverlayWidth;
+    height?: AutocompleteOverlayHeight;
+    maxHeight?: AutocompleteOverlayMaxHeight;
+    portalContainerName?: string;
+    children?: React.ReactNode;
+    className?: string;
+};
+export type AutocompleteContextValue = {
+    id?: string;
+    inputRef?: React.RefObject<HTMLInputElement | null>;
+    scrollContainerRef?: React.RefObject<HTMLDivElement | null>;
+    activeDescendantId?: string;
+    setActiveDescendantId?: (id: string | undefined) => void;
+    showMenu?: boolean;
+    setShowMenu?: (show: boolean) => void;
+    setInputValue?: (value: string) => void;
+    setAutocompleteSuggestion?: (suggestion: string) => void;
+};
+export type AutocompleteInputContextValue = {
+    inputValue?: string;
+    autocompleteSuggestion?: string;
+};
+export type AutocompleteDeferredInputContextValue = {
+    deferredInputValue?: string;
+};

package/build/components/autocomplete/AutocompleteContext.d.ts

@@ -0,0 +1,4 @@
+import type { AutocompleteContextValue, AutocompleteDeferredInputContextValue, AutocompleteInputContextValue } from "./Autocomplete.types";
+export declare const AutocompleteContext: import("react").Context<AutocompleteContextValue>;
+export declare const AutocompleteInputContext: import("react").Context<AutocompleteInputContextValue>;
+export declare const AutocompleteDeferredInputContext: import("react").Context<AutocompleteDeferredInputContextValue>;

package/build/components/autocomplete/AutocompleteInput.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+declare const _default: <As extends React.ElementType = never>(props: Omit<import("..").TextInputProps, "as" | "openOnFocus"> & {
+    as?: As | undefined;
+    openOnFocus?: boolean;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/autocomplete/AutocompleteMenu.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { AutocompleteItem, AutocompleteMenuProps } from "./Autocomplete.types";
+declare function AutocompleteMenu<T extends AutocompleteItem>(props: AutocompleteMenuProps<T>): React.JSX.Element;
+declare namespace AutocompleteMenu {
+    var displayName: string;
+}
+export default AutocompleteMenu;

package/build/components/autocomplete/AutocompleteOverlay.d.ts

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

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

@@ -0,0 +1,15 @@
+import AutocompleteBase from "./Autocomplete";
+import AutocompleteInput from "./AutocompleteInput";
+import AutocompleteMenu from "./AutocompleteMenu";
+import AutocompleteOverlay from "./AutocompleteOverlay";
+export declare const Autocomplete: typeof AutocompleteBase & {
+    Input: <As extends React.ElementType = never>(props: Omit<import("..").TextInputProps, "as" | "openOnFocus"> & {
+        as?: As | undefined;
+        openOnFocus?: boolean;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Menu: typeof AutocompleteMenu;
+    Overlay: typeof AutocompleteOverlay;
+};
+export { AutocompleteInput, AutocompleteMenu, AutocompleteOverlay };
+export { AutocompleteContext, AutocompleteInputContext, AutocompleteDeferredInputContext, } from "./AutocompleteContext";
+export * from "./Autocomplete.types";

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

@@ -0,0 +1,11 @@
+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> & {
+    size?: import("./Avatar.types").AvatarSize;
+    shape?: AvatarShape;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

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

@@ -0,0 +1,10 @@
+import type * as React from "react";
+import type { ResponsiveValue } from "../../hooks/useResponsive";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type AvatarSize = number | ResponsiveValue<number>;
+export type AvatarShape = "circle" | "square";
+export type AvatarProps<As extends React.ElementType = "img"> = PolymorphicProps<As, "img", {
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    className?: string;
+}>;

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

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

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

@@ -0,0 +1,14 @@
+import * as React from "react";
+import type { AvatarShape, AvatarSize } from "../avatar/Avatar.types";
+import type { 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> & {
+    variant?: AvatarStackVariant;
+    shape?: AvatarShape;
+    size?: AvatarSize;
+    alignRight?: boolean;
+    disableExpand?: boolean;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

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

@@ -0,0 +1,12 @@
+import type * as React from "react";
+import type { AvatarShape, AvatarSize } from "../avatar/Avatar.types";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type AvatarStackVariant = "cascade" | "stack";
+export type AvatarStackProps<As extends React.ElementType = "span"> = PolymorphicProps<As, "span", {
+    variant?: AvatarStackVariant;
+    shape?: AvatarShape;
+    size?: AvatarSize;
+    alignRight?: boolean;
+    disableExpand?: boolean;
+    className?: string;
+}>;

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

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

package/build/components/banner/Banner.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+import type { BannerLayout, BannerVariant } from "./Banner.types";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    hideTitle?: boolean;
+    leadingVisual?: React.ReactNode;
+    variant?: BannerVariant;
+    layout?: BannerLayout;
+    actionsLayout?: import("./Banner.types").BannerActionsLayout;
+    flush?: boolean;
+    onDismiss?: () => void;
+    primaryAction?: React.ReactNode;
+    secondaryAction?: React.ReactNode;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/banner/Banner.types.d.ts

@@ -0,0 +1,33 @@
+import type * as React from "react";
+import type { ButtonProps } from "../button";
+export type BannerVariant = "critical" | "info" | "success" | "upsell" | "warning";
+export type BannerLayout = "default" | "compact";
+export type BannerActionsLayout = "default" | "inline" | "stacked";
+export type BannerTitleLevel = "h2" | "h3" | "h4" | "h5" | "h6";
+export type BannerProps = React.ComponentPropsWithoutRef<"section"> & {
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    hideTitle?: boolean;
+    leadingVisual?: React.ReactNode;
+    variant?: BannerVariant;
+    layout?: BannerLayout;
+    actionsLayout?: BannerActionsLayout;
+    flush?: boolean;
+    onDismiss?: () => void;
+    primaryAction?: React.ReactNode;
+    secondaryAction?: React.ReactNode;
+    className?: string;
+};
+export type BannerTitleProps = React.ComponentPropsWithoutRef<"h2"> & {
+    as?: BannerTitleLevel;
+    className?: string;
+};
+export type BannerDescriptionProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type BannerActionProps = Omit<ButtonProps, "variant">;
+export type BannerPrimaryActionProps = BannerActionProps;
+export type BannerSecondaryActionProps = BannerActionProps;
+export type BannerContextValue = {
+    titleId?: string;
+};

package/build/components/banner/BannerContext.d.ts

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

package/build/components/banner/BannerDescription.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/banner/BannerPrimaryAction.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const _default: (props: import("./Banner.types").BannerActionProps & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/banner/BannerSecondaryAction.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const _default: (props: import("./Banner.types").BannerActionProps & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/banner/BannerTitle.d.ts

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

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

@@ -0,0 +1,31 @@
+import BannerDescription from "./BannerDescription";
+import BannerPrimaryAction from "./BannerPrimaryAction";
+import BannerSecondaryAction from "./BannerSecondaryAction";
+import BannerTitle from "./BannerTitle";
+export declare const Banner: ((props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    hideTitle?: boolean;
+    leadingVisual?: React.ReactNode;
+    variant?: import("./Banner.types").BannerVariant;
+    layout?: import("./Banner.types").BannerLayout;
+    actionsLayout?: import("./Banner.types").BannerActionsLayout;
+    flush?: boolean;
+    onDismiss?: () => void;
+    primaryAction?: React.ReactNode;
+    secondaryAction?: React.ReactNode;
+    className?: string;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Title: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & {
+        as?: import("./Banner.types").BannerTitleLevel;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Description: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    PrimaryAction: (props: import("./Banner.types").BannerActionProps & import("react").RefAttributes<any>) => React.ReactNode;
+    SecondaryAction: (props: import("./Banner.types").BannerActionProps & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { BannerTitle, BannerDescription, BannerPrimaryAction, BannerSecondaryAction };
+export { BannerContext } from "./BannerContext";
+export * from "./Banner.types";

package/build/components/blankslate/Blankslate.d.ts

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

package/build/components/blankslate/Blankslate.types.d.ts

@@ -0,0 +1,28 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type BlankslateSize = "small" | "medium" | "large";
+export type BlankslateHeadingLevel = "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
+export type BlankslateProps<As extends React.ElementType = "div"> = PolymorphicProps<As, "div", {
+    size?: BlankslateSize;
+    border?: boolean;
+    narrow?: boolean;
+    spacious?: boolean;
+    className?: string;
+}>;
+export type BlankslateVisualProps = React.ComponentPropsWithoutRef<"span"> & {
+    className?: string;
+};
+export type BlankslateHeadingProps = React.ComponentPropsWithoutRef<"h2"> & {
+    as?: BlankslateHeadingLevel;
+    className?: string;
+};
+export type BlankslateDescriptionProps = React.ComponentPropsWithoutRef<"p"> & {
+    className?: string;
+};
+export type BlankslateActionProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type BlankslatePrimaryActionProps = BlankslateActionProps;
+export type BlankslateSecondaryActionProps = BlankslateActionProps & {
+    href?: string;
+};

package/build/components/blankslate/BlankslateAction.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/blankslate/BlankslateDescription.d.ts

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

package/build/components/blankslate/BlankslateHeading.d.ts

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

package/build/components/blankslate/BlankslatePrimaryAction.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/blankslate/BlankslateSecondaryAction.d.ts

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

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

@@ -0,0 +1,35 @@
+import BlankslateDescription from "./BlankslateDescription";
+import BlankslateHeading from "./BlankslateHeading";
+import BlankslatePrimaryAction from "./BlankslatePrimaryAction";
+import BlankslateSecondaryAction from "./BlankslateSecondaryAction";
+import BlankslateVisual from "./BlankslateVisual";
+export declare const Blankslate: (<As extends React.ElementType = "div">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "div" : As> & {
+    size?: import("./Blankslate.types").BlankslateSize;
+    border?: boolean;
+    narrow?: boolean;
+    spacious?: boolean;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Visual: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Heading: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & {
+        as?: import("./Blankslate.types").BlankslateHeadingLevel;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Description: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    PrimaryAction: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    SecondaryAction: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & {
+        href?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { BlankslateVisual, BlankslateHeading, BlankslateDescription, BlankslatePrimaryAction, BlankslateSecondaryAction, };
+export * from "./Blankslate.types";

package/build/components/breadcrumbs/Breadcrumbs.d.ts

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