@invect/ui 0.0.1

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

@@ -0,0 +1,47 @@
+import { NodeExecutionStatus } from '@invect/core/types';
+export { BatchFlowEdge, defaultEdgeOptions } from './BatchFlowEdge';
+export { LayoutSelector } from './LayoutSelector';
+export { langflowColors, type NodeStatus } from './styleUtils';
+export type { BatchFlowEdgeData } from './BatchFlowEdge';
+export interface BatchFlowNodeData extends Record<string, unknown> {
+    id: string;
+    type: string;
+    display_name: string;
+    description?: string;
+    icon?: string;
+    frozen?: boolean;
+    beta?: boolean;
+    deprecated?: boolean;
+    outputs?: Array<{
+        name: string;
+        display_name: string;
+        type: string;
+        required?: boolean;
+    }>;
+    inputs?: Array<{
+        name: string;
+        display_name: string;
+        type: string;
+        required?: boolean;
+        value?: unknown;
+    }>;
+    template?: Record<string, {
+        display_name: string;
+        type: string;
+        required?: boolean;
+        show?: boolean;
+        value?: unknown;
+        options?: unknown[];
+        list?: boolean;
+        multiline?: boolean;
+        placeholder?: string;
+        password?: boolean;
+        advanced?: boolean;
+        _input_type?: string;
+    }>;
+    connectedTemplateFields?: Set<string>;
+    executionStatus?: NodeExecutionStatus;
+    executionError?: string;
+    executionOutput?: unknown;
+    flow?: unknown;
+}

package/dist/components/graph/styleUtils.d.ts

@@ -0,0 +1,124 @@
+import { NodeExecutionStatus } from '@invect/core/types';
+export type NodeType = 'ChatInput' | 'TextInput' | 'Input' | 'ChatOutput' | 'TextOutput' | 'Output' | 'OpenAIModel' | 'AnthropicModel' | 'LLM' | 'Prompt' | 'PromptTemplate' | 'Agent' | 'Memory' | 'Tool' | 'Chain' | 'Retriever' | 'Embedding' | 'VectorStore' | 'DocumentLoader' | 'TextSplitter' | 'Note' | 'Unknown';
+export type NodeStatus = 'idle' | 'running' | 'success' | 'error' | 'inactive';
+export declare const mapExecutionStatusToNodeStatus: (status: NodeExecutionStatus | string) => NodeStatus;
+export declare const langflowColors: {
+    emerald: {
+        light: string;
+        DEFAULT: string;
+        dark: string;
+    };
+    sky: {
+        light: string;
+        DEFAULT: string;
+        dark: string;
+    };
+    fuchsia: {
+        light: string;
+        DEFAULT: string;
+        dark: string;
+    };
+    amber: {
+        light: string;
+        DEFAULT: string;
+        dark: string;
+    };
+    orange: {
+        light: string;
+        DEFAULT: string;
+        dark: string;
+    };
+    red: {
+        light: string;
+        DEFAULT: string;
+        dark: string;
+    };
+    cyan: {
+        light: string;
+        DEFAULT: string;
+        dark: string;
+    };
+    lime: {
+        light: string;
+        DEFAULT: string;
+        dark: string;
+    };
+    teal: {
+        light: string;
+        DEFAULT: string;
+        dark: string;
+    };
+    indigo: {
+        light: string;
+        DEFAULT: string;
+        dark: string;
+    };
+    pink: {
+        light: string;
+        DEFAULT: string;
+        dark: string;
+    };
+    purple: {
+        light: string;
+        DEFAULT: string;
+        dark: string;
+    };
+    rose: {
+        light: string;
+        DEFAULT: string;
+        dark: string;
+    };
+    slate: {
+        light: string;
+        DEFAULT: string;
+        dark: string;
+    };
+    success: {
+        DEFAULT: string;
+        light: string;
+        dark: string;
+    };
+    error: {
+        DEFAULT: string;
+        light: string;
+        dark: string;
+    };
+    running: {
+        DEFAULT: string;
+        light: string;
+        dark: string;
+    };
+    border: string;
+    background: string;
+    foreground: string;
+    muted: string;
+    mutedForeground: string;
+    primary: string;
+    secondary: string;
+};
+export declare const nodeTypeToColorName: Record<NodeType, keyof typeof langflowColors>;
+export declare const getNodeIconName: (type: NodeType, icon?: string) => string;
+export declare const getNodeTailwindStyles: (type: NodeType, selected?: boolean) => {
+    card: string;
+    header: string;
+    iconContainer: string;
+    icon: string;
+    title: string;
+    typeBadge: string;
+    description: string;
+    parametersSection: string;
+    parameterTitle: string;
+    parameterValue: string;
+    handleBase: string;
+    categoryColorName: "error" | "success" | "secondary" | "border" | "muted" | "background" | "cyan" | "fuchsia" | "indigo" | "lime" | "orange" | "pink" | "purple" | "red" | "teal" | "running" | "emerald" | "sky" | "amber" | "rose" | "slate" | "foreground" | "mutedForeground" | "primary";
+    categoryDefaultColor: string;
+};
+export declare const getNodeMinimapColor: (nodeType: NodeType) => string;
+export declare const getNodeStatusStyles: (status: NodeStatus | undefined, _baseBorderColor: string) => string;
+export declare const truncateText: (text: string, maxLength: number) => string;
+export declare const parseNodeType: (type: string) => NodeType;
+export declare const getRawNodeColors: (type: NodeType) => {
+    light: string;
+    DEFAULT: string;
+    dark: string;
+};

package/dist/components/nodes/AgentConfigPanel.d.ts

@@ -0,0 +1,24 @@
+import { ToolDefinition, AddedToolInstance } from './ToolSelectorModal';
+export interface AgentConfigDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Display name of the agent node */
+    agentName: string;
+    /** Available tools fetched from the API */
+    availableTools: ToolDefinition[];
+    /** Currently added tool instances on this agent */
+    addedTools: AddedToolInstance[];
+    /** Current agent node params */
+    agentParams: Record<string, unknown>;
+    /** Called to add a tool instance, returns the new instanceId */
+    onAddTool: (toolId: string) => string;
+    /** Called to remove a tool instance */
+    onRemoveTool: (instanceId: string) => void;
+    /** Called to update a tool instance */
+    onUpdateTool: (instanceId: string, updates: Partial<Omit<AddedToolInstance, 'instanceId' | 'toolId'>>) => void;
+    /** Called to update agent-level params */
+    onUpdateParams: (params: Record<string, unknown>) => void;
+    /** Portal container for sub-modals */
+    portalContainer?: HTMLElement | null;
+}
+export declare const AgentConfigDialog: import('react').NamedExoticComponent<AgentConfigDialogProps>;

package/dist/components/nodes/AgentNode.d.ts

@@ -0,0 +1,8 @@
+import { NodeProps } from '@xyflow/react';
+/**
+ * AgentNode - A specialized node for AI Agents with an attached tools box
+ *
+ * This node renders like the UniversalNode but with an additional "appendix"
+ * panel that displays and manages the tools available to the agent.
+ */
+export declare const AgentNode: import('react').MemoExoticComponent<({ id, data, selected }: NodeProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/components/nodes/AgentToolsBox.d.ts

@@ -0,0 +1,41 @@
+import { AddedToolInstance, ToolDefinition } from './ToolSelectorModal';
+/**
+ * Tool category for organization in UI
+ * Matches AgentToolCategory from @invect/core
+ */
+export type ToolCategory = 'data' | 'web' | 'code' | 'utility' | 'custom';
+/**
+ * Simplified tool definition for display in the UI
+ * @deprecated Use AddedToolInstance instead
+ */
+export interface AgentToolDisplay {
+    id: string;
+    name: string;
+    category: ToolCategory;
+}
+interface AgentToolsBoxProps {
+    /** Tool instances currently attached to the agent */
+    tools: AddedToolInstance[];
+    /** Available tool definitions for resolving category info */
+    availableTools: ToolDefinition[];
+    /** Currently selected tool instance ID (being configured) */
+    selectedInstanceId?: string | null;
+    /** Called when user clicks "Add Tool" button */
+    onAddTool?: () => void;
+    /** Called when user wants to see all selected tools (opens modal with filter) */
+    onShowMore?: () => void;
+    /** Called when user clicks on a tool (to configure it) */
+    onToolClick?: (tool: AddedToolInstance) => void;
+    /** Called when user clicks remove button on a tool */
+    onRemoveTool?: (instanceId: string) => void;
+    /** Additional CSS classes */
+    className?: string;
+}
+/**
+ * AgentToolsBox - Displays and manages tools attached to an AI Agent node
+ *
+ * Renders as a compact grid showing tool tiles with category-based styling.
+ * Shows max 2x3 grid with "show more" button if there are more tools.
+ */
+export declare const AgentToolsBox: import('react').NamedExoticComponent<AgentToolsBoxProps>;
+export {};

package/dist/components/nodes/NodeAppendix.d.ts

@@ -0,0 +1,19 @@
+export type AppendixPosition = 'top' | 'bottom' | 'left' | 'right';
+interface NodeAppendixProps {
+    position?: AppendixPosition;
+    onPositionChange?: (position: AppendixPosition) => void;
+    children: React.ReactNode;
+    className?: string;
+    /** Override the default border class (e.g. for selected/hover/state colours) */
+    borderClassName?: string;
+    /** Whether to show the position toggle button */
+    showPositionToggle?: boolean;
+}
+/**
+ * NodeAppendix - A reusable component that renders an attached panel to a node
+ *
+ * Used to display additional content like tools, configurations, or previews
+ * that are visually connected to a node but rendered outside its bounds.
+ */
+export declare const NodeAppendix: import('react').NamedExoticComponent<NodeAppendixProps>;
+export {};

package/dist/components/nodes/NodeStatusIndicator.d.ts

@@ -0,0 +1,30 @@
+import { default as React } from 'react';
+export type NodeStatusIndicatorStatus = 'initial' | 'loading' | 'success' | 'error';
+export type NodeStatusIndicatorLoadingVariant = 'border' | 'overlay';
+interface NodeStatusIndicatorProps {
+    status: NodeStatusIndicatorStatus;
+    loadingVariant?: NodeStatusIndicatorLoadingVariant;
+    children: React.ReactNode;
+    className?: string;
+}
+/**
+ * A node wrapper that indicates the status of a node via a border effect.
+ *
+ * Status can be:
+ * - "initial" - no status indicator (default state)
+ * - "loading" - animated conic gradient border that rotates
+ * - "success" - green border
+ * - "error" - red border
+ *
+ * Loading variants:
+ * - "border" - animated gradient border around the node (default)
+ * - "overlay" - full overlay with spinner
+ *
+ * The animated border uses CSS @property for the conic gradient angle animation.
+ * This is supported in Chrome/Chromium browsers. Firefox will show a static gradient.
+ */
+export declare function NodeStatusIndicator({ status, loadingVariant, children, className, }: NodeStatusIndicatorProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace NodeStatusIndicator {
+    var displayName: string;
+}
+export {};

package/dist/components/nodes/NodeViewContext.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+import { Node } from '@xyflow/react';
+export type NodeViewMode = 'edit' | 'view' | 'readonly';
+interface NodeViewContextValue {
+    mode: NodeViewMode;
+    onEdit?: (node: Node) => void;
+    onEditNode?: (nodeId: string) => void;
+    stripExecutionData: boolean;
+}
+export declare const useNodeViewContext: () => NodeViewContextValue;
+export interface NodeViewProviderProps {
+    mode: NodeViewMode;
+    onEdit?: (node: Node) => void;
+    onEditNode?: (nodeId: string) => void;
+    children: React.ReactNode;
+}
+export declare const NodeViewProvider: React.FC<NodeViewProviderProps>;
+export {};

package/dist/components/nodes/ToolParamField.d.ts

@@ -0,0 +1,28 @@
+import { NodeParamField } from '../../types/node-definition.types';
+export interface AddCredentialRequest {
+    fieldName: string;
+    /** If specified, the credential requires OAuth2 with this specific provider */
+    oauth2Providers?: string[];
+}
+interface ToolParamFieldProps {
+    field: NodeParamField;
+    value: unknown;
+    onChange: (value: unknown) => void;
+    /** If true, the AI will choose this value at runtime (param included in tool's input schema) */
+    aiChosen: boolean;
+    onAiChosenChange: (enabled: boolean) => void;
+    /** Callback to open the create credential modal (passes the field name and OAuth2 provider info) */
+    onAddCredential?: (request: AddCredentialRequest) => void;
+}
+/**
+ * A config field for tool parameters with "AI Chosen" vs "Static" toggle.
+ *
+ * - AI Chosen (default): The parameter IS included in the tool's input schema, and the AI
+ *   decides what value to provide when calling the tool.
+ * - Static: User provides a fixed value, which is passed directly during tool execution.
+ *   The parameter is NOT included in the tool's input schema shown to the model.
+ *
+ * Note: Credential fields are ALWAYS static (never AI chosen) for security reasons.
+ */
+export declare const ToolParamField: import('react').NamedExoticComponent<ToolParamFieldProps>;
+export {};

package/dist/components/nodes/ToolSelectorModal.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Tool category for organization in UI
+ */
+export type ToolCategory = 'data' | 'web' | 'code' | 'utility' | 'custom';
+/**
+ * Full tool definition with schema information
+ */
+export interface ToolDefinition {
+    id: string;
+    name: string;
+    description: string;
+    category: ToolCategory;
+    /** Tags for filtering */
+    tags?: string[];
+    /** JSON Schema for tool inputs */
+    inputSchema?: Record<string, unknown>;
+    /** Documentation URL */
+    docsUrl?: string;
+    /** Whether this tool is enabled by default */
+    enabledByDefault?: boolean;
+    /** If this tool is backed by a node, this is the node type */
+    nodeType?: string;
+    /** Provider information for grouping and branding */
+    provider?: {
+        id: string;
+        name: string;
+        icon: string;
+        /** Raw SVG markup for custom provider branding */
+        svgIcon?: string;
+    };
+}
+/**
+ * An instance of a tool that has been added to the agent.
+ * Multiple instances of the same tool can exist with different configurations.
+ */
+export interface AddedToolInstance {
+    /** Unique instance ID */
+    instanceId: string;
+    /** Reference to the base tool definition */
+    toolId: string;
+    /** Custom name for this instance (defaults to tool name) */
+    name: string;
+    /** Custom description for this instance (defaults to tool description) */
+    description: string;
+    /** Tool-specific configuration parameters */
+    params: Record<string, unknown>;
+}
+interface ToolSelectorModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** All available tools */
+    availableTools: ToolDefinition[];
+    /** Currently added tool instances */
+    addedTools: AddedToolInstance[];
+    /** Called when a tool is added. Returns the new instance ID. */
+    onAddTool: (toolId: string) => string;
+    /** Called when a tool instance is removed */
+    onRemoveTool: (instanceId: string) => void;
+    /** Called when a tool instance is updated */
+    onUpdateTool: (instanceId: string, updates: Partial<Omit<AddedToolInstance, 'instanceId' | 'toolId'>>) => void;
+    /** Portal container for rendering the modal (needed when inside ReactFlow) */
+    portalContainer?: HTMLElement | null;
+    /** If true, start with focus on added tools section */
+    initialShowSelected?: boolean;
+    /** If provided, auto-select this tool instance when modal opens */
+    initialSelectedInstanceId?: string | null;
+}
+/**
+ * ToolSelectorModal - Modal for managing agent tools
+ *
+ * Layout:
+ * - Left side (60%):
+ *   - Top: Search bar + category tabs + tag filters
+ *   - Middle: Browse available tools grid
+ *   - Horizontal divider (when tools added)
+ *   - Bottom: Added tools (horizontally scrollable)
+ * - Right side (40%): Tool details/configuration panel
+ */
+export declare const ToolSelectorModal: import('react').NamedExoticComponent<ToolSelectorModalProps>;
+export {};

package/dist/components/nodes/ToolSelectorParts.d.ts

@@ -0,0 +1,30 @@
+import { AddCredentialRequest } from './ToolParamField';
+import { ToolDefinition, ToolCategory, AddedToolInstance } from './ToolSelectorModal';
+export declare const categoryConfig: Record<ToolCategory, {
+    label: string;
+    icon: React.ElementType;
+    color: string;
+}>;
+export declare const categoryOrder: ToolCategory[];
+export declare const BrowseToolCard: import('react').NamedExoticComponent<{
+    tool: ToolDefinition;
+    onAdd: () => void;
+    onPreview: () => void;
+    isActive: boolean;
+}>;
+export declare const AddedToolTile: import('react').NamedExoticComponent<{
+    instance: AddedToolInstance;
+    toolDef: ToolDefinition | undefined;
+    isActive: boolean;
+    onSelect: () => void;
+    onRemove: () => void;
+}>;
+export declare const ToolDetailsPanel: import('react').NamedExoticComponent<{
+    tool: ToolDefinition | null;
+    instance: AddedToolInstance | null;
+    onAdd?: () => void;
+    onUpdate?: (updates: Partial<Omit<AddedToolInstance, "instanceId" | "toolId">>) => void;
+    onRemove?: () => void;
+    onAddCredential?: (request: AddCredentialRequest) => void;
+    portalContainer?: HTMLElement | null;
+}>;

package/dist/components/nodes/UniversalNode.d.ts

@@ -0,0 +1,2 @@
+import { NodeProps } from '@xyflow/react';
+export declare const UniversalNode: import('react').MemoExoticComponent<({ data, selected }: NodeProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/components/nodes/createContextAwareNodes.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Create context-wrapped node components for all known node types.
+ * Returns the base mapping; for dynamic action-based types that aren't
+ * in NODE_COMPONENTS, use `getContextAwareComponent()` at lookup time.
+ */
+export declare function createContextAwareNodes(): Record<string, React.ComponentType<any>>;

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

@@ -0,0 +1,22 @@
+import { Node, NodeProps } from '@xyflow/react';
+import { NodeExecutionStatus } from '@invect/core/types';
+export { UniversalNode } from './UniversalNode';
+export { AgentNode } from './AgentNode';
+export { NodeAppendix, type AppendixPosition } from './NodeAppendix';
+export { AgentToolsBox, type AgentToolDisplay, type ToolCategory } from './AgentToolsBox';
+export { type ToolDefinition, type AddedToolInstance } from './ToolSelectorModal';
+export { ToolParamField, type AddCredentialRequest } from './ToolParamField';
+export { NodeStatusIndicator, type NodeStatusIndicatorStatus, type NodeStatusIndicatorLoadingVariant, } from './NodeStatusIndicator';
+export { NodeViewProvider, useNodeViewContext, type NodeViewMode, type NodeViewProviderProps, } from './NodeViewContext';
+export { withNodeContext } from './withNodeContext';
+export { createContextAwareNodes } from './createContextAwareNodes';
+export { NODE_COMPONENTS, getNodeComponent, type NodeComponentType } from './nodeRegistry';
+export interface BaseNodeData {
+    description?: string;
+    icon?: string;
+    status?: string;
+    executionStatus?: NodeExecutionStatus;
+    executionOutput?: unknown;
+    executionError?: string;
+}
+export type FBNodeProps<T> = NodeProps<Node<T & BaseNodeData & Record<string, unknown>>>;

package/dist/components/nodes/nodeRegistry.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Legacy export — static mapping of known enum node types.
+ * For dynamic node type resolution (including action-based types),
+ * use `getNodeComponent()` instead.
+ */
+export declare const NODE_COMPONENTS: Record<string, import('react').ComponentType<any>>;
+/**
+ * Resolve the React component for a given node type string.
+ * Returns the custom component for known special types (e.g. AGENT),
+ * or UniversalNode as the default for everything else.
+ */
+export declare function getNodeComponent(nodeType: string): React.ComponentType<any>;
+export type NodeComponentType = string;

package/dist/components/nodes/withNodeContext.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+export declare function withNodeContext<P extends {
+    data?: Record<string, unknown>;
+    onEdit?: (...args: unknown[]) => void;
+    isStatusView?: boolean;
+    id: string;
+}>(Component: React.ComponentType<P>): React.ForwardRefExoticComponent<React.PropsWithoutRef<P> & React.RefAttributes<HTMLDivElement>>;

package/dist/components/shared/InvectLoader.d.ts

@@ -0,0 +1,8 @@
+export interface InvectLoaderProps {
+    className?: string;
+    iconClassName?: string;
+    label?: string;
+    labelClassName?: string;
+    variant?: 'theme' | 'dark' | 'light';
+}
+export declare const InvectLoader: import('react').NamedExoticComponent<InvectLoaderProps>;

package/dist/components/shared/InvectLogo.d.ts

@@ -0,0 +1,9 @@
+export interface InvectLogoProps {
+    className?: string;
+    iconClassName?: string;
+    labelClassName?: string;
+    showLabel?: boolean;
+    label?: string;
+    variant?: 'theme' | 'dark' | 'light';
+}
+export declare const InvectLogo: import('react').NamedExoticComponent<InvectLogoProps>;

package/dist/components/shared/ProviderIcon.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Resolve a Lucide icon component from its name string.
+ * Falls back to Zap if the name is not found.
+ */
+export declare const getLucideIcon: (iconName?: string) => React.ElementType;
+export interface ProviderIconProps {
+    /** Provider id — when it matches a known provider, a bundled inline SVG is rendered */
+    providerId?: string;
+    /** Lucide icon name (e.g. "Mail", "Github") */
+    icon?: string;
+    /** Raw SVG markup string — takes precedence over `icon` (legacy, prefer providerId) */
+    svgIcon?: string;
+    /** CSS class applied to the wrapper / Lucide icon component */
+    className?: string;
+}
+/**
+ * Renders a provider icon with the following priority:
+ *
+ * 1. **Bundled inline SVG** — if `providerId` matches a known provider
+ * 2. **Inline SVG string** — if `svgIcon` is provided (legacy fallback)
+ * 3. **Lucide icon** — resolved from the `icon` name string
+ */
+export declare const ProviderIcon: import('react').NamedExoticComponent<ProviderIconProps>;

package/dist/components/side-menu/side-menu.d.ts

@@ -0,0 +1,4 @@
+export interface AppSideMenuProps {
+    basePath?: string;
+}
+export declare function AppSideMenu({ basePath }: AppSideMenuProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/sidebar/BaseSidebar.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { FlowVersion } from '@invect/core/types';
+interface BaseSidebarProps {
+    title?: string;
+    lastModified?: Date;
+    author?: string;
+    className?: string;
+    children?: React.ReactNode;
+    width?: 'narrow' | 'normal' | 'wide';
+    backUrl?: string;
+    backTitle?: string;
+    versions?: FlowVersion[];
+    currentVersion?: FlowVersion;
+    onVersionChange?: (versionId: string) => void;
+}
+export declare const BaseSidebar: React.FC<BaseSidebarProps>;
+export {};

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

@@ -0,0 +1 @@
+export { BaseSidebar } from './BaseSidebar';

package/dist/components/triggers/CronPreview.d.ts

@@ -0,0 +1,12 @@
+interface CronPreviewProps {
+    /** Cron expression (e.g. "0 * * * *") */
+    expression: string;
+    /** IANA timezone (e.g. "America/New_York") */
+    timezone?: string;
+    className?: string;
+}
+/**
+ * Shows a human-readable preview of a cron expression + next fire time.
+ */
+export declare function CronPreview({ expression, timezone, className }: CronPreviewProps): import("react/jsx-runtime").JSX.Element | null;
+export default CronPreview;

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

@@ -0,0 +1 @@
+export { CronPreview } from './CronPreview';

package/dist/components/ui/alert-dialog.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+declare function AlertDialog({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogTrigger({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogPortal({ container, children, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Portal> & {
+    container?: HTMLElement | null;
+}): import("react/jsx-runtime").JSX.Element;
+declare const AlertDialogOverlay: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare function AlertDialogContent({ className, container, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Content> & {
+    container?: HTMLElement | null;
+}): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogHeader({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogFooter({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogTitle({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogDescription({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Description>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogAction({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Action>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogCancel({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Cancel>): import("react/jsx-runtime").JSX.Element;
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };

package/dist/components/ui/badge.d.ts

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

package/dist/components/ui/button.d.ts

@@ -0,0 +1,13 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "icon" | "lg" | "icon-sm" | "icon-lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const Button: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement> & VariantProps<(props?: ({
+    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "icon" | "lg" | "icon-sm" | "icon-lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string> & {
+    asChild?: boolean;
+}, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };