@gamecrafters/base-ui 0.0.1

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

@@ -0,0 +1,6 @@
+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;

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

@@ -0,0 +1,8 @@
+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;

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

@@ -0,0 +1,3 @@
+export declare const CHART_SERIES_COLORS: string[];
+export declare const CHART_OVERFLOW_COLOR = "var(--foreground-color-muted)";
+export declare const getSeriesColor: (index: number, color?: string) => string;

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

@@ -0,0 +1,36 @@
+import type { ChartDatum, ChartResolvedSeries, ChartType } from "./Chart.types";
+export declare const MAX_BAR_THICKNESS = 24;
+export declare const BAR_RADIUS = 4;
+export declare const MARK_GAP = 2;
+export declare const CHART_PADDING: {
+    top: number;
+    right: number;
+};
+export declare const readValue: (datum: ChartDatum, key: string) => number | null;
+export declare const readLabel: (datum: ChartDatum, key: string) => string;
+export declare const getStackBounds: (data: ChartDatum[], series: ChartResolvedSeries[], stacked: boolean) => ({
+    value: null;
+    start: number;
+    end: number;
+} | {
+    value: number;
+    start: number;
+    end: number;
+})[][];
+export declare const getValueDomain: (bounds: ReturnType<typeof getStackBounds>, type: ChartType) => [number, number];
+export declare const getValueScale: (domain: [number, number], range: [number, number]) => import("d3-scale").ScaleLinear<number, number, never>;
+export declare const getPointScale: (labels: string[], width: number) => import("d3-scale").ScalePoint<string>;
+export declare const getBandScale: (labels: string[], width: number) => import("d3-scale").ScaleBand<string>;
+export declare const getBarBand: (bandwidth: number, count: number, index: number, grouped: boolean) => {
+    offset: number;
+    thickness: number;
+};
+export declare const getBarPath: (x: number, y: number, width: number, height: number, end: "top" | "bottom" | "left" | "right") => string;
+type PointReading = {
+    x: number;
+    value: number | null;
+    start: number;
+};
+export declare const getLinePath: (readings: PointReading[], valueScale: (value: number) => number, smooth: boolean) => string;
+export declare const getAreaPath: (readings: PointReading[], valueScale: (value: number) => number, smooth: boolean) => string;
+export {};

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

@@ -0,0 +1,36 @@
+import ChartLegend from "./ChartLegend";
+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;
+    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;
+};
+export { ChartLegend, ChartTooltip };
+export { CHART_SERIES_COLORS, CHART_OVERFLOW_COLOR, getSeriesColor } from "./chartPalette";
+export { BAR_RADIUS, MARK_GAP, MAX_BAR_THICKNESS } from "./chartScales";
+export * from "./Chart.types";

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

@@ -0,0 +1,2 @@
+import * as React from "react";
+export declare const useChartWidth: (ref: React.RefObject<HTMLElement | null>, fallback: number) => number;

package/build/components/checkbox/Checkbox.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref">, "value" | "type"> & {
+    indeterminate?: boolean;
+    validationStatus?: import("./Checkbox.types").CheckboxValidationStatus;
+    value?: string;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/checkbox/Checkbox.types.d.ts

@@ -0,0 +1,8 @@
+import type * as React from "react";
+export type CheckboxValidationStatus = "error" | "success";
+export type CheckboxProps = Omit<React.ComponentPropsWithoutRef<"input">, "type" | "value"> & {
+    indeterminate?: boolean;
+    validationStatus?: CheckboxValidationStatus;
+    value?: string;
+    className?: string;
+};

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

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

package/build/components/checkbox-group/CheckboxGroup.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+declare const _default: <As extends React.ElementType = "fieldset">(props: Omit<import("../../utilities/polymorphic").PolymorphicProps<As, "fieldset", {
+    disabled?: boolean;
+    required?: boolean;
+    className?: string;
+}>, "onChange"> & {
+    onChange?: (selected: string[], event?: React.ChangeEvent<HTMLInputElement>) => void;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/checkbox-group/CheckboxGroup.types.d.ts

@@ -0,0 +1,28 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type CheckboxGroupValidationStatus = "error" | "success";
+export type CheckboxGroupProps<As extends React.ElementType = "fieldset"> = Omit<PolymorphicProps<As, "fieldset", {
+    disabled?: boolean;
+    required?: boolean;
+    className?: string;
+}>, "onChange"> & {
+    onChange?: (selected: string[], event?: React.ChangeEvent<HTMLInputElement>) => void;
+};
+export type CheckboxGroupLabelProps = React.ComponentPropsWithoutRef<"span"> & {
+    visuallyHidden?: boolean;
+    className?: string;
+};
+export type CheckboxGroupCaptionProps = React.ComponentPropsWithoutRef<"span"> & {
+    className?: string;
+};
+export type CheckboxGroupValidationProps = React.ComponentPropsWithoutRef<"span"> & {
+    variant: CheckboxGroupValidationStatus;
+    className?: string;
+};
+export type CheckboxGroupContextValue = {
+    disabled?: boolean;
+    required?: boolean;
+    captionId?: string;
+    validationMessageId?: string;
+    onChange?: React.ChangeEventHandler<HTMLInputElement>;
+};

package/build/components/checkbox-group/CheckboxGroupCaption.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-group/CheckboxGroupContext.d.ts

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

package/build/components/checkbox-group/CheckboxGroupLabel.d.ts

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

package/build/components/checkbox-group/CheckboxGroupValidation.d.ts

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

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

@@ -0,0 +1,25 @@
+import CheckboxGroupCaption from "./CheckboxGroupCaption";
+import CheckboxGroupLabel from "./CheckboxGroupLabel";
+import CheckboxGroupValidation from "./CheckboxGroupValidation";
+export declare const CheckboxGroup: (<As extends React.ElementType = "fieldset">(props: Omit<import("../../utilities/polymorphic").PolymorphicProps<As, "fieldset", {
+    disabled?: boolean;
+    required?: boolean;
+    className?: string;
+}>, "onChange"> & {
+    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("./CheckboxGroup.types").CheckboxGroupValidationStatus;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { CheckboxGroupLabel, CheckboxGroupCaption, CheckboxGroupValidation };
+export { CheckboxGroupContext } from "./CheckboxGroupContext";
+export * from "./CheckboxGroup.types";

package/build/components/collapsible/Collapsible.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+declare const _default: <As extends React.ElementType = "div">(props: Omit<import("../../utilities/polymorphic").PolymorphicProps<As, "div", {
+    open?: boolean;
+    defaultOpen?: boolean;
+    disabled?: boolean;
+    className?: string;
+}>, "onChange"> & {
+    onChange?: (open: boolean) => void;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/collapsible/Collapsible.types.d.ts

@@ -0,0 +1,25 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type CollapsibleIndicatorPosition = "start" | "end" | "none";
+export type CollapsibleProps<As extends React.ElementType = "div"> = Omit<PolymorphicProps<As, "div", {
+    open?: boolean;
+    defaultOpen?: boolean;
+    disabled?: boolean;
+    className?: string;
+}>, "onChange"> & {
+    onChange?: (open: boolean) => void;
+};
+export type CollapsibleTriggerProps = React.ComponentPropsWithoutRef<"button"> & {
+    indicator?: CollapsibleIndicatorPosition;
+    className?: string;
+};
+export type CollapsibleContentProps<As extends React.ElementType = "div"> = PolymorphicProps<As, "div", {
+    className?: string;
+}>;
+export type CollapsibleContextValue = {
+    triggerId?: string;
+    contentId?: string;
+    isOpen?: boolean;
+    disabled?: boolean;
+    toggle?: () => void;
+};

package/build/components/collapsible/CollapsibleContent.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/collapsible/CollapsibleContext.d.ts

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

package/build/components/collapsible/CollapsibleTrigger.d.ts

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

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

@@ -0,0 +1,23 @@
+import CollapsibleContent from "./CollapsibleContent";
+import CollapsibleTrigger from "./CollapsibleTrigger";
+export declare const Collapsible: (<As extends React.ElementType = "div">(props: Omit<import("../../utilities/polymorphic").PolymorphicProps<As, "div", {
+    open?: boolean;
+    defaultOpen?: boolean;
+    disabled?: boolean;
+    className?: string;
+}>, "onChange"> & {
+    onChange?: (open: boolean) => void;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Trigger: (props: Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+        indicator?: import("./Collapsible.types").CollapsibleIndicatorPosition;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Content: <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 { CollapsibleTrigger, CollapsibleContent };
+export { CollapsibleContext } from "./CollapsibleContext";
+export * from "./Collapsible.types";

package/build/components/command-palette/CommandPalette.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "defaultValue" | "onSelect"> & {
+    search?: string;
+    defaultSearch?: string;
+    onSearchChange?: (search: string) => void;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    onSelect?: (value: string) => void;
+    filter?: import("./CommandPalette.types").CommandPaletteFilter;
+    shouldFilter?: boolean;
+    loop?: boolean;
+    label?: string;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/command-palette/CommandPalette.types.d.ts

@@ -0,0 +1,81 @@
+import type * as React from "react";
+import type { TextInputProps } from "../text-input";
+export type CommandPaletteFilter = (value: string, search: string, keywords: string[]) => number;
+export type CommandPaletteEntry = {
+    value: string;
+    id: string;
+    keywords: string[];
+    groupId?: string;
+    disabled: boolean;
+    forceMount: boolean;
+};
+export type CommandPaletteContextValue = {
+    search: string;
+    setSearch: (search: string) => void;
+    value: string;
+    activeId?: string;
+    setValue: (value: string) => void;
+    order: string[];
+    entries: CommandPaletteEntry[];
+    scores: Record<string, number>;
+    register: (entry: CommandPaletteEntry) => void;
+    unregister: (value: string) => void;
+    onSelect: (value: string) => void;
+    listId: string;
+    labelId: string;
+    shouldFilter: boolean;
+};
+export type CommandPaletteGroupContextValue = {
+    groupId: string;
+};
+export type CommandPaletteProps = Omit<React.ComponentPropsWithoutRef<"div">, "onSelect" | "defaultValue"> & {
+    search?: string;
+    defaultSearch?: string;
+    onSearchChange?: (search: string) => void;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    onSelect?: (value: string) => void;
+    filter?: CommandPaletteFilter;
+    shouldFilter?: boolean;
+    loop?: boolean;
+    label?: string;
+    className?: string;
+};
+export type CommandPaletteInputProps = Omit<TextInputProps, "value" | "onChange" | "type"> & {
+    className?: string;
+};
+export type CommandPaletteListProps = React.ComponentPropsWithoutRef<"div"> & {
+    maxHeight?: number;
+    className?: string;
+};
+export type CommandPaletteItemProps = Omit<React.ComponentPropsWithoutRef<"div">, "onSelect" | "value"> & {
+    value?: string;
+    keywords?: string[];
+    disabled?: boolean;
+    forceMount?: boolean;
+    onSelect?: (value: string) => void;
+    className?: string;
+};
+export type CommandPaletteGroupProps = React.ComponentPropsWithoutRef<"div"> & {
+    heading?: React.ReactNode;
+    forceMount?: boolean;
+    className?: string;
+};
+export type CommandPaletteEmptyProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type CommandPaletteLoadingProps = React.ComponentPropsWithoutRef<"div"> & {
+    label?: string;
+    className?: string;
+};
+export type CommandPaletteSeparatorProps = React.ComponentPropsWithoutRef<"div"> & {
+    alwaysRender?: boolean;
+    className?: string;
+};
+export type CommandPaletteDialogProps = CommandPaletteProps & {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    returnFocusRef?: React.RefObject<HTMLElement | null>;
+    overlayClassName?: string;
+};

package/build/components/command-palette/CommandPaletteContext.d.ts

@@ -0,0 +1,3 @@
+import type { CommandPaletteContextValue, CommandPaletteGroupContextValue } from "./CommandPalette.types";
+export declare const CommandPaletteContext: import("react").Context<CommandPaletteContextValue | null>;
+export declare const CommandPaletteGroupContext: import("react").Context<CommandPaletteGroupContextValue | null>;

package/build/components/command-palette/CommandPaletteDialog.d.ts

@@ -0,0 +1,21 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "defaultValue" | "onSelect"> & {
+    search?: string;
+    defaultSearch?: string;
+    onSearchChange?: (search: string) => void;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    onSelect?: (value: string) => void;
+    filter?: import("./CommandPalette.types").CommandPaletteFilter;
+    shouldFilter?: boolean;
+    loop?: boolean;
+    label?: string;
+    className?: string;
+} & {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    returnFocusRef?: React.RefObject<HTMLElement | null>;
+    overlayClassName?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/command-palette/CommandPaletteEmpty.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/command-palette/CommandPaletteGroup.d.ts

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

package/build/components/command-palette/CommandPaletteInput.d.ts

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

package/build/components/command-palette/CommandPaletteItem.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "value" | "onSelect"> & {
+    value?: string;
+    keywords?: string[];
+    disabled?: boolean;
+    forceMount?: boolean;
+    onSelect?: (value: string) => void;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/command-palette/CommandPaletteList.d.ts

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

package/build/components/command-palette/CommandPaletteLoading.d.ts

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

package/build/components/command-palette/CommandPaletteSeparator.d.ts

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

package/build/components/command-palette/commandScore.d.ts

@@ -0,0 +1 @@
+export declare const commandScore: (value: string, search: string, keywords?: string[]) => number;

package/build/components/command-palette/index.d.ts

@@ -0,0 +1,77 @@
+import CommandPaletteDialog from "./CommandPaletteDialog";
+import CommandPaletteEmpty from "./CommandPaletteEmpty";
+import CommandPaletteGroup from "./CommandPaletteGroup";
+import CommandPaletteInput from "./CommandPaletteInput";
+import CommandPaletteItem from "./CommandPaletteItem";
+import CommandPaletteList from "./CommandPaletteList";
+import CommandPaletteLoading from "./CommandPaletteLoading";
+import CommandPaletteSeparator from "./CommandPaletteSeparator";
+export declare const CommandPalette: ((props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "defaultValue" | "onSelect"> & {
+    search?: string;
+    defaultSearch?: string;
+    onSearchChange?: (search: string) => void;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    onSelect?: (value: string) => void;
+    filter?: import("./CommandPalette.types").CommandPaletteFilter;
+    shouldFilter?: boolean;
+    loop?: boolean;
+    label?: string;
+    className?: string;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Dialog: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "defaultValue" | "onSelect"> & {
+        search?: string;
+        defaultSearch?: string;
+        onSearchChange?: (search: string) => void;
+        value?: string;
+        defaultValue?: string;
+        onValueChange?: (value: string) => void;
+        onSelect?: (value: string) => void;
+        filter?: import("./CommandPalette.types").CommandPaletteFilter;
+        shouldFilter?: boolean;
+        loop?: boolean;
+        label?: string;
+        className?: string;
+    } & {
+        open: boolean;
+        onOpenChange: (open: boolean) => void;
+        returnFocusRef?: React.RefObject<HTMLElement | null>;
+        overlayClassName?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Input: (props: Omit<import("..").TextInputProps, "onChange" | "value" | "type"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    List: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        maxHeight?: number;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Group: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        heading?: React.ReactNode;
+        forceMount?: boolean;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Item: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "value" | "onSelect"> & {
+        value?: string;
+        keywords?: string[];
+        disabled?: boolean;
+        forceMount?: boolean;
+        onSelect?: (value: string) => void;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Separator: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        alwaysRender?: boolean;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Empty: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Loading: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        label?: string;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { CommandPaletteDialog, CommandPaletteInput, CommandPaletteList, CommandPaletteGroup, CommandPaletteItem, CommandPaletteSeparator, CommandPaletteEmpty, CommandPaletteLoading, };
+export { CommandPaletteContext, CommandPaletteGroupContext } from "./CommandPaletteContext";
+export { commandScore } from "./commandScore";
+export * from "./CommandPalette.types";

package/build/components/confirmation-dialog/ConfirmationDialog.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+declare const _default: (props: {
+    onClose: (gesture: import("./ConfirmationDialog.types").ConfirmationDialogCloseGesture) => void;
+    title: React.ReactNode;
+    cancelButtonContent?: React.ReactNode;
+    confirmButtonContent?: React.ReactNode;
+    confirmButtonType?: import("./ConfirmationDialog.types").ConfirmationButtonType;
+    cancelButtonLoading?: boolean;
+    confirmButtonLoading?: boolean;
+    overrideButtonFocus?: import("./ConfirmationDialog.types").ConfirmationButtonFocus;
+    width?: import("..").DialogWidth;
+    height?: import("..").DialogHeight;
+    className?: string;
+} & {
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/confirmation-dialog/ConfirmationDialog.types.d.ts

@@ -0,0 +1,21 @@
+import type * as React from "react";
+import type { DialogCloseGesture, DialogHeight, DialogWidth } from "../dialog/Dialog.types";
+export type ConfirmationDialogCloseGesture = DialogCloseGesture | "confirm" | "cancel";
+export type ConfirmationButtonType = "normal" | "primary" | "danger";
+export type ConfirmationButtonFocus = "cancel" | "confirm";
+export type ConfirmationDialogProps = React.PropsWithChildren<{
+    onClose: (gesture: ConfirmationDialogCloseGesture) => void;
+    title: React.ReactNode;
+    cancelButtonContent?: React.ReactNode;
+    confirmButtonContent?: React.ReactNode;
+    confirmButtonType?: ConfirmationButtonType;
+    cancelButtonLoading?: boolean;
+    confirmButtonLoading?: boolean;
+    overrideButtonFocus?: ConfirmationButtonFocus;
+    width?: DialogWidth;
+    height?: DialogHeight;
+    className?: string;
+}>;
+export type ConfirmOptions = Omit<ConfirmationDialogProps, "onClose" | "children"> & {
+    content: React.ReactNode;
+};

package/build/components/confirmation-dialog/index.d.ts

@@ -0,0 +1,3 @@
+export { default as ConfirmationDialog } from "./ConfirmationDialog";
+export { useConfirm } from "./useConfirm";
+export * from "./ConfirmationDialog.types";

package/build/components/confirmation-dialog/useConfirm.d.ts

@@ -0,0 +1,2 @@
+import type { ConfirmOptions } from "./ConfirmationDialog.types";
+export declare const useConfirm: () => ({ content, ...props }: ConfirmOptions) => Promise<boolean>;

package/build/components/counter-label/CounterLabel.d.ts

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