@overmap-ai/blocks 1.0.31-minimize-size.7 → 1.0.31-tailwind-components.0

package/README.md

@@ -1,3 +1,3 @@
-# overmap-ai blocks
-
-Contains basic components used by overmap-ai libraries.
+# overmap-ai blocks
+
+Contains basic components used by overmap-ai libraries.

package/dist/AlertDialog/Content.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import * as RadixAlertDialog from "@radix-ui/react-alert-dialog";
+import { AlertDialogVariantProps } from "./typings";
+export interface AlertDialogContentProps extends RadixAlertDialog.AlertDialogContentProps, AlertDialogVariantProps {
+    container?: RadixAlertDialog.AlertDialogPortalProps["container"];
+}
+export declare const AlertDialogContent: import("react").ForwardRefExoticComponent<AlertDialogContentProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/AlertDialog/Provider.d.ts

@@ -0,0 +1,2 @@
+import { PropsWithChildren } from "react";
+export declare const AlertDialogProvider: (props: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;

package/dist/AlertDialog/context.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { AlertDialogOptions } from "./typings";
+type AlertDialogContextType = (options: AlertDialogOptions) => void;
+export declare const AlertDialogContext: import("react").Context<AlertDialogContextType>;
+export {};

package/dist/AlertDialog/cva.d.ts

@@ -0,0 +1,4 @@
+export declare const dialogOverlay: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+export declare const dialogContent: (props?: ({
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;

package/dist/AlertDialog/hooks.d.ts

@@ -0,0 +1 @@
+export declare const useAlertDialog: () => (options: import("./typings").AlertDialogOptions) => void;

package/dist/AlertDialog/index.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import * as RadixAlertDialog from "@radix-ui/react-alert-dialog";
+export * from "./Content";
+export * from "./hooks";
+export * from "./Provider";
+export declare const AlertDialog: {
+    Content: import("react").ForwardRefExoticComponent<import("./Content").AlertDialogContentProps & import("react").RefAttributes<HTMLDivElement>>;
+    Trigger: import("react").ForwardRefExoticComponent<RadixAlertDialog.AlertDialogTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+    Root: import("react").FC<RadixAlertDialog.AlertDialogProps>;
+    Title: import("react").ForwardRefExoticComponent<RadixAlertDialog.AlertDialogTitleProps & import("react").RefAttributes<HTMLHeadingElement>>;
+    Description: import("react").ForwardRefExoticComponent<RadixAlertDialog.AlertDialogDescriptionProps & import("react").RefAttributes<HTMLParagraphElement>>;
+    Action: import("react").ForwardRefExoticComponent<RadixAlertDialog.AlertDialogActionProps & import("react").RefAttributes<HTMLButtonElement>>;
+    Cancel: import("react").ForwardRefExoticComponent<RadixAlertDialog.AlertDialogCancelProps & import("react").RefAttributes<HTMLButtonElement>>;
+};

package/dist/AlertDialog/typings.d.ts

@@ -0,0 +1,19 @@
+import { VariantProps } from "class-variance-authority";
+import { ReactNode } from "react";
+import { dialogContent } from "./cva";
+type Variants = VariantProps<typeof dialogContent>;
+export type AlertDialogSize = NonNullable<Variants["size"]>;
+export interface AlertDialogVariantProps {
+    size?: AlertDialogSize;
+}
+export interface AlertDialogOptions {
+    title: string;
+    description: string;
+    onAction: () => void;
+    onCancel?: () => void;
+    onClose?: () => void;
+    cancel?: ReactNode;
+    action?: ReactNode;
+    size?: AlertDialogSize;
+}
+export {};

package/dist/Avatar/Fallback.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import * as RadixAvatar from "@radix-ui/react-avatar";
+export interface AvatarFallbackProps extends RadixAvatar.AvatarFallbackProps {
+}
+export declare const AvatarFallback: import("react").ForwardRefExoticComponent<AvatarFallbackProps & import("react").RefAttributes<HTMLSpanElement>>;

package/dist/Avatar/Image.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import * as RadixAvatar from "@radix-ui/react-avatar";
+export interface AvatarImageProps extends RadixAvatar.AvatarImageProps {
+}
+export declare const AvatarImage: import("react").ForwardRefExoticComponent<AvatarImageProps & import("react").RefAttributes<HTMLImageElement>>;

package/dist/Avatar/Root.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import * as RadixAvatar from "@radix-ui/react-avatar";
+import { AccentColorProps } from "../typings";
+import { AvatarVariantProps } from "./typings";
+export interface AvatarRootProps extends RadixAvatar.AvatarProps, AvatarVariantProps, AccentColorProps {
+}
+export declare const AvatarRoot: import("react").ForwardRefExoticComponent<AvatarRootProps & import("react").RefAttributes<HTMLSpanElement>>;

package/dist/Avatar/context.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { AvatarVariant } from "./typings";
+interface IAvatarContext {
+    variant: AvatarVariant;
+}
+export declare const AvatarContext: import("react").Context<IAvatarContext>;
+export {};

package/dist/Avatar/cva.d.ts

@@ -0,0 +1,6 @@
+export declare const avatar: (props?: ({
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export declare const avatarFallback: (props?: ({
+    variant?: "solid" | "soft" | "surface" | "outline" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;

package/dist/Avatar/index.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+export * from "./Fallback";
+export * from "./Image";
+export * from "./Root";
+export declare const Avatar: {
+    Fallback: import("react").ForwardRefExoticComponent<import("./Fallback").AvatarFallbackProps & import("react").RefAttributes<HTMLSpanElement>>;
+    Image: import("react").ForwardRefExoticComponent<import("./Image").AvatarImageProps & import("react").RefAttributes<HTMLImageElement>>;
+    Root: import("react").ForwardRefExoticComponent<import("./Root").AvatarRootProps & import("react").RefAttributes<HTMLSpanElement>>;
+};

package/dist/Avatar/typings.d.ts

@@ -0,0 +1,12 @@
+import { VariantProps } from "class-variance-authority";
+import { ComponentRadius } from "../Provider/typings";
+import { avatar, avatarFallback } from "./cva";
+type Variants = VariantProps<typeof avatar> & VariantProps<typeof avatarFallback>;
+export type AvatarSize = NonNullable<Variants["size"]>;
+export type AvatarVariant = NonNullable<Variants["variant"]>;
+export interface AvatarVariantProps {
+    variant?: AvatarVariant;
+    size?: AvatarSize;
+    radius?: ComponentRadius;
+}
+export {};

package/dist/Badge/Badge.d.ts

@@ -1,6 +1,6 @@
-import { FC } from "react";
-import { BadgeProps } from "./typings";
-/** The Badge Component is a user interface element that provides visual feedback, typically displaying a small amount
- * of information. It is commonly used to indicate counts, statuses, or labels in a concise and visually appealing
- * manner. This Badge components wraps the Badge component from Radix-ui found here https://www.radix-ui.com/themes/docs/components/badge */
-export declare const Badge: FC<BadgeProps>;
+import { ComponentProps } from "react";
+import { AccentColorProps } from "../typings";
+import { BadgeVariantProps } from "./typings";
+export interface BadgeProps extends ComponentProps<"span">, BadgeVariantProps, AccentColorProps {
+}
+export declare const Badge: import("react").ForwardRefExoticComponent<Omit<BadgeProps, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;

package/dist/Badge/cva.d.ts

@@ -0,0 +1,5 @@
+export declare const badge: (props?: ({
+    icon?: boolean | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    variant?: "solid" | "soft" | "surface" | "outline" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;

package/dist/Badge/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./Badge";
+export * from "./cva";
 export * from "./typings";

package/dist/Badge/typings.d.ts

@@ -1,8 +1,13 @@
-import { ComponentProps } from "react";
-import { Badge as RadixBadge, MarginProps } from "@radix-ui/themes";
-import { Severity } from "../typings";
-export interface BadgeProps extends Omit<ComponentProps<typeof RadixBadge>, keyof MarginProps> {
-    /** The severity of the Badge, supports all global severities. Note that specifying a severity will overwrite any
-     * color passed into the Badge component. */
-    severity?: Severity;
+import { VariantProps } from "class-variance-authority";
+import { ComponentRadius } from "../Provider/typings";
+import { badge } from "./cva";
+type BadgeVariants = VariantProps<typeof badge>;
+export type BadgeSize = NonNullable<BadgeVariants["size"]>;
+export type BadgeVariant = NonNullable<BadgeVariants["variant"]>;
+export interface BadgeVariantProps {
+    size?: BadgeSize;
+    variant?: BadgeVariant;
+    radius?: ComponentRadius;
+    icon?: NonNullable<BadgeVariants["icon"]>;
 }
+export {};

package/dist/ButtonGroup/ButtonGroup.d.ts

@@ -1,7 +1,9 @@
-import { FC } from "react";
-import { ButtonGroupProps } from "./typings";
-/** The ButtonGroup Component is a user interface element that groups multiple buttons together for improved user
- * interaction and visual clarity. It is commonly used to present related actions or options in a compact and organized
- * manner. The ButtonGroup supports all props of the RadixUI Flex layout component besides MarginProps,
- * further documentation for the Flex layout component can be found here https://www.radix-ui.com/themes/docs/components/flex */
-export declare const ButtonGroup: FC<ButtonGroupProps>;
+import { PropsWithChildren } from "react";
+import { ButtonVariantProps } from "../Buttons";
+interface ButtonsProps extends PropsWithChildren, ButtonVariantProps {
+}
+export declare const ButtonGroup: {
+    (props: ButtonsProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export {};

package/dist/ButtonGroup/context.d.ts

@@ -1,5 +1,10 @@
 /// <reference types="react" />
-import { ButtonProps } from "../Buttons/typings";
-export type ButtonContextType = Pick<ButtonProps, "variant" | "size" | "severity" | "hoverEffects" | "fluid" | "highContrast">;
-export declare const ButtonGroupContext: import("react").Context<ButtonContextType>;
-export declare const useButtonGroupContext: () => ButtonContextType;
+import { ButtonSize, ButtonVariant } from "../Buttons";
+import { ComponentRadius } from "../Provider/typings";
+interface IButtonGroupContext {
+    variant: ButtonVariant;
+    size: ButtonSize;
+    radius: ComponentRadius;
+}
+export declare const ButtonGroupContext: import("react").Context<IButtonGroupContext>;
+export {};

package/dist/ButtonGroup/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./ButtonGroup";
-export * from "./typings";
-export { ButtonList } from "./ButtonList";
+export * from "./hooks";

package/dist/Buttons/Button.d.ts

@@ -1,4 +1,6 @@
-import { FC } from "react";
-import { ButtonProps } from "./typings";
-declare const Button: FC<ButtonProps>;
-export default Button;
+import { ComponentProps } from "react";
+import { AccentColorProps } from "../typings";
+import { ButtonVariantProps } from "./typings";
+export interface ButtonProps extends ButtonVariantProps, ComponentProps<"button">, AccentColorProps {
+}
+export declare const Button: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>>;

package/dist/Buttons/IconButton.d.ts

@@ -1,8 +1,6 @@
-import { FC } from "react";
-import { ButtonProps } from "./typings";
-interface IconButtonProps extends ButtonProps {
-    "aria-label": string;
+import { ComponentProps } from "react";
+import { AccentColorProps } from "../typings";
+import { ButtonVariantProps } from "./typings";
+export interface IconButtonProps extends ButtonVariantProps, ComponentProps<"button">, AccentColorProps {
 }
-/** The `IconButton` is a `Button` variant specifically designed for single icons. */
-declare const IconButton: FC<IconButtonProps>;
-export default IconButton;
+export declare const IconButton: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<Omit<IconButtonProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>>;

package/dist/Buttons/cva.d.ts

@@ -0,0 +1,5 @@
+export declare const button: (props?: ({
+    variant?: "solid" | "soft" | "ghost" | "surface" | "outline" | null | undefined;
+    icon?: boolean | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;

package/dist/Buttons/index.d.ts

@@ -1,4 +1,4 @@
-export { default as Button } from "./Button";
-export { default as IconButton } from "./IconButton";
-export type { ButtonHoverEffect, ButtonProps, ButtonStyleProps } from "./typings";
-export { divButtonProps } from "./constants";
+export * from "./Button";
+export * from "./cva";
+export * from "./IconButton";
+export * from "./typings";

package/dist/Buttons/typings.d.ts

@@ -1,25 +1,12 @@
-import React from "react";
-import { Button as RadixButton, MarginProps, Responsive } from "@radix-ui/themes";
-import { Severity, Size, Variant } from "../typings";
-export interface Shortcut {
-    keys: string[];
-    action: () => void;
-    disabled?: boolean;
-}
-export interface ButtonStyleProps {
-    fluid?: boolean;
-    /** @default solid */
-    variant?: Variant;
-    /** @default primary */
-    severity?: Severity;
-    size?: Responsive<Size>;
-    hoverEffects?: ButtonHoverEffect[];
-    highContrast?: boolean;
-}
-export type RadixButtonProps = React.ComponentProps<typeof RadixButton>;
-export type ButtonHoverEffect = "spin90Clockwise" | "spin180Clockwise" | "spin360Clockwise";
-export interface ButtonProps extends Omit<RadixButtonProps, "size" | "variant" | "loading" | keyof MarginProps>, ButtonStyleProps {
-    children: RadixButtonProps["children"];
-    shortcut?: Shortcut;
-    loading?: boolean;
+import { VariantProps } from "class-variance-authority";
+import { ComponentRadius } from "../Provider/typings";
+import { button } from "./cva";
+type Variants = VariantProps<typeof button>;
+export type ButtonSize = NonNullable<Variants["size"]>;
+export type ButtonVariant = NonNullable<Variants["variant"]>;
+export interface ButtonVariantProps {
+    size?: ButtonSize;
+    variant?: ButtonVariant;
+    radius?: ComponentRadius;
 }
+export {};

package/dist/Checkbox/Indicator.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import * as RadixCheckbox from "@radix-ui/react-checkbox";
+export interface CheckboxIndicatorProps extends RadixCheckbox.CheckboxIndicatorProps {
+}
+export declare const CheckboxIndicator: import("react").ForwardRefExoticComponent<CheckboxIndicatorProps & import("react").RefAttributes<HTMLSpanElement>>;

package/dist/Checkbox/Root.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import * as RadixCheckbox from "@radix-ui/react-checkbox";
+import { AccentColorProps } from "../typings";
+import { CheckboxVariantProps } from "./typings";
+export interface CheckboxRootProps extends CheckboxVariantProps, RadixCheckbox.CheckboxProps, AccentColorProps {
+}
+export declare const CheckboxRoot: import("react").ForwardRefExoticComponent<CheckboxRootProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/Checkbox/cva.d.ts

@@ -0,0 +1,4 @@
+export declare const checkbox: (props?: ({
+    variant?: "soft" | "surface" | "outline" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;

package/dist/Checkbox/index.d.ts

@@ -1,3 +1,7 @@
-export { Checkbox } from "./Checkbox";
-export { SelectAllCheckbox } from "./SelectAllCheckbox";
-export * from "./typings";
+/// <reference types="react" />
+export * from "./Indicator";
+export * from "./Root";
+export declare const Checkbox: {
+    Root: import("react").ForwardRefExoticComponent<import("./Root").CheckboxRootProps & import("react").RefAttributes<HTMLButtonElement>>;
+    Indicator: import("react").ForwardRefExoticComponent<import("./Indicator").CheckboxIndicatorProps & import("react").RefAttributes<HTMLSpanElement>>;
+};

package/dist/Checkbox/typings.d.ts

@@ -1,16 +1,12 @@
-import React, { ReactNode, ReactElement } from "react";
-import { Checkbox as RadixCheckbox } from "@radix-ui/themes";
-import { FlexProps } from "../Flex";
-export type RadixCheckboxProps = React.ComponentProps<typeof RadixCheckbox>;
-export type CheckboxValue = boolean | "indeterminate";
-export interface CheckboxProps extends RadixCheckboxProps {
-    className?: string;
-    labelClassName?: string;
-    label?: ReactNode;
-    doesLabelCheck?: boolean;
-    alwaysShow?: boolean;
-    checkboxPosition?: FlexProps["align"];
-}
-export interface SelectAllCheckboxProps extends Omit<CheckboxProps, "checked"> {
-    children: Array<ReactElement<CheckboxProps>>;
+import { VariantProps } from "class-variance-authority";
+import { ComponentRadius } from "../Provider/typings";
+import { checkbox } from "./cva";
+type Variants = VariantProps<typeof checkbox>;
+export type CheckboxSize = NonNullable<Variants["size"]>;
+export type CheckboxVariant = NonNullable<Variants["variant"]>;
+export interface CheckboxVariantProps {
+    size?: CheckboxSize;
+    variant?: CheckboxVariant;
+    radius?: ComponentRadius;
 }
+export {};

package/dist/CollapsibleTree/context.d.ts

@@ -1,11 +1,8 @@
-import { ComponentProps, CSSProperties } from "react";
-import { Flex } from "@radix-ui/themes";
+import { CSSProperties } from "react";
 import { NodeCallbacks, NodeRenderer } from "./typings";
 interface ICollapsibleTreeContext<TMeta> extends NodeCallbacks<TMeta> {
     nodeClassName?: string;
     nodeStyles?: CSSProperties;
-    nodeGap: ComponentProps<typeof Flex>["gap"];
-    levelGap: ComponentProps<typeof Flex>["pl"];
     disabled: boolean;
     nodeRenderer: NodeRenderer<TMeta>;
 }

package/dist/CollapsibleTree/typings.d.ts

@@ -1,9 +1,6 @@
-import { ComponentProps, CSSProperties } from "react";
 import { CollapsibleProps } from "@radix-ui/react-collapsible";
-import { Flex } from "@radix-ui/themes";
+import { CSSProperties, ReactNode } from "react";
 import { PropsWithClassNameAndStyle } from "../typings";
-import { OvermapItemProps } from "../OvermapItem";
-import { OvermapItemGroupProps } from "../OvermapItemGroup";
 export type NodeEventHandler<TMeta> = (meta: TMeta) => void;
 export interface NodeCallbacks<TMeta> {
     /** callback fired when a specific TreeNode is clicked, regardless of the current open state of the specific
@@ -27,11 +24,9 @@ export type NodeRenderer<TMeta> = (args: {
      * TreeNode is disabled or not. */
     disabled: boolean;
 }) => {
-    children: OvermapItemProps["children"];
+    children: ReactNode;
     className?: string;
     style?: CSSProperties;
-    leftSlot?: OvermapItemProps["leftSlot"];
-    rightSlot?: OvermapItemProps["rightSlot"];
 };
 export interface TreeNodeProps<TMeta> extends Pick<CollapsibleProps, "disabled"> {
     /** list of TreeNodes to be rendered within the current TreeNode collapsible */
@@ -40,17 +35,9 @@ export interface TreeNodeProps<TMeta> extends Pick<CollapsibleProps, "disabled">
      * the structure of this meta-data. */
     meta: TMeta;
 }
-export interface CollapsibleTreeProps<TMeta> extends PropsWithClassNameAndStyle, Pick<OvermapItemGroupProps, "size">, NodeCallbacks<TMeta> {
+export interface CollapsibleTreeProps<TMeta> extends PropsWithClassNameAndStyle, NodeCallbacks<TMeta> {
     /** the TreeNode structure that should be rendered within the CollapsibleTree */
     nodes: TreeNodeProps<TMeta>[];
-    /** the vertical gap between each TreeNode in the CollapsibleTree.
-     * @default "0"
-     * */
-    nodeGap?: ComponentProps<typeof Flex>["gap"];
-    /** the left inset between each TreeNode level in the CollapsibleTree.
-     * @default "2"
-     * */
-    levelGap?: ComponentProps<typeof Flex>["pl"];
     /** disables all TreeNodes in the CollapsibleTree.
      * @default false
      * */

package/dist/Dialog/Content.d.ts

@@ -0,0 +1,11 @@
+import * as RadixDialog from "@radix-ui/react-dialog";
+import { ReactNode } from "react";
+import { AlertDialogSize } from "../AlertDialog/typings";
+import { CloseDialogWithOptions } from "./typings";
+export interface DialogContentProps extends Omit<RadixDialog.DialogContentProps, "children"> {
+    title: string;
+    container?: RadixDialog.DialogPortalProps["container"];
+    size?: AlertDialogSize;
+    children: ReactNode | ((close: CloseDialogWithOptions) => ReactNode);
+}
+export declare const DialogContent: import("react").ForwardRefExoticComponent<DialogContentProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/Dialog/Root.d.ts

@@ -0,0 +1,2 @@
+import { DialogProps } from "./typings";
+export declare const DialogRoot: (props: DialogProps) => import("react/jsx-runtime").JSX.Element;

package/dist/Dialog/context.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { CloseDialogWithOptions } from "./typings";
+export declare const CloseDialogContext: import("react").Context<CloseDialogWithOptions>;

package/dist/Dialog/hooks.d.ts

@@ -0,0 +1 @@
+export declare const useCloseDialog: () => import("./typings").CloseDialogWithOptions;

package/dist/Dialog/index.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import * as RadixDialog from "@radix-ui/react-dialog";
+export * from "./Content";
+export * from "./Root";
+export * from "./typings";
+export declare const Dialog: {
+    Root: (props: import("./typings").DialogProps) => import("react/jsx-runtime").JSX.Element;
+    Content: import("react").ForwardRefExoticComponent<import("./Content").DialogContentProps & import("react").RefAttributes<HTMLDivElement>>;
+    Trigger: import("react").ForwardRefExoticComponent<RadixDialog.DialogTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+    Close: import("react").ForwardRefExoticComponent<RadixDialog.DialogCloseProps & import("react").RefAttributes<HTMLButtonElement>>;
+};

package/dist/Dialog/typings.d.ts

@@ -0,0 +1,17 @@
+import * as RadixDialog from "@radix-ui/react-dialog";
+/** Triggers the dialog to close */
+export type CloseDialog = () => void;
+export interface CloseDialogOptions {
+    /** Bypass the `onCloseInterrupt` and force the dialog to close */
+    force?: boolean;
+}
+export type CloseDialogWithOptions = (options?: CloseDialogOptions) => void;
+export interface DialogProps extends RadixDialog.DialogProps {
+    /** Called when the dialog opens. Unlike `onCloseInterrupt`, it does not interrupt the dialog opening */
+    onOpen?: () => void;
+    /** Interrupts the close process; use the provided `confirmClose` callback to continue the close process. */
+    onCloseInterrupt?: (confirmClose: CloseDialog) => void;
+    /** Called when the dialog closes. If used in conjunction with `onCloseInterrupt`,
+     * the `onClose` callback executes when the `confirmClose` callback is called. */
+    onClose?: () => void;
+}

package/dist/HoverCard/Arrow.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import * as RadixHoverCard from "@radix-ui/react-hover-card";
+export interface HoverCardArrowProps extends RadixHoverCard.HoverCardArrowProps {
+}
+export declare const HoverCardArrow: import("react").ForwardRefExoticComponent<HoverCardArrowProps & import("react").RefAttributes<SVGSVGElement>>;

package/dist/HoverCard/Content.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import * as RadixHoverCard from "@radix-ui/react-hover-card";
+import { AccentColorProps } from "../typings";
+import { HoverCardVariantProps } from "./typings";
+export interface HoverCardContentProps extends RadixHoverCard.HoverCardContentProps, HoverCardVariantProps, AccentColorProps {
+    container?: RadixHoverCard.HoverCardPortalProps["container"];
+}
+export declare const HoverCardContent: import("react").ForwardRefExoticComponent<HoverCardContentProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/HoverCard/cva.d.ts

@@ -0,0 +1,3 @@
+export declare const hoverCardContent: (props?: ({
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;

package/dist/HoverCard/index.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import * as RadixHoverCard from "@radix-ui/react-hover-card";
+export * from "./Arrow";
+export * from "./Content";
+export declare const HoverCard: {
+    Arrow: import("react").ForwardRefExoticComponent<import("./Arrow").HoverCardArrowProps & import("react").RefAttributes<SVGSVGElement>>;
+    Content: import("react").ForwardRefExoticComponent<import("./Content").HoverCardContentProps & import("react").RefAttributes<HTMLDivElement>>;
+    Root: import("react").FC<RadixHoverCard.HoverCardProps>;
+    Trigger: import("react").ForwardRefExoticComponent<RadixHoverCard.HoverCardTriggerProps & import("react").RefAttributes<HTMLAnchorElement>>;
+};

package/dist/HoverCard/typings.d.ts

@@ -0,0 +1,10 @@
+import { VariantProps } from "class-variance-authority";
+import { ComponentRadius } from "../Provider/typings";
+import { hoverCardContent } from "./cva";
+type Variants = VariantProps<typeof hoverCardContent>;
+export type HoverCardSize = NonNullable<Variants["size"]>;
+export interface HoverCardVariantProps {
+    size?: HoverCardSize;
+    radius?: ComponentRadius;
+}
+export {};

package/dist/HoverUtility/HoverUtility.d.ts

@@ -5,6 +5,7 @@ interface ChildProps {
     onPointerLeave: PointerEventHandler<HTMLElement>;
 }
 interface HoverUtilityProps {
+    forceHover?: boolean;
     children: (props: ChildProps) => ReactElement;
 }
 /** HoverUtility is a utility component used for detecting when an element is being hovered over or not, is passes a

package/dist/Input/Field.d.ts

@@ -0,0 +1,4 @@
+import { ComponentProps, PropsWithoutRef } from "react";
+export interface InputFieldProps extends PropsWithoutRef<ComponentProps<"input">> {
+}
+export declare const InputField: import("react").ForwardRefExoticComponent<InputFieldProps & import("react").RefAttributes<HTMLInputElement>>;

package/dist/Input/Root.d.ts

@@ -0,0 +1,6 @@
+import { ComponentProps, PropsWithoutRef } from "react";
+import { AccentColorProps } from "../typings";
+import { InputVariantProps } from "./typings";
+export interface InputRootProps extends InputVariantProps, PropsWithoutRef<ComponentProps<"div">>, AccentColorProps {
+}
+export declare const InputRoot: import("react").ForwardRefExoticComponent<InputRootProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/Input/Slot.d.ts

@@ -0,0 +1,4 @@
+import { ComponentProps, PropsWithoutRef } from "react";
+export interface InputSlotProps extends PropsWithoutRef<ComponentProps<"div">> {
+}
+export declare const InputSlot: import("react").ForwardRefExoticComponent<InputSlotProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/Input/context.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { InputSize, InputVariant } from "./typings";
+interface IInputContext {
+    size: InputSize;
+    variant: InputVariant;
+}
+export declare const InputContext: import("react").Context<IInputContext>;
+export {};

package/dist/Input/cva.d.ts

@@ -0,0 +1,12 @@
+export declare const inputRoot: (props?: ({
+    variant?: "soft" | "surface" | "outline" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export declare const inputField: (props?: ({
+    variant?: "soft" | "surface" | "outline" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export declare const inputSlot: (props?: ({
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    variant?: "soft" | "surface" | "outline" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;

package/dist/Input/index.d.ts

@@ -1,2 +1,9 @@
-export * from "./Input";
-export * from "./typings";
+/// <reference types="react" />
+export * from "./Field";
+export * from "./Root";
+export * from "./Slot";
+export declare const Input: {
+    Field: import("react").ForwardRefExoticComponent<import("./Field").InputFieldProps & import("react").RefAttributes<HTMLInputElement>>;
+    Root: import("react").ForwardRefExoticComponent<import("./Root").InputRootProps & import("react").RefAttributes<HTMLDivElement>>;
+    Slot: import("react").ForwardRefExoticComponent<import("./Slot").InputSlotProps & import("react").RefAttributes<HTMLDivElement>>;
+};