import * as AccordionPrimitive from '@radix-ui/react-accordion';
import * as react from 'react';
import react__default, { ReactNode, PropsWithChildren, HTMLAttributes, ButtonHTMLAttributes, WheelEventHandler, Dispatch, SetStateAction, ComponentType, SVGProps, InputHTMLAttributes, ComponentProps, MouseEvent, KeyboardEvent as KeyboardEvent$1, RefObject } from 'react';
import * as class_variance_authority_dist_types from 'class-variance-authority/dist/types';
import * as class_variance_authority from 'class-variance-authority';
import { VariantProps } from 'class-variance-authority';
import * as react_jsx_runtime from 'react/jsx-runtime';
import Autoplay from 'embla-carousel-autoplay';
import useEmblaCarousel, { UseEmblaCarouselType } from 'embla-carousel-react';
import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
import { Icon, GlobePointer, SatelliteDish, Flag6, InputSearch, Page2, Gift, Hyperlink, Raycast, Typescript, Book2Fill, FeatherFill, Twitter } from './icons/index.js';
export { Africa, Airtm, Amazon, Apple, ArrowBoldUp, ArrowRight, ArrowTrendUp, ArrowTurnLeft, ArrowTurnRight2, ArrowUpRight, ArrowsOppositeDirectionY, Asia, BadgeCheck, Blog, Bolt, BoltFill, Book2, Book2Fill, Book2Small, BookOpen, Books2, BoxArchive, BulletList, BulletListFill, Calendar6, CalendarDays, CalendarIcon, CalendarRefresh, CardAmex, CardDiscover, CardMastercard, CardVisa, Cards, CaretUpFill, CashApp, ChartActivity2, ChartLine, ChatGPT, Check, Check2, CheckboxCheckedFill, CheckboxUnchecked, CircleCheck, CircleCheckFill, CircleDollar, CircleDotted, CircleHalfDottedCheck, CircleHalfDottedClock, CircleInfo, CirclePlay, CirclePlayFill, CircleQuestion, CircleWarning, CircleXmark, Circles, Circles3, CloudUpload, Code, ColorPalette2, ConnectedDots, ConnectedDots4, ConnectedDotsFill, Connections3, Copy, CreditCard, Crosshairs3, Crown, CrownSmall, Cube, CubeSettings, CubeSettingsFill, CurrencyDollar, CursorRays, DatabaseKey, Desktop, DiamondTurnRight, Dots, Download, DubCraftedShield, Duplicate, EarthPosition, EnvelopeArrowRight, Europe, ExpandingArrow, Eye, EyeSlash, Facebook, FeatherFill, Figma, FileZip2, Filter2, FilterBars, Flag2, Flag6, FlagWavy, Folder, Folder5, GamingConsole, Gauge6, Gear, Gear2, Gear3, Gem, Gift, GiftFill, GitHubEnhanced, Github, Globe, Globe2, GlobePointer, GlobeSearch, Go, Google, GoogleEnhanced, GreekTemple, GridIcon, GridLayoutRows, GridPlus, Headset, HeadsetFill, HeartFill, HexadecagonStar, Hyperlink, Icon, Icosahedron, Incognito, InputPassword, InputSearch, InvoiceDollar, Key, LayoutSidebar, License, LinesY, Link4, LinkBroken, LinkedIn, LoadingCircle, LoadingDots, LoadingSpinner, LocationPin, Magic, Magnifier, MapPosition, MatrixLines, Menu3, MessageSmile, MobilePhone, MoneyBill2, MoneyBills2, NorthAmerica, Note, NucleoPhoto, Oceania, OfficeBuilding, Page2, Paintbrush, Palette2, Payoneer, Paypal, Pen2, PenWriting, PercentageArrowDown, Photo, Php, Plug2, Plus, Post, Prisma, ProductHunt, Pyramid, Python, QRCode, Raycast, Receipt2, ReferredVia, Refresh2, Robot, Ruby, SatelliteDish, ScanText, Scribble, ShieldAlert, ShieldCheck, ShieldKeyhole, ShieldSlash, Shuffle, Sliders, SortOrder, SouthAmerica, Sparkle3, Spotify, SquareChart, SquareLayoutGrid6, SquareXmark, Stars2, StripeLink, Success, TV, TableIcon, TableRows2, Tablet, Tag, Tags, Tick, Tinybird, Toggle2Fill, Trash, Twitter, Typescript, Unsplash, User, UserCheck, UserCrown, Users, Users2, Users6, UsersSettings, Venmo, Versions2, Watch, Webhook, Window, WindowSearch, WindowSettings, Xmark, YouTube } from './icons/index.js';
import { DayPickerSingleProps, DayPickerRangeProps, Matcher } from 'react-day-picker';
export { Matcher } from 'react-day-picker';
import { Locale } from 'date-fns';
import { LucideIcon } from 'lucide-react';
import * as LabelPrimitive from '@radix-ui/react-label';
import { Drawer, ContentProps } from 'vaul';
import * as _tanstack_react_table from '@tanstack/react-table';
import { PaginationState as PaginationState$1, Table as Table$1, ColumnDef, Cell, VisibilityState, ColumnPinningState, Row, RowSelectionState } from '@tanstack/react-table';
import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
import * as TooltipPrimitive from '@radix-ui/react-tooltip';
import Cookies from 'js-cookie';
import { AppRouterInstance } from 'next/dist/shared/lib/app-router-context.shared-runtime';
import { ReadonlyURLSearchParams } from 'next/navigation';
import * as framer_motion from 'framer-motion';
import { ImageProps } from 'next/image';

declare const Accordion: react.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & react.RefAttributes<HTMLDivElement>>;
declare const AccordionItem: react.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
declare const AccordionTrigger: react.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & react.RefAttributes<HTMLButtonElement>, "ref"> & {
    variant?: "chevron" | "plus" | undefined;
} & react.RefAttributes<HTMLButtonElement>>;
declare const AccordionContent: react.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;

declare const Alert: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
    variant?: "default" | "destructive" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string> & react.RefAttributes<HTMLDivElement>>;
declare const AlertTitle: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLHeadingElement> & react.RefAttributes<HTMLParagraphElement>>;
declare const AlertDescription: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLParagraphElement> & react.RefAttributes<HTMLParagraphElement>>;

type User = {
    id?: string | null | undefined;
    name?: string | null | undefined;
    email?: string | null | undefined;
    image?: string | null | undefined;
};
declare function getUserAvatarUrl(user?: User | null): string;
declare function Avatar({ user, className, }: {
    user?: User;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare function TokenAvatar({ id, className, }: {
    id: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare const badgeVariants: (props?: ({
    variant?: "black" | "blue" | "gray" | "violet" | "default" | "sky" | "neutral" | "blueGradient" | "rainbow" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface BadgeProps$1 extends React.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof badgeVariants> {
}
declare function Badge({ className, variant, ...props }: BadgeProps$1): react_jsx_runtime.JSX.Element;

declare const buttonVariants: (props?: ({
    variant?: "outline" | "primary" | "secondary" | "success" | "danger" | "danger-outline" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
    text?: ReactNode | string;
    textWrapperClassName?: string;
    loading?: boolean;
    icon?: ReactNode;
    shortcut?: string;
    right?: ReactNode;
    disabledTooltip?: string | ReactNode;
}
declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;

declare const cardListVariants: (props?: ({
    variant?: "compact" | "loose" | null | undefined;
    loading?: boolean | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
type CardListProps = PropsWithChildren<{
    loading?: boolean;
    className?: string;
}> & VariantProps<typeof cardListVariants>;
declare function CardList$1({ variant, loading, className, children, }: CardListProps): react_jsx_runtime.JSX.Element;

declare function CardListCard({ outerClassName, innerClassName, children, onClick, hoverStateEnabled, }: PropsWithChildren<{
    outerClassName?: string;
    innerClassName?: string;
    onClick?: () => void;
    hoverStateEnabled?: boolean;
}>): react_jsx_runtime.JSX.Element;

declare const CardList: typeof CardList$1 & {
    Card: typeof CardListCard & {
        Context: react.Context<{
            hovered: boolean;
        }>;
    };
    Context: react.Context<Pick<{
        loading?: boolean | undefined;
        className?: string | undefined;
    } & {
        children?: react.ReactNode;
    } & class_variance_authority.VariantProps<(props?: ({
        variant?: "compact" | "loose" | null | undefined;
        loading?: boolean | null | undefined;
    } & class_variance_authority_dist_types.ClassProp) | undefined) => string>, "variant">>;
};

declare const AUTOPLAY_DEFAULT_DELAY = 2000;
type CarouselApi = UseEmblaCarouselType[1];
type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
type CarouselOptions = UseCarouselParameters[0];
type CarouselPlugin = UseCarouselParameters[1];
type AutoplayOptions = Parameters<typeof Autoplay>[0];
type CarouselProps = {
    opts?: CarouselOptions;
    plugins?: CarouselPlugin;
    orientation?: "horizontal" | "vertical";
    autoplay?: boolean | AutoplayOptions;
    setApi?: (api: CarouselApi) => void;
};
type CarouselContextProps = {
    carouselRef: ReturnType<typeof useEmblaCarousel>[0];
    api: ReturnType<typeof useEmblaCarousel>[1];
    scrollPrev: () => void;
    scrollNext: () => void;
    canScrollPrev: boolean;
    canScrollNext: boolean;
} & CarouselProps;
declare function useCarousel(): CarouselContextProps;
declare function useCarouselActiveIndex(): number;
declare const Carousel: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & CarouselProps & react.RefAttributes<HTMLDivElement>>;
declare const CarouselContent: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
declare const CarouselItem: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
declare const CarouselPrevious: react.ForwardRefExoticComponent<{
    className?: string | undefined;
} & react.RefAttributes<HTMLButtonElement>>;
declare const CarouselNext: react.ForwardRefExoticComponent<{
    className?: string | undefined;
} & react.RefAttributes<HTMLButtonElement>>;

declare const CarouselNavBar: ({ variant, className, }: VariantProps<(props?: ({
    variant?: "simple" | "floating" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string> & {
    className?: string | undefined;
}) => react_jsx_runtime.JSX.Element;

declare const CarouselThumbnails: ({ className, ...rest }: HTMLAttributes<HTMLDivElement>) => react_jsx_runtime.JSX.Element;
declare const CarouselThumbnail: react.ForwardRefExoticComponent<{
    index: number;
    className?: string | ((d: {
        active: boolean;
    }) => string) | undefined;
} & Omit<ButtonHTMLAttributes<HTMLButtonElement>, "className"> & react.RefAttributes<HTMLDivElement>>;

declare const Checkbox: react.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;

type PopoverProps = PropsWithChildren<{
    content: ReactNode | string;
    align?: "center" | "start" | "end";
    side?: "bottom" | "top" | "left" | "right";
    openPopover: boolean;
    setOpenPopover: (open: boolean) => void;
    mobileOnly?: boolean;
    popoverContentClassName?: string;
    collisionBoundary?: Element | Element[];
    sticky?: "partial" | "always";
    onEscapeKeyDown?: (event: KeyboardEvent) => void;
    onWheel?: WheelEventHandler;
}>;
declare function Popover({ children, content, align, side, openPopover, setOpenPopover, mobileOnly, popoverContentClassName, collisionBoundary, sticky, onEscapeKeyDown, onWheel, }: PopoverProps): react_jsx_runtime.JSX.Element;

type ComboboxOption<TMeta = any> = {
    label: string;
    value: string;
    icon?: Icon | ReactNode;
    meta?: TMeta;
};
type ComboboxProps<TMultiple extends boolean | undefined, TMeta extends any> = PropsWithChildren<{
    multiple?: TMultiple;
    selected: TMultiple extends true ? ComboboxOption<TMeta>[] : ComboboxOption<TMeta> | null;
    setSelected: TMultiple extends true ? (options: ComboboxOption<TMeta>[]) => void : (option: ComboboxOption<TMeta> | null) => void;
    options?: ComboboxOption<TMeta>[];
    icon?: Icon | ReactNode;
    placeholder?: ReactNode;
    searchPlaceholder?: string;
    emptyState?: ReactNode;
    createLabel?: (search: string) => ReactNode;
    onCreate?: (search: string) => Promise<boolean>;
    buttonProps?: ButtonProps;
    shortcutHint?: string;
    caret?: boolean;
    side?: PopoverProps["side"];
    open?: boolean;
    onOpenChange?: (open: boolean) => void;
    onSearchChange?: (search: string) => void;
    shouldFilter?: boolean;
    inputClassName?: string;
    optionRight?: (option: ComboboxOption) => ReactNode;
    optionClassName?: string;
    matchTriggerWidth?: boolean;
}>;
declare function Combobox({ multiple, selected: selectedProp, setSelected, options, icon: Icon, placeholder, searchPlaceholder, emptyState, createLabel, onCreate, buttonProps, shortcutHint, caret, side, open, onOpenChange, onSearchChange, shouldFilter, inputClassName, optionRight, optionClassName, matchTriggerWidth, children, }: ComboboxProps<boolean | undefined, any>): react_jsx_runtime.JSX.Element;

type OmitKeys<T, K extends keyof T> = {
    [P in keyof T as P extends K ? never : P]: T[P];
};
type KeysToOmit = "showWeekNumber" | "captionLayout" | "mode";
type SingleProps = OmitKeys<DayPickerSingleProps, KeysToOmit>;
type RangeProps = OmitKeys<DayPickerRangeProps, KeysToOmit>;
type CalendarProps$1 = ({
    mode: "single";
} & SingleProps) | ({
    mode?: undefined;
} & SingleProps) | ({
    mode: "range";
} & RangeProps);
declare function Calendar({ mode, weekStartsOn, numberOfMonths, showYearNavigation, disableNavigation, locale, className, classNames, ...props }: CalendarProps$1 & {
    showYearNavigation?: boolean;
}): react_jsx_runtime.JSX.Element;

type CalendarProps = {
    fromYear?: number;
    toYear?: number;
    fromMonth?: Date;
    toMonth?: Date;
    fromDay?: Date;
    toDay?: Date;
    fromDate?: Date;
    toDate?: Date;
    locale?: Locale;
};
interface PickerProps extends CalendarProps {
    className?: string;
    disabled?: boolean;
    disabledDays?: Matcher | Matcher[] | undefined;
    required?: boolean;
    showTimePicker?: boolean;
    placeholder?: string;
    showYearNavigation?: boolean;
    disableNavigation?: boolean;
    hasError?: boolean;
    id?: string;
    align?: PopoverProps["align"];
    "aria-invalid"?: boolean;
    "aria-label"?: string;
    "aria-labelledby"?: string;
    "aria-required"?: boolean;
}
type DateRange = {
    from: Date | undefined;
    to?: Date | undefined;
};
interface Preset {
    id: string;
    label: string;
    requiresUpgrade?: boolean;
    tooltipContent?: ReactNode;
    shortcut?: string;
}
interface DateRangePreset extends Preset {
    dateRange: DateRange;
}

type RangeDatePickerProps = {
    presets?: DateRangePreset[];
    presetId?: DateRangePreset["id"];
    defaultValue?: DateRange;
    value?: DateRange;
    onChange?: (dateRange?: DateRange, preset?: DateRangePreset) => void;
} & PickerProps;
declare function DateRangePicker({ presets, ...props }: RangeDatePickerProps): react_jsx_runtime.JSX.Element;

declare const DatePickerContext: react.Context<{
    isOpen: boolean;
    setIsOpen: Dispatch<SetStateAction<boolean>>;
}>;

type EmptyStateProps = PropsWithChildren<{
    icon: React.ElementType;
    title: string;
    description?: ReactNode;
    learnMore?: string;
}>;
declare function EmptyState({ icon: Icon, title, description, learnMore, children, }: EmptyStateProps): react_jsx_runtime.JSX.Element;

type AcceptedFileFormats = "any" | "images" | "csv";
declare const imageUploadVariants: (props?: ({
    variant?: "default" | "plain" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
type FileUploadReadFileProps = {
    /**
     * Whether to automatically read the file and return the result as `src` to onChange
     */
    readFile?: false;
    onChange?: (data: {
        file: File;
    }) => void;
} | {
    /**
     * Whether to automatically read the file and return the result as `src` to onChange
     */
    readFile: true;
    onChange?: (data: {
        file: File;
        src: string;
    }) => void;
};
type FileUploadProps = FileUploadReadFileProps & {
    accept: AcceptedFileFormats;
    className?: string;
    iconClassName?: string;
    previewClassName?: string;
    /**
     * Custom preview component to display instead of the default
     */
    customPreview?: ReactNode;
    /**
     * Image to display (generally for image uploads)
     */
    imageSrc?: string | null;
    /**
     * Whether to display a loading spinner
     */
    loading?: boolean;
    /**
     * Whether to allow clicking on the area to upload
     */
    clickToUpload?: boolean;
    /**
     * Whether to show instruction overlay when hovered
     */
    showHoverOverlay?: boolean;
    /**
     * Content to display below the upload icon (null to only display the icon)
     */
    content?: ReactNode | null;
    /**
     * Desired resolution to suggest and optionally resize to
     */
    targetResolution?: {
        width: number;
        height: number;
    };
    /**
     * A maximum file size (in megabytes) to check upon file selection
     */
    maxFileSizeMB?: number;
    /**
     * Accessibility label for screen readers
     */
    accessibilityLabel?: string;
    disabled?: boolean;
} & VariantProps<typeof imageUploadVariants>;
declare function FileUpload({ readFile, onChange, variant, className, iconClassName, previewClassName, customPreview, accept, imageSrc, loading, clickToUpload, showHoverOverlay, content, maxFileSizeMB, targetResolution, accessibilityLabel, disabled, }: FileUploadProps): react_jsx_runtime.JSX.Element;

type FilterIcon = LucideIcon | ReactNode | ComponentType<SVGProps<SVGSVGElement>>;
type Filter$1 = {
    key: string;
    icon: FilterIcon;
    label: string;
    shouldFilter?: boolean;
    separatorAfter?: boolean;
    options: FilterOption[] | null;
    multiple?: boolean;
    getOptionIcon?: (value: FilterOption["value"], props: {
        key: Filter$1["key"];
        option?: FilterOption;
    }) => FilterIcon | null;
    getOptionLabel?: (value: FilterOption["value"], props: {
        key: Filter$1["key"];
        option?: FilterOption;
    }) => string | null;
};
type FilterOption = {
    value: any;
    label: string;
    right?: ReactNode;
    icon?: FilterIcon;
    hideDuringSearch?: boolean;
    data?: Record<string, any>;
};

type FilterListProps = {
    filters: Filter$1[];
    activeFilters?: {
        key: Filter$1["key"];
        value: FilterOption["value"];
    }[];
    onRemove: (key: string, value: FilterOption["value"]) => void;
    onRemoveAll: () => void;
    className?: string;
};
declare function FilterList({ filters, activeFilters, onRemove, onRemoveAll, className, }: FilterListProps): react_jsx_runtime.JSX.Element;

type FilterSelectProps = {
    filters: Filter$1[];
    onSelect: (key: string, value: FilterOption["value"]) => void;
    onRemove: (key: string, value: FilterOption["value"]) => void;
    onOpenFilter?: (key: string) => void;
    onSearchChange?: (search: string) => void;
    onSelectedFilterChange?: (key: string | null) => void;
    activeFilters?: {
        key: Filter$1["key"];
        value: FilterOption["value"];
    }[];
    askAI?: boolean;
    children?: ReactNode;
    emptyState?: ReactNode | Record<string, ReactNode>;
    className?: string;
};
declare function FilterSelect({ filters, onSelect, onRemove, onOpenFilter, onSearchChange, onSelectedFilterChange, activeFilters, askAI, children, emptyState, className, }: FilterSelectProps): react_jsx_runtime.JSX.Element;

declare const Filter: {
    Select: typeof FilterSelect;
    List: typeof FilterList;
};

declare function Form({ title, description, inputAttrs, helpText, buttonText, disabledTooltip, handleSubmit, }: {
    title: string;
    description: string;
    inputAttrs: InputHTMLAttributes<HTMLInputElement>;
    helpText?: string | ReactNode;
    buttonText?: string;
    disabledTooltip?: string | ReactNode;
    handleSubmit: (data: any) => Promise<any>;
}): react_jsx_runtime.JSX.Element;

declare function Grid({ cellSize, strokeWidth, patternOffset, className, }: {
    cellSize?: number;
    strokeWidth?: number;
    patternOffset?: [number, number];
    className?: string;
}): react_jsx_runtime.JSX.Element;

interface InputProps extends react__default.InputHTMLAttributes<HTMLInputElement> {
    error?: string;
}
declare const Input: react__default.ForwardRefExoticComponent<InputProps & react__default.RefAttributes<HTMLInputElement>>;

interface InputSelectItemProps {
    id: string;
    value: string;
    color?: string;
    image?: string;
    disabled?: boolean;
    label?: string;
}
declare function InputSelect({ items, selectedItem, setSelectedItem, className, disabled, adjustForMobile, icon, inputAttrs, noItemsElement, }: {
    items: InputSelectItemProps[] | [];
    selectedItem: InputSelectItemProps | null;
    setSelectedItem: Dispatch<SetStateAction<InputSelectItemProps | null>>;
    className?: string;
    disabled?: boolean;
    adjustForMobile?: boolean;
    icon?: ReactNode;
    inputAttrs?: InputHTMLAttributes<HTMLInputElement>;
    noItemsElement?: ReactNode;
}): react_jsx_runtime.JSX.Element;

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

type MiniAreaChartProps = {
    data: {
        date: Date;
        value: number;
    }[];
    curve?: boolean;
    color?: string;
};
declare function MiniAreaChart(props: MiniAreaChartProps): react_jsx_runtime.JSX.Element;

declare function Modal({ children, className, showModal, setShowModal, onClose, desktopOnly, preventDefaultClose, drawerRootProps, }: {
    children: React.ReactNode;
    className?: string;
    showModal?: boolean;
    setShowModal?: Dispatch<SetStateAction<boolean>>;
    onClose?: () => void;
    desktopOnly?: boolean;
    preventDefaultClose?: boolean;
    drawerRootProps?: ComponentProps<typeof Drawer.Root>;
}): react_jsx_runtime.JSX.Element;

declare function PaginationControls({ pagination, setPagination, totalCount, unit, className, children, }: PropsWithChildren<{
    pagination: PaginationState$1;
    setPagination: (pagination: PaginationState$1) => void;
    totalCount: number;
    unit?: string | ((plural: boolean) => string);
    className?: string;
}>): react_jsx_runtime.JSX.Element;

declare const RadioGroup: react.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & react.RefAttributes<HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
declare const RadioGroupItem: react.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupItemProps & react.RefAttributes<HTMLButtonElement>, "ref"> & react.RefAttributes<HTMLButtonElement>>;

declare function SheetRoot({ children, contentProps, nested, ...rest }: {
    contentProps?: ContentProps;
    nested?: boolean;
} & ComponentProps<typeof Drawer.Root>): react_jsx_runtime.JSX.Element;
declare function Title({ className, ...rest }: ComponentProps<typeof Drawer.Title>): react_jsx_runtime.JSX.Element;
declare function Description(props: ComponentProps<typeof Drawer.Description>): react_jsx_runtime.JSX.Element;
declare function Close(props: ComponentProps<typeof Drawer.Close>): react_jsx_runtime.JSX.Element;
declare const Sheet: typeof SheetRoot & {
    Title: typeof Title;
    Description: typeof Description;
    Close: typeof Close;
};

declare function ShimmerDots({ dotSize, cellSize, speed, className, }: {
    dotSize?: number;
    cellSize?: number;
    speed?: number;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare const statusBadgeVariants: (props?: ({
    variant?: "neutral" | "success" | "error" | "new" | "pending" | "warning" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
interface BadgeProps extends React.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof statusBadgeVariants> {
    icon?: Icon | null;
}
declare function StatusBadge({ className, variant, icon, onClick, children, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;

declare function Switch({ fn, id, trackDimensions, thumbDimensions, thumbTranslate, thumbIcon, checked, loading, disabled, disabledTooltip, }: {
    fn?: Dispatch<SetStateAction<boolean>> | ((checked: boolean) => void);
    id?: string;
    trackDimensions?: string;
    thumbDimensions?: string;
    thumbTranslate?: string;
    thumbIcon?: ReactNode;
    checked?: boolean;
    loading?: boolean;
    disabled?: boolean;
    disabledTooltip?: string | ReactNode;
}): react_jsx_runtime.JSX.Element;

type UseTableProps<T> = {
    columns: ColumnDef<T, any>[];
    data: T[];
    loading?: boolean;
    error?: string;
    emptyState?: ReactNode;
    cellRight?: (cell: Cell<T, any>) => ReactNode;
    defaultColumn?: Partial<ColumnDef<T, any>>;
    sortBy?: string;
    sortOrder?: "asc" | "desc";
    onSortChange?: (props: {
        sortBy?: string;
        sortOrder?: "asc" | "desc";
    }) => void;
    sortableColumns?: string[];
    columnVisibility?: VisibilityState;
    onColumnVisibilityChange?: (visibility: VisibilityState) => void;
    columnPinning?: ColumnPinningState;
    resourceName?: (plural: boolean) => string;
    onRowClick?: (row: Row<T>, e: MouseEvent) => void;
    getRowId?: (row: T) => string;
    onRowSelectionChange?: (rows: Row<T>[]) => void;
    selectedRows?: RowSelectionState;
    className?: string;
    containerClassName?: string;
    scrollWrapperClassName?: string;
    thClassName?: string | ((columnId: string) => string);
    tdClassName?: string | ((columnId: string) => string);
} & ({
    pagination?: PaginationState$1;
    onPaginationChange?: Dispatch<SetStateAction<PaginationState$1>>;
    rowCount: number;
} | {
    pagination?: never;
    onPaginationChange?: never;
    rowCount?: never;
});
type TableProps<T> = UseTableProps<T> & PropsWithChildren<{
    table: Table$1<T>;
}>;
declare function useTable<T extends any>(props: UseTableProps<T>): TableProps<T> & {
    table: Table$1<T>;
};
declare function Table<T>({ columns, data, loading, error, emptyState, cellRight, sortBy, sortOrder, onSortChange, sortableColumns, className, containerClassName, scrollWrapperClassName, thClassName, tdClassName, table, pagination, resourceName, onRowClick, rowCount, children, }: TableProps<T>): react_jsx_runtime.JSX.Element;

declare function useTablePagination({ pageSize, page, onPageChange, }: {
    pageSize: number;
    page: number;
    onPageChange?: (page: number) => void;
}): {
    pagination: PaginationState$1;
    setPagination: react.Dispatch<react.SetStateAction<PaginationState$1>>;
};

interface ToggleOption {
    value: string;
    label: string | React.ReactNode;
    badge?: React.ReactNode;
}
declare function ToggleGroup({ options, selected, selectAction, className, optionClassName, indicatorClassName, style, }: {
    options: ToggleOption[];
    selected: string | null;
    selectAction: (option: string) => void;
    className?: string;
    optionClassName?: string;
    indicatorClassName?: string;
    style?: React.CSSProperties;
}): react_jsx_runtime.JSX.Element;

declare function TooltipProvider({ children }: {
    children: ReactNode;
}): react_jsx_runtime.JSX.Element;
interface TooltipProps extends Omit<TooltipPrimitive.TooltipContentProps, "content"> {
    content: ReactNode | string | ((props: {
        setOpen: (open: boolean) => void;
    }) => ReactNode);
    contentClassName?: string;
    disableHoverableContent?: TooltipPrimitive.TooltipProps["disableHoverableContent"];
    delayDuration?: TooltipPrimitive.TooltipProps["delayDuration"];
}
declare function Tooltip({ children, content, contentClassName, side, disableHoverableContent, delayDuration, ...rest }: TooltipProps): react_jsx_runtime.JSX.Element;
declare function TooltipContent({ title, cta, href, target, onClick, }: {
    title: ReactNode;
    cta?: string;
    href?: string;
    target?: string;
    onClick?: () => void;
}): react_jsx_runtime.JSX.Element;
declare function SimpleTooltipContent({ title, cta, href, }: {
    title: string;
    cta: string;
    href: string;
}): react_jsx_runtime.JSX.Element;
declare function LinkifyTooltipContent({ children }: {
    children: ReactNode;
}): react_jsx_runtime.JSX.Element;
declare function InfoTooltip(props: Omit<TooltipProps, "children">): react_jsx_runtime.JSX.Element;
declare function NumberTooltip({ value, unit, prefix, children, lastClicked, }: {
    value?: number | null;
    unit?: string;
    prefix?: string;
    children: ReactNode;
    lastClicked?: Date | null;
}): string | number | boolean | react_jsx_runtime.JSX.Element | Iterable<ReactNode> | react.PromiseLikeOfReactNode | null | undefined;
declare function BadgeTooltip({ children, content, ...props }: TooltipProps): react_jsx_runtime.JSX.Element;
declare function ButtonTooltip({ children, tooltipProps, ...props }: {
    children: ReactNode;
    tooltipProps: TooltipProps;
} & ButtonProps): react_jsx_runtime.JSX.Element;

declare const UTM_PARAMETERS: readonly [{
    readonly key: "utm_source";
    readonly icon: typeof GlobePointer;
    readonly label: "Source";
    readonly placeholder: "google";
    readonly description: "Where the traffic is coming from";
}, {
    readonly key: "utm_medium";
    readonly icon: typeof SatelliteDish;
    readonly label: "Medium";
    readonly placeholder: "cpc";
    readonly description: "How the traffic is coming";
}, {
    readonly key: "utm_campaign";
    readonly icon: typeof Flag6;
    readonly label: "Campaign";
    readonly placeholder: "summer sale";
    readonly description: "The name of the campaign";
}, {
    readonly key: "utm_term";
    readonly icon: typeof InputSearch;
    readonly label: "Term";
    readonly placeholder: "running shoes";
    readonly description: "The term of the campaign";
}, {
    readonly key: "utm_content";
    readonly icon: typeof Page2;
    readonly label: "Content";
    readonly placeholder: "logo link";
    readonly description: "The content of the campaign";
}, {
    readonly key: "ref";
    readonly icon: typeof Gift;
    readonly label: "Referral";
    readonly placeholder: "yoursite.com";
    readonly description: "The referral of the campaign";
}];
declare function UTMBuilder({ values, onChange, disabled, autoFocus, disabledTooltip, className, }: {
    values: Record<(typeof UTM_PARAMETERS)[number]["key"], string | null | undefined>;
    onChange: (key: (typeof UTM_PARAMETERS)[number]["key"], value: string) => void;
    disabled?: boolean;
    autoFocus?: boolean;
    disabledTooltip?: string | ReactNode;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function useCookies<T>(key: string, initialValue: T, opts?: Cookies.CookieAttributes): [T, (value: T) => void];

declare const useCopyToClipboard: (timeout?: number) => [boolean, (value: string | ClipboardItem) => Promise<void>];

declare function useCurrentAnchor(): string | undefined;

declare function useEnterSubmit(formRef: React.RefObject<HTMLFormElement>): {
    handleKeyDown: (event: KeyboardEvent$1<HTMLTextAreaElement>) => void;
};

declare function useInViewport(elementRef: RefObject<Element>, options?: {
    root?: RefObject<Element>;
    defaultValue?: boolean;
}): boolean;

/**
 * Determines whether an <input> or <textarea> element is currently focused.
 */
declare function useInputFocused(): boolean;

interface Args extends IntersectionObserverInit {
    freezeOnceVisible?: boolean;
}
declare function useIntersectionObserver(elementRef: RefObject<Element>, { threshold, root, rootMargin, freezeOnceVisible, }: Args): IntersectionObserverEntry | undefined;

type KeyboardShortcutListener = {
    id: string;
    key: string | string[];
    enabled?: boolean;
    priority?: number;
};
declare const KeyboardShortcutContext: react.Context<{
    listeners: KeyboardShortcutListener[];
    setListeners: Dispatch<SetStateAction<KeyboardShortcutListener[]>>;
}>;
declare function KeyboardShortcutProvider({ children, }: {
    children: React.ReactNode;
}): react_jsx_runtime.JSX.Element;
declare function useKeyboardShortcut(key: KeyboardShortcutListener["key"], callback: (e: KeyboardEvent) => void, options?: {
    modal?: boolean;
} & Pick<KeyboardShortcutListener, "enabled" | "priority">): void;

declare function useLocalStorage<T>(key: string, initialValue: T): [T, (value: T) => void];

declare function useMediaQuery(): {
    device: "mobile" | "tablet" | "desktop" | null;
    width: number | undefined;
    height: number | undefined;
    isMobile: boolean;
    isTablet: boolean;
    isDesktop: boolean;
};

declare function useOptimisticUpdate<T>(url: string, toastCopy?: {
    loading: string;
    success: string;
    error: string;
}): {
    data: T | undefined;
    isLoading: boolean;
    update: (fn: (data: T) => Promise<T>, optimisticData: T) => Promise<string | number>;
};

type PaginationState = {
    pageIndex: number;
    pageSize: number;
};
declare function usePagination(pageSize?: number): {
    pagination: _tanstack_react_table.PaginationState;
    setPagination: react.Dispatch<react.SetStateAction<_tanstack_react_table.PaginationState>>;
};

declare function useRemoveGAParams(): void;

/**
 * Use a ResizeObserver to react to changes in an element's size
 *
 * More about ResizeObserver: https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver
 */
declare function useResizeObserver(elementRef: RefObject<Element>): ResizeObserverEntry | undefined;

declare function useRouterStuff(): {
    pathname: string;
    router: AppRouterInstance;
    searchParams: ReadonlyURLSearchParams;
    searchParamsObj: {
        [k: string]: string;
    };
    queryParams: ({ set, del, replace, scroll, getNewPath, arrayDelimiter, }: {
        set?: Record<string, string | string[]> | undefined;
        del?: string | string[] | undefined;
        replace?: boolean | undefined;
        scroll?: boolean | undefined;
        getNewPath?: boolean | undefined;
        arrayDelimiter?: string | undefined;
    }) => string | undefined;
    getQueryString: (kv?: Record<string, any>, opts?: {
        ignore?: string[];
    }) => string;
};

declare function useScroll(threshold: number): boolean;

declare function useScrollProgress(ref: RefObject<HTMLElement>): {
    scrollProgress: number;
    updateScrollProgress: () => void;
};

declare function useToastWithUndo(): ({ id, message, undo, duration, }: {
    id: number | string;
    message: string;
    undo: () => void;
    duration?: number | undefined;
}) => string | number;

declare function Background(): react_jsx_runtime.JSX.Element;

declare function Footer({ staticDomain, className, }: {
    staticDomain?: string;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function MaxWidthWrapper({ className, children, }: {
    className?: string;
    children: ReactNode;
}): react_jsx_runtime.JSX.Element;

declare function ProductContent({ domain }: {
    domain: string;
}): react_jsx_runtime.JSX.Element;

type NavTheme = "light" | "dark";
declare const NavContext: react.Context<{
    theme: NavTheme;
}>;
declare const navItems: ({
    name: string;
    content: typeof ProductContent;
    childItems: {
        title: string;
        description: string;
        icon: typeof Hyperlink;
        href: string;
    }[];
    segments: string[];
    href?: undefined;
} | {
    name: string;
    href: string;
    segments: string[];
    content?: undefined;
    childItems?: undefined;
})[];
declare function Nav({ theme, staticDomain, maxWidthWrapperClassName, }: {
    theme?: NavTheme;
    staticDomain?: string;
    maxWidthWrapperClassName?: string;
}): react_jsx_runtime.JSX.Element;

declare function NavMobile({ theme, staticDomain, }: {
    theme?: NavTheme;
    staticDomain?: string;
}): react_jsx_runtime.JSX.Element;

declare const FEATURES_LIST: {
    title: string;
    description: string;
    icon: typeof Hyperlink;
    href: string;
}[];
declare const CUSTOMER_STORIES: {
    icon: typeof Raycast;
    iconClassName: string;
    title: string;
    description: string;
    href: string;
}[];
declare const SDKS: {
    icon: typeof Typescript;
    iconClassName: string;
    title: string;
    href: string;
}[];
declare const RESOURCES: {
    icon: typeof Book2Fill;
    title: string;
    description: string;
    href: string;
}[];
declare const COMPANY: {
    icon: typeof FeatherFill;
    title: string;
    description: string;
    href: string;
}[];
declare const COMPARE_PAGES: {
    name: string;
    slug: string;
}[];
declare const LEGAL_PAGES: {
    name: string;
    slug: string;
}[];
declare const SOCIAL_LINKS: {
    name: string;
    icon: typeof Twitter;
    href: string;
}[];

/**
 * A container with animated width and height (each optional) based on children dimensions
 */
declare const AnimatedSizeContainer: react.ForwardRefExoticComponent<{
    width?: boolean | undefined;
    height?: boolean | undefined;
} & {
    children?: react.ReactNode;
} & Omit<Omit<{
    className?: string | undefined;
    title?: string | undefined;
    suppressHydrationWarning?: boolean | undefined;
    color?: string | undefined;
    id?: string | undefined;
    lang?: string | undefined;
    role?: react.AriaRole | undefined;
    tabIndex?: number | undefined;
    "aria-activedescendant"?: string | undefined;
    "aria-atomic"?: (boolean | "true" | "false") | undefined;
    "aria-autocomplete"?: "none" | "list" | "inline" | "both" | undefined;
    "aria-braillelabel"?: string | undefined;
    "aria-brailleroledescription"?: string | undefined;
    "aria-busy"?: (boolean | "true" | "false") | undefined;
    "aria-checked"?: boolean | "true" | "false" | "mixed" | undefined;
    "aria-colcount"?: number | undefined;
    "aria-colindex"?: number | undefined;
    "aria-colindextext"?: string | undefined;
    "aria-colspan"?: number | undefined;
    "aria-controls"?: string | undefined;
    "aria-current"?: boolean | "time" | "true" | "false" | "page" | "step" | "location" | "date" | undefined;
    "aria-describedby"?: string | undefined;
    "aria-description"?: string | undefined;
    "aria-details"?: string | undefined;
    "aria-disabled"?: (boolean | "true" | "false") | undefined;
    "aria-dropeffect"?: "link" | "none" | "copy" | "move" | "execute" | "popup" | undefined;
    "aria-errormessage"?: string | undefined;
    "aria-expanded"?: (boolean | "true" | "false") | undefined;
    "aria-flowto"?: string | undefined;
    "aria-grabbed"?: (boolean | "true" | "false") | undefined;
    "aria-haspopup"?: boolean | "dialog" | "menu" | "grid" | "listbox" | "tree" | "true" | "false" | undefined;
    "aria-hidden"?: (boolean | "true" | "false") | undefined;
    "aria-invalid"?: boolean | "true" | "false" | "grammar" | "spelling" | undefined;
    "aria-keyshortcuts"?: string | undefined;
    "aria-label"?: string | undefined;
    "aria-labelledby"?: string | undefined;
    "aria-level"?: number | undefined;
    "aria-live"?: "off" | "assertive" | "polite" | undefined;
    "aria-modal"?: (boolean | "true" | "false") | undefined;
    "aria-multiline"?: (boolean | "true" | "false") | undefined;
    "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
    "aria-orientation"?: "horizontal" | "vertical" | undefined;
    "aria-owns"?: string | undefined;
    "aria-placeholder"?: string | undefined;
    "aria-posinset"?: number | undefined;
    "aria-pressed"?: boolean | "true" | "false" | "mixed" | undefined;
    "aria-readonly"?: (boolean | "true" | "false") | undefined;
    "aria-relevant"?: "text" | "all" | "additions" | "additions removals" | "additions text" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals" | undefined;
    "aria-required"?: (boolean | "true" | "false") | undefined;
    "aria-roledescription"?: string | undefined;
    "aria-rowcount"?: number | undefined;
    "aria-rowindex"?: number | undefined;
    "aria-rowindextext"?: string | undefined;
    "aria-rowspan"?: number | undefined;
    "aria-selected"?: (boolean | "true" | "false") | undefined;
    "aria-setsize"?: number | undefined;
    "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
    "aria-valuemax"?: number | undefined;
    "aria-valuemin"?: number | undefined;
    "aria-valuenow"?: number | undefined;
    "aria-valuetext"?: string | undefined;
    dangerouslySetInnerHTML?: {
        __html: string | TrustedHTML;
    } | undefined;
    onCopy?: react.ClipboardEventHandler<HTMLDivElement> | undefined;
    onCopyCapture?: react.ClipboardEventHandler<HTMLDivElement> | undefined;
    onCut?: react.ClipboardEventHandler<HTMLDivElement> | undefined;
    onCutCapture?: react.ClipboardEventHandler<HTMLDivElement> | undefined;
    onPaste?: react.ClipboardEventHandler<HTMLDivElement> | undefined;
    onPasteCapture?: react.ClipboardEventHandler<HTMLDivElement> | undefined;
    onCompositionEnd?: react.CompositionEventHandler<HTMLDivElement> | undefined;
    onCompositionEndCapture?: react.CompositionEventHandler<HTMLDivElement> | undefined;
    onCompositionStart?: react.CompositionEventHandler<HTMLDivElement> | undefined;
    onCompositionStartCapture?: react.CompositionEventHandler<HTMLDivElement> | undefined;
    onCompositionUpdate?: react.CompositionEventHandler<HTMLDivElement> | undefined;
    onCompositionUpdateCapture?: react.CompositionEventHandler<HTMLDivElement> | undefined;
    onFocus?: react.FocusEventHandler<HTMLDivElement> | undefined;
    onFocusCapture?: react.FocusEventHandler<HTMLDivElement> | undefined;
    onBlur?: react.FocusEventHandler<HTMLDivElement> | undefined;
    onBlurCapture?: react.FocusEventHandler<HTMLDivElement> | undefined;
    onChange?: react.FormEventHandler<HTMLDivElement> | undefined;
    onChangeCapture?: react.FormEventHandler<HTMLDivElement> | undefined;
    onBeforeInput?: react.FormEventHandler<HTMLDivElement> | undefined;
    onBeforeInputCapture?: react.FormEventHandler<HTMLDivElement> | undefined;
    onInput?: react.FormEventHandler<HTMLDivElement> | undefined;
    onInputCapture?: react.FormEventHandler<HTMLDivElement> | undefined;
    onReset?: react.FormEventHandler<HTMLDivElement> | undefined;
    onResetCapture?: react.FormEventHandler<HTMLDivElement> | undefined;
    onSubmit?: react.FormEventHandler<HTMLDivElement> | undefined;
    onSubmitCapture?: react.FormEventHandler<HTMLDivElement> | undefined;
    onInvalid?: react.FormEventHandler<HTMLDivElement> | undefined;
    onInvalidCapture?: react.FormEventHandler<HTMLDivElement> | undefined;
    onLoad?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onLoadCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onError?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onErrorCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onKeyDown?: react.KeyboardEventHandler<HTMLDivElement> | undefined;
    onKeyDownCapture?: react.KeyboardEventHandler<HTMLDivElement> | undefined;
    onKeyPress?: react.KeyboardEventHandler<HTMLDivElement> | undefined;
    onKeyPressCapture?: react.KeyboardEventHandler<HTMLDivElement> | undefined;
    onKeyUp?: react.KeyboardEventHandler<HTMLDivElement> | undefined;
    onKeyUpCapture?: react.KeyboardEventHandler<HTMLDivElement> | undefined;
    onAbort?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onAbortCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onCanPlay?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onCanPlayCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onCanPlayThrough?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onCanPlayThroughCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onDurationChange?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onDurationChangeCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onEmptied?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onEmptiedCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onEncrypted?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onEncryptedCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onEnded?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onEndedCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onLoadedData?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onLoadedDataCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onLoadedMetadata?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onLoadedMetadataCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onLoadStart?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onLoadStartCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onPause?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onPauseCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onPlay?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onPlayCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onPlaying?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onPlayingCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onProgress?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onProgressCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onRateChange?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onRateChangeCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onResize?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onResizeCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onSeeked?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onSeekedCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onSeeking?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onSeekingCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onStalled?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onStalledCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onSuspend?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onSuspendCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onTimeUpdate?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onTimeUpdateCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onVolumeChange?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onVolumeChangeCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onWaiting?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onWaitingCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onAuxClick?: react.MouseEventHandler<HTMLDivElement> | undefined;
    onAuxClickCapture?: react.MouseEventHandler<HTMLDivElement> | undefined;
    onClick?: react.MouseEventHandler<HTMLDivElement> | undefined;
    onClickCapture?: react.MouseEventHandler<HTMLDivElement> | undefined;
    onContextMenu?: react.MouseEventHandler<HTMLDivElement> | undefined;
    onContextMenuCapture?: react.MouseEventHandler<HTMLDivElement> | undefined;
    onDoubleClick?: react.MouseEventHandler<HTMLDivElement> | undefined;
    onDoubleClickCapture?: react.MouseEventHandler<HTMLDivElement> | undefined;
    onDragCapture?: react.DragEventHandler<HTMLDivElement> | undefined;
    onDragEndCapture?: react.DragEventHandler<HTMLDivElement> | undefined;
    onDragEnter?: react.DragEventHandler<HTMLDivElement> | undefined;
    onDragEnterCapture?: react.DragEventHandler<HTMLDivElement> | undefined;
    onDragExit?: react.DragEventHandler<HTMLDivElement> | undefined;
    onDragExitCapture?: react.DragEventHandler<HTMLDivElement> | undefined;
    onDragLeave?: react.DragEventHandler<HTMLDivElement> | undefined;
    onDragLeaveCapture?: react.DragEventHandler<HTMLDivElement> | undefined;
    onDragOver?: react.DragEventHandler<HTMLDivElement> | undefined;
    onDragOverCapture?: react.DragEventHandler<HTMLDivElement> | undefined;
    onDragStartCapture?: react.DragEventHandler<HTMLDivElement> | undefined;
    onDrop?: react.DragEventHandler<HTMLDivElement> | undefined;
    onDropCapture?: react.DragEventHandler<HTMLDivElement> | undefined;
    onMouseDown?: react.MouseEventHandler<HTMLDivElement> | undefined;
    onMouseDownCapture?: react.MouseEventHandler<HTMLDivElement> | undefined;
    onMouseEnter?: react.MouseEventHandler<HTMLDivElement> | undefined;
    onMouseLeave?: react.MouseEventHandler<HTMLDivElement> | undefined;
    onMouseMove?: react.MouseEventHandler<HTMLDivElement> | undefined;
    onMouseMoveCapture?: react.MouseEventHandler<HTMLDivElement> | undefined;
    onMouseOut?: react.MouseEventHandler<HTMLDivElement> | undefined;
    onMouseOutCapture?: react.MouseEventHandler<HTMLDivElement> | undefined;
    onMouseOver?: react.MouseEventHandler<HTMLDivElement> | undefined;
    onMouseOverCapture?: react.MouseEventHandler<HTMLDivElement> | undefined;
    onMouseUp?: react.MouseEventHandler<HTMLDivElement> | undefined;
    onMouseUpCapture?: react.MouseEventHandler<HTMLDivElement> | undefined;
    onSelect?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onSelectCapture?: react.ReactEventHandler<HTMLDivElement> | undefined;
    onTouchCancel?: react.TouchEventHandler<HTMLDivElement> | undefined;
    onTouchCancelCapture?: react.TouchEventHandler<HTMLDivElement> | undefined;
    onTouchEnd?: react.TouchEventHandler<HTMLDivElement> | undefined;
    onTouchEndCapture?: react.TouchEventHandler<HTMLDivElement> | undefined;
    onTouchMove?: react.TouchEventHandler<HTMLDivElement> | undefined;
    onTouchMoveCapture?: react.TouchEventHandler<HTMLDivElement> | undefined;
    onTouchStart?: react.TouchEventHandler<HTMLDivElement> | undefined;
    onTouchStartCapture?: react.TouchEventHandler<HTMLDivElement> | undefined;
    onPointerDown?: react.PointerEventHandler<HTMLDivElement> | undefined;
    onPointerDownCapture?: react.PointerEventHandler<HTMLDivElement> | undefined;
    onPointerMove?: react.PointerEventHandler<HTMLDivElement> | undefined;
    onPointerMoveCapture?: react.PointerEventHandler<HTMLDivElement> | undefined;
    onPointerUp?: react.PointerEventHandler<HTMLDivElement> | undefined;
    onPointerUpCapture?: react.PointerEventHandler<HTMLDivElement> | undefined;
    onPointerCancel?: react.PointerEventHandler<HTMLDivElement> | undefined;
    onPointerCancelCapture?: react.PointerEventHandler<HTMLDivElement> | undefined;
    onPointerEnter?: react.PointerEventHandler<HTMLDivElement> | undefined;
    onPointerEnterCapture?: react.PointerEventHandler<HTMLDivElement> | undefined;
    onPointerLeave?: react.PointerEventHandler<HTMLDivElement> | undefined;
    onPointerLeaveCapture?: react.PointerEventHandler<HTMLDivElement> | undefined;
    onPointerOver?: react.PointerEventHandler<HTMLDivElement> | undefined;
    onPointerOverCapture?: react.PointerEventHandler<HTMLDivElement> | undefined;
    onPointerOut?: react.PointerEventHandler<HTMLDivElement> | undefined;
    onPointerOutCapture?: react.PointerEventHandler<HTMLDivElement> | undefined;
    onGotPointerCapture?: react.PointerEventHandler<HTMLDivElement> | undefined;
    onGotPointerCaptureCapture?: react.PointerEventHandler<HTMLDivElement> | undefined;
    onLostPointerCapture?: react.PointerEventHandler<HTMLDivElement> | undefined;
    onLostPointerCaptureCapture?: react.PointerEventHandler<HTMLDivElement> | undefined;
    onScroll?: react.UIEventHandler<HTMLDivElement> | undefined;
    onScrollCapture?: react.UIEventHandler<HTMLDivElement> | undefined;
    onWheel?: react.WheelEventHandler<HTMLDivElement> | undefined;
    onWheelCapture?: react.WheelEventHandler<HTMLDivElement> | undefined;
    onAnimationStartCapture?: react.AnimationEventHandler<HTMLDivElement> | undefined;
    onAnimationEnd?: react.AnimationEventHandler<HTMLDivElement> | undefined;
    onAnimationEndCapture?: react.AnimationEventHandler<HTMLDivElement> | undefined;
    onAnimationIteration?: react.AnimationEventHandler<HTMLDivElement> | undefined;
    onAnimationIterationCapture?: react.AnimationEventHandler<HTMLDivElement> | undefined;
    onTransitionEnd?: react.TransitionEventHandler<HTMLDivElement> | undefined;
    onTransitionEndCapture?: react.TransitionEventHandler<HTMLDivElement> | undefined;
    content?: string | undefined;
    translate?: "no" | "yes" | undefined;
    hidden?: boolean | undefined;
    slot?: string | undefined;
    defaultChecked?: boolean | undefined;
    defaultValue?: string | number | readonly string[] | undefined;
    suppressContentEditableWarning?: boolean | undefined;
    accessKey?: string | undefined;
    autoFocus?: boolean | undefined;
    contentEditable?: "inherit" | (boolean | "true" | "false") | "plaintext-only" | undefined;
    contextMenu?: string | undefined;
    dir?: string | undefined;
    draggable?: (boolean | "true" | "false") | undefined;
    nonce?: string | undefined;
    spellCheck?: (boolean | "true" | "false") | undefined;
    radioGroup?: string | undefined;
    about?: string | undefined;
    datatype?: string | undefined;
    inlist?: any;
    prefix?: string | undefined;
    property?: string | undefined;
    rel?: string | undefined;
    resource?: string | undefined;
    rev?: string | undefined;
    typeof?: string | undefined;
    vocab?: string | undefined;
    autoCapitalize?: string | undefined;
    autoCorrect?: string | undefined;
    autoSave?: string | undefined;
    itemProp?: string | undefined;
    itemScope?: boolean | undefined;
    itemType?: string | undefined;
    itemID?: string | undefined;
    itemRef?: string | undefined;
    results?: number | undefined;
    security?: string | undefined;
    unselectable?: "off" | "on" | undefined;
    inputMode?: "search" | "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | undefined;
    is?: string | undefined;
    tw?: string | undefined;
} & framer_motion.MotionProps & react.RefAttributes<HTMLDivElement>, "ref">, "children" | "animate"> & react.RefAttributes<HTMLDivElement>>;

declare function BlurImage(props: ImageProps): react_jsx_runtime.JSX.Element;

declare const ClientOnly: ({ children, fallback, fadeInDuration, className, }: {
    children: ReactNode;
    fallback?: ReactNode;
    fadeInDuration?: number | undefined;
    className?: string | undefined;
}) => react_jsx_runtime.JSX.Element;

declare const copyButtonVariants: (props?: ({
    variant?: "default" | "neutral" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
declare function CopyButton({ variant, value, className, icon, successMessage, }: {
    value: string;
    className?: string;
    icon?: LucideIcon;
    successMessage?: string;
} & VariantProps<typeof copyButtonVariants>): react_jsx_runtime.JSX.Element;

declare function CopyText({ value, children, className, successMessage, }: {
    value: string;
    children: ReactNode;
    className?: string;
    successMessage?: string;
}): react_jsx_runtime.JSX.Element;

interface MenuIconProps {
    icon: ReactNode;
    text: string;
}
declare function IconMenu({ icon, text }: MenuIconProps): react_jsx_runtime.JSX.Element;

declare const InlineSnippet: ({ children }: {
    children: string;
}) => react_jsx_runtime.JSX.Element;

declare function LinkLogo({ apexDomain, className, imageProps, }: {
    apexDomain?: string | null;
    className?: string;
    imageProps?: Partial<ImageProps>;
}): react_jsx_runtime.JSX.Element;

declare function LinkPreview({ defaultUrl }: {
    defaultUrl?: string;
}): react_jsx_runtime.JSX.Element;
declare function LinkPreviewPlaceholder({ defaultUrl, }: {
    defaultUrl?: string;
}): react_jsx_runtime.JSX.Element;

declare const PopupContext: react.Context<{
    hidePopup: () => void;
}>;
declare function Popup({ children, hiddenCookieId, }: {
    children: ReactNode;
    hiddenCookieId: string;
}): react_jsx_runtime.JSX.Element;

declare function ProgressBar({ value, max, className, }: {
    value?: number;
    max?: number;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare const tabSelectButtonVariants: (props?: ({
    variant?: "default" | "accent" | null | undefined;
} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
declare function TabSelect<T extends string>({ variant, options, selected, onSelect, className, }: VariantProps<typeof tabSelectButtonVariants> & {
    options: {
        id: T;
        label: string;
    }[];
    selected: string | null;
    onSelect?: Dispatch<SetStateAction<T>> | ((id: T) => void);
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function CompositeLogo({ className }: {
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function Logo({ className }: {
    className?: string;
}): react_jsx_runtime.JSX.Element;

/**
 * The Dub logo with a custom context menu for copying/navigation,
 * for use in the top site nav
 */
declare function NavWordmark({ variant, isInApp, className, }: {
    variant?: "full" | "symbol";
    isInApp?: boolean;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function Wordmark({ className }: {
    className?: string;
}): react_jsx_runtime.JSX.Element;

export { AUTOPLAY_DEFAULT_DELAY, Accordion, AccordionContent, AccordionItem, AccordionTrigger, Alert, AlertDescription, AlertTitle, AnimatedSizeContainer, Avatar, Background, Badge, BadgeTooltip, BlurImage, Button, ButtonProps, ButtonTooltip, COMPANY, COMPARE_PAGES, CUSTOMER_STORIES, Calendar, CardList, Carousel, CarouselApi, CarouselContent, CarouselItem, CarouselNavBar, CarouselNext, CarouselPrevious, CarouselThumbnail, CarouselThumbnails, Checkbox, ClientOnly, Combobox, ComboboxOption, ComboboxProps, CompositeLogo, CopyButton, CopyText, DatePickerContext, DateRangePicker, EmptyState, EmptyStateProps, FEATURES_LIST, FileUpload, FileUploadProps, Filter, Footer, Form, Grid, IconMenu, InfoTooltip, InlineSnippet, Input, InputProps, InputSelect, InputSelectItemProps, KeyboardShortcutContext, KeyboardShortcutProvider, LEGAL_PAGES, Label, LinkLogo, LinkPreview, LinkPreviewPlaceholder, LinkifyTooltipContent, Logo, MaxWidthWrapper, MiniAreaChart, MiniAreaChartProps, Modal, Nav, NavContext, NavMobile, NavTheme, NavWordmark, NumberTooltip, PaginationControls, PaginationState, Popover, PopoverProps, Popup, PopupContext, ProgressBar, RESOURCES, RadioGroup, RadioGroupItem, SDKS, SOCIAL_LINKS, Sheet, ShimmerDots, SimpleTooltipContent, StatusBadge, Switch, TabSelect, Table, ToggleGroup, TokenAvatar, Tooltip, TooltipContent, TooltipProps, TooltipProvider, UTMBuilder, UTM_PARAMETERS, Wordmark, badgeVariants, buttonVariants, getUserAvatarUrl, navItems, statusBadgeVariants, useCarousel, useCarouselActiveIndex, useCookies, useCopyToClipboard, useCurrentAnchor, useEnterSubmit, useInViewport, useInputFocused, useIntersectionObserver, useKeyboardShortcut, useLocalStorage, useMediaQuery, useOptimisticUpdate, usePagination, useRemoveGAParams, useResizeObserver, useRouterStuff, useScroll, useScrollProgress, useTable, useTablePagination, useToastWithUndo };
