declare module "../../sdk-web-types/src/sl-types" {
    import type { StreamSettings as SLStreamSettings, SdkOverlay, Advertising, OrganizationSettings as SLOrganizationSettings } from '@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb';
    import type { GameSettings as IGameSettings } from '@streamlayer/sl-eslib/sdkSettings/game/common/game_common_pb';
    import type { ClientSettings } from '@streamlayer/sl-eslib/sdkSettings/client/client_pb';
    import type { User as ProtoUser } from '@streamlayer/sl-eslib/users/users_common_pb';
    import type { SummaryResponse_ResponseData_SummaryResponseAttributes } from '@streamlayer/sl-eslib/sports/events/events_pb';
    import type { PickHistory as IPickHistory, InsightHistory as IInsightHistory, TweetHistory as ITweetHistory, FeedItem as IFeedItem, FeedItemAttributes as IFeedItemAttributes, InstantView as IInstantView, PromotionHistory as IPromotionHistory } from '@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb';
    import type { LeaderboardItem as ILeaderboardItem } from '@streamlayer/sl-eslib/interactive/leaderboard/interactive.leaderboard_pb';
    import { type ExtendedQuestionAnswer as IExtendedQuestionAnswer, type Question as IQuestion, type ExtendedQuestion as IExtendedQuestion, type QuestionOptions_PromotionOptions, type QuestionOptions_AdCampaigns, type QuestionNotification as IQuestionNotification, type PromotionNotification as IPromotionNotification, type CloseTimer as ICloseTimer, type Promotion as IPromotion, QuestionOptions_GamOptions } from '@streamlayer/sl-eslib/interactive/interactive.common_pb';
    import type { EventWithSeries as IEventWithSeries } from '@streamlayer/sl-eslib/polymarket/sportsClient_pb';
    export type UnionOmit<T, K extends string | number | symbol> = T extends unknown ? Omit<T, K> : never;
    export type NullUnionOmit<T, K extends string | number | symbol> = null extends T ? UnionOmit<NonNullable<T>, K> : UnionOmit<T, K>;
    export type RecursiveOmitHelper<T, K extends string | number | symbol> = {
        [P in keyof T]: RecursiveOmit<T[P], K>;
    };
    export type RecursiveOmit<T, K extends string | number | symbol> = T extends {
        [P in K]: any;
    } ? NullUnionOmit<RecursiveOmitHelper<T, K>, K> : RecursiveOmitHelper<T, K>;
    export type RecursivePartial<T> = T extends object ? {
        [P in keyof T]?: RecursivePartial<T[P]> | null;
    } : T;
    export type PlainMessage<T> = RecursiveOmit<T, '$typeName'>;
    export type PartialMessage<T> = RecursivePartial<RecursiveOmit<T, '$typeName'>>;
    export { QuestionType, QuestionStatus, QuestionImages, QuestionPosition, NotificationPromotionImagePosition, ImagePosition, SilenceSetting, type QuestionOptions, PromotionType, PromotionButtonType, PromotionWallet, PromotionLogoMode, CtaIconMode, NotificationSponsorLogoMode, NotificationEnabled, NotificationUseContentMedia, NotificationUseContentTexts, CloseTimerAuto, NotificationPromotionMode, AutoPlayVideo, PlayVideoMuted, UseAsNotification, AdUnit, } from '@streamlayer/sl-eslib/interactive/interactive.common_pb';
    export { PickHistoryStatus, type SubscriptionResponse, } from '@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb';
    export type PickHistory = PlainMessage<IPickHistory>;
    export type ExtendedQuestionAnswer = PlainMessage<IExtendedQuestionAnswer>;
    export type InsightHistory = PlainMessage<IInsightHistory>;
    export type TweetHistory = PlainMessage<ITweetHistory>;
    export type OrganizationSettings = SLOrganizationSettings;
    export type OrganizationAdvertising = Advertising;
    export type FeatureConfig = PlainMessage<SdkOverlay>;
    export type StreamSettings = SLStreamSettings;
    export type User = {
        data: ProtoUser | undefined;
    };
    export type UserSettings = ClientSettings;
    export type LeaderboardItem = ILeaderboardItem;
    export type FeedItem = PlainMessage<IFeedItem>;
    export type FeedItemAttributes = PlainMessage<IFeedItemAttributes>;
    export type InstantView = PlainMessage<IInstantView>;
    export type GameSettings = PlainMessage<IGameSettings>;
    export type Question = PlainMessage<IQuestion>;
    export type ExtendedQuestion = PlainMessage<IExtendedQuestion>;
    export type CloseTimer = PlainMessage<ICloseTimer>;
    export type PromotionHistory = PlainMessage<IPromotionHistory>;
    export type PromotionOptions = QuestionOptions_PromotionOptions;
    export type Promotion = PlainMessage<IPromotion>;
    export type QuestionNotification = PlainMessage<IQuestionNotification>;
    export type PromotionNotification = PlainMessage<IPromotionNotification>;
    export type EventSummary = PlainMessage<SummaryResponse_ResponseData_SummaryResponseAttributes>;
    export type GamOptions = PlainMessage<QuestionOptions_GamOptions>;
    export type AdCampaigns = PlainMessage<QuestionOptions_AdCampaigns>;
    export type EventWithSeries = PlainMessage<IEventWithSeries>;
    export { SdkOverlayType as FeatureType, type SdkOverlaySettings, type GamesOverlaySettings, } from '@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb';
    export { InvitationFrom } from '@streamlayer/sl-eslib/analytics/v1/invitations/invitations_pb';
    export enum NotificationType {
        ONBOARDING = 1,
        QUESTION = 2,
        QUESTION_RESOLVED = 3
    }
}
declare module "../../sdk-web-types/src/index" {
    export * from "../../sdk-web-types/src/sl-types";
}
declare module "../../sdk-web-logger/src/index" {
    import { pino, ChildLoggerOptions } from 'pino';
    export const createLogger: (name: string, options?: ChildLoggerOptions) => pino.Logger<never, boolean>;
    export type Logger = ReturnType<typeof createLogger>;
}
declare module "../../sdk-web-interfaces/src/event-bus/index" {
    import { InvitationFrom, NotificationType, PromotionType, QuestionType } from '@streamlayer/sdk-web-types';
    const EventBusActions: {
        notification: {
            received: string;
            opened: string;
            rendered: string;
            closed: string;
        };
        app: {
            close: string;
            open: string;
        };
        exposedPauseAd: {
            enabled: string;
            disabled: string;
            closed: string;
            load: string;
            loaded: string;
            rendered: string;
            navigated: string;
        };
        invitation: {
            accepted: string;
            sent: string;
        };
        interactions: {
            tap: string;
            scroll: string;
        };
        advertisement: {
            opened: string;
            'notification-opened': string;
            'notification-received': string;
            received: string;
            viewed: string;
            closed: string;
            videoPlay: string;
            videoEnd: string;
            videoRendered: string;
            videoMuted: string;
            videoUnmuted: string;
            videoReplayed: string;
            quartileCompleted: string;
            buttonSelect: string;
            bannerSelect: string;
            bannerShown: string;
        };
        poll: {
            voted: string;
            navigated: string;
            opened: string;
            viewed: string;
            closed: string;
            received: string;
            onboardingOpen: string;
            onboardingPassed: string;
        };
    };
    export type EventBusActionPayload = {
        notification: {
            type?: NotificationType;
            eventId?: string;
            questionId?: string;
            questionType?: QuestionType;
        };
        app: unknown;
        exposedPauseAd: {
            id?: string;
            parentId?: string;
        };
        invitation: {
            from?: InvitationFrom;
        };
        interactions: unknown;
        advertisement: {
            id: string;
            type?: PromotionType;
            isViewed?: boolean;
            openedFrom?: 'auto' | 'notification';
            hasNotification?: boolean;
            hasBanner?: boolean;
            quartile?: 25 | 50 | 75;
        };
        poll: {
            questionId?: string;
            questionType?: QuestionType;
            questionOpenedFrom?: 'list' | 'notification';
            hasBanner?: boolean;
            isAd?: boolean;
        };
    };
    type EventBusActionsKeys = keyof typeof EventBusActions;
    type EventBusActions<T> = T extends EventBusActionsKeys ? keyof (typeof EventBusActions)[T] : never;
    export type EventBusData<T extends EventBusActionsKeys = EventBusActionsKeys> = {
        type: T;
        action: EventBusActions<T>;
        payload: EventBusActionPayload[T];
        skipAnalytics?: boolean;
    };
    export class EventBusEvent<T extends EventBusActionsKeys = EventBusActionsKeys> extends Event {
        slEventBus?: EventBusData<T>;
        constructor(name: string, payload?: EventBusData<T>);
    }
    export class EventBus {
        private name;
        private listeners;
        constructor(name?: string);
        emit: <K extends EventBusActionsKeys = "notification" | "app" | "exposedPauseAd" | "invitation" | "interactions" | "advertisement" | "poll">(type: K, payload: Omit<EventBusData<K>, "type">) => void;
        listen<T extends EventBusActionsKeys>(listener: (event: EventBusEvent<T>) => void): () => void;
        off<T extends EventBusActionsKeys>(listener: (event: EventBusEvent<T>) => void): void;
        destroy: () => void;
    }
}
declare module "../../sdk-web-interfaces/src/auth" {
    export abstract class AbstractAuthenticationProvider {
        abstract login(...args: unknown[]): Promise<unknown>;
        abstract logout(): void;
        abstract me(): Promise<unknown>;
        abstract isAuthenticated(): Promise<unknown>;
    }
}
declare module "../../sdk-web-interfaces/src/store/abstract" {
    import { type AnyStore } from 'nanostores';
    global {
        interface Window {
            slStore: any;
        }
    }
    /**
     * An abstract store is a wrapper for third-party stores,
     * providing developers with a consistent interface inspired
     * by the "nanostore" pattern. This simplifies
     * interactions with different storage systems.
     */
    export abstract class AbstractStore<T extends AnyStore> {
        /**
         * store instance (nanostores)
         */
        protected readonly store: T;
        protected readonly name: string;
        constructor(store: T, name: string);
        /**
         * return store instance
         */
        getStore(): T;
        /**
         * get all store values
         */
        abstract getValues(): unknown;
        /**
         * get store value by key
         */
        abstract getValue(...args: unknown[]): unknown;
        /**
         * subscribe directly to store changes
         */
        abstract subscribe(...args: unknown[]): void;
        /**
         * unsubscribe directly to store change
         */
        abstract unsubscribe(): void;
    }
    /**
     * Merge multiple stores into a single instance using a single
     * subscribe handler, leveraging the `useStore` method from `@nanostores/react` for React subscriptions.
     */
    export const mergeStores: <T extends Record<string, AbstractStore<AnyStore>>, K = { [Index in keyof T]: ReturnType<T[Index]["getStore"]>["value"]; }>(stores: T) => import("nanostores").ReadableAtom<K>;
}
declare module "../../sdk-web-interfaces/src/store/map" {
    import { type MapStoreKeys, type MapStore as NMapStore } from 'nanostores';
    import { AbstractStore } from "../../sdk-web-interfaces/src/store/abstract";
    interface MapStoreObj {
        [k: string]: any;
    }
    /**
     * Wrapper for nanostores MapStore
     */
    export class MapStore<StoreInterface extends MapStoreObj, StoreInstance extends NMapStore<StoreInterface> = NMapStore<StoreInterface>> extends AbstractStore<StoreInstance> {
        getValues: () => StoreInterface;
        getValue: (key: MapStoreKeys<StoreInstance>) => StoreInterface[MapStoreKeys<StoreInstance>];
        setValue: <Key extends MapStoreKeys<StoreInstance>>(path: Key, value: StoreInterface[Key]) => void;
        subscribe: StoreInstance['subscribe'];
        unsubscribe: () => void;
    }
    /**
     * create map store from nanostores
     */
    export const createMapStore: <Data extends MapStoreObj>(initialData: Data) => import("nanostores").PreinitializedMapStore<Data> & object;
    export type MapStoreListeners<StoreInstance extends NMapStore<StoreInterface>, StoreInterface extends MapStoreObj> = {
        [T in MapStoreKeys<StoreInstance>]: (value: StoreInterface[T]) => void;
    };
}
declare module "../../sdk-web-interfaces/src/feature" {
    import { FeatureConfig as SdkOverlay, SdkOverlaySettings, PlainMessage } from '@streamlayer/sdk-web-types';
    import { WritableAtom } from 'nanostores';
    import { MapStore } from "../../sdk-web-interfaces/src/store/map";
    type FeatureListener = {
        name: string;
        enabled: boolean;
        onEvent: (...args: unknown[]) => void;
    };
    export type FeatureProps = SdkOverlay;
    export enum FeatureSource {
        ORGANIZATION = "ORGANIZATION",
        STREAM = "STREAM"
    }
    type FeatureConfig = Omit<FeatureProps, 'settings'>;
    type FeatureSettings = {
        case: Exclude<SdkOverlaySettings['overlaySettings']['case'], 'inplay' | 'getstream' | undefined>;
        value: PlainMessage<Exclude<SdkOverlaySettings['overlaySettings']['value'], undefined>>;
    };
    export enum FeatureStatus {
        Ready = "ready",
        Suspended = "suspended"
    }
    export class AbstractFeatureUnit {
        status: WritableAtom<FeatureStatus>;
        protected listeners: Set<FeatureListener>;
        constructor();
        registerEventListener(listener: FeatureListener): void;
        enable: () => void;
        disable: () => void;
        protected fireEvent(event: unknown): void;
    }
    export class AbstractFeature<K extends FeatureSettings['case'] | undefined, C extends FeatureSettings['value'] = FeatureSettings['value']> {
        status: WritableAtom<FeatureStatus>;
        source: FeatureSource;
        protected config: MapStore<FeatureConfig>;
        protected settings: MapStore<C>;
        protected listeners: Set<FeatureListener>;
        protected settingsKey: K;
        constructor({ settings, ...config }: FeatureProps, source: FeatureSource);
        get featureConfig(): import("nanostores").MapStore<FeatureConfig>;
        get featureSettings(): import("nanostores").MapStore<C>;
        registerEventListener(listener: FeatureListener): void;
        enable: () => void;
        disable: () => void;
        setFeatureConfig: ({ settings, ...config }: FeatureProps) => void;
        update: (config: FeatureProps, source: FeatureSource) => void;
        protected fireEvent(event: unknown): void;
    }
}
declare module "../../sdk-web-interfaces/src/store/single" {
    import { type StoreValue, type WritableAtom } from 'nanostores';
    import { AbstractStore } from "../../sdk-web-interfaces/src/store/abstract";
    /**
     * Wrapper for nanostores WritableAtom
     */
    export class SingleStore<StoreValue, StoreInstance extends WritableAtom<StoreValue | undefined> = WritableAtom<StoreValue | undefined>> extends AbstractStore<StoreInstance> {
        getValue: () => StoreInstance["value"];
        getValues(): unknown;
        setValue: (value?: StoreValue) => void;
        subscribe: (listener: Parameters<StoreInstance["subscribe"]>[0]) => () => void;
        unsubscribe: () => void;
        listen(listener: Parameters<StoreInstance['subscribe']>[0]): () => void;
        get(): StoreValue | undefined;
    }
    /**
     * create atom store from nanostores
     */
    export const createSingleStore: <T>(initialData: T) => import("nanostores").PreinitializedWritableAtom<T> & object;
    export const createComputedStore: <Value, T extends WritableAtom = WritableAtom<any>>(store: T, mutator: (value: StoreValue<T>) => Value) => import("nanostores").ReadableAtom<Value>;
}
declare module "../../sdk-web-interfaces/src/store/api" {
    import type { FetcherStore, FetcherValue } from '@nanostores/query';
    import { WritableAtom } from 'nanostores';
    import { AbstractStore } from "../../sdk-web-interfaces/src/store/abstract";
    /**
     * Wrapper for @nanostores/query FetcherStore
     */
    export class ApiStore<StoreValue, StoreInstance extends FetcherStore<StoreValue, any> = FetcherStore<StoreValue, any>> extends AbstractStore<StoreInstance> {
        private readonly atomStore;
        constructor(store: StoreInstance, name: string, atomPicker?: (val: FetcherValue<StoreValue, unknown>, prevVal?: string) => string | undefined);
        getAtomStore: () => WritableAtom<string | undefined>;
        getValue: () => Promise<StoreValue | undefined>;
        getValues: () => FetcherValue<StoreValue, any>;
        setValue: (value?: StoreInstance["value"]) => void;
        subscribe: StoreInstance['subscribe'];
        unsubscribe: () => never;
        invalidate: () => void;
        listen: (cb: Parameters<StoreInstance["listen"]>[0]) => () => void;
        get(): void;
        key: () => string | undefined;
        off: () => void;
    }
}
declare module "../../sdk-web-interfaces/src/index" {
    import { FeatureType } from '@streamlayer/sdk-web-types';
    import { EventBus, EventBusEvent, EventBusData, EventBusActionPayload } from "../../sdk-web-interfaces/src/event-bus/index";
    export { AbstractAuthenticationProvider } from "../../sdk-web-interfaces/src/auth";
    export { AbstractFeature, AbstractFeatureUnit, FeatureSource, type FeatureProps, FeatureStatus } from "../../sdk-web-interfaces/src/feature";
    export { MapStore, createMapStore } from "../../sdk-web-interfaces/src/store/map";
    export type { MapStoreListeners } from "../../sdk-web-interfaces/src/store/map";
    export { SingleStore, createSingleStore, createComputedStore } from "../../sdk-web-interfaces/src/store/single";
    export { ApiStore } from "../../sdk-web-interfaces/src/store/api";
    export { AbstractStore, mergeStores } from "../../sdk-web-interfaces/src/store/abstract";
    export type CancelMountCb = () => void;
    export type OnMountCb = () => CancelMountCb;
    export interface StreamLayerSDK {
        onMount: (opts: {
            name: string;
            clear?: boolean;
        }, cb: OnMountCb) => void;
        closeFeature: (destroy?: boolean) => void;
        openFeature: (featureType: FeatureType) => void;
    }
    export interface StreamLayerContext {
        sdk: StreamLayerSDK;
    }
    type DoneFn = Function;
    export type StreamLayerPlugin<T = any> = (instance: StreamLayerContext, opts: T, done: DoneFn) => void;
    export const eventBus: EventBus;
    export type { EventBusEvent, EventBusData, EventBusActionPayload };
}
declare module "../../sdk-web-storage/src/isQuotaExceededError" {
    export function isQuotaExceededError(err: unknown): boolean;
}
declare module "../../sdk-web-storage/src/index" {
    import { isQuotaExceededError } from "../../sdk-web-storage/src/isQuotaExceededError";
    export { isQuotaExceededError };
    export type ArrayWithMinTwoItems = [string, string, ...string[]];
    export class Storage {
        private delimiter;
        private prefix;
        private storage;
        constructor(prefix?: string, storage?: globalThis.Storage);
        clear: () => void;
        protected generateKey: (keyParts: string[]) => string;
        protected write: (keyParts_0: string, keyParts_1: string, ...keyParts: string[]) => void;
        protected read: (...keyParts: string[]) => string | undefined;
        protected remove: (...keyParts: string[]) => void;
    }
}
declare module "../../sdk-web-api/src/utils/devtools" {
    export const __GRPC_DEVTOOLS_EXTENSION__: any;
}
declare module "../../sdk-web-api/src/grpc/retry" {
    import { type Interceptor } from '@connectrpc/connect';
    /**
     * Retry interceptor
     *
     * This interceptor is used to retry requests in case of network errors.
     * Retries are performed according to the exponential backoff algorithm.
     * Allowing retries for the following error codes:
     *  [
     *    Code.Unknown,
     *    Code.Internal,
     *    Code.DeadlineExceeded,
     *    Code.ResourceExhausted,
     *    Code.FailedPrecondition,
     *    Code.Unavailable,
     *    Code.DataLoss,
     *  ]
     *
     * Retry params:
     * - retryAttempts: number of attempts to retry the request, 0 means no retries
     * - retryDelay: max delay between retries in milliseconds
     *
     * Example:
     * ```ts
        const { client, createRequestOptions, queryKey } = transport.createPromiseClient(Leaderboard, {
          method: 'summary',
          params: [$eventId, $userId],
        })
    
        return transport.nanoquery.createFetcherStore(queryKey, {
          fetcher: async (_, __, eventId, userId) => {
            const contextValues = createRequestOptions({
              retryAttempts: 5,
              retryDelay: 10000,
            })
    
            const res = await client.summary(
              {
                eventId: eventId as unknown as bigint,
                userId: userId as string,
              },
              { contextValues }
            )
    
            return res.data?.attributes
          },
        })
     * ```
     */
    export const retry: Interceptor;
}
declare module "../../sdk-web-api/src/grpc/transport" {
    import { MapStore } from '@streamlayer/sdk-web-interfaces';
    import { createRouterTransport, ConnectRouter, Interceptor, Client, UnaryRequest, StreamRequest } from '@connectrpc/connect';
    import { createGrpcWebTransport } from '@connectrpc/connect-web';
    import { type KeyInput, nanoquery } from '@nanostores/query';
    import { PreinitializedWritableAtom } from 'nanostores';
    import { GenService, GenServiceMethods } from '@bufbuild/protobuf/codegenv1';
    import { ServerStreamSubscription, StreamPromiseClient, type ServerStreamSubscriptionOptions } from "../../sdk-web-api/src/grpc/subscription";
    type ServiceType = GenService<GenServiceMethods>;
    type KnownHeaders = {
        authorization?: string;
        sdk?: string;
        'sl-device-id': string;
        'sl-device-os': string;
        'sl-user-id'?: string;
    } & Record<string, string>;
    export type GrpcTransport = Transport['transport'];
    type ReservedHeaders = 'sdk' | 'authorization';
    type ExcludeReservedHeaders<T> = ReservedHeaders extends T ? never : T extends ReservedHeaders ? never : T;
    global {
        interface Window {
            __GRPC_DEVTOOLS_EXTENSION__?: () => import('@connectrpc/connect').Interceptor;
        }
    }
    type NanoqueryReturnType = ReturnType<typeof nanoquery>;
    type NanoqueryObjectType = {
        createFetcherStore: NanoqueryReturnType[0];
        createMutatorStore: NanoqueryReturnType[1];
        utils: NanoqueryReturnType[2];
    };
    export const RequestOptionsKeys: {
        retryAttempts: import("@connectrpc/connect").ContextKey<number>;
        retryDelay: import("@connectrpc/connect").ContextKey<number>;
    };
    type RequestOptionsKey = keyof typeof RequestOptionsKeys;
    type RequestOptions = Partial<Record<RequestOptionsKey, (typeof RequestOptionsKeys)[RequestOptionsKey]['defaultValue']>>;
    export interface DataObj {
        [k: string]: any;
    }
    /**
     * transport wrapper, initialize grpc transport, store headers and connect interceptors
     */
    export class Transport {
        toJsonOptions: {
            emitDefaultValues: boolean;
            enumAsInteger: boolean;
            useProtoFieldName: boolean;
        };
        readonly transport: ReturnType<typeof createGrpcWebTransport>;
        readonly streamTransport: ReturnType<typeof createGrpcWebTransport>;
        nanoquery: NanoqueryObjectType;
        readonly host: string;
        readonly $headers: MapStore<KnownHeaders>;
        storeCache: Map<string, any>;
        protected interceptors: Interceptor[];
        private clients;
        private streamClients;
        private subscriptions;
        private opts?;
        constructor(host: string, opts?: {
            dedupeTime?: number;
            refetchInterval?: number;
            retryable?: boolean;
            webOS?: boolean;
        });
        addSubscription: <T extends ServiceType, Req extends Record<string, unknown>, Res extends Record<string, unknown>, M extends keyof StreamPromiseClient<T> = keyof StreamPromiseClient<T>>(method: StreamPromiseClient<T>[M], params: PreinitializedWritableAtom<Req> | Req, options: ServerStreamSubscriptionOptions) => ServerStreamSubscription<ServiceType, DataObj, DataObj, never, never> | ServerStreamSubscription<T, Req, Res, keyof StreamPromiseClient<T>, StreamPromiseClient<T>[keyof StreamPromiseClient<T>]>;
        removeSubscription: (subscription: ServerStreamSubscription<ServiceType, DataObj, DataObj>) => void;
        disconnect: () => void;
        registerInterceptor: (interceptor: Interceptor) => void;
        removeInterceptor: (interceptor: Interceptor) => void;
        getClient: <T extends ServiceType>(service: T) => Client<T>;
        getStreamClient: <T extends ServiceType>(service: T) => Client<T>;
        createPromiseClient: <T extends ServiceType>(service: T, { params, method }: {
            params?: KeyInput;
            method: keyof T["method"];
        }) => {
            client: Client<T>;
            createRequestOptions: (options: RequestOptions) => import("@connectrpc/connect").ContextValues;
            queryKey: ((string | number | true) | import("nanostores").ReadableAtom<(string | number | true) | (false | void | null | undefined)> | import("@nanostores/query").FetcherStore<any, any>)[];
            queryKeyStr: string;
        };
        createStreamClient: <T extends ServiceType>(service: T) => {
            client: Client<T>;
        };
        setSdkKey: (sdkKey: string) => void;
        setAuth: (token: string, userId: string) => void;
        setHeader: <T extends keyof KnownHeaders = string>(name: ExcludeReservedHeaders<T>, value: string) => void;
        getHeader: (name: keyof KnownHeaders) => string;
        getHeaders: () => KnownHeaders;
        initInterceptors: () => void;
    }
    export class MockTransport extends Transport {
        transport: ReturnType<typeof createRouterTransport>;
        calls: Array<UnaryRequest | StreamRequest>;
        constructor(transport: (router: ConnectRouter) => void);
    }
}
declare module "../../sdk-web-api/src/grpc/subscription" {
    import { Client } from '@connectrpc/connect';
    import { PreinitializedWritableAtom } from 'nanostores';
    import type { GenService, GenServiceMethods } from '@bufbuild/protobuf/codegenv1';
    import type { DescMethodServerStreaming } from '@bufbuild/protobuf';
    import { Transport } from "../../sdk-web-api/src/grpc/transport";
    type ServiceType = GenService<GenServiceMethods>;
    export type StreamMethodsDesc<T extends ServiceType> = {
        [P in keyof T['method'] as T['method'][P] extends DescMethodServerStreaming ? P : never]: T['method'][P] extends DescMethodServerStreaming ? T['method'][P] : never;
    };
    export type StreamPromiseClient<T extends ServiceType> = {
        [P in keyof T['method'] as T['method'][P] extends DescMethodServerStreaming ? P : never]: T['method'][P] extends DescMethodServerStreaming ? Client<T>[P] : never;
    };
    export type StreamMethods<T extends ServiceType> = {
        [P in keyof StreamPromiseClient<T>]: P;
    };
    enum ServerStreamSubscriptionStatus {
        Init = "init",
        Ready = "ready",
        Connecting = "connecting",
        Connected = "connected",
        Disconnected = "disconnected",
        Failed = "failed",
        Reconnect = "reconnect",
        Reconnecting = "reconnecting"
    }
    export type ServerStreamSubscriptionOptions = {
        name: string;
        withStore?: boolean;
        reconnectDelay?: number;
        reconnectMaxDelay?: number;
        reconnectMaxAttempts?: number;
    };
    interface DataObj {
        [k: string]: any;
    }
    export class ServerStreamSubscription<T extends ServiceType, Request extends DataObj, Response extends DataObj, M extends keyof StreamMethods<T> = keyof StreamMethods<T>, Method extends StreamPromiseClient<T>[M] = StreamPromiseClient<T>[M]> {
        params: PreinitializedWritableAtom<Request> | Request;
        private streamCancel?;
        private method;
        private options;
        private headers;
        private listeners;
        private state;
        private store?;
        private paramsListener?;
        private reconnectTimeout?;
        private attempt;
        constructor(headers: Transport['$headers'], method: Method, params: PreinitializedWritableAtom<Request> | Request, options: ServerStreamSubscriptionOptions);
        updateState: (status: ServerStreamSubscriptionStatus) => void;
        addStateLog: (msg: string) => void;
        addListener: (name: string, listener: (response: Response) => void) => (() => void);
        removeListener: (name: string) => void;
        connect: () => void;
        disconnect: () => void;
        /**
         * Reconnect after delay, if not already reconnecting, otherwise do nothing
         */
        reconnect: () => void;
        getStore: () => import("nanostores").WritableAtom<Response | null | undefined> | undefined;
        private onData;
        /**
         * Disconnect if error is not instance of ConnectError or stream is Canceled,
         * Reconnect in other cases
         * Do nothing if error is undefined
         */
        private onStreamError;
    }
}
declare module "../../sdk-web-api/src/grpc/queries/event" {
    import { ReadableAtom } from 'nanostores';
    import type { StreamSettings } from '@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb';
    import { Transport } from "../../sdk-web-api/src/grpc/transport";
    export const $retrieveEventId: ($providerStreamId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<string | undefined, any>;
    export const $streamSettings: (slStreamId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<StreamSettings | undefined, any>;
    export const $streamSummary: (slStreamId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/sports/events/events_pb").SummaryResponse_ResponseData_SummaryResponseAttributes | undefined, any>;
}
declare module "../../sdk-web-api/src/grpc/queries/user" {
    import { ReadableAtom } from 'nanostores';
    import { type BypassAuthRequest } from '@streamlayer/sl-eslib/users/users_pb';
    import { Transport } from "../../sdk-web-api/src/grpc/transport";
    export const $user: ($userToken: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<{
        data: import("@streamlayer/sl-eslib/users/users_common_pb").User | undefined;
    }, any>;
    export const bypassLogin: (transport: Transport) => ({ userKey, schema, init, inviterKey }: Omit<BypassAuthRequest, "$typeName">) => Promise<import("@streamlayer/sl-eslib/users/users_pb").BypassAuthResponse>;
    export const bypassAuth: (transport: Transport, params: {
        userKey?: string;
        schema?: string;
        init?: boolean;
    }) => Promise<import("@streamlayer/sl-eslib/users/users_pb").BypassAuthResponse>;
    export const $userSettings: ($userToken: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/sdkSettings/client/client_pb").ClientSettings | undefined, any>;
    export const register: (transport: Transport, phone: string) => Promise<import("@streamlayer/sl-eslib/users/users_pb").RegisterResponse>;
}
declare module "../../sdk-web-api/src/grpc/queries/organization" {
    import { ReadableAtom } from 'nanostores';
    import { Transport } from "../../sdk-web-api/src/grpc/transport";
    export { $user } from "../../sdk-web-api/src/grpc/queries/user";
    export const $organizationSettings: ($enabled: ReadableAtom<"on" | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<{
        id: string;
        $typeName?: "streamlayer.sdkSettings.OrganizationSettings" | undefined;
        $unknown?: import("@bufbuild/protobuf").UnknownField[];
        overlays?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").SdkOverlay[] | undefined;
        buttonIcon?: string | undefined;
        tinodeHost?: string | undefined;
        audience?: string | undefined;
        name?: string | undefined;
        provider?: string | undefined;
        primaryColor?: string | undefined;
        secondaryColor?: string | undefined;
        moderationPrimaryColor?: string | undefined;
        linkShareIcon?: string | undefined;
        linkShareText?: string | undefined;
        brandDefaults?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").BrandDefaults;
        pub?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").JWK;
        getstream?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").GetStreamSettingsClient;
        publicName?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").PublicName | undefined;
        analyticsVersion?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").AnalyticsVersion | undefined;
    } | undefined, any>;
    export const $organizationAdvertising: ($enabled: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").Advertising | undefined, any>;
}
declare module "../../sdk-web-api/src/grpc/queries/index" {
    export * from "../../sdk-web-api/src/grpc/queries/event";
    export * from "../../sdk-web-api/src/grpc/queries/organization";
    export * from "../../sdk-web-api/src/grpc/queries/user";
}
declare module "../../sdk-web-api/src/index" {
    import { StreamLayerContext } from '@streamlayer/sdk-web-interfaces';
    import { FetcherStore } from '@nanostores/query';
    export type { ServerStreamSubscriptionOptions } from "../../sdk-web-api/src/grpc/subscription";
    export { Transport } from "../../sdk-web-api/src/grpc/transport";
    import { Transport } from "../../sdk-web-api/src/grpc/transport";
    export type { GrpcTransport } from "../../sdk-web-api/src/grpc/transport";
    export * as queries from "../../sdk-web-api/src/grpc/queries/index";
    export type GetApiResponseType<T extends (...args: any[]) => FetcherStore> = ReturnType<ReturnType<T>['get']>['data'];
    module '@streamlayer/sdk-web-interfaces' {
        interface StreamLayerSDK {
            host: string;
        }
        interface StreamLayerContext {
            transport: Transport;
            analyticsTransport: Transport;
        }
    }
    export const transport: (instance: StreamLayerContext, opts: {
        sdkKey: string;
        host: string;
        analyticsHost: string;
        version?: string;
        webOS?: boolean;
    }, done: () => void) => void;
}
declare module "../../sdk-web-core/src/storage" {
    import { Storage } from '@streamlayer/sdk-web-storage';
    export class UserStorage extends Storage {
        constructor();
        setSchema: (value: string) => void;
        getSchema: () => string | undefined;
        setToken: (value: string) => void;
        getToken: () => string | undefined;
        setExternalToken: (value: string) => void;
        getExternalToken: () => string | undefined;
        removeToken: () => void;
    }
}
declare module "../../sdk-web-core/src/store/init" {
    import { SingleStore, ApiStore } from '@streamlayer/sdk-web-interfaces';
    import { Transport } from '@streamlayer/sdk-web-api';
    import { User } from '@streamlayer/sdk-web-types';
    export enum CoreStatus {
        DISABLED = "disabled",
        INITIALIZATION = "initialization",
        READY = "ready",
        FAILED = "failed",
        SUSPENDED = "suspended"
    }
    export const initializeStore: (transport: Transport) => {
        readonly enabled: SingleStore<unknown, import("nanostores").PreinitializedWritableAtom<"on" | undefined> & object>;
        readonly status: SingleStore<unknown, import("nanostores").PreinitializedWritableAtom<CoreStatus> & object>;
        readonly providerStreamId: SingleStore<unknown, import("nanostores").PreinitializedWritableAtom<string | undefined> & object>;
        readonly slStreamId: ApiStore<string | undefined, import("@nanostores/query").FetcherStore<string | undefined, any>>;
        readonly streamSettings: ApiStore<import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").StreamSettings | undefined, import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").StreamSettings | undefined, any>>;
        readonly streamSummary: ApiStore<import("@streamlayer/sl-eslib/sports/events/events_pb").SummaryResponse_ResponseData_SummaryResponseAttributes | undefined, import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/sports/events/events_pb").SummaryResponse_ResponseData_SummaryResponseAttributes | undefined, any>>;
        readonly user: ApiStore<User, import("@nanostores/query").FetcherStore<User, any>>;
        readonly userKey: SingleStore<unknown, import("nanostores").PreinitializedWritableAtom<string | undefined> & object>;
        readonly userToken: SingleStore<unknown, import("nanostores").PreinitializedWritableAtom<string | undefined> & object>;
        readonly userSettings: ApiStore<import("@streamlayer/sl-eslib/sdkSettings/client/client_pb").ClientSettings | undefined, import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/sdkSettings/client/client_pb").ClientSettings | undefined, any>>;
        readonly organizationSettings: ApiStore<{
            id: string;
            $typeName?: "streamlayer.sdkSettings.OrganizationSettings" | undefined;
            $unknown?: import("@bufbuild/protobuf").UnknownField[];
            overlays?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").SdkOverlay[] | undefined;
            buttonIcon?: string | undefined;
            tinodeHost?: string | undefined;
            audience?: string | undefined;
            name?: string | undefined;
            provider?: string | undefined;
            primaryColor?: string | undefined;
            secondaryColor?: string | undefined;
            moderationPrimaryColor?: string | undefined;
            linkShareIcon?: string | undefined;
            linkShareText?: string | undefined;
            brandDefaults?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").BrandDefaults;
            pub?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").JWK;
            getstream?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").GetStreamSettingsClient;
            publicName?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").PublicName | undefined;
            analyticsVersion?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").AnalyticsVersion | undefined;
        } | undefined, import("@nanostores/query").FetcherStore<{
            id: string;
            $typeName?: "streamlayer.sdkSettings.OrganizationSettings" | undefined;
            $unknown?: import("@bufbuild/protobuf").UnknownField[];
            overlays?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").SdkOverlay[] | undefined;
            buttonIcon?: string | undefined;
            tinodeHost?: string | undefined;
            audience?: string | undefined;
            name?: string | undefined;
            provider?: string | undefined;
            primaryColor?: string | undefined;
            secondaryColor?: string | undefined;
            moderationPrimaryColor?: string | undefined;
            linkShareIcon?: string | undefined;
            linkShareText?: string | undefined;
            brandDefaults?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").BrandDefaults;
            pub?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").JWK;
            getstream?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").GetStreamSettingsClient;
            publicName?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").PublicName | undefined;
            analyticsVersion?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").AnalyticsVersion | undefined;
        } | undefined, any>>;
        readonly organizationAdvertising: ApiStore<import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").Advertising | undefined, import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").Advertising | undefined, any>>;
    };
}
declare module "../../sdk-web-core/src/store/store" {
    import type { OrganizationAdvertising, StreamSettings, OrganizationSettings, User, UserSettings, EventSummary } from '@streamlayer/sdk-web-types';
    import { AbstractStore } from '@streamlayer/sdk-web-interfaces';
    import { Transport } from '@streamlayer/sdk-web-api';
    import { ReadableAtom } from 'nanostores';
    import { FetcherValue } from '@nanostores/query';
    import { initializeStore, CoreStatus } from "../../sdk-web-core/src/store/init";
    export { CoreStatus };
    export interface CoreStoreInterface {
        enabled?: 'on';
        status: string;
        userKey?: string;
        userToken?: string;
        organizationSettings?: OrganizationSettings & {
            id: string;
        };
        organizationAdvertising?: OrganizationAdvertising;
        streamSettings?: StreamSettings;
        streamSummary?: EventSummary;
        user?: User;
        userSettings?: UserSettings;
        providerStreamId?: string;
        slStreamId?: string;
    }
    export type StoreObj = ReturnType<typeof initializeStore>;
    export type CoreStores = {
        [Index in keyof StoreObj]: ReturnType<StoreObj[Index]['getStore']>;
    };
    export type CoreStoresValues = {
        [Index in keyof StoreObj]: ReturnType<StoreObj[Index]['getStore']>['value'];
    };
    export type CoreStoreInstance = ReadableAtom<CoreStoresValues>;
    /**
     * @description `CoreStore` is a store that contains all the necessary data for the SDK to work.
     * `CoreStore` is a singleton and is created when the SDK is initialized. It includes the following stores:
     * - `enabled` - the status of the SDK. The SDK is enabled when the `on` value is set.
     * - `status` - the status of the SDK. Can be one of the following values: `disabled`, `initialization`, `ready`, `failed`, `suspended`.
     * - `userKey` - the user key provided by the host.
     * - `userToken` - the user token received from the StreamLayer after login.
     * - `organizationSettings` - the organization settings.
     * - `organizationAdvertising` - the organization advertising.
     * - `streamSettings` - the stream settings.
     * - `user` - the user data.
     * - `userSettings` - the user settings.
     * - `providerStreamId` - the event id provided by the host.
     * - `slStreamId` - the event id received from the StreamLayer, resolved by the `providerStreamId`.
     */
    export class CoreStore extends AbstractStore<CoreStoreInstance> {
        private stores;
        constructor(transport: Transport);
        getValue(): unknown;
        getValues(): {
            readonly enabled: import("@streamlayer/sdk-web-interfaces").SingleStore<unknown, import("nanostores").PreinitializedWritableAtom<"on" | undefined> & object>;
            readonly status: import("@streamlayer/sdk-web-interfaces").SingleStore<unknown, import("nanostores").PreinitializedWritableAtom<CoreStatus> & object>;
            readonly providerStreamId: import("@streamlayer/sdk-web-interfaces").SingleStore<unknown, import("nanostores").PreinitializedWritableAtom<string | undefined> & object>;
            readonly slStreamId: import("@streamlayer/sdk-web-interfaces").ApiStore<string | undefined, import("@nanostores/query").FetcherStore<string | undefined, any>>;
            readonly streamSettings: import("@streamlayer/sdk-web-interfaces").ApiStore<import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").StreamSettings | undefined, import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").StreamSettings | undefined, any>>;
            readonly streamSummary: import("@streamlayer/sdk-web-interfaces").ApiStore<import("@streamlayer/sl-eslib/sports/events/events_pb").SummaryResponse_ResponseData_SummaryResponseAttributes | undefined, import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/sports/events/events_pb").SummaryResponse_ResponseData_SummaryResponseAttributes | undefined, any>>;
            readonly user: import("@streamlayer/sdk-web-interfaces").ApiStore<User, import("@nanostores/query").FetcherStore<User, any>>;
            readonly userKey: import("@streamlayer/sdk-web-interfaces").SingleStore<unknown, import("nanostores").PreinitializedWritableAtom<string | undefined> & object>;
            readonly userToken: import("@streamlayer/sdk-web-interfaces").SingleStore<unknown, import("nanostores").PreinitializedWritableAtom<string | undefined> & object>;
            readonly userSettings: import("@streamlayer/sdk-web-interfaces").ApiStore<import("@streamlayer/sl-eslib/sdkSettings/client/client_pb").ClientSettings | undefined, import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/sdkSettings/client/client_pb").ClientSettings | undefined, any>>;
            readonly organizationSettings: import("@streamlayer/sdk-web-interfaces").ApiStore<{
                id: string;
                $typeName?: "streamlayer.sdkSettings.OrganizationSettings" | undefined;
                $unknown?: import("@bufbuild/protobuf").UnknownField[];
                overlays?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").SdkOverlay[] | undefined;
                buttonIcon?: string | undefined;
                tinodeHost?: string | undefined;
                audience?: string | undefined;
                name?: string | undefined;
                provider?: string | undefined;
                primaryColor?: string | undefined;
                secondaryColor?: string | undefined;
                moderationPrimaryColor?: string | undefined;
                linkShareIcon?: string | undefined;
                linkShareText?: string | undefined;
                brandDefaults?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").BrandDefaults;
                pub?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").JWK;
                getstream?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").GetStreamSettingsClient;
                publicName?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").PublicName | undefined;
                analyticsVersion?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").AnalyticsVersion | undefined;
            } | undefined, import("@nanostores/query").FetcherStore<{
                id: string;
                $typeName?: "streamlayer.sdkSettings.OrganizationSettings" | undefined;
                $unknown?: import("@bufbuild/protobuf").UnknownField[];
                overlays?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").SdkOverlay[] | undefined;
                buttonIcon?: string | undefined;
                tinodeHost?: string | undefined;
                audience?: string | undefined;
                name?: string | undefined;
                provider?: string | undefined;
                primaryColor?: string | undefined;
                secondaryColor?: string | undefined;
                moderationPrimaryColor?: string | undefined;
                linkShareIcon?: string | undefined;
                linkShareText?: string | undefined;
                brandDefaults?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").BrandDefaults;
                pub?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").JWK;
                getstream?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").GetStreamSettingsClient;
                publicName?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").PublicName | undefined;
                analyticsVersion?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").AnalyticsVersion | undefined;
            } | undefined, any>>;
            readonly organizationAdvertising: import("@streamlayer/sdk-web-interfaces").ApiStore<import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").Advertising | undefined, import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").Advertising | undefined, any>>;
        };
        setValue(): void;
        subscribe: (subscribes: Partial<StoreListeners>) => void;
        unsubscribe: () => void;
    }
    export type StoreListeners = {
        [Index in keyof StoreObj]: (params: FetcherValue<CoreStoreInterface[Index]>) => void;
    };
}
declare module "../../sdk-web-core/src/deepLink/index" {
    import { MapStore, StreamLayerContext } from '@streamlayer/sdk-web-interfaces';
    type DeepLinkContextData = {
        handled?: boolean;
        parsed?: boolean;
        used?: boolean;
        data?: DeepLinkUrlParams;
    };
    export type DeepLinkCallback = (deepLinkData: DeepLinkContextData['data']) => void;
    export interface DeepLinkContext {
        $store: DeepLinkContextStore;
        getDeepLinkData: () => Pick<DeepLinkContextData, 'data' | 'used'>;
        deepLinkUsed: (inviterId: string) => void;
        onDeepLinkHandlers: Set<DeepLinkCallback>;
    }
    export type DeepLinkContextStore = MapStore<DeepLinkContextData>;
    module '@streamlayer/sdk-web-interfaces' {
        interface StreamLayerContext {
            deepLink: DeepLinkContext;
        }
        interface StreamLayerSDK {
            addDeepLinkHandler: (cb: DeepLinkCallback) => void;
            removeDeepLinkHandler: (cb: DeepLinkCallback) => void;
            getInviter: () => string | undefined;
            inviteDisplayed: () => void;
        }
    }
    export const DEEP_LINK_PREFIX = "sldl";
    export const DEEP_LINK_USER_ID = "sldl_uid";
    export const DEEP_LINK_EVENT_ID = "sldl_eid";
    export const DEEP_LINK_EXTERNAL_EVENT_ID = "sldl_e_eid";
    export type DeepLinkUrlParams = {
        [DEEP_LINK_USER_ID]?: string;
        [DEEP_LINK_EVENT_ID]?: string;
        [DEEP_LINK_EXTERNAL_EVENT_ID]?: string;
    };
    /**
     * Bypass authorization, used for login with external token.
     * Automatically login user if SDK initialized and READY.
     */
    export const deepLink: (instance: StreamLayerContext, opts: {
        onDeepLinkHandled?: DeepLinkCallback;
    }, done: () => void) => void;
}
declare module "../../sdk-web-core/src/auth/bypass/index" {
    import { AbstractAuthenticationProvider } from '@streamlayer/sdk-web-interfaces';
    import { Transport } from '@streamlayer/sdk-web-api';
    import { CoreStore } from "../../sdk-web-core/src/store/store";
    import { DeepLinkContext } from "../../sdk-web-core/src/deepLink/index";
    /**
     * An authorization service manages user access by providing login, logout,
     * authentication checks, and the ability to revoke access.
     * Subscribed to $userStore and automatically updates the auth header for the Transport.
     */
    export class BypassAuth extends AbstractAuthenticationProvider {
        private readonly $coreStore;
        private readonly deepLink;
        private readonly transport;
        private readonly bypassLogin;
        constructor(store: CoreStore, transport: Transport, deepLink: DeepLinkContext);
        me: () => Promise<import("@streamlayer/sl-eslib/users/users_common_pb").User | undefined>;
        /**
         * Login user by token and schema.
         * On success, save the user and update the token to the Transport, UserStore and cache.
         * @param schema - schema created by the host app and provided to the StreamLayer SDK.
         * @param userKey - user token received from the host app.
         */
        login: (schema: string, userKey: string) => Promise<string>;
        isAuthenticated: () => Promise<import("@streamlayer/sl-eslib/users/users_common_pb").User | undefined>;
        /**
         * Logout user. Clears the all user data from the store.
         */
        logout: () => void;
        /**
         * Soft logout, only clears the StreamLayer user data from the store.
         * Does not clear the external token. And automatically tries to re-login by external token.
         */
        softLogout: () => void;
        /**
         * Try to re-login.
         * - If the user has an token, then try to login by it, by calling the me() method.
         * - If the user has an external token, then try to login by it, by calling the login() method. On failure, logout.
         * -
         * - If no one of the above is true, then logout.
         */
        reLogin: ({ skipLogin }?: {
            skipLogin: boolean;
        }) => Promise<import("@streamlayer/sl-eslib/users/users_common_pb").User | undefined> | undefined;
        /**
         * Write token to the Transport and UserStore
         */
        private saveUser;
        /**
         * Add interceptor to the Transport to handle 401 and 403 errors.
         * If the user is logged in (auth header is set), then make a soft logout.
         */
        private connect;
    }
}
declare module "../../sdk-web-core/src/auth/index" {
    import { StreamLayerContext } from '@streamlayer/sdk-web-interfaces';
    import { CoreStores, StoreObj } from "../../sdk-web-core/src/store/store";
    import { UserStorage } from "../../sdk-web-core/src/storage";
    import { BypassAuth } from "../../sdk-web-core/src/auth/bypass/index";
    module '@streamlayer/sdk-web-interfaces' {
        interface StreamLayerSDK {
            authorizationBypass: (schema: string, userKey: string) => Promise<void>;
            logout: () => void;
            getUserStore: () => CoreStores['user'];
            userId: StoreObj['user']['getAtomStore'];
            isUserAuthorized: BypassAuth['isAuthenticated'];
        }
        interface StreamLayerContext {
            auth: BypassAuth;
        }
    }
    export const storage: UserStorage;
    /**
     * Bypass authorization, used for login with external token.
     * Automatically login user if SDK initialized and READY.
     */
    export const bypass: (instance: StreamLayerContext, opts: unknown, done: () => void) => void;
}
declare module "../../sdk-web-core/src/store/index" {
    import { StreamLayerContext } from '@streamlayer/sdk-web-interfaces';
    import { CoreStore, CoreStores, StoreObj } from "../../sdk-web-core/src/store/store";
    module '@streamlayer/sdk-web-interfaces' {
        interface StreamLayerSDK {
            sdkStore: CoreStores;
            enabled: CoreStores['enabled'];
            status: CoreStores['status'];
            organizationStore: () => CoreStores['organizationSettings'];
            streamStore: () => CoreStores['streamSettings'];
            streamSummary: () => CoreStores['streamSummary'];
        }
        interface ContextConfig {
            skipOrganizationSettings?: boolean;
        }
        interface StreamLayerContext {
            contextConfig?: ContextConfig;
        }
        interface StreamLayerContext {
            store: CoreStore;
            stores: StoreObj;
            storeSubscribe: () => void;
            storeUnsubscribe: () => void;
            contextConfig?: ContextConfig;
        }
    }
    /**
     * store plugin, connect store to sdk
     */
    export const store: (instance: StreamLayerContext, opts: unknown, done: () => void) => void;
}
declare module "../../sdk-web-core/src/videoPlayer/index" {
    import { StreamLayerContext } from '@streamlayer/sdk-web-interfaces';
    export type VideoPlayerData = {
        muted?: boolean;
        play?: boolean;
    };
    export type VideoPlayerCallback = (videoPlayerData: VideoPlayerData) => void;
    export interface VideoPlayerContext {
        controllers: Set<VideoPlayerCallback>;
    }
    module '@streamlayer/sdk-web-interfaces' {
        interface StreamLayerContext {
            videoPlayer: VideoPlayerContext;
        }
        interface StreamLayerSDK {
            addVideoPlayerController: (cb: VideoPlayerCallback) => void;
            removeVideoPlayerController: (cb: VideoPlayerCallback) => void;
            controlVideoPlayer: VideoPlayerCallback;
        }
    }
    export const videoPlayer: (instance: StreamLayerContext, opts: {
        videoPlayerController?: VideoPlayerCallback;
    }, done: () => void) => void;
}
declare module "../../sdk-web-core/src/ui/index" {
    import { createMapStore, StreamLayerContext } from '@streamlayer/sdk-web-interfaces';
    import { QuestionType } from '@streamlayer/sdk-web-types';
    export type UIData = {
        stage: 'activate' | 'deactivate';
        id: string;
        isViewed?: boolean;
        hasNotification?: boolean;
        type: 'advertisement' | 'insight' | 'poll' | 'trivia' | 'prediction' | 'tweet' | 'question';
        hasBanner?: boolean;
    };
    export type OnContentActivateCallback = (renderData: UIData) => void;
    export type UIState = {
        promotionExternalAd?: boolean;
        promotionSidebar?: boolean;
        promotionOverlay?: boolean;
        promotionBanner?: boolean;
        promotionNotification?: boolean;
        app?: boolean;
        appSidebar?: boolean;
        appNotification?: boolean;
        appBanner?: boolean;
        onboardingNotification?: boolean;
        exposedPauseAd?: boolean;
        polymarket?: boolean;
    };
    export interface UIContext {
        disableApp: () => void;
        enableApp: () => void;
        disableAppNotification: () => void;
        enableAppNotification: () => void;
        disableOnboardingNotification: () => void;
        enableOnboardingNotification: () => void;
        onContentActivate?: OnContentActivateCallback;
        enableExposedPauseAd: () => void;
        disableExposedPauseAd: () => void;
        enablePolymarket: () => void;
        disablePolymarket: () => void;
    }
    module '@streamlayer/sdk-web-interfaces' {
        interface StreamLayerContext {
            ui: UIContext;
            onQuestionActivate: (params: Omit<UIData, 'type'> & {
                type?: string;
                questionType?: QuestionType;
            }) => void;
        }
        interface StreamLayerSDK {
            uiState: ReturnType<typeof createMapStore<UIState>>;
            uiHandlers: Pick<UIContext, 'enablePolymarket' | 'disablePolymarket'>;
        }
    }
    export const ui: (instance: StreamLayerContext, opts: {
        onContentActivate?: OnContentActivateCallback;
        withAdNotification?: boolean;
        withAd?: boolean;
    }, done: () => void) => void;
}
declare module "../../sdk-web-core/src/index" {
    import { StreamLayerContext, createMapStore, StreamLayerOptions } from '@streamlayer/sdk-web-interfaces';
    export { bypass, storage } from "../../sdk-web-core/src/auth/index";
    export { store } from "../../sdk-web-core/src/store/index";
    export { deepLink, type DeepLinkUrlParams, type DeepLinkCallback, type DeepLinkContext, DEEP_LINK_PREFIX, DEEP_LINK_USER_ID, DEEP_LINK_EVENT_ID, DEEP_LINK_EXTERNAL_EVENT_ID, } from "../../sdk-web-core/src/deepLink/index";
    export { videoPlayer, type VideoPlayerCallback } from "../../sdk-web-core/src/videoPlayer/index";
    export { ui, type UIContext, type OnContentActivateCallback, type UIData } from "../../sdk-web-core/src/ui/index";
    import "../../sdk-web-core/src/store/index";
    import "../../sdk-web-core/src/auth/index";
    module '@streamlayer/sdk-web-interfaces' {
        interface StreamLayerOptions {
            friendsTab: 'enabled' | 'disabled' | 'activatedGame';
            theme?: string;
            themeMode?: 'light' | 'dark';
            skipOnboarding?: boolean;
            hideFriends?: boolean;
            betPack?: boolean;
            containerId?: string;
            parentClassName?: string;
        }
        interface StreamLayerSDK {
            initializeApp: (contextConfig?: ContextConfig) => Promise<{
                enabled?: boolean;
                err?: string;
            }>;
            disableApp: () => void;
            createEventSession: (providerStreamId: string, internal?: boolean) => void;
            withAuth: boolean;
            options: ReturnType<typeof createMapStore<StreamLayerOptions>>;
        }
        interface StreamLayerContext {
            ready: () => void;
        }
    }
    /**
     * The main application instance is the core of a application. It includes:
     * Store: Manages data storage.
     * Public Methods: Provides a way to interact with the application.
     * Connect Features: Handles communication between components through store.
     * Connect Transport: Handles communication with api.
     * Dependency Injection: Incorporates other necessary instances.
     * Error Handling: Manages errors and logs them.
     * Security: Implements authentication and authorization.
     */
    export const core: (instance: StreamLayerContext, opts: StreamLayerOptions, done: () => void) => void;
}
declare module "app/bet-pack" {
    export type BetPackProps = {
        event: string;
        theme?: string;
        token?: string;
        deviceId?: string;
        sdkKey: string;
        themeMode?: 'light' | 'dark';
        production?: boolean;
    };
    export const BetPackProvider: () => import("react/jsx-runtime").JSX.Element | null;
}
declare module "app/masters" {
    import { Component, ErrorInfo } from 'react';
    import '@streamlayer/react-ui/style.css';
    export { useStreamLayer } from '@streamlayer/react-ui/core/hooks';
    export { MastersStreamLayerProvider } from '@streamlayer/react-ui/masters';
    export class MastersStreamLayerSDKReact extends Component<{
        betPack?: boolean;
        useContainer?: boolean;
    }, {
        hasError: boolean;
    }> {
        constructor(props: {
            betPack?: boolean;
            useContainer?: boolean;
        });
        static getDerivedStateFromError(): {
            hasError: boolean;
        };
        componentDidCatch(error: Error, info: ErrorInfo): void;
        render(): import("react/jsx-runtime").JSX.Element | null;
    }
}
declare module "app/auth" {
    export const StreamLayerLogin: React.FC<{
        token: string;
        schema: string;
    }>;
}
/// <amd-module name="@streamlayer/react/masters" />
declare module "@streamlayer/react/masters" {
    export * from "app/masters";
    export * from "app/auth";
    export { type DeepLinkCallback, type VideoPlayerCallback, type VideoPlayerData, } from '@streamlayer/react-ui/core/provider';
    export const BetPackStandalone: React.FC<{
        production?: boolean;
    }>;
    export const StreamLayerSDKPoints: () => import("react/jsx-runtime").JSX.Element | null;
}
declare module "app/notification" {
    import { StreamLayerSDKNotification as StreamLayerSDKNotificationUI } from '@streamlayer/react-ui/notification';
    export { StreamLayerSDKNotificationUI };
    export const StreamLayerSDKNotification: React.FC<{
        theme?: string;
    }>;
}
declare module "index" {
    export { useStreamLayer, useStreamLayerUI, useStreamLayerTheme } from '@streamlayer/react-ui/core/hooks';
    export { StreamLayerProvider, type DeepLinkCallback, type VideoPlayerCallback, type VideoPlayerData, type ContentActivateParams, type OnContentActivateCallback, } from '@streamlayer/react-ui/core/provider';
    export { StreamLayerThemeProvider } from '@streamlayer/react-ui/ui/theme';
    export { StreamLayerSDKEvent, type StreamLayerSDKEventProps } from '@streamlayer/react-ui/core/event';
    export { StreamLayerSDKReact } from '@streamlayer/react-ui/core/app';
    export { StreamLayerSDKNotification, StreamLayerSDKNotificationUI } from "app/notification";
}
declare module "app/advertisement" {
    import { StreamLayerSDKAdvertisement as StreamLayerSDKAdvertisementUI } from '@streamlayer/react-ui/advertisement';
    export type StreamLayerSDKAdvertisementProps = {
        /**
         * @deprecated Pass event to StreamLayerProvider or StreamLayerSDKEvent component instead, see docs for more info
         */
        event?: string;
        theme?: string;
        sidebar?: 'left' | 'right';
        banner?: 'top' | 'bottom';
        isMobileScreen?: boolean;
        persistent?: boolean;
        notification?: boolean;
        skipAutoClose?: boolean;
        skipTypeCheck?: boolean;
        externalAd?: boolean;
        muted?: boolean;
    };
    export { StreamLayerSDKAdvertisementUI };
    export const StreamLayerSDKAdvertisement: React.FC<StreamLayerSDKAdvertisementProps>;
}
declare module "../../react-ui/src/index" {
    export { App } from 'app/app';
}
declare module "app/app" {
    import type { StreamLayerOptions, StreamLayerSDK } from '@streamlayer/sdk-web-interfaces';
    export const useStreamLayer: () => StreamLayerSDK | null;
    export const useStreamLayerEvent: () => import("react").MutableRefObject<string> | undefined;
    export const useStreamLayerTheme: () => Pick<StreamLayerOptions, "theme" | "themeMode">;
    export const useStreamLayerUI: () => {
        promotionExternalAd?: boolean;
        promotionSidebar?: boolean;
        promotionOverlay?: boolean;
        promotionNotification?: boolean;
        promotionBanner?: boolean;
        app?: boolean;
        appNotification?: boolean;
        appSidebar?: boolean;
        appBanner?: boolean;
        onboardingNotification?: boolean;
    };
    export const StreamLayerSDKReact: React.FC<{
        event?: string;
        topNavigation?: boolean;
        withSidebarNotification?: boolean;
        muted?: boolean;
        theme?: string;
    }>;
}
declare module "app/insight" {
    import { StreamLayerSDKInsight as StreamLayerSDKInsightUI } from '@streamlayer/react-ui/insight';
    export type StreamLayerSDKInsightProps = {
        /**
         * @deprecated Pass event to StreamLayerProvider or StreamLayerSDKEvent component instead, see docs for more info
         */
        event?: string;
        theme?: string;
        hideHeader?: boolean;
        persistent?: boolean;
        skipAutoClose?: boolean;
    };
    export { StreamLayerSDKInsightUI };
    export const StreamLayerSDKInsight: React.FC<StreamLayerSDKInsightProps>;
}
declare module "app/pause-ad" {
    import { type StreamLayerSDKTvOptions } from '@streamlayer/react-ui/webos';
    import { Component } from 'react';
    import { VideoPlayerCallback } from '@streamlayer/react-ui/core/provider';
    export type StreamLayerPauseAdProps = {
        children?: React.ReactNode;
        showPauseAd?: boolean;
        pauseAdVastUrl?: Array<{
            template?: 'default';
            url: string;
        }>;
        onClosePauseAd?: () => void;
        videoPlayerController?: VideoPlayerCallback;
        onRenderPauseAd?: (params: {
            rendered: boolean;
        }) => void;
        options?: StreamLayerSDKTvOptions;
    };
    export class StreamLayerPauseAd extends Component<StreamLayerPauseAdProps, {
        hasError: boolean;
    }> {
        constructor(props: StreamLayerPauseAdProps);
        static getDerivedStateFromError(): {
            hasError: boolean;
        };
        componentDidCatch(error: Error, info: React.ErrorInfo): void;
        render(): string | number | boolean | import("react/jsx-runtime").JSX.Element | Iterable<import("react").ReactNode> | null | undefined;
    }
}
declare module "app/points" {
    export const StreamLayerSDKPoints: React.FC<{
        theme?: string;
    }>;
}
declare module "app/polymarket" {
    import '@streamlayer/sdk-web-core/ui';
    export const StreamLayerSDKPolymarketButton: React.FC<{
        theme?: string;
    }>;
    export const StreamLayerSDKPolymarket: React.FC<{
        theme?: string;
    }>;
}
declare module "app/useStreamLayerApp" {
    export { useStreamLayerApp } from '@streamlayer/react-ui/useStreamLayerApp';
}
