@gamecrafters/base-ui 0.0.7 → 0.0.8

package/build/components/chart/Chart.d.ts

@@ -1,21 +1,7 @@
 import * as React from "react";
-declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref">, "title"> & {
-    type?: import("./Chart.types").ChartType;
-    data: import("./Chart.types").ChartDatum[];
-    xKey: string;
-    series: import("./Chart.types").ChartSeries[];
-    title?: React.ReactNode;
-    description?: React.ReactNode;
-    stacked?: boolean;
-    horizontal?: boolean;
-    height?: number;
-    valueFormat?: (value: number) => string;
-    labelFormat?: (label: string) => string;
-    tickCount?: number;
-    showGrid?: boolean;
-    showLegend?: boolean;
-    smooth?: boolean;
-    emptyText?: string;
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "children"> & {
+    chart: import("./Chart.types").ChartInstance;
+    children: React.ReactElement;
     className?: string;
 } & React.RefAttributes<any>) => React.ReactNode;
 export default _default;

package/build/components/chart/Chart.types.d.ts

@@ -1,59 +1,115 @@
 import type * as React from "react";
-export type ChartType = "line" | "area" | "bar";
-export type ChartDatum = Record<string, string | number | null | undefined>;
-export type ChartSeries = {
-    key: string;
+import type { LegendPayload, TooltipContentProps } from "recharts";
+import type { ViewBox } from "recharts/types/util/types";
+import type { ChartColorName } from "./chartPalette";
+export type ChartColor = ChartColorName | (string & {});
+export type ChartSeries<T> = {
+    name?: keyof T;
+    color?: ChartColor;
+    icon?: React.ReactNode;
+    label?: React.ReactNode;
+    stackId?: string;
+    yAxisId?: string;
+    strokeDasharray?: string;
+    id?: string;
+};
+export type ChartResolvedSeries<T> = ChartSeries<T> & {
+    color: ChartColor;
+};
+export type ChartSeriesConfig = {
     name?: string;
-    color?: string;
-};
-export type ChartResolvedSeries = ChartSeries & {
-    name: string;
-    color: string;
-};
-export type ChartReading = {
-    index: number;
-    label: string;
-    values: {
-        series: ChartResolvedSeries;
-        value: number | null;
-    }[];
-};
-export type ChartLayout = {
-    width: number;
-    height: number;
-    left: number;
-    right: number;
-    top: number;
-    bottom: number;
-    innerWidth: number;
-    innerHeight: number;
-};
-export type ChartProps = Omit<React.ComponentPropsWithoutRef<"figure">, "title"> & {
-    type?: ChartType;
-    data: ChartDatum[];
-    xKey: string;
-    series: ChartSeries[];
-    title?: React.ReactNode;
-    description?: React.ReactNode;
-    stacked?: boolean;
-    horizontal?: boolean;
-    height?: number;
-    valueFormat?: (value: number) => string;
-    labelFormat?: (label: string) => string;
-    tickCount?: number;
-    showGrid?: boolean;
-    showLegend?: boolean;
-    smooth?: boolean;
-    emptyText?: string;
+    color?: ChartColor;
+    icon?: React.ReactNode;
+    label?: React.ReactNode;
+};
+export type ChartValueDomain = [
+    number,
+    number
+] | ((props: {
+    min: number;
+    max: number;
+}) => [number, number]);
+export type ChartSort<T> = {
+    by: keyof T;
+    direction: "asc" | "desc";
+};
+export type UseChartProps<T> = {
+    data: T[];
+    series?: ChartSeries<T>[];
+    sort?: ChartSort<T>;
+    locale?: string;
+};
+export type ChartInstance = {
+    id: string;
+    getSeries: (item: unknown) => ChartSeriesConfig | undefined;
+    color: (value?: ChartColor) => string | undefined;
+    formatNumber: (options?: Intl.NumberFormatOptions) => (value: number) => string;
+    formatDate: (options?: Intl.DateTimeFormatOptions) => (value: string | number | Date) => string;
+    highlightedSeries: string | null;
+    setHighlightedSeries: React.Dispatch<React.SetStateAction<string | null>>;
+    isHighlightedSeries: (name?: string) => boolean;
+    getSeriesOpacity: (name?: string, fallback?: number) => number | undefined;
+    getPayloadTotal: (payload?: readonly {
+        value?: unknown;
+    }[]) => number | undefined;
+};
+export type UseChartReturn<T> = ChartInstance & {
+    key: <K extends keyof T>(prop?: K) => K;
+    data: T[];
+    series: ChartResolvedSeries<T>[];
+    groupBy: (key: keyof T) => T[][];
+    getTotal: (key: keyof T) => number;
+    getMin: (key: keyof T) => number;
+    getMax: (key: keyof T) => number;
+    getValuePercent: (key: keyof T, value: number, domain?: ChartValueDomain) => number;
+};
+export type ChartProps = Omit<React.ComponentPropsWithoutRef<"div">, "children"> & {
+    chart: ChartInstance;
+    children: React.ReactElement;
     className?: string;
 };
-export type ChartLegendProps = Omit<React.ComponentPropsWithoutRef<"ul">, "children"> & {
-    series: ChartResolvedSeries[];
+export type ChartLegendAlign = "left" | "center" | "right";
+export type ChartLegendVerticalAlign = "top" | "middle" | "bottom";
+export type ChartLegendLayout = "horizontal" | "vertical" | "auto";
+export type ChartLegendInteraction = "hover" | "click";
+export type ChartLegendProps = {
+    payload?: LegendPayload[];
+    align?: ChartLegendAlign;
+    verticalAlign?: ChartLegendVerticalAlign;
+    layout?: ChartLegendLayout;
+    title?: React.ReactNode;
+    nameKey?: string;
+    interaction?: ChartLegendInteraction;
     className?: string;
 };
-export type ChartTooltipProps = Omit<React.ComponentPropsWithoutRef<"div">, "children"> & {
-    reading: ChartReading;
-    valueFormat: (value: number) => string;
-    labelFormat: (label: string) => string;
+export type ChartTooltipIndicator = "dot" | "line" | "dashed";
+export type ChartTooltipFormatter = (value: unknown, name: React.ReactNode) => React.ReactNode | [React.ReactNode, React.ReactNode];
+export type ChartTooltipProps = Partial<TooltipContentProps<string | number, string>> & {
+    hideLabel?: boolean;
+    hideIndicator?: boolean;
+    hideSeriesLabel?: boolean;
+    showTotal?: boolean;
+    fitContent?: boolean;
+    nameKey?: string;
+    indicator?: ChartTooltipIndicator;
+    formatter?: ChartTooltipFormatter;
+    render?: (payload: unknown) => React.ReactNode;
     className?: string;
 };
+export type ChartGradientStop = {
+    color: ChartColor;
+    offset: string | number;
+    opacity?: number;
+};
+export type ChartGradientProps = {
+    id: string;
+    fillOpacity?: number;
+    stops: ChartGradientStop[];
+};
+export type ChartRadialTextProps = {
+    viewBox?: ViewBox;
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    gap?: number;
+    fontSize?: string;
+};

package/build/components/chart/ChartContext.d.ts

@@ -0,0 +1,3 @@
+import type { ChartInstance } from "./Chart.types";
+export declare const ChartContext: import("react").Context<ChartInstance | null>;
+export declare const useChartContext: () => ChartInstance;

package/build/components/chart/ChartGradient.d.ts

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

package/build/components/chart/ChartLegend.d.ts

@@ -1,6 +1,7 @@
 import * as React from "react";
-declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref">, "children"> & {
-    series: import("./Chart.types").ChartResolvedSeries[];
-    className?: string;
-} & React.RefAttributes<any>) => React.ReactNode;
-export default _default;
+import type { ChartLegendProps } from "./Chart.types";
+declare function ChartLegend(props: ChartLegendProps): React.JSX.Element | null;
+declare namespace ChartLegend {
+    var displayName: string;
+}
+export default ChartLegend;

package/build/components/chart/ChartRadialText.d.ts

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

package/build/components/chart/ChartTooltip.d.ts

@@ -1,8 +1,7 @@
 import * as React from "react";
-declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "children"> & {
-    reading: import("./Chart.types").ChartReading;
-    valueFormat: (value: number) => string;
-    labelFormat: (label: string) => string;
-    className?: string;
-} & React.RefAttributes<any>) => React.ReactNode;
-export default _default;
+import type { ChartTooltipProps } from "./Chart.types";
+declare function ChartTooltip(props: ChartTooltipProps): React.JSX.Element | null;
+declare namespace ChartTooltip {
+    var displayName: string;
+}
+export default ChartTooltip;

package/build/components/chart/chartPalette.d.ts

@@ -1,3 +1,16 @@
 export declare const CHART_SERIES_COLORS: string[];
 export declare const CHART_OVERFLOW_COLOR = "var(--foreground-color-muted)";
+export declare const CHART_COLORS: {
+    blue: string;
+    orange: string;
+    purple: string;
+    green: string;
+    pink: string;
+    grid: string;
+    axis: string;
+    surface: string;
+    foreground: string;
+    muted: string;
+};
+export type ChartColorName = keyof typeof CHART_COLORS;
 export declare const getSeriesColor: (index: number, color?: string) => string;

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

@@ -1,36 +1,20 @@
+import ChartGradient from "./ChartGradient";
 import ChartLegend from "./ChartLegend";
+import ChartRadialText from "./ChartRadialText";
 import ChartTooltip from "./ChartTooltip";
-export declare const Chart: ((props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLElement>, HTMLElement>, "ref">, "title"> & {
-    type?: import("./Chart.types").ChartType;
-    data: import("./Chart.types").ChartDatum[];
-    xKey: string;
-    series: import("./Chart.types").ChartSeries[];
-    title?: React.ReactNode;
-    description?: React.ReactNode;
-    stacked?: boolean;
-    horizontal?: boolean;
-    height?: number;
-    valueFormat?: (value: number) => string;
-    labelFormat?: (label: string) => string;
-    tickCount?: number;
-    showGrid?: boolean;
-    showLegend?: boolean;
-    smooth?: boolean;
-    emptyText?: string;
+export declare const Chart: ((props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "children"> & {
+    chart: import("./Chart.types").ChartInstance;
+    children: React.ReactElement;
     className?: string;
 } & import("react").RefAttributes<any>) => React.ReactNode) & {
-    Legend: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref">, "children"> & {
-        series: import("./Chart.types").ChartResolvedSeries[];
-        className?: string;
-    } & import("react").RefAttributes<any>) => React.ReactNode;
-    Tooltip: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "children"> & {
-        reading: import("./Chart.types").ChartReading;
-        valueFormat: (value: number) => string;
-        labelFormat: (label: string) => string;
-        className?: string;
-    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Gradient: typeof ChartGradient;
+    Legend: typeof ChartLegend;
+    RadialText: typeof ChartRadialText;
+    Tooltip: typeof ChartTooltip;
 };
-export { ChartLegend, ChartTooltip };
-export { CHART_SERIES_COLORS, CHART_OVERFLOW_COLOR, getSeriesColor } from "./chartPalette";
-export { BAR_RADIUS, MARK_GAP, MAX_BAR_THICKNESS } from "./chartScales";
+export { ChartGradient, ChartLegend, ChartRadialText, ChartTooltip };
+export { ChartContext, useChartContext } from "./ChartContext";
+export { getProp, useChart } from "./useChart";
+export { CHART_COLORS, CHART_OVERFLOW_COLOR, CHART_SERIES_COLORS, getSeriesColor, } from "./chartPalette";
+export type { ChartColorName } from "./chartPalette";
 export * from "./Chart.types";

package/build/components/chart/useChart.d.ts

@@ -0,0 +1,3 @@
+import type { UseChartProps, UseChartReturn } from "./Chart.types";
+export declare const getProp: <T = unknown>(item: unknown, key?: string) => T | undefined;
+export declare const useChart: <T>(props: UseChartProps<T>) => UseChartReturn<T>;

package/build/components/checkbox-card/CheckboxCard.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+import type { CheckboxCardValidationStatus } from "./CheckboxCard.types";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref">, "onChange"> & {
+    value: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    indeterminate?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    validationStatus?: CheckboxCardValidationStatus;
+    onChange?: React.ChangeEventHandler<HTMLInputElement>;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/checkbox-card/CheckboxCard.types.d.ts

@@ -0,0 +1,26 @@
+import type * as React from "react";
+export type CheckboxCardValidationStatus = "error" | "success";
+export type CheckboxCardProps = Omit<React.ComponentPropsWithoutRef<"label">, "onChange"> & {
+    value: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    indeterminate?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    validationStatus?: CheckboxCardValidationStatus;
+    onChange?: React.ChangeEventHandler<HTMLInputElement>;
+    className?: string;
+};
+export type CheckboxCardLabelProps = React.ComponentPropsWithoutRef<"span"> & {
+    className?: string;
+};
+export type CheckboxCardDescriptionProps = React.ComponentPropsWithoutRef<"span"> & {
+    className?: string;
+};
+export type CheckboxCardLeadingVisualProps = React.ComponentPropsWithoutRef<"span"> & {
+    className?: string;
+};
+export type CheckboxCardContextValue = {
+    labelId?: string;
+    descriptionId?: string;
+};

package/build/components/checkbox-card/CheckboxCardContext.d.ts

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

package/build/components/checkbox-card/CheckboxCardLeadingVisual.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/checkbox-card/index.d.ts

@@ -0,0 +1,27 @@
+import CheckboxCardDescription from "./CheckboxCardDescription";
+import CheckboxCardLabel from "./CheckboxCardLabel";
+import CheckboxCardLeadingVisual from "./CheckboxCardLeadingVisual";
+export declare const CheckboxCard: ((props: Omit<Omit<import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref">, "onChange"> & {
+    value: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    indeterminate?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    validationStatus?: import("./CheckboxCard.types").CheckboxCardValidationStatus;
+    onChange?: React.ChangeEventHandler<HTMLInputElement>;
+    className?: string;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    LeadingVisual: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Label: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Description: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { CheckboxCardLeadingVisual, CheckboxCardLabel, CheckboxCardDescription };
+export { CheckboxCardContext } from "./CheckboxCardContext";
+export * from "./CheckboxCard.types";

package/build/components/{upload/Upload.d.ts → file-upload/FileUpload.d.ts}

@@ -1,16 +1,16 @@
 import * as React from "react";
-import type { UploadSize, UploadSource, UploadValidationStatus } from "./Upload.types";
+import type { FileUploadSize, FileUploadSource, FileUploadValidationStatus } from "./FileUpload.types";
 declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onSelect"> & {
-    size?: UploadSize;
+    size?: FileUploadSize;
     accept?: string;
     multiple?: boolean;
     disabled?: boolean;
     required?: boolean;
     name?: string;
     maxSize?: number;
-    validationStatus?: UploadValidationStatus;
-    onSelect?: (files: File[], source: UploadSource) => void;
-    onReject?: (rejections: import("./Upload.types").UploadRejection[], source: UploadSource) => void;
+    validationStatus?: FileUploadValidationStatus;
+    onSelect?: (files: File[], source: FileUploadSource) => void;
+    onReject?: (rejections: import("./FileUpload.types").FileUploadRejection[], source: FileUploadSource) => void;
     className?: string;
 } & React.RefAttributes<any>) => React.ReactNode;
 export default _default;

package/build/components/file-upload/FileUpload.types.d.ts

@@ -0,0 +1,51 @@
+import type * as React from "react";
+export type FileUploadSize = "small" | "medium" | "large";
+export type FileUploadValidationStatus = "error" | "success";
+export type FileUploadSource = "input" | "drop";
+export type FileUploadRejectionReason = "type" | "size" | "count";
+export type FileUploadRejection = {
+    file: File;
+    reason: FileUploadRejectionReason;
+};
+export type FileUploadItemStatus = "pending" | "uploading" | "success" | "error";
+export type FileUploadProps = Omit<React.ComponentPropsWithoutRef<"div">, "onSelect"> & {
+    size?: FileUploadSize;
+    accept?: string;
+    multiple?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    maxSize?: number;
+    validationStatus?: FileUploadValidationStatus;
+    onSelect?: (files: File[], source: FileUploadSource) => void;
+    onReject?: (rejections: FileUploadRejection[], source: FileUploadSource) => void;
+    className?: string;
+};
+export type FileUploadIconProps = React.ComponentPropsWithoutRef<"span"> & {
+    icon?: React.ElementType;
+    className?: string;
+};
+export type FileUploadLabelProps = React.ComponentPropsWithoutRef<"span"> & {
+    className?: string;
+};
+export type FileUploadDescriptionProps = React.ComponentPropsWithoutRef<"span"> & {
+    className?: string;
+};
+export type FileUploadListProps = React.ComponentPropsWithoutRef<"ul"> & {
+    className?: string;
+};
+export type FileUploadItemProps = React.ComponentPropsWithoutRef<"li"> & {
+    name: string;
+    fileSize?: number;
+    status?: FileUploadItemStatus;
+    progress?: number;
+    description?: React.ReactNode;
+    icon?: React.ElementType;
+    onRemove?: (event: React.MouseEvent<HTMLButtonElement>) => void;
+    removeLabel?: string;
+    className?: string;
+};
+export type FileUploadContextValue = {
+    labelId?: string;
+    descriptionId?: string;
+};

package/build/components/file-upload/FileUploadContext.d.ts

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

package/build/components/file-upload/FileUploadDescription.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/{upload/UploadItem.d.ts → file-upload/FileUploadItem.d.ts}

@@ -2,7 +2,7 @@ import * as React from "react";
 declare const _default: (props: Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & {
     name: string;
     fileSize?: number;
-    status?: import("./Upload.types").UploadItemStatus;
+    status?: import("./FileUpload.types").FileUploadItemStatus;
     progress?: number;
     description?: React.ReactNode;
     icon?: React.ElementType;

package/build/components/file-upload/FileUploadLabel.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/{upload → file-upload}/files.d.ts

@@ -1,9 +1,9 @@
-import type { UploadRejection } from "./Upload.types";
+import type { FileUploadRejection } from "./FileUpload.types";
 export declare const formatFileSize: (bytes: number) => string;
 export declare const isFileAccepted: (file: File, accept?: string) => boolean;
 export type FileTriage = {
     accepted: File[];
-    rejected: UploadRejection[];
+    rejected: FileUploadRejection[];
 };
 export type FileTriageOptions = {
     accept?: string;

package/build/components/{upload → file-upload}/index.d.ts

@@ -1,19 +1,19 @@
-import UploadDescription from "./UploadDescription";
-import UploadIcon from "./UploadIcon";
-import UploadItem from "./UploadItem";
-import UploadLabel from "./UploadLabel";
-import UploadList from "./UploadList";
-export declare const Upload: ((props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onSelect"> & {
-    size?: import("./Upload.types").UploadSize;
+import FileUploadDescription from "./FileUploadDescription";
+import FileUploadIcon from "./FileUploadIcon";
+import FileUploadItem from "./FileUploadItem";
+import FileUploadLabel from "./FileUploadLabel";
+import FileUploadList from "./FileUploadList";
+export declare const FileUpload: ((props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onSelect"> & {
+    size?: import("./FileUpload.types").FileUploadSize;
     accept?: string;
     multiple?: boolean;
     disabled?: boolean;
     required?: boolean;
     name?: string;
     maxSize?: number;
-    validationStatus?: import("./Upload.types").UploadValidationStatus;
-    onSelect?: (files: File[], source: import("./Upload.types").UploadSource) => void;
-    onReject?: (rejections: import("./Upload.types").UploadRejection[], source: import("./Upload.types").UploadSource) => void;
+    validationStatus?: import("./FileUpload.types").FileUploadValidationStatus;
+    onSelect?: (files: File[], source: import("./FileUpload.types").FileUploadSource) => void;
+    onReject?: (rejections: import("./FileUpload.types").FileUploadRejection[], source: import("./FileUpload.types").FileUploadSource) => void;
     className?: string;
 } & import("react").RefAttributes<any>) => React.ReactNode) & {
     Icon: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
@@ -32,7 +32,7 @@ export declare const Upload: ((props: Omit<Omit<import("react").DetailedHTMLProp
     Item: (props: Omit<import("react").DetailedHTMLProps<import("react").LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & {
         name: string;
         fileSize?: number;
-        status?: import("./Upload.types").UploadItemStatus;
+        status?: import("./FileUpload.types").FileUploadItemStatus;
         progress?: number;
         description?: React.ReactNode;
         icon?: React.ElementType;
@@ -41,8 +41,8 @@ export declare const Upload: ((props: Omit<Omit<import("react").DetailedHTMLProp
         className?: string;
     } & import("react").RefAttributes<any>) => React.ReactNode;
 };
-export { UploadIcon, UploadLabel, UploadDescription, UploadList, UploadItem };
-export { UploadContext } from "./UploadContext";
+export { FileUploadIcon, FileUploadLabel, FileUploadDescription, FileUploadList, FileUploadItem };
+export { FileUploadContext } from "./FileUploadContext";
 export { formatFileSize, isFileAccepted, triageFiles } from "./files";
 export type { FileTriage, FileTriageOptions } from "./files";
-export * from "./Upload.types";
+export * from "./FileUpload.types";

package/build/components/hover-card/HoverCard.d.ts

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

package/build/components/hover-card/HoverCard.types.d.ts

@@ -0,0 +1,33 @@
+import type * as React from "react";
+import type { AnchorAlignment, AnchorSide } from "../tooltip/anchoredPosition";
+export type HoverCardProps = {
+    side?: AnchorSide;
+    align?: AnchorAlignment;
+    anchorOffset?: number;
+    alignmentOffset?: number;
+    openDelay?: number;
+    closeDelay?: number;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    disabled?: boolean;
+    portalContainerName?: string;
+    children?: React.ReactNode;
+    className?: string;
+};
+export type HoverCardTriggerProps = {
+    children?: React.ReactNode;
+};
+export type HoverCardContentProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type HoverCardTriggerHandlers = {
+    ref: React.Ref<HTMLElement>;
+    "aria-describedby"?: string;
+    onPointerEnter: React.PointerEventHandler;
+    onPointerLeave: React.PointerEventHandler;
+    onFocus: React.FocusEventHandler;
+    onBlur: React.FocusEventHandler;
+};
+export type HoverCardContextValue = {
+    triggerHandlers?: HoverCardTriggerHandlers;
+};

package/build/components/hover-card/HoverCardContent.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/hover-card/HoverCardContext.d.ts

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