@streamlayer/react 1.21.3 → 1.22.1

package/lib/dist/index.d.ts

@@ -0,0 +1,1332 @@
+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-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-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';
+    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 { 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;
+        };
+        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 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, 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 { AbstractStore, mergeStores } from "../../sdk-web-interfaces/src/store/abstract";
+    export { ApiStore } from "../../sdk-web-interfaces/src/store/api";
+    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 = unknown> = (instance: StreamLayerContext, opts: T, done: DoneFn) => void;
+    export const eventBus: EventBus;
+    export type { EventBusEvent, EventBusData, EventBusActionPayload };
+}
+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 "../../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/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;
+    };
+    export interface UIContext {
+        disableApp: () => void;
+        enableApp: () => void;
+        disableAppNotification: () => void;
+        enableAppNotification: () => void;
+        disableOnboardingNotification: () => void;
+        enableOnboardingNotification: () => void;
+        onContentActivate?: OnContentActivateCallback;
+        enableExposedPauseAd: () => void;
+        disableExposedPauseAd: () => 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>>;
+        }
+    }
+    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/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 { 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?: {
+            showPauseButton?: boolean;
+            pauseAdDelay?: number;
+        };
+    };
+    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/useStreamLayerApp" {
+    export { useStreamLayerApp } from '@streamlayer/react-ui/useStreamLayerApp';
+}