@overmap-ai/blocks 1.0.27 → 1.0.28

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 } from "./typings";
+export type { ButtonHoverEffect, ButtonProps, ButtonStyleProps } from "./typings";
 export { divButtonProps } from "./constants";

package/dist/Buttons/typings.d.ts

@@ -6,11 +6,7 @@ export interface Shortcut {
     action: () => void;
     disabled?: 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> {
-    children: RadixButtonProps["children"];
-    /** @default false */
+export interface ButtonStyleProps {
     fluid?: boolean;
     /** @default solid */
     variant?: Variant;
@@ -18,6 +14,12 @@ export interface ButtonProps extends Omit<RadixButtonProps, "size" | "variant" |
     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;
 }

package/dist/CollapsibleTree/CollapsibleTree.d.ts

@@ -0,0 +1,5 @@
+import { CollapsibleTreeProps } from "./typings";
+/** The Collapsible Tree Component is a reusable UI element that displays hierarchical data in a tree structure.
+ * Nodes in the tree can be expanded or collapsed to show or hide their children, allowing for an intuitive and
+ * space-efficient way to navigate complex data structures.*/
+export declare const CollapsibleTree: <TMeta>(props: CollapsibleTreeProps<TMeta>) => import("react/jsx-runtime").JSX.Element;

package/dist/CollapsibleTree/context.d.ts

@@ -0,0 +1,14 @@
+import { ComponentProps, CSSProperties } from "react";
+import { Flex } from "@radix-ui/themes";
+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>;
+}
+export declare const CollapsibleTreeContext: import("react").Context<ICollapsibleTreeContext<never>>;
+export declare function useCollapsibleTreeContext<TMeta>(): ICollapsibleTreeContext<TMeta>;
+export {};

package/dist/CollapsibleTree/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./CollapsibleTree";
+export * from "./typings";

package/dist/CollapsibleTree/typings.d.ts

@@ -0,0 +1,71 @@
+import { ComponentProps, CSSProperties } from "react";
+import { CollapsibleProps } from "@radix-ui/react-collapsible";
+import { Flex } from "@radix-ui/themes";
+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
+     * TreeNode collapsible. */
+    onNodeClick?: NodeEventHandler<TMeta>;
+    /** callback fired when a specific TreeNode collapsible is opened. */
+    onNodeOpen?: NodeEventHandler<TMeta>;
+    /** callback fired when a specific TreeNode collapsible is closed. */
+    onNodeClose?: NodeEventHandler<TMeta>;
+}
+export type NodeRenderer<TMeta> = (args: {
+    /** passing any meta information defined for the given node*/
+    meta: TMeta;
+    /** a function to toggle the open state of the TreeNode, useful to define what content with the TreeNode is responsible
+     * for triggering the opening and closing of the TreeNode collapsible. */
+    toggleOpen: () => void;
+    /** the current open state of the TreeNode collapsible, useful for changing rendered content within the TreeNode
+     * based on its open state. */
+    open: boolean;
+    /** the current disabled state of the TreeNode, useful for changing rendered content or functionality based on if the
+     * TreeNode is disabled or not. */
+    disabled: boolean;
+}) => {
+    children: OvermapItemProps["children"];
+    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 */
+    nodes?: TreeNodeProps<TMeta>[];
+    /** any meta-information that should be attached to a given TreeNode uses the TMeta type to specifically type
+     * the structure of this meta-data. */
+    meta: TMeta;
+}
+export interface CollapsibleTreeProps<TMeta> extends PropsWithClassNameAndStyle, Pick<OvermapItemGroupProps, "size">, 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
+     * */
+    disabled?: boolean;
+    /** A className that will be applied to every TreeNode. Useful if all the TreeNodes are required to look
+     * the same stylistically. */
+    nodeClassName?: string;
+    /** styles that will be applied to every TreeNode. Useful if there are styles that need to be applied to all
+     * for stylistic consistency TreeNodes. */
+    nodeStyles?: CSSProperties;
+    /** a callback used to determine the content rendered within a TreeNode. The callback is passed with the following arguments,
+     * @param meta - TreeNodes meta object.
+     * @param toggleOpen - function to toggle the open state of a TreeNode.
+     * @param open - the current open state of the TreeNode collapsible.
+     * @param disabled - the current disabled state of the TreeNode collapsible.
+     * */
+    nodeRenderer: NodeRenderer<TMeta>;
+}

package/dist/DialogMenu/Provider.d.ts

@@ -0,0 +1,6 @@
+import { PropsWithChildren } from "react";
+import { IDialogMenuContext } from "./context";
+interface DialogMenuContextProviderProps extends Pick<IDialogMenuContext, "size" | "closeOnSelect" | "close" | "selectedIndicator">, PropsWithChildren {
+}
+export declare const DialogMenuContextProvider: import("react").MemoExoticComponent<(props: DialogMenuContextProviderProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/DialogMenu/components/DialogCommandMenu.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { DialogCommandMenuProps } from "../typings";
+/** The Dialog Command Menu component is a flexible UI element designed to present a list of command options within a
+ * dialog overlay. This component enhances user interaction by providing a structured and accessible way to execute
+ * commands or actions from a centralized menu. */
+export declare const DialogCommandMenu: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogCommandMenuProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/components/DialogMultiSelectMenu.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { DialogMultiSelectMenuProps } from "../typings";
+/** The Dialog Multi Select Menu component is a versatile UI element that enables users to select multiple options from
+ * a list within a dialog overlay. This component enhances user interaction by providing a clear and accessible way to
+ * make multiple selections in contexts such as forms, filters, and settings. */
+export declare const DialogMultiSelectMenu: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogMultiSelectMenuProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/components/DialogSelectMenu.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { DialogSelectMenuProps } from "../typings";
+/** The Dialog Select Menu component is a user interface element that provides a dropdown single selection menu within a dialog
+ * overlay. It allows users to choose an option from a predefined list, offering an enhanced user experience through a
+ * modal dialog. This component is particularly useful in forms and settings where space is limited, and a clean,
+ * accessible selection method is needed. */
+export declare const DialogSelectMenu: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogSelectMenuProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/components/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./DialogCommandMenu";
+export * from "./DialogSelectMenu";
+export * from "./DialogMultiSelectMenu";

package/dist/DialogMenu/constants.d.ts

@@ -0,0 +1,3 @@
+import { OvermapItemSizes } from "../OvermapItem";
+export declare const DEFAULT_DIALOG_MENU_SIZE: OvermapItemSizes;
+export declare const DEFAULT_SELECTED_INDICATOR: import("react/jsx-runtime").JSX.Element;

package/dist/DialogMenu/content/Content.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { DialogMenuContentProps } from "../typings";
+export declare const ContentImpl: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogMenuContentProps & {
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<HTMLDivElement>>>;
+export declare const Content: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogMenuContentProps & {
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/content/SubContent.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { DialogMenuSubContentProps } from "../typings";
+export declare const SubContent: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogMenuSubContentProps & {
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/content/index.d.ts

@@ -0,0 +1,2 @@
+export { Content } from "./Content";
+export * from "./SubContent";

package/dist/DialogMenu/context.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { OvermapItemProps } from "../OvermapItem";
+import { CloseDialogWithOptions } from "../Dialogs";
+import { DialogSelectItemProps } from "./typings";
+export interface IDialogMenuContext {
+    size: OvermapItemProps["size"];
+    closeOnSelect: boolean;
+    close: CloseDialogWithOptions;
+    subContentId: string | null;
+    setSubContentId: (subContent: string | null) => void;
+    selectedIndicator?: DialogSelectItemProps["selectedIndicator"];
+}
+export declare const DialogMenuContext: import("react").Context<IDialogMenuContext>;
+export declare const useDialogMenuContext: () => IDialogMenuContext;

package/dist/DialogMenu/groups/Group.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { DialogGroupProps } from "../typings";
+export declare const Group: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogGroupProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/groups/MultiSelectGroup.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { DialogMultiSelectGroupProps } from "../typings";
+export declare const MultiSelectGroup: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogMultiSelectGroupProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/groups/SelectGroup.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { DialogSelectGroupProps } from "../typings";
+export declare const SelectGroup: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogSelectGroupProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/groups/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Group";
+export * from "./SelectGroup";
+export * from "./MultiSelectGroup";

package/dist/DialogMenu/index.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+export declare const DialogMenu: {
+    Root: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./typings").DialogMenuProps & import("react").RefAttributes<HTMLDivElement>>>;
+    Item: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./typings").DialogItemProps & import("react").RefAttributes<HTMLDivElement>>>;
+    SelectItem: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./typings").DialogSelectItemProps & import("react").RefAttributes<HTMLDivElement>>>;
+    MultiSelectItem: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./typings").DialogSelectItemProps & import("react").RefAttributes<HTMLDivElement>>>;
+    Separator: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<Omit<import("..").SeparatorProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>>;
+    Content: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./typings").DialogMenuContentProps & {
+        children?: import("react").ReactNode;
+    } & import("react").RefAttributes<HTMLDivElement>>>;
+    Group: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./typings").DialogGroupProps & import("react").RefAttributes<HTMLDivElement>>>;
+    SelectGroup: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./typings").DialogSelectGroupProps & import("react").RefAttributes<HTMLDivElement>>>;
+    MultiSelectGroup: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./typings").DialogMultiSelectGroupProps & import("react").RefAttributes<HTMLDivElement>>>;
+    SubTrigger: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./typings").DialogSubTriggerProps & import("react").RefAttributes<HTMLDivElement>>>;
+    SubContent: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./typings").DialogMenuSubContentProps & {
+        children?: import("react").ReactNode;
+    } & import("react").RefAttributes<HTMLDivElement>>>;
+};
+export * from "./components";
+export * from "./typings";

package/dist/DialogMenu/items/Item.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { DialogItemProps } from "../typings";
+export declare const Item: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogItemProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/items/MultiSelectItem.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { DialogSelectItemProps } from "../typings";
+export declare const MultiSelectItem: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogSelectItemProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/items/SelectItem.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { DialogSelectItemProps } from "../typings";
+export declare const SelectItem: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogSelectItemProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/items/Separator.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { SeparatorProps } from "../../Separator";
+/** A separator component to be used within Dialog Menus. */
+export declare const Separator: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<Omit<SeparatorProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/items/SubTrigger.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { DialogSubTriggerProps } from "../typings";
+export declare const SubTrigger: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogSubTriggerProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/items/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./Item";
+export * from "./SelectItem";
+export * from "./MultiSelectItem";
+export * from "./SubTrigger";
+export * from "./Separator";

package/dist/DialogMenu/root/Root.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { DialogMenuProps } from "../typings";
+/** The Dialog Menu component is a flexible and customizable UI element that allows users to trigger a dialog containing
+ * a menu of items. This component is designed to enhance user interaction by providing a structured and accessible
+ * way to present multiple items/choices/options within a dialog overlay.*/
+export declare const Root: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<DialogMenuProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/DialogMenu/root/index.d.ts

@@ -0,0 +1 @@
+export * from "./Root";

package/dist/DialogMenu/typings.d.ts

@@ -0,0 +1,59 @@
+import { OvermapItemProps } from "../OvermapItem";
+import { PropsWithChildren, ReactNode } from "react";
+import { BaseDialogProps } from "../Dialogs/BaseDialog";
+import { OvermapItemGroupProps } from "../OvermapItemGroup";
+import { OvermapInputItemProps } from "../OvermapInputItem";
+export interface DialogItemProps extends OvermapItemProps {
+    closeOnSelect?: boolean;
+    onSelect?: () => void;
+}
+export interface DialogSelectItemProps extends DialogItemProps {
+    value: string;
+    selectedIndicator?: ReactNode;
+}
+export interface DialogSubTriggerProps extends DialogItemProps {
+    subContentId: string;
+}
+export interface DialogGroupProps extends PropsWithChildren {
+    size?: OvermapItemGroupProps["size"];
+    grid?: boolean;
+}
+export interface DialogSelectGroupProps extends DialogGroupProps {
+    value: string | null;
+    onValueChange: (value: string | null) => void;
+}
+export interface DialogMultiSelectGroupProps extends DialogGroupProps {
+    values: string[];
+    onValuesChange: (values: string[]) => void;
+}
+export interface DialogMenuContentProps extends FilterProps {
+    topSlot?: ReactNode;
+    bottomSlot?: ReactNode;
+    numberOfItems: number;
+}
+export interface DialogMenuSubContentProps extends DialogMenuContentProps {
+    id: string;
+}
+export interface DialogMenuProps extends Omit<BaseDialogProps, "content"> {
+    size?: OvermapItemProps["size"];
+    closeOnSelect?: boolean;
+    content: ReactNode;
+    selectedIndicator?: DialogSelectItemProps["selectedIndicator"];
+}
+export interface DialogCommandMenuProps extends Omit<DialogMenuProps, "content" | "selectedIndicator">, Omit<DialogGroupProps, "children" | "size">, Omit<DialogMenuContentProps, "numberOfItems"> {
+    items: DialogItemProps[];
+}
+export interface DialogSelectMenuProps extends Omit<DialogMenuProps, "content">, Omit<DialogSelectGroupProps, "children" | "size">, Omit<DialogMenuContentProps, "numberOfItems"> {
+    items: DialogSelectItemProps[];
+}
+export interface DialogMultiSelectMenuProps extends Omit<DialogMenuProps, "content">, Omit<DialogMultiSelectGroupProps, "children" | "size">, Omit<DialogMenuContentProps, "numberOfItems"> {
+    items: DialogSelectItemProps[];
+}
+interface FilterProps {
+    filterValue?: string;
+    onFilterValueChange?: (filterValue: string) => void;
+    placeholder?: string;
+    leftFilterSlot?: OvermapInputItemProps["leftSlot"];
+    rightFilterSlot?: OvermapInputItemProps["rightSlot"];
+}
+export {};

package/dist/Dialogs/BaseDialog/BaseDialog.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { BaseDialogProps } from "./typings";
+export declare const BaseDialog: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<BaseDialogProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/Dialogs/BaseDialog/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./BaseDialog";
+export * from "./typings";

package/dist/Dialogs/BaseDialog/typings.d.ts

@@ -0,0 +1,31 @@
+import { CSSProperties, ReactElement, ReactNode } from "react";
+import * as RadixDialogPrimitive from "@radix-ui/react-dialog";
+import { CloseDialog, CloseDialogWithOptions } from "../typings";
+export interface BaseDialogProps {
+    /** The content to be displayed within the Overlay. A prop pattern with a passed close function that can be used to
+     * close the Overlay from the components rendering the content. pass {force: true} to the close function to avoid
+     * the onInterruptClose process when using in an uncontrolled state. NOTE: when controlling the open state of the overlay,
+     * the close function will have no effect on the open state of the Overlay */
+    content: (close: CloseDialogWithOptions) => ReactNode;
+    /** the element that should act as a trigger for opening the Overlay */
+    children?: ReactElement;
+    /** the initial open state of the Overlay */
+    defaultOpen?: RadixDialogPrimitive.DialogProps["defaultOpen"];
+    /** callback that is fired upon closing of the Overlay calls the close function to continue the closing process.
+     * If the close function is not called, the Overlay will not be closed */
+    onInterruptClose?: (close: CloseDialog) => void;
+    /** callback fired when the Overlay is being closed, if onInterruptClose is specified, it fires if the closing process
+     * is continued by calling the close function within the callback passed to onInterruptClose.
+     * */
+    onClose?: () => void;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    className?: string;
+    style?: CSSProperties;
+    /** when true, renders an unstyled overlay filling the Overlays parent container */
+    overlay?: boolean;
+    /** className to be applied to the overlay component */
+    overlayClass?: string;
+    /** style object to be applied to the overlay component */
+    overlayStyle?: CSSProperties;
+}

package/dist/Dialogs/Dialog/typings.d.ts

@@ -1,11 +1,6 @@
+import React, { ReactNode } from "react";
 import { DialogContent } from "@radix-ui/themes";
-import { CloseDialog } from "../typings";
-import { ReactNode } from "react";
-export interface CloseDialogOptions {
-    /** Bypass the `onCloseInterrupt` and force the dialog to close */
-    force?: boolean;
-}
-export type CloseDialogWithOptions = (options?: CloseDialogOptions) => void;
+import { CloseDialog, CloseDialogWithOptions } from "../typings";
 type RadixDialogContentProps = React.ComponentProps<typeof DialogContent>;
 export interface DialogProps extends Omit<RadixDialogContentProps, "content" | "children"> {
     /** The content of the dialog, which is rendered below the description.

package/dist/Dialogs/Dialog/utils.d.ts

@@ -1,4 +1,4 @@
-import { CloseDialogOptions, CloseDialogWithOptions } from "./typings.ts";
+import { CloseDialogOptions, CloseDialogWithOptions } from "../typings";
 /** This custom hook is used as a utility for wrapping a general callback in callback that accepts a close function for the
  * Blocks dialog component. Sometimes a side effect callback needs to be run upon the closure of a Dialog. This provides
  * a hook to wrap a callback with the returned close function passed to the Dialog Content. This allows the closure of

package/dist/Dialogs/Overlay/Overlay.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { BaseDialogProps } from "../BaseDialog";
+export interface OverlayProps extends BaseDialogProps {
+}
+/** The Overlay component is a versatile UI element designed to provide a layer above the existing content.
+ * It serves various purposes such as modals, popovers, tooltips, or any other temporary or context-based UI overlay.*/
+export declare const Overlay: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<OverlayProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/Dialogs/Overlay/index.d.ts

@@ -0,0 +1 @@
+export * from "./Overlay";

package/dist/Dialogs/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./Dialog/";
 export * from "./AlertDialog/";
+export * from "./Overlay";
+export * from "./typings";

package/dist/Dialogs/typings.d.ts

@@ -1,2 +1,7 @@
 /** 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;

package/dist/DownloadButtonUtility/DownloadButtonUtility.d.ts

@@ -0,0 +1,7 @@
+import { ReactElement } from "react";
+interface DownloadButtonUtilityProps {
+    children: ReactElement;
+    file: File;
+}
+export declare const DownloadButtonUtility: import("react").MemoExoticComponent<(props: DownloadButtonUtilityProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/DownloadButtonUtility/index.d.ts

@@ -0,0 +1 @@
+export * from "./DownloadButtonUtility";

package/dist/Layout/SlideOutOverlay.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="react" />
 import { PropsWithClassNameAndStyle } from "../typings";
 import { SlideOutV3Props } from "../SlideOutV3";
-export interface OverlayProps extends PropsWithClassNameAndStyle {
+export interface LayoutOverlayProps extends PropsWithClassNameAndStyle {
     active?: boolean;
     side: SlideOutV3Props["side"];
     smallModeOnly?: boolean;
 }
-export declare const SlideOutOverlay: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<OverlayProps & import("react").RefAttributes<HTMLDivElement>>>;
+export declare const SlideOutOverlay: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<LayoutOverlayProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/Layout/index.d.ts

@@ -2,7 +2,7 @@
 export declare const Layout: {
     Root: import("react").MemoExoticComponent<(props: import("./Root").RootProps) => import("react/jsx-runtime").JSX.Element>;
     Container: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<Omit<import("./Container").ContainerProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>>;
-    SlideOutOverlay: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./SlideOutOverlay").OverlayProps & import("react").RefAttributes<HTMLDivElement>>>;
+    SlideOutOverlay: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./SlideOutOverlay").LayoutOverlayProps & import("react").RefAttributes<HTMLDivElement>>>;
     LeftSlideOut: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./SlideOut").LayoutSlideOutProps & import("react").RefAttributes<HTMLDivElement>>>;
     RightSlideOut: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./SlideOut").LayoutSlideOutProps & import("react").RefAttributes<HTMLDivElement>>>;
     SlideOutTrigger: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<import("./SlideOutTrigger").SlideOutTriggerProps & import("react").RefAttributes<HTMLButtonElement>>>;

package/dist/OvermapInputItem/OvermapInputItem.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { OvermapInputItemProps } from "./typings";
+/** The OvermapInputItem component is used as a Base Component to provide an input-based element that follows the
+ * OvermapItem layout, in an item-like format. It supports responsive sizing and slot props to insert content to the
+ * left and right of its input field. */
+export declare const OvermapInputItem: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<Omit<OvermapInputItemProps, "ref"> & import("react").RefAttributes<HTMLInputElement>>>;

package/dist/OvermapInputItem/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./OvermapInputItem";
+export * from "./typings";

package/dist/OvermapInputItem/typings.d.ts

@@ -0,0 +1,4 @@
+import { HTMLProps } from "react";
+import { OvermapItemProps } from "../OvermapItem";
+export interface OvermapInputItemProps extends Pick<OvermapItemProps, "size" | "leftSlot" | "rightSlot">, Omit<HTMLProps<HTMLInputElement>, "size"> {
+}

package/dist/OvermapItem/OvermapItem.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { OvermapItemProps } from "./typings";
+/** The OvermapItem component is supposed to be used as a Base Component to layout content in an item-like format. It
+ * supports responsive sizing and slot props to insert content to the left and right of its children. */
+export declare const OvermapItem: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<OvermapItemProps & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/OvermapItem/constants.d.ts

@@ -0,0 +1,2 @@
+import { OvermapItemSizes, SizeDependableProps } from "./typings";
+export declare const OvermapItemSizeDependantProps: Record<OvermapItemSizes, SizeDependableProps>;

package/dist/OvermapItem/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./OvermapItem";
+export * from "./typings";

package/dist/OvermapItem/typings.d.ts

@@ -0,0 +1,24 @@
+import { HTMLProps, ReactNode, ComponentProps } from "react";
+import { Flex } from "@radix-ui/themes";
+import { OvermapResponsive } from "../typings";
+type FlexProps = ComponentProps<typeof Flex>;
+export interface SizeDependableProps {
+    gap: FlexProps["gap"];
+    px: FlexProps["px"];
+    height: FlexProps["height"];
+    fontSize: string;
+}
+export type OvermapItemSizes = "1" | "2" | "3" | "4" | "5";
+export interface OvermapItemProps extends Omit<HTMLProps<HTMLDivElement>, "ref" | "width" | "height" | "wrap" | "size"> {
+    /** content to be rendered on the left of any children */
+    leftSlot?: ReactNode;
+    /** content to be rendered on the right of any children */
+    rightSlot?: ReactNode;
+    /** supports five different sizes, changing the overall proportions of the OvermapItem including font size. */
+    size?: OvermapResponsive<OvermapItemSizes>;
+    /** displays the item in a "compact" mode.
+     * leftSlot and rightSlot won't be visible, and the width and height are the same
+     * based on the "size" prop.  */
+    compact?: boolean;
+}
+export {};

package/dist/OvermapItemGroup/OvermapItemGroup.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { OvermapItemGroupProps } from "./typings";
+export declare const OvermapItemGroup: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<Omit<OvermapItemGroupProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/OvermapItemGroup/context.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { OvermapItemProps } from "../OvermapItem";
+interface OvermapItemGroupContext {
+    size: OvermapItemProps["size"];
+    compact: OvermapItemProps["compact"];
+}
+export declare const OvermapItemGroupContext: import("react").Context<OvermapItemGroupContext>;
+export declare const useOvermapItemGroupContext: () => OvermapItemGroupContext;
+export {};

package/dist/OvermapItemGroup/index.d.ts

@@ -0,0 +1,3 @@
+export { useOvermapItemGroupContext } from "./context";
+export * from "./typings";
+export * from "./OvermapItemGroup";

package/dist/OvermapItemGroup/typings.d.ts

@@ -0,0 +1,7 @@
+import { ComponentProps } from "react";
+import { Grid } from "@radix-ui/themes";
+import { OvermapItemProps } from "../OvermapItem";
+export interface OvermapItemGroupProps extends ComponentProps<typeof Grid> {
+    size?: OvermapItemProps["size"];
+    compact?: OvermapItemProps["compact"];
+}

package/dist/RiIcon/RiIcon.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { IconBaseProps } from "react-icons";
+interface RemixIconProps extends IconBaseProps {
+    icon: string;
+}
+export declare const RiIcon: import("react").MemoExoticComponent<(props: RemixIconProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/RiIcon/index.d.ts

@@ -0,0 +1 @@
+export * from "./RiIcon";