@vizbeetv/homesso-sdk-qa 1.0.1

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@vizbeetv/homesso-sdk-qa",
+  "version": "1.0.1",
+  "description": "TV app authentication library (QA)",
+  "main": "./es5/index.cjs",
+  "module": "./es5/index.mjs",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./es5/index.mjs",
+      "require": "./es5/index.cjs"
+    },
+    "./es5": {
+      "types": "./types/index.d.ts",
+      "import": "./es5/index.mjs",
+      "require": "./es5/index.cjs"
+    },
+    "./es6": {
+      "types": "./types/index.d.ts",
+      "import": "./es6/index.mjs",
+      "require": "./es6/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "keywords": [
+    "tv",
+    "authentication",
+    "sso"
+  ],
+  "author": "",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/types/VizbeeHomeSSOManager.d.ts

@@ -0,0 +1,186 @@
+import { VizbeeSignInInfo } from './model/VizbeeSignInInfo';
+import { FailureStatus, ProgressStatus, SuccessStatus } from './model/VizbeeSignInStatus';
+import { MessagePayload, VizbeeModalPreferences, VizbeeSignInStatusCallback } from './types';
+/**
+ * Manages Single Sign-On (SSO) functionality between mobile and TV devices in the Vizbee ecosystem.
+ * Implements singleton pattern for global state management.
+ *
+ * @remarks
+ * This class serves as the central manager for SSO operations, handling:
+ * - Communication between mobile and TV devices
+ * - Sign-in status management and updates
+ * - UI state management
+ * - Analytics and metrics tracking
+ *
+ * @class VizbeeHomeSSOManager
+ * @public
+ */
+export declare class VizbeeHomeSSOManager implements VizbeeSignInStatusCallback {
+    /** @internal Singleton instance of the manager */
+    private static instance;
+    /** @internal Vizbee session instance for managing communication */
+    private vizbeeSession;
+    /** @internal Client for handling messaging between devices */
+    private vizbeeMessagingClient;
+    /** @internal Callback function to retrieve sign-in information */
+    private getSignInInfo;
+    /** @internal List of sign-in information for different services */
+    private signInInfoList;
+    /** @internal Tracks if remote device is signed in */
+    private isRemoteSignedIn;
+    /** @internal Tracks if screen device is signed in */
+    private isScreenSignedIn;
+    /** @internal Tracks if sign-in process is currently active */
+    private isSignInInProgress;
+    /** @internal UI manager instance for handling SSO-related displays */
+    private vizbeeHomeSSOUIManager;
+    /** @internal Snackbar instance for showing notifications */
+    private readonly snackbar;
+    /** @internal Information about the sender device */
+    private senderInfo;
+    /** @internal Manager for handling metrics and analytics */
+    private readonly vizbeeMetricsManager;
+    private signInHandler;
+    /**
+     * Modal display preferences for the SSO UI
+     * @public
+     */
+    modalPreferences: VizbeeModalPreferences;
+    /**
+     * Private constructor to enforce singleton pattern
+     * Initializes necessary components and sets up default handlers
+     *
+     * @internal
+     */
+    private constructor();
+    /**
+     * Gets the singleton instance of VizbeeHomeSSOManager
+     * Creates a new instance if one doesn't exist
+     *
+     * @returns The singleton instance of the SSO manager
+     * @public
+     */
+    static getInstance(): VizbeeHomeSSOManager;
+    init(): void;
+    /**
+     * Sets up a handler for processing sign-in events from mobile devices
+     *
+     * @param handler - Callback function to process sign-in information and provide status updates
+     * @public
+     */
+    setSignInHandler(handler: (signInInfo: MessagePayload, statusCallback: (signInStatus: ProgressStatus | SuccessStatus | FailureStatus) => void) => void): void;
+    /**
+     * Sets the callback for retrieving sign-in information
+     *
+     * @param getSignInInfo - Async callback that provides the list of sign-in information
+     * @public
+     */
+    setSignInInfoGetter(getSignInInfo: () => Promise<VizbeeSignInInfo[]>): void;
+    /**
+     * Handles sign-in progress updates
+     * Updates UI, sends status to mobile device, and logs metrics
+     *
+     * @param progressStatus - Current progress status of the sign-in process
+     * @public
+     */
+    onProgress(progressStatus: ProgressStatus): void;
+    /**
+     * Handles successful sign-in completion
+     * Updates UI, sends success status to mobile device, and logs metrics
+     *
+     * @param successStatus - Success status details
+     * @public
+     */
+    onSuccess(successStatus: SuccessStatus): void;
+    /**
+     * Handles sign-in failures
+     * Updates UI and sends failure status to mobile device
+     *
+     * @param failureStatus - Failure status details
+     * @public
+     */
+    onFailure(failureStatus: FailureStatus): void;
+    /**
+     * Adds custom attributes for metrics tracking
+     *
+     * @param customEventAttributes - Dictionary of custom attributes to track
+     * @public
+     */
+    addCustomEventAttributes(customEventAttributes: Record<string, unknown>): void;
+    /**
+     * Initializes Vizbee session and messaging client
+     *
+     * @throws Error if initialization fails
+     * @internal
+     */
+    private initializeVizbeeSession;
+    /**
+     * Processes incoming sign-in requests
+     * Validates request and triggers appropriate handler
+     *
+     * @param payload - Sign-in request payload
+     * @param handler - Callback to handle the sign-in request
+     * @internal
+     */
+    private handleSignInRequest;
+    /**
+     * Determines if a sign-in request should be ignored
+     * Checks various conditions like existing sign-in state
+     *
+     * @returns Promise<boolean> indicating if request should be ignored
+     * @internal
+     */
+    private shouldIgnoreSignInRequest;
+    /**
+     * Checks if user is already signed in for a specific sign-in type
+     *
+     * @param signInType - Type of sign-in to check
+     * @returns Promise<boolean> indicating if user is signed in
+     * @internal
+     */
+    private isUserAlreadySignedIn;
+    /**
+     * Handles sign-in status updates
+     * Routes status updates to appropriate handlers
+     *
+     * @param status - Current status of the sign-in process
+     * @internal
+     */
+    private handleSignInStatus;
+    /**
+     * Sends status updates to mobile device
+     *
+     * @param status - Status to send to mobile device
+     * @internal
+     */
+    private sendStatusToSender;
+    /**
+     * Serializes status objects for transmission to mobile device
+     *
+     * @param status - Status object to serialize
+     * @returns Serialized status object or null if invalid status type
+     * @internal
+     */
+    private serializeStatus;
+    /**
+     * Updates UI for sign-in progress state
+     * Shows appropriate modal based on remote sign-in status
+     *
+     * @internal
+     */
+    private updateProgressUI;
+    /**
+     * Updates UI for successful sign-in
+     * Shows success modal with appropriate message
+     *
+     * @internal
+     */
+    private updateSuccessUI;
+    /**
+     * Updates UI for failed sign-in
+     * Hides any active modals
+     *
+     * @internal
+     */
+    private updateFailureUI;
+}

package/types/VizbeeSignInStatusCallback.d.ts

@@ -0,0 +1,34 @@
+interface VizbeeSignInStatusBase {
+    provider: string;
+}
+interface VizbeeSignInProgressStatus extends VizbeeSignInStatusBase {
+    data: Record<string, any>;
+}
+interface VizbeeSignInSuccessStatus extends VizbeeSignInStatusBase {
+    userId: string;
+}
+interface VizbeeSignInFailureStatus extends VizbeeSignInStatusBase {
+    error: string;
+    isCancelled: boolean;
+}
+interface VizbeeSignInStatusCallback {
+    /**
+     * Called as soon as registration code is generated
+     * @param progress - Contains provider and progress data including registration code
+     * @example callback.onProgress({ provider: "mvpd", data: { regcode: "123456" } })
+     */
+    onProgress(progress: VizbeeSignInProgressStatus): void;
+    /**
+     * Called as soon as the polling succeeds
+     * @param success - Contains provider and user ID
+     * @example callback.onSuccess({ provider: "mvpd", userId: "user123" })
+     */
+    onSuccess(success: VizbeeSignInSuccessStatus): void;
+    /**
+     * Called as soon as the polling fails or user cancels the sign-in
+     * @param failure - Contains provider, error message, and cancellation status
+     * @example callback.onFailure({ provider: "mvpd", error: "xyz", isCancelled: false })
+     */
+    onFailure(failure: VizbeeSignInFailureStatus): void;
+}
+export type { VizbeeSignInStatusCallback, VizbeeSignInProgressStatus, VizbeeSignInSuccessStatus, VizbeeSignInFailureStatus, };

package/types/index.d.ts

@@ -0,0 +1,63 @@
+import { VizbeeHomeSSOManager } from './VizbeeHomeSSOManager';
+import { ProgressStatus, SuccessStatus, FailureStatus } from './model/VizbeeSignInStatus';
+import { IVizbeeAnalyticsProvider, IVizbeeXMessages } from './types';
+import { VizbeeHomeSSOUIManager } from './ui/VizbeeHomeSSOUIManager';
+import { LogLevel } from './utils/Logger';
+/**
+ * @class HomeSSOContext
+ * @description Context provider for Vizbee Home SSO functionality
+ */
+declare class HomeSSOContext {
+    private static instance;
+    private homeSSOUIManager;
+    private constructor();
+    /**
+     * Gets the singleton instance of HomeSSOContext
+     * @returns The singleton instance of HomeSSOContext
+     */
+    static getInstance(): HomeSSOContext;
+    /**
+     * Gets the HomeSSOManager instance
+     * @returns The singleton instance of VizbeeHomeSSOManager
+     */
+    getHomeSSOManager(): VizbeeHomeSSOManager;
+    /**
+     * Gets the HomeSSOUIManager instance
+     * @param config Optional UI configuration including theme settings
+     * @returns The singleton instance of VizbeeHomeSSOUIManager
+     */
+    getHomeSSOUIManager(): VizbeeHomeSSOUIManager;
+    enableLogger(enable: boolean): void;
+    setLoggerLevel(level: LogLevel): void;
+}
+declare global {
+    interface Window {
+        vizbee: {
+            continuity?: {
+                xmessages: IVizbeeXMessages;
+                analytics: {
+                    AnalyticsProvider: new () => IVizbeeAnalyticsProvider;
+                };
+            };
+            homesso: {
+                HomeSSOContext: typeof HomeSSOContext;
+                messages: {
+                    ProgressStatus: typeof ProgressStatus;
+                    SuccessStatus: typeof SuccessStatus;
+                    FailureStatus: typeof FailureStatus;
+                };
+                LoggerLevel: typeof LogLevel;
+                VERSION: string;
+            };
+        };
+    }
+}
+export { HomeSSOContext };
+export { ProgressStatus, SuccessStatus, FailureStatus } from './model/VizbeeSignInStatus';
+export { LogLevel } from './utils/Logger';
+export { VizbeeHomeSSOManager } from './VizbeeHomeSSOManager';
+export { VizbeeHomeSSOUIManager } from './ui/VizbeeHomeSSOUIManager';
+export { UNKNOWN_VALUE } from './model/VizbeeSignInInfo';
+export type { VizbeeSignInInfo } from './model/VizbeeSignInInfo';
+export type { VizbeeSignInStatusCallback, IVizbeeAnalyticsProvider, IVizbeeXMessages, IVizbeeMessagingClient, IVizbeeSession, IVizbeeBicastSessionManager, ISessionStateListener, MessagePayload, VizbeeSenderDevice, } from './types';
+export type { VizbeeHomeSSOTheme, CommonModalPreferenceOptions, InformationalSignInPreferenceOptions, ProgressSignInPreferenceOptions, SuccessSignInPreferenceOptions, } from './ui/VizbeeHomeSSOUIConfig';

package/types/metrics/IVizbeeAttributesProvider.d.ts

@@ -0,0 +1,3 @@
+export interface IVizbeeAttributesProvider {
+    getAttributes(): Record<string, any>;
+}

package/types/metrics/VizbeeMetricsConstants.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @const VizbeeConstants
+ * @description Metrics Constants used throughout the Vizbee Home SSO implementation
+ */
+export declare const VizbeeMetricsConstants: {
+    METRICS_EVENT_SCREEN_HOMESSO_SIGNIN_RECEIVED: string;
+    METRICS_EVENT_SCREEN_HOMESSO_SIGNIN_STATUS: string;
+    METRICS_ATTR_SCREEN_HOMESSO_SDK_VERSION: string;
+    METRICS_ATTR_IS_SCREEN_SIGNED_IN: string;
+    METRICS_ATTR_IS_REMOTE_SIGNED_IN: string;
+    METRICS_ATTR_IS_SCREEN_SIGN_IN_STATUS: string;
+    METRICS_ATTR_SCREEN_HOMESSO_USER_ID: string;
+    METRICS_ATTR_SCREEN_HOMESSO_USER_INFO: string;
+    METRICS_ATTR_HOMESSO_SIGN_IN_TYPE: string;
+    METRICS_ATTR_REMOTE_DEVICE_ID: string;
+    METRICS_ATTR_REMOTE_DEVICE_TYPE: string;
+    METRICS_ATTR_REMOTE_FRIENDLY_NAME: string;
+    METRICS_ATTR_REMOTE_NETWORK_SESSION_ID: string;
+    METRICS_ATTR_USER_LOGIN_TYPE: string;
+    METRICS_ATTR_USER_IS_SIGNED_IN: string;
+    METRICS_ATTR_USER_LOGIN: string;
+    METRICS_ATTR_USER_NAME: string;
+    METRICS_ATTR_USER_SUBSCRIPTION_TYPE: string;
+    METRICS_ATTR_USER_SUBSCRIPTION_VALUE: string;
+    METRICS_ATTR_USER_SUBSCRIPTION_RENEWAL_TYPE: string;
+    METRICS_ATTR_USER_ADDITIONAL_INFO: string;
+};

package/types/metrics/VizbeeMetricsManager.d.ts

@@ -0,0 +1,15 @@
+import { SenderInfo } from '../model/VizbeeSenderSignInInfo';
+import { VizbeeSignInInfo } from '../model/VizbeeSignInInfo';
+import { IVizbeeAttributesProvider } from './IVizbeeAttributesProvider';
+export declare class VizbeeMetricsManager implements IVizbeeAttributesProvider {
+    private metricsManager;
+    senderInfo: SenderInfo | null;
+    getSignInInfo: () => Promise<VizbeeSignInInfo[]>;
+    constructor();
+    log(event: string, attributes: Record<string, any>, bypassAttributeProviders?: boolean): void;
+    setCustomAttributes(customAttributes: Record<string, any>): void;
+    getAttributes(): Promise<Record<string, any>>;
+    private createAttributesJson;
+    private createUserInfoObject;
+    private addDefaultAttributes;
+}

package/types/model/VizbeeSenderSignInInfo.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @interface SenderInfo
+ * @description Contains information about the sender device/user
+ */
+export interface SenderInfo {
+    friendlyName: string;
+    deviceId: string;
+    deviceType: string;
+    networkSessionId: string;
+}
+/**
+ * @interface VizbeeSenderSignInInfo
+ * @description Represents the sign-in information from a sender device
+ */
+export interface VizbeeSenderSignInInfo {
+    isSignedIn: boolean;
+    signInType: string;
+    customData: Record<string, any>;
+    senderInfo: SenderInfo | null;
+}

package/types/model/VizbeeSignInInfo.d.ts

@@ -0,0 +1,11 @@
+export declare const UNKNOWN_VALUE = "UNKNOWN";
+export interface VizbeeSignInInfo {
+    userLoginType: string;
+    isSignedIn: boolean;
+    userLogin: string;
+    userName?: string;
+    userSubscriptionType?: string;
+    userSubscriptionValue?: string;
+    userSubscriptionRenewalType?: string;
+    userAdditionalInfo?: Record<string, any>;
+}

package/types/model/VizbeeSignInStatus.d.ts

@@ -0,0 +1,31 @@
+import { VizbeeSignInState } from '../utils/constants';
+declare abstract class VizbeeSignInStatus {
+    readonly signInType: string;
+    readonly customData: Record<string, any> | null;
+    protected constructor(signInType: string, customData: Record<string, any> | null);
+    abstract getState(): VizbeeSignInState;
+    serialize(): Record<string, any>;
+}
+export declare class ProgressStatus extends VizbeeSignInStatus {
+    readonly signInType: string;
+    readonly customData: Record<string, any> | null;
+    constructor(signInType: string, customData?: Record<string, any> | null);
+    getState(): VizbeeSignInState;
+}
+export declare class SuccessStatus extends VizbeeSignInStatus {
+    readonly signInType: string;
+    readonly userId: string | null;
+    readonly customData: Record<string, any> | null;
+    constructor(signInType: string, userId?: string | null, customData?: Record<string, any> | null);
+    getState(): VizbeeSignInState;
+}
+export declare class FailureStatus extends VizbeeSignInStatus {
+    readonly signInType: string;
+    readonly isCancelled: boolean;
+    readonly reason: string | null;
+    readonly exception: Error | null;
+    readonly customData: Record<string, any> | null;
+    constructor(signInType: string, isCancelled: boolean, reason?: string | null, exception?: Error | null, customData?: Record<string, any> | null);
+    getState(): VizbeeSignInState;
+}
+export {};

package/types/types.d.ts

@@ -0,0 +1,77 @@
+import { ProgressStatus, SuccessStatus, FailureStatus } from './model/VizbeeSignInStatus';
+import { VizbeeSignInState } from './utils/constants';
+/**
+ * Represents the structure of messages passed between devices
+ */
+export interface MessagePayload {
+    [key: string]: unknown;
+}
+/**
+ * Represents a device that can send messages in the Vizbee ecosystem
+ */
+export interface VizbeeSenderDevice {
+    friendlyName: string;
+    deviceId: string;
+    deviceType: string;
+    networkSessionId: string;
+}
+/**
+ * Core messaging interface for communication between devices
+ */
+export interface IVizbeeMessagingClient {
+    addReceiver(namespace: string, callback: (payload: MessagePayload, namespace: string, device: VizbeeSenderDevice) => void): void;
+    send(payload: Record<string, any>, namespace: string, callback?: (error?: Error) => void): void;
+}
+/**
+ * Manages a communication session and provides access to messaging capabilities
+ */
+export interface IVizbeeSession {
+    getMessagingClient(): IVizbeeMessagingClient;
+}
+export interface ISessionStateListener {
+    onSessionStateChanged(state: number): void;
+}
+/**
+ * Manages bidirectional communication sessions between devices
+ */
+export interface IVizbeeBicastSessionManager {
+    addSessionStateListener(listener: ISessionStateListener): void;
+    removeSessionStateListener(listener: ISessionStateListener): void;
+    getSession(): IVizbeeSession;
+}
+/**
+ * Top-level interface for the Vizbee messaging system
+ */
+export interface IVizbeeXMessages {
+    VizbeeSession: IVizbeeSession;
+    VizbeeMessagingClient: IVizbeeMessagingClient;
+    VizbeeBicastSessionManager: {
+        new (): IVizbeeBicastSessionManager;
+    };
+}
+/**
+ * Interface for sign-in status callbacks
+ */
+export interface VizbeeSignInStatusCallback {
+    onProgress(progress: ProgressStatus): void;
+    onSuccess(success: SuccessStatus): void;
+    onFailure(failure: FailureStatus): void;
+}
+/**
+ * Interface for modal preferences
+ */
+export interface VizbeeModalPreferences {
+}
+/**
+ * Interface for sign-in modal manager
+ */
+export interface ISignInModalManager {
+    updateSignInStatus(state: VizbeeSignInState, preferences: VizbeeModalPreferences, isRemoteSignedIn: boolean): void;
+}
+export interface IVizbeeAnalyticsProvider {
+    logMetrics(eventName: string, properties: Record<string, any>): void;
+    setCustomAttributes(customAttributes: Record<string, any>): void;
+}
+export interface IVizbeeAttributesProvider {
+    getAttributes(): Promise<Record<string, any>>;
+}

package/types/ui/VizbeeHomeSSOUIConfig.d.ts

@@ -0,0 +1,156 @@
+/**
+ * @fileoverview Configuration and type definitions for Vizbee Home SSO UI components
+ * Defines interfaces and default configurations for various modal states and themes
+ */
+import { ModalDirection, SnackbarPosition } from './VizbeeSnackBar';
+/**
+ * Enum defining the different types of sign-in modals available in the system
+ */
+export declare enum SignInModalType {
+    INFORMATION = "information",
+    PROGRESS = "progress",
+    SUCCESS = "success"
+}
+/**
+ * Interface defining the theme configuration for the Home SSO UI
+ * Controls colors and fonts across all modal types
+ */
+export interface VizbeeHomeSSOTheme {
+    primaryColor: string;
+    secondaryColor: string;
+    tertiaryColor: string;
+    subTextColor: string | undefined;
+    primaryFont: string | undefined;
+    secondaryFont: string | undefined;
+    direction: ModalDirection | undefined;
+}
+/**
+ * Base interface for common modal preferences
+ * Defines properties shared across all modal types
+ */
+export interface CommonModalPreferenceOptions {
+    direction: ModalDirection | undefined;
+    width: string | undefined;
+    height: string | undefined;
+    minHeight: string | undefined;
+    padding: string | undefined;
+    borderRadius: string | undefined;
+    backgroundColor: string | undefined;
+    borderColor: string | undefined;
+    borderWidth: string | undefined;
+    boxShadow: string | undefined;
+    edgeMargin: string | undefined;
+    marginTop: string | undefined;
+    marginRight: string | undefined;
+    marginBottom: string | undefined;
+    marginLeft: string | undefined;
+    iconBase64String: string | undefined;
+    iconWidth: string | undefined;
+    iconHeight: string | undefined;
+    iconMarginRight: string | undefined;
+    titleTextFontFamily: string | undefined;
+    titleTextFontColor: string | undefined;
+    titleTextFontSize: string | undefined;
+    titleTextFontWeight: string | undefined;
+    titleTextLineHeight: string | undefined;
+    titleMarginBottom: string | undefined;
+    descriptionTextFontFamily: string | undefined;
+    descriptionTextFontColor: string | undefined;
+    descriptionTextFontSize: string | undefined;
+    descriptionTextFontWeight: string | undefined;
+    descriptionTextLineHeight: string | undefined;
+}
+/**
+ * Interface for informational sign-in modal preferences
+ * Extends common modal options with specific properties for information state
+ */
+export interface InformationalSignInPreferenceOptions extends CommonModalPreferenceOptions {
+    titleText: string | undefined;
+    descriptionText: string;
+    position: SnackbarPosition;
+}
+/**
+ * Interface for progress sign-in modal preferences
+ * Extends common modal options with specific properties for progress state
+ */
+export interface ProgressSignInPreferenceOptions extends CommonModalPreferenceOptions {
+    titleText: string | undefined;
+    descriptionText: string;
+    iconBase64Strings: Array<string> | undefined;
+    position: SnackbarPosition;
+}
+/**
+ * Interface for success sign-in modal preferences
+ * Extends common modal options with specific properties for success state
+ */
+export interface SuccessSignInPreferenceOptions extends CommonModalPreferenceOptions {
+    titleText: string | undefined;
+    descriptionText: string;
+    duration: number;
+    position: SnackbarPosition;
+}
+/**
+ * Interface for success preferences
+ * Simplified version of success modal preferences
+ */
+export interface SuccessPreferenceOptions extends CommonModalPreferenceOptions {
+    duration: number;
+}
+/**
+ * Base interface for preference configuration
+ * Includes enable flag and common modal options
+ */
+export interface PreferenceConfig {
+    enable: boolean;
+    options: CommonModalPreferenceOptions;
+}
+/**
+ * Configuration interface for informational sign-in modal
+ */
+export interface InformationalSignInPreferenceConfig {
+    enable: boolean;
+    options: InformationalSignInPreferenceOptions;
+}
+/**
+ * Configuration interface for progress sign-in modal
+ */
+export interface ProgressSignInPreferenceConfig {
+    enable: boolean;
+    options: ProgressSignInPreferenceOptions;
+}
+/**
+ * Configuration interface for success sign-in modal
+ */
+export interface SuccessSignInPreferenceConfig {
+    enable: boolean;
+    options: SuccessSignInPreferenceOptions;
+}
+/**
+ * Main configuration interface combining all UI components
+ */
+export interface VizbeeHomeSSOUIConfig {
+    theme: VizbeeHomeSSOTheme;
+    modalConfig: CommonModalPreferenceOptions;
+    informationalSignInModalConfig: InformationalSignInPreferenceOptions;
+    progressSignInModalConfig: ProgressSignInPreferenceOptions;
+    successSignInModalConfig: SuccessSignInPreferenceOptions;
+}
+/**
+ * Default theme configuration with basic color scheme
+ */
+export declare const defaultTheme: VizbeeHomeSSOTheme;
+/**
+ * Default configuration for informational sign-in modal
+ * Shown when initial sign-in process starts
+ */
+export declare const defaultInformationalModalConfig: InformationalSignInPreferenceConfig;
+/**
+ * Default configuration for progress sign-in modal
+ * Shown while sign-in is in progress
+ */
+export declare const defaultProgressModalConfig: ProgressSignInPreferenceConfig;
+/**
+ * Default configuration for success sign-in modal
+ * Shown when sign-in process completes successfully
+ */
+export declare const defaultSuccessModalConfig: SuccessSignInPreferenceConfig;