@libreapps/ui 5.4.1

package/dist/primitives/input-group.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { type VariantProps } from 'class-variance-authority';
+import { Button } from './button';
+declare function InputGroup({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare const inputGroupAddonVariants: (props?: ({
+    align?: "block-end" | "block-start" | "inline-end" | "inline-start" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function InputGroupAddon({ className, align, ...props }: React.ComponentProps<'div'> & VariantProps<typeof inputGroupAddonVariants>): import("react/jsx-runtime").JSX.Element;
+declare const inputGroupButtonVariants: (props?: ({
+    size?: "sm" | "icon-sm" | "xs" | "icon-xs" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function InputGroupButton({ className, type, variant, size, ...props }: Omit<React.ComponentProps<typeof Button>, 'size'> & VariantProps<typeof inputGroupButtonVariants>): import("react/jsx-runtime").JSX.Element;
+declare function InputGroupText({ className, ...props }: React.ComponentProps<'span'>): import("react/jsx-runtime").JSX.Element;
+declare function InputGroupInput({ className, ...props }: React.ComponentProps<'input'>): import("react/jsx-runtime").JSX.Element;
+declare function InputGroupTextarea({ className, ...props }: React.ComponentProps<'textarea'>): import("react/jsx-runtime").JSX.Element;
+export { InputGroup, InputGroupAddon, InputGroupButton, InputGroupText, InputGroupInput, InputGroupTextarea, };

package/dist/primitives/input-otp.d.ts

@@ -0,0 +1,34 @@
+import * as React from 'react';
+declare const InputOTP: React.ForwardRefExoticComponent<(Omit<Omit<React.InputHTMLAttributes<HTMLInputElement>, "onChange" | "value" | "textAlign" | "onComplete" | "maxLength" | "pushPasswordManagerStrategy" | "pasteTransformer" | "containerClassName" | "noScriptCSSFallback"> & {
+    value?: string;
+    onChange?: (newValue: string) => unknown;
+    maxLength: number;
+    textAlign?: "left" | "center" | "right";
+    onComplete?: (...args: any[]) => unknown;
+    pushPasswordManagerStrategy?: "increase-width" | "none";
+    pasteTransformer?: (pasted: string) => string;
+    containerClassName?: string;
+    noScriptCSSFallback?: string | null;
+} & {
+    render: (props: import("input-otp").RenderProps) => React.ReactNode;
+    children?: never;
+} & React.RefAttributes<HTMLInputElement>, "ref"> | Omit<Omit<React.InputHTMLAttributes<HTMLInputElement>, "onChange" | "value" | "textAlign" | "onComplete" | "maxLength" | "pushPasswordManagerStrategy" | "pasteTransformer" | "containerClassName" | "noScriptCSSFallback"> & {
+    value?: string;
+    onChange?: (newValue: string) => unknown;
+    maxLength: number;
+    textAlign?: "left" | "center" | "right";
+    onComplete?: (...args: any[]) => unknown;
+    pushPasswordManagerStrategy?: "increase-width" | "none";
+    pasteTransformer?: (pasted: string) => string;
+    containerClassName?: string;
+    noScriptCSSFallback?: string | null;
+} & {
+    render?: never;
+    children: React.ReactNode;
+} & React.RefAttributes<HTMLInputElement>, "ref">) & React.RefAttributes<HTMLInputElement>>;
+declare const InputOTPGroup: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const InputOTPSlot: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    index: number;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const InputOTPSeparator: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { InputOTP, InputOTPGroup, InputOTPSlot, InputOTPSeparator };

package/dist/primitives/input.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import type { RefCallBack } from 'react-hook-form';
+export interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+    startAdornment?: React.ReactNode;
+    endAdornment?: React.ReactNode;
+    hidePasswordToggle?: boolean;
+    ref?: React.RefObject<HTMLInputElement | null> | RefCallBack;
+}
+declare const Input: {
+    ({ className, type, startAdornment, endAdornment, hidePasswordToggle, ref, ...props }: InputProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Input };
+export default Input;

package/dist/primitives/item.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { type VariantProps } from 'class-variance-authority';
+import { Separator } from './separator';
+declare function ItemGroup({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function ItemSeparator({ className, ...props }: React.ComponentProps<typeof Separator>): import("react/jsx-runtime").JSX.Element;
+declare const itemVariants: (props?: ({
+    variant?: "default" | "outline" | "muted" | null | undefined;
+    size?: "default" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Item({ className, variant, size, asChild, ...props }: React.ComponentProps<'div'> & VariantProps<typeof itemVariants> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare const itemMediaVariants: (props?: ({
+    variant?: "image" | "default" | "icon" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function ItemMedia({ className, variant, ...props }: React.ComponentProps<'div'> & VariantProps<typeof itemMediaVariants>): import("react/jsx-runtime").JSX.Element;
+declare function ItemContent({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function ItemTitle({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function ItemDescription({ className, ...props }: React.ComponentProps<'p'>): import("react/jsx-runtime").JSX.Element;
+declare function ItemActions({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function ItemHeader({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function ItemFooter({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+export { Item, ItemMedia, ItemContent, ItemActions, ItemGroup, ItemSeparator, ItemTitle, ItemDescription, ItemHeader, ItemFooter, };

package/dist/primitives/kbd.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+declare function Kbd({ className, ...props }: React.ComponentProps<"kbd">): import("react/jsx-runtime").JSX.Element;
+declare function KbdGroup({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+export { Kbd, KbdGroup };

package/dist/primitives/label.d.ts

@@ -0,0 +1,10 @@
+import * as LabelPrimitive from '@radix-ui/react-label';
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const labelVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+declare const Label: {
+    ({ className, ...props }: React.ComponentProps<typeof LabelPrimitive.Root> & VariantProps<typeof labelVariants>): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+export { Label };
+export default Label;

package/dist/primitives/list-adaptor.d.ts

@@ -0,0 +1,9 @@
+interface ListAdaptor<T> {
+    getValue: (el: T) => string;
+    equals: (el1: T, el2: T) => boolean;
+    valueEquals: (el: T, v: string) => boolean;
+    getLabel?: (el: T) => string;
+    getImageUrl?: (el: T) => string | null;
+    isDisabled?: (el: T) => boolean;
+}
+export { type ListAdaptor as default };

package/dist/primitives/list-box.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+declare function ListBox<T>({ values, labels, onValueChange, value, isEqual, clx, itemClx }: {
+    values: T[];
+    labels: string[];
+    onValueChange: (val: T) => void;
+    value: T | undefined;
+    isEqual: (v1: T, v2: T) => boolean;
+    clx?: string;
+    itemClx?: string;
+}): React.ReactElement;
+export default ListBox;

package/dist/primitives/loading-spinner.d.ts

@@ -0,0 +1,5 @@
+declare const LoadingSpinner: React.FC<{
+    size?: number;
+    className?: string;
+} & React.SVGProps<SVGSVGElement>>;
+export default LoadingSpinner;

package/dist/primitives/markdown-preview.d.ts

@@ -0,0 +1,128 @@
+import { Primitive } from '@radix-ui/react-primitive';
+import { Element } from 'hast';
+import React, { type ComponentPropsWithoutRef, type ComponentType, type ElementType, type FC, type ReactNode } from 'react';
+import { Options } from 'react-markdown';
+import { type SyntaxHighlighterProps as SHP } from 'react-syntax-highlighter';
+export type CodeHeaderProps = {
+    node?: Element | undefined;
+    language: string | undefined;
+    code: string;
+};
+export declare const CodeHeader: FC<CodeHeaderProps>;
+export declare const makePrismAsyncLightSyntaxHighlighter: (config: Omit<SHP, "language" | "children">) => React.FC<SyntaxHighlighterProps>;
+export declare const SyntaxHighlighterBase: React.FC<SyntaxHighlighterProps>;
+export declare const defaultComponents: {
+    h1: ({ className, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+    h2: ({ className, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+    h3: ({ className, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+    h4: ({ className, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+    h5: ({ className, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+    h6: ({ className, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+    p: ({ className, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+    a: ({ className, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+    blockquote: ({ className, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+    ul: ({ className, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+    ol: ({ className, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+    hr: ({ className, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+    table: ({ className, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+    thead: ({ className, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+    th: ({ className, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+    td: ({ className, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+    tr: ({ className, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+    sup: ({ className, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+    pre: ({ className, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+    code: ({ className, ...props }: any) => import("react/jsx-runtime").JSX.Element;
+    CodeHeader: React.FC<CodeHeaderProps>;
+    SyntaxHighlighter: React.FC<SyntaxHighlighterProps>;
+};
+export type PreComponent = ComponentType<ComponentPropsWithoutRef<'pre'> & {
+    node?: Element | undefined;
+}>;
+export type CodeComponent = ComponentType<ComponentPropsWithoutRef<'code'> & {
+    node?: Element | undefined;
+}>;
+export declare const PreContext: React.Context<Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLPreElement>, HTMLPreElement>, "ref"> & {
+    node?: Element | undefined;
+}, "children"> | null>;
+export declare const IsRunningContext: React.Context<boolean | undefined>;
+export declare const useIsMarkdownCodeBlock: () => boolean;
+export declare const useIsRunning: () => boolean | undefined;
+export declare const PreOverride: PreComponent;
+export declare const DefaultPre: PreComponent;
+export declare const DefaultCode: CodeComponent;
+export declare const DefaultCodeBlockContent: ComponentType<{
+    node: Element | undefined;
+    components: {
+        Pre: PreComponent;
+        Code: CodeComponent;
+    };
+    code: string | ReactNode | undefined;
+}>;
+export declare const DefaultCodeHeader: ComponentType<CodeHeaderProps>;
+type PrimitiveDivProps = ComponentPropsWithoutRef<typeof Primitive.div>;
+export type MarkdownTextPrimitiveProps = Omit<Options, 'components' | 'children'> & {
+    className?: string;
+    containerProps?: Omit<PrimitiveDivProps, 'children' | 'asChild'> | undefined;
+    containerComponent?: ElementType;
+    componentsByLanguage?: Record<string, {
+        CodeHeader?: ComponentType<CodeHeaderProps> | undefined;
+        SyntaxHighlighter?: ComponentType<SyntaxHighlighterProps> | undefined;
+    }> | undefined;
+    components?: (NonNullable<Options['components']> & {
+        SyntaxHighlighter?: ComponentType<SyntaxHighlighterProps> | undefined;
+        CodeHeader?: ComponentType<CodeHeaderProps> | undefined;
+    }) | undefined;
+    content: string;
+    ref?: React.RefObject<HTMLDivElement>;
+};
+export type CodeOverrideProps = ComponentPropsWithoutRef<CodeComponent> & {
+    components: {
+        Pre: PreComponent;
+        Code: CodeComponent;
+        CodeHeader: ComponentType<CodeHeaderProps>;
+        SyntaxHighlighter: ComponentType<SyntaxHighlighterProps>;
+    };
+    componentsByLanguage?: Record<string, {
+        CodeHeader?: ComponentType<CodeHeaderProps>;
+        SyntaxHighlighter?: ComponentType<SyntaxHighlighterProps>;
+    }> | undefined;
+};
+export type SyntaxHighlighterProps = {
+    components: {
+        Pre: PreComponent;
+        Code: CodeComponent;
+    };
+    language: string;
+    code: string;
+    isRunning?: boolean;
+};
+export type CodeBlockProps = {
+    node: Element | undefined;
+    language: string;
+    code: string;
+    components: {
+        Pre: PreComponent;
+        Code: CodeComponent;
+        CodeHeader: ComponentType<CodeHeaderProps>;
+        SyntaxHighlighter: ComponentType<SyntaxHighlighterProps>;
+    };
+    isRunning?: boolean;
+};
+export declare const DefaultCodeBlock: FC<CodeBlockProps>;
+export declare const withDefaultProps: <TProps extends {
+    className?: string | undefined;
+}>({ className, ...defaultProps }: Partial<TProps>) => ({ className: classNameProp, ...props }: TProps) => TProps;
+export declare const CodeOverrideBase: FC<CodeOverrideProps>;
+export declare const CodeOverride: React.NamedExoticComponent<CodeOverrideProps>;
+export declare const MarkdownTextPrimitive: {
+    ({ components: userComponents, className, containerProps, containerComponent: Container, content, componentsByLanguage, ref, isRunning, ...rest }: MarkdownTextPrimitiveProps & {
+        isRunning?: boolean;
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export type MakeMarkdownTextProps = MarkdownTextPrimitiveProps & {
+    isRunning?: boolean;
+};
+export declare const MarkdownTextBase: ({ className, isRunning, components: userComponents, ...rest }: MakeMarkdownTextProps) => import("react/jsx-runtime").JSX.Element;
+export declare const MarkdownText: React.MemoExoticComponent<({ className, isRunning, components: userComponents, ...rest }: MakeMarkdownTextProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/primitives/menubar.d.ts

@@ -0,0 +1,28 @@
+import * as React from "react";
+import * as MenubarPrimitive from "@radix-ui/react-menubar";
+declare function MenubarMenu({ ...props }: React.ComponentProps<typeof MenubarPrimitive.Menu>): import("react/jsx-runtime").JSX.Element;
+declare function MenubarGroup({ ...props }: React.ComponentProps<typeof MenubarPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function MenubarPortal({ ...props }: React.ComponentProps<typeof MenubarPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare function MenubarRadioGroup({ ...props }: React.ComponentProps<typeof MenubarPrimitive.RadioGroup>): import("react/jsx-runtime").JSX.Element;
+declare function MenubarSub({ ...props }: React.ComponentProps<typeof MenubarPrimitive.Sub>): import("react/jsx-runtime").JSX.Element;
+declare const Menubar: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarTrigger: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const MenubarSubTrigger: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarSubContent: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarContent: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarItem: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarCheckboxItem: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarRadioItem: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarLabel: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarSeparator: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const MenubarShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Menubar, MenubarMenu, MenubarTrigger, MenubarContent, MenubarItem, MenubarSeparator, MenubarLabel, MenubarCheckboxItem, MenubarRadioGroup, MenubarRadioItem, MenubarPortal, MenubarSubContent, MenubarSubTrigger, MenubarGroup, MenubarSub, MenubarShortcut, };

package/dist/primitives/mermaid.d.ts

@@ -0,0 +1,7 @@
+import { FC } from 'react';
+import { SyntaxHighlighterProps } from './markdown-preview';
+export type MermaidDiagramProps = SyntaxHighlighterProps & {
+    className?: string;
+    isRunning?: boolean;
+};
+export declare const MermaidDiagram: FC<MermaidDiagramProps>;

package/dist/primitives/native-select.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+export interface NativeSelectProps extends Omit<React.ComponentProps<"select">, "size"> {
+    size?: "sm" | "default";
+}
+declare const NativeSelect: React.ForwardRefExoticComponent<Omit<NativeSelectProps, "ref"> & React.RefAttributes<HTMLSelectElement>>;
+declare const NativeSelectOption: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.OptionHTMLAttributes<HTMLOptionElement>, HTMLOptionElement>, "ref"> & React.RefAttributes<HTMLOptionElement>>;
+declare const NativeSelectOptGroup: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.OptgroupHTMLAttributes<HTMLOptGroupElement>, HTMLOptGroupElement>, "ref"> & React.RefAttributes<HTMLOptGroupElement>>;
+export { NativeSelect, NativeSelectOptGroup, NativeSelectOption };

package/dist/primitives/navigation-menu.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import * as NavigationMenuPrimitive from '@radix-ui/react-navigation-menu';
+declare const NavigationMenu: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuProps & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const NavigationMenuList: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuListProps & React.RefAttributes<HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const NavigationMenuItem: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuItemProps & React.RefAttributes<HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+declare const navigationMenuTriggerStyle: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+declare const NavigationMenuTrigger: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const NavigationMenuContent: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const NavigationMenuLink: React.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+declare const NavigationMenuViewport: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuViewportProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const NavigationMenuIndicator: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuIndicatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { navigationMenuTriggerStyle, NavigationMenu, NavigationMenuList, NavigationMenuItem, NavigationMenuContent, NavigationMenuTrigger, NavigationMenuLink, NavigationMenuIndicator, NavigationMenuViewport, };

package/dist/primitives/next/image.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { ImageDef, Dimensions, MediaTransform } from '../../types';
+declare const Image: React.FC<{
+    def: ImageDef;
+    constrainTo?: Dimensions;
+    transform?: MediaTransform;
+    fullWidth?: boolean;
+    className?: string;
+    preload?: boolean;
+}>;
+export default Image;

package/dist/primitives/next/index.d.ts

@@ -0,0 +1,7 @@
+export { default as Image } from './image';
+export { default as InlineIcon } from './inline-icon';
+export { default as LinkElement } from './link-element';
+export { default as MDXLink } from './mdx-link';
+export { default as MediaStack } from './media-stack';
+export { default as NavItems } from './nav-items';
+export { default as YouTubeEmbed } from './youtube-embed';

package/dist/primitives/next/inline-icon.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+declare const InlineIcon: React.FC<{
+    /**
+     * If a ReactNode is passed in, it should be set to 'w-full h-auto' so that it can be sized
+     * according to width of parent.
+     */
+    icon: React.ReactNode;
+    /** default should be handled by calling code. */
+    size?: number;
+    agent?: string;
+    className?: string;
+}>;
+export default InlineIcon;

package/dist/primitives/next/link-element.d.ts

@@ -0,0 +1,23 @@
+import React, { PropsWithChildren } from 'react';
+import type { LinkDef } from '../../types';
+import { buttonVariants } from '../button';
+import { type VariantProps } from '../../util';
+/**
+ * If this is rendered directly (and not auto generated in a Block)
+ * and it has any children, title, icon, and iconAfter
+ * are ignore.
+ */
+declare const LinkElement: React.FC<PropsWithChildren & VariantProps<typeof buttonVariants> & {
+    def: LinkDef;
+    /**
+     * Use to trigger other events in addition to the
+     * link action itself. For example, to also close a drawer menu.
+     */
+    onClick?: () => void;
+    /** overrides def (eg, for title area)*/
+    icon?: React.ReactNode;
+    /** overrides def */
+    iconAfter?: boolean;
+    className?: string;
+}>;
+export default LinkElement;

package/dist/primitives/next/mdx-link.d.ts

@@ -0,0 +1,3 @@
+import React, { AnchorHTMLAttributes } from 'react';
+declare const MDXLink: React.FC<AnchorHTMLAttributes<HTMLAnchorElement>>;
+export default MDXLink;

package/dist/primitives/next/media-stack.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { MediaStackDef, Dimensions } from '../../types';
+declare const MediaStack: React.FC<{
+    media: MediaStackDef;
+    constrainTo?: Dimensions;
+    clx?: string;
+}>;
+export default MediaStack;

package/dist/primitives/next/nav-items.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { LinkDef } from '../../types';
+declare const NavItems: React.FC<{
+    items: LinkDef[];
+    className?: string;
+    as?: React.ElementType;
+    itemClx?: string | ((def: LinkDef) => string);
+    currentAs?: string;
+}>;
+export default NavItems;

package/dist/primitives/next/youtube-embed.d.ts

@@ -0,0 +1,11 @@
+declare const YouTubeEmbed: React.FC<{
+    youtubeID: string;
+    width: number;
+    height: number;
+    buttonSize?: number;
+    timeAt?: string;
+    title?: string;
+    caption?: string;
+    className?: string;
+}>;
+export default YouTubeEmbed;

package/dist/primitives/pagination.d.ts

@@ -0,0 +1,34 @@
+import * as React from 'react';
+import { ButtonProps } from './button';
+declare const Pagination: {
+    ({ className, ...props }: React.ComponentProps<"nav">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const PaginationContent: {
+    ({ className, ...props }: React.ComponentProps<"ul">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const PaginationItem: {
+    ({ className, ...props }: React.ComponentProps<"li">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+type PaginationLinkProps = {
+    isActive?: boolean;
+} & Pick<ButtonProps, 'size'> & React.ComponentProps<'a'>;
+declare const PaginationLink: {
+    ({ className, isActive, size, ...props }: PaginationLinkProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const PaginationPrevious: {
+    ({ className, ...props }: React.ComponentProps<typeof PaginationLink>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const PaginationNext: {
+    ({ className, ...props }: React.ComponentProps<typeof PaginationLink>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const PaginationEllipsis: {
+    ({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Pagination, PaginationContent, PaginationLink, PaginationItem, PaginationPrevious, PaginationNext, PaginationEllipsis, };

package/dist/primitives/popover.d.ts

@@ -0,0 +1,11 @@
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as React from 'react';
+declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverAnchor: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
+declare const PopoverClose: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverContent: {
+    ({ className, align, sideOffset, ...props }: React.ComponentProps<typeof PopoverPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+export { Popover, PopoverTrigger, PopoverContent, PopoverAnchor, PopoverClose };

package/dist/primitives/pretty-json-print.d.ts

@@ -0,0 +1,4 @@
+export declare const PrettyJsonPrint: ({ json, className, }: {
+    json: string | object;
+    className?: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/primitives/progress.d.ts

@@ -0,0 +1,8 @@
+import * as ProgressPrimitive from '@radix-ui/react-progress';
+import * as React from 'react';
+declare const Progress: {
+    ({ className, value, ...props }: React.ComponentProps<typeof ProgressPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+export { Progress };
+export default Progress;

package/dist/primitives/prompt-textarea.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+export interface PromptTextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    isLoading?: boolean;
+    label?: string;
+    field: {
+        onChange: (...event: any[]) => void;
+        onBlur: () => void;
+        value: any;
+        disabled?: boolean;
+        name: string;
+        placeholder?: string;
+    };
+}
+declare const PromptTextarea: {
+    ({ className, ...props }: PromptTextareaProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { PromptTextarea };

package/dist/primitives/qr-code.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { IProps } from 'react-qrcode-logo';
+export declare function QRCode({ value, size, id, ...props }: {
+    value: IProps['value'];
+    size: IProps['size'];
+    id?: IProps['id'];
+} & React.HTMLAttributes<HTMLDivElement>): React.ReactElement;
+export declare function QrCodeModal({ open, onOpenChange, value, onSave, title, description, modalClassName, }: {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    value: IProps['value'];
+    onSave: (key: string) => void;
+    title: React.ReactNode;
+    description: React.ReactNode;
+    modalClassName?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/primitives/radio-group.d.ts

@@ -0,0 +1,11 @@
+import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
+import * as React from 'react';
+declare const RadioGroup: {
+    ({ className, ...props }: React.ComponentProps<typeof RadioGroupPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+declare const RadioGroupItem: {
+    ({ className, ...props }: React.ComponentProps<typeof RadioGroupPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+export { RadioGroup, RadioGroupItem };

package/dist/primitives/resizable.d.ts

@@ -0,0 +1,23 @@
+import * as ResizablePrimitive from 'react-resizable-panels';
+declare const ResizablePanelGroup: ({ className, ...props }: React.ComponentProps<typeof ResizablePrimitive.PanelGroup>) => import("react/jsx-runtime").JSX.Element;
+declare const ResizablePanel: import("react").ForwardRefExoticComponent<Omit<import("react").HTMLAttributes<keyof HTMLElementTagNameMap>, "id" | "onResize"> & {
+    className?: string | undefined;
+    collapsedSize?: number | undefined;
+    collapsible?: boolean | undefined;
+    defaultSize?: number | undefined;
+    id?: string | undefined;
+    maxSize?: number | undefined;
+    minSize?: number | undefined;
+    onCollapse?: ResizablePrimitive.PanelOnCollapse | undefined;
+    onExpand?: ResizablePrimitive.PanelOnExpand | undefined;
+    onResize?: ResizablePrimitive.PanelOnResize | undefined;
+    order?: number | undefined;
+    style?: object | undefined;
+    tagName?: keyof HTMLElementTagNameMap | undefined;
+} & {
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<ResizablePrimitive.ImperativePanelHandle>>;
+declare const ResizableHandle: ({ withHandle, className, ...props }: React.ComponentProps<typeof ResizablePrimitive.PanelResizeHandle> & {
+    withHandle?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+export { ResizablePanelGroup, ResizablePanel, ResizableHandle };

package/dist/primitives/scroll-area.d.ts

@@ -0,0 +1,13 @@
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+import * as React from 'react';
+declare const ScrollArea: {
+    ({ className, children, ref, ...props }: React.ComponentProps<typeof ScrollAreaPrimitive.Root> & {
+        ref?: React.RefObject<HTMLDivElement | null>;
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+declare const ScrollBar: {
+    ({ className, orientation, ...props }: React.ComponentProps<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+export { ScrollArea, ScrollBar };

package/dist/primitives/search-input.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+export type SearchInputProps = React.InputHTMLAttributes<HTMLInputElement> & {
+    classNames?: {
+        container?: string;
+        input?: string;
+        button?: string;
+    };
+};
+declare const SearchInput: {
+    ({ className, value, onChange, classNames, ...props }: SearchInputProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { SearchInput };

package/dist/primitives/select.d.ts

@@ -0,0 +1,26 @@
+import * as SelectPrimitive from '@radix-ui/react-select';
+import * as React from 'react';
+declare const Select: React.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: {
+    ({ className, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+declare const SelectContent: {
+    ({ className, children, position, ...props }: React.ComponentProps<typeof SelectPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+declare const SelectLabel: {
+    ({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Label>): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+declare const SelectItem: {
+    ({ className, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+declare const SelectSeparator: {
+    ({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectLabel, SelectItem, SelectSeparator, };