import * as react_jsx_runtime from 'react/jsx-runtime';
import * as React$1 from 'react';
import React__default, { LabelHTMLAttributes, ButtonHTMLAttributes, ReactNode, Ref, ReactElement, RefObject, FocusEvent, TextareaHTMLAttributes, CSSProperties, ChangeEvent, HTMLAttributes, FC, MouseEvent } from 'react';
import { SvgProps } from 'react-native-svg';
import { TextProps, StyleProp, TextStyle, ViewStyle, AccessibilityRole, AccessibilityState, ImageStyle, View, TextInputProps, NativeSyntheticEvent, TextInputFocusEventData, ModalProps, GestureResponderEvent, TouchableOpacity } from 'react-native';
import * as src from 'src';

type ThemeColors = 'light' | 'dark';

interface ThemeState {
    theme: ThemeColors;
    setTheme: (theme: ThemeColors) => void;
}
declare const ThemeProvider: ({ theme, children, }: {
    theme?: ThemeColors;
    children: React.ReactNode;
}) => react_jsx_runtime.JSX.Element;
declare const useTheme: () => ThemeState;

interface SportsBettingIconsProps extends React.SVGProps<SVGSVGElement> {
    color?: string;
    size?: number;
    iconcolor?: string;
}
interface SportsBettingIconsNativeProps extends SvgProps {
    color?: string;
    size?: number;
    iconcolor?: string;
}

declare const SportsBetting: React__default.FC<SportsBettingIconsProps>;
declare const SportsBettingLogo: React__default.FC<SportsBettingIconsProps>;
declare const Sport: React__default.FC<SportsBettingIconsProps>;
declare const Soccer: React__default.FC<SportsBettingIconsProps>;
declare const IceHockey: React__default.FC<SportsBettingIconsProps>;
declare const Tennis: React__default.FC<SportsBettingIconsProps>;
declare const TennisEmpty: React__default.FC<SportsBettingIconsProps>;
declare const Basketball: React__default.FC<SportsBettingIconsProps>;
declare const BasketballEmpty: React__default.FC<SportsBettingIconsProps>;
declare const Handball: React__default.FC<SportsBettingIconsProps>;
declare const AmericanFootball: React__default.FC<SportsBettingIconsProps>;
declare const TableTennis: React__default.FC<SportsBettingIconsProps>;
declare const Football: React__default.FC<SportsBettingIconsProps>;
declare const HandballEmpty: React__default.FC<SportsBettingIconsProps>;
declare const Futsal: React__default.FC<SportsBettingIconsProps>;
declare const Baseball: React__default.FC<SportsBettingIconsProps>;
declare const Volleyball: React__default.FC<SportsBettingIconsProps>;
declare const Cycling: React__default.FC<SportsBettingIconsProps>;
declare const Aircash: React__default.FC<SportsBettingIconsProps>;
declare const AircashFlat: React__default.FC<SportsBettingIconsProps>;
declare const Paypal: React__default.FC<SportsBettingIconsProps>;
declare const PaypalFlat: React__default.FC<SportsBettingIconsProps>;
declare const Trustly: React__default.FC<SportsBettingIconsProps>;
declare const TrustlyFlat: React__default.FC<SportsBettingIconsProps>;
declare const Mastercard: React__default.FC<SportsBettingIconsProps>;
declare const MastercardFlat: React__default.FC<SportsBettingIconsProps>;
declare const Visa: React__default.FC<SportsBettingIconsProps>;
declare const VisaFlat: React__default.FC<SportsBettingIconsProps>;
declare const Skrill: React__default.FC<SportsBettingIconsProps>;
declare const SkrillFlat: React__default.FC<SportsBettingIconsProps>;
declare const BankTransfer: React__default.FC<SportsBettingIconsProps>;
declare const BankTransferFlat: React__default.FC<SportsBettingIconsProps>;
declare const CustomerCard: React__default.FC<SportsBettingIconsProps>;
declare const MGALogo: React__default.FC<SportsBettingIconsProps>;
declare const GGLLogo: React__default.FC<SportsBettingIconsProps>;
declare const ManagementSystemLogo: React__default.FC<SportsBettingIconsProps>;
declare const DSWLogo: React__default.FC<SportsBettingIconsProps>;
declare const Facebook: React__default.FC<SportsBettingIconsProps>;
declare const Twitter: React__default.FC<SportsBettingIconsProps>;
declare const LinkedIn: React__default.FC<SportsBettingIconsProps>;
declare const Instagram: React__default.FC<SportsBettingIconsProps>;
declare const ChrevonUp: React__default.FC<SportsBettingIconsProps>;
declare const ChrevonDown: React__default.FC<SportsBettingIconsProps>;
declare const ChrevonLeft: React__default.FC<SportsBettingIconsProps>;
declare const ChrevonRight: React__default.FC<SportsBettingIconsProps>;
declare const LeftRightArrow: React__default.FC<SportsBettingIconsProps>;
declare const Star: React__default.FC<SportsBettingIconsProps>;
declare const WarningFilled: React__default.FC<SportsBettingIconsProps>;
declare const Warning: React__default.FC<SportsBettingIconsProps>;
declare const AgeRestriction: React__default.FC<SportsBettingIconsProps>;
declare const AppleStore: React__default.FC<SportsBettingIconsProps>;
declare const PlayStore: React__default.FC<SportsBettingIconsProps>;
declare const QRCode: React__default.FC<SportsBettingIconsProps>;
declare const VerticalBar: React__default.FC<SportsBettingIconsProps>;
declare const Globe: React__default.FC<SportsBettingIconsProps>;
declare const User: React__default.FC<SportsBettingIconsProps>;
declare const X: React__default.FC<SportsBettingIconsProps>;
declare const XFill: React__default.FC<SportsBettingIconsProps>;
declare const ShopWallet: React__default.FC<SportsBettingIconsProps>;
declare const CicrleCheck: React__default.FC<SportsBettingIconsProps>;
declare const CicrleCheckFill: React__default.FC<SportsBettingIconsProps>;
declare const CicrleCheckFill2: React__default.FC<SportsBettingIconsProps>;
declare const CircleCrossFill: React__default.FC<SportsBettingIconsProps>;
declare const Minus: React__default.FC<SportsBettingIconsProps>;
declare const Plus: React__default.FC<SportsBettingIconsProps>;
declare const Chat: React__default.FC<SportsBettingIconsProps>;
declare const HeadSet: React__default.FC<SportsBettingIconsProps>;
declare const Bin: React__default.FC<SportsBettingIconsProps>;
declare const Lock: React__default.FC<SportsBettingIconsProps>;
declare const Gift: React__default.FC<SportsBettingIconsProps>;
declare const EuroIcon: React__default.FC<SportsBettingIconsProps>;
declare const Card$1: React__default.FC<SportsBettingIconsProps>;
declare const Pin: React__default.FC<SportsBettingIconsProps>;
declare const RedCard: React__default.FC<SportsBettingIconsProps>;
declare const Ball: React__default.FC<SportsBettingIconsProps>;
declare const VAR: React__default.FC<SportsBettingIconsProps>;
declare const Live: React__default.FC<SportsBettingIconsProps>;
declare const ArrowDown: React__default.FC<SportsBettingIconsProps>;
declare const ArrowUp: React__default.FC<SportsBettingIconsProps>;
declare const ArrowLeft: React__default.FC<SportsBettingIconsProps>;
declare const TriangleInclinedUp: React__default.FC<SportsBettingIconsProps>;
declare const TriangleInclinedDown: React__default.FC<SportsBettingIconsProps>;
declare const GridView: React__default.FC<SportsBettingIconsProps>;
declare const Medal: React__default.FC<SportsBettingIconsProps>;
declare const Search: React__default.FC<SportsBettingIconsProps>;
declare const Bell: React__default.FC<SportsBettingIconsProps>;
declare const Eye: React__default.FC<SportsBettingIconsProps>;
declare const EyeOff: React__default.FC<SportsBettingIconsProps>;
declare const Graph: React__default.FC<SportsBettingIconsProps>;
declare const TriangleRight: React__default.FC<SportsBettingIconsProps>;
declare const TriangleLeft: React__default.FC<SportsBettingIconsProps>;
declare const TriangleDown: React__default.FC<SportsBettingIconsProps>;
declare const TriangleUp: React__default.FC<SportsBettingIconsProps>;
declare const Flash: React__default.FC<SportsBettingIconsProps>;
declare const BettingSlip: React__default.FC<SportsBettingIconsProps>;
declare const CashOut: React__default.FC<SportsBettingIconsProps>;
declare const CashoutRotate: React__default.FC<SportsBettingIconsProps>;
declare const Menu: React__default.FC<SportsBettingIconsProps>;
declare const HighlightsPoint: React__default.FC<SportsBettingIconsProps>;
declare const InternetError: React__default.FC<SportsBettingIconsProps>;
declare const Logout: React__default.FC<SportsBettingIconsProps>;
declare const UEFA: React__default.FC<SportsBettingIconsProps>;
declare const LeftArrow: ({ color, ...props }: SportsBettingIconsProps) => react_jsx_runtime.JSX.Element;
declare const Information: ({ color, ...props }: SportsBettingIconsProps) => react_jsx_runtime.JSX.Element;
declare const TransferDeposit: React__default.FC<SportsBettingIconsProps>;
declare const TransferWithdraw: React__default.FC<SportsBettingIconsProps>;
declare const Reload: React__default.FC<SportsBettingIconsProps>;
declare const Smartphone: React__default.FC<SportsBettingIconsProps>;
declare const Envelope: React__default.FC<SportsBettingIconsProps>;
declare const InformationCircle: React__default.FC<SportsBettingIconsProps>;
declare const SuccessIcon: React__default.FC<SportsBettingIconsProps>;
declare const PendingIcon: React__default.FC<SportsBettingIconsProps>;
declare const ErrorIcon: React__default.FC<SportsBettingIconsProps>;
declare const CancelledIcon: React__default.FC<SportsBettingIconsProps>;
declare const Check: React__default.FC<SportsBettingIconsProps>;
declare const Cross: React__default.FC<SportsBettingIconsProps>;
declare const StarFill: React__default.FC<SportsBettingIconsProps>;
declare const Barcode: React__default.FC<SportsBettingIconsProps>;
declare const CameraBlocked: React__default.FC<SportsBettingIconsProps>;
declare const BarcodeBorder: ({ ...props }: {
    [x: string]: any;
}) => react_jsx_runtime.JSX.Element;
declare const House: React__default.FC<SportsBettingIconsProps>;
declare const UploadIcon: React__default.FC<SportsBettingIconsProps>;
declare const Clock: React__default.FC<SportsBettingIconsProps>;
declare const CancelTip: React__default.FC<SportsBettingIconsProps>;
declare const PaperclipIcon: React__default.FC<SportsBettingIconsProps>;
declare const SettingsIcon: React__default.FC<SportsBettingIconsProps>;
declare const MixedMenuIcon: React__default.FC<SportsBettingIconsProps>;
declare const MastercardMobile: React__default.FC<SportsBettingIconsProps>;
declare const BellEmpty: React__default.FC<SportsBettingIconsProps>;
declare const MixedMenuIcon1: React__default.FC<SportsBettingIconsProps>;

declare const index_AgeRestriction: typeof AgeRestriction;
declare const index_Aircash: typeof Aircash;
declare const index_AircashFlat: typeof AircashFlat;
declare const index_AmericanFootball: typeof AmericanFootball;
declare const index_AppleStore: typeof AppleStore;
declare const index_ArrowDown: typeof ArrowDown;
declare const index_ArrowLeft: typeof ArrowLeft;
declare const index_ArrowUp: typeof ArrowUp;
declare const index_Ball: typeof Ball;
declare const index_BankTransfer: typeof BankTransfer;
declare const index_BankTransferFlat: typeof BankTransferFlat;
declare const index_Barcode: typeof Barcode;
declare const index_BarcodeBorder: typeof BarcodeBorder;
declare const index_Baseball: typeof Baseball;
declare const index_Basketball: typeof Basketball;
declare const index_BasketballEmpty: typeof BasketballEmpty;
declare const index_Bell: typeof Bell;
declare const index_BellEmpty: typeof BellEmpty;
declare const index_BettingSlip: typeof BettingSlip;
declare const index_Bin: typeof Bin;
declare const index_CameraBlocked: typeof CameraBlocked;
declare const index_CancelTip: typeof CancelTip;
declare const index_CancelledIcon: typeof CancelledIcon;
declare const index_CashOut: typeof CashOut;
declare const index_CashoutRotate: typeof CashoutRotate;
declare const index_Chat: typeof Chat;
declare const index_Check: typeof Check;
declare const index_ChrevonDown: typeof ChrevonDown;
declare const index_ChrevonLeft: typeof ChrevonLeft;
declare const index_ChrevonRight: typeof ChrevonRight;
declare const index_ChrevonUp: typeof ChrevonUp;
declare const index_CicrleCheck: typeof CicrleCheck;
declare const index_CicrleCheckFill: typeof CicrleCheckFill;
declare const index_CicrleCheckFill2: typeof CicrleCheckFill2;
declare const index_CircleCrossFill: typeof CircleCrossFill;
declare const index_Clock: typeof Clock;
declare const index_Cross: typeof Cross;
declare const index_CustomerCard: typeof CustomerCard;
declare const index_Cycling: typeof Cycling;
declare const index_DSWLogo: typeof DSWLogo;
declare const index_Envelope: typeof Envelope;
declare const index_ErrorIcon: typeof ErrorIcon;
declare const index_EuroIcon: typeof EuroIcon;
declare const index_Eye: typeof Eye;
declare const index_EyeOff: typeof EyeOff;
declare const index_Facebook: typeof Facebook;
declare const index_Flash: typeof Flash;
declare const index_Football: typeof Football;
declare const index_Futsal: typeof Futsal;
declare const index_GGLLogo: typeof GGLLogo;
declare const index_Gift: typeof Gift;
declare const index_Globe: typeof Globe;
declare const index_Graph: typeof Graph;
declare const index_GridView: typeof GridView;
declare const index_Handball: typeof Handball;
declare const index_HandballEmpty: typeof HandballEmpty;
declare const index_HeadSet: typeof HeadSet;
declare const index_HighlightsPoint: typeof HighlightsPoint;
declare const index_House: typeof House;
declare const index_IceHockey: typeof IceHockey;
declare const index_Information: typeof Information;
declare const index_InformationCircle: typeof InformationCircle;
declare const index_Instagram: typeof Instagram;
declare const index_InternetError: typeof InternetError;
declare const index_LeftArrow: typeof LeftArrow;
declare const index_LeftRightArrow: typeof LeftRightArrow;
declare const index_LinkedIn: typeof LinkedIn;
declare const index_Live: typeof Live;
declare const index_Lock: typeof Lock;
declare const index_Logout: typeof Logout;
declare const index_MGALogo: typeof MGALogo;
declare const index_ManagementSystemLogo: typeof ManagementSystemLogo;
declare const index_Mastercard: typeof Mastercard;
declare const index_MastercardFlat: typeof MastercardFlat;
declare const index_MastercardMobile: typeof MastercardMobile;
declare const index_Medal: typeof Medal;
declare const index_Menu: typeof Menu;
declare const index_Minus: typeof Minus;
declare const index_MixedMenuIcon: typeof MixedMenuIcon;
declare const index_MixedMenuIcon1: typeof MixedMenuIcon1;
declare const index_PaperclipIcon: typeof PaperclipIcon;
declare const index_Paypal: typeof Paypal;
declare const index_PaypalFlat: typeof PaypalFlat;
declare const index_PendingIcon: typeof PendingIcon;
declare const index_Pin: typeof Pin;
declare const index_PlayStore: typeof PlayStore;
declare const index_Plus: typeof Plus;
declare const index_QRCode: typeof QRCode;
declare const index_RedCard: typeof RedCard;
declare const index_Reload: typeof Reload;
declare const index_Search: typeof Search;
declare const index_SettingsIcon: typeof SettingsIcon;
declare const index_ShopWallet: typeof ShopWallet;
declare const index_Skrill: typeof Skrill;
declare const index_SkrillFlat: typeof SkrillFlat;
declare const index_Smartphone: typeof Smartphone;
declare const index_Soccer: typeof Soccer;
declare const index_Sport: typeof Sport;
declare const index_SportsBetting: typeof SportsBetting;
type index_SportsBettingIconsNativeProps = SportsBettingIconsNativeProps;
type index_SportsBettingIconsProps = SportsBettingIconsProps;
declare const index_SportsBettingLogo: typeof SportsBettingLogo;
declare const index_Star: typeof Star;
declare const index_StarFill: typeof StarFill;
declare const index_SuccessIcon: typeof SuccessIcon;
declare const index_TableTennis: typeof TableTennis;
declare const index_Tennis: typeof Tennis;
declare const index_TennisEmpty: typeof TennisEmpty;
declare const index_TransferDeposit: typeof TransferDeposit;
declare const index_TransferWithdraw: typeof TransferWithdraw;
declare const index_TriangleDown: typeof TriangleDown;
declare const index_TriangleInclinedDown: typeof TriangleInclinedDown;
declare const index_TriangleInclinedUp: typeof TriangleInclinedUp;
declare const index_TriangleLeft: typeof TriangleLeft;
declare const index_TriangleRight: typeof TriangleRight;
declare const index_TriangleUp: typeof TriangleUp;
declare const index_Trustly: typeof Trustly;
declare const index_TrustlyFlat: typeof TrustlyFlat;
declare const index_Twitter: typeof Twitter;
declare const index_UEFA: typeof UEFA;
declare const index_UploadIcon: typeof UploadIcon;
declare const index_User: typeof User;
declare const index_VAR: typeof VAR;
declare const index_VerticalBar: typeof VerticalBar;
declare const index_Visa: typeof Visa;
declare const index_VisaFlat: typeof VisaFlat;
declare const index_Volleyball: typeof Volleyball;
declare const index_Warning: typeof Warning;
declare const index_WarningFilled: typeof WarningFilled;
declare const index_X: typeof X;
declare const index_XFill: typeof XFill;
declare namespace index {
  export { index_AgeRestriction as AgeRestriction, index_Aircash as Aircash, index_AircashFlat as AircashFlat, index_AmericanFootball as AmericanFootball, index_AppleStore as AppleStore, index_ArrowDown as ArrowDown, index_ArrowLeft as ArrowLeft, index_ArrowUp as ArrowUp, index_Ball as Ball, index_BankTransfer as BankTransfer, index_BankTransferFlat as BankTransferFlat, index_Barcode as Barcode, index_BarcodeBorder as BarcodeBorder, index_Baseball as Baseball, index_Basketball as Basketball, index_BasketballEmpty as BasketballEmpty, index_Bell as Bell, index_BellEmpty as BellEmpty, index_BettingSlip as BettingSlip, index_Bin as Bin, index_CameraBlocked as CameraBlocked, index_CancelTip as CancelTip, index_CancelledIcon as CancelledIcon, Card$1 as Card, index_CashOut as CashOut, index_CashoutRotate as CashoutRotate, index_Chat as Chat, index_Check as Check, index_ChrevonDown as ChrevonDown, index_ChrevonLeft as ChrevonLeft, index_ChrevonRight as ChrevonRight, index_ChrevonUp as ChrevonUp, index_CicrleCheck as CicrleCheck, index_CicrleCheckFill as CicrleCheckFill, index_CicrleCheckFill2 as CicrleCheckFill2, index_CircleCrossFill as CircleCrossFill, index_Clock as Clock, index_Cross as Cross, index_CustomerCard as CustomerCard, index_Cycling as Cycling, index_DSWLogo as DSWLogo, index_Envelope as Envelope, index_ErrorIcon as ErrorIcon, index_EuroIcon as EuroIcon, index_Eye as Eye, index_EyeOff as EyeOff, index_Facebook as Facebook, index_Flash as Flash, index_Football as Football, index_Futsal as Futsal, index_GGLLogo as GGLLogo, index_Gift as Gift, index_Globe as Globe, index_Graph as Graph, index_GridView as GridView, index_Handball as Handball, index_HandballEmpty as HandballEmpty, index_HeadSet as HeadSet, index_HighlightsPoint as HighlightsPoint, index_House as House, index_IceHockey as IceHockey, index_Information as Information, index_InformationCircle as InformationCircle, index_Instagram as Instagram, index_InternetError as InternetError, index_LeftArrow as LeftArrow, index_LeftRightArrow as LeftRightArrow, index_LinkedIn as LinkedIn, index_Live as Live, index_Lock as Lock, index_Logout as Logout, index_MGALogo as MGALogo, index_ManagementSystemLogo as ManagementSystemLogo, index_Mastercard as Mastercard, index_MastercardFlat as MastercardFlat, index_MastercardMobile as MastercardMobile, index_Medal as Medal, index_Menu as Menu, index_Minus as Minus, index_MixedMenuIcon as MixedMenuIcon, index_MixedMenuIcon1 as MixedMenuIcon1, index_PaperclipIcon as PaperclipIcon, index_Paypal as Paypal, index_PaypalFlat as PaypalFlat, index_PendingIcon as PendingIcon, index_Pin as Pin, index_PlayStore as PlayStore, index_Plus as Plus, index_QRCode as QRCode, index_RedCard as RedCard, index_Reload as Reload, index_Search as Search, index_SettingsIcon as SettingsIcon, index_ShopWallet as ShopWallet, index_Skrill as Skrill, index_SkrillFlat as SkrillFlat, index_Smartphone as Smartphone, index_Soccer as Soccer, index_Sport as Sport, index_SportsBetting as SportsBetting, type index_SportsBettingIconsNativeProps as SportsBettingIconsNativeProps, type index_SportsBettingIconsProps as SportsBettingIconsProps, index_SportsBettingLogo as SportsBettingLogo, index_Star as Star, index_StarFill as StarFill, index_SuccessIcon as SuccessIcon, index_TableTennis as TableTennis, index_Tennis as Tennis, index_TennisEmpty as TennisEmpty, index_TransferDeposit as TransferDeposit, index_TransferWithdraw as TransferWithdraw, index_TriangleDown as TriangleDown, index_TriangleInclinedDown as TriangleInclinedDown, index_TriangleInclinedUp as TriangleInclinedUp, index_TriangleLeft as TriangleLeft, index_TriangleRight as TriangleRight, index_TriangleUp as TriangleUp, index_Trustly as Trustly, index_TrustlyFlat as TrustlyFlat, index_Twitter as Twitter, index_UEFA as UEFA, index_UploadIcon as UploadIcon, index_User as User, index_VAR as VAR, index_VerticalBar as VerticalBar, index_Visa as Visa, index_VisaFlat as VisaFlat, index_Volleyball as Volleyball, index_Warning as Warning, index_WarningFilled as WarningFilled, index_X as X, index_XFill as XFill };
}

interface ThemeSwitcherProps {
    className?: string;
}
declare function ThemeSwitcher({ className }: ThemeSwitcherProps): react_jsx_runtime.JSX.Element | null;

type LabelVariant = 'primary' | 'secondary';
type LabelSize = 'small' | 'medium' | 'large';
interface LabelProps extends LabelHTMLAttributes<HTMLLabelElement> {
    /**
     * The variant of the label
     * @default 'primary'
     */
    variant?: LabelVariant;
    /**
     * The size of the label
     * @default 'medium'
     */
    size?: LabelSize;
    /**
     * Classname for the label
     * @default ''
     */
    htmlFor?: string;
    ariaLabel?: string;
    className?: string;
    accessibilityLabel?: string;
}
interface LabelNativeProps extends TextProps {
    variant?: LabelVariant;
    size?: LabelSize;
    style?: StyleProp<TextStyle>;
    accessibilityLabel?: string;
    children: React.ReactNode;
}

declare const Label: ({ size, variant, className, htmlFor, children, "aria-label": ariaLabel, ...props }: LabelProps) => react_jsx_runtime.JSX.Element;

type ButtonVariant = 'primary' | 'secondary' | 'ghost' | 'ghostDark' | 'cyan' | 'withShadow';
type ButtonSize = 'small' | 'medium' | 'large';
interface ButtonNativeProps {
    id?: string;
    label?: string | ReactElement;
    icon?: ReactElement;
    onPress?: () => void;
    disabled?: boolean;
    variant?: ButtonVariant;
    size?: ButtonSize;
    loading?: boolean;
    rounded?: boolean;
    style?: StyleProp<ViewStyle>;
    accessibilityLabel?: string;
    className?: string;
    textStyle?: string;
    accessibilityRole?: AccessibilityRole;
    accessibilityState?: AccessibilityState;
    accessibilityHint?: string;
}
interface ButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onClick'> {
    label: string | ReactNode;
    onClick?: () => void;
    icon?: ReactNode;
    disabled?: boolean;
    variant?: ButtonVariant;
    size?: ButtonSize;
    loading?: boolean;
    rounded?: boolean;
    forwardedRef?: Ref<HTMLButtonElement>;
    asChild?: boolean;
    textStyle?: string;
    className?: string;
    as?: React.ElementType;
    ariaLabel?: string;
}

declare const Button: React__default.ForwardRefExoticComponent<ButtonProps & React__default.RefAttributes<HTMLButtonElement>>;

interface SkeletonProps {
    id?: string;
    className?: string;
    height?: string | number;
    width?: string | number;
    shape?: 'rectangular' | 'circle' | 'rounded';
    count?: number;
    duration?: number;
    animated?: boolean;
    color?: string;
    backgroundColor?: string;
    isVisible?: boolean;
    showPercentage?: boolean;
    style?: React.CSSProperties | StyleProp<ViewStyle>;
    containerStyle?: React.CSSProperties | StyleProp<ViewStyle>;
}

declare const Skeleton: ({ id, className, height, width, shape, count, duration, animated, color, backgroundColor, isVisible, showPercentage, containerStyle, }: SkeletonProps) => react_jsx_runtime.JSX.Element | null;

type BannerTextPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'center';
interface BannerProps {
    id?: string;
    alt?: string;
    className?: string;
    ref?: RefObject<HTMLDivElement>;
    image?: string;
    imageFit?: 'cover' | 'contain';
    heading?: string | ReactNode;
    subheading?: string | ReactNode;
    textPosition?: BannerTextPosition;
    hoverEffect?: boolean;
    shadowOnHover?: boolean;
    innerShadowOnHover?: boolean;
    layerBlurOnHover?: boolean;
    dimensions?: 'small' | 'medium' | 'large';
}
interface BannerNativeProps {
    id?: string;
    style?: StyleProp<ViewStyle>;
    alt?: string;
    image?: string | number;
    imageFit?: 'cover' | 'contain' | 'stretch' | 'center' | 'repeat';
    imageStyle?: StyleProp<ImageStyle>;
    ref?: React.Ref<View> | React.RefObject<View>;
    heading?: string | ReactNode;
    subheading?: string | ReactNode;
    textPosition?: BannerTextPosition;
    onPressEffect?: boolean;
    shadowOnPress?: boolean;
    innerShadowOnPress?: boolean;
    layerBlurOnPress?: boolean;
    dimensions?: 'small' | 'medium' | 'large';
    disableDefaultDimensions?: boolean;
    aspectRatio?: number;
    autoAspectRatio?: boolean;
    fallbackHeight?: number;
}

declare const Banner: React$1.ForwardRefExoticComponent<Omit<BannerProps, "ref"> & React$1.RefAttributes<HTMLDivElement>>;

interface SeparatorProps {
    id?: string;
    className?: string;
    orientation?: 'horizontal' | 'vertical';
    thickness?: number | string;
    color?: string;
    spacing?: number | string;
    length?: number | string;
    variant?: 'solid' | 'dashed' | 'dotted' | 'multiple';
    lineCount?: number;
    lineSpacing?: string | number;
    style?: React__default.CSSProperties | StyleProp<ViewStyle>;
    ariaLabel?: string;
}

declare const Separator: React__default.FC<SeparatorProps>;

type CheckBoxSize$1 = 'small' | 'medium' | 'large';
type CheckBoxVariant = 'primary' | 'secondary';
type CheckBoxDirection = 'row' | 'column';
type CheckBoxStatus$1 = 'warning' | 'error' | 'default';
interface CheckBoxProps {
    /**
     * Checkbox id
     */
    id?: string;
    /**
     * Custom CSS class for styling.
     */
    className?: string;
    /**
     * Check box label
     */
    label?: string | ReactNode;
    /**
     * Default checked state
     * @default false
     */
    defaultChecked?: boolean;
    /**
     * Whether the checkbox is in a checked state
     * @default false
     */
    checked?: boolean;
    /**
     * Function for updating the checkbox state
     */
    onChange?: (value: boolean) => void;
    /**
     * Whether the checkbox is in a disabled state
     * @default false
     */
    disabled?: boolean;
    /**
     * Whether the checkbox is in a readonly state
     * @default false
     */
    readOnly?: boolean;
    /**
     * Whether the checkbox is in a required state
     * @default false
     */
    required?: boolean;
    onFocus?: (event: FocusEvent<HTMLInputElement>) => void;
    onBlur?: (event: FocusEvent<HTMLInputElement>) => void;
    /**
     * Checkbox size
     * @default medium
     */
    size?: CheckBoxSize$1;
    /**
     * Checkbox variant
     * @default primary
     */
    variant?: CheckBoxVariant;
    /**
     * Checkbox direction
     * @default row
     */
    direction?: CheckBoxDirection;
    /**
     * Checkbox status
     */
    status?: CheckBoxStatus$1;
    partialChecked?: boolean;
    checkboxClassname?: string;
}

declare const CheckBox: React__default.FC<CheckBoxProps>;

type CheckBoxStatusType = 'completed' | 'active' | 'error' | 'pending' | 'neutral' | 'custom';
type CheckBoxSize = 'small' | 'medium' | 'large';
interface CheckBoxStatusProps {
    id: string;
    className?: string;
    status: CheckBoxStatusType;
    size?: CheckBoxSize;
    strokeColor?: string;
}

declare const CheckBoxStatus: React__default.FC<CheckBoxStatusProps>;

type TooltipPlacement = 'top' | 'bottom' | 'left' | 'right';
type TooltipTrigger = 'hover' | 'click' | 'focus' | 'manual';
type TooltipAnimation = 'fade' | 'scale' | 'none';
type TooltipVariant = 'warning' | 'success' | 'error' | 'info';
type TooltipPointerDirection = 'left' | 'right' | 'center';
interface TooltipProps {
    /**
     * Unique identifier for the Tooltip component.
     */
    id: string;
    /**
     * Custom CSS class for styling the Tooltip.
     */
    className?: string;
    /**
     *  The text or element displayed inside the Tooltip.
     */
    content: string | ReactNode;
    /**
     *  The preferred position of the Tooltip relative to the target element.
     *  - Top: Tooltip appears above the target.
     *  - Bottom: Tooltip appears below the target.
     *  - Left: Tooltip appears to the left of the target.
     *  - Right: Tooltip appears to the right of the target.
     */
    placement?: TooltipPlacement;
    /**
     * Defines how the Tooltip is activated.
     *  - Hover (default): Tooltip appears when hovering over the target.
     *  - Click: Tooltip appears when clicking the target.
     *  - Focus: Tooltip appears when the target gains focus.
     *  - Manual: Tooltip is controlled programmatically.
     */
    trigger?: TooltipTrigger;
    /**
     * Time (in milliseconds) before the Tooltip appears/disappears after triggering.
     */
    delay?: number;
    /**
     * Whether to display an arrow pointing to the target element.
     */
    arrow?: boolean;
    /**
     *  Defines the appearance animation of the Tooltip.
     *  - Fade (default): Smooth fade-in effect.
     *  - Scale: Expands from the center.
     *  - None: No animation.
     */
    animation?: TooltipAnimation;
    /**
     * Defines the maximum width of the Tooltip content.
     */
    maxWidth?: string | number;
    /**
     * Disables the Tooltip when set to true.
     */
    disabled?: boolean;
    /**
     * Specifies the type of element wrapping the Tooltip trigger.
     */
    asChild?: 'button' | 'span' | 'div';
    /**
     * A reference to the underlying Tooltip container.
     */
    ref?: RefObject<HTMLDivElement>;
    /**
     * Controls whether the Tooltip is visible by default.
     * true: The Tooltip is visible when rendered.
     * false (default): The Tooltip follows the trigger behavior.
     */
    isVisible?: boolean;
    /**
     * If true, a close button appears inside the Tooltip, allowing manual dismissal.
     */
    closeButton?: boolean;
    /**
     * Callback function triggered when the close button is clicked.
     */
    onClose?: () => void;
    /**
     * Callback function triggered when the Tooltip becomes visible.
     */
    onShow?: () => void;
    /**
     * Callback function triggered when the Tooltip is hidden.
     */
    onHide?: () => void;
    variant?: TooltipVariant;
    pointerDirection?: TooltipPointerDirection;
}

declare const Tooltip: React__default.FC<TooltipProps & {
    children: ReactNode;
}>;

type BadgeVariant = 'solid' | 'outline' | 'ghost';
type BadgeSize = 'small' | 'medium' | 'large';
type BadgeColor = 'primary' | 'secondary' | 'danger' | 'success' | 'warning' | string;
interface BadgeProps {
    /**
     * Unique identifier for the Badge component.
     */
    id: string;
    /**
     * Custom CSS class for styling the Badge component.
     */
    className?: string;
    /**
     * Defines the visual style of the Badge.
     * Solid: A filled badge with a background color.
     * Outline: A badge with a border but no background color.
     * Ghost: A badge with a very subtle or transparent background.
     */
    variant?: BadgeVariant;
    /**
     *  Defines the size of the Badge.
     *  @Default medium
     */
    size?: BadgeSize;
    /**
     * Defines the color of the Badge.
     * @Default primary
     */
    color?: BadgeColor;
    /**
     * The text or content displayed inside the Badge.
     */
    text: string | ReactNode;
    /**
     * If true, the Badge will have rounded edges (pill-shaped).
     */
    pill?: boolean;
    /**
     * If true, the Badge will display an icon in addition to the text.
     */
    icon?: boolean;
    /**
     * If true, the Badge will be circular.
     */
    circular?: boolean;
    /**
     * Defines the icon to be displayed inside the Badge. The value can be an icon component or any ReactNode
     */
    iconValue?: ReactNode;
    /**
     *  Content for the tooltip displayed when the Badge is hovered over (optional).
     */
    tooltipContent?: string | ReactNode;
    textClassName?: string;
}

declare const Badge: React__default.FC<BadgeProps>;

type CountryFlagSize = 'small' | 'medium' | 'large' | number;
interface CountryFlagProps {
    /**
     * id?: string – Unique identifier for the CountryFlag component.
     */
    id?: string;
    /**
     * Custom CSS class for styling the CountryFlag component.
     */
    className?: string;
    /**
     * The two-letter country code used to fetch and display the flag.
     */
    countryCode: string;
    /**
     * Defines the flag’s size:
     * @default medium
     */
    size?: CountryFlagSize;
    /**
     * Custom alternative text for accessibility.
     * @Defaults to "Flag of [country]".
     */
    altText?: string;
    /**
     * RefObject<HTMLImageElement> – A reference to the underlying image element.
     */
    ref?: RefObject<HTMLImageElement>;
    rounded?: boolean;
    shadow?: boolean;
}

declare const CountryFlag: React__default.FC<CountryFlagProps>;

type TextAreaSize = 'small' | 'default' | 'large';
type TextAreaStatus = 'warning' | 'error' | 'none';
type TextAreaResize = 'none' | 'vertical' | 'horizontal' | 'both';
type TooltipPosition = 'left' | 'right' | 'bottom' | 'top' | 'mouse';
interface TextAreaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'onChange' | 'suffix' | 'prefix'> {
    id: string;
    className?: string;
    placeholder?: string;
    value?: string;
    defaultValue?: string;
    size?: TextAreaSize;
    disabled?: boolean;
    readOnly?: boolean;
    required?: boolean;
    onChange: (value: string) => void;
    onFocus?: (event: FocusEvent<HTMLTextAreaElement>) => void;
    onBlur?: (event: FocusEvent<HTMLTextAreaElement>) => void;
    autoFocus?: boolean;
    allowClear?: boolean;
    maxLength?: number;
    minLength?: number;
    showCount?: boolean;
    rows?: number;
    resize?: TextAreaResize;
    prefix?: ReactNode;
    suffix?: ReactNode;
    addonBefore?: ReactNode;
    addonAfter?: ReactNode;
    status?: TextAreaStatus;
    tooltip?: string;
    tooltipOptions?: TooltipProps;
    'aria-label'?: string;
    'aria-describedby'?: string;
}

declare const TextArea: React__default.FC<TextAreaProps>;

type SelectSize = 'small' | 'medium' | 'large';
type SelectMode = 'single' | 'multiple' | 'tags';
type SelectPlacement = 'top' | 'bottom' | 'left' | 'right';
type SelectStatus = 'warning' | 'error' | 'default';
type TooltipPositions = 'top' | 'bottom' | 'left' | 'right' | 'mouse';
type TooltipTriggers = 'always' | 'click' | 'focus' | 'hover';
type TooltipPointerDirections = 'left' | 'right' | 'center';
interface ExtendedSelectTooltipProps {
    position?: TooltipPositions;
    pointerDirection?: TooltipPointerDirections;
    trigger?: TooltipTriggers;
    className?: string;
    delay?: number;
    body?: (value: string) => ReactNode;
    status?: SelectStatus;
}
interface Option {
    label: string | ReactNode;
    value: string | number;
    disabled?: boolean;
}
interface SelectProps {
    id: string;
    className?: string;
    placeholder?: string;
    value: string | number | (string | number)[] | null;
    defaultValue?: string | number;
    size?: SelectSize;
    disabled?: boolean;
    readOnly?: boolean;
    required?: boolean;
    onChange: (value: string | number | (string | number)[]) => void;
    onBlur?: (event: React__default.FocusEvent<HTMLDivElement>) => void;
    onFocus?: (event: React__default.FocusEvent<HTMLDivElement>) => void;
    autoFocus?: boolean;
    options: Option[];
    multiple?: boolean;
    mode?: SelectMode;
    allowClear?: boolean;
    searchable?: boolean;
    emptyText?: string;
    prefix?: ReactNode;
    suffix?: ReactNode;
    addonBefore?: ReactNode;
    addonAfter?: ReactNode;
    status?: SelectStatus;
    dropdownRender?: (menu: ReactNode) => ReactNode;
    dropdownClassName?: string;
    textClassName?: string;
    dropdownStyle?: CSSProperties;
    placement?: SelectPlacement;
    open?: boolean;
    onDropdownVisibleChange?: (open: boolean) => void;
    tooltip?: string;
    tooltipOptions?: ExtendedSelectTooltipProps;
    dropdownContentClassName?: string;
}
interface SelectTooltipOptions extends ExtendedSelectTooltipProps, React__default.HTMLAttributes<HTMLDivElement> {
    message: string | string[] | undefined;
    bgColor?: string;
    children: React__default.ReactNode;
}
interface SelectNativeProps {
    id?: string;
    style?: StyleProp<ViewStyle>;
    placeholder?: string;
    value?: string | number | (string | number)[] | null;
    defaultValue?: string | number | (string | number)[] | null;
    size?: SelectSize;
    disabled?: boolean;
    onChange?: (value: string | number | (string | number)[] | null) => void;
    multiple?: boolean;
    mode?: SelectMode;
    allowClear?: boolean;
    searchable?: boolean;
    emptyText?: string;
    options: Option[];
    prefix?: ReactNode;
    suffix?: ReactNode;
    addonBefore?: ReactNode;
    addonAfter?: ReactNode;
    status?: SelectStatus;
    dropdownRender?: (menu: ReactNode) => ReactNode;
    textStyle?: StyleProp<TextStyle>;
    dropdownStyle?: StyleProp<ViewStyle>;
    onDropdownVisibleChange?: (open: boolean) => void;
    textCentered?: boolean;
}

declare const Select: ({ id, className, placeholder, value, defaultValue, size, disabled, readOnly, onChange, onBlur, onFocus, autoFocus, options, multiple, mode, allowClear, searchable, emptyText, prefix, suffix, addonBefore, addonAfter, status, dropdownRender, dropdownClassName, dropdownStyle, placement, open, onDropdownVisibleChange, tooltip, tooltipOptions, textClassName, dropdownContentClassName, ...props }: SelectProps) => react_jsx_runtime.JSX.Element;

interface RadioGroupProps {
    id: string;
    className?: string;
    options: string[];
    selectedOption: string;
    onChange: (selected: string) => void;
    name?: string;
    disabled?: boolean;
    horizontal?: boolean;
    variant?: 'default' | 'primary' | 'secondary' | 'outline' | 'ghost';
    labelClassName?: string;
}
interface RadioGroupNativeProps {
    id?: string;
    style?: StyleProp<ViewStyle>;
    className?: string;
    options: string[];
    selectedOption: string;
    onChange: (selected: string) => void;
    disabled?: boolean;
    horizontal?: boolean;
    variant?: 'default' | 'primary' | 'secondary' | 'outline' | 'ghost';
    labelStyle?: StyleProp<TextStyle>;
    selectContainerStyle?: StyleProp<ViewStyle>;
    labelClassName?: string;
}

declare function RadioGroup({ id, className, options, selectedOption, onChange, name, disabled, horizontal, variant, labelClassName, }: RadioGroupProps): react_jsx_runtime.JSX.Element;

type RadioInputVariant = 'primary' | 'secondary';
interface RadioInputProps {
    id: string;
    name: string;
    value: string | number;
    label: string | React__default.ReactNode;
    checked?: boolean;
    onChange?: (e: ChangeEvent<HTMLInputElement>) => void;
    disabled?: boolean;
    className?: string;
    labelPosition?: 'left' | 'right';
    inputClassName?: string;
    labelClassName?: string;
    variant?: RadioInputVariant;
}

declare const RadioInput: React__default.ForwardRefExoticComponent<RadioInputProps & React__default.RefAttributes<HTMLInputElement>>;

type MatchStatus = 'playing' | 'upcoming';
interface MatchBoardProps {
    id: string;
    score?: string;
    minute?: number;
    matchTime?: string;
    className?: string;
    homeOpponent: string;
    awayOpponent: string;
    onClose?: () => void;
    withAggregate?: boolean;
    matchStatus: MatchStatus;
}

declare function MatchBoard({ id, score, minute, onClose, matchTime, className, matchStatus, homeOpponent, awayOpponent, }: MatchBoardProps): react_jsx_runtime.JSX.Element;

type Status = 'N' | 'U' | 'S';
interface ChainedStatusItem {
    label: string;
    status: Status;
}
declare const statusColors: Record<Status, string>;
type ChainedStatusVariant = 'circle' | 'square';
type ChainedStatusSize = 'small' | 'default' | 'large';
type ChainedStatusDirection = 'left' | 'right' | 'none';
interface ChainedStatusProps {
    id: string;
    className?: string;
    size?: ChainedStatusSize;
    items: ChainedStatusItem[];
    variant?: ChainedStatusVariant;
    direction?: ChainedStatusDirection;
}
interface ChainedStatusNativeProps extends ChainedStatusProps {
    connectorColor?: string;
}

declare function ChainedStatus({ id, items, className, size, direction, variant, }: ChainedStatusProps): react_jsx_runtime.JSX.Element;

type CardShadow = 'none' | 'small' | 'medium' | 'large';
type CardPadding = 'none' | 'small' | 'medium' | 'large';
interface CardProps extends HTMLAttributes<HTMLElement> {
    /**
     * Card id
     */
    id: string;
    /**
     * Card header component
     */
    header?: ReactNode | string;
    /**
     * Card footer component
     */
    footer?: ReactNode | string;
    /**
     * Bordered state to display card bordered style
     */
    bordered?: boolean;
    /**
     * Card width
     */
    width?: string | number;
    /**
     * Card height
     */
    height?: string | number;
    /**
     * Card shadow
     */
    shadow?: CardShadow;
    /**
     * Card padding
     */
    padding?: CardPadding;
    /**
     * The content of the button
     */
    children: ReactNode;
}

declare const Card: React__default.FC<CardProps>;

type MatchProgressVariant = 'compact' | 'default' | 'detailed';
interface MatchData {
    home: number;
    tie: number;
    away: number;
}
interface MatchProgressProps {
    id: string;
    className?: string;
    matchData: MatchData;
    variant?: MatchProgressVariant;
    homeLabel?: string;
    drawLabel?: string;
    awayLabel?: string;
}
interface MatchProgressNativeProps extends MatchProgressProps {
    style?: StyleProp<ViewStyle | TextStyle>;
}

type Category = 'Sponsor' | 'News';
interface PostProps {
    id?: string;
    title?: string;
    author?: string;
    thumbnailUrl: string;
    redirectUrl?: string;
    truncate?: boolean;
    category: Category;
    className?: string;
    timestamp?: Date;
    description: string;
    onPress?: () => void;
}
interface PostNativeProps extends PostProps {
    hasError?: boolean;
    mediaAspectRatio?: number;
    loadingAnimation?: boolean;
    showCategoryIndicator?: boolean;
}

declare const Post: FC<PostProps>;

type ListGroupVariant = 'striped' | 'bordered' | 'borderless' | 'flush';
type ListGroupDirection = 'vertical' | 'horizontal';
type ListGroupAsChild = 'span' | 'button' | 'a';
/**
 * Props for the ListGroup component.
 */
interface ListGroupProps {
    /** Unique identifier for the ListGroup component. */
    id?: string;
    /** Custom CSS class for styling the ListGroup component. */
    className?: string;
    /** Visual variant of the ListGroup component. */
    variant?: ListGroupVariant;
    /** Colors for striped variant. */
    stripedColors?: {
        even?: string;
        odd?: string;
    };
    /** Layout direction: vertical (default) or horizontal. */
    direction?: ListGroupDirection;
    /** Enables hover effect on list items if true. */
    hover?: boolean;
    /** Index of the active (highlighted) list item. */
    activeIndex?: number[] | number;
    /** Element type used for each list item: span, button, or anchor (link). */
    asChild?: ListGroupAsChild;
    /** List of elements to render (strings or React nodes). */
    items: Array<string | object | ReactNode> | ReactElement[];
    itemTemplate?: (item: PrimitiveValue$1, index?: number) => ReactNode | null | undefined;
    /** Callback triggered when an item is selected. */
    onSelect?: (index: number) => void;
    /** Callback triggered when an item is clicked. */
    onClick?: (event: React__default.MouseEvent, index: number) => void;
    /** Aria label for the ListGroup component. */
    ariaLabel?: string;
}
type PrimitiveValue$1 = string | number | boolean | undefined | React__default.ReactNode | object;

declare const ListGroup: React__default.ForwardRefExoticComponent<ListGroupProps & React__default.RefAttributes<HTMLDivElement>>;

type ProgressBarProps = {
    id: string;
    className?: string;
    value?: number;
    defaultValue?: number;
    max?: number;
    min?: number;
    size?: 'small' | 'medium' | 'large';
    color?: string;
    backgroundColor?: string;
    striped?: boolean;
    animated?: boolean;
    variant?: 'solid' | 'dashed' | 'dotted';
    showPercentage?: boolean;
    indeterminate?: boolean;
    autoFocus?: boolean;
    onClick?: (event: React__default.MouseEvent<HTMLDivElement>) => void;
    style?: React__default.CSSProperties;
    onChange?: (value: number) => void;
    direction?: 'horizontal' | 'vertical';
    minColor?: string;
    maxColor?: string;
    showLoadingLabel?: boolean;
    labelPosition?: 'inside' | 'outside';
    minLabel?: string;
    maxLabel?: string;
};

interface ScrollAreaProps {
    id?: string;
    className?: string;
    children: ReactNode | ReactNode[];
    thin?: number;
    color?: string;
    ariaLabel?: string;
}
interface ScrollAreaNativeProps {
    id?: string;
    children: ReactNode | ReactNode[];
    style?: ViewStyle;
    thin?: number;
    color?: string;
    stickyIndices?: number[];
    thumbLength?: number;
    ariaLabel?: string;
}

declare const ScrollArea: React__default.FC<ScrollAreaProps>;

type LoaderSize = 'small' | 'medium' | 'large';
type LoaderState = 'loading' | 'success' | 'error';
type LoaderPosition = 'top' | 'bottom' | 'left' | 'right';
type PercentagePosition = 'top' | 'bottom' | 'left' | 'right' | 'center';
interface LoaderProps {
    id: string;
    value?: number;
    color?: string;
    shadow?: boolean;
    size?: LoaderSize;
    className?: string;
    animated?: boolean;
    state?: LoaderState;
    indeterminate?: boolean;
    showPercentage?: boolean;
    content?: React.ReactNode;
    style?: React.CSSProperties;
    loaderPosition?: LoaderPosition;
    percentagePosition?: PercentagePosition;
}

declare const Loader: FC<LoaderProps>;

type SplitLoaderSize = 'small' | 'medium' | 'large';
interface SplitLoaderProps {
    id: string;
    text?: string;
    className?: string;
    size?: SplitLoaderSize;
    showLoaderText?: boolean;
    showLoaderShadow?: boolean;
    showLoaderBackground?: boolean;
}
interface SizeMapProps {
    loaderContainer: string;
    svgSize: number;
}

declare const SplitLoader: React__default.FC<SplitLoaderProps>;

type KeyboardLayout = 'numeric' | 'custom';
type KeySize = 'small' | 'medium' | 'large';
type KeyColorScheme = 'light' | 'dark' | 'default';
interface ITheme {
    keyLabel: string;
    keyBackground: string;
    secondaryKeysLabel: string;
    secondaryKeysBackground: string;
    incrementKeysLabel: string;
    incrementKeysBackground: string;
    borderColor: string;
}
declare const Themes: Record<KeyColorScheme, ITheme>;
interface IKeyboardProps {
    id?: string;
    value: string;
    className?: string;
    ref?: React__default.RefObject<HTMLDivElement>;
    layout?: KeyboardLayout;
    keySize?: KeySize;
    keyColorScheme?: KeyColorScheme;
    customColorScheme?: ITheme;
    columns?: number;
    rows?: number;
    showActions?: boolean;
    includeComma?: boolean;
    includeIncrements?: boolean;
    disabledKeys?: string[];
    isLoading?: boolean;
    onClear?: () => void;
    onSubmit?: () => void;
    onChange: (value: string) => void;
    onKeyPress?: (keyValue: string) => void;
}
interface IKeyboardButton {
    label: string;
}
interface IKeyboardTypeProps {
    theme: ITheme;
    rows?: number;
    keySize: string;
    columns?: number;
    includeComma?: boolean;
    disabledKeys: string[];
    includeIncrements?: boolean;
    onKeyPress: (value: string) => void;
    renderKey: (value: string) => string;
    ref?: React__default.RefObject<HTMLDivElement>;
}
interface ISkeletonLoaderProps {
    rows?: number;
    columns?: number;
    layout: KeyboardLayout;
}
declare const defaultNumericKeys: string[];
declare const incrementKeys: string[];
declare const secondaryKeys: string[];

declare const Keyboard: FC<IKeyboardProps>;

type BetStopStatus = 'Suspended' | 'Blocked' | 'RegulatoryHold' | 'TechnicalIssue' | 'redCard' | 'goal' | 'yellowCard' | 'penalty' | 'ownGoal' | 'var';
interface Bet$1 {
    id: string;
    category: string;
    match: {
        homeTeam: string;
        awayTeam: string;
    };
    value: number;
    date: string;
}
interface BetStopProps {
    bet: Bet$1;
    status: BetStopStatus;
    className?: string;
    showTooltip?: boolean;
}

declare const BetStop: React__default.FC<BetStopProps>;

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

type InputSize = 'small' | 'default' | 'large';
type InputType = 'text' | 'email' | 'number' | 'password';
type InputMode = 'decimal' | 'currency';
type InputStatus = 'warning' | 'error' | 'success' | 'default';
type InputTooltipPosition = 'left' | 'right' | 'bottom' | 'top' | 'mouse';
type InputTooltipTrigger = 'always' | 'click' | 'focus' | 'hover';
type InputTooltipPointerDirection = 'left' | 'right' | 'center';
interface InputTooltipOptions {
    position?: InputTooltipPosition;
    pointerDirection?: InputTooltipPointerDirection;
    trigger?: InputTooltipTrigger;
    className?: string;
    delay?: number;
    body?: (value: string) => React__default.ReactNode;
    status?: InputStatus;
    customBackgroundColor?: string;
}
interface InputProps {
    id: string;
    name: string;
    className?: string;
    placeholder?: string;
    floatingLabel?: boolean;
    direction?: 'ltr' | 'rtl';
    value?: string;
    defaultValue?: string;
    size?: InputSize;
    readOnly?: boolean;
    required?: boolean;
    allowClear?: boolean;
    disabled?: boolean;
    onChange: (e: React__default.ChangeEvent<HTMLInputElement>) => void;
    onFocus?: (e: React__default.FocusEvent<HTMLInputElement>) => void;
    onBlur?: (e: React__default.FocusEvent<HTMLInputElement>) => void;
    onInvalid?: (e: React__default.FormEvent<HTMLInputElement>) => void;
    autoFocus?: boolean;
    isControlled?: boolean;
    type?: InputType;
    mode?: InputMode;
    currency?: string;
    min?: string | number;
    max?: string | number;
    step?: number;
    iconRender?: boolean;
    prefix?: React__default.ReactNode;
    suffix?: React__default.ReactNode;
    addonBefore?: React__default.ReactNode;
    addonAfter?: React__default.ReactNode;
    status?: InputStatus;
    tooltip?: string | string[];
    tooltipOptions?: InputTooltipOptions;
}
interface InputTooltipProps extends InputTooltipOptions, React__default.HTMLAttributes<HTMLDivElement> {
    message: string | string[] | undefined;
    bgColor?: string;
    children: React__default.ReactNode;
}
interface InputNativeProps extends TextInputProps {
    id?: string;
    name: string;
    className?: string;
    placeholder?: string;
    placeholderStyle?: string;
    floatingLabel?: boolean;
    direction?: 'ltr' | 'rtl';
    value?: string;
    defaultValue?: string;
    readOnly?: boolean;
    required?: boolean;
    disabled?: boolean;
    size?: InputSize;
    onFocus?: (e: NativeSyntheticEvent<TextInputFocusEventData>) => void;
    onBlur?: (e: NativeSyntheticEvent<TextInputFocusEventData>) => void;
    onInvalid?: () => void;
    autoFocus?: boolean;
    type?: InputType;
    min?: string | number;
    max?: string | number;
    mode?: InputMode;
    currency?: string;
    noKeyboard?: boolean;
    clearable?: boolean;
    iconRender?: boolean;
    prefix?: React__default.ReactNode;
    suffix?: React__default.ReactNode;
    addonBefore?: React__default.ReactNode;
    addonAfter?: React__default.ReactNode;
    status?: InputStatus;
    tooltip?: string;
    tooltipOptions?: InputTooltipOptions & {
        bgColor?: string;
        style?: StyleProp<ViewStyle>;
    };
}

/**
 * Input component with advanced focus management and tooltip support.
 *
 * @component
 * @param {InputProps} props - Component props.
 * @param {React.Ref<HTMLInputElement>} ref - Forwarded ref.
 * @returns {JSX.Element} The rendered input component.
 */
declare const Input: React__default.ForwardRefExoticComponent<InputProps & React__default.RefAttributes<HTMLInputElement>>;

type SwitchSize = 'small' | 'medium' | 'large';
type SwitchColor = 'primary' | 'secondary' | 'custom';
interface SwitchProps {
    id: string;
    name?: string;
    value?: string | number;
    defaultValue?: string | number;
    checked: boolean;
    onChange: (event: ChangeEvent<HTMLInputElement>) => void;
    onClick?: (event: MouseEvent<HTMLInputElement>) => void;
    disabled?: boolean;
    size?: SwitchSize;
    color?: SwitchColor;
    autoFocus?: boolean;
    className?: string;
    label?: {
        on: string;
        off: string;
    };
    ellipsis?: boolean;
    accessibilityLabel?: string;
    accessibilityHint?: string;
}
interface SwitchNativeProps {
    id?: string;
    checked: boolean;
    onValueChange: (value: boolean) => void;
    disabled?: boolean;
    size?: SwitchSize;
    color?: SwitchColor;
    label?: {
        on: string;
        off: string;
    };
    ellipsis?: boolean;
    accessibilityLabel?: string;
    accessibilityHint?: string;
}

declare const Switch: React__default.FC<SwitchProps>;

interface StepItem {
    label: string;
    status?: 'error';
}
interface StepperProps {
    id: string;
    className?: string;
    steps: StepItem[];
    currentStep: number;
    onStepChange?: (newStep: number) => void;
    readonly?: boolean;
    header?: string | ReactNode;
    extraSpacing?: boolean;
    errorColor?: string;
    activeColor?: string;
    completedColor?: string;
    stepSize?: 'small' | 'medium' | 'large';
    forceErrorTest?: boolean;
}

declare const Stepper: React__default.FC<StepperProps>;

type InfoBoxVariant = 'success' | 'error' | 'warning' | 'info' | 'primary' | 'secondary' | 'custom';
type InfoBoxDirection = 'horizontal' | 'vertical';
interface InfoBoxProps {
    id: string;
    title?: string;
    classNames?: string;
    variant?: InfoBoxVariant;
    description?: string | ReactNode;
    icon?: ReactNode;
    isClosable?: boolean;
    autoClose?: number;
    onClose?: () => void;
    direction?: InfoBoxDirection;
    isClose?: boolean;
    titleClassName?: string;
    titleContainerClassName?: string;
}

declare const InfoBox: React__default.FC<InfoBoxProps>;

type NavMenuVariant = 'primary' | 'secondary' | 'outlined' | 'text';
type NavMenuDirection = 'vertical' | 'horizontal';
type NavMenuItemIconPosition = 'left' | 'right' | 'top' | 'bottom';
interface NavMenuProps {
    /**
     * Unique identifier for the NavMenu component.
     */
    id: string;
    /**
     * Custom CSS class for styling the NavMenu component.
     */
    className?: string;
    /**
     * Custom CSS class for styling individual nav items.
     */
    navClassName?: string;
    /**
     * Defines the visual styling of the NavMenu component.
     */
    variant?: NavMenuVariant;
    /**
     * Defines the layout direction of the NavMenu.
     * @default Vertical
     */
    direction?: NavMenuDirection;
    /**
     * The index or identifier of the currently active item. Used to highlight the active item.
     */
    activeIndex?: number | string;
    /**
     * If true, disables the menu, making all items un-clickable.
     */
    disabled?: boolean;
    /**
     * A reference to the underlying element.
     */
    ref?: React__default.Ref<HTMLDivElement>;
    items: NavMenuItemProps[];
}
interface NavMenuItemProps {
    /**
     * Text displayed on the NavMenu item.
     */
    label: string;
    /**
     * URL to navigate to (only used if the item is a link).
     */
    href?: string;
    /**
     * Optional icon to display alongside the label.
     */
    icon?: React__default.ReactNode;
    /**
     * Defines the position of the icon relative to the label.
     * @default Right
     */
    iconPosition?: NavMenuItemIconPosition;
    /**
     * Optional callback function for when the item is clicked
     */
    onClick?: () => void;
    /**
     * Custom class for styling individual list items.
     */
    className?: string;
    /**
     * Optional body to display in the NavMenu.
     */
    body?: (item: NavMenuItemProps, index: number, isActive?: boolean) => React__default.ReactNode;
    /**
     * Optional badge to display alongside the label.
     */
    badge?: string | number;
}

declare const NavMenu: React__default.FC<NavMenuProps>;

type DrawerPlacement = 'left' | 'right' | 'top' | 'bottom';
type DrawerSize = 'small' | 'medium' | 'large' | 'full-screen';
type DrawerVariant = 'default' | string;
type DrawerDirection = 'horizontal' | 'vertical';
interface DrawerProps {
    id: string;
    className?: string;
    isOpen: boolean;
    onClose?: () => void;
    stickyHeader?: boolean;
    title?: string | ReactNode;
    header?: string | ReactNode;
    content?: string | ReactNode;
    footer?: string | ReactNode;
    placement?: DrawerPlacement;
    size?: DrawerSize;
    width?: string | number;
    height?: string | number;
    isClosable?: boolean;
    hasBackdrop?: boolean;
    disableCloseOnClickOutside?: boolean;
    autoClose?: number;
    variant?: DrawerVariant;
    direction?: DrawerDirection;
    indicator?: boolean;
    headerClassName?: string;
}

declare const Drawer: React__default.FC<DrawerProps>;

interface CheckListProps {
    id?: string;
    className?: string;
    containerClassName?: string;
    badgeLabelClassName?: string;
    descClassName?: string;
    variant?: 'default' | 'striped' | 'bordered';
    display?: 'grid' | 'flex' | 'list';
    columns?: number;
    hover?: boolean;
    activeIndex?: number | string;
    selectAllLabel?: string;
    checkType?: 'checkbox' | 'badge';
    asChild?: 'button' | 'div';
    ref?: RefObject<HTMLDivElement>;
    children: ReactNode;
    ariaLabel?: string;
}
interface CheckListItemProps {
    label: string | ReactNode;
    iconValue?: string;
    desc?: string | ReactNode;
    checked?: boolean;
    disabled?: boolean;
    className?: string;
    containerClass?: string;
}

declare const CheckList: {
    ({ id, className, containerClassName, badgeLabelClassName, descClassName, variant, display, columns, hover, activeIndex, selectAllLabel, checkType, children, ref, ariaLabel, }: CheckListProps): react_jsx_runtime.JSX.Element | null;
    Item: React__default.FC<CheckListItemProps>;
};

type DialogBoxSize = 'small' | 'medium' | 'large';
type DialogBoxPadding = 'none' | 'small' | 'default' | 'large';
type DialogBoxVariant = 'default' | 'warning' | 'error' | 'success' | 'info';
interface DialogBoxProps {
    id: string;
    isOpen: boolean;
    className?: string;
    contentClassName?: string;
    title?: string;
    message: string | ReactNode;
    variant?: DialogBoxVariant;
    size?: DialogBoxSize;
    closable?: boolean;
    onClose: () => void;
    onConfirm?: () => void;
    onCancel?: () => void;
    confirmButtonLabel?: string;
    cancelButtonLabel?: string;
    showCloseIcon?: boolean;
    autoFocus?: boolean;
    padding?: DialogBoxPadding;
    backdropClickClose?: boolean;
    escKeyClose?: boolean;
    titleIcon?: ReactNode;
    headerTemplate?: ReactNode;
    showFooter?: boolean;
    footerTemplateOutside?: ReactNode;
    footerTemplate?: ReactNode;
    headerClassName?: string;
    footerClassName?: string;
}

declare const DialogBox: FC<DialogBoxProps>;

type TableSelectMode = 'single' | 'multiple';

interface TableProps {
    id: string;
    className?: string;
    headerClassName?: string;
    colClassName?: string;
    rowClassName?: string;
    variant?: 'default' | 'striped' | 'bordered' | 'borderless' | 'compact';
    hover?: boolean;
    shadowOnHover?: 'none' | 'small' | 'medium' | 'large';
    pagination?: boolean;
    pageSize?: number;
    stickyHeader?: boolean;
    stickyColumn?: boolean;
    stickyColumnDir?: 'left' | 'right';
    size?: 'small' | 'medium' | 'large' | 'xs';
    columns: ColumnProps[];
    data: RowData[];
    selectable?: boolean;
    selectMode?: TableSelectMode;
    width?: string;
    height?: string;
    onSelectRow?: (selectedRows: (string | number)[]) => void;
    onDeselectRow?: (deselectedRows: (string | number)[]) => void;
    onRowClick?: (rowData: PrimitiveValue | object) => void;
    emptyMessage?: string;
    headerIndex?: number;
    expandableHeader?: boolean;
    caption?: string | React__default.ReactNode | (() => React__default.ReactNode);
    headerTemplate?: string | React__default.ReactNode | (() => React__default.ReactNode);
    footerTemplate?: React__default.ReactNode | (() => React__default.ReactNode);
    selectedRowId?: string | number | null;
    highlightRowBorder?: boolean;
}
interface ColumnProps {
    key: string;
    title: string | React__default.ReactNode;
    dataIndex: string;
    colSpan?: number;
    rowSpan?: number;
    width?: string;
    fixed?: 'left' | 'right';
    onCell?: (rowData: RowData, rowIndex: number) => {
        colSpan?: number;
        rowSpan?: number;
        [key: string]: PrimitiveValue;
    };
    render?: (value: PrimitiveValue, rowIndex?: number | string) => React__default.ReactNode;
    className?: string;
    cellClassName?: string;
}
interface RowData {
    [key: string]: PrimitiveValue;
}
type PrimitiveValue = string | number | boolean | undefined | ReactNode;

type TableSize = 'small' | 'medium' | 'large' | 'xs';

interface EvenDataTableProps {
    data: Root[];
    favorite?: boolean;
    topAlarm?: boolean;
    searchable?: boolean;
    sortable?: boolean;
    toggleHead?: boolean;
    filterable?: boolean;
    showLoading?: boolean;
    isLoading?: boolean;
    className?: string;
    showTableHeader?: boolean;
    tableSize?: TableSize;
    onRowClick?: (id: string) => void;
    onFilterSelect?: (value: string) => void;
    handleOnSettingsClose?: () => void;
    handleOnSettingOpen?: () => void;
    showCategoryFilter?: boolean;
    showMarketFilter?: boolean;
    initialCategoryFilter?: MatchTypes;
    tableId?: string;
    showSettingsIcon?: boolean;
    showBottomSheetFilter?: boolean;
}
interface Root {
    category: MatchTypes;
    competition: string;
    matches: Match[];
    id?: string;
}
type BetType = Tipp | OverUnder | Handicap | BothTeamsToScore | DoubleChance | RestOfMatch | Set | SetHandicap | Leg;
type Tipp = Record<'type' | '1' | 'X' | '2', number | string>;
type OverUnder = Record<'type' | 'point' | '+' | '-', number | string>;
type Handicap = Record<'type' | 'totalScore' | '1' | 'X' | '2', number | string>;
type DoubleChance = Record<'type' | '1/X' | '1/2' | 'X/2', number | string>;
type RestOfMatch = Record<'type' | '1' | 'X' | '2', number | string>;
type BothTeamsToScore = Record<'type' | 'Ja' | 'Nein', number | string>;
type Set = Record<'type' | '1' | '2', number | string>;
type SetHandicap = Record<'type' | '1' | '2', number | string>;
type Leg = Record<'type' | '+' | '-', number | string>;

declare const EventDataTable: React__default.FC<EvenDataTableProps>;

declare function EventDetailDrawer({ isMobile }: {
    isMobile: boolean;
}): react_jsx_runtime.JSX.Element;

type MatchTypes = 'All' | 'Fußball' | 'Basketball' | 'Volleyball' | 'Tennis' | 'Handball' | 'TableTennis' | 'American Football' | 'IceHockey';
type BetStatus = 'Green' | 'Red';
type OddChange = {
    status: BetStatus;
    index: number;
};
type MatchScore = {
    sets?: number[];
    games?: number[];
    points?: number[];
};
interface Match {
    id: string;
    team: string;
    teamRedCard?: number;
    teamYellowCard?: number;
    opponent: string;
    opponentRedCard?: number;
    opponentYellowCard?: number;
    date?: string;
    time?: string;
    betType: BetType[];
    score: string[] | null;
    showGraph?: boolean;
    onGoing?: boolean;
    matchScores?: MatchScore;
    sessions?: string;
    isBetStop?: boolean;
    betStop?: BetStopProps;
    betStatus?: OddChange[];
}

interface CountryItemProps {
    id: string | number;
    name: string;
    iso: string;
    league: string | string[] | object[];
    groups?: string[] | object[];
    date?: Date | string | number;
    [key: string]: string | string[] | CountryItemProps[] | number | undefined | object[] | Date;
}

type AccountType = 'online' | 'shop';
interface Wallet {
    _id: string;
    userId: string;
    type: AccountType;
    currency: string;
    realMoneyBalance: number;
    customerCardBalance: number;
    bonusBalance: number;
    isActive: boolean;
    isDefault: boolean;
    isPaymentAllowed: boolean;
    isCashoutAllowed: boolean;
    isBettingAllowed: boolean;
    createdAt: string;
    updatedAt: string;
    __v: number;
    summaryToApproveId: string | SummaryToApproveId;
    totalBalance: number;
    id: string;
}
interface SummaryToApproveId {
    _id: string;
    walletId: string;
    creationDate: string;
    approvedByUser: boolean;
    sumDeposits: number;
    sumWithdrawals: number;
    sumBetStake: number;
    sumBetWin: number;
    netBetResult: number;
    periodStart: string;
    periodEnd: string;
    transactionIds: string[];
    transactionCount: number;
    summaryType: string;
    isFinalized: boolean;
    createdAt: string;
    updatedAt: string;
    __v: number;
}

type TimeFilter = 'ALL' | '24H' | '3H';
interface HomeCategoryWidgetProps {
    favorites?: Array<CountryItemProps>;
    highlights?: Array<CountryItemProps>;
    categories?: Array<CountryItemProps>;
    matchCategories?: Array<MatchTypes>;
    loading?: boolean;
    error?: string;
    className?: string;
    onSelectLeague?: (country: CountryItemProps) => void;
    onLongTimeBet?: (country?: CountryItemProps) => void;
    onToggleFavorite?: (country: CountryItemProps, isNowFavorite: boolean) => void;
    activeMatchCategory?: MatchTypes | undefined;
    onSelectMatchCategory?: (type: MatchTypes | undefined) => void;
    timeFilter?: TimeFilter;
    onTimeFilterChange?: (filter: TimeFilter) => void;
    handleOnAllSportsPress?: () => void;
    handleOnAllLongTimeBet?: () => void;
}

type Bet = {
    betId: string;
    category: string;
    odd: number;
    winCondition: string;
    isValid: boolean;
    hasOddChanged?: 'up' | 'down';
    isBetLocked?: boolean;
};
type Bets = {
    id: string;
    homeTeam: string;
    awayTeam: string;
    date: Date;
    time: string;
    type: 'non-bank' | 'bank';
    bets: Bet[];
};
type ValidationState = {
    isBetValid: boolean;
    isMoneySufficient: boolean;
    isTimeValid: boolean;
};
type ProcessingResult = {
    isSuccess: boolean;
    isError: boolean;
    errorMessage: string;
};
interface IBetslipsActions {
    setSingleStake: (singleStake: string) => void;
    setSingleTotalStake: (singleTotalStake: string) => void;
    setMultiStake: (multiStake: string) => void;
    setMultiTotalStake: (multiTotalStake: string) => void;
    setSingleStakeCount: (singleStakeCount: number) => void;
    setMultiStakeCount: (multiStakeCount: number) => void;
    setSystemStake: (systemStake: string) => void;
    setSystemTotalStake: (systemTotalStake: string) => void;
    setSelectedSystem: (selectedSystem: Record<number, {
        idx: number;
        systemBetCount: number;
    }>) => void;
    setSystemStakeCount: (systemStakeCount: number) => void;
    resetSelectedSystem: () => void;
    setActiveTab: (activeTab: number) => void;
}
interface BetslipState {
    singleStake: string;
    singleTotalStake: string;
    multiStake: string;
    multiTotalStake: string;
    singleStakeCount: number;
    multiStakeCount: number;
    systemStake: string;
    systemTotalStake: string;
    selectedSystem: Record<number, {
        idx: number;
        systemBetCount: number;
    }>;
    systemStakeCount: number;
    activeTab: number;
    isSingleTabOpen: boolean;
    isMultiTabOpen: boolean;
    isSystemTabOpen: boolean;
}
interface IStakeCalculations {
    calculateSingleStakeCount: (bets: Bets[]) => number;
    calculateMultiStakeCount: (bets: Bets[]) => number;
}
interface IBetSlipProcessingActions {
    handleConfirm: () => void;
    handleConfirmToProcessing: (onClick: () => void) => void;
    handleCancel: () => void;
}
type WalletOptionsConfig = {
    type: 'select' | 'banner';
    onSelect?: (value: string) => void;
    shouldShow: boolean;
};

type ErrorMessageColor = 'white' | 'red' | 'accent';
interface IOdds {
    label: '1' | 'X' | '2';
    value: number;
}
interface ITopStoryItem {
    id?: string;
    date: string;
    time: string;
    teams: {
        home: string;
        away: string;
    };
    odds: IOdds[];
}
interface TopStoriesWidgetProps {
    data: ITopStoryItem[];
    errorMessage?: string;
    background?: React.ReactNode;
    selectedOdds?: Record<string, string>;
    className?: string | React.CSSProperties;
    errorMessageColor?: ErrorMessageColor;
    onOddSelect?: (matchId: string, oddLabel: string) => void;
    activateError?: boolean;
    activateLoading?: boolean;
}
interface NativeTopStoriesProps extends Omit<TopStoriesWidgetProps, 'className'> {
    className?: string;
    enableAnimation?: boolean;
    useFullDeviceWidth?: boolean;
}
interface TopStoryProps {
    data: ITopStoryItem;
    onOddSelect?: (matchId: string, oddLabel: string) => void;
}
interface NativeTopStoryProps extends TopStoryProps {
    enableAnimation: boolean;
}

declare const TopStories: React__default.FC<TopStoriesWidgetProps>;

declare const Table: React__default.FC<TableProps>;

declare const FilterOptions: string[];
interface LeagueStatisticsProps {
    error?: string;
    showChainedStatus?: boolean;
    skeletonLoaderRowCount?: number;
    data: LeagueStatisticsTableItem[];
}
interface LeagueStatisticsTableItem extends RowData {
    id: number;
    Team: string;
    Form: string;
    Sp: number;
    G: number;
    U: number;
    V: number;
    Tore: string;
    Pkt: number;
}
interface StatisticsSkeletonLoaderProps {
    rows: number;
    columns?: number;
}

declare const LeagueStatistics: React__default.FC<LeagueStatisticsProps>;

type DescriptionIcon = 'gift' | 'other';
type TransactionType = 'Einzahlungen' | 'Auszahlungen' | 'Wettgewinn' | 'Gesamteinsatz';
type IconVariant = 'increase' | 'decrease' | 'gift' | 'cashout' | 'betting' | 'debit' | 'credit';
interface SummaryItem {
    transaction: TransactionType;
    amount: number;
}
interface AccountSummaryProps {
    isOpen: boolean;
    account: AccountProps;
    className?: string;
    onClose: () => void;
    onBackdropClickClose?: boolean;
    openAnimation?: ModalProps['animationType'];
}
interface TransactionEntry {
    id: string;
    icon: IconVariant;
    time: string;
    type: 'debit' | 'credit';
    amount: number;
    description: string;
    descriptionIcon?: DescriptionIcon;
    additionalInfo?: string;
}
interface TransactionHistory {
    date: string;
    transactions: TransactionEntry[];
}

declare const AccountSummary: FC<AccountSummaryProps>;

type LegacyCashoutItem = Omit<CashoutItem, 'matches'> & {
    match: {
        homeTeam: string;
        awayTeam: string;
        event?: string;
        date?: string;
    };
};
interface CashoutProps {
    /**
     * Unique identifier for the component
     */
    id?: string;
    /**
     * List of cashout items to display
     */
    cashouts: CashoutItem[];
    /**
     * Function triggered when a user clicks on a cashout button
     */
    onCashout?: (id: string) => void;
    /**
     * Additional CSS class for styling
     */
    className?: string;
    isLoading?: boolean;
}

interface CashoutItemDetailsProps {
    item: CashoutItem;
    backgroundColor: string;
    confirmOpen: boolean;
    countdown: number | null;
    cancelHover: boolean;
    showInput: boolean;
    inputValue: string;
    onStartCountdown: () => void;
    onCancelCountdown: () => void;
    onToggleInput: () => void;
    onInputChange: (value: string) => void;
    onSubmitInput: () => void;
}
interface CashoutItemLabelProps {
    item: CashoutItem;
    index: number;
    pinned: boolean;
    onTogglePin: (itemId: string, e: React.MouseEvent | React.KeyboardEvent) => void;
    onCashout?: (id: string) => void;
}
interface CashoutItemLabelPropsNative {
    item: CashoutItem;
    index: number | string;
    pinned: boolean;
    onTogglePin: (itemId: string, e: GestureResponderEvent) => void;
    onCashout?: (id: string) => void;
}
type CashoutItem = {
    id?: string;
    betType: 'Einzel' | 'Kombi' | 'System';
    amount: number;
    tipAmount?: number;
    chanceOfWinning: number;
    walletType: 'Bonus' | 'RealMoney';
    description?: string;
    matches: {
        homeTeam: string;
        awayTeam: string;
        event?: string;
        date?: string;
    }[];
    cashoutAmount: number;
    status: 'Pending' | 'Available' | 'Processed' | 'Failed' | 'PartiallyProcessed';
    isLocked?: boolean;
    isLive?: boolean;
    isPinned?: boolean;
};
interface MatchInfo {
    homeTeam: string;
    awayTeam: string;
    tipAmount?: number;
    isLocked?: boolean;
}
interface ScoreboardProps {
    matches: MatchInfo[];
}
type CashoutItemComponentProps = {
    id: string;
    item: CashoutItem;
    onCashout?: (id: string) => void;
    onTogglePin: (itemId: string, e?: GestureResponderEvent) => void;
    pinned: boolean;
    onStatusMessage?: (id: string, status: CashoutItem['status'], isLocked?: boolean) => void;
};

type MessageType = {
    id: string;
    content: string | ReactNode;
    sender: 'user' | 'bot' | 'system';
    timestamp?: string;
    avatar?: string;
    status?: 'sent' | 'delivered' | 'read';
};
type ChatboxProps = {
    id?: string;
    className?: string;
    messages: MessageType[];
    headerTemplate?: ReactNode;
    footerTemplate?: ReactNode;
    headerClassName?: string;
    footerClassName?: string;
    inputPlaceholder?: string;
    sendButtonLabel?: string | ReactNode;
    showTypingIndicator?: boolean;
    isVisible?: boolean;
    closeButton?: boolean;
    onSendMessage?: (message: string) => void;
    onReceiveMessage?: (message: MessageType) => void;
    onShow?: () => void;
    onHide?: () => void;
    enableEmojis?: boolean;
    enableAttachments?: boolean;
    attachmentTypes?: string[];
    messageVariant?: 'bubble' | 'card';
    asChild?: 'div' | 'section' | 'article';
    showHeader?: boolean;
    showFooter?: boolean;
    showAvatar?: boolean;
    mobileTopOffset?: number | string;
    mobileBottomOffset?: number | string;
};

declare const Chatbox: React__default.FC<ChatboxProps>;

type BetPackerTableData = {
    id: string;
    name: string;
    odds: {
        type: '1' | 'X' | '2' | '+' | '-' | '1X' | '12' | 'X2' | '1X2';
        value: number;
        isLocked?: boolean;
    }[];
};
type BetPackerOddButtonProps = {
    type: string;
    value: number;
    isLocked: boolean;
    selectBet: (isSelected: boolean, value: number, id: string) => void;
};
type BetPackerTableProps = {
    data: BetPackerTableData[];
    isLoading?: boolean;
};

type LongTermBetEventType = 'Tournament' | 'League' | 'Championship' | string;
type LongTermBetStatus = 'Open' | 'Closed' | 'Processed' | 'Failed';
type LongTermBetSports = MatchTypes;
interface LongTermBetItem {
    id: string;
    eventType: LongTermBetEventType;
    participant: string;
    odds: number;
    description: string;
    status: LongTermBetStatus;
    eventDetails: {
        name: string;
        startDate: string;
        endDate: string;
    };
}
interface LongTermBetProps {
    bets: LongTermBetItem[];
    sports?: LongTermBetSports;
    onPlaceBet?: (id: string) => void;
    onLeaguePress?: (id: string) => void;
    drawerClassName?: string;
}
interface LongTermBetDrawerProps {
    bets: LongTermBetItem[];
    hasActiveBets: (id: string) => boolean;
    handlePlaceBet: (id: string, setActive: boolean) => void;
}
interface LongTermBetDrawerNativeProps {
    bets: LongTermBetItem[];
}

declare const LongTermBet: React__default.FC<LongTermBetProps>;

type ToastDuration = 'short' | 'long';
type ToastVariant = 'success' | 'error' | 'warning' | 'info';
interface ToastVariantProps {
    icon: ReactNode;
    textColor: string;
    iconBackground: string;
    backgroundColor: string;
    toastContentColor: string;
}
interface ToastProps {
    title?: string;
    message: string;
    variant: ToastVariant;
    duration?: ToastDuration;
    onClose?: () => void;
}
interface ToastInternal extends ToastProps {
    toastUUID: string;
}
interface ToastContextType {
    showToast: (toast: Omit<ToastProps, 'id'>) => void;
}

interface AccountHeaderProps {
    iconColor?: string;
    accountType: AccountType;
    showActivateButton?: boolean;
    accountDescription?: string | undefined;
}
interface AccountBodyProps {
    total: string;
    actual: string;
    bonus: string;
    customerCard: string | undefined;
    canDeposit: boolean;
    onDeposit?: () => void;
    iconColor?: string;
}
interface AccountFooterProps {
    canCashOut: boolean;
    canPlaceBet: boolean;
    canWithdrawDeposit: boolean;
}
interface FooterItemProps {
    label: string;
    isActive: boolean;
}
interface AccountWallet extends Wallet {
    accountDescription?: string;
}
interface AccountProps extends HTMLAttributes<HTMLDivElement> {
    id: string;
    className?: string;
    ref?: RefObject<HTMLDivElement>;
    showFooter?: boolean;
    showHoverShadow?: boolean;
    showDepositButton?: boolean;
    showActivateButton?: boolean;
    showDefaultHighlighting?: boolean;
    showActivateButtonFullText?: boolean;
    wallet: AccountWallet;
    onDeposit?: () => void;
    onAccountClick?: (id: string) => void;
    onWalletActivate?: (id: string) => void;
}

declare const Account: FC<AccountProps>;

type AccordionContextType = {
    activeKeys: number[];
    toggleItem: (index: number) => void;
    multiple: boolean;
};
type AccordionVariant = 'primary' | 'secondary' | 'none';
type HorizontalDirection = 'left' | 'right';
type VerticalDirection = 'top' | 'bottom';
type AccordionHeaderPosition = HorizontalDirection | VerticalDirection;
/**
 * General Accordion props.
 */
type AccordionProps = {
    id: string;
    className?: string;
    headerClassName?: string;
    children: ReactElement<AccordionItemProps> | ReactElement<AccordionItemProps>[];
    defaultActiveKey?: number | number[];
    multiple?: boolean;
    variant?: AccordionVariant;
    onChange?: (activeKeys: number[]) => void;
};
/**
 * Accordion Item props, combining header, card, and icon properties.
 */
type AccordionItemProps = {
    itemIndex?: number;
    label?: string | ReactNode | ReactElement<AccordionHeaderProps> | null;
    disabled?: boolean;
    headerPosition?: 'top' | 'bottom' | 'left' | 'right';
    header?: ReactNode | string;
    footer?: ReactNode | string;
    padding?: 'none' | 'small' | 'medium' | 'large';
    bordered?: boolean;
    shadow?: 'none' | 'small' | 'medium' | 'large';
    icon?: ReactNode | ReactElement<AccordionIconProps> | null;
    activeIcon?: ReactNode | ReactElement<AccordionIconProps> | null;
    iconPosition?: 'left' | 'right' | 'top' | 'bottom' | 'center';
    headerClassName?: string;
};
type AccordionHeaderProps = {
    label?: string | ReactNode | ReactElement<AccordionHeaderProps> | null;
    onClick: (index: number) => void;
    disabled?: boolean;
    headerPosition?: AccordionHeaderPosition;
    ref?: RefObject<HTMLButtonElement>;
};
type AccordionCardProps = {
    header?: ReactNode | string;
    body?: ReactNode | string;
    footer?: ReactNode | string;
    padding?: 'none' | 'small' | 'medium' | 'large';
    bordered?: boolean;
    shadow?: 'none' | 'small' | 'medium' | 'large';
    ref?: RefObject<HTMLDivElement>;
};
type AccordionIconProps = {
    icon?: ReactNode;
    activeIcon?: ReactNode;
    iconPosition?: 'left' | 'right' | 'top' | 'bottom' | 'center';
};
type AccordionNativeVariant = AccordionVariant | 'stripped';
interface AccordionNativeProps extends AccordionIconProps {
    variant?: AccordionNativeVariant;
    multiple?: boolean;
    headerClassName?: string;
    defaultOpenIndex?: number;
    headerPosition?: AccordionHeaderPosition;
    flush?: boolean;
    disabled?: boolean;
    onChange?: (openItems: string[]) => void;
    items: {
        label: string | ReactNode;
        header?: ReactNode | string;
        content: ReactNode | string;
        footer?: ReactNode | string;
        className?: string;
    }[];
}

interface AccordionContextTypeWithAdditions extends AccordionContextType {
    variant: 'primary' | 'secondary' | 'none';
}
declare const AccordionContext: React__default.Context<AccordionContextTypeWithAdditions | undefined>;
declare const Accordion: React__default.ForwardRefExoticComponent<AccordionProps & React__default.RefAttributes<HTMLDivElement>>;
declare const AccordionItem: React__default.ForwardRefExoticComponent<AccordionItemProps & {
    children: React__default.ReactNode;
} & React__default.RefAttributes<HTMLDivElement>>;

interface Tab {
    accessibilityHint?: string;
    label: string;
    content?: ReactNode;
    header?: ReactNode | string;
    body?: ReactNode | string;
    bodyClassName?: string;
    footer?: ReactNode | string;
    disabled?: boolean;
    buttonRef?: RefObject<TouchableOpacity> | RefObject<HTMLButtonElement>;
    cardRef?: RefObject<View> | RefObject<HTMLDivElement>;
}
interface TabsProps {
    testID?: string;
    id: string;
    style?: StyleProp<ViewStyle>;
    tabLabelStyle?: string;
    className?: string;
    tabs: Tab[];
    activeTab?: number;
    onTabChange?: (index: number) => void;
    onTabStatusChange?: (newIndex: number, oldIndex: number) => void;
    tabPosition?: 'top' | 'bottom' | 'left' | 'right';
    variant?: 'primary' | 'secondary';
    padding?: 'none' | 'small' | 'medium' | 'large';
    bordered?: boolean;
    shadow?: 'none' | 'small' | 'medium' | 'large';
    accessibilityHint?: string;
}
interface TabsRef {
    scrollToActiveTab: () => void;
}

declare const Tabs: React$1.ForwardRefExoticComponent<TabsProps & React$1.RefAttributes<TabsRef>>;

interface LimitDepositProps {
    id: string;
    className?: string;
    minValue?: number;
    maxValue?: number;
    initialValue?: number;
    description?: React__default.ReactNode | string;
    showButtons?: boolean;
    saving?: boolean;
    currency?: string;
    radioInputProps?: {
        value?: string;
        label?: string;
        name?: string;
        labelPosition?: 'left' | 'right';
        id?: string;
        variant?: 'primary' | 'secondary';
        className?: string;
        checked?: boolean;
    };
    onRadioClick?: (value: string) => void;
    onLimitSave?: (limit: number) => void;
    onCancel?: () => void;
    tooltipErrorMessage?: {
        max: string;
        min: string;
    } | string;
    onInputFocus?: () => void;
    onInputValueChange?: (value: number) => void;
    onSaveFeedback?: string;
}
type LimitDepositNativeProps = LimitDepositProps;

declare const LimitDeposit: React__default.ForwardRefExoticComponent<LimitDepositProps & React__default.RefAttributes<HTMLDivElement>>;

type SearchWidgetProps = {
    id?: string;
    value: string;
    placeholder?: string;
    onChange?: (value: string) => void;
    onSubmit?: (value: string) => void;
    onClear?: () => void;
    disabled?: boolean;
    showClearButton?: boolean;
    className?: string;
    inputClassName?: string;
    submitButtonIcon?: ReactNode;
    clearButtonIcon?: ReactNode;
    label?: string;
};

declare const SearchWidget: React__default.ForwardRefExoticComponent<SearchWidgetProps & React__default.RefAttributes<HTMLInputElement>>;
declare const CustomSearchWidget: React__default.ForwardRefExoticComponent<SearchWidgetProps & React__default.RefAttributes<HTMLInputElement>>;

declare const useToast: () => src.ToastContextType;

declare const Toast: ({ title, message, variant, duration, onClose }: ToastProps) => react_jsx_runtime.JSX.Element;

declare const ToastContext: React$1.Context<ToastContextType>;
declare const ToastProvider: ({ children }: {
    children: ReactNode;
}) => react_jsx_runtime.JSX.Element;

type NavBarVariant = 'primary' | 'secondary' | 'transparent';
type NavBarPosition = 'fixed' | 'absolute' | 'sticky' | 'relative';
interface NavBarProps extends HTMLAttributes<HTMLDivElement> {
    id: string;
    variant?: NavBarVariant;
    position?: NavBarPosition;
    shadowOnScroll?: boolean;
    ref?: RefObject<HTMLDivElement>;
}

declare const NavBar: React__default.FC<NavBarProps>;

type MatchRow = {
    team: string;
    match: string;
    odds1: string;
    odds2: string;
};
interface OddsDataItem {
    comboLabel: string;
    stakeLabel: string;
    brand: string;
    potentialWin: string;
    competitorWin: string;
    rows: MatchRow[];
}
interface OddsComparisonSliderProps {
    oddsData: OddsDataItem[];
    onAddToBettingSlip?: (item: OddsDataItem) => void;
    onClose?: () => void;
    title?: string;
    isLoading?: boolean;
}
declare function OddsComparisonSlider({ oddsData, onAddToBettingSlip, onClose, title, isLoading, }: OddsComparisonSliderProps): JSX.Element;

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

declare const Cookies: React__default.FC;

interface CookiesProps {
    isOpen: boolean;
    onClose: () => void;
    onSave: () => void;
    onReject: () => void;
    onAcceptAll: () => void;
}

declare const CookiesProvider: React__default.FC<{
    children: ReactNode;
}>;

interface WalletSelectorProps {
    isOpen: boolean;
    className?: string;
    accounts: AccountProps[];
    showDisclaimer?: boolean;
    isCheckBoxChecked?: boolean;
    onClose: () => void;
    onCheckBoxChange?: (value: boolean) => void;
    onAccountSelect?: (accountId: string) => void;
}

declare const WalletSelector: FC<WalletSelectorProps>;

interface WalletSwitcherProps {
    className?: string;
    accounts: AccountProps[];
    ref?: RefObject<HTMLDivElement> | null;
    onAccountDepositClick?: () => void;
    onAccountSelect: (accountId: string) => void;
}

declare const WalletSwitcher: FC<WalletSwitcherProps>;

type ErrorType = 'base-error' | 'germany-only' | 'connection-unavailable' | 'service-unavailable' | 'bet-added' | 'bet-added-and-registration' | 'reality-check' | 'waiting-period' | 'active-elsewhere' | 'logged-in-elsewhere' | 'inactive-error' | 'new-wallet' | 'push-notification' | 'self-block';
type Language = 'de' | 'en';
interface ErrorPopUpProps {
    variant: ErrorType;
    className?: string;
    errorTitle?: string;
    language?: Language;
    showWarningIcon?: boolean;
    defaultButtonLabel?: string;
    footerButtons?: Array<ReactNode>;
    errorDetails?: string | ReactNode;
    isClosable?: boolean;
    showDetails?: boolean;
    escKeyClose?: boolean;
    showCloseIcon?: boolean;
    backdropClickClose?: boolean;
    isOpen: boolean;
    onClose: () => void;
    onConfirmWallet?: () => void;
    onUsePushNotification?: () => void;
    onLugasClick?: () => void;
    onLogoutClick?: () => void;
    onStayLoggedInClick?: () => void;
    onUseNowClick?: () => void;
    onUseLaterClick?: () => void;
    onTryAgainClick?: () => void;
    onReloadPageClick?: () => void;
    onConfirmCreation?: () => void;
    onNewWalletSupportClick?: () => void;
    onNewWalletCheckboxChange?: (isChecked: boolean) => void;
}

declare const ErrorPopUp: FC<ErrorPopUpProps>;

declare const Cashout: React__default.FC<CashoutProps>;

type LeagueTableItem = {
    id?: string;
    team: string;
    overall: TeamStatistics;
    home: TeamStatistics;
    away: TeamStatistics;
    status: 'Champions League' | 'UEFA Europa League' | 'UEFA Conference League' | 'Relegation' | 'Neutral';
    trend: 'up' | 'down' | 'stable';
    isFlagged?: boolean;
};
type TeamStatistics = {
    played: number;
    wins: number;
    draws: number;
    losses: number;
    goalsFor: number;
    goalsAgainst: number;
    goalDifference: number;
    points: number;
};
type LeagueTableProps = {
    data: LeagueTableItem[];
    error?: string;
    leagueName?: string;
    title?: ReactNode;
};

declare const LeagueTable: React__default.FC<LeagueTableProps>;

declare const HomeCategory: React__default.FC<HomeCategoryWidgetProps>;

interface SportsCategoryItemWebProps {
    category: MatchTypes;
    isSelected?: boolean;
    onSelect?: (category: MatchTypes | undefined) => void;
    className?: string;
    labelClassName?: string;
    isFavorite?: boolean;
    countryCode?: string;
    leagueName?: string;
}
declare const SportsCategoryItem: React__default.FC<SportsCategoryItemWebProps>;

interface BetStoreProps {
    bets: Bets[];
    setBets: (bets: Bets[]) => void;
    addBet: (bet: Bets) => void;
    removeBet: (bet: Bet, parentId: string) => void;
    removeBetByBetId: (betId: string) => void;
    removeAllBets: (parentId: string) => void;
    clearBets: () => void;
    walletSelected: string;
    setWalletSelected: (selected: string) => void;
    walletOptions: WalletOptionsConfig;
    setWalletOptions: (options: WalletOptionsConfig) => void;
    validationState: ValidationState;
    setValidationState: (state: ValidationState) => void;
    processingResult: ProcessingResult;
    setProcessingResult: (result: ProcessingResult) => void;
    onReuse: () => void;
    onShow: () => void;
    onFinishProcessing: () => void;
    betSlipHistory: Bets[][];
    saveBetSlip: () => void;
    undoBetSlip: () => void;
}

interface BetSlipWidgetProps {
    storeInstance: BetStoreProps;
    isLoggedIn: boolean;
    isSelfExcluded: boolean;
    redirections: {
        redirectToLogin: () => void;
        redirectToDeposit: () => void;
    };
}
declare function BetSlipWidget({ storeInstance, isLoggedIn, isSelfExcluded, redirections, }: BetSlipWidgetProps): react_jsx_runtime.JSX.Element;

declare function EmptyBetSlip(): react_jsx_runtime.JSX.Element;
type SuccessBetSlipProps = {
    onReuse: () => void;
    onShow: () => void;
};
declare function SuccessBetSlip({ onReuse, onShow }: SuccessBetSlipProps): react_jsx_runtime.JSX.Element;
declare function NotEnoughMoney({ redirectFunction }: {
    redirectFunction: () => void;
}): react_jsx_runtime.JSX.Element;

interface StakeSelectionsTabsProps {
    bets: Bets[];
    stakeCalculations: IStakeCalculations;
    state: BetslipState;
    actions: IBetslipsActions;
    isProcessing: boolean;
    walletOptions: WalletOptionsConfig;
}
declare function StakeSelectionsTabs({ bets, stakeCalculations, isProcessing, state, actions, walletOptions, }: StakeSelectionsTabsProps): react_jsx_runtime.JSX.Element;

type DisplayBetsProps = {
    bets: Bets[];
    onClearAll: () => void;
    isSystemTab: boolean;
    onRemoveBetByBetId: (id: string) => void;
    onRemoveParentBet: (id: string) => void;
};
declare function DisplayBets({ bets, onClearAll, onRemoveBetByBetId, onRemoveParentBet, isSystemTab, }: DisplayBetsProps): react_jsx_runtime.JSX.Element;

interface StakeInputProps {
    id: string;
    label: string;
    stake: string;
    currency: string;
    disabled: boolean;
    onStakeChange: (value: string) => void;
    onStakeBlur?: () => void;
}
declare function StakeInput({ id, label, stake, currency, disabled, onStakeChange, onStakeBlur, }: StakeInputProps): react_jsx_runtime.JSX.Element;
declare function GewinnchanceDisplay(): react_jsx_runtime.JSX.Element;
declare function WetteinsatzDisplay({ state }: {
    state: BetslipState;
}): react_jsx_runtime.JSX.Element;
declare function BankIndicator({ type }: {
    type: 'bank' | 'non-bank';
}): react_jsx_runtime.JSX.Element;
type OddDisplayProps = {
    odd: number;
    isValid: boolean;
    isLocked?: boolean;
    hasOddChange?: 'up' | 'down';
};
declare function OddDisplay({ odd, isValid, isLocked, hasOddChange }: OddDisplayProps): react_jsx_runtime.JSX.Element;
type WinConditionDisplayProps = {
    category: string;
    winCondition: string;
    bet: Bets;
    isLocked?: boolean;
};
declare function WinConditionDisplay({ category, winCondition, bet, isLocked }: WinConditionDisplayProps): react_jsx_runtime.JSX.Element;

type WalletOptionsProps = {
    onSelect?: (value: string) => void;
    type?: 'select' | 'banner';
};
declare function WalletOptions({ onSelect, type }: WalletOptionsProps): react_jsx_runtime.JSX.Element;

interface BetSlipButtonProps {
    onFinishProcessing: () => void;
    isLoggedIn: boolean;
    isSelfExcluded: boolean;
    processing: {
        isConfirming: boolean;
        isProcessing: boolean;
        actions: IBetSlipProcessingActions;
        countdown: number;
    };
    checkValidSubmission: () => boolean;
    isMoneySufficient: boolean;
    redirectToLogin: () => void;
    redirectToDeposit: () => void;
}
declare function BetSlipButton({ onFinishProcessing, isLoggedIn, isSelfExcluded, isMoneySufficient, checkValidSubmission, processing, redirectToLogin, redirectToDeposit, }: BetSlipButtonProps): react_jsx_runtime.JSX.Element;

type SelfExclusionDialogProps = {
    isSelfExcluded: boolean;
    isPending: boolean;
    isSuccess: boolean;
    isError: boolean;
    onButtonClick: () => void;
    remainingText?: string;
};
declare function SelfExclusionDialog({ isSelfExcluded, isPending, isError, onButtonClick, remainingText, }: SelfExclusionDialogProps): react_jsx_runtime.JSX.Element;

type BetSlipProps = {
    title?: string;
};
type BetSlipContextType = {
    title: string;
};
type BetSlipItemProps = {
    title: string;
};

export { Accordion, type AccordionCardProps, AccordionContext, type AccordionContextType, type AccordionHeaderPosition, type AccordionHeaderProps, type AccordionIconProps, AccordionItem, type AccordionItemProps, type AccordionNativeProps, type AccordionNativeVariant, type AccordionProps, type AccordionVariant, Account, type AccountBodyProps, type AccountFooterProps, type AccountHeaderProps, type AccountProps, AccountSummary, type AccountSummaryProps, type AccountWallet, Badge, type BadgeColor, type BadgeProps, type BadgeSize, type BadgeVariant, BankIndicator, Banner, type BannerNativeProps, type BannerProps, type BannerTextPosition, type Bet$1 as Bet, type BetPackerOddButtonProps, type BetPackerTableData, type BetPackerTableProps, BetSlipButton, type BetSlipContextType, type BetSlipItemProps, type BetSlipProps, BetSlipWidget, BetStop, type BetStopProps, type BetStopStatus, Button, type ButtonNativeProps, type ButtonProps, type ButtonSize, type ButtonVariant, Card, type CardPadding, type CardProps, type CardShadow, Cashout, type CashoutItem, type CashoutItemComponentProps, type CashoutItemDetailsProps, type CashoutItemLabelProps, type CashoutItemLabelPropsNative, type CashoutProps, ChainedStatus, type ChainedStatusDirection, type ChainedStatusItem, type ChainedStatusNativeProps, type ChainedStatusProps, type ChainedStatusSize, type ChainedStatusVariant, Chatbox, type ChatboxProps, CheckBox, type CheckBoxDirection, type CheckBoxProps, type CheckBoxSize$1 as CheckBoxSize, CheckBoxStatus, type CheckBoxStatusProps, type CheckBoxSize as CheckBoxStatusSize, type CheckBoxStatusType, type CheckBoxVariant, CheckList, type ColumnProps, Cookies, type CookiesProps, CookiesProvider, CountryFlag, type CountryFlagProps, type CountryFlagSize, CustomSearchWidget, type DescriptionIcon, DialogBox, type DialogBoxProps, DisplayBets, Drawer, type DrawerDirection, type DrawerPlacement, type DrawerProps, type DrawerSize, type DrawerVariant, DynamicHelmet, EmptyBetSlip, type ErrorMessageColor, ErrorPopUp, EventDataTable, EventDetailDrawer, type ExtendedSelectTooltipProps, FilterOptions, type FooterItemProps, GewinnchanceDisplay, HomeCategory, type HorizontalDirection, type IKeyboardButton, type IKeyboardProps, type IKeyboardTypeProps, type IOdds, type ISkeletonLoaderProps, type ITopStoryItem, type IconVariant, index as Icons, InfoBox, type InfoBoxDirection, type InfoBoxProps, type InfoBoxVariant, Input, type InputMode, type InputNativeProps, type InputProps, type InputSize, type InputStatus, type InputTooltipOptions, type InputTooltipPointerDirection, type InputTooltipPosition, type InputTooltipProps, type InputTooltipTrigger, type InputType, Keyboard, Label, type LabelNativeProps, type LabelProps, type LabelSize, type LabelVariant, LeagueStatistics, type LeagueStatisticsProps, type LeagueStatisticsTableItem, LeagueTable, type LeagueTableItem, type LeagueTableProps, type LegacyCashoutItem, LimitDeposit, type LimitDepositNativeProps, type LimitDepositProps, ListGroup, Loader, type LoaderProps, LongTermBet, type LongTermBetDrawerNativeProps, type LongTermBetDrawerProps, type LongTermBetEventType, type LongTermBetItem, type LongTermBetProps, type LongTermBetSports, type LongTermBetStatus, MatchBoard, type MatchBoardProps, type MatchData, type MatchInfo, type MatchProgressNativeProps, type MatchProgressProps, type MatchProgressVariant, type MessageType, type NativeTopStoriesProps, type NativeTopStoryProps, NavBar, type NavBarPosition, type NavBarProps, type NavBarVariant, NavMenu, type NavMenuDirection, type NavMenuItemIconPosition, type NavMenuItemProps, type NavMenuProps, type NavMenuVariant, NotEnoughMoney, OddDisplay, OddsComparisonSlider, OddsComparisonSliderContent, type OddsComparisonSliderProps, type OddsDataItem, type Option, Post, type PostNativeProps, type PostProps, type PrimitiveValue, type ProgressBarProps, RadioGroup, type RadioGroupNativeProps, type RadioGroupProps, RadioInput, type RadioInputProps, type RadioInputVariant, type RowData, type ScoreboardProps, ScrollArea, type ScrollAreaNativeProps, type ScrollAreaProps, SearchWidget, type SearchWidgetProps, Select, type SelectMode, type SelectNativeProps, type SelectPlacement, type SelectProps, type SelectSize, type SelectStatus, type SelectTooltipOptions, SelfExclusionDialog, Separator, type SeparatorProps, type SizeMapProps, Skeleton, type SkeletonProps, SplitLoader, type SplitLoaderProps, type SplitLoaderSize, SportsCategoryItem, type SportsCategoryItemWebProps, StakeInput, StakeSelectionsTabs, type StatisticsSkeletonLoaderProps, type Status, type StepItem, Stepper, type StepperProps, SuccessBetSlip, type SummaryItem, Switch, type SwitchColor, type SwitchNativeProps, type SwitchProps, type SwitchSize, type Tab, Table, type TableProps, Tabs, type TabsProps, type TabsRef, type TeamStatistics, TextArea, type TextAreaProps, type TextAreaResize, type TextAreaSize, type TextAreaStatus, ThemeProvider, ThemeSwitcher, Themes, Toast, ToastContext, type ToastContextType, type ToastDuration, type ToastInternal, type ToastProps, ToastProvider, type ToastVariant, type ToastVariantProps, Tooltip, type TooltipAnimation, type TooltipPlacement, type TooltipPointerDirection, type TooltipPointerDirections, type TooltipPosition, type TooltipPositions, type TooltipProps, type TooltipTrigger, type TooltipTriggers, type TooltipVariant, TopStories, type TopStoriesWidgetProps, type TopStoryProps, type TransactionEntry, type TransactionHistory, type TransactionType, type VerticalDirection, WalletOptions, WalletSelector, type WalletSelectorProps, WalletSwitcher, type WalletSwitcherProps, WetteinsatzDisplay, WinConditionDisplay, defaultNumericKeys, incrementKeys, secondaryKeys, statusColors, useTheme, useToast };
