@inkeep/agents-ui 0.14.20 → 0.14.22

package/dist/primitives/atoms/avatars/ai.d.ts

@@ -0,0 +1,3 @@
+import { ForwardRefExoticComponent, RefAttributes } from 'react';
+declare const AISvg: ForwardRefExoticComponent<RefAttributes<SVGSVGElement>>;
+export default AISvg;

package/dist/primitives/atoms/avatars/user.d.ts

@@ -0,0 +1,3 @@
+import { ForwardRefExoticComponent, RefAttributes } from 'react';
+declare const UserSvg: ForwardRefExoticComponent<RefAttributes<SVGSVGElement>>;
+export default UserSvg;

package/dist/primitives/atoms/cmdk/command-score.d.ts

@@ -0,0 +1 @@
+export declare function commandScore(string: string, abbreviation: string, aliases: string[]): number;

package/dist/primitives/atoms/cmdk/index.d.ts

@@ -0,0 +1,460 @@
+import { Primitive } from '@radix-ui/react-primitive';
+import * as RadixDialog from '../dialog';
+import * as React from 'react';
+type Children = {
+    children?: React.ReactNode;
+};
+type DivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;
+type CommandProps = Children & DivProps & {
+    /**
+     * Accessible label for this command menu. Not shown visibly.
+     */
+    label?: string;
+    /**
+     * Optionally set to `false` to turn off the automatic filtering and sorting.
+     * If `false`, you must conditionally render valid items based on the search query yourself.
+     */
+    shouldFilter?: boolean;
+    /**
+     * Custom filter function for whether each command menu item should matches the given search query.
+     * It should return a number between 0 and 1, with 1 being the best match and 0 being hidden entirely.
+     * By default, uses the `command-score` library.
+     */
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    /**
+     * Optional default item value when it is initially rendered.
+     */
+    defaultValue?: string;
+    /**
+     * Optional default query when it is initially rendered.
+     */
+    defaultSearch?: string;
+    /**
+     * Optional controlled state of the selected command menu item.
+     */
+    value?: string;
+    /**
+     * Event handler called when the selected item of the menu changes.
+     */
+    onValueChange?: (value: string) => void;
+    /**
+     * Optionally set to `true` to turn on looping around when using the arrow keys.
+     */
+    loop?: boolean;
+    /**
+     * Optionally set to `true` to disable selection via pointer events.
+     */
+    disablePointerSelection?: boolean;
+    /**
+     * Set to `false` to disable ctrl+n/j/p/k shortcuts. Defaults to `true`.
+     */
+    vimBindings?: boolean;
+};
+type State = {
+    search: string;
+    value: string;
+    selectedItemId?: string;
+    filtered: {
+        count: number;
+        items: Map<string, number>;
+        groups: Set<string>;
+    };
+};
+type Store = {
+    subscribe: (callback: () => void) => () => void;
+    snapshot: () => State;
+    setState: <K extends keyof State>(key: K, value: State[K], opts?: any) => void;
+    emit: () => void;
+};
+type Group = {
+    id: string;
+    forceMount?: boolean;
+};
+declare const defaultFilter: CommandProps['filter'];
+declare const useStore: () => Store;
+declare const Command: React.ForwardRefExoticComponent<Children & Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    asChild?: boolean;
+}, "ref"> & {
+    /**
+     * Accessible label for this command menu. Not shown visibly.
+     */
+    label?: string;
+    /**
+     * Optionally set to `false` to turn off the automatic filtering and sorting.
+     * If `false`, you must conditionally render valid items based on the search query yourself.
+     */
+    shouldFilter?: boolean;
+    /**
+     * Custom filter function for whether each command menu item should matches the given search query.
+     * It should return a number between 0 and 1, with 1 being the best match and 0 being hidden entirely.
+     * By default, uses the `command-score` library.
+     */
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    /**
+     * Optional default item value when it is initially rendered.
+     */
+    defaultValue?: string;
+    /**
+     * Optional default query when it is initially rendered.
+     */
+    defaultSearch?: string;
+    /**
+     * Optional controlled state of the selected command menu item.
+     */
+    value?: string;
+    /**
+     * Event handler called when the selected item of the menu changes.
+     */
+    onValueChange?: (value: string) => void;
+    /**
+     * Optionally set to `true` to turn on looping around when using the arrow keys.
+     */
+    loop?: boolean;
+    /**
+     * Optionally set to `true` to disable selection via pointer events.
+     */
+    disablePointerSelection?: boolean;
+    /**
+     * Set to `false` to disable ctrl+n/j/p/k shortcuts. Defaults to `true`.
+     */
+    vimBindings?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Command menu item. Becomes active on pointer enter or through keyboard navigation.
+ * Preferably pass a `value`, otherwise the value will be inferred from `children` or
+ * the rendered item's `textContent`.
+ */
+declare const Item: React.ForwardRefExoticComponent<Children & Omit<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    asChild?: boolean;
+}, "ref">, "value" | "disabled" | "onSelect"> & {
+    /** Whether this item is currently disabled. */
+    disabled?: boolean;
+    /** Event handler for when this item is selected, either via click or keyboard selection. */
+    onSelect?: (details: {
+        value: string;
+        trigger: "click" | "keyboard";
+    }) => void;
+    /**
+     * A unique value for this item.
+     * If no value is provided, it will be inferred from `children` or the rendered `textContent`. If your `textContent` changes between renders, you _must_ provide a stable, unique `value`.
+     */
+    value?: string;
+    /** Optional keywords to match against when filtering. */
+    keywords?: string[];
+    /** Whether this item is forcibly rendered regardless of filtering. */
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Group command menu items together with a heading.
+ * Grouped items are always shown together.
+ */
+declare const Group: React.ForwardRefExoticComponent<Children & Omit<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    asChild?: boolean;
+}, "ref">, "value" | "heading"> & {
+    /** Optional heading to render for this group. */
+    heading?: React.ReactNode;
+    /** If no heading is provided, you must provide a value that is unique for this group. */
+    value?: string;
+    /** Whether this group is forcibly rendered regardless of filtering. */
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+/**
+ * A visual and semantic separator between items or groups.
+ * Visible when the search query is empty or `alwaysRender` is true, hidden otherwise.
+ */
+declare const Separator: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    asChild?: boolean;
+}, "ref"> & {
+    /** Whether this separator should always be rendered. Useful if you disable automatic filtering. */
+    alwaysRender?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Command menu input.
+ * All props are forwarded to the underyling `input` element.
+ */
+declare const Input: React.ForwardRefExoticComponent<Omit<Omit<React.ClassAttributes<HTMLInputElement> & React.InputHTMLAttributes<HTMLInputElement> & {
+    asChild?: boolean;
+}, "ref">, "type" | "value" | "onChange"> & {
+    /**
+     * Optional controlled state for the value of the search input.
+     */
+    value?: string;
+    /**
+     * Event handler called when the search value changes.
+     */
+    onValueChange?: (search: string) => void;
+} & React.RefAttributes<HTMLInputElement>>;
+/**
+ * Contains `Item`, `Group`, and `Separator`.
+ * Use the `--cmdk-list-height` CSS variable to animate height based on the number of results.
+ */
+declare const List: React.ForwardRefExoticComponent<Children & Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    asChild?: boolean;
+}, "ref"> & {
+    /**
+     * Accessible label for this List of suggestions. Not shown visibly.
+     */
+    label?: string;
+} & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Renders the command menu in a Radix Dialog.
+ */
+declare const Dialog: React.ForwardRefExoticComponent<RadixDialog.DialogProps & Children & Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    asChild?: boolean;
+}, "ref"> & {
+    /**
+     * Accessible label for this command menu. Not shown visibly.
+     */
+    label?: string;
+    /**
+     * Optionally set to `false` to turn off the automatic filtering and sorting.
+     * If `false`, you must conditionally render valid items based on the search query yourself.
+     */
+    shouldFilter?: boolean;
+    /**
+     * Custom filter function for whether each command menu item should matches the given search query.
+     * It should return a number between 0 and 1, with 1 being the best match and 0 being hidden entirely.
+     * By default, uses the `command-score` library.
+     */
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    /**
+     * Optional default item value when it is initially rendered.
+     */
+    defaultValue?: string;
+    /**
+     * Optional default query when it is initially rendered.
+     */
+    defaultSearch?: string;
+    /**
+     * Optional controlled state of the selected command menu item.
+     */
+    value?: string;
+    /**
+     * Event handler called when the selected item of the menu changes.
+     */
+    onValueChange?: (value: string) => void;
+    /**
+     * Optionally set to `true` to turn on looping around when using the arrow keys.
+     */
+    loop?: boolean;
+    /**
+     * Optionally set to `true` to disable selection via pointer events.
+     */
+    disablePointerSelection?: boolean;
+    /**
+     * Set to `false` to disable ctrl+n/j/p/k shortcuts. Defaults to `true`.
+     */
+    vimBindings?: boolean;
+} & {
+    /** Provide a className to the Dialog overlay. */
+    overlayClassName?: string;
+    /** Provide a className to the Dialog content. */
+    contentClassName?: string;
+    /** Provide a custom element the Dialog should portal into. */
+    container?: HTMLElement;
+} & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Automatically renders when there are no results for the search query.
+ */
+declare const Empty: React.ForwardRefExoticComponent<Children & Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    asChild?: boolean;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * You should conditionally render this with `progress` while loading asynchronous items.
+ */
+declare const Loading: React.ForwardRefExoticComponent<Children & Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    asChild?: boolean;
+}, "ref"> & {
+    /** Estimated progress of loading asynchronous options. */
+    progress?: number;
+    /**
+     * Accessible label for this loading progressbar. Not shown visibly.
+     */
+    label?: string;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const pkg: React.ForwardRefExoticComponent<Children & Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    asChild?: boolean;
+}, "ref"> & {
+    /**
+     * Accessible label for this command menu. Not shown visibly.
+     */
+    label?: string;
+    /**
+     * Optionally set to `false` to turn off the automatic filtering and sorting.
+     * If `false`, you must conditionally render valid items based on the search query yourself.
+     */
+    shouldFilter?: boolean;
+    /**
+     * Custom filter function for whether each command menu item should matches the given search query.
+     * It should return a number between 0 and 1, with 1 being the best match and 0 being hidden entirely.
+     * By default, uses the `command-score` library.
+     */
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    /**
+     * Optional default item value when it is initially rendered.
+     */
+    defaultValue?: string;
+    /**
+     * Optional default query when it is initially rendered.
+     */
+    defaultSearch?: string;
+    /**
+     * Optional controlled state of the selected command menu item.
+     */
+    value?: string;
+    /**
+     * Event handler called when the selected item of the menu changes.
+     */
+    onValueChange?: (value: string) => void;
+    /**
+     * Optionally set to `true` to turn on looping around when using the arrow keys.
+     */
+    loop?: boolean;
+    /**
+     * Optionally set to `true` to disable selection via pointer events.
+     */
+    disablePointerSelection?: boolean;
+    /**
+     * Set to `false` to disable ctrl+n/j/p/k shortcuts. Defaults to `true`.
+     */
+    vimBindings?: boolean;
+} & React.RefAttributes<HTMLDivElement>> & {
+    List: React.ForwardRefExoticComponent<Children & Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+        asChild?: boolean;
+    }, "ref"> & {
+        /**
+         * Accessible label for this List of suggestions. Not shown visibly.
+         */
+        label?: string;
+    } & React.RefAttributes<HTMLDivElement>>;
+    Item: React.ForwardRefExoticComponent<Children & Omit<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+        asChild?: boolean;
+    }, "ref">, "value" | "disabled" | "onSelect"> & {
+        /** Whether this item is currently disabled. */
+        disabled?: boolean;
+        /** Event handler for when this item is selected, either via click or keyboard selection. */
+        onSelect?: (details: {
+            value: string;
+            trigger: "click" | "keyboard";
+        }) => void;
+        /**
+         * A unique value for this item.
+         * If no value is provided, it will be inferred from `children` or the rendered `textContent`. If your `textContent` changes between renders, you _must_ provide a stable, unique `value`.
+         */
+        value?: string;
+        /** Optional keywords to match against when filtering. */
+        keywords?: string[];
+        /** Whether this item is forcibly rendered regardless of filtering. */
+        forceMount?: boolean;
+    } & React.RefAttributes<HTMLDivElement>>;
+    Input: React.ForwardRefExoticComponent<Omit<Omit<React.ClassAttributes<HTMLInputElement> & React.InputHTMLAttributes<HTMLInputElement> & {
+        asChild?: boolean;
+    }, "ref">, "type" | "value" | "onChange"> & {
+        /**
+         * Optional controlled state for the value of the search input.
+         */
+        value?: string;
+        /**
+         * Event handler called when the search value changes.
+         */
+        onValueChange?: (search: string) => void;
+    } & React.RefAttributes<HTMLInputElement>>;
+    Group: React.ForwardRefExoticComponent<Children & Omit<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+        asChild?: boolean;
+    }, "ref">, "value" | "heading"> & {
+        /** Optional heading to render for this group. */
+        heading?: React.ReactNode;
+        /** If no heading is provided, you must provide a value that is unique for this group. */
+        value?: string;
+        /** Whether this group is forcibly rendered regardless of filtering. */
+        forceMount?: boolean;
+    } & React.RefAttributes<HTMLDivElement>>;
+    Separator: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+        asChild?: boolean;
+    }, "ref"> & {
+        /** Whether this separator should always be rendered. Useful if you disable automatic filtering. */
+        alwaysRender?: boolean;
+    } & React.RefAttributes<HTMLDivElement>>;
+    Dialog: React.ForwardRefExoticComponent<RadixDialog.DialogProps & Children & Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+        asChild?: boolean;
+    }, "ref"> & {
+        /**
+         * Accessible label for this command menu. Not shown visibly.
+         */
+        label?: string;
+        /**
+         * Optionally set to `false` to turn off the automatic filtering and sorting.
+         * If `false`, you must conditionally render valid items based on the search query yourself.
+         */
+        shouldFilter?: boolean;
+        /**
+         * Custom filter function for whether each command menu item should matches the given search query.
+         * It should return a number between 0 and 1, with 1 being the best match and 0 being hidden entirely.
+         * By default, uses the `command-score` library.
+         */
+        filter?: (value: string, search: string, keywords?: string[]) => number;
+        /**
+         * Optional default item value when it is initially rendered.
+         */
+        defaultValue?: string;
+        /**
+         * Optional default query when it is initially rendered.
+         */
+        defaultSearch?: string;
+        /**
+         * Optional controlled state of the selected command menu item.
+         */
+        value?: string;
+        /**
+         * Event handler called when the selected item of the menu changes.
+         */
+        onValueChange?: (value: string) => void;
+        /**
+         * Optionally set to `true` to turn on looping around when using the arrow keys.
+         */
+        loop?: boolean;
+        /**
+         * Optionally set to `true` to disable selection via pointer events.
+         */
+        disablePointerSelection?: boolean;
+        /**
+         * Set to `false` to disable ctrl+n/j/p/k shortcuts. Defaults to `true`.
+         */
+        vimBindings?: boolean;
+    } & {
+        /** Provide a className to the Dialog overlay. */
+        overlayClassName?: string;
+        /** Provide a className to the Dialog content. */
+        contentClassName?: string;
+        /** Provide a custom element the Dialog should portal into. */
+        container?: HTMLElement;
+    } & React.RefAttributes<HTMLDivElement>>;
+    Empty: React.ForwardRefExoticComponent<Children & Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+        asChild?: boolean;
+    }, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Loading: React.ForwardRefExoticComponent<Children & Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+        asChild?: boolean;
+    }, "ref"> & {
+        /** Estimated progress of loading asynchronous options. */
+        progress?: number;
+        /**
+         * Accessible label for this loading progressbar. Not shown visibly.
+         */
+        label?: string;
+    } & React.RefAttributes<HTMLDivElement>>;
+};
+export { useCmdk as useCommandState };
+export { useStore as useCommandStore };
+export { pkg as Command };
+export { defaultFilter };
+export { Command as CommandRoot };
+export { List as CommandList };
+export { Item as CommandItem };
+export { Input as CommandInput };
+export type { Group as CommandGroup };
+export { Separator as CommandSeparator };
+export { Dialog as CommandDialog };
+export { Empty as CommandEmpty };
+export { Loading as CommandLoading };
+/** Run a selector against the store state. */
+declare function useCmdk<T = any>(selector: (state: State) => T): T;

package/dist/primitives/atoms/codeblock/index.d.ts

@@ -0,0 +1,10 @@
+export interface CodeProps {
+    className?: string;
+    children: string;
+    /**
+     * Callback when the code is copied.
+     * Receives the current language and code that's copied.
+     */
+    onCopy?: (language: string, code: string) => void;
+}
+export declare const CodeBlock: ({ className, children, onCopy }: CodeProps) => import("react/jsx-runtime").JSX.Element;

package/dist/primitives/atoms/custom-styles.d.ts

@@ -0,0 +1,5 @@
+export declare function useCustomStyles(): {
+    customStyles: import("react/jsx-runtime").JSX.Element | null;
+    loaded: boolean;
+};
+export declare function useCompareMemoize<T>(value: T): T;

package/dist/primitives/atoms/dialog.d.ts

@@ -0,0 +1,94 @@
+import { DismissableLayer } from '@radix-ui/react-dismissable-layer';
+import { TrapFocusOptions } from '@zag-js/focus-trap';
+import { Portal as PortalPrimitive } from '@radix-ui/react-portal';
+import { Primitive } from '@radix-ui/react-primitive';
+import { CreateScope } from '@radix-ui/react-context';
+import * as React from 'react';
+declare const createDialogScope: CreateScope;
+interface DialogProps {
+    children?: React.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?(open: boolean): void;
+    modal?: boolean;
+}
+declare const Dialog: React.FC<DialogProps>;
+type PrimitiveButtonProps = React.ComponentPropsWithoutRef<typeof Primitive.button>;
+interface DialogTriggerProps extends PrimitiveButtonProps {
+}
+declare const DialogTrigger: React.ForwardRefExoticComponent<DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+type PortalProps = React.ComponentPropsWithoutRef<typeof PortalPrimitive>;
+interface DialogPortalProps {
+    children?: React.ReactNode;
+    /**
+     * Specify a container element to portal the content into.
+     */
+    container?: PortalProps['container'];
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with React animation libraries.
+     */
+    forceMount?: true;
+}
+declare const DialogPortal: React.FC<DialogPortalProps>;
+interface DialogOverlayProps extends DialogOverlayImplProps {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with React animation libraries.
+     */
+    forceMount?: true;
+}
+declare const DialogOverlay: React.ForwardRefExoticComponent<DialogOverlayProps & React.RefAttributes<HTMLDivElement>>;
+type PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;
+interface DialogOverlayImplProps extends PrimitiveDivProps {
+}
+interface DialogContentProps extends DialogContentTypeProps {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with React animation libraries.
+     */
+    forceMount?: true;
+}
+declare const DialogContent: React.ForwardRefExoticComponent<DialogContentProps & React.RefAttributes<HTMLDivElement>>;
+interface DialogContentTypeProps extends Omit<DialogContentImplProps, 'trapFocus' | 'disableOutsidePointerEvents'> {
+}
+type DismissableLayerProps = React.ComponentPropsWithoutRef<typeof DismissableLayer>;
+interface DialogContentImplProps extends Omit<DismissableLayerProps, 'onDismiss'> {
+    /**
+     * When `true`, focus cannot escape the `Content` via keyboard,
+     * pointer, or a programmatic focus.
+     * @defaultValue false
+     */
+    trapFocus?: boolean;
+    /**
+     * Event handler called when auto-focusing on open.
+     * Can be prevented.
+     */
+    onOpenAutoFocus?: TrapFocusOptions['onActivate'];
+    /**
+     * Event handler called when auto-focusing on close.
+     * Can be prevented.
+     */
+    onCloseAutoFocus?: TrapFocusOptions['onDeactivate'];
+}
+type PrimitiveHeading2Props = React.ComponentPropsWithoutRef<typeof Primitive.h2>;
+interface DialogTitleProps extends PrimitiveHeading2Props {
+}
+declare const DialogTitle: React.ForwardRefExoticComponent<DialogTitleProps & React.RefAttributes<HTMLHeadingElement>>;
+type PrimitiveParagraphProps = React.ComponentPropsWithoutRef<typeof Primitive.p>;
+interface DialogDescriptionProps extends PrimitiveParagraphProps {
+}
+declare const DialogDescription: React.ForwardRefExoticComponent<DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;
+interface DialogCloseProps extends PrimitiveButtonProps {
+}
+declare const DialogClose: React.ForwardRefExoticComponent<DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Root: React.FC<DialogProps>;
+declare const Trigger: React.ForwardRefExoticComponent<DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Portal: React.FC<DialogPortalProps>;
+declare const Overlay: React.ForwardRefExoticComponent<DialogOverlayProps & React.RefAttributes<HTMLDivElement>>;
+declare const Content: React.ForwardRefExoticComponent<DialogContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Title: React.ForwardRefExoticComponent<DialogTitleProps & React.RefAttributes<HTMLHeadingElement>>;
+declare const Description: React.ForwardRefExoticComponent<DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;
+declare const Close: React.ForwardRefExoticComponent<DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+export { createDialogScope, Dialog, DialogTrigger, DialogPortal, DialogOverlay, DialogContent, DialogTitle, DialogDescription, DialogClose, Root, Trigger, Portal, Overlay, Content, Title, Description, Close, };
+export type { DialogProps, DialogTriggerProps, DialogPortalProps, DialogOverlayProps, DialogContentProps, DialogTitleProps, DialogDescriptionProps, DialogCloseProps, };

package/dist/primitives/atoms/error-boundary.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode, FC } from 'react';
+interface ErrorBoundaryProps {
+    children: ReactNode;
+}
+export declare const ErrorBoundary: FC<ErrorBoundaryProps>;
+export {};

package/dist/primitives/atoms/icons/built-in-icon-renderer.d.ts

@@ -0,0 +1,6 @@
+import { InkeepCustomIcon } from '../../../types/index.ts';
+import { MemoExoticComponent } from 'react';
+export declare const BuiltInIconRenderer: MemoExoticComponent<({ iconSettings, ...props }: {
+    iconSettings: InkeepCustomIcon;
+    className?: string;
+}) => import("react/jsx-runtime").JSX.Element | null>;