@moontra/moonui-pro/dist/index.d.ts

Premium React components for MoonUI - Advanced UI library with 50+ pro components including performance, interactive, and gesture components

import { ClassValue } from 'clsx';
import * as React$1 from 'react';
import React__default, { ReactNode, ErrorInfo } from 'react';
import * as AccordionPrimitive from '@radix-ui/react-accordion';
import * as class_variance_authority_dist_types from 'class-variance-authority/dist/types';
import { VariantProps } from 'class-variance-authority';
import * as AvatarPrimitive from '@radix-ui/react-avatar';
import * as react_jsx_runtime from 'react/jsx-runtime';
import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
import { Command } from 'cmdk';
import * as SheetPrimitive from '@radix-ui/react-dialog';
import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
import * as LabelPrimitive from '@radix-ui/react-label';
import * as PopoverPrimitive from '@radix-ui/react-popover';
import * as ProgressPrimitive from '@radix-ui/react-progress';
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 SwitchPrimitives from '@radix-ui/react-switch';
import * as TabsPrimitive from '@radix-ui/react-tabs';
import * as ToastPrimitives from '@radix-ui/react-toast';
import * as TogglePrimitive from '@radix-ui/react-toggle';
import * as TooltipPrimitive from '@radix-ui/react-tooltip';
import * as HoverCardPrimitive from '@radix-ui/react-hover-card';
import { ColumnDef, OnChangeFn, SortingState, ColumnFiltersState } from '@tanstack/react-table';
export { ColumnDef } from '@tanstack/react-table';

declare function cn(...inputs: ClassValue[]): string;

declare const MoonUIAccordionPro: React$1.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUIAccordionItemPro: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUIAccordionTriggerPro: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
declare const MoonUIAccordionContentPro: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;

/**
 * Alert Component
 *
 * Yüksek kaliteli, özelleştirilebilir ve erişilebilir alert bileşeni.
 * Bildirim, uyarı ve dikkat çekmek gereken içerikler için kullanılır.
 */
declare const MoonUIalertVariantsPro: (props?: ({
    variant?: "default" | "primary" | "success" | "warning" | "error" | "info" | null | undefined;
    size?: "default" | "sm" | "lg" | null | undefined;
    radius?: "none" | "default" | "sm" | "lg" | "full" | null | undefined;
    withClose?: boolean | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface AlertProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof MoonUIalertVariantsPro> {
    /** Alert ikonunu gizler */
    hideIcon?: boolean;
    /** Kapatma butonu ekler */
    closable?: boolean;
    /** Kapatma butonu tıklandığında çalışacak fonksiyon */
    onClose?: () => void;
}
declare const MoonUIAlertPro: React$1.ForwardRefExoticComponent<AlertProps & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUIAlertTitlePro: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & React$1.RefAttributes<HTMLParagraphElement>>;
declare const MoonUIAlertDescriptionPro: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;

/**
 * Premium Aspect Ratio Component
 *
 * Advanced component that maintains specific aspect ratios with preset support,
 * responsive behavior, animations, and enhanced styling options.
 * Perfect for images, videos, and media content in modern applications.
 */
declare const PRESET_RATIOS: {
    readonly square: 1;
    readonly video: number;
    readonly portrait: number;
    readonly landscape: number;
    readonly golden: 1.618;
    readonly ultrawide: number;
    readonly cinema: 2.39;
    readonly instagram: number;
    readonly story: number;
    readonly banner: number;
};
type PresetRatio = keyof typeof PRESET_RATIOS;
interface ResponsiveRatio {
    sm?: number | PresetRatio;
    md?: number | PresetRatio;
    lg?: number | PresetRatio;
    xl?: number | PresetRatio;
    "2xl"?: number | PresetRatio;
}
declare const MoonUIaspectRatioVariantsPro: (props?: ({
    variant?: "default" | "ghost" | "outline" | "card" | "glass" | "gradient" | null | undefined;
    radius?: "none" | "sm" | "lg" | "full" | "md" | "xl" | "2xl" | null | undefined;
    animate?: boolean | null | undefined;
    hover?: boolean | null | undefined;
    loading?: boolean | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface AspectRatioProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof MoonUIaspectRatioVariantsPro> {
    /**
     * Aspect ratio (width/height). For example 16/9, 4/3, 1/1 etc.
     * @default 16/9
     */
    ratio?: number;
    /**
     * Preset aspect ratio for quick usage
     */
    preset?: PresetRatio;
    /**
     * Responsive aspect ratios for different breakpoints
     */
    responsive?: ResponsiveRatio;
    /**
     * Enable smooth aspect ratio changes
     */
    smoothTransition?: boolean;
    /**
     * Add overlay content
     */
    overlay?: React$1.ReactNode;
    /**
     * Overlay position
     */
    overlayPosition?: "center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
    /**
     * Show loading skeleton
     */
    skeleton?: boolean;
}
declare const MoonUIAspectRatioPro: React$1.ForwardRefExoticComponent<AspectRatioProps & React$1.RefAttributes<HTMLDivElement>>;

declare const moonUIAvatarVariantsPro: (props?: ({
    size?: "default" | "sm" | "lg" | "md" | "xl" | "2xl" | "xs" | null | undefined;
    radius?: "none" | "default" | "sm" | "lg" | "full" | null | undefined;
    variant?: "default" | "border" | "ring" | "ringOffset" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface MoonUIAvatarProProps extends React$1.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root>, VariantProps<typeof moonUIAvatarVariantsPro> {
}
declare const MoonUIAvatarPro: React$1.ForwardRefExoticComponent<MoonUIAvatarProProps & React$1.RefAttributes<HTMLSpanElement>>;
declare const MoonUIAvatarImagePro: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React$1.RefAttributes<HTMLImageElement>, "ref"> & React$1.RefAttributes<HTMLImageElement>>;
declare const MoonUIAvatarFallbackPro: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React$1.RefAttributes<HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;

/**
 * Premium Badge Component
 *
 * Durum, kategori ve etiketleme için yüksek kaliteli badge bileşeni.
 * Dark ve light modda uyumlu, erişilebilir ve çeşitli varyantlar sunar.
 */
declare const moonUIBadgeVariantsPro: (props?: ({
    variant?: "primary" | "success" | "warning" | "ghost" | "outline" | "secondary" | "destructive" | "pro" | "admin" | null | undefined;
    size?: "sm" | "lg" | "md" | null | undefined;
    radius?: "none" | "default" | "sm" | "lg" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface MoonUIBadgeProProps extends React$1.HTMLAttributes<HTMLDivElement>, Omit<VariantProps<typeof moonUIBadgeVariantsPro>, 'variant'> {
    withDot?: boolean;
    dotColor?: string;
    removable?: boolean;
    onRemove?: () => void;
    leftIcon?: React$1.ReactNode;
    rightIcon?: React$1.ReactNode;
    variant?: 'primary' | 'secondary' | 'destructive' | 'outline' | 'success' | 'warning' | 'ghost' | 'pro' | 'admin';
}
/**
 * Premium Badge Component
 *
 * @param props - Badge bileşeni özellikleri
 * @param props.variant - Badgenin görsel varyantı
 * @param props.size - Badge boyutu
 * @param props.radius - Köşe yuvarlama stili
 * @param props.withDot - Başında nokta gösterimi
 * @param props.dotColor - Noktanın rengi (özel)
 * @param props.removable - Kaldırılabilir badge (X simgesi ile)
 * @param props.onRemove - Kaldırma işlevi
 * @param props.leftIcon - Badge'in solunda görüntülenecek ikon
 * @param props.rightIcon - Badge'in sağında görüntülenecek ikon
 */
declare function MoonUIBadgePro({ className, variant, size, radius, withDot, dotColor, removable, onRemove, leftIcon, rightIcon, children, ...props }: MoonUIBadgeProProps): react_jsx_runtime.JSX.Element;

declare const MoonUIbreadcrumbVariantsPro: (props?: ({
    variant?: "default" | "ghost" | "muted" | null | undefined;
    size?: "default" | "sm" | "lg" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface BreadcrumbProps extends React$1.HTMLAttributes<HTMLElement>, VariantProps<typeof MoonUIbreadcrumbVariantsPro> {
    separator?: React$1.ReactNode;
    showHomeIcon?: boolean;
}
interface BreadcrumbListProps extends React$1.HTMLAttributes<HTMLOListElement> {
    collapsed?: boolean;
    collapsedWidth?: number;
}
interface BreadcrumbItemProps extends React$1.HTMLAttributes<HTMLLIElement> {
    isCurrent?: boolean;
    href?: string;
    asChild?: boolean;
}
interface BreadcrumbSeparatorProps extends React$1.HTMLAttributes<HTMLSpanElement> {
    /** Custom separator icon or text */
    icon?: React$1.ReactNode;
}
interface BreadcrumbEllipsisProps extends React$1.HTMLAttributes<HTMLSpanElement> {
    /** Custom ellipsis icon */
    icon?: React$1.ReactNode;
}
declare const MoonUIBreadcrumbPro: React$1.ForwardRefExoticComponent<BreadcrumbProps & React$1.RefAttributes<HTMLElement>>;
declare const MoonUIBreadcrumbListPro: React$1.ForwardRefExoticComponent<BreadcrumbListProps & React$1.RefAttributes<HTMLOListElement>>;
declare const MoonUIBreadcrumbItemPro: React$1.ForwardRefExoticComponent<BreadcrumbItemProps & React$1.RefAttributes<HTMLLIElement>>;
declare const MoonUIBreadcrumbSeparatorPro: {
    ({ children, className, ...props }: BreadcrumbSeparatorProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const MoonUIBreadcrumbEllipsisPro: {
    ({ className, ...props }: BreadcrumbEllipsisProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const MoonUIBreadcrumbLinkPro: React$1.ForwardRefExoticComponent<React$1.AnchorHTMLAttributes<HTMLAnchorElement> & React$1.RefAttributes<HTMLAnchorElement>>;
declare const MoonUIBreadcrumbPagePro: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLSpanElement> & React$1.RefAttributes<HTMLSpanElement>>;

/**
 * MoonUI Button Pro Component
 *
 * A world-class, accessible, and versatile button component.
 * Pixel-perfect design with extensive variants and states.
 */
declare const moonUIButtonProVariants: (props?: ({
    variant?: "link" | "primary" | "success" | "ghost" | "outline" | "glass" | "gradient" | "secondary" | "destructive" | "glow" | "soft" | "neon" | null | undefined;
    size?: "sm" | "lg" | "md" | "xl" | "icon" | "xs" | "icon-sm" | "icon-lg" | null | undefined;
    rounded?: "none" | "default" | "full" | null | undefined;
    fullWidth?: boolean | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface MoonUIButtonProProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof moonUIButtonProVariants> {
    asChild?: boolean;
    loading?: boolean;
    leftIcon?: React$1.ReactNode;
    rightIcon?: React$1.ReactNode;
}
/**
 * MoonUI Button Pro Component
 *
 * @param props - MoonUI Button Pro component properties
 * @param props.variant - Visual variant (primary, secondary, ghost, etc.)
 * @param props.size - Button size (xs, sm, md, lg, xl)
 * @param props.loading - Loading state display
 * @param props.leftIcon - Icon on the left side
 * @param props.rightIcon - Icon on the right side
 * @param props.fullWidth - Full width display
 * @param props.rounded - Corner rounding style (default, full, none)
 * @param props.asChild - For Radix UI polymorphic component
 */
declare const MoonUIButtonPro: React$1.ForwardRefExoticComponent<MoonUIButtonProProps & React$1.RefAttributes<HTMLButtonElement>>;

interface CalendarProps$1 {
    mode?: "single" | "range" | "multiple";
    selected?: Date | Date[] | {
        from?: Date;
        to?: Date;
    } | undefined;
    onSelect?: (date: Date | Date[] | {
        from?: Date;
        to?: Date;
    } | undefined) => void;
    disabled?: (date: Date) => boolean;
    showOutsideDays?: boolean;
    className?: string;
    classNames?: Record<string, string>;
    numberOfMonths?: number;
    defaultMonth?: Date;
    initialFocus?: boolean;
}
declare function Calendar$1({ mode, selected, onSelect, disabled, showOutsideDays, className, classNames, numberOfMonths, defaultMonth, ...props }: CalendarProps$1): react_jsx_runtime.JSX.Element;
declare namespace Calendar$1 {
    var displayName: string;
}

declare const moonUICardVariantsPro: (props?: ({
    variant?: "default" | "outline" | "glass" | "gradient" | "filled" | "glow" | "neon" | "elevated" | null | undefined;
    size?: "default" | "sm" | "lg" | "xl" | null | undefined;
    radius?: "none" | "default" | "sm" | "lg" | "full" | null | undefined;
    interactive?: boolean | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface MoonUICardProProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof moonUICardVariantsPro> {
    asChild?: boolean;
    microInteraction?: "lift" | "glow" | "scale" | "none";
    enableGlassmorphism?: boolean;
    enableParallax?: boolean;
    enableTilt?: boolean;
    tiltMaxAngle?: number;
    parallaxOffset?: number;
}
declare const MoonUICardPro: React$1.ForwardRefExoticComponent<MoonUICardProProps & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUICardHeaderPro: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUICardTitlePro: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & React$1.RefAttributes<HTMLHeadingElement>>;
declare const MoonUICardDescriptionPro: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
declare const MoonUICardContentPro: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUICardFooterPro: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;

/**
 * Checkbox Bileşeni
 *
 * Erişilebilir, özelleştirilebilir ve tema sistemiyle tam entegre checkbox bileşeni.
 * Form elemanları ve seçim listeleri için kullanılır.
 */
declare const moonUICheckboxVariantsPro: (props?: ({
    variant?: "default" | "ghost" | "outline" | "muted" | null | undefined;
    size?: "default" | "sm" | "lg" | "md" | null | undefined;
    radius?: "none" | "default" | "sm" | "full" | "md" | null | undefined;
    animation?: "none" | "default" | "subtle" | "bounce" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface MoonUICheckboxProProps extends React$1.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>, VariantProps<typeof moonUICheckboxVariantsPro> {
    /**
     * İndeterminate durumu - grup seçimlerinde bazı öğeler seçilmişse kullanılır
     */
    indeterminate?: boolean;
    /**
     * Özel ikon komponenti
     */
    icon?: React$1.ReactNode;
}
declare const MoonUICheckboxPro: React$1.ForwardRefExoticComponent<MoonUICheckboxProProps & React$1.RefAttributes<HTMLButtonElement>>;

/**
 * Collapsible (Daraltılabilir) Bileşeni
 *
 * İçeriği genişletilip daraltılabilen hafif bir bileşendir.
 * Tema sistemiyle tam entegre, erişilebilir ve özelleştirilebilir.
 */
declare const MoonUICollapsiblePro: React$1.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUIcollapsibleTriggerVariantsPro: (props?: ({
    variant?: "default" | "ghost" | "outline" | null | undefined;
    size?: "default" | "sm" | "lg" | "md" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface CollapsibleTriggerProps extends React$1.ComponentPropsWithoutRef<typeof CollapsiblePrimitive.Trigger>, VariantProps<typeof MoonUIcollapsibleTriggerVariantsPro> {
}
declare const MoonUICollapsibleTriggerPro: React$1.ForwardRefExoticComponent<CollapsibleTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const MoonUIcollapsibleContentVariantsPro: (props?: ({
    variant?: "default" | "ghost" | "outline" | null | undefined;
    size?: "default" | "sm" | "lg" | "md" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface CollapsibleContentProps extends React$1.ComponentPropsWithoutRef<typeof CollapsiblePrimitive.Content>, VariantProps<typeof MoonUIcollapsibleContentVariantsPro> {
}
declare const MoonUICollapsibleContentPro: React$1.ForwardRefExoticComponent<CollapsibleContentProps & React$1.RefAttributes<HTMLDivElement>>;

interface MoonUIColorPickerProProps {
    value?: string;
    onChange?: (color: string) => void;
    className?: string;
    showInput?: boolean;
    showPresets?: boolean;
    size?: string;
    presets?: string[];
}
declare const MoonUIColorPickerPro: ({ value, onChange, className, showInput, showPresets, size, presets }: MoonUIColorPickerProProps) => react_jsx_runtime.JSX.Element;

/**
 * Premium Dialog Component
 *
 * Modern, accessible and customizable modal dialog component.
 * Enhances user experience with variants, sizes and rich features.
 * Provides a premium appearance with dark and light mode compatibility and fluid animations.
 */
declare const MoonUIDialogPro: React$1.FC<SheetPrimitive.DialogProps>;
declare const MoonUIDialogTriggerPro: React$1.ForwardRefExoticComponent<SheetPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const MoonUIDialogClosePro: React$1.ForwardRefExoticComponent<SheetPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const overlayVariants: (props?: ({
    variant?: "default" | "blur" | "subtle" | "minimal" | null | undefined;
    animation?: "default" | "slow" | "fast" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
declare const dialogContentVariants: (props?: ({
    variant?: "default" | "primary" | "ghost" | "secondary" | "destructive" | null | undefined;
    size?: "default" | "sm" | "lg" | "full" | "md" | "xl" | "xs" | null | undefined;
    radius?: "none" | "default" | "sm" | "lg" | "full" | "xl" | null | undefined;
    animation?: "none" | "default" | "zoom" | "fade" | "slide" | null | undefined;
    position?: "default" | "bottom" | "top" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface MoonUIDialogContentProProps extends Omit<React$1.ComponentPropsWithoutRef<typeof SheetPrimitive.Content>, 'title'>, VariantProps<typeof dialogContentVariants> {
    /** X butonunu gizle */
    hideCloseButton?: boolean;
    /** Overlay varyantı */
    overlayVariant?: VariantProps<typeof overlayVariants>["variant"];
    /** Overlay animasyonu */
    overlayAnimation?: VariantProps<typeof overlayVariants>["animation"];
    /** İçerik başlığı (hızlı kullanım için) */
    title?: React$1.ReactNode;
    /** İçerik açıklaması (hızlı kullanım için) */
    description?: React$1.ReactNode;
    /** Başlık ikonu */
    icon?: React$1.ReactNode;
    /** Yükleniyor durumu */
    loading?: boolean;
    /** Success durumu */
    success?: boolean;
    /** Özel onClose handler */
    onClose?: () => void;
}
declare const MoonUIDialogContentPro: React$1.ForwardRefExoticComponent<MoonUIDialogContentProProps & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUIDialogHeaderPro: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const MoonUIDialogFooterPro: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const MoonUIDialogTitlePro: React$1.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
declare const MoonUIDialogDescriptionPro: React$1.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;

/**
 * Command (Komut Paleti) Bileşeni
 *
 * Gerçek command palette işlevselliği ile klavye navigasyonu, arama ve filtreleme.
 * cmdk kütüphanesi üzerine inşa edilmiş, tam özellikli command interface.
 */
declare const MoonUIcommandVariantsPro: (props?: ({
    variant?: "default" | "glass" | "bordered" | null | undefined;
    size?: "default" | "sm" | "lg" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface CommandProps extends React$1.ComponentProps<typeof Command>, VariantProps<typeof MoonUIcommandVariantsPro> {
}
declare const MoonUICommandPro: React$1.ForwardRefExoticComponent<Omit<CommandProps, "ref"> & React$1.RefAttributes<never>>;
interface CommandDialogProps extends React$1.ComponentProps<typeof MoonUIDialogPro> {
    commandClassName?: string;
    children?: React$1.ReactNode;
}
declare const MoonUICommandDialogPro: ({ children, commandClassName, ...props }: CommandDialogProps) => react_jsx_runtime.JSX.Element;
interface CommandInputProps extends React$1.ComponentProps<typeof Command.Input> {
}
declare const MoonUICommandInputPro: React$1.ForwardRefExoticComponent<Omit<CommandInputProps, "ref"> & React$1.RefAttributes<never>>;
interface CommandListProps extends React$1.ComponentProps<typeof Command.List> {
}
declare const MoonUICommandListPro: React$1.ForwardRefExoticComponent<Omit<CommandListProps, "ref"> & React$1.RefAttributes<never>>;
interface CommandEmptyProps extends React$1.ComponentProps<typeof Command.Empty> {
}
declare const MoonUICommandEmptyPro: React$1.ForwardRefExoticComponent<Omit<CommandEmptyProps, "ref"> & React$1.RefAttributes<never>>;
interface CommandGroupProps extends React$1.ComponentProps<typeof Command.Group> {
}
declare const MoonUICommandGroupPro: React$1.ForwardRefExoticComponent<Omit<CommandGroupProps, "ref"> & React$1.RefAttributes<never>>;
interface CommandSeparatorProps extends React$1.ComponentProps<typeof Command.Separator> {
}
declare const MoonUICommandSeparatorPro: React$1.ForwardRefExoticComponent<Omit<CommandSeparatorProps, "ref"> & React$1.RefAttributes<never>>;
interface CommandItemProps extends React$1.ComponentProps<typeof Command.Item> {
}
declare const MoonUICommandItemPro: React$1.ForwardRefExoticComponent<Omit<CommandItemProps, "ref"> & React$1.RefAttributes<never>>;
declare const MoonUICommandShortcutPro: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};

declare const MoonUIDropdownMenuPro: React$1.FC<DropdownMenuPrimitive.DropdownMenuProps>;
declare const MoonUIDropdownMenuTriggerPro: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const MoonUIDropdownMenuGroupPro: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUIDropdownMenuPortalPro: React$1.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
declare const MoonUIDropdownMenuSubPro: React$1.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
declare const MoonUIDropdownMenuRadioGroupPro: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUIDropdownMenuSubTriggerPro: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUIDropdownMenuSubContentPro: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUIDropdownMenuContentPro: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUIDropdownMenuItemPro: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUIDropdownMenuCheckboxItemPro: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUIDropdownMenuRadioItemPro: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUIDropdownMenuLabelPro: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUIDropdownMenuSeparatorPro: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUIDropdownMenuShortcutPro: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};

declare const moonUIInputVariantsPro: (props?: ({
    variant?: "ghost" | "underline" | "filled" | "standard" | null | undefined;
    size?: "sm" | "lg" | "md" | null | undefined;
    hasLeftIcon?: boolean | null | undefined;
    hasRightIcon?: boolean | null | undefined;
    hasRightButton?: boolean | null | undefined;
    isError?: boolean | null | undefined;
    isSuccess?: boolean | null | undefined;
    isDisabled?: boolean | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface MoonUIInputProProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size">, Omit<VariantProps<typeof moonUIInputVariantsPro>, "isDisabled" | "hasLeftIcon" | "hasRightIcon" | "hasRightButton"> {
    /** Hata mesajı */
    error?: string;
    /** Başarı mesajı */
    success?: string;
    /** Yükleniyor durumu */
    loading?: boolean;
    /** Sol tarafta gösterilecek ikon */
    leftIcon?: React$1.ReactNode;
    /** Sağ tarafta gösterilecek ikon */
    rightIcon?: React$1.ReactNode;
    /** Sağ tarafta gösterilecek buton (password show/hide vb. için) */
    rightButton?: React$1.ReactNode;
    /** Mesajın görünürlüğü (true: her zaman görünür, false: sadece hata/başarı durumunda) */
    alwaysShowMessage?: boolean;
    /** Input wrapper için ek sınıflar */
    wrapperClassName?: string;
    /** Mesaj için ek sınıflar */
    messageClassName?: string;
}
/**
 * Premium Input Component
 *
 * @param props - Input bileşeni özellikleri
 * @param props.variant - Görsel varyant (standard, filled, ghost, underline)
 * @param props.size - Boyut (sm, md, lg)
 * @param props.error - Hata mesajı
 * @param props.success - Başarı mesajı
 * @param props.loading - Yükleniyor durumu
 * @param props.leftIcon - Sol tarafta gösterilecek ikon
 * @param props.rightIcon - Sağ tarafta gösterilecek ikon
 * @param props.rightButton - Sağ tarafta gösterilecek buton
 * @param props.alwaysShowMessage - Mesajın her zaman görünür olması
 */
declare const MoonUIInputPro: React$1.ForwardRefExoticComponent<MoonUIInputProProps & React$1.RefAttributes<HTMLInputElement>>;

declare const MoonUILabelPro: React$1.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React$1.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: class_variance_authority_dist_types.ClassProp | undefined) => string> & React$1.RefAttributes<HTMLLabelElement>>;

declare const MoonUIPaginationPro: {
    ({ className, ...props }: React$1.ComponentProps<"nav">): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const MoonUIPaginationContentPro: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React$1.RefAttributes<HTMLUListElement>>;
declare const MoonUIPaginationItemPro: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React$1.RefAttributes<HTMLLIElement>>;
type PaginationLinkProps = {
    isActive?: boolean;
} & Pick<MoonUIButtonProProps, "size"> & React$1.ComponentProps<"a">;
declare const MoonUIPaginationLinkPro: {
    ({ className, isActive, size, ...props }: PaginationLinkProps): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const MoonUIPaginationPreviousPro: {
    ({ className, ...props }: React$1.ComponentProps<typeof MoonUIPaginationLinkPro>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const MoonUIPaginationNextPro: {
    ({ className, ...props }: React$1.ComponentProps<typeof MoonUIPaginationLinkPro>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const MoonUIPaginationEllipsisPro: {
    ({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
    displayName: string;
};

/**
 * Popover Bileşeni
 *
 * Tıklanabilir bir öğeden açılan, tema sistemiyle tam entegre bir içerik bileşeni.
 * Filtreler, ayarlar ve diğer içerikler için kullanışlı ve erişilebilir bir arayüz sağlar.
 */
declare const popoverContentVariants: (props?: ({
    variant?: "default" | "outline" | "destructive" | "subtle" | null | undefined;
    size?: "default" | "sm" | "lg" | null | undefined;
    side?: "left" | "right" | "bottom" | "top" | null | undefined;
    position?: "default" | "pointerEventsNone" | null | undefined;
    radius?: "none" | "default" | "sm" | "lg" | "full" | null | undefined;
    shadow?: "none" | "default" | "sm" | "lg" | "md" | "xl" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
declare const MoonUIPopoverPro: React$1.FC<PopoverPrimitive.PopoverProps>;
declare const MoonUIPopoverTriggerPro: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
interface MoonUIPopoverContentProProps extends Omit<React$1.ComponentPropsWithoutRef<typeof PopoverPrimitive.Content>, 'side'>, VariantProps<typeof popoverContentVariants> {
    /**
     * Popover'ın arka plan bulanıklığı etkin mi
     */
    backdrop?: boolean;
    /**
     * Popover'a tıklandığında kapanıp kapanmayacağı
     */
    closeOnInteractOutside?: boolean;
    /**
     * Popover açıkken arka planın karartılması
     */
    overlayBackdrop?: boolean;
}
declare const MoonUIPopoverContentPro: React$1.ForwardRefExoticComponent<MoonUIPopoverContentProProps & React$1.RefAttributes<HTMLDivElement>>;

declare const MoonUIProgressPro: React$1.ForwardRefExoticComponent<Omit<ProgressPrimitive.ProgressProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<never>>;

/**
 * Radio Group Component
 *
 * Accessible, customizable, and fully integrated with the theme system radio button group.
 * Allows users to select a single option from a group of choices.
 */
declare const MoonUIradioGroupItemVariantsPro: (props?: ({
    variant?: "default" | "outline" | "filled" | null | undefined;
    size?: "default" | "sm" | "lg" | "md" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface RadioGroupProps extends React$1.HTMLAttributes<HTMLDivElement> {
    /**
     * Radio group value
     */
    value?: string;
    /**
     * Function to call when radio group value changes
     */
    onValueChange?: (value: string) => void;
    /**
     * Radio group disabled state
     */
    disabled?: boolean;
    /**
     * Radio group name
     */
    name?: string;
}
declare const MoonUIRadioGroupContextPro: React$1.Context<{
    value?: string;
    onValueChange?: (value: string) => void;
    disabled?: boolean;
    name?: string;
}>;
declare const MoonUIRadioGroupPro: React$1.ForwardRefExoticComponent<RadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
interface RadioGroupItemProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, 'size'>, VariantProps<typeof MoonUIradioGroupItemVariantsPro> {
    /**
     * Custom indicator component
     */
    indicator?: React$1.ReactNode;
    /**
     * HTML id for radio button
     */
    id?: string;
    /**
     * Radio button value
     */
    value: string;
    /**
     * Radio button disabled state
     */
    disabled?: boolean;
}
declare const MoonUIRadioGroupItemPro: React$1.ForwardRefExoticComponent<RadioGroupItemProps & React$1.RefAttributes<HTMLInputElement>>;
interface RadioLabelProps extends React$1.HTMLAttributes<HTMLLabelElement> {
    /**
     * HTML id for radio button
     */
    htmlFor?: string;
    /**
     * Label content
     */
    children: React$1.ReactNode;
    /**
     * Disabled state style
     */
    disabled?: boolean;
}
declare const MoonUIRadioLabelPro: React$1.ForwardRefExoticComponent<RadioLabelProps & React$1.RefAttributes<HTMLLabelElement>>;
interface RadioItemWithLabelProps extends RadioGroupItemProps {
    /**
     * Label content
     */
    label: React$1.ReactNode;
    /**
     * HTML classes for label
     */
    labelClassName?: string;
    /**
     * HTML id for radio button
     */
    id?: string;
    /**
     * Disabled state
     */
    disabled?: boolean;
}
declare const MoonUIRadioItemWithLabelPro: React$1.ForwardRefExoticComponent<RadioItemWithLabelProps & React$1.RefAttributes<HTMLInputElement>>;

declare const ScrollArea: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const ScrollBar: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;

/**
 * Premium Select Component
 *
 * Advanced dropdown/select component with variants, sizes and accessibility features.
 * Compatible with dark and light mode, providing a modern user experience with smooth animations.
 */
declare const MoonUISelectPro: React$1.FC<SelectPrimitive.SelectProps>;
declare const MoonUISelectGroupPro: React$1.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUISelectValuePro: React$1.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React$1.RefAttributes<HTMLSpanElement>>;
type SelectTriggerVariant = "standard" | "outline" | "ghost" | "underline";
type SelectTriggerSize = "sm" | "md" | "lg";
interface MoonUISelectTriggerProProps extends React$1.ComponentPropsWithoutRef<typeof SelectPrimitive.Trigger> {
    /** Visual variant */
    variant?: SelectTriggerVariant;
    /** Size */
    size?: SelectTriggerSize;
    /** Error state */
    error?: boolean | string;
    /** Success state */
    success?: boolean;
    /** Loading state */
    loading?: boolean;
    /** Icon displayed on the left */
    leftIcon?: React$1.ReactNode;
    /** Icon displayed on the right (instead of default chevron) */
    rightIcon?: React$1.ReactNode;
    /** Enable clear button */
    clearable?: boolean;
    /** On clear callback */
    onClear?: () => void;
    /** Custom placeholder when value is selected */
    selectedPlaceholder?: string;
}
declare const MoonUISelectTriggerPro: React$1.ForwardRefExoticComponent<MoonUISelectTriggerProProps & React$1.RefAttributes<HTMLButtonElement>>;
interface MoonUISelectContentProProps extends React$1.ComponentPropsWithoutRef<typeof SelectPrimitive.Content> {
    /** Enable search functionality */
    enableSearch?: boolean;
    /** Search placeholder */
    searchPlaceholder?: string;
    /** No results text */
    noResultsText?: string;
    /** Loading search results */
    searchLoading?: boolean;
    /** Custom search icon */
    searchIcon?: React$1.ReactNode;
}
declare const MoonUISelectContentPro: React$1.ForwardRefExoticComponent<MoonUISelectContentProProps & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUISelectLabelPro: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
type SelectItemVariant = "default" | "subtle" | "destructive" | "success" | "warning";
type SelectItemSize = "sm" | "md" | "lg";
interface MoonUISelectItemProProps extends React$1.ComponentPropsWithoutRef<typeof SelectPrimitive.Item> {
    /** Visual variant */
    variant?: SelectItemVariant;
    /** Size */
    size?: SelectItemSize;
    /** Icon displayed on the right */
    rightIcon?: React$1.ReactNode;
    /** Custom indicator icon (instead of default check) */
    customIndicator?: React$1.ReactNode;
    /** Enable hover scale animation */
    enableHoverScale?: boolean;
    /** Description text shown below the main text */
    description?: string;
}
declare const MoonUISelectItemPro: React$1.ForwardRefExoticComponent<MoonUISelectItemProProps & React$1.RefAttributes<HTMLDivElement>>;
declare const MoonUISelectSeparatorPro: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;

declare const moonUISeparatorVariantsPro: (props?: ({
    orientation?: "horizontal" | "vertical" | null | undefined;
    variant?: "default" | "gradient" | "dashed" | "dotted" | null | undefined;
    size?: "sm" | "lg" | "md" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface MoonUISeparatorProProps extends Omit<React$1.ComponentPropsWithoutRef<typeof SeparatorPrimitive.Root>, 'orientation'>, VariantProps<typeof moonUISeparatorVariantsPro> {
    orientation?: "horizontal" | "vertical";
}
declare const MoonUISeparatorPro: React$1.ForwardRefExoticComponent<MoonUISeparatorProProps & React$1.RefAttributes<HTMLDivElement>>;

declare const Sheet: React$1.FC<SheetPrimitive.DialogProps>;
declare const SheetTrigger: React$1.ForwardRefExoticComponent<SheetPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const SheetClose: React$1.ForwardRefExoticComponent<SheetPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const SheetPortal: React$1.FC<SheetPrimitive.DialogPortalProps>;
declare const SheetOverlay: React$1.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const sheetVariants: (props?: ({
    side?: "left" | "right" | "bottom" | "top" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface SheetContentProps extends React$1.ComponentPropsWithoutRef<typeof SheetPrimitive.Content>, VariantProps<typeof sheetVariants> {
}
declare const SheetContent: React$1.ForwardRefExoticComponent<SheetContentProps & React$1.RefAttributes<HTMLDivElement>>;
declare const SheetHeader: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const SheetFooter: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const SheetTitle: React$1.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
declare const SheetDescription: React$1.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;

interface MoonUISkeletonProProps extends React.HTMLAttributes<HTMLDivElement> {
}
declare function MoonUISkeletonPro({ className, ...props }: MoonUISkeletonProProps): react_jsx_runtime.JSX.Element;

/**
 * Slider Component
 *
 * Accessible, customizable slider component fully integrated with the theme system.
 * Used for value ranges like volume, brightness, price ranges.
 */
declare const moonUISliderVariantsPro: (props?: ({
    size?: "default" | "sm" | "lg" | "md" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
declare const sliderTrackVariants: (props?: ({
    variant?: "default" | "primary" | "success" | "warning" | "error" | "secondary" | "accent" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
declare const sliderRangeVariants: (props?: ({
    variant?: "default" | "primary" | "success" | "warning" | "error" | "secondary" | "accent" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
declare const sliderThumbVariants: (props?: ({
    variant?: "default" | "primary" | "success" | "warning" | "error" | "secondary" | "accent" | null | undefined;
    size?: "default" | "sm" | "lg" | "md" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
type SliderBaseProps = {
    /**
     * Track variant
     */
    trackVariant?: VariantProps<typeof sliderTrackVariants>["variant"];
    /**
     * Range variant
     */
    rangeVariant?: VariantProps<typeof sliderRangeVariants>["variant"];
    /**
     * Thumb variant
     */
    thumbVariant?: VariantProps<typeof sliderThumbVariants>["variant"];
    /**
     * Thumb size
     */
    thumbSize?: VariantProps<typeof sliderThumbVariants>["size"];
    /**
     * Show value label
     */
    showValueLabel?: boolean;
    /**
     * Value label format function
     */
    valueLabelFormat?: (value: number) => string;
    /**
     * Value label class name
     */
    valueLabelClassName?: string;
    /**
     * Slider value
     */
    value?: number[];
    /**
     * Default value
     */
    defaultValue?: number[];
    /**
     * Function called when value changes
     */
    onValueChange?: (value: number[]) => void;
    /**
     * Minimum value
     */
    min?: number;
    /**
     * Maximum value
     */
    max?: number;
    /**
     * Step value
     */
    step?: number;
    /**
     * Slider size
     */
    size?: VariantProps<typeof moonUISliderVariantsPro>["size"];
    /**
     * Disabled state
     */
    disabled?: boolean;
};
declare const MoonUISliderPro: React$1.ForwardRefExoticComponent<SliderBaseProps & Omit<React$1.HTMLAttributes<HTMLDivElement>, "defaultValue"> & React$1.RefAttributes<HTMLDivElement>>;

type SwitchSize = "sm" | "md" | "lg";
type SwitchVariant = "primary" | "success" | "warning" | "danger" | "secondary";
interface MoonUISwitchProProps extends React$1.ComponentPropsWithoutRef<typeof SwitchPrimitives.Root> {
    /** Switch boyutu */
    size?: SwitchSize;
    /** Switch renk varyantı */
    variant?: SwitchVariant;
    /** Yükleniyor durumunu gösterir */
    loading?: boolean;
    /** Sol tarafta gösterilecek ikon */
    leftIcon?: React$1.ReactNode;
    /** Sağ tarafta gösterilecek ikon */
    rightIcon?: React$1.ReactNode;
    /** Switch açıklaması */
    description?: string;
}
declare const MoonUISwitchPro: React$1.ForwardRefExoticComponent<MoonUISwitchProProps & React$1.RefAttributes<HTMLButtonElement>>;

type SortDirection = "asc" | "desc" | null;
declare const MoonUItableVariantsPro: (props?: ({
    variant?: "default" | "card" | "minimal" | "bordered" | "striped" | null | undefined;
    size?: "default" | "sm" | "lg" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface TableProps<T> extends React$1.HTMLAttributes<HTMLTableElement>, VariantProps<typeof MoonUItableVariantsPro> {
    /** Veri yükleniyor durumunu gösterir */
    loading?: boolean;
    /** Sıralama için kullanılan sütun */
    sortColumn?: string;
    /** Sıralama yönü */
    sortDirection?: SortDirection;
    /** Sıralama değiştiğinde çağrılacak fonksiyon */
    onSortChange?: (column: string, direction: SortDirection) => void;
    /** Boş durum için özel içerik */
    emptyContent?: React$1.ReactNode;
    /** Seçili satır id'leri */
    selectedRowIds?: string[];
    /** Satır seçim değiştiğinde çağrılacak fonksiyon */
    onRowSelectionChange?: (selectedRowIds: string[]) => void;
    /** Satır seçim devre dışı */
    disableRowSelection?: boolean;
    /** Her satır için benzersiz id çıkarma fonksiyonu */
    getRowId?: (row: T) => string;
}
declare const MoonUITablePro: React$1.ForwardRefExoticComponent<TableProps<unknown> & React$1.RefAttributes<HTMLTableElement>>;
declare const MoonUITableHeaderPro: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
interface TableBodyProps extends React$1.HTMLAttributes<HTMLTableSectionElement> {
    /** Veri yoksa gösterilecek boş durum içeriği */
    emptyContent?: React$1.ReactNode;
    /** Varsayılan boş durum mesajı */
    emptyMessage?: string;
}
declare const MoonUITableBodyPro: React$1.ForwardRefExoticComponent<TableBodyProps & React$1.RefAttributes<HTMLTableSectionElement>>;
declare const MoonUITableFooterPro: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
declare const MoonUITableRowPro: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableRowElement> & React$1.RefAttributes<HTMLTableRowElement>>;
interface TableHeadProps extends React$1.ThHTMLAttributes<HTMLTableCellElement> {
    /** Bu sütun için sıralama durumu */
    sortable?: boolean;
    /** Bu sütunun sıralanma durumu */
    sorted?: SortDirection;
    /** Sıralama değiştiğinde çağrılacak fonksiyon */
    onSort?: () => void;
}
declare const MoonUITableHeadPro: React$1.ForwardRefExoticComponent<TableHeadProps & React$1.RefAttributes<HTMLTableCellElement>>;
declare const MoonUITableCellPro: React$1.ForwardRefExoticComponent<React$1.TdHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
declare const MoonUITableCaptionPro: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCaptionElement> & React$1.RefAttributes<HTMLTableCaptionElement>>;

interface MoonUITabsProProps extends React$1.ComponentPropsWithoutRef<typeof TabsPrimitive.Root> {
    /** Mobil görünümde dikey düzen için */
    vertical?: boolean;
}
declare const MoonUITabsPro: React$1.ForwardRefExoticComponent<MoonUITabsProProps & React$1.RefAttributes<HTMLDivElement>>;
declare const tabsListVariants: (props?: ({
    variant?: "default" | "underline" | "minimal" | "pills" | "cards" | null | undefined;
    orientation?: "horizontal" | "vertical" | null | undefined;
    fullWidth?: boolean | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface MoonUITabsListProProps extends React$1.ComponentPropsWithoutRef<typeof TabsPrimitive.List>, VariantProps<typeof tabsListVariants> {
    /** Dikey düzende göster */
    orientation?: "horizontal" | "vertical";
}
declare const MoonUITabsListPro: React$1.ForwardRefExoticComponent<MoonUITabsListProProps & React$1.RefAttributes<HTMLDivElement>>;
declare const tabsTriggerVariants: (props?: ({
    variant?: "default" | "underline" | "minimal" | "pills" | "cards" | null | undefined;
    size?: "sm" | "lg" | "md" | null | undefined;
    orientation?: "horizontal" | "vertical" | null | undefined;
    fullWidth?: boolean | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface MoonUITabsTriggerProProps extends React$1.ComponentPropsWithoutRef<typeof TabsPrimitive.Trigger>, VariantProps<typeof tabsTriggerVariants> {
    /** İkon konumu */
    iconPosition?: "left" | "right" | "none";
    /** İkon */
    icon?: React$1.ReactNode;
    /** Badge içeriği */
    badge?: React$1.ReactNode;
    /** Aktif olmayan durumda yarı saydam */
    fadeTabs?: boolean;
    /** Dikey düzende göster */
    orientation?: "horizontal" | "vertical";
}
declare const MoonUITabsTriggerPro: React$1.ForwardRefExoticComponent<MoonUITabsTriggerProProps & React$1.RefAttributes<HTMLButtonElement>>;
interface MoonUITabsContentProProps extends React$1.ComponentPropsWithoutRef<typeof TabsPrimitive.Content> {
    /** İçerik animasyonu */
    animated?: boolean;
}
declare const MoonUITabsContentPro: React$1.ForwardRefExoticComponent<MoonUITabsContentProProps & React$1.RefAttributes<HTMLDivElement>>;

interface MoonUITextareaProProps extends React__default.TextareaHTMLAttributes<HTMLTextAreaElement> {
}
declare const MoonUITextareaPro: React__default.ForwardRefExoticComponent<MoonUITextareaProProps & React__default.RefAttributes<HTMLTextAreaElement>>;

declare const MoonUIToastPro: React$1.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & React$1.RefAttributes<HTMLLIElement>, "ref"> & VariantProps<(props?: ({
    vari