@gamecrafters/base-ui 0.0.1

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

@@ -0,0 +1,7 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type CounterLabelVariant = "primary" | "secondary";
+export type CounterLabelProps<As extends React.ElementType = "span"> = PolymorphicProps<As, "span", {
+    variant?: CounterLabelVariant;
+    className?: string;
+}>;

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

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

package/build/components/data-table/DataTable.d.ts

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

package/build/components/data-table/DataTable.types.d.ts

@@ -0,0 +1,118 @@
+import type * as React from "react";
+import type { ResponsiveValue } from "../../hooks/useResponsive";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type UniqueRow = {
+    id: string | number;
+};
+type ArrayOfLength<Length extends number, Sized extends unknown[] = []> = Sized["length"] extends Length ? Sized : ArrayOfLength<Length, [...Sized, Sized["length"]]>;
+type MaxLength = ArrayOfLength<10>[number];
+type ArrayIndex<A extends ReadonlyArray<any>, Keys extends number = never> = A extends readonly [] ? Keys : A extends readonly [infer _, ...infer Tail] ? ArrayIndex<Tail, Keys | Tail["length"]> : Keys;
+type ArrayWithinBounds<T> = T extends ReadonlyArray<any> & {
+    length: infer Length;
+} ? Length extends MaxLength ? T : never : never;
+export type ObjectPaths<T> = T extends readonly any[] & ArrayWithinBounds<T> ? `${ArrayIndex<T>}` | PrefixPath<T, ArrayIndex<T>> : T extends any[] ? never & "Unable to determine the keys of a boundless array" : T extends Date ? never : T extends object ? Extract<keyof T, string | number> | PrefixPath<T, Extract<keyof T, string | number>> : never;
+type PrefixPath<T, Prefix> = Prefix extends Extract<keyof T, number | string> ? `${Prefix}.${ObjectPaths<T[Prefix]>}` : never;
+export type ObjectPathValue<ObjectType extends object, Path extends string | number> = ObjectType extends Record<string | number, any> ? Path extends `${infer Key}.${infer NestedPath}` ? ObjectPathValue<ObjectType[Key], NestedPath> : ObjectType[Path] : never;
+export type SortDirection = "ASC" | "DESC" | "NONE";
+export type SortStrategyName = "alphanumeric" | "basic" | "datetime";
+export type CustomSortStrategy<Data> = (a: Data, b: Data) => number;
+export type CellAlignment = "start" | "end";
+export type ColumnWidth = "grow" | "growCollapse" | "auto" | React.CSSProperties["width"];
+export type TableCellPadding = "condensed" | "normal" | "spacious";
+export type Column<Data extends UniqueRow> = {
+    id?: string;
+    header: string | (() => React.ReactNode);
+    field?: ObjectPaths<Data>;
+    align?: CellAlignment;
+    width?: ColumnWidth;
+    minWidth?: React.CSSProperties["minWidth"];
+    maxWidth?: React.CSSProperties["maxWidth"];
+    renderCell?: (data: Data) => React.ReactNode;
+    rowHeader?: boolean;
+    sortBy?: boolean | SortStrategyName | CustomSortStrategy<Data>;
+};
+export type DataTableProps<Data extends UniqueRow> = {
+    data: Data[];
+    columns: Column<Data>[];
+    cellPadding?: TableCellPadding;
+    initialSortColumn?: ObjectPaths<Data> | string | number;
+    initialSortDirection?: Exclude<SortDirection, "NONE">;
+    externalSorting?: boolean;
+    getRowId?: (rowData: Data) => string | number;
+    onToggleSort?: (columnId: ObjectPaths<Data> | string | number, direction: Exclude<SortDirection, "NONE">) => void;
+    "aria-labelledby"?: string;
+    "aria-describedby"?: string;
+};
+export type TableProps = React.ComponentPropsWithoutRef<"table"> & {
+    cellPadding?: TableCellPadding;
+    gridTemplateColumns?: React.CSSProperties["gridTemplateColumns"];
+    "aria-labelledby"?: string;
+    "aria-describedby"?: string;
+    className?: string;
+};
+export type TableHeadProps = React.ComponentPropsWithoutRef<"thead"> & {
+    className?: string;
+};
+export type TableBodyProps = React.ComponentPropsWithoutRef<"tbody"> & {
+    className?: string;
+};
+export type TableRowProps = React.ComponentPropsWithoutRef<"tr"> & {
+    className?: string;
+};
+export type TableHeaderProps = Omit<React.ComponentPropsWithoutRef<"th">, "align"> & {
+    align?: CellAlignment;
+    className?: string;
+};
+export type TableSortHeaderProps = TableHeaderProps & {
+    direction: SortDirection;
+    onToggleSort: () => void;
+};
+export type TableCellProps = Omit<React.ComponentPropsWithoutRef<"td">, "align"> & {
+    align?: CellAlignment;
+    scope?: "row";
+    className?: string;
+};
+export type TableCellPlaceholderProps = React.ComponentPropsWithoutRef<"span"> & {
+    className?: string;
+};
+export type TableContainerProps<As extends React.ElementType = "div"> = PolymorphicProps<As, "div", {
+    className?: string;
+}>;
+export type TableTitleProps<As extends React.ElementType = "h2"> = PolymorphicProps<As, "h2", {
+    id: string;
+    className?: string;
+}>;
+export type TableSubtitleProps<As extends React.ElementType = "div"> = PolymorphicProps<As, "div", {
+    id: string;
+    className?: string;
+}>;
+export type TableActionsProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type TableDividerProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type TableSkeletonProps<Data extends UniqueRow> = React.ComponentPropsWithoutRef<"table"> & {
+    columns: Column<Data>[];
+    cellPadding?: TableCellPadding;
+    rows?: number;
+    className?: string;
+};
+export type TablePaginationState = {
+    pageIndex: number;
+};
+export type TablePaginationProps = Omit<React.ComponentPropsWithoutRef<"nav">, "onChange"> & {
+    "aria-label": string;
+    totalCount: number;
+    pageSize?: number;
+    defaultPageIndex?: number;
+    onChange?: (state: TablePaginationState) => void;
+    showPages?: boolean | ResponsiveValue<boolean>;
+    className?: string;
+};
+export type TableErrorDialogProps = React.PropsWithChildren<{
+    title?: string;
+    onRetry?: () => void;
+    onDismiss?: () => void;
+}>;
+export {};

package/build/components/data-table/Table.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+import type { TableCellPadding } from "./DataTable.types";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>, "ref"> & {
+    cellPadding?: TableCellPadding;
+    gridTemplateColumns?: React.CSSProperties["gridTemplateColumns"];
+    "aria-labelledby"?: string;
+    "aria-describedby"?: string;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/data-table/TableActions.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/data-table/TableBody.d.ts

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

package/build/components/data-table/TableCell.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>, "ref">, "align"> & {
+    align?: import("./DataTable.types").CellAlignment;
+    scope?: "row";
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/data-table/TableCellPlaceholder.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/data-table/TableContainer.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/data-table/TableDivider.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/data-table/TableErrorDialog.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+declare const _default: (props: {
+    title?: string;
+    onRetry?: () => void;
+    onDismiss?: () => void;
+} & {
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/data-table/TableHead.d.ts

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

package/build/components/data-table/TableHeader.d.ts

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

package/build/components/data-table/TablePagination.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+import type { TablePaginationState } from "./DataTable.types";
+export declare const DEFAULT_TABLE_PAGE_SIZE = 25;
+export declare const DEFAULT_TABLE_SHOW_PAGES: {
+    narrow: boolean;
+};
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref">, "onChange"> & {
+    "aria-label": string;
+    totalCount: number;
+    pageSize?: number;
+    defaultPageIndex?: number;
+    onChange?: (state: TablePaginationState) => void;
+    showPages?: boolean | import("../../hooks/useResponsive").ResponsiveValue<boolean>;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/data-table/TableRow.d.ts

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

package/build/components/data-table/TableSkeleton.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+import type { UniqueRow } from "./DataTable.types";
+export declare const DEFAULT_TABLE_SKELETON_ROWS = 10;
+declare const _default: <Data extends UniqueRow>(props: Omit<React.DetailedHTMLProps<React.TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>, "ref"> & {
+    columns: import("./DataTable.types").Column<Data>[];
+    cellPadding?: import("./DataTable.types").TableCellPadding;
+    rows?: number;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/data-table/TableSortHeader.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>, "ref">, "align"> & {
+    align?: import("./DataTable.types").CellAlignment;
+    className?: string;
+} & {
+    direction: import("./DataTable.types").SortDirection;
+    onToggleSort: () => void;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/data-table/TableSubtitle.d.ts

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

package/build/components/data-table/TableTitle.d.ts

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

package/build/components/data-table/column.d.ts

@@ -0,0 +1,4 @@
+import type { Column, UniqueRow } from "./DataTable.types";
+export declare const createColumnHelper: <Data extends UniqueRow>() => {
+    column: (column: Column<Data>) => Column<Data>;
+};

package/build/components/data-table/index.d.ts

@@ -0,0 +1,103 @@
+import TableActions from "./TableActions";
+import TableBody from "./TableBody";
+import TableCell from "./TableCell";
+import TableCellPlaceholder from "./TableCellPlaceholder";
+import TableContainer from "./TableContainer";
+import TableDivider from "./TableDivider";
+import TableErrorDialog from "./TableErrorDialog";
+import TableHead from "./TableHead";
+import TableHeader from "./TableHeader";
+import TablePagination from "./TablePagination";
+import TableRow from "./TableRow";
+import TableSkeleton from "./TableSkeleton";
+import TableSortHeader from "./TableSortHeader";
+import TableSubtitle from "./TableSubtitle";
+import TableTitle from "./TableTitle";
+export declare const Table: ((props: Omit<import("react").DetailedHTMLProps<import("react").TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>, "ref"> & {
+    cellPadding?: import("./DataTable.types").TableCellPadding;
+    gridTemplateColumns?: React.CSSProperties["gridTemplateColumns"];
+    "aria-labelledby"?: string;
+    "aria-describedby"?: string;
+    className?: string;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Container: <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;
+    Title: <As extends React.ElementType = "h2">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "h2" : As> & {
+        id: string;
+        className?: string;
+    }, "as"> & {
+        as?: As | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Subtitle: <As extends React.ElementType = "div">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "div" : As> & {
+        id: string;
+        className?: string;
+    }, "as"> & {
+        as?: As | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Actions: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Divider: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Skeleton: <Data extends import("./DataTable.types").UniqueRow>(props: Omit<import("react").DetailedHTMLProps<import("react").TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>, "ref"> & {
+        columns: import("./DataTable.types").Column<Data>[];
+        cellPadding?: import("./DataTable.types").TableCellPadding;
+        rows?: number;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Head: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Body: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Header: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>, "ref">, "align"> & {
+        align?: import("./DataTable.types").CellAlignment;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    SortHeader: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>, "ref">, "align"> & {
+        align?: import("./DataTable.types").CellAlignment;
+        className?: string;
+    } & {
+        direction: import("./DataTable.types").SortDirection;
+        onToggleSort: () => void;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Row: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Cell: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>, "ref">, "align"> & {
+        align?: import("./DataTable.types").CellAlignment;
+        scope?: "row";
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    CellPlaceholder: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Pagination: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLElement>, HTMLElement>, "ref">, "onChange"> & {
+        "aria-label": string;
+        totalCount: number;
+        pageSize?: number;
+        defaultPageIndex?: number;
+        onChange?: (state: import("./DataTable.types").TablePaginationState) => void;
+        showPages?: boolean | import("../../hooks/useResponsive").ResponsiveValue<boolean>;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    ErrorDialog: (props: {
+        title?: string;
+        onRetry?: () => void;
+        onDismiss?: () => void;
+    } & {
+        children?: import("react").ReactNode | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { default as DataTable } from "./DataTable";
+export { TableContainer, TableTitle, TableSubtitle, TableActions, TableDivider, TableSkeleton, TableHead, TableBody, TableHeader, TableSortHeader, TableRow, TableCell, TableCellPlaceholder, TablePagination, TableErrorDialog, };
+export { DEFAULT_TABLE_SKELETON_ROWS } from "./TableSkeleton";
+export { DEFAULT_TABLE_PAGE_SIZE } from "./TablePagination";
+export { createColumnHelper } from "./column";
+export { sortStrategies, transitionSortDirection, DEFAULT_SORT_DIRECTION } from "./sorting";
+export * from "./DataTable.types";

package/build/components/data-table/sorting.d.ts

@@ -0,0 +1,8 @@
+import type { SortDirection } from "./DataTable.types";
+export declare const DEFAULT_SORT_DIRECTION: Exclude<SortDirection, "NONE">;
+export declare const transitionSortDirection: (direction: Exclude<SortDirection, "NONE">) => Exclude<SortDirection, "NONE">;
+export declare const sortStrategies: {
+    alphanumeric: (inputA: string, inputB: string) => number;
+    basic: <T>(a: T, b: T) => 0 | 1 | -1;
+    datetime: (a: Date | number, b: Date | number) => 0 | 1 | -1;
+};

package/build/components/data-table/tableLayout.d.ts

@@ -0,0 +1,4 @@
+import type { Column, UniqueRow } from "./DataTable.types";
+export declare const SUBGRID_CLASSES: string;
+export declare const getGridTemplateFromColumns: <Data extends UniqueRow>(columns: Column<Data>[]) => string[];
+export declare const getGridTemplate: <Data extends UniqueRow>(columns: Column<Data>[]) => string;

package/build/components/data-table/useTable.d.ts

@@ -0,0 +1,35 @@
+import type { Column, SortDirection, UniqueRow } from "./DataTable.types";
+export type TableHeaderModel<Data extends UniqueRow> = {
+    id: string;
+    column: Column<Data>;
+    isSortable: () => boolean;
+    getSortDirection: () => SortDirection;
+};
+export type TableCellModel<Data extends UniqueRow> = {
+    id: string;
+    column: Column<Data>;
+    rowHeader: boolean;
+    getValue: () => Data[keyof Data];
+};
+export type TableRowModel<Data extends UniqueRow> = {
+    id: string;
+    getValue: () => Data;
+    getCells: () => TableCellModel<Data>[];
+};
+export type TableModel<Data extends UniqueRow> = {
+    headers: TableHeaderModel<Data>[];
+    rows: TableRowModel<Data>[];
+    actions: {
+        sortBy: (header: TableHeaderModel<Data>) => void;
+    };
+    gridTemplateColumns: string;
+};
+export type UseTableOptions<Data extends UniqueRow> = {
+    columns: Column<Data>[];
+    data: Data[];
+    initialSortColumn?: string | number;
+    initialSortDirection?: Exclude<SortDirection, "NONE">;
+    externalSorting?: boolean;
+    getRowId: (rowData: Data) => string | number;
+};
+export declare const useTable: <Data extends UniqueRow>({ columns, data, initialSortColumn, initialSortDirection, externalSorting, getRowId, }: UseTableOptions<Data>) => TableModel<Data>;

package/build/components/date-picker/DatePicker.d.ts

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

package/build/components/date-picker/DatePicker.types.d.ts

@@ -0,0 +1,41 @@
+import type { CalendarDateInput, CalendarDateMatcher, CalendarMode, CalendarRange, CalendarRangeInput, CalendarWeekStart } from "../calendar/Calendar.types";
+import type { TextInputProps } from "../text-input";
+export type DatePickerCloseGesture = "date-select" | "button" | "click-outside" | "escape";
+export type DatePickerPropsForOneDay = {
+    mode?: "single";
+    value?: CalendarDateInput | null;
+    defaultValue?: CalendarDateInput | null;
+    onChange?: (date: Date | null) => void;
+};
+export type DatePickerPropsForARange = {
+    mode: "range";
+    value?: CalendarRangeInput | null;
+    defaultValue?: CalendarRangeInput | null;
+    onChange?: (range: CalendarRange) => void;
+};
+export type DatePickerSelectionConfig = DatePickerPropsForOneDay | DatePickerPropsForARange;
+export type DatePickerBaseProps = Omit<TextInputProps, "type" | "value" | "defaultValue" | "onChange" | "trailingAction" | "characterLimit" | "min" | "max"> & {
+    format?: string;
+    rangeSeparator?: string;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean, gesture?: DatePickerCloseGesture) => void;
+    min?: CalendarDateInput;
+    max?: CalendarDateInput;
+    isDateDisabled?: CalendarDateMatcher;
+    weekStartsOn?: CalendarWeekStart;
+    fixedWeeks?: boolean;
+    showWeekNumbers?: boolean;
+    monthFormat?: string;
+    calendarButtonLabel?: string;
+    calendarLabel?: string;
+    inputClassName?: string;
+    className?: string;
+};
+export type DatePickerProps = DatePickerBaseProps & DatePickerSelectionConfig;
+export type DatePickerElementProps = DatePickerBaseProps & {
+    mode?: CalendarMode;
+    value?: CalendarDateInput | CalendarRangeInput | null;
+    defaultValue?: CalendarDateInput | CalendarRangeInput | null;
+    onChange?: ((date: Date | null) => void) | ((range: CalendarRange) => void);
+};

package/build/components/date-picker/index.d.ts

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

package/build/components/details/Details.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.DetailsHTMLAttributes<HTMLDetailsElement>, HTMLDetailsElement>, "ref"> & {
+    defaultOpen?: boolean;
+    closeOnOutsideClick?: boolean;
+    className?: string;
+}, "onChange"> & {
+    onChange?: (open: boolean) => void;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/details/Details.types.d.ts

@@ -0,0 +1,12 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type DetailsProps = Omit<React.ComponentPropsWithoutRef<"details"> & {
+    defaultOpen?: boolean;
+    closeOnOutsideClick?: boolean;
+    className?: string;
+}, "onChange"> & {
+    onChange?: (open: boolean) => void;
+};
+export type DetailsSummaryProps<As extends React.ElementType = "summary"> = PolymorphicProps<As, "summary", {
+    className?: string;
+}>;

package/build/components/details/DetailsSummary.d.ts

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

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

@@ -0,0 +1,16 @@
+import DetailsSummary from "./DetailsSummary";
+export declare const Details: ((props: Omit<Omit<import("react").DetailedHTMLProps<import("react").DetailsHTMLAttributes<HTMLDetailsElement>, HTMLDetailsElement>, "ref"> & {
+    defaultOpen?: boolean;
+    closeOnOutsideClick?: boolean;
+    className?: string;
+}, "onChange"> & {
+    onChange?: (open: boolean) => void;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Summary: <As extends React.ElementType = "summary">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "summary" : As> & {
+        className?: string;
+    }, "as"> & {
+        as?: As | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { DetailsSummary };
+export * from "./Details.types";

package/build/components/dialog/Dialog.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+import type { DialogAlign, DialogHeaderRenderProps, DialogHeight, DialogPosition, DialogRenderProps, DialogResponsivePosition, DialogWidth } from "./Dialog.types";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "title" | "role" | "onClose"> & {
+    title?: React.ReactNode;
+    subtitle?: React.ReactNode;
+    renderHeader?: import("./Dialog.types").DialogRenderer<DialogHeaderRenderProps>;
+    renderBody?: import("./Dialog.types").DialogRenderer<DialogRenderProps>;
+    renderFooter?: import("./Dialog.types").DialogRenderer<DialogRenderProps>;
+    footerButtons?: import("./Dialog.types").DialogButtonProps[];
+    onClose: (gesture: import("./Dialog.types").DialogCloseGesture) => void;
+    role?: import("./Dialog.types").DialogRole;
+    width?: DialogWidth;
+    height?: DialogHeight;
+    position?: DialogPosition | DialogResponsivePosition;
+    align?: DialogAlign;
+    returnFocusRef?: React.RefObject<HTMLElement | null>;
+    initialFocusRef?: React.RefObject<HTMLElement | null>;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;