@streamlayer/react 0.28.5 → 0.29.1

package/lib/dist/index.d.ts

@@ -0,0 +1,1530 @@
+/// <reference types="react" />
+declare module "../../sdk-web-types/src/sl-types" {
+    import { PlainMessage } from '@bufbuild/protobuf';
+    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 { UserAttributes } from '@streamlayer/sl-eslib/users/users_common_pb';
+    export { QuestionType, QuestionStatus, QuestionImages, ImagePosition, ExtendedQuestion, SilenceSetting, QuestionOptions, } from '@streamlayer/sl-eslib/interactive/interactive.common_pb';
+    import type { PickHistory as IPickHistory, InsightHistory as IInsightHistory, FeedItemAttributes, InstantView as IInstantView } from '@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb';
+    export { PickHistoryStatus } 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 } from '@streamlayer/sl-eslib/interactive/interactive.common_pb';
+    export type ExtendedQuestionAnswer = PlainMessage<IExtendedQuestionAnswer>;
+    export type PickHistory = PlainMessage<IPickHistory>;
+    export type InsightHistory = PlainMessage<IInsightHistory>;
+    export type OrganizationSettings = SLOrganizationSettings;
+    export type OrganizationAdvertising = Advertising;
+    export type FeatureConfig = SdkOverlay;
+    export type StreamSettings = SLStreamSettings;
+    export type User = UserAttributes;
+    export type UserSettings = ClientSettings;
+    export type LeaderboardItem = ILeaderboardItem;
+    export type FeedItem = PlainMessage<FeedItemAttributes>;
+    export type InstantView = PlainMessage<IInstantView>;
+    export type GameSettings = PlainMessage<IGameSettings>;
+    export { SdkOverlayType as FeatureType, SdkOverlaySettings, GamesOverlaySettings, } from '@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb';
+}
+declare module "../../sdk-web-types/src/index" {
+    export * from "../../sdk-web-types/src/sl-types";
+}
+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, MapStore as NMapStore } from 'nanostores';
+    import { AbstractStore } from "../../sdk-web-interfaces/src/store/abstract";
+    /**
+     * Wrapper for nanostores MapStore
+     */
+    export class MapStore<StoreInterface extends object, 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 object>(initialData: Data) => NMapStore<Data>;
+    export type MapStoreListeners<StoreInstance extends NMapStore<StoreInterface>, StoreInterface extends object> = {
+        [T in MapStoreKeys<StoreInstance>]: (value: StoreInterface[T]) => void;
+    };
+}
+declare module "../../sdk-web-interfaces/src/feature" {
+    import { FeatureConfig as SdkOverlay, SdkOverlaySettings } from '../../sdk-web-types/src/index.ts';
+    import { PlainMessage } from '@bufbuild/protobuf';
+    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 = PlainMessage<SdkOverlay>;
+    export enum FeatureSource {
+        ORGANIZATION = "ORGANIZATION",
+        STREAM = "STREAM"
+    }
+    type FeatureConfig = Omit<FeatureProps, 'settings'>;
+    type FeatureSettings = Exclude<PlainMessage<SdkOverlaySettings>['overlaySettings'], {
+        case: 'inplay';
+    } | {
+        case: 'getstream';
+    } | {
+        case: 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, 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) => WritableAtom<T>;
+    export const createComputedStore: <Value, T extends WritableAtom<any> = WritableAtom<any>>(store: T, mutator: (value: StoreValue<T>) => Value) => import("nanostores").ReadableAtom<Value>;
+}
+declare module "../../sdk-web-interfaces/src/store/api" {
+    import type { FetcherStore } 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?: StoreInstance['value']) => string | undefined);
+        getAtomStore: () => WritableAtom<string | undefined>;
+        getValue: () => Promise<StoreValue | undefined>;
+        getValues: () => never;
+        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 '../../sdk-web-types/src/index.ts';
+    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 interface StreamLayerSDK {
+        openFeature: (featureType: FeatureType) => void;
+        closeFeature: () => void;
+    }
+    export interface StreamLayerContext {
+        sdk: StreamLayerSDK;
+    }
+    type DoneFn = Function;
+    export type StreamLayerPlugin = (instance: StreamLayerContext, opts: unknown, done: DoneFn) => void;
+}
+declare module "../../sdk-web-api/src/utils/devtools" {
+    export const __GRPC_DEVTOOLS_EXTENSION__: any;
+}
+declare module "../../sdk-web-api/src/grpc/transport" {
+    import { createRouterTransport, ConnectRouter, Interceptor, PromiseClient, CallbackClient, UnaryRequest, StreamRequest } from '@connectrpc/connect';
+    import type { ServiceType, Message, PlainMessage } from '@bufbuild/protobuf';
+    import { createGrpcWebTransport } from '@connectrpc/connect-web';
+    import type { KeyInput } from '@nanostores/query';
+    import { nanoquery } from '@nanostores/query';
+    import { Atom } from 'nanostores';
+    import { ServerStreamSubscription, type ServerStreamSubscriptionOptions } from "../../sdk-web-api/src/grpc/subscription";
+    type KnownHeaders = {
+        authorization?: string;
+        sdk?: string;
+        'sl-device-id': 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];
+    };
+    /**
+     * 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 nanoquery: NanoqueryObjectType;
+        readonly host: string;
+        protected interceptors: Interceptor[];
+        private readonly $headers;
+        private clients;
+        private callbackClients;
+        private subscriptions;
+        constructor(host: string);
+        addSubscription: <T extends ServiceType, Req extends Message<Req>, Res extends Message<Res>>(method: CallbackClient<T>[import("./subscription").StreamMethod<T>], params: PlainMessage<Req> | Atom<PlainMessage<Req>>, options: ServerStreamSubscriptionOptions) => ServerStreamSubscription<ServiceType, Message<import("@bufbuild/protobuf").AnyMessage>, Message<import("@bufbuild/protobuf").AnyMessage>, never, never> | ServerStreamSubscription<T, Req, Res, import("./subscription").StreamMethod<T>, CallbackClient<T>[import("./subscription").StreamMethod<T>]>;
+        removeSubscription: (subscription: ServerStreamSubscription<ServiceType, Message, Message>) => void;
+        disconnect: () => void;
+        registerInterceptor: (interceptor: Interceptor) => void;
+        removeInterceptor: (interceptor: Interceptor) => void;
+        getClient: <T extends ServiceType>(service: T) => PromiseClient<T>;
+        getCallbackClient: <T extends ServiceType>(service: T) => CallbackClient<T>;
+        createPromiseClient: <T extends ServiceType>(service: T, { params, method }: {
+            params?: KeyInput | undefined;
+            method: keyof T["methods"];
+        }) => {
+            client: PromiseClient<T>;
+            queryKey: ((string | number | true) | import("nanostores").ReadableAtom<(string | number | true) | (false | void | null | undefined)> | import("@nanostores/query").FetcherStore<any, any>)[];
+            queryKeyStr: string;
+        };
+        createCallbackClient: <T extends ServiceType>(service: T) => {
+            client: CallbackClient<T>;
+        };
+        setSdkKey: (sdkKey: string) => void;
+        setAuth: (token: string, userId: string) => void;
+        setHeader: <T extends string = 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 { CallbackClient } from '@connectrpc/connect';
+    import { Atom } from 'nanostores';
+    import type { ServiceType, Message, PlainMessage, MethodInfoServerStreaming } from '@bufbuild/protobuf';
+    import { Transport } from "../../sdk-web-api/src/grpc/transport";
+    type StreamMethods<T extends ServiceType> = {
+        [P in keyof CallbackClient<T> as T['methods'][P] extends MethodInfoServerStreaming<any, any> ? P : never]: P;
+    };
+    export type StreamMethod<T extends ServiceType> = StreamMethods<T>[keyof StreamMethods<T>] extends keyof CallbackClient<T> ? StreamMethods<T>[keyof StreamMethods<T>] : never;
+    enum ServerStreamSubscriptionStatus {
+        Init = "init",
+        Ready = "ready",
+        Connecting = "connecting",
+        Connected = "connected",
+        Disconnected = "disconnected",
+        Failed = "failed",
+        Reconnecting = "reconnecting"
+    }
+    export type ServerStreamSubscriptionOptions = {
+        name: string;
+        withStore?: boolean;
+    };
+    export class ServerStreamSubscription<T extends ServiceType, Request extends Message<Request>, Response extends Message<Response>, M extends StreamMethod<T> = StreamMethod<T>, Method extends CallbackClient<T>[M] = CallbackClient<T>[M]> {
+        params: Atom<PlainMessage<Request>> | PlainMessage<Request>;
+        private stream?;
+        private method;
+        private name;
+        private headers;
+        private listeners;
+        private state;
+        private store?;
+        constructor(headers: Transport['$headers'], method: Method, params: Atom<PlainMessage<Request>> | PlainMessage<Request>, options: ServerStreamSubscriptionOptions);
+        updateState: (status: ServerStreamSubscriptionStatus) => void;
+        addStateLog: (msg: string) => void;
+        addListener: (name: string, listener: (response: Response) => void) => boolean;
+        removeListener: (name: string) => void;
+        connect: () => void;
+        disconnect: () => void;
+        reconnect: () => void;
+        getStore: () => import("nanostores").WritableAtom<Response | null | undefined> | undefined;
+        private onData;
+        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>;
+}
+declare module "../../sdk-web-api/src/grpc/queries/user" {
+    import { ReadableAtom } from 'nanostores';
+    import type { BypassAuthRequest } from '@streamlayer/sl-eslib/users/users_pb';
+    import { PlainMessage } from '@bufbuild/protobuf';
+    import { Transport } from "../../sdk-web-api/src/grpc/transport";
+    export const $user: ($userToken: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/users/users_pb").MeResponse, any>;
+    export const bypassLogin: (transport: Transport) => ({ userKey, schema, init }: PlainMessage<BypassAuthRequest>) => 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;
+        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 | undefined;
+        pub?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").JWK | undefined;
+        getstream?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").GetStreamSettingsClient | 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 '../../sdk-web-interfaces/src/index.ts';
+    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;
+        }
+    }
+    export const transport: (instance: StreamLayerContext, opts: {
+        sdkKey: string;
+        host: string;
+    }, done: () => void) => void;
+}
+declare module "../../sdk-web-storage/src/index" {
+    export class Storage {
+        private delimiter;
+        private prefix;
+        constructor(prefix?: string);
+        clear: () => void;
+        protected generateKey: (keyParts: string[]) => string;
+        protected write: (keyParts_0: string, keyParts_1: string, ...keyParts_2: string[]) => void;
+        protected read: (...keyParts: string[]) => string | undefined;
+        protected remove: (...keyParts: string[]) => void;
+    }
+}
+declare module "../../sdk-web-core/src/storage" {
+    import { Storage } from '../../sdk-web-storage/src/index.ts';
+    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 '../../sdk-web-interfaces/src/index.ts';
+    import { Transport } from '../../sdk-web-api/src/index.ts';
+    export enum CoreStatus {
+        DISABLED = "disabled",
+        INITIALIZATION = "initialization",
+        READY = "ready",
+        FAILED = "failed",
+        SUSPENDED = "suspended"
+    }
+    export const initializeStore: (transport: Transport) => {
+        readonly enabled: SingleStore<unknown, import("nanostores").WritableAtom<"on" | undefined>>;
+        readonly status: SingleStore<unknown, import("nanostores").WritableAtom<CoreStatus>>;
+        readonly providerStreamId: SingleStore<unknown, import("nanostores").WritableAtom<string | undefined>>;
+        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 user: ApiStore<import("@streamlayer/sl-eslib/users/users_pb").MeResponse | undefined, import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/users/users_pb").MeResponse | undefined, any>>;
+        readonly userKey: SingleStore<unknown, import("nanostores").WritableAtom<string | undefined>>;
+        readonly userToken: SingleStore<unknown, import("nanostores").WritableAtom<string | undefined>>;
+        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;
+            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 | undefined;
+            pub?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").JWK | undefined;
+            getstream?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").GetStreamSettingsClient | undefined;
+        } | undefined, import("@nanostores/query").FetcherStore<{
+            id: string;
+            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 | undefined;
+            pub?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").JWK | undefined;
+            getstream?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").GetStreamSettingsClient | 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 } from '../../sdk-web-types/src/index.ts';
+    import { AbstractStore } from '../../sdk-web-interfaces/src/index.ts';
+    import { Transport } from '../../sdk-web-api/src/index.ts';
+    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;
+        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('../../sdk-web-interfaces/src/index.ts').SingleStore<unknown, import("nanostores").WritableAtom<"on" | undefined>>;
+            readonly status: import('../../sdk-web-interfaces/src/index.ts').SingleStore<unknown, import("nanostores").WritableAtom<CoreStatus>>;
+            readonly providerStreamId: import('../../sdk-web-interfaces/src/index.ts').SingleStore<unknown, import("nanostores").WritableAtom<string | undefined>>;
+            readonly slStreamId: import('../../sdk-web-interfaces/src/index.ts').ApiStore<string | undefined, import("@nanostores/query").FetcherStore<string | undefined, any>>;
+            readonly streamSettings: import('../../sdk-web-interfaces/src/index.ts').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 user: import('../../sdk-web-interfaces/src/index.ts').ApiStore<import("@streamlayer/sl-eslib/users/users_pb").MeResponse | undefined, import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/users/users_pb").MeResponse | undefined, any>>;
+            readonly userKey: import('../../sdk-web-interfaces/src/index.ts').SingleStore<unknown, import("nanostores").WritableAtom<string | undefined>>;
+            readonly userToken: import('../../sdk-web-interfaces/src/index.ts').SingleStore<unknown, import("nanostores").WritableAtom<string | undefined>>;
+            readonly userSettings: import('../../sdk-web-interfaces/src/index.ts').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('../../sdk-web-interfaces/src/index.ts').ApiStore<{
+                id: string;
+                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 | undefined;
+                pub?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").JWK | undefined;
+                getstream?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").GetStreamSettingsClient | undefined;
+            } | undefined, import("@nanostores/query").FetcherStore<{
+                id: string;
+                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 | undefined;
+                pub?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").JWK | undefined;
+                getstream?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").GetStreamSettingsClient | undefined;
+            } | undefined, any>>;
+            readonly organizationAdvertising: import('../../sdk-web-interfaces/src/index.ts').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/auth/bypass/index" {
+    import { AbstractAuthenticationProvider } from '../../sdk-web-interfaces/src/index.ts';
+    import { Transport } from '../../sdk-web-api/src/index.ts';
+    import { CoreStore } from "../../sdk-web-core/src/store/store";
+    /**
+     * 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 transport;
+        private readonly bypassLogin;
+        constructor(store: CoreStore, transport: Transport);
+        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: () => Promise<void> | 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 '../../sdk-web-interfaces/src/index.ts';
+    import { CoreStores } 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'];
+            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 '../../sdk-web-interfaces/src/index.ts';
+    import { CoreStore, CoreStores, StoreObj, CoreStoreInstance } from "../../sdk-web-core/src/store/store";
+    module '@streamlayer/sdk-web-interfaces' {
+        interface StreamLayerSDK {
+            sdkStore: CoreStoreInstance;
+            enabled: CoreStores['enabled'];
+            status: CoreStores['status'];
+            organizationStore: () => CoreStores['organizationSettings'];
+            streamStore: () => CoreStores['streamSettings'];
+        }
+        interface StreamLayerContext {
+            store: CoreStore;
+            stores: StoreObj;
+            storeSubscribe: () => void;
+            storeUnsubscribe: () => void;
+        }
+    }
+    /**
+     * store plugin, connect store to sdk
+     */
+    export const store: (instance: StreamLayerContext, opts: unknown, done: () => void) => void;
+}
+declare module "../../sdk-web-core/src/index" {
+    import { StreamLayerContext } from '../../sdk-web-interfaces/src/index.ts';
+    export { bypass, storage } from "../../sdk-web-core/src/auth/index";
+    export { store } from "../../sdk-web-core/src/store/index";
+    import "../../sdk-web-core/src/store/index";
+    import "../../sdk-web-core/src/auth/index";
+    module '@streamlayer/sdk-web-interfaces' {
+        interface StreamLayerSDK {
+            initializeApp: () => Promise<{
+                enabled?: boolean;
+                err?: string;
+            }>;
+            disableApp: () => void;
+            createEventSession: (providerStreamId: string) => 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: unknown, done: () => void) => void;
+}
+declare module "../../react-ui/src/index" {
+    export const Demo: React.FC<{
+        sdk: unknown;
+    }>;
+    export { StreamLayerThemeProvider } from 'ui/theme';
+}
+declare module "../../sdk-web-logger/src/index" {
+    import { pino, ChildLoggerOptions } from 'pino';
+    export const createLogger: (name: string, options?: ChildLoggerOptions) => pino.Logger<{
+        level: "trace";
+    } & ChildLoggerOptions>;
+    export type Logger = ReturnType<typeof createLogger>;
+}
+declare module "../../sdk-web-notifications/src/queue/index" {
+    import { SingleStore, createComputedStore } from '../../sdk-web-interfaces/src/index.ts';
+    import { Notification } from "../../sdk-web-notifications/src/index";
+    export type NotificationsQueueOptions = {
+        concurrency: number;
+        animationDelay: number;
+    };
+    export type NotificationsList = ReturnType<typeof createComputedStore<Notification[]>>;
+    export class NotificationsQueue {
+        notificationsList: ReturnType<SingleStore<Map<Notification['id'], Notification>>['getStore']>;
+        private notifications;
+        private store;
+        private timeouts;
+        private waitingQueue;
+        private activeQueue;
+        private options;
+        private logger;
+        constructor(options: NotificationsQueueOptions);
+        addToQueue: (notification: Notification) => void;
+        tickWaitingQueue: () => void;
+        tickActiveQueue: (notificationId: string) => void;
+        closeNotification: (notificationId: string) => void;
+    }
+}
+declare module "../../sdk-web-notifications/src/storage" {
+    import { Storage } from '../../sdk-web-storage/src/index.ts';
+    export class NotificationStorage extends Storage {
+        constructor();
+        setOpened: (notificationId: string) => void;
+        isOpened: (notificationId: string) => string | undefined;
+        clearNotification: () => void;
+    }
+}
+declare module "../../sdk-web-notifications/src/notifications" {
+    import { InstantView, QuestionType, GameSettings } from '../../sdk-web-types/src/index.ts';
+    import { NotificationsQueue, NotificationsQueueOptions } from "../../sdk-web-notifications/src/queue/index";
+    export type NotificationData = {
+        questionType: QuestionType;
+        question?: {
+            title: string;
+        };
+        insight?: InstantView;
+        onboarding?: GameSettings;
+    };
+    export enum NotificationType {
+        ONBOARDING = 1,
+        QUESTION = 2,
+        QUESTION_RESOLVED = 3
+    }
+    export type Notification<M extends Record<string, Function> = never> = {
+        autoHideDuration: number;
+        delay?: number;
+        hiding?: boolean;
+        type: NotificationType;
+        action?: (...args: unknown[]) => void;
+        close?: (...args: unknown[]) => void;
+        methods?: M;
+        data: NotificationData;
+        id: string;
+    };
+    /**
+     * @description app notifications (inapp)
+     */
+    export class Notifications {
+        queue: NotificationsQueue;
+        private storage;
+        constructor(options?: Partial<NotificationsQueueOptions>);
+        add: (notification: Notification) => void;
+        close: (notificationId: string) => void;
+        getQueueStore: () => import("nanostores").WritableAtom<Map<string, Notification> | undefined>;
+        markAsViewed: (notificationId: string) => void;
+    }
+}
+declare module "../../sdk-web-notifications/src/index" {
+    import { StreamLayerContext } from '../../sdk-web-interfaces/src/index.ts';
+    import { Notifications } from "../../sdk-web-notifications/src/notifications";
+    export { type Notification, type NotificationData, NotificationType, Notifications } from "../../sdk-web-notifications/src/notifications";
+    export { type NotificationsList } from "../../sdk-web-notifications/src/queue/index";
+    export type NotificationsStore = ReturnType<Notifications['getQueueStore']>;
+    module '@streamlayer/sdk-web-interfaces' {
+        interface StreamLayerContext {
+            notifications: Notifications;
+            addNotification: Notifications['add'];
+        }
+        interface StreamLayerSDK {
+            getNotificationsStore: Notifications['getQueueStore'];
+        }
+    }
+    /**
+     * notifications plugin, connect notifications to sdk
+     */
+    export const notifications: (instance: StreamLayerContext, opts: unknown, done: () => void) => void;
+}
+declare module "../../feature-gamification/src/queries/leaderboard" {
+    import type { Transport } from '../../sdk-web-api/src/index.ts';
+    import { ReadableAtom } from 'nanostores';
+    import { ListRequest } from '@streamlayer/sl-eslib/interactive/leaderboard/interactive.leaderboard_pb';
+    import { PartialMessage } from '@bufbuild/protobuf';
+    export { LeaderboardItem } from '@streamlayer/sl-eslib/interactive/leaderboard/interactive.leaderboard_pb';
+    export const $userSummary: ($eventId: ReadableAtom<string | undefined>, $userId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/interactive/leaderboard/interactive.leaderboard_pb").LeaderboardSummaryItem | undefined, any>;
+    export const $leaderboardList: ($eventId: ReadableAtom<string | undefined>, _: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/interactive/leaderboard/interactive.leaderboard_pb").ListResponse_ListResponseData[], any>;
+    export const createLeaderboardListFetch: (transport: Transport) => (params: PartialMessage<ListRequest>) => Promise<import("@streamlayer/sl-eslib/interactive/leaderboard/interactive.leaderboard_pb").ListResponse>;
+}
+declare module "../../feature-gamification/src/queries/moderation" {
+    import type { Transport } from '../../sdk-web-api/src/index.ts';
+    import { ReadableAtom } from 'nanostores';
+    export const $moderation: (slStreamId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").InteractiveFeed | undefined, any>;
+}
+declare module "../../feature-gamification/src/queries/index" {
+    import type { Transport } from '../../sdk-web-api/src/index.ts';
+    import { ReadableAtom } from 'nanostores';
+    import type { SubscriptionRequest, SubscriptionResponse, VotingSubscriptionRequest, VotingSubscriptionResponse, QuestionSubscriptionRequest, QuestionSubscriptionResponse } from '@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb';
+    export const $activeQuestion: (slStreamId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedQuestion | undefined, any>;
+    export const feedSubscription: ($slStreamId: ReadableAtom<string | undefined>, transport: Transport) => import("../../../sdk-web-api/src/grpc/subscription").ServerStreamSubscription<import("@bufbuild/protobuf").ServiceType, import("@bufbuild/protobuf").Message<import("@bufbuild/protobuf").AnyMessage>, import("@bufbuild/protobuf").Message<import("@bufbuild/protobuf").AnyMessage>, never, never> | import("../../../sdk-web-api/src/grpc/subscription").ServerStreamSubscription<{
+        readonly typeName: "streamlayer.interactive.feed.Feed";
+        readonly methods: {
+            readonly get: {
+                readonly name: "Get";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").GetRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").GetResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly subscription: {
+                readonly name: "Subscription";
+                readonly I: typeof SubscriptionRequest;
+                readonly O: typeof SubscriptionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.ServerStreaming;
+            };
+            readonly votingSubscription: {
+                readonly name: "VotingSubscription";
+                readonly I: typeof VotingSubscriptionRequest;
+                readonly O: typeof VotingSubscriptionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.ServerStreaming;
+            };
+            readonly questionSubscription: {
+                readonly name: "QuestionSubscription";
+                readonly I: typeof QuestionSubscriptionRequest;
+                readonly O: typeof QuestionSubscriptionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.ServerStreaming;
+            };
+            readonly questionByUser: {
+                readonly name: "QuestionByUser";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").QuestionByUserRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").QuestionByUserResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly syncQuestion: {
+                readonly name: "SyncQuestion";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SyncQuestionRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SyncQuestionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly getQuestion: {
+                readonly name: "GetQuestion";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").GetQuestionRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").GetQuestionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly questionDetail: {
+                readonly name: "QuestionDetail";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").QuestionDetailRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").QuestionDetailResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly submitAnswer: {
+                readonly name: "SubmitAnswer";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SubmitAnswerRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SubmitAnswerResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly submitInplay: {
+                readonly name: "SubmitInplay";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SubmitInplayRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SubmitInplayResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly skipQuestion: {
+                readonly name: "SkipQuestion";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SkipQuestionRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SkipQuestionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly pickHistory: {
+                readonly name: "PickHistory";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").PickHistoryRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").PickHistoryResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly insightHistory: {
+                readonly name: "InsightHistory";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").InsightHistoryRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").InsightHistoryResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly tweetHistory: {
+                readonly name: "TweetHistory";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").TweetHistoryRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").TweetHistoryResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly promotionHistory: {
+                readonly name: "PromotionHistory";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").PromotionHistoryRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").PromotionHistoryResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly list: {
+                readonly name: "List";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedListRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedListResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly feedSubscription: {
+                readonly name: "FeedSubscription";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.ServerStreaming;
+            };
+        };
+    }, SubscriptionRequest, SubscriptionResponse, "subscription" | "votingSubscription" | "questionSubscription" | "feedSubscription", ((request: import("@bufbuild/protobuf").PartialMessage<SubscriptionRequest>, messageCallback: (response: SubscriptionResponse) => void, closeCallback: (error: import("@connectrpc/connect").ConnectError | undefined) => void, options?: import("@connectrpc/connect").CallOptions | undefined) => () => void) | ((request: import("@bufbuild/protobuf").PartialMessage<VotingSubscriptionRequest>, messageCallback: (response: VotingSubscriptionResponse) => void, closeCallback: (error: import("@connectrpc/connect").ConnectError | undefined) => void, options?: import("@connectrpc/connect").CallOptions | undefined) => () => void) | ((request: import("@bufbuild/protobuf").PartialMessage<QuestionSubscriptionRequest>, messageCallback: (response: QuestionSubscriptionResponse) => void, closeCallback: (error: import("@connectrpc/connect").ConnectError | undefined) => void, options?: import("@connectrpc/connect").CallOptions | undefined) => () => void) | ((request: import("@bufbuild/protobuf").PartialMessage<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionRequest>, messageCallback: (response: import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionResponse) => void, closeCallback: (error: import("@connectrpc/connect").ConnectError | undefined) => void, options?: import("@connectrpc/connect").CallOptions | undefined) => () => void)>;
+    export const votingSubscription: (params: {
+        questionId: string;
+        feedId: string;
+    }, transport: Transport) => import("../../../sdk-web-api/src/grpc/subscription").ServerStreamSubscription<import("@bufbuild/protobuf").ServiceType, import("@bufbuild/protobuf").Message<import("@bufbuild/protobuf").AnyMessage>, import("@bufbuild/protobuf").Message<import("@bufbuild/protobuf").AnyMessage>, never, never> | import("../../../sdk-web-api/src/grpc/subscription").ServerStreamSubscription<{
+        readonly typeName: "streamlayer.interactive.feed.Feed";
+        readonly methods: {
+            readonly get: {
+                readonly name: "Get";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").GetRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").GetResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly subscription: {
+                readonly name: "Subscription";
+                readonly I: typeof SubscriptionRequest;
+                readonly O: typeof SubscriptionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.ServerStreaming;
+            };
+            readonly votingSubscription: {
+                readonly name: "VotingSubscription";
+                readonly I: typeof VotingSubscriptionRequest;
+                readonly O: typeof VotingSubscriptionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.ServerStreaming;
+            };
+            readonly questionSubscription: {
+                readonly name: "QuestionSubscription";
+                readonly I: typeof QuestionSubscriptionRequest;
+                readonly O: typeof QuestionSubscriptionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.ServerStreaming;
+            };
+            readonly questionByUser: {
+                readonly name: "QuestionByUser";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").QuestionByUserRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").QuestionByUserResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly syncQuestion: {
+                readonly name: "SyncQuestion";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SyncQuestionRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SyncQuestionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly getQuestion: {
+                readonly name: "GetQuestion";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").GetQuestionRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").GetQuestionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly questionDetail: {
+                readonly name: "QuestionDetail";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").QuestionDetailRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").QuestionDetailResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly submitAnswer: {
+                readonly name: "SubmitAnswer";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SubmitAnswerRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SubmitAnswerResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly submitInplay: {
+                readonly name: "SubmitInplay";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SubmitInplayRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SubmitInplayResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly skipQuestion: {
+                readonly name: "SkipQuestion";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SkipQuestionRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SkipQuestionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly pickHistory: {
+                readonly name: "PickHistory";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").PickHistoryRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").PickHistoryResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly insightHistory: {
+                readonly name: "InsightHistory";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").InsightHistoryRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").InsightHistoryResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly tweetHistory: {
+                readonly name: "TweetHistory";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").TweetHistoryRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").TweetHistoryResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly promotionHistory: {
+                readonly name: "PromotionHistory";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").PromotionHistoryRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").PromotionHistoryResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly list: {
+                readonly name: "List";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedListRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedListResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly feedSubscription: {
+                readonly name: "FeedSubscription";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.ServerStreaming;
+            };
+        };
+    }, VotingSubscriptionRequest, VotingSubscriptionResponse, "subscription" | "votingSubscription" | "questionSubscription" | "feedSubscription", ((request: import("@bufbuild/protobuf").PartialMessage<SubscriptionRequest>, messageCallback: (response: SubscriptionResponse) => void, closeCallback: (error: import("@connectrpc/connect").ConnectError | undefined) => void, options?: import("@connectrpc/connect").CallOptions | undefined) => () => void) | ((request: import("@bufbuild/protobuf").PartialMessage<VotingSubscriptionRequest>, messageCallback: (response: VotingSubscriptionResponse) => void, closeCallback: (error: import("@connectrpc/connect").ConnectError | undefined) => void, options?: import("@connectrpc/connect").CallOptions | undefined) => () => void) | ((request: import("@bufbuild/protobuf").PartialMessage<QuestionSubscriptionRequest>, messageCallback: (response: QuestionSubscriptionResponse) => void, closeCallback: (error: import("@connectrpc/connect").ConnectError | undefined) => void, options?: import("@connectrpc/connect").CallOptions | undefined) => () => void) | ((request: import("@bufbuild/protobuf").PartialMessage<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionRequest>, messageCallback: (response: import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionResponse) => void, closeCallback: (error: import("@connectrpc/connect").ConnectError | undefined) => void, options?: import("@connectrpc/connect").CallOptions | undefined) => () => void)>;
+    export const questionSubscription: (questionId: string, transport: Transport) => import("../../../sdk-web-api/src/grpc/subscription").ServerStreamSubscription<import("@bufbuild/protobuf").ServiceType, import("@bufbuild/protobuf").Message<import("@bufbuild/protobuf").AnyMessage>, import("@bufbuild/protobuf").Message<import("@bufbuild/protobuf").AnyMessage>, never, never> | import("../../../sdk-web-api/src/grpc/subscription").ServerStreamSubscription<{
+        readonly typeName: "streamlayer.interactive.feed.Feed";
+        readonly methods: {
+            readonly get: {
+                readonly name: "Get";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").GetRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").GetResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly subscription: {
+                readonly name: "Subscription";
+                readonly I: typeof SubscriptionRequest;
+                readonly O: typeof SubscriptionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.ServerStreaming;
+            };
+            readonly votingSubscription: {
+                readonly name: "VotingSubscription";
+                readonly I: typeof VotingSubscriptionRequest;
+                readonly O: typeof VotingSubscriptionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.ServerStreaming;
+            };
+            readonly questionSubscription: {
+                readonly name: "QuestionSubscription";
+                readonly I: typeof QuestionSubscriptionRequest;
+                readonly O: typeof QuestionSubscriptionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.ServerStreaming;
+            };
+            readonly questionByUser: {
+                readonly name: "QuestionByUser";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").QuestionByUserRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").QuestionByUserResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly syncQuestion: {
+                readonly name: "SyncQuestion";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SyncQuestionRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SyncQuestionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly getQuestion: {
+                readonly name: "GetQuestion";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").GetQuestionRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").GetQuestionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly questionDetail: {
+                readonly name: "QuestionDetail";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").QuestionDetailRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").QuestionDetailResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly submitAnswer: {
+                readonly name: "SubmitAnswer";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SubmitAnswerRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SubmitAnswerResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly submitInplay: {
+                readonly name: "SubmitInplay";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SubmitInplayRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SubmitInplayResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly skipQuestion: {
+                readonly name: "SkipQuestion";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SkipQuestionRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SkipQuestionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly pickHistory: {
+                readonly name: "PickHistory";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").PickHistoryRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").PickHistoryResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly insightHistory: {
+                readonly name: "InsightHistory";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").InsightHistoryRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").InsightHistoryResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly tweetHistory: {
+                readonly name: "TweetHistory";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").TweetHistoryRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").TweetHistoryResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly promotionHistory: {
+                readonly name: "PromotionHistory";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").PromotionHistoryRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").PromotionHistoryResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly list: {
+                readonly name: "List";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedListRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedListResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.Unary;
+            };
+            readonly feedSubscription: {
+                readonly name: "FeedSubscription";
+                readonly I: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionRequest;
+                readonly O: typeof import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionResponse;
+                readonly kind: import("@bufbuild/protobuf").MethodKind.ServerStreaming;
+            };
+        };
+    }, QuestionSubscriptionRequest, QuestionSubscriptionResponse, "subscription" | "votingSubscription" | "questionSubscription" | "feedSubscription", ((request: import("@bufbuild/protobuf").PartialMessage<SubscriptionRequest>, messageCallback: (response: SubscriptionResponse) => void, closeCallback: (error: import("@connectrpc/connect").ConnectError | undefined) => void, options?: import("@connectrpc/connect").CallOptions | undefined) => () => void) | ((request: import("@bufbuild/protobuf").PartialMessage<VotingSubscriptionRequest>, messageCallback: (response: VotingSubscriptionResponse) => void, closeCallback: (error: import("@connectrpc/connect").ConnectError | undefined) => void, options?: import("@connectrpc/connect").CallOptions | undefined) => () => void) | ((request: import("@bufbuild/protobuf").PartialMessage<QuestionSubscriptionRequest>, messageCallback: (response: QuestionSubscriptionResponse) => void, closeCallback: (error: import("@connectrpc/connect").ConnectError | undefined) => void, options?: import("@connectrpc/connect").CallOptions | undefined) => () => void) | ((request: import("@bufbuild/protobuf").PartialMessage<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionRequest>, messageCallback: (response: import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedSubscriptionResponse) => void, closeCallback: (error: import("@connectrpc/connect").ConnectError | undefined) => void, options?: import("@connectrpc/connect").CallOptions | undefined) => () => void)>;
+    export const getQuestionByUser: (questionId: string, transport: Transport) => Promise<import("@streamlayer/sl-eslib/interactive/interactive.common_pb").ExtendedQuestion | undefined>;
+    export const $questionByUser: ($questionId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/interactive/interactive.common_pb").ExtendedQuestion | undefined, any>;
+    export const $pickHistory: (slStreamId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<(import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").PickHistory | undefined)[], any>;
+    export const $feedList: (slStreamId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedItem[], any>;
+    export const $insightHistory: (slStreamId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<(import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").InsightHistory | undefined)[] | undefined, any>;
+    export { $userSummary, $leaderboardList } from "../../feature-gamification/src/queries/leaderboard";
+    export { $moderation } from "../../feature-gamification/src/queries/moderation";
+}
+declare module "../../feature-gamification/src/detail" {
+    import type { Transport } from '../../sdk-web-api/src/index.ts';
+    import { ReadableAtom } from 'nanostores';
+    import { getQuestionByUser } from "../../feature-gamification/src/queries/index";
+    import { type GamificationBackground } from "../../feature-gamification/src/background";
+    type ExtendedQuestion = Awaited<ReturnType<typeof getQuestionByUser>>;
+    type ExtendedQuestionStore = {
+        data?: ExtendedQuestion;
+        loading?: boolean;
+        error?: string;
+    };
+    export const detail: (transport: Transport, $openedQuestionId: ReadableAtom<string | undefined>, $feedList: ReturnType<GamificationBackground['feedList']['getStore']>) => {
+        $store: ReadableAtom<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").FeedItem | undefined>;
+        $extendedStore: import("nanostores").MapStore<ExtendedQuestionStore>;
+        updateExtendedQuestion: (question: ExtendedQuestion) => void;
+    };
+}
+declare module "../../feature-gamification/src/background" {
+    import { ApiStore, type StreamLayerContext } from '../../sdk-web-interfaces/src/index.ts';
+    import type { GetApiResponseType } from '../../sdk-web-api/src/index.ts';
+    import '@streamlayer/sdk-web-core/store';
+    import { ReadableAtom, WritableAtom } from 'nanostores';
+    import * as queries from "../../feature-gamification/src/queries/index";
+    import { detail } from "../../feature-gamification/src/detail";
+    /**
+     * get GamificationBackground singleton
+     */
+    export const gamificationBackground: (instance: StreamLayerContext) => GamificationBackground;
+    /**
+     * Background Singleton class for Gamification and Highlights overlays
+     */
+    export class GamificationBackground {
+        /** sl event id */
+        slStreamId: ReadableAtom<string | undefined>;
+        /** organization id */
+        organizationId: ReadableAtom<string | undefined>;
+        /** current user id */
+        userId: ReadableAtom<string | undefined>;
+        /** opened question, using to download statistics */
+        openedQuestionId: WritableAtom<string | undefined>;
+        /** opened question statistics */
+        openedQuestion: ReturnType<typeof detail>;
+        /** last active question in feed */
+        activeQuestionId: ApiStore<GetApiResponseType<typeof queries.$activeQuestion>>;
+        feedList: ApiStore<GetApiResponseType<typeof queries.$feedList>>;
+        /** moderation id */
+        moderationId: ReadableAtom<string | undefined>;
+        /** moderation */
+        moderation: ApiStore<GetApiResponseType<typeof queries.$moderation>>;
+        /** feed subscription to receive new active question, update last active question */
+        feedSubscription: ReturnType<typeof queries.feedSubscription>;
+        /** subscription to opened question (vote percentage) */
+        questionSubscription?: ReturnType<typeof queries.questionSubscription>;
+        private notifications;
+        private log;
+        constructor(instance: StreamLayerContext);
+        /**
+         * Get id for notifications and link with current session
+         * @param opts.prefix - id prefix (onboarding, question, tweet, ...etc)
+         * @param opts.userId - current user id, if not presented get from sdk automatically
+         * @param opts.eventId - current event id, if not presented get from sdk automatically
+         * @param opts.organizationId - current organization id, if not presented get from sdk automatically
+         * @param opts.entity - entity id (question id, tweet id, ...etc)
+         */
+        getCurrentSessionId: (opts: {
+            prefix?: string;
+            userId?: string;
+            eventId?: string;
+            organizationId?: string;
+            entity?: string;
+        }) => string;
+        disconnect: () => void;
+        /**
+         * Open question and mark notification for this question as viewed
+         */
+        openQuestion: (questionId: string) => void;
+        /**
+         * Close question and mark notification for this question as viewed
+         */
+        closeQuestion: (questionId?: string) => void;
+    }
+}
+declare module "../../feature-gamification/src/queries/actions" {
+    import type { Transport } from '../../sdk-web-api/src/index.ts';
+    export const submitAnswer: (transport: Transport, data: {
+        questionId: string;
+        answerId: string;
+    }) => Promise<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SubmitAnswerResponse>;
+    export const submitInplay: (transport: Transport, eventId: string) => Promise<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SubmitInplayResponse>;
+    export const skipQuestion: (transport: Transport, questionId: string) => Promise<import("@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb").SkipQuestionResponse>;
+}
+declare module "../../feature-gamification/src/onboarding" {
+    import { Transport } from '../../sdk-web-api/src/index.ts';
+    import { type Notifications } from '../../sdk-web-notifications/src/index.ts';
+    import { GamificationBackground } from "../../feature-gamification/src/background";
+    import { Gamification } from "../../feature-gamification/src/index";
+    /**
+     * Required: in-app should be displayed and questions not available
+     * Optional: in-app should be displayed but questions are available
+     * Completed: user completed onboarding, cached in browser. Linked by eventId, organizationId and userId
+     * Disabled: no in-app but questions are available
+     * Unavailable: no in-app and questions not available [behavior is discussed]
+     */
+    export enum OnboardingStatus {
+        Unset = "unset",
+        Required = "required",
+        Optional = "optional",
+        Completed = "completed",
+        Disabled = "disabled",
+        Unavailable = "unavailable"
+    }
+    export const onboarding: (service: Gamification, background: GamificationBackground, transport: Transport, notifications: Notifications) => {
+        $store: import("nanostores").WritableAtom<OnboardingStatus>;
+        submitInplay: () => Promise<void>;
+    };
+}
+declare module "../../feature-gamification/src/storage" {
+    import { Storage } from '../../sdk-web-storage/src/index.ts';
+    import { OnboardingStatus } from "../../feature-gamification/src/onboarding";
+    type UserProps = {
+        userId: string;
+        eventId: string;
+        organizationId: string;
+    };
+    export class GamificationStorage extends Storage {
+        constructor();
+        saveOnboardingStatus: ({ userId, eventId, organizationId }: UserProps, status: OnboardingStatus) => void;
+        getOnboardingStatus: ({ userId, eventId, organizationId }: UserProps) => string | undefined;
+    }
+}
+declare module "../../feature-gamification/src/leaderboard" {
+    import type { Transport } from '../../sdk-web-api/src/index.ts';
+    import { ReadableAtom } from 'nanostores';
+    import { type LeaderboardItem } from "../../feature-gamification/src/queries/leaderboard";
+    type LeaderboardOptions = {
+        pageSize?: number;
+    };
+    type LeaderboardStore = {
+        data?: LeaderboardItem[];
+        loading?: boolean;
+        error?: string;
+    };
+    export const leaderboard: (transport: Transport, $eventId: ReadableAtom<string | undefined>, options?: LeaderboardOptions) => {
+        $store: import("nanostores").MapStore<LeaderboardStore>;
+        fetchMore: () => void;
+        invalidate: () => void;
+    };
+}
+declare module "../../feature-gamification/src/gamification" {
+    import { AbstractFeature, ApiStore, FeatureSource, type FeatureProps, type StreamLayerContext } from '../../sdk-web-interfaces/src/index.ts';
+    import { type GamesOverlaySettings } from '../../sdk-web-types/src/index.ts';
+    import type { GetApiResponseType } from '../../sdk-web-api/src/index.ts';
+    import '@streamlayer/sdk-web-core/store';
+    import type { PlainMessage } from '@bufbuild/protobuf';
+    import { WritableAtom } from 'nanostores';
+    import * as queries from "../../feature-gamification/src/queries/index";
+    import { leaderboard } from "../../feature-gamification/src/leaderboard";
+    import { OnboardingStatus } from "../../feature-gamification/src/onboarding";
+    import { LeaderboardItem } from "../../feature-gamification/src/queries/leaderboard";
+    import { GamificationBackground } from "../../feature-gamification/src/index";
+    /**
+     * Gamification (Games) Overlay
+     * Includes:
+     * - questions list (pick history)
+     * - active question (question from active queue, available from pick history and in-app)
+     * - leaderboard (currently only global pinned leaderboard)
+     * - user summary (current user summary)
+     * - onboarding (welcome book)
+     */
+    export class Gamification extends AbstractFeature<'games', PlainMessage<GamesOverlaySettings>> {
+        /** user statistics (leaderboard panel) */
+        userSummary: ApiStore<GetApiResponseType<typeof queries.$userSummary>>;
+        /** feed list (pick history) */
+        feedList: ApiStore<GetApiResponseType<typeof queries.$feedList>>;
+        /** pinned leaderboard id */
+        leaderboardId: WritableAtom<string | undefined>;
+        /** leaderboard list */
+        leaderboardList: ReturnType<typeof leaderboard>;
+        /** onboarding status */
+        onboardingStatus: {
+            $store: WritableAtom<OnboardingStatus | undefined>;
+            submitInplay: () => Promise<void>;
+        };
+        /** opened question */
+        openedQuestion: GamificationBackground['openedQuestion'];
+        /** pinned leaderboard id */
+        openedUser: WritableAtom<LeaderboardItem | undefined>;
+        closeFeature: () => void;
+        openFeature: () => void;
+        private notifications;
+        private transport;
+        /** gamification background class, handle subscriptions and notifications for closed overlay */
+        private background;
+        /** Browser cache */
+        private storage;
+        constructor(config: FeatureProps, source: FeatureSource, instance: StreamLayerContext);
+        connect: (transport: StreamLayerContext['transport']) => void;
+        disconnect: () => void;
+        submitAnswer: (questionId: string, answerId: string) => Promise<void>;
+        skipQuestion: (questionId: string) => Promise<void>;
+        openQuestion: (questionId: string) => void;
+        closeQuestion: (questionId?: string) => void;
+        openUser: (userId: string) => void;
+        closeUser: () => void;
+    }
+}
+declare module "../../feature-gamification/src/highlights" {
+    import { AbstractFeature, ApiStore, FeatureSource, type FeatureProps, type StreamLayerContext } from '../../sdk-web-interfaces/src/index.ts';
+    import type { GetApiResponseType } from '../../sdk-web-api/src/index.ts';
+    import '@streamlayer/sdk-web-core/store';
+    import * as queries from "../../feature-gamification/src/queries/index";
+    import { GamificationBackground } from "../../feature-gamification/src/index";
+    export class Highlights extends AbstractFeature<undefined> {
+        insights?: ApiStore<GetApiResponseType<typeof queries.$insightHistory>>;
+        closeFeature: () => void;
+        openFeature: () => void;
+        openedInsight: GamificationBackground['openedQuestion'];
+        private notifications;
+        private transport;
+        private background;
+        constructor(config: FeatureProps, source: FeatureSource, instance: StreamLayerContext);
+        connect: () => void;
+        disconnect: () => void;
+        openHighlight: (questionId: string) => void;
+        closeHighlight: (questionId?: string) => void;
+    }
+}
+declare module "../../feature-gamification/src/index" {
+    export { GamificationBackground, gamificationBackground } from "../../feature-gamification/src/background";
+    export { Gamification } from "../../feature-gamification/src/gamification";
+    export { Highlights } from "../../feature-gamification/src/highlights";
+    module '@streamlayer/sdk-web-interfaces' {
+        interface StreamLayerContext {
+            gamification: import("../../feature-gamification/src/background").GamificationBackground;
+        }
+    }
+}
+declare module "../../sdk-web-features/src/index" {
+    import { FeatureType } from '../../sdk-web-types/src/index.ts';
+    import { AbstractFeature, FeatureSource, FeatureProps, StreamLayerContext, SingleStore } from '../../sdk-web-interfaces/src/index.ts';
+    import { Highlights, Gamification } from '../../feature-gamification/src/index.ts';
+    export type Features = Feature | Gamification | Highlights;
+    export const AvailableFeatures: {
+        12: boolean;
+        14: boolean;
+    };
+    export class Feature extends AbstractFeature<undefined> {
+        constructor(overlay: FeatureProps, source: FeatureSource);
+    }
+    export const initFeature: (overlay: FeatureProps, source: FeatureSource, instance: StreamLayerContext) => Gamification | Highlights | Feature;
+    export { FeatureSource } from '../../sdk-web-interfaces/src/index.ts';
+    module '@streamlayer/sdk-web-interfaces' {
+        interface StreamLayerContext {
+            features: Map<FeatureType, Features>;
+            initFeature: (overlay: FeatureProps, source: FeatureSource) => void;
+            updateFeature: (overlay: FeatureProps, source: FeatureSource) => void;
+            destroyFeature: (overlay: FeatureProps) => void;
+            reinitializeFeatures: () => Promise<void>;
+            activeFeature: SingleStore<FeatureType>;
+        }
+        interface StreamLayerSDK {
+            getFeatures: () => Map<FeatureType, Features>;
+            getFeature: <T extends FeatureType = FeatureType>(featureType: T) => (T extends FeatureType.GAMES ? Gamification : T extends FeatureType.HIGHLIGHTS ? Highlights : Feature) | undefined;
+            getActiveFeature: SingleStore<FeatureType>['getStore'];
+            closeFeature: () => void;
+        }
+    }
+    export const features: (instance: StreamLayerContext, opts: unknown, done: () => void) => void;
+}
+declare module "../../sdk-web/src/index" {
+    import { StreamLayerContext } from '../../sdk-web-interfaces/src/index.ts';
+    import avvio from 'avvio';
+    export type StreamLayerInstance = avvio.mixedInstance<StreamLayerContext>;
+    export type StreamLayerPlugin = (instance: StreamLayerContext, opts: unknown, done: DoneFn) => void;
+    type DoneFn = Function;
+    export function StreamLayer(sdkKey: string, production?: boolean, autoEnable?: boolean): avvio.Avvio<StreamLayerContext>;
+}
+declare module "app/useStreamLayerApp" {
+    import type { StreamLayerSDK, StreamLayerPlugin } from '../../sdk-web-interfaces/src/index.ts';
+    export const useStreamLayerApp: (sdkKey: string, plugins?: Set<StreamLayerPlugin>, production?: boolean, autoEnable?: boolean) => StreamLayerSDK | null;
+}
+declare module "app/provider" {
+    import type { StreamLayerSDK, StreamLayerPlugin } from '../../sdk-web-interfaces/src/index.ts';
+    export enum StreamLayerStatus {
+        UNSET = 0,
+        CONNECTED = 1,
+        READY = 2
+    }
+    export const StreamLayerContext: import("react").Context<{
+        status: StreamLayerStatus;
+        sdk: StreamLayerSDK | null;
+    }>;
+    export type StreamLayerProps = {
+        sdkKey: string;
+        plugins?: Set<StreamLayerPlugin>;
+        production?: boolean;
+        autoEnable?: boolean;
+    };
+    export const StreamLayerProvider: React.FC<StreamLayerProps & {
+        children: React.ReactNode;
+    }>;
+}
+declare module "app/masters" {
+    import { StreamLayerProps } from "app/provider";
+    export const MastersStreamLayerProvider: React.FC<StreamLayerProps & {
+        children: React.ReactNode;
+    }>;
+    type Overlays = {
+        leaderboard: React.ReactNode;
+    };
+    type MastersAppChildrenProps = {
+        enableSdk: (event: string) => void;
+        disableSdk: () => void;
+    };
+    type MastersAppProps = {
+        overlays?: Overlays;
+        children: (methods: MastersAppChildrenProps) => React.ReactNode;
+    };
+    export const MastersStreamLayerSDKReact: React.FC<MastersAppProps>;
+}
+declare module "app/app" {
+    import type { StreamLayerSDK } from '../../sdk-web-interfaces/src/index.ts';
+    export const useStreamLayer: () => StreamLayerSDK | null;
+    export const StreamLayerSDKReact: React.FC;
+}
+declare module "app/auth" {
+    export const StreamLayerLogin: React.FC<{
+        token: string;
+        schema: string;
+    }>;
+}
+declare module "app/points" {
+    export const StreamLayerSDKPoints: () => import("react/jsx-runtime").JSX.Element | null;
+}
+/// <amd-module name="@streamlayer/react/masters" />
+declare module "@streamlayer/react/masters" {
+    export * from "app/masters";
+    export * from "app/auth";
+    export * from "app/points";
+}
+declare module "index" {
+    import '@streamlayer/sdk-web-api';
+    import '@streamlayer/sdk-web-core';
+    import '@streamlayer/sdk-web-types';
+    import '@streamlayer/sdk-web-logger';
+    import '@streamlayer/sdk-web-storage';
+    import '@streamlayer/sdk-web-features';
+    import '@streamlayer/sdk-web-interfaces';
+    import '@streamlayer/sdk-web-notifications';
+    import '@streamlayer/feature-gamification';
+    export { StreamLayerProvider } from "app/provider";
+    export { StreamLayerSDKReact, useStreamLayer } from "app/app";
+}