import * as react_jsx_runtime from 'react/jsx-runtime';
import * as React$1 from 'react';
import React__default, { LabelHTMLAttributes, ReactElement, ButtonHTMLAttributes, ReactNode, Ref, RefObject, FC, CSSProperties, ChangeEvent, MouseEvent, HTMLAttributes } from 'react';
import { SvgProps } from 'react-native-svg';
import { TextProps, StyleProp, TextStyle, TextInputProps, NativeSyntheticEvent, TextInputFocusEventData, ViewStyle, TextInput, AccessibilityRole, AccessibilityState, TouchableOpacity, ImageStyle, View, DimensionValue, TargetedEvent, ColorValue, ViewProps, GestureResponderEvent, ModalProps, TouchableWithoutFeedbackProps } from 'react-native';
import { DimensionValue as DimensionValue$1 } from 'react-native/Libraries/StyleSheet/StyleSheetTypes';
import { DrawerContentComponentProps } from '@react-navigation/drawer';
import BottomSheet from '@gorhom/bottom-sheet';

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

declare const index_native_AgeRestriction: typeof AgeRestriction;
declare const index_native_Aircash: typeof Aircash;
declare const index_native_AircashFlat: typeof AircashFlat;
declare const index_native_AmericanFootball: typeof AmericanFootball;
declare const index_native_AppleStore: typeof AppleStore;
declare const index_native_ArrowDown: typeof ArrowDown;
declare const index_native_ArrowLeft: typeof ArrowLeft;
declare const index_native_ArrowUp: typeof ArrowUp;
declare const index_native_Ball: typeof Ball;
declare const index_native_BankTransfer: typeof BankTransfer;
declare const index_native_BankTransferFlat: typeof BankTransferFlat;
declare const index_native_Barcode: typeof Barcode;
declare const index_native_BarcodeBorder: typeof BarcodeBorder;
declare const index_native_Baseball: typeof Baseball;
declare const index_native_Basketball: typeof Basketball;
declare const index_native_BasketballEmpty: typeof BasketballEmpty;
declare const index_native_Bell: typeof Bell;
declare const index_native_BellEmpty: typeof BellEmpty;
declare const index_native_BettingSlip: typeof BettingSlip;
declare const index_native_Bin: typeof Bin;
declare const index_native_CameraBlocked: typeof CameraBlocked;
declare const index_native_CancelTip: typeof CancelTip;
declare const index_native_CancelledIcon: typeof CancelledIcon;
declare const index_native_CashOut: typeof CashOut;
declare const index_native_CashoutRotate: typeof CashoutRotate;
declare const index_native_Chat: typeof Chat;
declare const index_native_Check: typeof Check;
declare const index_native_ChrevonDown: typeof ChrevonDown;
declare const index_native_ChrevonLeft: typeof ChrevonLeft;
declare const index_native_ChrevonRight: typeof ChrevonRight;
declare const index_native_ChrevonUp: typeof ChrevonUp;
declare const index_native_CicrleCheck: typeof CicrleCheck;
declare const index_native_CicrleCheckFill: typeof CicrleCheckFill;
declare const index_native_CicrleCheckFill2: typeof CicrleCheckFill2;
declare const index_native_CircleCrossFill: typeof CircleCrossFill;
declare const index_native_Clock: typeof Clock;
declare const index_native_Cross: typeof Cross;
declare const index_native_CustomerCard: typeof CustomerCard;
declare const index_native_Cycling: typeof Cycling;
declare const index_native_DSWLogo: typeof DSWLogo;
declare const index_native_Envelope: typeof Envelope;
declare const index_native_ErrorIcon: typeof ErrorIcon;
declare const index_native_EuroIcon: typeof EuroIcon;
declare const index_native_Eye: typeof Eye;
declare const index_native_EyeOff: typeof EyeOff;
declare const index_native_Facebook: typeof Facebook;
declare const index_native_Flash: typeof Flash;
declare const index_native_Football: typeof Football;
declare const index_native_Futsal: typeof Futsal;
declare const index_native_GGLLogo: typeof GGLLogo;
declare const index_native_Gift: typeof Gift;
declare const index_native_Globe: typeof Globe;
declare const index_native_Graph: typeof Graph;
declare const index_native_GridView: typeof GridView;
declare const index_native_Handball: typeof Handball;
declare const index_native_HandballEmpty: typeof HandballEmpty;
declare const index_native_HeadSet: typeof HeadSet;
declare const index_native_HighlightsPoint: typeof HighlightsPoint;
declare const index_native_House: typeof House;
declare const index_native_IceHockey: typeof IceHockey;
declare const index_native_Information: typeof Information;
declare const index_native_InformationCircle: typeof InformationCircle;
declare const index_native_Instagram: typeof Instagram;
declare const index_native_InternetError: typeof InternetError;
declare const index_native_LeftArrow: typeof LeftArrow;
declare const index_native_LeftRightArrow: typeof LeftRightArrow;
declare const index_native_LightingFilled: typeof LightingFilled;
declare const index_native_LinkedIn: typeof LinkedIn;
declare const index_native_Live: typeof Live;
declare const index_native_Lock: typeof Lock;
declare const index_native_Logout: typeof Logout;
declare const index_native_MGALogo: typeof MGALogo;
declare const index_native_ManagementSystemLogo: typeof ManagementSystemLogo;
declare const index_native_Mastercard: typeof Mastercard;
declare const index_native_MastercardFlat: typeof MastercardFlat;
declare const index_native_MastercardMobile: typeof MastercardMobile;
declare const index_native_Medal: typeof Medal;
declare const index_native_Menu: typeof Menu;
declare const index_native_Minus: typeof Minus;
declare const index_native_MixedMenuIcon: typeof MixedMenuIcon;
declare const index_native_MixedMenuIcon1: typeof MixedMenuIcon1;
declare const index_native_PaperclipIcon: typeof PaperclipIcon;
declare const index_native_Paypal: typeof Paypal;
declare const index_native_PaypalFlat: typeof PaypalFlat;
declare const index_native_PendingIcon: typeof PendingIcon;
declare const index_native_Pin: typeof Pin;
declare const index_native_PlayStore: typeof PlayStore;
declare const index_native_Plus: typeof Plus;
declare const index_native_QRCode: typeof QRCode;
declare const index_native_RedCard: typeof RedCard;
declare const index_native_Reload: typeof Reload;
declare const index_native_Search: typeof Search;
declare const index_native_SettingsIcon: typeof SettingsIcon;
declare const index_native_ShopWallet: typeof ShopWallet;
declare const index_native_ShowHeaderIcon: typeof ShowHeaderIcon;
declare const index_native_Skrill: typeof Skrill;
declare const index_native_SkrillFlat: typeof SkrillFlat;
declare const index_native_Smartphone: typeof Smartphone;
declare const index_native_Soccer: typeof Soccer;
declare const index_native_Sport: typeof Sport;
declare const index_native_SportsBetting: typeof SportsBetting;
type index_native_SportsBettingIconsNativeProps = SportsBettingIconsNativeProps;
type index_native_SportsBettingIconsProps = SportsBettingIconsProps;
declare const index_native_SportsBettingLogo: typeof SportsBettingLogo;
declare const index_native_Star: typeof Star;
declare const index_native_StarFill: typeof StarFill;
declare const index_native_SuccessIcon: typeof SuccessIcon;
declare const index_native_TableTennis: typeof TableTennis;
declare const index_native_Tennis: typeof Tennis;
declare const index_native_TennisEmpty: typeof TennisEmpty;
declare const index_native_TransferDeposit: typeof TransferDeposit;
declare const index_native_TransferWithdraw: typeof TransferWithdraw;
declare const index_native_TriangleDown: typeof TriangleDown;
declare const index_native_TriangleInclinedDown: typeof TriangleInclinedDown;
declare const index_native_TriangleInclinedUp: typeof TriangleInclinedUp;
declare const index_native_TriangleLeft: typeof TriangleLeft;
declare const index_native_TriangleRight: typeof TriangleRight;
declare const index_native_TriangleUp: typeof TriangleUp;
declare const index_native_Trustly: typeof Trustly;
declare const index_native_TrustlyFlat: typeof TrustlyFlat;
declare const index_native_Twitter: typeof Twitter;
declare const index_native_UEFA: typeof UEFA;
declare const index_native_UploadIcon: typeof UploadIcon;
declare const index_native_User: typeof User;
declare const index_native_VAR: typeof VAR;
declare const index_native_VerticalBar: typeof VerticalBar;
declare const index_native_Visa: typeof Visa;
declare const index_native_VisaFlat: typeof VisaFlat;
declare const index_native_Volleyball: typeof Volleyball;
declare const index_native_Warning: typeof Warning;
declare const index_native_WarningFilled: typeof WarningFilled;
declare const index_native_X: typeof X;
declare const index_native_XFill: typeof XFill;
declare namespace index_native {
  export { index_native_AgeRestriction as AgeRestriction, index_native_Aircash as Aircash, index_native_AircashFlat as AircashFlat, index_native_AmericanFootball as AmericanFootball, index_native_AppleStore as AppleStore, index_native_ArrowDown as ArrowDown, index_native_ArrowLeft as ArrowLeft, index_native_ArrowUp as ArrowUp, index_native_Ball as Ball, index_native_BankTransfer as BankTransfer, index_native_BankTransferFlat as BankTransferFlat, index_native_Barcode as Barcode, index_native_BarcodeBorder as BarcodeBorder, index_native_Baseball as Baseball, index_native_Basketball as Basketball, index_native_BasketballEmpty as BasketballEmpty, index_native_Bell as Bell, index_native_BellEmpty as BellEmpty, index_native_BettingSlip as BettingSlip, index_native_Bin as Bin, index_native_CameraBlocked as CameraBlocked, index_native_CancelTip as CancelTip, index_native_CancelledIcon as CancelledIcon, Card$1 as Card, index_native_CashOut as CashOut, index_native_CashoutRotate as CashoutRotate, index_native_Chat as Chat, index_native_Check as Check, index_native_ChrevonDown as ChrevonDown, index_native_ChrevonLeft as ChrevonLeft, index_native_ChrevonRight as ChrevonRight, index_native_ChrevonUp as ChrevonUp, index_native_CicrleCheck as CicrleCheck, index_native_CicrleCheckFill as CicrleCheckFill, index_native_CicrleCheckFill2 as CicrleCheckFill2, index_native_CircleCrossFill as CircleCrossFill, index_native_Clock as Clock, index_native_Cross as Cross, index_native_CustomerCard as CustomerCard, index_native_Cycling as Cycling, index_native_DSWLogo as DSWLogo, index_native_Envelope as Envelope, index_native_ErrorIcon as ErrorIcon, index_native_EuroIcon as EuroIcon, index_native_Eye as Eye, index_native_EyeOff as EyeOff, index_native_Facebook as Facebook, index_native_Flash as Flash, index_native_Football as Football, index_native_Futsal as Futsal, index_native_GGLLogo as GGLLogo, index_native_Gift as Gift, index_native_Globe as Globe, index_native_Graph as Graph, index_native_GridView as GridView, index_native_Handball as Handball, index_native_HandballEmpty as HandballEmpty, index_native_HeadSet as HeadSet, index_native_HighlightsPoint as HighlightsPoint, index_native_House as House, index_native_IceHockey as IceHockey, index_native_Information as Information, index_native_InformationCircle as InformationCircle, index_native_Instagram as Instagram, index_native_InternetError as InternetError, index_native_LeftArrow as LeftArrow, index_native_LeftRightArrow as LeftRightArrow, index_native_LightingFilled as LightingFilled, index_native_LinkedIn as LinkedIn, index_native_Live as Live, index_native_Lock as Lock, index_native_Logout as Logout, index_native_MGALogo as MGALogo, index_native_ManagementSystemLogo as ManagementSystemLogo, index_native_Mastercard as Mastercard, index_native_MastercardFlat as MastercardFlat, index_native_MastercardMobile as MastercardMobile, index_native_Medal as Medal, index_native_Menu as Menu, index_native_Minus as Minus, index_native_MixedMenuIcon as MixedMenuIcon, index_native_MixedMenuIcon1 as MixedMenuIcon1, index_native_PaperclipIcon as PaperclipIcon, index_native_Paypal as Paypal, index_native_PaypalFlat as PaypalFlat, index_native_PendingIcon as PendingIcon, index_native_Pin as Pin, index_native_PlayStore as PlayStore, index_native_Plus as Plus, index_native_QRCode as QRCode, index_native_RedCard as RedCard, index_native_Reload as Reload, index_native_Search as Search, index_native_SettingsIcon as SettingsIcon, index_native_ShopWallet as ShopWallet, index_native_ShowHeaderIcon as ShowHeaderIcon, index_native_Skrill as Skrill, index_native_SkrillFlat as SkrillFlat, index_native_Smartphone as Smartphone, index_native_Soccer as Soccer, index_native_Sport as Sport, index_native_SportsBetting as SportsBetting, type index_native_SportsBettingIconsNativeProps as SportsBettingIconsNativeProps, type index_native_SportsBettingIconsProps as SportsBettingIconsProps, index_native_SportsBettingLogo as SportsBettingLogo, index_native_Star as Star, index_native_StarFill as StarFill, index_native_SuccessIcon as SuccessIcon, index_native_TableTennis as TableTennis, index_native_Tennis as Tennis, index_native_TennisEmpty as TennisEmpty, index_native_TransferDeposit as TransferDeposit, index_native_TransferWithdraw as TransferWithdraw, index_native_TriangleDown as TriangleDown, index_native_TriangleInclinedDown as TriangleInclinedDown, index_native_TriangleInclinedUp as TriangleInclinedUp, index_native_TriangleLeft as TriangleLeft, index_native_TriangleRight as TriangleRight, index_native_TriangleUp as TriangleUp, index_native_Trustly as Trustly, index_native_TrustlyFlat as TrustlyFlat, index_native_Twitter as Twitter, index_native_UEFA as UEFA, index_native_UploadIcon as UploadIcon, index_native_User as User, index_native_VAR as VAR, index_native_VerticalBar as VerticalBar, index_native_Visa as Visa, index_native_VisaFlat as VisaFlat, index_native_Volleyball as Volleyball, index_native_Warning as Warning, index_native_WarningFilled as WarningFilled, index_native_X as X, index_native_XFill as XFill };
}

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: React__default.FC<LabelNativeProps>;
declare const styles: {
    base: {
        fontWeight: "500";
    };
    small: {
        fontSize: number;
        lineHeight: number;
    };
    medium: {
        fontSize: number;
        lineHeight: number;
    };
    large: {
        fontSize: number;
        lineHeight: number;
    };
};

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>;
    };
}

declare const Input: React__default.ForwardRefExoticComponent<InputNativeProps & React__default.RefAttributes<TextInput>>;

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<ButtonNativeProps & {
    iconColor?: string;
    accessibilityRole?: string;
    accessibilityState?: AccessibilityState;
} & React__default.RefAttributes<TouchableOpacity>>;

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: React__default.FC<SkeletonProps>;

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__default.FC<BannerNativeProps>;

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 normalizeSize: (value: number | string) => DimensionValue;
declare const strToNumber: (value: string | number) => number;
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 CheckBoxNativeProps {
    id?: string;
    label?: string | ReactNode;
    defaultChecked?: boolean;
    checked?: boolean;
    onChange?: (value: boolean) => void;
    disabled?: boolean;
    readOnly?: boolean;
    required?: boolean;
    size?: CheckBoxSize$1;
    variant?: CheckBoxVariant;
    direction?: CheckBoxDirection;
    status?: CheckBoxStatus$1;
    partialChecked?: boolean;
    onFocus?: (e: NativeSyntheticEvent<TargetedEvent>) => void;
    onBlur?: (e: NativeSyntheticEvent<TargetedEvent>) => void;
    className?: string;
}

declare const CheckBox: React__default.FC<CheckBoxNativeProps>;

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$1 = 'top' | 'bottom' | 'left' | 'right';
type TooltipTrigger$1 = 'click' | 'focus' | 'manual';
type TooltipAnimation$1 = 'fade' | 'scale' | 'none';
type TooltipVariant$1 = 'warning' | 'success' | 'error' | 'info';
type TooltipPointerDirection$1 = 'left' | 'right' | 'center' | 'top' | 'bottom';
interface TooltipNativeProps {
    id: string;
    content?: string | React__default.ReactNode;
    placement?: TooltipPlacement$1;
    trigger?: TooltipTrigger$1;
    delay?: number;
    arrow?: boolean;
    animation?: TooltipAnimation$1;
    maxWidth?: DimensionValue;
    disabled?: boolean;
    isVisible?: boolean;
    closeButton?: boolean;
    onClose?: () => void;
    onShow?: () => void;
    onHide?: () => void;
    variant?: TooltipVariant$1;
    pointerDirection?: TooltipPointerDirection$1;
    className?: string;
    pointerDirectionOffset?: DimensionValue;
}

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

type BadgeVariant = 'solid' | 'outline' | 'ghost';
type BadgeSize = 'small' | 'medium' | 'large';
type BadgeColor = 'primary' | 'secondary' | 'danger' | 'success' | 'warning' | string;
interface BadgeNativeProps {
    id?: string;
    variant?: BadgeVariant;
    size?: BadgeSize;
    color?: BadgeColor;
    text: string;
    pill?: boolean;
    icon?: boolean;
    circular?: boolean;
    iconValue?: React__default.ReactNode;
    tooltipContent?: string | React__default.ReactNode;
    classNames?: string;
    textClassNames?: string;
    accessibilityLabel?: string;
    onPress?: () => void;
}

declare const Badge: ({ id, icon, text, circular, iconValue, onPress, pill, size, tooltipContent, color, variant, classNames, textClassNames, accessibilityLabel, }: BadgeNativeProps) => react_jsx_runtime.JSX.Element;

type CountryFlagSize = "small" | "medium" | "large" | number;
interface CountryFlagNativeProps {
    id?: string;
    countryCode: string;
    size?: CountryFlagSize;
    altText?: string;
    rounded?: boolean;
    shadow?: boolean;
    className?: string;
}

declare const CountryFlag: React__default.FC<CountryFlagNativeProps>;

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;
}

type TextAreaSize = 'small' | 'default' | 'large';
type TextAreaStatus = 'none' | 'warning' | 'error';
type TooltipPosition = 'left' | 'right' | 'bottom' | 'top' | 'mouse';
interface TextAreaNativeProps extends Omit<TextInputProps, 'onChange'> {
    id?: string;
    placeholder?: string;
    value?: string;
    defaultValue?: string;
    size?: TextAreaSize;
    disabled?: boolean;
    readOnly?: boolean;
    autoFocus?: boolean;
    allowClear?: boolean;
    maxLength?: number;
    minLength?: number;
    showCount?: boolean;
    status?: TextAreaStatus;
    prefix?: ReactNode;
    suffix?: ReactNode;
    addonAfter?: ReactNode;
    addonBefore?: ReactNode;
    onChange?: (value: string) => void;
    onBlur?: (event: NativeSyntheticEvent<TextInputFocusEventData>) => void;
    onFocus?: (event: NativeSyntheticEvent<TextInputFocusEventData>) => void;
    tooltipContent?: ReactNode;
    tooltipOptions?: TooltipProps;
}

declare const TextArea: FC<TextAreaNativeProps>;

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: React__default.FC<SelectNativeProps>;

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 const RadioGroup: React__default.FC<RadioGroupNativeProps>;

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 const MatchBoard: FC<MatchBoardProps>;

type RadioInputVariant = 'primary' | 'secondary' | ColorValue;
interface RadioInputNativeProps {
    id?: string;
    classNames?: string;
    value: string | number;
    label: string | ReactNode;
    checked?: boolean;
    disabled?: boolean;
    labelPosition?: 'left' | 'right';
    variant?: RadioInputVariant;
    labelClassNames?: string;
    onChange?: (value: string | number, isChecked: boolean) => void;
    unCheckColor?: ColorValue;
    containerClassNames?: string;
}

declare const RadioInput: React__default.FC<RadioInputNativeProps>;

type Status = 'N' | 'U' | 'S';
interface ChainedStatusItem {
    label: string;
    status: Status;
}
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, size, variant, direction, connectorColor, }: ChainedStatusNativeProps): react_jsx_runtime.JSX.Element;

type CardShadow = 'none' | 'small' | 'medium' | 'large';
type CardPadding = 'none' | 'small' | 'medium' | 'large';
interface CardNativeProps extends ViewProps {
    id: string;
    header?: ReactNode | string;
    footer?: ReactNode | string;
    bordered?: boolean;
    width?: DimensionValue$1;
    height?: DimensionValue$1;
    shadow?: CardShadow;
    padding?: CardPadding;
    children: ReactNode;
    className?: string;
    headerClassName?: string;
    footerClassName?: string;
}

declare const Card: React__default.FC<CardNativeProps>;

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

declare const MatchProgress: FC<MatchProgressNativeProps>;

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<PostNativeProps>;

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$2, 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$2 = string | number | boolean | undefined | React__default.ReactNode | object;
interface ListGroupNativeProps extends Omit<ListGroupProps, 'onClick'> {
    style?: ViewStyle;
    onClick?: (event: GestureResponderEvent, index: number) => void;
    accessibilityLabel?: string;
}

declare const ListGroup: React__default.ForwardRefExoticComponent<ListGroupNativeProps & React__default.RefAttributes<View>>;

type ProgressBarSize = 'small' | 'medium' | 'large';
type ProgressBarLabelPosition = 'inside' | 'outside';
type ProgressBarDirection = 'horizontal' | 'vertical';
type ProgressBarVariant = 'solid' | 'dashed' | 'dotted';
type SizeClassProps = Record<ProgressBarDirection, Record<ProgressBarSize, string>>;
interface ProgressBarNativeProps {
    id: string;
    className?: string;
    value?: number;
    defaultValue?: number;
    max?: number;
    min?: number;
    size?: ProgressBarSize;
    color?: string;
    backgroundColor?: string;
    striped?: boolean;
    animated?: boolean;
    variant?: ProgressBarVariant;
    showPercentage?: boolean;
    indeterminate?: boolean;
    style?: StyleProp<ViewStyle | TextStyle>;
    onChange?: (value: number) => void;
    direction?: ProgressBarDirection;
    minColor?: string;
    maxColor?: string;
    showLoadingLabel?: boolean;
    labelPosition?: ProgressBarLabelPosition;
    minLabel?: string;
    maxLabel?: string;
    minLabelClassName?: string;
    maxLabelClassName?: string;
    customProgressColorClass?: 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<ScrollAreaNativeProps>;

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>;

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<SwitchNativeProps>;

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 LoaderSize = 'small' | 'medium' | 'large';
type LoaderPosition = 'top' | 'bottom' | 'left' | 'right';
type PercentagePosition = 'top' | 'bottom' | 'left' | 'right' | 'center';
interface LoaderNativeProps {
    id: string;
    value?: number;
    color?: ColorValue;
    shadow?: boolean;
    size?: LoaderSize;
    animated?: boolean;
    indeterminate?: boolean;
    showPercentage?: boolean;
    content?: React.ReactNode;
    loaderPosition?: LoaderPosition;
    percentagePosition?: PercentagePosition;
    textStyle?: string;
    style?: string;
    useNativeIndeterminate?: boolean;
}

declare const Loader: FC<LoaderNativeProps>;

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 KeyboardSkeletonLoaderProps {
    rows?: number;
    theme: ITheme;
    keySize: string;
    columns?: number;
    layout: KeyboardLayout;
}
interface KeyBoardTypeProps {
    theme: ITheme;
    rows?: number;
    keySize: string;
    columns?: number;
    includeComma?: boolean;
    includeIncrements?: boolean;
    disabledKeys: string[];
    onKeyPress: (value: string) => void;
    ref?: RefObject<View>;
}
interface KeyboardProps {
    id?: string;
    value: string;
    style?: StyleProp<ViewStyle>;
    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;
}
declare const secondaryKeys: string[];
declare const incrementKeys: string[];
declare const defaultNumericKeys: string[];

declare const Keyboard: FC<KeyboardProps>;

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;
    }[];
}

declare function Accordion({ variant, multiple, headerPosition, headerClassName, flush, items, icon, activeIcon, iconPosition, disabled, defaultOpenIndex, onChange, }: AccordionNativeProps): react_jsx_runtime.JSX.Element;
declare namespace Accordion {
    var displayName: string;
}

type TableSelectMode = 'single' | 'multiple';

interface ColumnProps$1 {
    key: string;
    title: string | React__default.ReactNode;
    dataIndex: string;
    colSpan?: number;
    rowSpan?: number;
    width?: string;
    fixed?: 'left' | 'right';
    onCell?: (rowData: RowData$1, rowIndex: number) => {
        colSpan?: number;
        rowSpan?: number;
        [key: string]: PrimitiveValue$1;
    };
    render?: (value: PrimitiveValue$1, rowIndex?: number | string) => React__default.ReactNode;
    className?: string;
    cellClassName?: string;
}
interface RowData$1 {
    [key: string]: PrimitiveValue$1;
}
type PrimitiveValue$1 = string | number | boolean | undefined | ReactNode;

interface ThProps {
    style?: StyleProp<ViewStyle>;
    className?: string;
    children: ReactNode;
    rowSpan?: number;
    colSpan?: number;
}
interface TdProps {
    style?: StyleProp<ViewStyle>;
    className?: string;
    children: ReactNode;
    rowSpan?: number;
    colSpan?: number;
}
type TableSize = 'small' | 'medium' | 'large' | 'xs';
interface TableProps {
    id: string;
    className?: 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?: TableSize;
    columns: ColumnProps[];
    data: RowData[];
    selectable?: boolean;
    selectMode?: TableSelectMode;
    width?: DimensionValue;
    height?: DimensionValue;
    onSelectRow?: (selectedRows: (string | number)[]) => void;
    onDeselectRow?: (deselectedRows: (string | number)[]) => void;
    onRowClick?: (rowData: PrimitiveValue | object) => void;
    emptyMessage?: string;
    emptyMessageClassName?: 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);
    rowStyle?: (data: RowData) => ViewStyle;
    headerClassName?: string;
    headerContainerClassName?: string;
}
interface ColumnProps {
    key: string;
    title: string | React__default.ReactNode;
    dataIndex: string;
    colSpan?: number;
    rowSpan?: number;
    width?: DimensionValue;
    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;
    textCassName?: string;
}
interface RowData {
    [key: string]: PrimitiveValue;
}
type PrimitiveValue = string | number | boolean | undefined | ReactNode;

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 MatchData = {
    id: number;
    competition: React__default.ReactNode;
    graph?: React__default.ReactNode;
    dateTime?: React__default.ReactNode;
    score?: React__default.ReactNode;
};
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>;
type HeaderColumn = {
    key: string;
    title: React__default.ReactNode;
};
type SourceType = {
    columns: ColumnProps$1[];
    data: MatchData[];
    betTypes: string[];
    headerColumns: HeaderColumn[];
};
type SourceNativeType = {
    columns: ColumnProps[];
    data: MatchData[];
    betTypes: string[];
    headerColumns: HeaderColumn[];
};
declare enum SpecificBetType {
    Tipp = "tipp",
    OverUnder = "overUnder",
    Handicap = "handicap",
    DoubleChance = "doubleChance",
    RestOfMatch = "restOfMatch",
    Set = "set",
    SetHandicap = "setHandicap",
    Leg = "leg"
}
type ExtendedHeaderTemplateProps = {
    table: SourceTypeWithVisibleColumns | SourceTypeWithVisibleNativeColumns;
    idx: number;
    allowColumnFilter?: boolean;
    headerToggle?: () => void;
    showSettingsIcon?: boolean;
    settingIconPress?: () => void;
    showHeaderIcon?: boolean;
    isMobile?: boolean;
    betType?: string;
    reOrder: (tableIdx: number, visibleIdx: number, currentBetType: string, newBetType: string) => void;
};
interface BetTypeRTemplateProps {
    betType: string[];
    indent?: boolean;
    center?: boolean;
}
type SourceTypeWithVisibleColumns = SourceType & {
    headerIndex: number | null;
    originalBetTypes: string[];
    currentBetTypes: string[];
    visibleColumns: ColumnProps$1[];
    visibleHeaderColumns: HeaderColumn[];
};
type SourceTypeWithVisibleNativeColumns = SourceNativeType & {
    headerIndex: number | null;
    originalBetTypes: string[];
    currentBetTypes: string[];
    visibleColumns: ColumnProps[];
    visibleHeaderColumns: HeaderColumn[];
};
interface BottomSheetFilteringProps {
    bottomSheetRef: React__default.RefObject<BottomSheet>;
    competitionChecked: boolean;
    handleOnCompetitionChanged: (value: string | number, isChecked: boolean) => void;
    timeChecked: boolean;
    handleOnTimeChanged: (value: string | number, isChecked: boolean) => void;
    handleOnAdvancedPress: () => void;
    handleOnCompactPress: () => void;
    onClose?: () => void;
}

interface CheckListItemProps {
    label: string | ReactNode;
    iconValue?: string;
    desc?: string | ReactNode;
    checked?: boolean;
    disabled?: boolean;
    className?: string;
    containerClass?: string;
}
interface CheckListNativeProps {
    id?: string;
    className?: string;
    containerClassName?: string;
    badgeLabelStyle?: StyleProp<TextStyle>;
    descStyle?: StyleProp<TextStyle>;
    variant?: 'default' | 'striped' | 'bordered';
    display?: 'grid' | 'flex' | 'list';
    columns?: number;
    activeIndex?: number | string | number[];
    selectAllLabel?: string;
    checkType?: 'checkbox' | 'badge';
    style?: StyleProp<ViewStyle>;
    children: ReactNode;
    ariaLabel?: string;
}

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;
}

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;

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;
}

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

interface CookiesNativeProps {
    isOpen: boolean;
    onClose: () => void;
    onSave: () => void;
    onReject: () => void;
    onAcceptAll: () => void;
    style?: StyleProp<ViewStyle>;
    className?: string;
}

interface CookiePreferences {
    essenziell: boolean;
    funktionell: boolean;
    marketing: boolean;
}
interface CookiesContextType {
    isCookieVisible: boolean;
    cookiePreferences: CookiePreferences;
    acceptCookies: () => void;
    rejectCookies: () => void;
    saveCookiePreferences: (preferences: CookiePreferences) => void;
    showCookieDialog: () => void;
}
declare const CookiesContext: React__default.Context<CookiesContextType | undefined>;
declare const useCookies: () => CookiesContextType;
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;
}

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

interface LeagueStatisticsProps {
    error?: string;
    showChainedStatus?: boolean;
    skeletonLoaderRowCount?: number;
    data: LeagueStatisticsTableItem[];
}
interface LeagueStatisticsTableItem extends RowData$1 {
    id: number;
    Team: string;
    Form: string;
    Sp: number;
    G: number;
    U: number;
    V: number;
    Tore: string;
    Pkt: number;
}

interface AccountSummaryProps {
    isOpen: boolean;
    account: AccountProps;
    className?: string;
    onClose: () => void;
    onBackdropClickClose?: boolean;
    openAnimation?: ModalProps['animationType'];
}

type NativeDialogBoxSize = 'small' | 'default' | 'large';
type NativeDialogBoxAnimation = 'slide' | 'fade' | 'none';
type NativeDialogBoxPadding = 'none' | 'small' | 'default' | 'large';
type NativeDialogBoxVariant = 'default' | 'warning' | 'error' | 'success' | 'info';
interface DialogBoxNativeProps extends TouchableWithoutFeedbackProps {
    id: string;
    style?: StyleProp<ViewStyle>;
    isOpen: boolean;
    className?: string;
    autoCloseTimeout?: number;
    title?: string;
    content: string | ReactNode;
    variant?: NativeDialogBoxVariant;
    size?: NativeDialogBoxSize;
    closable?: boolean;
    onClose: () => void;
    onConfirm?: () => void;
    onCancel?: () => void;
    confirmButtonLabel?: string;
    cancelButtonLabel?: string;
    showCloseIcon?: boolean;
    paddingSize?: NativeDialogBoxPadding;
    backdropClickClose?: boolean;
    icon?: ReactNode;
    headerTemplate?: ReactNode;
    footerTemplateOutside?: ReactNode;
    footerTemplate?: ReactNode;
    headerStyle?: string;
    footerStyle?: string;
    animation?: NativeDialogBoxAnimation;
    showFooterButtons?: boolean;
    addContentSpacing?: boolean;
}

declare const DialogBox: FC<DialogBoxNativeProps>;

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;
}
interface NativeErrorPopUpProps extends Omit<ErrorPopUpProps, 'variant'> {
    variant: ErrorType;
    animation?: DialogBoxNativeProps['animation'];
}

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 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;
};

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;
}

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;
}

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

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;
}

interface SelfExclusion$1 {
    isSelfExcluded: boolean;
    selfExclusionDate: Date | null;
    selfExclusionDuration: number | null;
    isPending: boolean;
    isSuccess: boolean;
    isError: boolean;
    expireAt?: string | null;
    reason?: string;
    durationCode?: '24h' | '7d' | '30d' | '6m' | 'permanent' | null;
}
interface SelfExclusionProps {
    selfExclusion: SelfExclusion$1;
    handleSelfExclusion: () => 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 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 IBetSlipProcessingActions {
    handleConfirm: () => void;
    handleConfirmToProcessing: (onClick: () => void) => void;
    handleCancel: () => void;
}
type WalletOptionsConfig = {
    type: 'select' | 'banner';
    onSelect?: (value: string) => void;
    shouldShow: boolean;
};

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

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>;

declare const CheckList: {
    ({ id, className, style, containerClassName, badgeLabelStyle, descStyle, variant, display, columns, activeIndex, selectAllLabel, checkType, children, ariaLabel, }: CheckListNativeProps): react_jsx_runtime.JSX.Element | null;
    Item: React__default.FC<CheckListItemProps>;
};

type DrawerPlacement = 'left' | 'right';
type DrawerSize = 'small' | 'medium' | 'large' | 'full-screen';
type DrawerVariant = 'default' | string;
interface DrawerProps {
    id: string;
    onClose?: () => void;
    title?: string | ReactNode;
    header?: string | ReactNode;
    content?: string | ReactNode;
    footer?: string | ReactNode;
    placement?: DrawerPlacement;
    size?: DrawerSize;
    isClosable?: boolean;
    hasBackdrop?: boolean;
    disableCloseOnClickOutside?: boolean;
    autoClose?: number;
    variant?: DrawerVariant;
    indicator?: boolean;
}

declare const Drawer: React__default.FC<DrawerContentComponentProps & DrawerProps>;

declare const DrawerWrapper: (props: DrawerProps) => react_jsx_runtime.JSX.Element;

type InfoBoxDirection = 'horizontal' | 'vertical';
type InfoBoxVariant = 'success' | 'error' | 'warning' | 'info' | 'primary' | 'secondary';
interface InfoBoxNativeProps {
    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<InfoBoxNativeProps>;

declare const LimitDeposit: React__default.FC<LimitDepositNativeProps>;

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

type NavMenuVariant = 'primary' | 'secondary' | 'outlined' | 'text';
type NavMenuDirection = 'vertical' | 'horizontal';
type NavMenuItemIconPosition = 'left' | 'right' | 'top' | 'bottom';
interface NavMenuProps {
    id: string;
    style?: StyleProp<ViewStyle>;
    variant?: NavMenuVariant;
    direction?: NavMenuDirection;
    activeIndex?: number;
    disabled?: boolean;
    items: NavMenuItemProps[];
}
interface NavMenuItemProps {
    label: string;
    icon?: React__default.ReactNode;
    iconPosition?: NavMenuItemIconPosition;
    onClick?: () => void;
    style?: StyleProp<ViewStyle>;
    body?: (item: NavMenuItemProps, index: number) => React__default.ReactNode;
    badge?: string | number;
    path?: string;
}

declare const NavMenu: React__default.FC<NavMenuProps>;

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$1.ForwardRefExoticComponent<SearchWidgetProps & React$1.RefAttributes<TextInput>>;
declare const CustomSearchWidget: React$1.ForwardRefExoticComponent<SearchWidgetProps & React$1.RefAttributes<TextInput>>;

declare const Table: React__default.FC<TableProps>;

type NavBarVariant = 'primary' | 'secondary' | 'transparent';
type NavBarPosition = 'fixed' | 'absolute' | 'sticky' | 'relative';
interface NavBarNativeProps {
    id: string;
    variant?: NavBarVariant;
    position?: NavBarPosition;
    shadowOnScroll?: boolean;
    className?: string;
    children?: React__default.ReactNode;
}

declare const NavBar: React__default.FC<NavBarNativeProps>;

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;
    id: string;
    className?: string;
    oddsLength?: number;
};
type BetPackerTableNativeProps = {
    data: BetPackerTableData[];
    showHeader?: boolean;
    isLoading?: boolean;
};

declare const BetPackerTable: React__default.FC<BetPackerTableNativeProps>;

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;
    onPressAllContent?: (index: number) => void;
    showAllscreens?: boolean;
    initialScrollIndex?: number;
}
declare function OddsComparisonSlider({ oddsData, onAddToBettingSlip, title, isLoading, onPressAllContent, showAllscreens, initialScrollIndex, }: OddsComparisonSliderProps): JSX.Element;

interface LoaderProps {
    cards?: number;
    showHeader?: boolean;
}
declare const OddsComparisonSliderLoader: React__default.FC<LoaderProps>;

declare function Cookies(props: CookiesNativeProps): react_jsx_runtime.JSX.Element | null;
declare namespace Cookies {
    var displayName: string;
}

declare const TopStories: FC<NativeTopStoriesProps>;

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;
    categoryName?: string;
    leagueName?: string;
    isHeaderVisible?: boolean;
}

declare const LongTermBet: React__default.FC<LongTermBetProps>;

declare const LongTermBetDrawerContent: React__default.FC<LongTermBetDrawerNativeProps>;

declare const WalletSelector: FC<WalletSelectorProps>;

declare const WalletSwitcher: FC<WalletSwitcherProps>;

declare const LeagueStatistics: FC<LeagueStatisticsProps>;

declare const AccountSummary: FC<AccountSummaryProps>;

declare const ErrorPopUp: FC<NativeErrorPopUpProps>;

declare const Cashout: React__default.FC<CashoutProps>;

declare const ChatBox: React__default.FC<ChatboxNativeProps>;

declare const LeagueTable: React__default.FC<LeagueTableProps>;

type Props = EvenDataTableProps & {
    bottomSheetFilteringProps?: BottomSheetFilteringProps | null;
};
declare const EventDataTable: React__default.FC<Props>;

declare const HomeCategory: React__default.FC<HomeCategoryWidgetProps>;

interface SportsCategoryItemProps {
    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<SportsCategoryItemProps>;

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

interface StakeInputProps {
    id: string;
    label: string;
    stake: string;
    currency: string;
    disabled: boolean;
    onStakeChange: (value: string) => void;
    onStakeBlur?: () => void;
    onFocus?: () => void;
}
declare function StakeInput({ id, label, stake, currency, disabled, onStakeChange, onStakeBlur, onFocus, }: StakeInputProps): 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;
declare function WetteinsatzDisplay({ state }: {
    state: BetslipState;
}): react_jsx_runtime.JSX.Element;
declare function GewinnchanceDisplay(): 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;
    redirections: {
        redirectToLogin: () => void;
        redirectToDeposit: () => void;
    };
}
declare function BetSlipButton({ isLoggedIn, redirections, isSelfExcluded, processing, checkValidSubmission, isMoneySufficient, onFinishProcessing, }: BetSlipButtonProps): react_jsx_runtime.JSX.Element;

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

declare function SelfExclusion({ selfExclusion, handleSelfExclusion }: SelfExclusionProps): react_jsx_runtime.JSX.Element;

export { Accordion, type AccordionCardProps, type AccordionContextType, type AccordionHeaderPosition, type AccordionHeaderProps, type AccordionIconProps, type AccordionItemProps, type AccordionNativeProps, type AccordionNativeVariant, type AccordionProps, type AccordionVariant, Account, AccountSummary, Badge, type BadgeColor, type BadgeNativeProps, type BadgeSize, type BadgeVariant, BankIndicator, Banner, type BannerNativeProps, type BannerProps, type BannerTextPosition, type Bet$1 as Bet, type BetPackerOddButtonProps, BetPackerTable, type BetPackerTableData, type BetPackerTableNativeProps, BetSlipButton, type BetSlipContextType, type BetSlipItemProps, type BetSlipProps, BetSlipWidget, BetStop, type BetStopProps, type BetStopStatus, type BetType, type BetTypeRTemplateProps, type BothTeamsToScore, type BottomSheetFilteringProps, Button, type ButtonNativeProps, type ButtonProps, type ButtonSize, type ButtonVariant, Card, type CardNativeProps, type CardPadding, type CardShadow, Cashout, type CashoutItem, type CashoutItemComponentProps, type CashoutItemDetailsProps, type CashoutItemLabelProps, type CashoutItemLabelPropsNative, type CashoutProps, ChainedStatus, ChatBox, type ChatboxNativeProps, CheckBox, type CheckBoxDirection, type CheckBoxNativeProps, type CheckBoxSize$1 as CheckBoxSize, CheckBoxStatus, type CheckBoxStatusProps, type CheckBoxSize as CheckBoxStatusSize, type CheckBoxStatusType, type CheckBoxVariant, CheckList, type ColumnProps, type CookiePreferences, Cookies, CookiesContext, type CookiesContextType, CookiesProvider, CountryFlag, type CountryFlagNativeProps, type CountryFlagSize, CustomSearchWidget, DialogBox, type DialogBoxNativeProps, type DoubleChance, Drawer, type DrawerPlacement, type DrawerProps, type DrawerSize, type DrawerVariant, DrawerWrapper, ErrorPopUp, type EvenDataTableProps, EventDataTable, type ExtendedHeaderTemplateProps, type ExtendedSelectTooltipProps, GewinnchanceDisplay, type Handicap, type HeaderColumn, HomeCategory, type HorizontalDirection, index_native as Icons, InfoBox, type InfoBoxDirection, type InfoBoxNativeProps, 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, type KeyBoardTypeProps, type KeyColorScheme, type KeySize, Keyboard, type KeyboardLayout, type KeyboardProps, type KeyboardSkeletonLoaderProps, Label, type LabelNativeProps, type LabelProps, type LabelSize, type LabelVariant, LeagueStatistics, LeagueTable, type LeagueTableItem, type LeagueTableProps, type Leg, type LegacyCashoutItem, LimitDeposit, type LimitDepositNativeProps, type LimitDepositProps, ListGroup, Loader, type LoaderNativeProps, type LoaderPosition, type LoaderSize, LongTermBet, LongTermBetDrawerContent, type LongTermBetDrawerNativeProps, type LongTermBetDrawerProps, type LongTermBetEventType$1 as LongTermBetEventType, type LongTermBetItem$1 as LongTermBetItem, type LongTermBetProps$1 as LongTermBetProps, type LongTermBetSports$1 as LongTermBetSports, type LongTermBetStatus$1 as LongTermBetStatus, MatchBoard, type MatchData, type MatchInfo, MatchProgress, type MessageType, type MessageVariant, type NativeDialogBoxAnimation, type NativeDialogBoxPadding, type NativeDialogBoxSize, type NativeDialogBoxVariant, NavBar, type NavBarNativeProps, type NavBarPosition, type NavBarVariant, NavMenu, type NavMenuDirection, type NavMenuItemIconPosition, type NavMenuItemProps, type NavMenuProps, type NavMenuVariant, NotEnoughMoney, OddDisplay, OddsComparisonSlider, OddsComparisonSliderLoader, type OddsComparisonSliderProps, type OddsDataItem, type Option, type OverUnder, type PercentagePosition, Post, type PrimitiveValue, type ProgressBarDirection, type ProgressBarLabelPosition, type ProgressBarNativeProps, type ProgressBarSize, type ProgressBarVariant, RadioGroup, type RadioGroupNativeProps, type RadioGroupProps, RadioInput, type RadioInputNativeProps, type RadioInputVariant, type RestOfMatch, type Root, 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, SelfExclusion, Separator, type SeparatorProps, type Set, type SetHandicap, type SizeClassProps, Skeleton, type SourceNativeType, type SourceType, type SourceTypeWithVisibleColumns, type SourceTypeWithVisibleNativeColumns, SpecificBetType, SportsCategoryItem, type SportsCategoryItemProps, StakeInput, type StepItem, Stepper, type StepperProps, SuccessBetSlip, SuccessModal, Switch, type SwitchColor, type SwitchNativeProps, type SwitchProps, type SwitchSize, type Tab, Table, type TableProps, type TableSize, Tabs, type TabsProps, type TabsRef, type TdProps, type TeamStatistics, TextArea, type TextAreaNativeProps, type TextAreaSize, type TextAreaStatus, type ThProps, ThemeProvider, Themes, type Tipp, Tooltip, type TooltipAnimation$1 as TooltipAnimation, type TooltipNativeProps, type TooltipPlacement$1 as TooltipPlacement, type TooltipPointerDirection$1 as TooltipPointerDirection, type TooltipPointerDirections, type TooltipPosition, type TooltipPositions, type TooltipTrigger$1 as TooltipTrigger, type TooltipTriggers, type TooltipVariant$1 as TooltipVariant, TopStories, type VerticalDirection, WalletSelector, WalletSwitcher, WetteinsatzDisplay, WinConditionDisplay, defaultNumericKeys, incrementKeys, normalizeSize, secondaryKeys, strToNumber, styles, useCookies, useTheme };
