@gamecrafters/base-ui 0.0.1

package/build/components/radio-group/index.d.ts

@@ -0,0 +1,26 @@
+import RadioGroupCaption from "./RadioGroupCaption";
+import RadioGroupLabel from "./RadioGroupLabel";
+import RadioGroupValidation from "./RadioGroupValidation";
+export declare const RadioGroup: (<As extends React.ElementType = "fieldset">(props: Omit<import("../../utilities/polymorphic").PolymorphicProps<As, "fieldset", {
+    disabled?: boolean;
+    required?: boolean;
+    className?: string;
+}>, "onChange"> & {
+    name: string;
+    onChange?: (selected: string, event?: React.ChangeEvent<HTMLInputElement>) => void;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Label: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        visuallyHidden?: boolean;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Caption: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Validation: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        variant: import("./RadioGroup.types").RadioGroupValidationStatus;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { RadioGroupLabel, RadioGroupCaption, RadioGroupValidation };
+export { RadioGroupContext } from "./RadioGroupContext";
+export * from "./RadioGroup.types";

package/build/components/relative-time/RelativeTime.d.ts

@@ -0,0 +1,15 @@
+import * as React from "react";
+declare const _default: <As extends React.ElementType = "time">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "time" : As> & import("./RelativeTime.types").RelativeTimeDateOptions & {
+    date?: Date;
+    datetime?: string;
+    format?: import("./RelativeTime.types").RelativeTimeFormat;
+    tense?: import("./RelativeTime.types").RelativeTimeTense;
+    precision?: import("./RelativeTime.types").RelativeTimePrecision;
+    threshold?: string;
+    prefix?: string;
+    noTitle?: boolean;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/relative-time/RelativeTime.types.d.ts

@@ -0,0 +1,40 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type RelativeTimeFormat = "auto" | "micro" | "elapsed";
+export type RelativeTimeTense = "auto" | "past" | "future";
+export type RelativeTimePrecision = "year" | "month" | "day" | "hour" | "minute" | "second";
+export type RelativeTimeUnit = "year" | "month" | "week" | "day" | "hour" | "minute" | "second";
+export type RelativeTimeDateOptions = {
+    weekday?: "short" | "long" | "narrow";
+    year?: "numeric" | "2-digit";
+    month?: "numeric" | "2-digit" | "short" | "long" | "narrow";
+    day?: "numeric" | "2-digit";
+    hour?: "numeric" | "2-digit";
+    minute?: "numeric" | "2-digit";
+    second?: "numeric" | "2-digit";
+    timeZoneName?: "short" | "long" | "shortOffset" | "longOffset" | "shortGeneric" | "longGeneric";
+};
+export type RelativeTimeSettings = {
+    format: RelativeTimeFormat;
+    tense: RelativeTimeTense;
+    precision: RelativeTimePrecision;
+    threshold: string;
+    prefix: string;
+    dateOptions: RelativeTimeDateOptions;
+    locale?: string;
+};
+export type FormattedRelativeTime = {
+    text: string;
+    updateDelay: number | null;
+};
+export type RelativeTimeProps<As extends React.ElementType = "time"> = PolymorphicProps<As, "time", RelativeTimeDateOptions & {
+    date?: Date;
+    datetime?: string;
+    format?: RelativeTimeFormat;
+    tense?: RelativeTimeTense;
+    precision?: RelativeTimePrecision;
+    threshold?: string;
+    prefix?: string;
+    noTitle?: boolean;
+    className?: string;
+}>;

package/build/components/relative-time/index.d.ts

@@ -0,0 +1,3 @@
+export { default as RelativeTime } from "./RelativeTime";
+export { formatRelativeTime, formatTitle, DEFAULT_RELATIVE_TIME_PREFIX, DEFAULT_RELATIVE_TIME_THRESHOLD, } from "./relativeTimeFormat";
+export * from "./RelativeTime.types";

package/build/components/relative-time/relativeTimeFormat.d.ts

@@ -0,0 +1,19 @@
+import type { FormattedRelativeTime, RelativeTimeDateOptions, RelativeTimePrecision, RelativeTimeSettings, RelativeTimeUnit } from "./RelativeTime.types";
+export declare const DEFAULT_RELATIVE_TIME_THRESHOLD = "P30D";
+export declare const DEFAULT_RELATIVE_TIME_PREFIX = "on";
+export declare const parseDuration: (duration: string) => number | null;
+export declare const roundToSingleUnit: (elapsed: number) => {
+    value: number;
+    unit: RelativeTimeUnit;
+    length: number;
+};
+export declare const getElapsedUnits: (elapsed: number, precision: RelativeTimePrecision) => {
+    unit: RelativeTimePrecision;
+    count: number;
+}[];
+export declare const formatMicro: (elapsed: number) => string;
+export declare const formatElapsed: (elapsed: number, precision: RelativeTimePrecision) => string;
+export declare const formatRelative: (elapsed: number, locale?: string) => string;
+export declare const formatDate: (date: Date, now: number, options: RelativeTimeDateOptions, locale?: string) => string;
+export declare const formatTitle: (date: Date, locale?: string) => string;
+export declare const formatRelativeTime: (date: Date, now: number, settings: RelativeTimeSettings) => FormattedRelativeTime;

package/build/components/scrollable-region/ScrollableRegion.d.ts

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

package/build/components/scrollable-region/ScrollableRegion.types.d.ts

@@ -0,0 +1,13 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+type Labelled = {
+    "aria-label": string;
+    "aria-labelledby"?: never;
+} | {
+    "aria-label"?: never;
+    "aria-labelledby": string;
+};
+export type ScrollableRegionProps<As extends React.ElementType = "div"> = PolymorphicProps<As, "div", Labelled & {
+    className?: string;
+}>;
+export {};

package/build/components/scrollable-region/index.d.ts

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

package/build/components/segmented-control/SegmentedControl.d.ts

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

package/build/components/segmented-control/SegmentedControl.types.d.ts

@@ -0,0 +1,46 @@
+import type * as React from "react";
+import type { ResponsiveValue } from "../../hooks/useResponsive";
+import type { ButtonVisual } from "../button";
+import type { TooltipDirection, TooltipType } from "../tooltip";
+export type SegmentedControlSize = "small" | "medium";
+export type SegmentedControlVariant = "default" | "hideLabels" | "dropdown";
+type SegmentedControlAccessibleName = {
+    "aria-label": string;
+    "aria-labelledby"?: undefined;
+} | {
+    "aria-label"?: undefined;
+    "aria-labelledby": string;
+};
+type SegmentedControlOwnProps = {
+    fullWidth?: boolean | ResponsiveValue<boolean>;
+    onChange?: (selectedIndex: number) => void;
+    size?: SegmentedControlSize;
+    variant?: "default" | ResponsiveValue<SegmentedControlVariant>;
+    className?: string;
+};
+export type SegmentedControlProps = Omit<React.ComponentPropsWithoutRef<"ul">, "onChange" | "aria-label" | "aria-labelledby"> & SegmentedControlOwnProps & SegmentedControlAccessibleName;
+export type SegmentedControlElementProps = Omit<React.ComponentPropsWithoutRef<"ul">, "onChange"> & SegmentedControlOwnProps;
+type SegmentedControlSegmentOwnProps = {
+    selected?: boolean;
+    defaultSelected?: boolean;
+    disabled?: boolean;
+    className?: string;
+};
+export type SegmentedControlButtonProps = Omit<React.ComponentPropsWithoutRef<"button">, "children"> & SegmentedControlSegmentOwnProps & {
+    children: string;
+    leadingVisual?: ButtonVisual;
+    count?: number | string;
+};
+export type SegmentedControlIconButtonProps = Omit<React.ComponentPropsWithoutRef<"button">, "children" | "aria-label"> & SegmentedControlSegmentOwnProps & {
+    "aria-label": string;
+    icon: NonNullable<ButtonVisual>;
+    description?: string;
+    tooltipDirection?: TooltipDirection;
+};
+export type SegmentedControlSegmentProps = React.ComponentPropsWithoutRef<"button"> & Omit<SegmentedControlSegmentOwnProps, "defaultSelected"> & {
+    component: string;
+    tooltip?: string;
+    tooltipType?: TooltipType;
+    tooltipDirection?: TooltipDirection;
+};
+export {};

package/build/components/segmented-control/SegmentedControlButton.d.ts

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

package/build/components/segmented-control/SegmentedControlIconButton.d.ts

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

package/build/components/segmented-control/SegmentedControlSegment.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import type { ButtonVisual } from "../button";
+import type { SegmentedControlSegmentProps } from "./SegmentedControl.types";
+export declare const renderSegmentVisual: (visual: NonNullable<ButtonVisual>) => React.JSX.Element;
+declare function SegmentedControlSegment(props: SegmentedControlSegmentProps): React.JSX.Element;
+declare namespace SegmentedControlSegment {
+    var displayName: string;
+}
+export default SegmentedControlSegment;

package/build/components/segmented-control/index.d.ts

@@ -0,0 +1,9 @@
+import SegmentedControlBase from "./SegmentedControl";
+import SegmentedControlButton from "./SegmentedControlButton";
+import SegmentedControlIconButton from "./SegmentedControlIconButton";
+export declare const SegmentedControl: typeof SegmentedControlBase & {
+    Button: typeof SegmentedControlButton;
+    IconButton: typeof SegmentedControlIconButton;
+};
+export { SegmentedControlButton, SegmentedControlIconButton };
+export * from "./SegmentedControl.types";

package/build/components/select/Select.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+import type { SelectSize, SelectValidationStatus } from "./Select.types";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.SelectHTMLAttributes<HTMLSelectElement>, HTMLSelectElement>, "ref">, "multiple" | "size"> & {
+    size?: SelectSize;
+    block?: boolean;
+    validationStatus?: SelectValidationStatus;
+    placeholder?: string;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/select/Select.types.d.ts

@@ -0,0 +1,17 @@
+import type * as React from "react";
+export type SelectSize = "small" | "medium" | "large";
+export type SelectValidationStatus = "error" | "success";
+export type SelectProps = Omit<React.ComponentPropsWithoutRef<"select">, "size" | "multiple"> & {
+    size?: SelectSize;
+    block?: boolean;
+    validationStatus?: SelectValidationStatus;
+    placeholder?: string;
+    className?: string;
+};
+export type SelectOptionProps = React.ComponentPropsWithoutRef<"option"> & {
+    value: string;
+    className?: string;
+};
+export type SelectOptGroupProps = React.ComponentPropsWithoutRef<"optgroup"> & {
+    className?: string;
+};

package/build/components/select/SelectOptGroup.d.ts

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

package/build/components/select/SelectOption.d.ts

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

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

@@ -0,0 +1,19 @@
+import SelectOptGroup from "./SelectOptGroup";
+import SelectOption from "./SelectOption";
+export declare const Select: ((props: Omit<Omit<import("react").DetailedHTMLProps<import("react").SelectHTMLAttributes<HTMLSelectElement>, HTMLSelectElement>, "ref">, "multiple" | "size"> & {
+    size?: import("./Select.types").SelectSize;
+    block?: boolean;
+    validationStatus?: import("./Select.types").SelectValidationStatus;
+    placeholder?: string;
+    className?: string;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Option: (props: Omit<import("react").DetailedHTMLProps<import("react").OptionHTMLAttributes<HTMLOptionElement>, HTMLOptionElement>, "ref"> & {
+        value: string;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    OptGroup: (props: Omit<import("react").DetailedHTMLProps<import("react").OptgroupHTMLAttributes<HTMLOptGroupElement>, HTMLOptGroupElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { SelectOption, SelectOptGroup };
+export * from "./Select.types";

package/build/components/select-panel/SelectPanel.d.ts

@@ -0,0 +1,21 @@
+import * as React from "react";
+import type { SelectPanelMaxHeight, SelectPanelResponsiveVariant, SelectPanelVariant, SelectPanelWidth } from "./SelectPanel.types";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "title" | "onSubmit"> & {
+    title: string;
+    description?: string;
+    variant?: SelectPanelVariant | SelectPanelResponsiveVariant;
+    selectionVariant?: import("./SelectPanel.types").SelectPanelSelectionVariant;
+    id?: string;
+    defaultOpen?: boolean;
+    open?: boolean;
+    anchorRef?: React.RefObject<HTMLButtonElement | null>;
+    side?: import("..").AnchorSide;
+    align?: import("..").AnchorAlignment;
+    onCancel?: () => void;
+    onClearSelection?: () => void;
+    onSubmit?: (event?: React.FormEvent<HTMLFormElement>) => void;
+    width?: SelectPanelWidth;
+    maxHeight?: SelectPanelMaxHeight;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/select-panel/SelectPanel.types.d.ts

@@ -0,0 +1,82 @@
+import type * as React from "react";
+import type { ResponsiveValue } from "../../hooks/useResponsive";
+import type { ButtonProps } from "../button";
+import type { CheckboxProps } from "../checkbox";
+import type { LinkProps } from "../link";
+import type { TextInputProps } from "../text-input";
+import type { AnchorAlignment, AnchorSide } from "../tooltip/anchoredPosition";
+export type SelectPanelVariant = "anchored" | "modal";
+export type SelectPanelNarrowVariant = SelectPanelVariant | "full-screen" | "bottom-sheet";
+export type SelectPanelResponsiveVariant = ResponsiveValue<SelectPanelVariant, SelectPanelNarrowVariant>;
+export type SelectPanelSelectionVariant = "single" | "multiple" | "instant";
+export type SelectPanelWidth = "small" | "medium" | "large" | "xlarge" | "auto";
+export type SelectPanelMaxHeight = "small" | "medium" | "large" | "xlarge" | "fit-content";
+export type SelectPanelMessageVariant = "warning" | "error" | "empty";
+export type SelectPanelMessageSize = "inline" | "full";
+export type SelectPanelProps = Omit<React.ComponentPropsWithoutRef<"div">, "title" | "onSubmit"> & {
+    title: string;
+    description?: string;
+    variant?: SelectPanelVariant | SelectPanelResponsiveVariant;
+    selectionVariant?: SelectPanelSelectionVariant;
+    id?: string;
+    defaultOpen?: boolean;
+    open?: boolean;
+    anchorRef?: React.RefObject<HTMLButtonElement | null>;
+    side?: AnchorSide;
+    align?: AnchorAlignment;
+    onCancel?: () => void;
+    onClearSelection?: () => void;
+    onSubmit?: (event?: React.FormEvent<HTMLFormElement>) => void;
+    width?: SelectPanelWidth;
+    maxHeight?: SelectPanelMaxHeight;
+    className?: string;
+};
+export type SelectPanelButtonProps = ButtonProps;
+export type SelectPanelHeaderProps = React.ComponentPropsWithoutRef<"div"> & {
+    onBack?: () => void;
+    className?: string;
+};
+export type SelectPanelSearchInputProps = Omit<TextInputProps, "onChange"> & {
+    onChange?: (value: string, event: React.ChangeEvent<HTMLInputElement> | null) => void;
+    className?: string;
+};
+export type SelectPanelFooterProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type SelectPanelSecondaryActionProps = ({
+    variant: "button";
+} & Omit<ButtonProps, "variant">) | ({
+    variant: "link";
+} & LinkProps) | ({
+    variant: "checkbox";
+} & CheckboxProps);
+export type SelectPanelLoadingProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type SelectPanelMessageProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+} & ({
+    variant: "empty";
+    size?: "full";
+    title: string;
+} | {
+    variant: "warning" | "error";
+    size: "full";
+    title: string;
+} | {
+    variant: "warning" | "error";
+    size?: "inline";
+    title?: never;
+});
+export type SelectPanelContextValue = {
+    panelId?: string;
+    title?: string;
+    description?: string;
+    selectionVariant?: SelectPanelSelectionVariant;
+    searchQuery?: string;
+    setSearchQuery?: (value: string) => void;
+    searchInputRef?: React.RefObject<HTMLInputElement | null>;
+    onCancel?: () => void;
+    onClearSelection?: () => void;
+    moveFocusToList?: () => void;
+};

package/build/components/select-panel/SelectPanelButton.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/select-panel/SelectPanelContext.d.ts

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

package/build/components/select-panel/SelectPanelFooter.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/select-panel/SelectPanelHeader.d.ts

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

package/build/components/select-panel/SelectPanelLoading.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/select-panel/SelectPanelMessage.d.ts

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

package/build/components/select-panel/SelectPanelSearchInput.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+declare const _default: (props: Omit<import("..").TextInputProps, "onChange"> & {
+    onChange?: (value: string, event: React.ChangeEvent<HTMLInputElement> | null) => void;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/select-panel/SelectPanelSecondaryAction.d.ts

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

package/build/components/select-panel/index.d.ts

@@ -0,0 +1,48 @@
+import SelectPanelButton from "./SelectPanelButton";
+import SelectPanelFooter from "./SelectPanelFooter";
+import SelectPanelHeader from "./SelectPanelHeader";
+import SelectPanelLoading from "./SelectPanelLoading";
+import SelectPanelMessage from "./SelectPanelMessage";
+import SelectPanelSearchInput from "./SelectPanelSearchInput";
+import SelectPanelSecondaryAction from "./SelectPanelSecondaryAction";
+export declare const SelectPanel: ((props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "title" | "onSubmit"> & {
+    title: string;
+    description?: string;
+    variant?: import("./SelectPanel.types").SelectPanelVariant | import("./SelectPanel.types").SelectPanelResponsiveVariant;
+    selectionVariant?: import("./SelectPanel.types").SelectPanelSelectionVariant;
+    id?: string;
+    defaultOpen?: boolean;
+    open?: boolean;
+    anchorRef?: React.RefObject<HTMLButtonElement | null>;
+    side?: import("..").AnchorSide;
+    align?: import("..").AnchorAlignment;
+    onCancel?: () => void;
+    onClearSelection?: () => void;
+    onSubmit?: (event?: React.FormEvent<HTMLFormElement>) => void;
+    width?: import("./SelectPanel.types").SelectPanelWidth;
+    maxHeight?: import("./SelectPanel.types").SelectPanelMaxHeight;
+    className?: string;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    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;
+    Header: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        onBack?: () => void;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    SearchInput: (props: Omit<import("..").TextInputProps, "onChange"> & {
+        onChange?: (value: string, event: React.ChangeEvent<HTMLInputElement> | null) => void;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Footer: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    SecondaryAction: typeof SelectPanelSecondaryAction;
+    Loading: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Message: (props: import("./SelectPanel.types").SelectPanelMessageProps & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { SelectPanelButton, SelectPanelHeader, SelectPanelSearchInput, SelectPanelFooter, SelectPanelSecondaryAction, SelectPanelLoading, SelectPanelMessage, };
+export { SelectPanelContext } from "./SelectPanelContext";
+export * from "./SelectPanel.types";

package/build/components/skeleton-avatar/SkeletonAvatar.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { SkeletonAvatarProps } from "./SkeletonAvatar.types";
+declare function SkeletonAvatar({ size, shape, className, style, ...rest }: SkeletonAvatarProps): React.JSX.Element;
+declare namespace SkeletonAvatar {
+    var displayName: string;
+}
+export default SkeletonAvatar;

package/build/components/skeleton-avatar/SkeletonAvatar.types.d.ts

@@ -0,0 +1,7 @@
+import type * as React from "react";
+import type { AvatarShape, AvatarSize } from "../avatar/Avatar.types";
+export type SkeletonAvatarProps = React.ComponentPropsWithoutRef<"div"> & {
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    className?: string;
+};

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

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

package/build/components/skeleton-box/SkeletonBox.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> & {
+    width?: string;
+    height?: string;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/skeleton-box/SkeletonBox.types.d.ts

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

package/build/components/skeleton-box/index.d.ts

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

package/build/components/skeleton-text/SkeletonText.d.ts

@@ -0,0 +1,6 @@
+import type { SkeletonTextProps } from "./SkeletonText.types";
+declare function SkeletonText({ lines, maxWidth, size, className, style, ...rest }: SkeletonTextProps): import("react").JSX.Element;
+declare namespace SkeletonText {
+    var displayName: string;
+}
+export default SkeletonText;

package/build/components/skeleton-text/SkeletonText.types.d.ts

@@ -0,0 +1,8 @@
+import type * as React from "react";
+export type SkeletonTextSize = "display" | "titleLarge" | "titleMedium" | "titleSmall" | "bodyLarge" | "bodyMedium" | "bodySmall" | "subtitle";
+export type SkeletonTextProps = React.ComponentPropsWithoutRef<"div"> & {
+    size?: SkeletonTextSize;
+    lines?: number;
+    maxWidth?: React.CSSProperties["maxWidth"];
+    className?: string;
+};

package/build/components/skeleton-text/index.d.ts

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

package/build/components/slider/Slider.d.ts

@@ -0,0 +1,15 @@
+import * as React from "react";
+import type { SliderOrientation, SliderSize } from "./Slider.types";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref">, "onChange" | "value" | "defaultValue" | "type" | "step" | "size" | "max" | "min"> & {
+    min?: number;
+    max?: number;
+    step?: number;
+    value?: number;
+    defaultValue?: number;
+    size?: SliderSize;
+    orientation?: SliderOrientation;
+    block?: boolean;
+    onChange?: (value: number, event: React.ChangeEvent<HTMLInputElement>) => void;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/slider/Slider.types.d.ts

@@ -0,0 +1,15 @@
+import type * as React from "react";
+export type SliderSize = "small" | "medium" | "large";
+export type SliderOrientation = "horizontal" | "vertical";
+export type SliderProps = Omit<React.ComponentPropsWithoutRef<"input">, "type" | "size" | "value" | "defaultValue" | "onChange" | "min" | "max" | "step"> & {
+    min?: number;
+    max?: number;
+    step?: number;
+    value?: number;
+    defaultValue?: number;
+    size?: SliderSize;
+    orientation?: SliderOrientation;
+    block?: boolean;
+    onChange?: (value: number, event: React.ChangeEvent<HTMLInputElement>) => void;
+    className?: string;
+};

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

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

package/build/components/spinner/Spinner.d.ts

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