import * as React$1 from 'react';
import React__default from 'react';
import { EditorProps } from '@monaco-editor/react';
export { getFormattedDate, useDeviceSupport, useGridClasses, useShortcutFormatter, useSound } from './sdk.cjs';

interface ButtonProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
    variant?: "primary" | "secondary" | "outline" | "ghost" | "danger" | "success" | "filled" | "text";
    tone?: "primary" | "neutral" | "success" | "danger";
    size?: "sm" | "md" | "lg" | "xl";
    loading?: boolean;
    leftIcon?: React__default.ReactNode;
    rightIcon?: React__default.ReactNode;
    fullWidth?: boolean;
    rounded?: "sm" | "md" | "lg" | "full";
}
declare const Button: React__default.ForwardRefExoticComponent<ButtonProps & React__default.RefAttributes<HTMLButtonElement>>;

interface InputProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, 'size'> {
    variant?: "default" | "filled" | "outline";
    size?: "sm" | "md" | "lg";
    leftIcon?: React__default.ReactNode;
    rightIcon?: React__default.ReactNode;
    showSubmitButton?: boolean;
    onSubmit?: () => void;
    error?: string;
    label?: string;
    helperText?: string;
    fullWidth?: boolean;
}
declare const Input: React__default.ForwardRefExoticComponent<InputProps & React__default.RefAttributes<HTMLInputElement>>;

interface TextAreaProps extends React__default.TextareaHTMLAttributes<HTMLTextAreaElement> {
    variant?: "default" | "filled" | "outline";
    size?: "sm" | "md" | "lg";
    error?: string;
    label?: string;
    helperText?: string;
    fullWidth?: boolean;
    resize?: "none" | "vertical" | "horizontal" | "both";
}
declare const TextArea: React__default.ForwardRefExoticComponent<TextAreaProps & React__default.RefAttributes<HTMLTextAreaElement>>;

interface CodeEditorProps {
    value: string;
    onChange: (value: string) => void;
    language?: EditorProps["language"];
    height?: EditorProps["height"];
    options?: EditorProps["options"];
    className?: string;
    isDarkTheme?: boolean;
}
type JsonEditorProps = CodeEditorProps;
declare const CodeEditor: React__default.FC<CodeEditorProps>;

interface RichEditorProps {
    content: string;
    onChange: (content: string) => void;
    isDarkTheme?: boolean;
}
declare const RichEditor: ({ content, onChange, isDarkTheme }: RichEditorProps) => React$1.JSX.Element;

interface SelectOption {
    value: string;
    label: string;
    disabled?: boolean;
}
interface SelectProps extends Omit<React__default.SelectHTMLAttributes<HTMLSelectElement>, 'onChange' | 'size'> {
    options: SelectOption[];
    variant?: "default" | "filled" | "outline";
    size?: "sm" | "md" | "lg";
    error?: string;
    label?: string;
    helperText?: string;
    fullWidth?: boolean;
    onChange?: (value: string) => void;
    placeholder?: string;
}
declare const Select: React__default.ForwardRefExoticComponent<SelectProps & React__default.RefAttributes<HTMLSelectElement>>;

interface CheckboxProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, 'type' | 'size'> {
    variant?: "default" | "filled";
    size?: "sm" | "md" | "lg";
    error?: string;
    label?: React__default.ReactNode;
    helperText?: string;
    indeterminate?: boolean;
}
declare const Checkbox: React__default.ForwardRefExoticComponent<CheckboxProps & React__default.RefAttributes<HTMLInputElement>>;

interface ToggleProps {
    checked: boolean;
    onChange: (checked: boolean) => void;
    variant?: "default" | "success" | "warning" | "danger";
    size?: "sm" | "md" | "lg";
    disabled?: boolean;
    label?: string;
    helperText?: string;
    fullWidth?: boolean;
}
declare const Toggle: React__default.ForwardRefExoticComponent<ToggleProps & React__default.RefAttributes<HTMLButtonElement>>;

interface DropdownOption {
    value: string;
    label: string;
    disabled?: boolean;
    icon?: React__default.ReactNode;
}
interface DropdownProps {
    options: DropdownOption[];
    value?: string;
    onChange?: (value: string) => void;
    placeholder?: string;
    variant?: "default" | "filled" | "outline";
    size?: "sm" | "md" | "lg";
    disabled?: boolean;
    className?: string;
    trigger?: React__default.ReactNode;
}
declare const Dropdown: React__default.FC<DropdownProps>;

interface LoadingProps {
    variant?: "spinner" | "dots" | "pulse" | "image";
    size?: "sm" | "md" | "lg" | "xl";
    text?: string;
    fullScreen?: boolean;
    className?: string;
}
declare const Loading: React__default.FC<LoadingProps>;

interface SkeletonProps extends React__default.HTMLAttributes<HTMLDivElement> {
    variant?: "text" | "avatar" | "image" | "card" | "rect";
    lines?: number;
    lineClassName?: string;
    animate?: boolean;
}
declare const Skeleton: React__default.FC<SkeletonProps>;

interface ToastProps {
    heading?: string;
    message: string;
    type: "error" | "success" | "info" | "warning";
    isVisible: boolean;
    onClose: () => void;
    duration?: number;
    position?: "top-left" | "top-right" | "bottom-left" | "bottom-right" | "top-center" | "bottom-center";
    showCloseButton?: boolean;
    className?: string;
}
declare const Toast: React__default.FC<ToastProps>;

interface AlertProps {
    type: "success" | "error" | "warning" | "info";
    title?: string;
    message?: string;
    onClose?: () => void;
    showCloseButton?: boolean;
    variant?: "default" | "filled" | "outline";
    className?: string;
    children?: React__default.ReactNode;
}
declare const Alert: React__default.FC<AlertProps>;

interface ModalProps {
    isOpen: boolean;
    onClose: () => void;
    title?: string;
    children: React__default.ReactNode;
    size?: "sm" | "md" | "lg" | "xl" | "full";
    showCloseButton?: boolean;
    closeOnOverlayClick?: boolean;
    closeOnEscape?: boolean;
    className?: string;
}
declare const Modal: React__default.FC<ModalProps>;

interface CardProps extends React__default.HTMLAttributes<HTMLDivElement> {
    variant?: "default" | "elevated" | "outlined" | "filled";
    padding?: "none" | "sm" | "md" | "lg";
    children: React__default.ReactNode;
}
declare const Card: React__default.ForwardRefExoticComponent<CardProps & React__default.RefAttributes<HTMLDivElement>>;

interface BadgeProps extends React__default.HTMLAttributes<HTMLSpanElement> {
    variant?: "default" | "primary" | "success" | "warning" | "danger" | "info";
    size?: "sm" | "md" | "lg";
    rounded?: "sm" | "md" | "lg" | "full";
    children: React__default.ReactNode;
}
declare const Badge: React__default.ForwardRefExoticComponent<BadgeProps & React__default.RefAttributes<HTMLSpanElement>>;

interface AvatarProps {
    src?: string;
    alt?: string;
    size?: "sm" | "md" | "lg" | "xl";
    fallback?: string;
    className?: string;
    onClick?: () => void;
}
declare const Avatar: React__default.FC<AvatarProps>;

interface DividerProps {
    orientation?: "horizontal" | "vertical";
    variant?: "solid" | "dashed" | "dotted";
    size?: "sm" | "md" | "lg";
    className?: string;
}
declare const Divider: React__default.FC<DividerProps>;

interface TooltipProps {
    content: string;
    children: React__default.ReactNode;
    position?: "top" | "bottom" | "left" | "right";
    delay?: number;
    className?: string;
}
declare const Tooltip: React__default.FC<TooltipProps>;

interface SearchInputProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, "type" | "size"> {
    onSearch?: (value: string) => void;
    placeholder?: string;
    variant?: "default" | "filled" | "outline";
    size?: "sm" | "md" | "lg";
    showClearButton?: boolean;
    className?: string;
    enableKeyboardShortcuts?: boolean;
    isActive?: boolean;
}
declare const SearchInput: React__default.ForwardRefExoticComponent<SearchInputProps & React__default.RefAttributes<HTMLInputElement>>;

interface FileUploadProps {
    onFileSelect?: (files: File[]) => void;
    accept?: string;
    multiple?: boolean;
    maxSize?: number;
    variant?: "default" | "filled" | "outline";
    size?: "sm" | "md" | "lg";
    disabled?: boolean;
    className?: string;
    children?: React__default.ReactNode;
    dragAndDrop?: boolean;
}
declare const FileUpload: React__default.FC<FileUploadProps>;

interface ProgressProps {
    value: number;
    max?: number;
    variant?: "default" | "success" | "warning" | "danger";
    size?: "sm" | "md" | "lg";
    showLabel?: boolean;
    animated?: boolean;
    className?: string;
}
declare const Progress: React__default.FC<ProgressProps>;

interface PaginationProps {
    currentPage: number;
    totalPages: number;
    onPageChange: (page: number) => void;
    showFirstLast?: boolean;
    showPrevNext?: boolean;
    maxVisiblePages?: number;
    size?: "sm" | "md" | "lg";
    variant?: "default" | "outline";
    className?: string;
}
declare const Pagination: React__default.FC<PaginationProps>;

interface RadioProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, 'type' | 'size'> {
    label?: string;
    size?: "sm" | "md" | "lg";
    variant?: "default" | "filled";
    error?: string;
    helperText?: string;
}
declare const Radio: React__default.ForwardRefExoticComponent<RadioProps & React__default.RefAttributes<HTMLInputElement>>;

interface AccordionItem {
    title: string;
    content: React__default.ReactNode;
}
interface AccordionProps {
    items: AccordionItem[];
    active?: number;
}
declare const Accordion: React__default.FC<AccordionProps>;

interface TabItem {
    label: string;
    content: React__default.ReactNode;
    icon?: React__default.ReactNode;
}
interface TabsProps {
    tabs: TabItem[];
    defaultActiveTab?: number;
    onTabChange?: (index: number) => void;
    containerClassName?: string;
    buttonClassName?: string;
    activeButtonClassName?: string;
}
declare const Tabs: React__default.FC<TabsProps>;

type Variant = "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "p" | "span" | "div";
type Size = "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "4xl" | "5xl";
type Weight = "thin" | "extralight" | "light" | "normal" | "medium" | "semibold" | "bold" | "extrabold" | "black";
type Color = "neutral-100" | "neutral-200" | "neutral-300" | "neutral-400" | "neutral-500" | "neutral-600" | "neutral-700" | "neutral-800" | "neutral-900" | "brand-color" | "red-500" | "green-500" | "blue-500" | "yellow-500";
interface TypographyProps {
    as?: Variant;
    variant?: Variant;
    size?: Size;
    weight?: Weight;
    color?: Color;
    className?: string;
    children: React__default.ReactNode;
}
declare const Typography: React__default.FC<TypographyProps>;

type ImageSource = string | {
    src: string;
};
interface ImageWithPlaceholderProps extends Omit<React__default.ImgHTMLAttributes<HTMLImageElement>, "src"> {
    src?: ImageSource;
    fallbackSrc?: string;
}
declare const ImageWithPlaceholder: React__default.FC<ImageWithPlaceholderProps>;

interface OfficePreviewProps {
    base64: string;
    fileName: string;
    className?: string;
}

declare const OfficePreview: React__default.FC<OfficePreviewProps>;

interface PdfPreviewProps {
    base64: string;
    fileName: string;
    className?: string;
}
declare const PdfPreview: React__default.FC<PdfPreviewProps>;

interface PreviewComponentProps {
    fileName: string;
    base64: string;
    className?: string;
}
declare const PreviewComponent: React__default.FC<PreviewComponentProps>;

interface AppMetadata {
    title: string;
    description: string;
    ogImage?: string;
    keywords?: string;
    author?: string;
    siteName?: string;
}
interface AppInterface {
    name: string;
    slug: string;
    icon?: string;
    componentKey?: string;
    isActive: boolean;
    isMinimize: boolean;
    windowSize: {
        windowSize: {
            width: number;
            height: number;
        };
        isAppWindowResizing?: boolean;
    };
    metadata?: Partial<AppMetadata>;
    callback?: (value: "CLOSE_APP" | "CLICKED" | "MINIMIZE_APP") => void;
}

interface PluginSetting {
    key: string;
    label: string;
    type: "text" | "number" | "boolean" | "select" | "color";
    defaultValue?: unknown;
    options?: {
        label: string;
        value: unknown;
    }[];
    description?: string;
}
interface PluginWindowSize {
    windowSize: {
        width: number;
        height: number;
    };
    isAppWindowResizing: boolean;
}
interface PluginManifest {
    name: string;
    slug: string;
    version: string;
    author: string;
    description: string;
    keywords?: string[];
    icon?: string;
    entryPoint: string;
    permissions: string[];
    settings: PluginSetting[];
    category?: string;
    windowSize?: PluginWindowSize;
    repository?: string;
    minWidth?: number;
    minHeight?: number;
    isResizing?: boolean;
}
interface PluginAPI {
    showToast: (message: string, type: "success" | "error" | "info") => void;
    openApp: (app: AppInterface) => void;
    getUser: () => Promise<any>;
    getToken: () => Promise<string>;
    isDarkTheme?: boolean;
}
interface PluginComponentProps {
    api?: PluginAPI;
    app: AppInterface;
}

type WindowVariant = "with-side-menu" | "without-side-menu";
interface PlaygroundMenuItem {
    title: string;
    icon?: string;
    isActive?: boolean;
}
interface PlaygroundMenu {
    title: string;
    items: PlaygroundMenuItem[];
}
interface PlaygroundActionButton {
    title: string;
}
interface PluginPlaygroundMetadata extends Partial<PluginManifest> {
    title?: string;
    defaultWidth?: number;
    defaultHeight?: number;
    minWidth?: number;
    minHeight?: number;
    windowVariant?: WindowVariant;
    menu?: PlaygroundMenu;
    actionButton?: PlaygroundActionButton;
    backgroundImage?: string;
}
interface PluginPlaygroundProps {
    children: React.ReactNode | ((props: PluginComponentProps) => React.ReactNode);
    metadata: PluginPlaygroundMetadata;
    backgroundImage?: string;
}
declare function PluginPlayground({ children, metadata, backgroundImage, }: Readonly<PluginPlaygroundProps>): React$1.JSX.Element;

type ActionButton = {
    title: string;
    onClick: () => void;
};
type MenuItem = {
    title: string;
    icon: React__default.ReactNode;
    onClick: () => void;
    isActive?: boolean;
};
interface WindowWithSideMenuProps {
    app: AppInterface;
    children?: React__default.ReactNode;
    defaultSize?: {
        width: number;
        height: number;
    };
    isResizable?: boolean;
    actionButtons?: ActionButton;
    menu?: {
        title: string;
        items: MenuItem[];
    };
}
declare const WindowWithSideMenu: React__default.FC<WindowWithSideMenuProps>;

interface WindowWithoutSideMenuProps {
    app: AppInterface;
    children?: React__default.ReactNode;
    defaultSize?: {
        width: number;
        height: number;
    };
    isResizable?: boolean;
}
declare const WindowWithoutSideMenu: React__default.FC<WindowWithoutSideMenuProps>;

declare const Table: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableElement> & React$1.RefAttributes<HTMLTableElement>>;
declare const TableHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
declare const TableBody: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
declare const TableFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
declare const TableRow: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableRowElement> & React$1.RefAttributes<HTMLTableRowElement>>;
declare const TableHead: React$1.ForwardRefExoticComponent<React$1.ThHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
declare const TableCell: React$1.ForwardRefExoticComponent<React$1.TdHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
declare const TableCaption: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCaptionElement> & React$1.RefAttributes<HTMLTableCaptionElement>>;

export { Accordion, Alert, type AlertProps, type AppInterface, Avatar, type AvatarProps, Badge, type BadgeProps, Button, type ButtonProps, Card, type CardProps, Checkbox, type CheckboxProps, CodeEditor, type CodeEditorProps, Divider, Dropdown, type DropdownOption, type DropdownProps, PreviewComponent as FilePreview, FileUpload, type FileUploadProps, ImageWithPlaceholder, type ImageWithPlaceholderProps, Input, type InputProps, type JsonEditorProps, Loading, type LoadingProps, Modal, type ModalProps, OfficePreview, type OfficePreviewProps, Pagination, type PaginationProps, PdfPreview, type PdfPreviewProps, PluginPlayground, PreviewComponent, type PreviewComponentProps, Progress, type ProgressProps, Radio, type RadioProps, RichEditor, type RichEditorProps, SearchInput, type SearchInputProps, Select, type SelectOption, type SelectProps, Skeleton, type SkeletonProps, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, TextArea, type TextAreaProps, Toast, type ToastProps, Toggle, type ToggleProps, Tooltip, type TooltipProps, Typography, type TypographyProps, WindowWithSideMenu, WindowWithoutSideMenu };