@gram-ai/elements 1.25.2 → 1.26.0

package/dist/plugins/chart/catalog.d.ts

@@ -0,0 +1,123 @@
+import { z } from 'zod';
+/**
+ * Chart Catalog
+ *
+ * Defines all available chart components for LLM-generated visualizations.
+ * Uses Recharts under the hood for rendering.
+ */
+export declare const chartCatalog: import('@json-render/core').Catalog<{
+    BarChart: {
+        props: z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            data: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodNumber;
+                color: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            layout: z.ZodOptional<z.ZodEnum<{
+                vertical: "vertical";
+                horizontal: "horizontal";
+            }>>;
+            showGrid: z.ZodOptional<z.ZodBoolean>;
+            showLegend: z.ZodOptional<z.ZodBoolean>;
+            className: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        description: string;
+    };
+    LineChart: {
+        props: z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            data: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+            }, z.core.$catchall<z.ZodNumber>>>;
+            series: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            showGrid: z.ZodOptional<z.ZodBoolean>;
+            showLegend: z.ZodOptional<z.ZodBoolean>;
+            showDots: z.ZodOptional<z.ZodBoolean>;
+            curved: z.ZodOptional<z.ZodBoolean>;
+            className: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        description: string;
+    };
+    AreaChart: {
+        props: z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            data: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+            }, z.core.$catchall<z.ZodNumber>>>;
+            series: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            stacked: z.ZodOptional<z.ZodBoolean>;
+            showGrid: z.ZodOptional<z.ZodBoolean>;
+            showLegend: z.ZodOptional<z.ZodBoolean>;
+            className: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        description: string;
+    };
+    PieChart: {
+        props: z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            data: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodNumber;
+                color: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            showLabels: z.ZodOptional<z.ZodBoolean>;
+            showLegend: z.ZodOptional<z.ZodBoolean>;
+            className: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        description: string;
+    };
+    DonutChart: {
+        props: z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            data: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodNumber;
+                color: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            showLabels: z.ZodOptional<z.ZodBoolean>;
+            showLegend: z.ZodOptional<z.ZodBoolean>;
+            innerLabel: z.ZodOptional<z.ZodString>;
+            innerValue: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+            className: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        description: string;
+    };
+    ScatterChart: {
+        props: z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            data: z.ZodArray<z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                label: z.ZodOptional<z.ZodString>;
+                size: z.ZodOptional<z.ZodNumber>;
+                color: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            xLabel: z.ZodOptional<z.ZodString>;
+            yLabel: z.ZodOptional<z.ZodString>;
+            showGrid: z.ZodOptional<z.ZodBoolean>;
+            className: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        description: string;
+    };
+    RadarChart: {
+        props: z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            data: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodNumber;
+                color: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            showLegend: z.ZodOptional<z.ZodBoolean>;
+            className: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        description: string;
+    };
+}, Record<string, import('@json-render/core').ActionDefinition<Record<string, unknown>>>, Record<string, import('@json-render/core').ValidationFunction>>;
+export type ChartCatalogComponentProps = typeof chartCatalog extends {
+    components: infer C;
+} ? {
+    [K in keyof C]: C[K] extends {
+        props: infer P;
+    } ? z.infer<P extends z.ZodType ? P : never> : never;
+} : never;

package/dist/plugins/chart/index.d.ts

@@ -1,5 +1,5 @@
 import { Plugin } from '../../types/plugins';
 /**
- * This plugin renders Vega charts.
+ * This plugin renders charts using json-render format.
  */
 export declare const chart: Plugin;

package/dist/plugins/chart/ui/area-chart.d.ts

@@ -0,0 +1,16 @@
+import { FC } from 'react';
+interface SeriesDataPoint {
+    label: string;
+    [key: string]: string | number;
+}
+export interface AreaChartProps {
+    title?: string;
+    data: SeriesDataPoint[];
+    series?: string[];
+    stacked?: boolean;
+    showGrid?: boolean;
+    showLegend?: boolean;
+    className?: string;
+}
+export declare const AreaChart: FC<AreaChartProps>;
+export {};

package/dist/plugins/chart/ui/bar-chart.d.ts

@@ -0,0 +1,16 @@
+import { FC } from 'react';
+interface DataPoint {
+    label: string;
+    value: number;
+    color?: string;
+}
+export interface BarChartProps {
+    title?: string;
+    data: DataPoint[];
+    layout?: 'vertical' | 'horizontal';
+    showGrid?: boolean;
+    showLegend?: boolean;
+    className?: string;
+}
+export declare const BarChart: FC<BarChartProps>;
+export {};

package/dist/plugins/chart/ui/donut-chart.d.ts

@@ -0,0 +1,17 @@
+import { FC } from 'react';
+interface DataPoint {
+    label: string;
+    value: number;
+    color?: string;
+}
+export interface DonutChartProps {
+    title?: string;
+    data: DataPoint[];
+    showLabels?: boolean;
+    showLegend?: boolean;
+    innerLabel?: string;
+    innerValue?: string | number;
+    className?: string;
+}
+export declare const DonutChart: FC<DonutChartProps>;
+export {};

package/dist/plugins/chart/ui/index.d.ts

@@ -0,0 +1,7 @@
+export { BarChart, type BarChartProps } from './bar-chart';
+export { LineChart, type LineChartProps } from './line-chart';
+export { AreaChart, type AreaChartProps } from './area-chart';
+export { PieChart, type PieChartProps } from './pie-chart';
+export { DonutChart, type DonutChartProps } from './donut-chart';
+export { ScatterChart, type ScatterChartProps } from './scatter-chart';
+export { RadarChart, type RadarChartProps } from './radar-chart';

package/dist/plugins/chart/ui/line-chart.d.ts

@@ -0,0 +1,17 @@
+import { FC } from 'react';
+interface SeriesDataPoint {
+    label: string;
+    [key: string]: string | number;
+}
+export interface LineChartProps {
+    title?: string;
+    data: SeriesDataPoint[];
+    series?: string[];
+    showGrid?: boolean;
+    showLegend?: boolean;
+    showDots?: boolean;
+    curved?: boolean;
+    className?: string;
+}
+export declare const LineChart: FC<LineChartProps>;
+export {};

package/dist/plugins/chart/ui/pie-chart.d.ts

@@ -0,0 +1,15 @@
+import { FC } from 'react';
+interface DataPoint {
+    label: string;
+    value: number;
+    color?: string;
+}
+export interface PieChartProps {
+    title?: string;
+    data: DataPoint[];
+    showLabels?: boolean;
+    showLegend?: boolean;
+    className?: string;
+}
+export declare const PieChart: FC<PieChartProps>;
+export {};

package/dist/plugins/chart/ui/radar-chart.d.ts

@@ -0,0 +1,14 @@
+import { FC } from 'react';
+interface DataPoint {
+    label: string;
+    value: number;
+    color?: string;
+}
+export interface RadarChartProps {
+    title?: string;
+    data: DataPoint[];
+    showLegend?: boolean;
+    className?: string;
+}
+export declare const RadarChart: FC<RadarChartProps>;
+export {};

package/dist/plugins/chart/ui/scatter-chart.d.ts

@@ -0,0 +1,18 @@
+import { FC } from 'react';
+interface ScatterDataPoint {
+    x: number;
+    y: number;
+    label?: string;
+    size?: number;
+    color?: string;
+}
+export interface ScatterChartProps {
+    title?: string;
+    data: ScatterDataPoint[];
+    xLabel?: string;
+    yLabel?: string;
+    showGrid?: boolean;
+    className?: string;
+}
+export declare const ScatterChart: FC<ScatterChartProps>;
+export {};

package/dist/plugins/components/MacOSWindowFrame.d.ts

@@ -0,0 +1,13 @@
+import { FC, ReactNode } from 'react';
+interface MacOSWindowFrameProps {
+    children: ReactNode;
+    className?: string;
+    /** Optional title to display in the title bar */
+    title?: string;
+}
+/**
+ * A macOS-style window frame with traffic light buttons.
+ * Wraps content in a bordered container with a title bar.
+ */
+export declare const MacOSWindowFrame: FC<MacOSWindowFrameProps>;
+export {};

package/dist/plugins/components/PluginLoadingState.d.ts

@@ -5,7 +5,7 @@ interface PluginLoadingStateProps {
 }
 /**
  * Shared loading state component for plugins.
- * Displays a shimmer effect with loading text.
+ * Displays a shimmer effect with loading text inside a macOS-style window.
  */
 export declare const PluginLoadingState: FC<PluginLoadingStateProps>;
 export {};

package/dist/plugins/generative-ui/catalog.d.ts

@@ -0,0 +1,293 @@
+import { z } from 'zod';
+/**
+ * Generative UI Catalog
+ *
+ * Defines all available components for LLM-generated UI.
+ * Components map to shadcn/ui primitives in the ui/ directory.
+ */
+export declare const catalog: import('@json-render/core').Catalog<{
+    Stack: {
+        props: z.ZodObject<{
+            direction: z.ZodOptional<z.ZodEnum<{
+                vertical: "vertical";
+                horizontal: "horizontal";
+            }>>;
+            gap: z.ZodOptional<z.ZodEnum<{
+                sm: "sm";
+                md: "md";
+                lg: "lg";
+            }>>;
+            align: z.ZodOptional<z.ZodEnum<{
+                end: "end";
+                start: "start";
+                center: "center";
+                stretch: "stretch";
+            }>>;
+            justify: z.ZodOptional<z.ZodEnum<{
+                end: "end";
+                start: "start";
+                center: "center";
+                between: "between";
+                around: "around";
+            }>>;
+            className: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        hasChildren: true;
+        description: string;
+    };
+    Grid: {
+        props: z.ZodObject<{
+            columns: z.ZodOptional<z.ZodNumber>;
+            gap: z.ZodOptional<z.ZodEnum<{
+                sm: "sm";
+                md: "md";
+                lg: "lg";
+            }>>;
+            className: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        hasChildren: true;
+        description: string;
+    };
+    Card: {
+        props: z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            className: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        hasChildren: true;
+        description: string;
+    };
+    Text: {
+        props: z.ZodObject<{
+            content: z.ZodString;
+            variant: z.ZodOptional<z.ZodEnum<{
+                code: "code";
+                body: "body";
+                caption: "caption";
+                heading: "heading";
+            }>>;
+            className: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        description: string;
+    };
+    Metric: {
+        props: z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+            format: z.ZodOptional<z.ZodEnum<{
+                number: "number";
+                percent: "percent";
+                currency: "currency";
+            }>>;
+            className: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        description: string;
+    };
+    Badge: {
+        props: z.ZodObject<{
+            content: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                default: "default";
+                destructive: "destructive";
+                secondary: "secondary";
+                warning: "warning";
+                outline: "outline";
+            }>>;
+            className: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        hasChildren: true;
+        description: string;
+    };
+    Progress: {
+        props: z.ZodObject<{
+            value: z.ZodNumber;
+            max: z.ZodOptional<z.ZodNumber>;
+            className: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        description: string;
+    };
+    Table: {
+        props: z.ZodObject<{
+            headers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            rows: z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+            className: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        description: string;
+    };
+    List: {
+        props: z.ZodObject<{
+            items: z.ZodArray<z.ZodString>;
+            ordered: z.ZodOptional<z.ZodBoolean>;
+            className: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        description: string;
+    };
+    Alert: {
+        props: z.ZodObject<{
+            title: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                destructive: "destructive";
+            }>>;
+        }, z.core.$strip>;
+        description: string;
+    };
+    Separator: {
+        props: z.ZodObject<{
+            orientation: z.ZodOptional<z.ZodEnum<{
+                vertical: "vertical";
+                horizontal: "horizontal";
+            }>>;
+            className: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        description: string;
+    };
+    Divider: {
+        props: z.ZodObject<{
+            orientation: z.ZodOptional<z.ZodEnum<{
+                vertical: "vertical";
+                horizontal: "horizontal";
+            }>>;
+            className: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        description: string;
+    };
+    Accordion: {
+        props: z.ZodObject<{
+            type: z.ZodOptional<z.ZodEnum<{
+                single: "single";
+                multiple: "multiple";
+            }>>;
+        }, z.core.$strip>;
+        hasChildren: true;
+        description: string;
+    };
+    AccordionItem: {
+        props: z.ZodObject<{
+            value: z.ZodString;
+            title: z.ZodString;
+        }, z.core.$strip>;
+        hasChildren: true;
+        description: string;
+    };
+    Tabs: {
+        props: z.ZodObject<{
+            defaultValue: z.ZodOptional<z.ZodString>;
+            tabs: z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        hasChildren: true;
+        description: string;
+    };
+    TabContent: {
+        props: z.ZodObject<{
+            value: z.ZodString;
+        }, z.core.$strip>;
+        hasChildren: true;
+        description: string;
+    };
+    Button: {
+        props: z.ZodObject<{
+            label: z.ZodString;
+            variant: z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                destructive: "destructive";
+                secondary: "secondary";
+                outline: "outline";
+                ghost: "ghost";
+            }>>;
+            size: z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                icon: "icon";
+                sm: "sm";
+                lg: "lg";
+            }>>;
+            disabled: z.ZodOptional<z.ZodBoolean>;
+            action: z.ZodOptional<z.ZodString>;
+            actionParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>;
+        description: string;
+    };
+    ActionButton: {
+        props: z.ZodObject<{
+            label: z.ZodString;
+            action: z.ZodString;
+            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            variant: z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                destructive: "destructive";
+                secondary: "secondary";
+                outline: "outline";
+                ghost: "ghost";
+            }>>;
+            size: z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                icon: "icon";
+                sm: "sm";
+                lg: "lg";
+            }>>;
+            className: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        description: string;
+    };
+    Input: {
+        props: z.ZodObject<{
+            label: z.ZodOptional<z.ZodString>;
+            placeholder: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodEnum<{
+                number: "number";
+                text: "text";
+                tel: "tel";
+                email: "email";
+                password: "password";
+            }>>;
+            valuePath: z.ZodString;
+        }, z.core.$strip>;
+        description: string;
+    };
+    Checkbox: {
+        props: z.ZodObject<{
+            label: z.ZodOptional<z.ZodString>;
+            valuePath: z.ZodString;
+            defaultChecked: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        description: string;
+    };
+    Select: {
+        props: z.ZodObject<{
+            placeholder: z.ZodOptional<z.ZodString>;
+            valuePath: z.ZodString;
+            options: z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        description: string;
+    };
+    Avatar: {
+        props: z.ZodObject<{
+            src: z.ZodOptional<z.ZodString>;
+            alt: z.ZodOptional<z.ZodString>;
+            fallback: z.ZodString;
+        }, z.core.$strip>;
+        description: string;
+    };
+    Skeleton: {
+        props: z.ZodObject<{
+            width: z.ZodOptional<z.ZodString>;
+            height: z.ZodOptional<z.ZodString>;
+            className: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        description: string;
+    };
+}, Record<string, import('@json-render/core').ActionDefinition<Record<string, unknown>>>, Record<string, import('@json-render/core').ValidationFunction>>;
+export type CatalogComponentProps = typeof catalog extends {
+    components: infer C;
+} ? {
+    [K in keyof C]: C[K] extends {
+        props: infer P;
+    } ? z.infer<P extends z.ZodType ? P : never> : never;
+} : never;

package/dist/plugins/generative-ui/ui/accordion-wrapper.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+export interface AccordionWrapperProps {
+    type?: 'single' | 'multiple';
+    children?: React.ReactNode;
+}
+/**
+ * Accordion wrapper that adapts the compound Accordion to the catalog's props-based API.
+ */
+export declare function AccordionWrapper({ type, children, }: AccordionWrapperProps): import("react/jsx-runtime").JSX.Element;
+export interface AccordionItemWrapperProps {
+    value: string;
+    title: string;
+    children?: React.ReactNode;
+}
+/**
+ * AccordionItem wrapper that takes title as a prop and renders trigger + content.
+ */
+export declare function AccordionItemWrapper({ value, title, children, }: AccordionItemWrapperProps): import("react/jsx-runtime").JSX.Element;

package/dist/plugins/generative-ui/ui/accordion.d.ts

@@ -0,0 +1,7 @@
+import { Accordion as AccordionPrimitive } from 'radix-ui';
+import * as React from 'react';
+declare function Accordion({ ...props }: React.ComponentProps<typeof AccordionPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function AccordionItem({ className, ...props }: React.ComponentProps<typeof AccordionPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+declare function AccordionTrigger({ className, children, ...props }: React.ComponentProps<typeof AccordionPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function AccordionContent({ className, children, ...props }: React.ComponentProps<typeof AccordionPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };

package/dist/plugins/generative-ui/ui/action-button.d.ts

@@ -0,0 +1,10 @@
+import { buttonVariants } from './button';
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+export interface ActionButtonProps extends Omit<React.ComponentProps<'button'>, 'onClick'>, VariantProps<typeof buttonVariants> {
+    label: string;
+    /** Tool name to invoke when clicked (matches LLM prompt) */
+    action: string;
+    args?: Record<string, unknown>;
+}
+export declare function ActionButton({ label, action, args, variant, size, className, disabled, ...props }: ActionButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/plugins/generative-ui/ui/alert-wrapper.d.ts

@@ -0,0 +1,9 @@
+export interface AlertWrapperProps {
+    title: string;
+    description?: string;
+    variant?: 'default' | 'destructive';
+}
+/**
+ * Alert wrapper that takes title and description as props.
+ */
+export declare function AlertWrapper({ title, description, variant, }: AlertWrapperProps): import("react/jsx-runtime").JSX.Element;

package/dist/plugins/generative-ui/ui/alert.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const alertVariants: (props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function Alert({ className, variant, ...props }: React.ComponentProps<'div'> & VariantProps<typeof alertVariants>): import("react/jsx-runtime").JSX.Element;
+declare function AlertTitle({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDescription({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+export { Alert, AlertTitle, AlertDescription };

package/dist/plugins/generative-ui/ui/avatar-wrapper.d.ts

@@ -0,0 +1,9 @@
+export interface AvatarWrapperProps {
+    src?: string;
+    alt?: string;
+    fallback: string;
+}
+/**
+ * Avatar wrapper that takes src, alt, and fallback as props.
+ */
+export declare function AvatarWrapper({ src, alt, fallback }: AvatarWrapperProps): import("react/jsx-runtime").JSX.Element;

package/dist/plugins/generative-ui/ui/avatar.d.ts

@@ -0,0 +1,11 @@
+import { Avatar as AvatarPrimitive } from 'radix-ui';
+import * as React from 'react';
+declare function Avatar({ className, size, ...props }: React.ComponentProps<typeof AvatarPrimitive.Root> & {
+    size?: 'default' | 'sm' | 'lg';
+}): import("react/jsx-runtime").JSX.Element;
+declare function AvatarImage({ className, ...props }: React.ComponentProps<typeof AvatarPrimitive.Image>): import("react/jsx-runtime").JSX.Element;
+declare function AvatarFallback({ className, ...props }: React.ComponentProps<typeof AvatarPrimitive.Fallback>): import("react/jsx-runtime").JSX.Element;
+declare function AvatarBadge({ className, ...props }: React.ComponentProps<'span'>): import("react/jsx-runtime").JSX.Element;
+declare function AvatarGroup({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function AvatarGroupCount({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+export { Avatar, AvatarImage, AvatarFallback, AvatarBadge, AvatarGroup, AvatarGroupCount, };

package/dist/plugins/generative-ui/ui/badge.d.ts

@@ -0,0 +1,12 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const badgeVariants: (props?: ({
+    variant?: "success" | "default" | "error" | "destructive" | "secondary" | "warning" | "outline" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+interface BadgeProps extends React.ComponentProps<'span'>, VariantProps<typeof badgeVariants> {
+    asChild?: boolean;
+    /** Content text (matches LLM prompt) - rendered as children */
+    content?: string;
+}
+declare function Badge({ className, variant, asChild, content, children, ...props }: BadgeProps): import("react/jsx-runtime").JSX.Element;
+export { Badge, badgeVariants };