import React$1 from 'react';
import { ItemInfo, ItemPagingSlicedResult } from '@accelbyte/sdk-platform';
import { z } from 'zod';

interface StoreWidgetProps {
    children: ((props: {
        isSingleGame: boolean;
    }) => JSX.Element) | JSX.Element;
}
declare function StoreWidget({ children }: StoreWidgetProps): JSX.Element;

interface StoreEntryProps {
    children: JSX.Element;
}
declare function StoreEntry({ children }: StoreEntryProps): JSX.Element;

interface WidgetLinkObject {
    link: string;
    icon?: React.ReactNode;
    label: React.ReactNode;
    className?: string;
}

interface Props$8 {
    tabLinks: WidgetLinkObject[];
    children: React$1.ReactNode;
}
declare const MultipleGameStore: ({ tabLinks, children }: Props$8) => JSX.Element | null;

interface Props$7 {
    tabLinks: WidgetLinkObject[];
    children: React$1.ReactNode;
}
declare function SingleGameStore({ tabLinks, children }: Props$7): JSX.Element;

interface SingleGameStoreWrapperChildrenProps {
    baseItem: ItemInfo | null;
}
interface Props$6 {
    isPreviewMode?: boolean;
    children: ((props: SingleGameStoreWrapperChildrenProps) => React$1.ReactNode) | React$1.ReactNode;
}
declare function SingleGameStoreWrapper({ isPreviewMode, children }: Props$6): JSX.Element;

interface Props$5 {
    itemId: string | undefined;
    previewOptions?: {
        isSingleGame?: boolean;
        mode?: 'base' | 'checkout';
    };
}
declare const AppStoreDetailError: ({ error }: {
    error: Error | unknown;
}) => JSX.Element;
declare function AppStoreDetail({ itemId, previewOptions }: Props$5): JSX.Element;

interface Props$4 {
    itemId: string;
}
declare function BundleStoreDetail({ itemId }: Props$4): JSX.Element;

interface Props$3 {
    itemId: string;
}
declare function CodeStoreDetail({ itemId }: Props$3): JSX.Element;

interface Props$2 {
    itemId: string;
    previewMode?: 'checkout';
}
declare function DlcStoreDetail({ itemId, previewMode }: Props$2): JSX.Element;

interface Props$1 {
    itemId: string;
}
declare function IngameItemStoreDetail({ itemId }: Props$1): JSX.Element;

interface Props {
    itemId: string;
}
declare function OptionboxStoreDetail({ itemId }: Props): JSX.Element;

declare const ItemType: z.ZodEnum<["APP", "BUNDLE", "CODE", "COINS", "EXTENSION", "INGAMEITEM", "LOOTBOX", "MEDIA", "OPTIONBOX", "SEASON", "SUBSCRIPTION"]>;
declare type ItemType = z.infer<typeof ItemType>;
declare const AppType: z.ZodEnum<["DEMO", "DLC", "GAME", "SOFTWARE"]>;
declare type AppType = z.infer<typeof AppType>;

declare enum FetchStatus {
    IDLE = "idle",
    FETCHING = "fetching",
    CREATING = "creating",
    UPDATING = "updating",
    PURCHASING = "purchasing",
    CLAIMING = "claiming",
    REDEEMING = "redeeming",
    CANCELLING = "cancelling",
    REQUESTING = "requesting",
    VERIFYING = "verifying",
    DELETING = "deleting",
    DOWNLOADING = "downloading",
    SENDING = "sending"
}
declare type FetchErrorType = Error;

interface StoreListener<State = any> {
    id: string;
    setState: React.Dispatch<React.SetStateAction<State>>;
}
interface StoreContent<State = any> {
    state: State;
    initialState: State;
    subscribers: StoreListener<State>[];
}

interface ListStoreItemsState {
    items: ItemPagingSlicedResult | null;
    itemsFetchStatus: FetchStatus;
    itemsError: FetchErrorType | null;
}
declare const createStoreForItemsStore: () => StoreContent<ListStoreItemsState>;
declare type UseStoreItemsParams = ReturnType<typeof createStoreForItemsStore>;

interface BaseStoreProps {
    page: number;
    itemType: ItemType;
    pageSize?: number;
    country?: string;
    language?: string;
    plan?: string;
    baseAppId?: string;
    children?: React$1.ReactNode;
    store: UseStoreItemsParams;
}
declare type ExposedBaseStoreProps = Pick<BaseStoreProps, 'page' | 'pageSize' | 'country'>;

interface BaseStoreCompactProps {
    baseItem: ItemInfo;
    language?: string;
    withWrapper?: (content: React$1.ReactNode) => React$1.ReactNode;
    noItemMessage?: React$1.ReactNode | string;
    loadingMessage?: React$1.ReactNode | string;
    itemType?: ItemType;
    appType?: AppType;
    pageSize?: number;
    country?: string;
    initialShownItem?: number;
    isPreviewMode?: boolean;
    store: UseStoreItemsParams;
}

declare const AppStore: ({ pageSize, ...props }: ExposedBaseStoreProps) => JSX.Element;
declare const SingleGameAppStore: ({ baseItem }: {
    baseItem: BaseStoreCompactProps['baseItem'] | null;
}) => JSX.Element | null;

declare const CodeStore: ({ pageSize, ...props }: ExposedBaseStoreProps) => JSX.Element;

declare const BundleStore: ({ pageSize, ...props }: ExposedBaseStoreProps) => JSX.Element;
declare const SingleGameBundleStore: ({ baseItem }: {
    baseItem: BaseStoreCompactProps['baseItem'] | null;
}) => JSX.Element | null;

declare const SingleInGameItemsStore: ({ baseItem }: {
    baseItem: BaseStoreCompactProps['baseItem'] | null;
}) => JSX.Element | null;

declare const OptionboxStore: ({ pageSize, ...props }: ExposedBaseStoreProps) => JSX.Element;
declare const SingleGameOptionboxStore: ({ baseItem }: {
    baseItem: BaseStoreCompactProps['baseItem'] | null;
}) => JSX.Element | null;

export { AppStore, AppStoreDetail, AppStoreDetailError, BundleStore, BundleStoreDetail, CodeStore, CodeStoreDetail, DlcStoreDetail, IngameItemStoreDetail, MultipleGameStore, OptionboxStore, OptionboxStoreDetail, SingleGameAppStore, SingleGameBundleStore, SingleGameOptionboxStore, SingleGameStore, SingleGameStoreWrapper, SingleGameStoreWrapperChildrenProps, SingleInGameItemsStore, StoreEntry, StoreWidget };
