@definable/ui 0.1.9 → 0.1.12

package/dist/index.d.ts

@@ -4,18 +4,24 @@ import { ClassValue } from 'clsx';
 import { default as default_2 } from 'react';
 import * as DialogPrimitive from '@radix-ui/react-dialog';
 import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import { DropzoneOptions } from 'react-dropzone';
+import { editor } from 'monaco-editor';
 import { JSX as JSX_2 } from 'react/jsx-runtime';
 import * as LabelPrimitive from '@radix-ui/react-label';
 import { LucideIcon } from 'lucide-react';
+import { Monaco } from '@monaco-editor/react';
 import * as PopoverPrimitive from '@radix-ui/react-popover';
 import * as ProgressPrimitive from '@radix-ui/react-progress';
 import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
+import * as RadixContextMenu from '@radix-ui/react-context-menu';
 import * as React_2 from 'react';
+import { ReactNode } from 'react';
 import { ReactPortal } from 'react';
 import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
 import * as SelectPrimitive from '@radix-ui/react-select';
 import * as SeparatorPrimitive from '@radix-ui/react-separator';
 import * as SliderPrimitive from '@radix-ui/react-slider';
+import { SuggestionDataItem } from 'react-mentions';
 import * as SwitchPrimitives from '@radix-ui/react-switch';
 import * as TabsPrimitive from '@radix-ui/react-tabs';
 import { VariantProps } from 'class-variance-authority';
@@ -24,7 +30,29 @@ export declare const Alert: React_2.ForwardRefExoticComponent<AlertProps & React
 
 export declare const AlertDescription: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLParagraphElement> & React_2.RefAttributes<HTMLParagraphElement>>;
 
+export declare const AlertDialog: React_2.FC<AlertDialogProps>;
+
+declare interface AlertDialogProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    title?: React_2.ReactNode;
+    description?: React_2.ReactNode;
+    cancelText?: string;
+    actionText?: string;
+    onCancel?: () => void;
+    onAction?: () => void;
+    actionVariant?: "default" | "destructive";
+    className?: string;
+}
+
 export declare interface AlertProps extends React_2.HTMLAttributes<HTMLDivElement>, VariantProps<typeof alertVariants> {
+    isOpen?: boolean;
+    onClose?: () => void;
+    onConfirm?: () => void;
+    title?: string;
+    description?: string;
+    confirmText?: string;
+    cancelText?: string;
 }
 
 export declare const AlertTitle: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLHeadingElement> & React_2.RefAttributes<HTMLParagraphElement>>;
@@ -33,6 +61,42 @@ declare const alertVariants: (props?: ({
     variant?: "default" | "destructive" | null | undefined;
 } & ClassProp) | undefined) => string;
 
+export declare const ANSI: {
+    readonly RESET: "\u001B[0m";
+    readonly BOLD: "\u001B[1m";
+    readonly DIM: "\u001B[2m";
+    readonly ITALIC: "\u001B[3m";
+    readonly UNDERLINE: "\u001B[4m";
+    readonly BLINK: "\u001B[5m";
+    readonly REVERSE: "\u001B[7m";
+    readonly STRIKETHROUGH: "\u001B[9m";
+    readonly BLACK: "\u001B[30m";
+    readonly RED: "\u001B[31m";
+    readonly GREEN: "\u001B[32m";
+    readonly YELLOW: "\u001B[33m";
+    readonly BLUE: "\u001B[34m";
+    readonly MAGENTA: "\u001B[35m";
+    readonly CYAN: "\u001B[36m";
+    readonly WHITE: "\u001B[37m";
+    readonly GRAY: "\u001B[90m";
+    readonly BRIGHT_BLACK: "\u001B[90m";
+    readonly BRIGHT_RED: "\u001B[91m";
+    readonly BRIGHT_GREEN: "\u001B[92m";
+    readonly BRIGHT_YELLOW: "\u001B[93m";
+    readonly BRIGHT_BLUE: "\u001B[94m";
+    readonly BRIGHT_MAGENTA: "\u001B[95m";
+    readonly BRIGHT_CYAN: "\u001B[96m";
+    readonly BRIGHT_WHITE: "\u001B[97m";
+    readonly BG_BLACK: "\u001B[40m";
+    readonly BG_RED: "\u001B[41m";
+    readonly BG_GREEN: "\u001B[42m";
+    readonly BG_YELLOW: "\u001B[43m";
+    readonly BG_BLUE: "\u001B[44m";
+    readonly BG_MAGENTA: "\u001B[45m";
+    readonly BG_CYAN: "\u001B[46m";
+    readonly BG_WHITE: "\u001B[47m";
+};
+
 declare interface Assistant {
     provider: string;
     name: string;
@@ -54,7 +118,7 @@ export declare interface BadgeProps extends React_2.HTMLAttributes<HTMLDivElemen
 }
 
 export declare const badgeVariants: (props?: ({
-    variant?: "default" | "destructive" | "secondary" | "outline" | null | undefined;
+    variant?: "default" | "outline" | "secondary" | "destructive" | null | undefined;
 } & ClassProp) | undefined) => string;
 
 export declare function BarChart({ data }: BarChartProps): JSX_2.Element;
@@ -75,6 +139,24 @@ declare interface ButtonProps extends default_2.ButtonHTMLAttributes<HTMLButtonE
     children?: default_2.ReactNode;
 }
 
+export declare const Calendar: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & {
+    mode?: "single" | "multiple" | "range";
+    selected?: Date | Date[] | null;
+    onSelect?: (date: Date | null) => void;
+    disabled?: (date: Date) => boolean;
+    fromDate?: Date;
+    toDate?: Date;
+} & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare type CalendarProps = React_2.HTMLAttributes<HTMLDivElement> & {
+    mode?: "single" | "multiple" | "range";
+    selected?: Date | Date[] | null;
+    onSelect?: (date: Date | null) => void;
+    disabled?: (date: Date) => boolean;
+    fromDate?: Date;
+    toDate?: Date;
+};
+
 export declare const Card: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
 
 export declare const CardContent: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
@@ -232,6 +314,8 @@ declare interface CollapseProps {
     contentClassName?: string;
 }
 
+export declare const colorize: (text: string, color: string) => string;
+
 export declare interface Column<T> {
     id: string;
     header: string;
@@ -242,6 +326,100 @@ export declare interface Column<T> {
     truncate?: boolean;
 }
 
+export declare const Command: React_2.ForwardRefExoticComponent<Omit<{
+    children?: React_2.ReactNode;
+} & Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React_2.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React_2.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    label?: string;
+    shouldFilter?: boolean;
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    loop?: boolean;
+    disablePointerSelection?: boolean;
+    vimBindings?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CommandDialog: ({ children, open, onOpenChange, }: {
+    children: React_2.ReactNode;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}) => JSX_2.Element;
+
+export declare const CommandEmpty: React_2.ForwardRefExoticComponent<Omit<{
+    children?: React_2.ReactNode;
+} & Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React_2.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React_2.HTMLAttributes<HTMLDivElement> | "asChild"> & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CommandGroup: React_2.ForwardRefExoticComponent<Omit<{
+    children?: React_2.ReactNode;
+} & Omit<Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React_2.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React_2.HTMLAttributes<HTMLDivElement> | "asChild">, "value" | "heading"> & {
+    heading?: React_2.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CommandInput: React_2.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React_2.DetailedHTMLProps<React_2.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React_2.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React_2.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React_2.InputHTMLAttributes<HTMLInputElement>>, "onChange" | "type" | "value"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & React_2.RefAttributes<HTMLInputElement>, "ref"> & React_2.RefAttributes<HTMLInputElement>>;
+
+export declare const CommandItem: React_2.ForwardRefExoticComponent<Omit<{
+    children?: React_2.ReactNode;
+} & Omit<Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React_2.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React_2.HTMLAttributes<HTMLDivElement> | "asChild">, "onSelect" | "disabled" | "value"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const CommandList: React_2.ForwardRefExoticComponent<Omit<{
+    children?: React_2.ReactNode;
+} & Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React_2.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React_2.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    label?: string;
+} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare function CommandMenu({ open, onOpenChange }: CommandMenuProps): JSX_2.Element;
+
+export declare function CommandMenuDemo(): JSX_2.Element;
+
+declare type CommandMenuProps = {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+};
+
+export declare const CommandSeparator: React_2.ForwardRefExoticComponent<Omit<Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React_2.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | keyof React_2.HTMLAttributes<HTMLDivElement> | "asChild"> & {
+    alwaysRender?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
 export declare function ConfirmationModal({ isOpen, onClose, onConfirm, title, description, confirmText, cancelText, type }: ConfirmationModalProps): JSX_2.Element;
 
 declare interface ConfirmationModalProps {
@@ -255,6 +433,43 @@ declare interface ConfirmationModalProps {
     type?: 'danger' | 'warning';
 }
 
+export declare function ContextMenu({ children, menuContent, className, disabled, onContextMenuOpen, onContextMenuClose }: ContextMenuProps): JSX_2.Element;
+
+export declare const ContextMenuCheckboxItem: default_2.ForwardRefExoticComponent<Omit<RadixContextMenu.ContextMenuCheckboxItemProps & default_2.RefAttributes<HTMLDivElement>, "ref"> & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare const ContextMenuGroup: default_2.ForwardRefExoticComponent<RadixContextMenu.ContextMenuGroupProps & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare const ContextMenuItem: default_2.ForwardRefExoticComponent<Omit<RadixContextMenu.ContextMenuItemProps & default_2.RefAttributes<HTMLDivElement>, "ref"> & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare const ContextMenuLabel: default_2.ForwardRefExoticComponent<Omit<RadixContextMenu.ContextMenuLabelProps & default_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & default_2.RefAttributes<HTMLDivElement>>;
+
+declare interface ContextMenuProps {
+    children: ReactNode;
+    menuContent: ReactNode;
+    className?: string;
+    disabled?: boolean;
+    onContextMenuOpen?: () => void;
+    onContextMenuClose?: () => void;
+}
+
+export declare const ContextMenuRadioGroup: default_2.ForwardRefExoticComponent<RadixContextMenu.ContextMenuRadioGroupProps & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare const ContextMenuRadioItem: default_2.ForwardRefExoticComponent<Omit<RadixContextMenu.ContextMenuRadioItemProps & default_2.RefAttributes<HTMLDivElement>, "ref"> & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare const ContextMenuSeparator: default_2.ForwardRefExoticComponent<Omit<RadixContextMenu.ContextMenuSeparatorProps & default_2.RefAttributes<HTMLDivElement>, "ref"> & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare const ContextMenuSub: default_2.FC<RadixContextMenu.ContextMenuSubProps>;
+
+export declare const ContextMenuSubContent: default_2.ForwardRefExoticComponent<Omit<RadixContextMenu.ContextMenuSubContentProps & default_2.RefAttributes<HTMLDivElement>, "ref"> & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare const ContextMenuSubTrigger: default_2.ForwardRefExoticComponent<Omit<RadixContextMenu.ContextMenuSubTriggerProps & default_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare const defaultOptions: editor.IEditorOptions;
+
 export declare const Dialog: ({ ...props }: {
     [x: string]: any;
 }) => JSX_2.Element;
@@ -301,6 +516,17 @@ export declare const DropdownMenuSeparator: React_2.ForwardRefExoticComponent<Dr
 
 export declare const DropdownMenuTrigger: React_2.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
 
+export declare function Dropzone({ onDrop, children, className, overlayClassName, dropzoneOptions, showOverlay, }: DropzoneProps): JSX_2.Element;
+
+declare interface DropzoneProps {
+    onDrop: (acceptedFiles: File[]) => void;
+    children: ReactNode;
+    className?: string;
+    overlayClassName?: string;
+    dropzoneOptions?: Omit<DropzoneOptions, 'onDrop'>;
+    showOverlay?: boolean;
+}
+
 export declare const getAssistantIcon: (assistant: Assistant, props?: Props) => JSX_2.Element;
 
 export declare const getLLMIcon: (provider: string, props?: Props) => JSX_2.Element;
@@ -319,6 +545,29 @@ export declare const Icons: {
     gemini: (props: IconProps) => JSX_2.Element;
 };
 
+export declare function ImageCropper({ value, onChange, size, className, placeholder, title, outputSize }: ImageCropperProps): JSX_2.Element;
+
+export declare function ImageCropperModal({ isOpen, onClose, imageSrc, onCrop, title, outputSize }: ImageCropperModalProps): JSX_2.Element | null;
+
+declare interface ImageCropperModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    imageSrc: string | null;
+    onCrop: (croppedImage: string) => void;
+    title?: string;
+    outputSize?: number;
+}
+
+declare interface ImageCropperProps {
+    value?: string | null;
+    onChange: (croppedImage: string | null) => void;
+    size?: number;
+    className?: string;
+    placeholder?: string;
+    title?: string;
+    outputSize?: number;
+}
+
 export declare const Input: React_2.ForwardRefExoticComponent<InputProps & React_2.RefAttributes<HTMLInputElement>>;
 
 export declare interface InputProps extends React_2.InputHTMLAttributes<HTMLInputElement> {
@@ -326,6 +575,8 @@ export declare interface InputProps extends React_2.InputHTMLAttributes<HTMLInpu
 
 export declare const Label: React_2.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React_2.RefAttributes<HTMLLabelElement>, "ref"> & React_2.RefAttributes<HTMLLabelElement>>;
 
+export declare const languageOptions: Record<MonacoEditorLanguage, editor.IEditorOptions>;
+
 export declare function LineChart({ data }: LineChartProps): JSX_2.Element;
 
 declare interface LineChartProps {
@@ -352,6 +603,14 @@ declare interface LoadingPlaceholderProps {
     variant?: 'pulse' | 'shimmer';
 }
 
+export declare const LOG_COLORS: {
+    readonly error: "\u001B[31m";
+    readonly warning: "\u001B[33m";
+    readonly success: "\u001B[32m";
+    readonly info: "\u001B[34m";
+    readonly debug: "\u001B[90m";
+};
+
 export declare const Markdown: default_2.FC<MarkdownProps>;
 
 declare interface MarkdownProps {
@@ -361,6 +620,31 @@ declare interface MarkdownProps {
     isDark?: boolean;
 }
 
+export declare const Mention: default_2.ForwardRefExoticComponent<MentionProps & default_2.RefAttributes<HTMLDivElement>>;
+
+export declare interface MentionProps {
+    value: string;
+    onChange: (event: {
+        target: {
+            value: string;
+        };
+    }) => void;
+    placeholder?: string;
+    data: MentionUserData[];
+    disabled?: boolean;
+    className?: string;
+    inputClassName?: string;
+    suggestionItemClassName?: string;
+    trigger?: string;
+    displayTransform?: (id: string, display: string) => string;
+    onKeyDown?: (e: default_2.KeyboardEvent) => void;
+}
+
+export declare interface MentionUserData extends SuggestionDataItem {
+    avatar?: string;
+    subtitle?: string;
+}
+
 export declare function Modal({ isOpen, onClose, title, description, icon, children, footer, size, showClose, className, isContentScrollable, mainClassName, contentClassName, header, zIndexClassName }: ModalProps): ReactPortal;
 
 export declare interface ModalProps {
@@ -382,18 +666,53 @@ export declare interface ModalProps {
     zIndexClassName?: string;
 }
 
+export declare function MonacoEditor({ value, onChange, language, height, className, options, onMount, title, variables, variablePrefix, variableSuffix, predefinedVariables, allowFullscreen, isDark, }: MonacoEditorProps): JSX_2.Element;
+
+export declare type MonacoEditorLanguage = 'javascript' | 'typescript' | 'python' | 'json' | 'html' | 'css' | 'markdown' | 'plaintext';
+
+export declare interface MonacoEditorProps {
+    value: string;
+    onChange?: (value: string) => void;
+    language?: MonacoEditorLanguage;
+    height?: string | number;
+    className?: string;
+    options?: editor.IEditorOptions;
+    onMount?: (editor: editor.IStandaloneCodeEditor, monaco: Monaco) => void;
+    title?: string;
+    variables?: VariableSuggestion[];
+    variablePrefix?: string;
+    variableSuffix?: string;
+    predefinedVariables?: PredefinedVariable[];
+    allowFullscreen?: boolean;
+    isDark?: boolean;
+}
+
 export declare function NotificationContainer({ isDark }?: NotificationContainerProps): JSX_2.Element;
 
 declare interface NotificationContainerProps {
     isDark?: boolean;
 }
 
+export declare interface ObjectProperty {
+    name: string;
+    type: string;
+    documentation?: string;
+}
+
 export declare const Popover: React_2.FC<PopoverPrimitive.PopoverProps>;
 
 export declare const PopoverContent: React_2.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
 
 export declare const PopoverTrigger: React_2.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
 
+export declare interface PredefinedVariable {
+    name: string;
+    type: string;
+    documentation?: string;
+    properties?: ObjectProperty[];
+    isObject?: boolean;
+}
+
 export declare const Progress: React_2.ForwardRefExoticComponent<Omit<ProgressPrimitive.ProgressProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
 
 declare interface Props {
@@ -450,6 +769,11 @@ export declare const SelectValue: React_2.ForwardRefExoticComponent<SelectPrimit
 
 export declare const Separator: React_2.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
 
+/**
+ * Setup variable suggestions for Monaco editor
+ */
+export declare function setupVariableSuggestions(editor: editor.IStandaloneCodeEditor, monaco: Monaco, variables: VariableSuggestion[], config: VariableSuggestionProviderConfig): () => void;
+
 export declare function Sheet({ isOpen, onClose, children, header, footer, className, enableFullscreen, position, headerClassName }: SheetProps): ReactPortal | null;
 
 declare interface SheetProps {
@@ -464,8 +788,59 @@ declare interface SheetProps {
     headerClassName?: string;
 }
 
+export declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): JSX_2.Element;
+
 export declare const Slider: React_2.ForwardRefExoticComponent<Omit<SliderPrimitive.SliderProps & React_2.RefAttributes<HTMLSpanElement>, "ref"> & React_2.RefAttributes<HTMLSpanElement>>;
 
+export declare interface Step {
+    title: string;
+    description: string;
+    isCompleted: boolean;
+    isCurrent: boolean;
+}
+
+export declare function StepLayout({ children, title, sidebar, subclassName, }: StepLayoutProps): JSX_2.Element;
+
+declare interface StepLayoutProps {
+    children: React.ReactNode;
+    title?: string;
+    sidebar?: React.ReactNode;
+    subclassName?: string;
+}
+
+export declare function Stepper({ steps, className }: StepperProps): JSX_2.Element;
+
+export declare function StepperModal({ isOpen, onClose, title, description, icon: Icon, currentStep, totalSteps, onBack, onNext, onComplete, sidebar, children, continueText, completeText, isNextDisabled, isNextLoading, size, stepLayoutSubclassName, isShowBackButton, isModelContentScrollable }: StepperModalProps): JSX_2.Element;
+
+declare interface StepperModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    title: string;
+    description?: string;
+    icon?: React.ComponentType<any>;
+    currentStep: number;
+    totalSteps: number;
+    onBack: () => void;
+    onNext: () => void;
+    onComplete: () => void;
+    sidebar: React.ReactNode;
+    children: React.ReactNode;
+    continueText?: string;
+    completeText?: string;
+    isNextDisabled?: boolean;
+    isNextLoading?: boolean;
+    size?: ModalProps['size'];
+    stepLayoutSubclassName?: string;
+    isShowClose?: boolean;
+    isShowBackButton?: boolean;
+    isModelContentScrollable?: boolean;
+}
+
+declare interface StepperProps {
+    steps: Step[];
+    className?: string;
+}
+
 export declare const Switch: React_2.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
 
 export declare function Table<T extends {
@@ -482,6 +857,10 @@ declare interface TableEmptyProps {
     icon?: React.ReactNode;
 }
 
+export declare function TableMobile<T extends {
+    id: string;
+}>({ data, columns, showCheckbox, onRowClick, selectedItems, onSelect, isLoading, loadingRows }: TableProps<T>): JSX_2.Element | null;
+
 export declare interface TableProps<T> {
     data: T[];
     columns: Column<T>[];
@@ -515,6 +894,23 @@ export declare const Textarea: React_2.ForwardRefExoticComponent<TextareaProps &
 export declare interface TextareaProps extends React_2.TextareaHTMLAttributes<HTMLTextAreaElement> {
 }
 
+declare type Toast = ToastProps & {
+    id: string;
+};
+
+export declare const toast: (props: ToastProps) => {
+    dismiss: () => void;
+};
+
+export declare const ToastContainer: () => JSX_2.Element | null;
+
+declare type ToastProps = {
+    title: string;
+    description?: string;
+    type?: 'default' | 'success' | 'error' | 'warning';
+    duration?: number;
+};
+
 export declare function Tooltip({ content, side, align, isVisible }: TooltipProps): JSX_2.Element;
 
 declare interface TooltipProps {
@@ -524,4 +920,39 @@ declare interface TooltipProps {
     isVisible: boolean;
 }
 
+/**
+ * Update variables for an existing provider
+ * Creates a new provider with the updated variables
+ */
+export declare function updateVariableSuggestions(editor: editor.IStandaloneCodeEditor, monaco: Monaco, variables: VariableSuggestion[], config: VariableSuggestionProviderConfig): void;
+
+export declare const useToast: () => {
+    toast: (props: ToastProps) => {
+        dismiss: () => void;
+    };
+    toasts: Toast[];
+    dismiss: (id: string) => void;
+};
+
+export declare interface VariableSuggestion {
+    name: string;
+    type?: string;
+    description?: string;
+    value?: string;
+}
+
+declare type VariableSuggestionProviderConfig = {
+    language: string;
+    variablePrefix: string;
+    variableSuffix: string;
+};
+
+export declare interface VariableSuggestionsProps {
+    variables: VariableSuggestion[];
+    variablePrefix: string;
+    variableSuffix: string;
+    onClose: () => void;
+    onSelect: (variable: VariableSuggestion) => void;
+}
+
 export { }