import { SDKOptions, AccelbyteSDK } from '@accelbyte/sdk';
import * as React from 'react';
import React__default, { ReactNode, ComponentProps } from 'react';
import { z } from 'zod';
import { RouteComponentProps } from 'react-router-dom';
import { OrderInfo, PaymentOrderDetails, ItemInfo } from '@accelbyte/sdk-platform';
import { AxiosError } from 'axios';
import { Container } from 'unstated';
import { UserResponseV3 } from '@accelbyte/sdk-iam';

declare function AccountRoutesWidget(): (false | JSX.Element)[];

declare const AccountInterceptorsWidget: () => (false | "" | JSX.Element | null | undefined)[] | null;

/**
 * EcommerceRoutesWidget contains Store page AND Payment page.
 */
declare function EcommerceRoutesWidget(): JSX.Element[];

declare const EcommerceInterceptorsWidget: () => JSX.Element[];

declare function ErrorRoutesWidget(): JSX.Element[];

declare enum BackgroundOverlayType {
    GRADIENT = "gradient",
    FULL = "full"
}
declare const LogoVariantConfig: z.ZodObject<{
    /** The index of the image located in the `companyLogo` inside the discovery configs. */
    header: z.ZodNullable<z.ZodNumber>;
    /** The index of the image located in the `companyLogo` inside the discovery configs. */
    footer: z.ZodNullable<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    header: number | null;
    footer: number | null;
}, {
    header: number | null;
    footer: number | null;
}>;
declare type LogoVariantConfig = z.TypeOf<typeof LogoVariantConfig>;
declare const BackgroundConfig: z.ZodObject<{
    background: z.ZodString;
    backgroundOverlay: z.ZodObject<{
        isEnabled: z.ZodBoolean;
        type: z.ZodNativeEnum<typeof BackgroundOverlayType>;
        /** Number between 0-100. The bigger, the more solid the color will be. */
        opacity: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        type: BackgroundOverlayType;
        isEnabled: boolean;
        opacity: number;
    }, {
        type: BackgroundOverlayType;
        isEnabled: boolean;
        opacity: number;
    }>;
}, "strip", z.ZodTypeAny, {
    background: string;
    backgroundOverlay: {
        type: BackgroundOverlayType;
        isEnabled: boolean;
        opacity: number;
    };
}, {
    background: string;
    backgroundOverlay: {
        type: BackgroundOverlayType;
        isEnabled: boolean;
        opacity: number;
    };
}>;
interface BackgroundConfig extends z.TypeOf<typeof BackgroundConfig> {
}

declare const CompanyLogoConfig: z.ZodObject<{
    images: z.ZodArray<z.ZodObject<{
        url: z.ZodString;
        name: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        url: string;
        name: string;
    }, {
        url: string;
        name: string;
    }>, "many">;
    defaultIndex: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    images: {
        url: string;
        name: string;
    }[];
    defaultIndex: number;
}, {
    images: {
        url: string;
        name: string;
    }[];
    defaultIndex: number;
}>;
declare type CompanyLogoConfig = z.TypeOf<typeof CompanyLogoConfig>;
declare const GlobalStyleConfig: z.ZodObject<{
    global: z.ZodObject<{
        colors: z.ZodObject<{
            background: z.ZodObject<{
                hex: z.ZodString;
                rgb: z.ZodObject<{
                    r: z.ZodNumber;
                    g: z.ZodNumber;
                    b: z.ZodNumber;
                    a: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                }, {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                }>;
            }, "strip", z.ZodTypeAny, {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            }, {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            }>;
            card: z.ZodObject<{
                hex: z.ZodString;
                rgb: z.ZodObject<{
                    r: z.ZodNumber;
                    g: z.ZodNumber;
                    b: z.ZodNumber;
                    a: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                }, {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                }>;
            }, "strip", z.ZodTypeAny, {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            }, {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            }>;
            overlay: z.ZodObject<{
                hex: z.ZodString;
                rgb: z.ZodObject<{
                    r: z.ZodNumber;
                    g: z.ZodNumber;
                    b: z.ZodNumber;
                    a: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                }, {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                }>;
            }, "strip", z.ZodTypeAny, {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            }, {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            }>;
            primary: z.ZodObject<{
                hex: z.ZodString;
                rgb: z.ZodObject<{
                    r: z.ZodNumber;
                    g: z.ZodNumber;
                    b: z.ZodNumber;
                    a: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                }, {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                }>;
            }, "strip", z.ZodTypeAny, {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            }, {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            }>;
            secondary: z.ZodObject<{
                hex: z.ZodString;
                rgb: z.ZodObject<{
                    r: z.ZodNumber;
                    g: z.ZodNumber;
                    b: z.ZodNumber;
                    a: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                }, {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                }>;
            }, "strip", z.ZodTypeAny, {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            }, {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            }>;
            text: z.ZodObject<{
                hex: z.ZodString;
                rgb: z.ZodObject<{
                    r: z.ZodNumber;
                    g: z.ZodNumber;
                    b: z.ZodNumber;
                    a: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                }, {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                }>;
            }, "strip", z.ZodTypeAny, {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            }, {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            }>;
        }, "strip", z.ZodTypeAny, {
            text: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            background: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            card: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            overlay: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            primary: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            secondary: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
        }, {
            text: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            background: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            card: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            overlay: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            primary: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            secondary: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
        }>;
        fonts: z.ZodObject<{
            body: z.ZodString;
            customBodyFontUrl: z.ZodString;
            title: z.ZodString;
            customTitleFontUrl: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            body: string;
            customBodyFontUrl: string;
            title: string;
            customTitleFontUrl: string;
        }, {
            body: string;
            customBodyFontUrl: string;
            title: string;
            customTitleFontUrl: string;
        }>;
    }, "strip", z.ZodTypeAny, {
        colors: {
            text: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            background: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            card: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            overlay: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            primary: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            secondary: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
        };
        fonts: {
            body: string;
            customBodyFontUrl: string;
            title: string;
            customTitleFontUrl: string;
        };
    }, {
        colors: {
            text: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            background: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            card: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            overlay: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            primary: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            secondary: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
        };
        fonts: {
            body: string;
            customBodyFontUrl: string;
            title: string;
            customTitleFontUrl: string;
        };
    }>;
}, "strip", z.ZodTypeAny, {
    global: {
        colors: {
            text: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            background: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            card: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            overlay: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            primary: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            secondary: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
        };
        fonts: {
            body: string;
            customBodyFontUrl: string;
            title: string;
            customTitleFontUrl: string;
        };
    };
}, {
    global: {
        colors: {
            text: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            background: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            card: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            overlay: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            primary: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
            secondary: {
                hex: string;
                rgb: {
                    r: number;
                    g: number;
                    b: number;
                    a: number;
                };
            };
        };
        fonts: {
            body: string;
            customBodyFontUrl: string;
            title: string;
            customTitleFontUrl: string;
        };
    };
}>;
interface GlobalStyleConfig extends z.infer<typeof GlobalStyleConfig> {
}
declare const SocialLinkConfig: z.ZodObject<{
    url: z.ZodString;
    platform: z.ZodString;
    apps: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    url: string;
    platform: string;
    apps: string[];
}, {
    url: string;
    platform: string;
    apps: string[];
}>;
interface SocialLinkConfig extends z.infer<typeof SocialLinkConfig> {
}
declare enum TemplateConfig {
    SINGLE = "single-game",
    MULTIPLE = "multiple-game"
}
declare const PlayerPortalFeatureFlagsConfig: z.ZodObject<{
    /**
     * Determines whether "Account Overview" menu in Accounts page is visible or not.
     *
     * Defaults to `true`.
     **/
    isAccountOverviewVisible: z.ZodDefault<z.ZodBoolean>;
    /**
     * Determines whether "Change Password" menu in Accounts page and profile dropdown are visible or not.
     *
     * Defaults to `true`.
     **/
    isChangePasswordVisible: z.ZodDefault<z.ZodBoolean>;
    /**
     * Determines whether "Delete Account" menu in Accounts page is visible or not.
     *
     * Defaults to `true`.
     **/
    isDeleteAccountVisible: z.ZodDefault<z.ZodBoolean>;
    /**
     * Determines whether the "Get Launcher" button is visible or not.
     *
     * Defaults to `true`.
     **/
    isGetLauncherVisible: z.ZodDefault<z.ZodBoolean>;
    /**
     * Determines whether "Linked Accounts" menu in Accounts page is visible or not.
     *
     * Defaults to `true`.
     **/
    isLinkedAccountsVisible: z.ZodDefault<z.ZodBoolean>;
    /**
     * Determines whether "My Profile" menu in Accounts page is visible or not.
     *
     * Defaults to `true`.
     **/
    isMyProfileVisible: z.ZodDefault<z.ZodBoolean>;
    /**
     * Determines whether "Notifications" feature is visible or not.
     *
     * Defaults to `false`.
     **/
    isNotificationsVisible: z.ZodDefault<z.ZodBoolean>;
    /**
     * Determines whether "Order History" menu in Accounts page and profile dropdown are visible or not.
     *
     * Defaults to `true`.
     **/
    isOrderHistoryVisible: z.ZodDefault<z.ZodBoolean>;
    /**
     * Determines whether "Payment Methods" menu in Accounts page is visible or not.
     *
     * Defaults to `true`.
     **/
    isPaymentMethodsVisible: z.ZodDefault<z.ZodBoolean>;
    /**
     * Determines whether "Personal Data" menu in Accounts page is visible or not.
     *
     * Defaults to `true`.
     **/
    isPersonalDataVisible: z.ZodDefault<z.ZodBoolean>;
    /**
     * Determines whether "Legal Agreements" menu in Accounts page is visible or not.
     *
     * Defaults to `true`.
     **/
    isLegalAgreementsVisible: z.ZodDefault<z.ZodBoolean>;
    /**
     * Determines whether "Purchased Items" menu in Accounts page is visible or not.
     *
     * Defaults to `true`.
     **/
    isPurchasedItemsVisible: z.ZodDefault<z.ZodBoolean>;
    /**
     * Determines whether "Redeem Code" menu in Accounts page and profile dropdown are visible or not.
     *
     * Defaults to `true`.
     **/
    isRedeemCodeVisible: z.ZodDefault<z.ZodBoolean>;
    /**
     * Determines whether "Store" feature is visible or not.
     *
     * Defaults to `true`.
     **/
    isStoreVisible: z.ZodDefault<z.ZodBoolean>;
    /**
     * Determines whether "Subscriptions" feature is visible or not.
     *
     * Defaults to `false`.
     **/
    isSubscriptionsVisible: z.ZodDefault<z.ZodBoolean>;
    /**
     * Determines whether "Virtual Currency" feature is visible or not.
     *
     * Defaults to `false`.
     **/
    isVirtualCurrencyVisible: z.ZodDefault<z.ZodBoolean>;
    /**
     * Determines whether the "Twitch Drop" feature is enable or not.
     *
     * Defaults to `true`.
     **/
    isTwitchDropEnabled: z.ZodDefault<z.ZodBoolean>;
    /**
     * Determines whether the "Legal" feature is enable or not.
     * When there is mandatory Legal published, this feature flag will be ignored
     *
     * Defaults to `true`.
     **/
    isLegalEnabled: z.ZodDefault<z.ZodBoolean>;
    /**
     * Determines whether the "Legal" Page is accessible or not from Player Portal.
     *
     * Defaults to `true`.
     **/
    isLegalPageVisible: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    isAccountOverviewVisible: boolean;
    isChangePasswordVisible: boolean;
    isDeleteAccountVisible: boolean;
    isGetLauncherVisible: boolean;
    isLinkedAccountsVisible: boolean;
    isMyProfileVisible: boolean;
    isNotificationsVisible: boolean;
    isOrderHistoryVisible: boolean;
    isPaymentMethodsVisible: boolean;
    isPersonalDataVisible: boolean;
    isLegalAgreementsVisible: boolean;
    isPurchasedItemsVisible: boolean;
    isRedeemCodeVisible: boolean;
    isStoreVisible: boolean;
    isSubscriptionsVisible: boolean;
    isVirtualCurrencyVisible: boolean;
    isTwitchDropEnabled: boolean;
    isLegalEnabled: boolean;
    isLegalPageVisible: boolean;
}, {
    isAccountOverviewVisible?: boolean | undefined;
    isChangePasswordVisible?: boolean | undefined;
    isDeleteAccountVisible?: boolean | undefined;
    isGetLauncherVisible?: boolean | undefined;
    isLinkedAccountsVisible?: boolean | undefined;
    isMyProfileVisible?: boolean | undefined;
    isNotificationsVisible?: boolean | undefined;
    isOrderHistoryVisible?: boolean | undefined;
    isPaymentMethodsVisible?: boolean | undefined;
    isPersonalDataVisible?: boolean | undefined;
    isLegalAgreementsVisible?: boolean | undefined;
    isPurchasedItemsVisible?: boolean | undefined;
    isRedeemCodeVisible?: boolean | undefined;
    isStoreVisible?: boolean | undefined;
    isSubscriptionsVisible?: boolean | undefined;
    isVirtualCurrencyVisible?: boolean | undefined;
    isTwitchDropEnabled?: boolean | undefined;
    isLegalEnabled?: boolean | undefined;
    isLegalPageVisible?: boolean | undefined;
}>;
interface PlayerPortalFeatureFlagsConfig extends z.infer<typeof PlayerPortalFeatureFlagsConfig> {
}

declare const PlayerPortalFooterConfig: z.ZodObject<{
    links: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        link: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        link: string;
        name: string;
        id: string;
    }, {
        link: string;
        name: string;
        id: string;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    links: {
        link: string;
        name: string;
        id: string;
    }[];
}, {
    links: {
        link: string;
        name: string;
        id: string;
    }[];
}>;
interface PlayerPortalFooterConfig extends z.infer<typeof PlayerPortalFooterConfig> {
}

declare const GameList: z.ZodObject<{
    games: z.ZodArray<z.ZodObject<{
        gameId: z.ZodString;
        gameName: z.ZodString;
        namespace: z.ZodString;
        clientId: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        gameId: string;
        gameName: string;
        namespace: string;
        clientId: string;
    }, {
        gameId: string;
        gameName: string;
        namespace: string;
        clientId: string;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    games: {
        gameId: string;
        gameName: string;
        namespace: string;
        clientId: string;
    }[];
}, {
    games: {
        gameId: string;
        gameName: string;
        namespace: string;
        clientId: string;
    }[];
}>;
declare type GameList = z.TypeOf<typeof GameList>;
declare const StreamerInfo: z.ZodObject<{
    isStreamButtonEnabled: z.ZodBoolean;
    streamButton: z.ZodObject<{
        label: z.ZodString;
        url: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        url: string;
        label: string;
    }, {
        url: string;
        label: string;
    }>;
}, "strip", z.ZodTypeAny, {
    isStreamButtonEnabled: boolean;
    streamButton: {
        url: string;
        label: string;
    };
}, {
    isStreamButtonEnabled: boolean;
    streamButton: {
        url: string;
        label: string;
    };
}>;
declare type StreamerInfo = z.TypeOf<typeof StreamerInfo>;

interface SimplifiedPlayerPortalConfigData {
    /**
     * The launcher download link that will be shown on the top-right in the Player Portal.
     **/
    launcherDownloadLink: {
        value: string;
    };
    /**
     * The general metadata that will be applied to the `<head>` tag. Only use this when you are
     * using SSR (Server Side Rendering).
     */
    metaData?: {
        description: string;
        image: string;
        title: string;
    };
    footer: {
        value: PlayerPortalFooterConfig;
    };
    /** The logo variant that will be used in header and footer of the Player Portal. */
    logoVariant: LogoVariantConfig;
}
interface SimplifiedDiscoveryConfigData {
    /**
     * The game ID that is to be shown.
     **/
    appId: {
        value: string;
    };
    /**
     * The avatars list that is going to be used in the profile. Each array element must consist of
     * a URL string.
     **/
    avatarsList: {
        value: string[];
    };
    /**
     * The brand name for the UI. This will affect mainly the browser tab title.
     **/
    brandName: {
        value: string;
    };
    /**
     * The page title for the UI. This will affect mainly the browser tab title.
     **/
    pageTitle: {
        value: string;
    };
    /**
     * The list of company logo images that are used in tandem with the `logoVariant` config
     * in other configs.
     **/
    companyLogo: CompanyLogoConfig;
    /**
     * The copyright text that is going to be shown on the UI footer.
     **/
    copyright: {
        value: string;
    };
    /**
     * The experimental feature flags that can be used to test out features that are not released yet.
     **/
    experimentalFeatureFlags: Record<string, boolean>;
    /**
     * The global page config that is going to be applied to all UIs if the `isLocalStyleEnabled` is not
     * set to `true` in other configs.
     **/
    globalPageConfig: GlobalStyleConfig;
    /**
     * The Player Portal feature flags that can be used to show or hide certain features.
     **/
    ppFeatureFlags: Partial<Omit<PlayerPortalFeatureFlagsConfig, 'isNotificationsVisible' | 'isSubscriptionsVisible' | 'isVirtualCurrencyVisible'>>;
    /**
     * The Support feature flags that can be used to show or hide the Support page in PPv2 and Launcher.
     **/
    supportFeatureFlags: Record<string, boolean>;
    /**
     * The list of social links that are shown in the UI.
     **/
    /**
     * The list of social links that are shown in the UI.
     **/
    socialLinks: {
        value: SocialLinkConfig[];
    };
    /**
     * Specify whether the UI is to be shown for displaying single game or multiple games. Changing this will
     * result in some pages being shown and some other being hidden due to the restrictive nature of the page routes.
     *
     * For example, if the displayed config is single game, then we won't be able to access pages that are only visible
     * in the multiple game and vice versa.
     **/
    templateConfig: {
        value: `${TemplateConfig}`;
    };
}
interface SimplifiedTwitchDropConfigData {
    /** The logo variant that will be used across  the Twitch Drop pages. */
    logoVariant: {
        header: number | null;
    };
    /** List of games that are part of the Twitch Drop event. */
    gameList: GameList;
    /** The configuration for the View Streams button. */
    streamerInfo: StreamerInfo;
    /** The configuration for the background of the Twitch Drop pages. */
    backgroundConfig: BackgroundConfig;
}

interface SdkWidgetProps {
    sdkOptions: SDKOptions;
    onInitializeSDK?: (sdk: AccelbyteSDK) => void;
    basePath?: string;
    widgetOptions?: {
        generalConfigs: SimplifiedDiscoveryConfigData;
        playerPortalConfigs?: SimplifiedPlayerPortalConfigData;
        twitchDropConfigs?: SimplifiedTwitchDropConfigData;
    };
    children?: ReactNode;
}
interface State$4 {
    initialized: boolean;
}
declare class SdkWidget extends React__default.Component<SdkWidgetProps, State$4> {
    constructor(props: SdkWidgetProps);
    componentDidMount(): Promise<void>;
    render(): JSX.Element;
}

declare class AccountDeletionWidget extends React__default.Component {
    render(): JSX.Element;
}

declare class AccountOverviewWidget extends React__default.Component {
    render(): JSX.Element;
}

declare type isVisible = () => boolean | null;
interface NavLinkItem {
    type: 'link';
    key: string;
    to: string;
    label: string;
    isVisible?: isVisible;
}
interface NavLinkSeparator {
    type: 'separator';
    component?: () => JSX.Element;
}

interface Props$a extends RouteComponentProps {
    children: React__default.ReactNode;
    backgroundImageUrl?: string;
    accountPageNav: (NavLinkItem | NavLinkSeparator)[];
}
declare class AccountPageLayoutWidget extends React__default.Component<Props$a> {
    render(): JSX.Element;
}

declare class ChangeEmailWidget extends React__default.Component {
    render(): JSX.Element;
}

declare class ChangePasswordWidget extends React__default.Component {
    render(): JSX.Element;
}

declare class LinkedAccountsWidget extends React__default.Component {
    render(): JSX.Element;
}

declare class OrderHistoryWidget extends React__default.Component<RouteComponentProps> {
    render(): JSX.Element;
}

declare class PaymentMethodsWidget extends React__default.Component {
    render(): JSX.Element;
}

declare class PersonalDataWidget extends React__default.Component<RouteComponentProps> {
    constructor(props: RouteComponentProps);
    componentDidMount(): void;
    render(): JSX.Element;
}

declare class PrivacyRecordsWidget extends React__default.Component {
    render(): JSX.Element;
}

declare class ProfileWidget extends React__default.Component<RouteComponentProps> {
    render(): JSX.Element;
}

declare class PurchasedItemsWidget extends React__default.Component {
    render(): JSX.Element;
}

declare class RedeemCodeWidget extends React__default.Component {
    render(): JSX.Element;
}

interface Props$9 {
    itemId: string;
}
declare class AppDetailWidget extends React__default.Component<Props$9> {
    constructor(props: Props$9);
    render(): JSX.Element;
}

interface Props$8 {
    itemId: string;
}
declare class BundleItemDetailWidget extends React__default.Component<Props$8> {
    constructor(props: Props$8);
    render(): JSX.Element;
}

interface Props$7 {
    itemId: string;
}
declare class CodeItemDetailWidget extends React__default.Component<Props$7> {
    constructor(props: Props$7);
    render(): JSX.Element;
}

interface Props$6 {
    itemId: string;
}
declare class DlcDetailWidget extends React__default.Component<Props$6> {
    constructor(props: Props$6);
    render(): JSX.Element;
}

interface Props$5 {
    itemId: string;
}
declare class IngameItemDetailWidget extends React__default.Component<Props$5> {
    constructor(props: Props$5);
    render(): JSX.Element;
}

interface Props$4 {
    itemId: string;
}
declare class OptionboxItemDetailWidget extends React__default.Component<Props$4> {
    constructor(props: Props$4);
    render(): JSX.Element;
}

declare class StoreWidget extends React__default.Component {
    render(): JSX.Element;
}

declare const PaymentStatus: z.ZodEnum<["DONE", "CANCELLED", "PENDING", "RECEIVED", "UNKNOWN", "FAILED"]>;
declare type PaymentStatus = z.infer<typeof PaymentStatus>;

interface Props$3 {
    itemId: string;
    userId: string;
}
interface State$3 {
    isFetchingOrders: boolean;
    pendingOrders: OrderInfo[] | null;
    paymentInfo: PaymentOrderDetails | null;
    fetchOrdersError: AxiosError | Error | unknown | null;
    isCancelling: boolean;
    cancellationError: AxiosError | Error | unknown | null;
}
declare class PendingOrdersAppManager extends Container<State$3> {
    private readonly sdk;
    private readonly props;
    static DEFAULT_STATE: State$3;
    constructor(sdk: AccelbyteSDK, props: Props$3);
    init(): Promise<void>;
    cancelAll: () => Promise<void>;
    private fetchPendingOrders;
    private fetchPaymentInfo;
}

interface Props$2 {
    orderNo: string;
    userId: string;
}
declare type PendingOrdersAppManagerState = PendingOrdersAppManager['state'];
interface State$2 extends PendingOrdersAppManagerState {
    isFetching: boolean;
    order: OrderInfo | null;
    error: Error | unknown | null;
    orderIsExpired: boolean;
    item: ItemInfo | null;
}
declare class OrderLogic extends Container<State$2> {
    private pendingOrdersAppManager?;
    private readonly props;
    private readonly sdk;
    constructor(props: Props$2);
    init(): Promise<void>;
    orderExpiredTimeout: () => Promise<void>;
    fetchOrder: (orderNo: string) => Promise<void>;
    cancelAllOrders: () => Promise<void> | undefined;
}

declare type Props$1 = {
    orderNo: string;
    redirectPath?: string;
    onClosePaymentDialog?: (orderInfo: {
        status: 'orders-cancelled' | 'payment-processing';
    } | {
        status: 'payment-succeeded';
        order: OrderInfo;
    }) => void;
    isOnlyShowCloseButton?: boolean;
};
declare type State$1 = {
    paymentStatus: PaymentStatus | null;
    orderInfo: OrderInfo | null;
    shouldRedirect: boolean;
    cancellationDialogIsOpen: boolean;
    cancellationNoticeIsOpen: boolean;
    paymentStatusSuccessIsOpen: boolean;
    paymentStatusProcessedCountDownDialogIsOpen: boolean;
    paymentStatusNeedMoreTimeProcessedDialogIsOpen: boolean;
};
declare class PaymentBox extends React__default.Component<Props$1, State$1> {
    logic: OrderLogic;
    constructor(props: Props$1);
    componentDidMount(): void;
    componentWillUnmount(): void;
    render(): React__default.ReactNode;
    private redirectToItemPage;
    private renderRedirection;
    private openCancellationDialog;
    private closeCancellationDialog;
    private renderCancellationDialog;
    private renderExpiryDialog;
    private onClosePaymentSuccessfulDialog;
    private onCloseOrderCancelledDialog;
    private renderCancellationNotice;
    private cancelOrder;
    private onPaymentSuccess;
    private retryCheckOrderStatus;
    private renderPaymentStation;
    private renderOrderContent;
    private restartPayment;
    private onReloadPageWarningWhileStillInCountdown;
}

declare type OnClosePaymentDialogHandler = NonNullable<ComponentProps<typeof PaymentBox>['onClosePaymentDialog']>;
interface PaymentWidgetProps {
    orderNo: string;
    redirectPath?: string;
    onClosePaymentDialog?: OnClosePaymentDialogHandler;
    isOnlyShowCloseButton?: boolean;
}
declare class PaymentWidget extends React__default.Component<PaymentWidgetProps> {
    checkoutJs: HTMLScriptElement;
    constructor(props: PaymentWidgetProps);
    componentDidMount(): void;
    componentWillUnmount(): void;
    render(): JSX.Element;
}

interface Props {
    onLogout?: () => void;
    onUpdateUser?: (user: UserResponseV3 | null) => void;
    isDisableUsername?: boolean;
}
interface State {
    dropdownProfileOpen: boolean;
}
declare class LoginWidget extends React__default.Component<Props, State> {
    dropdownToggleProfileRef: React__default.RefObject<HTMLDivElement>;
    private userAppManager;
    private previousUser;
    constructor(props: Props);
    componentDidMount(): void;
    componentWillUnmount(): void;
    onLoginClick: (returnPath?: string | null | undefined) => void;
    onLogoutClick: () => Promise<void>;
    toggleMenuOff: (event: MouseEvent) => void;
    toggleProfileMenu: () => void;
    render(): JSX.Element;
}

declare global {
    // Some users of this package are don't use "dom" libs
    interface EventTarget {}
    interface EventListener {}
    interface EventListenerObject {}
}

// Type definitions for React Router 5.1


interface WithRouterStatics<C extends React.ComponentType<any>> {
    WrappedComponent: C;
}

declare enum TwitchDropValidateStatus {
    VALIDATING = "validating",
    SUCCESS = "success",
    FAILED = "failed"
}

interface TwitchDropPageProps extends RouteComponentProps {
    className?: string;
}
declare class TwitchDropPage$ extends React__default.Component<TwitchDropPageProps, {
    validateStatus: TwitchDropValidateStatus | null;
    retryStatus: boolean;
}> {
    private readonly linkTwitchManager;
    private readonly linkedAccountManager;
    private readonly appState;
    constructor(props: TwitchDropPageProps);
    componentDidMount(): Promise<void>;
    fetchLinkedTwitchAccount: (user: any) => Promise<void>;
    exchangeTwitchAuthTokenToABToken: (authCode: any) => Promise<void>;
    isReclaim: () => boolean;
    tryLogin(): void;
    getTwitchAuthToken: () => string | null;
    getRequestId: () => string | null;
    requestStatus: (requestId: any) => Promise<void>;
    validateTwitchAccount: (error: any) => void;
    linkAccount: (forceVerify?: boolean, namespace?: string | undefined, clientID?: string | undefined) => void;
    componentWillUnmount(): void;
    getPathname: () => string;
    render(): JSX.Element;
}
declare const TwitchDropPage: React__default.ComponentClass<Pick<TwitchDropPageProps, "className">, any> & WithRouterStatics<typeof TwitchDropPage$>;

interface TwitchDropLandingPageProps {
    onLinkAccount: () => void;
    onReclaim: () => void;
    className?: string;
}
declare function TwitchDropLandingPage({ onLinkAccount, onReclaim, className }: TwitchDropLandingPageProps): JSX.Element;

export { AccountDeletionWidget, AccountInterceptorsWidget, AccountOverviewWidget, AccountPageLayoutWidget, AccountRoutesWidget, AppDetailWidget, BundleItemDetailWidget, ChangeEmailWidget, ChangePasswordWidget, CodeItemDetailWidget, DlcDetailWidget, EcommerceInterceptorsWidget, EcommerceRoutesWidget, ErrorRoutesWidget, IngameItemDetailWidget, LinkedAccountsWidget, LoginWidget, NavLinkItem, NavLinkSeparator, OnClosePaymentDialogHandler, OptionboxItemDetailWidget, OrderHistoryWidget, PaymentMethodsWidget, PaymentWidget, PaymentWidgetProps, PersonalDataWidget, PrivacyRecordsWidget, ProfileWidget, PurchasedItemsWidget, RedeemCodeWidget, SdkWidget, StoreWidget, TwitchDropLandingPage as TwitchDropLandingWidget, TwitchDropPage as TwitchDropWidget };
