@vizbeetv/sdk-qa 7.8.36 → 7.8.38

package/types/index.d.ts

@@ -0,0 +1,486 @@
+// ---------------------------------------------------------------------------
+// Vizbee TV SDK — TypeScript type declarations
+// ---------------------------------------------------------------------------
+//
+// Hybrid surface:
+//  • The session / presence / messaging MODEL types below are RE-EXPORTED from
+//    declarations auto-generated off the TypeScript source (tsconfig.npm-types.json),
+//    so they never drift from the implementation.
+//  • The rest — the default-export `VizbeeSDK` API and its `continuity` tree
+//    (adapters, messages, context, UI, analytics, interceptors) — is plain JS
+//    in the SDK, has no TS source, and is therefore hand-maintained here.
+//
+// Named exports are intended for type annotations. Runtime values are reached
+// through the default export / `window.VizbeeSDK` (e.g.
+// `vizbee.continuity.adapters.PlayerAdapter`), not via value imports.
+// ---------------------------------------------------------------------------
+
+// ========================
+// Models & Enums (auto-generated from TS source — do not redeclare here)
+// ========================
+
+import {
+  SessionState,
+  SessionStateUtils,
+} from './vtvsdk/src/core/session/SessionState.js';
+import { SessionStateListener } from './vtvsdk/src/core/session/SessionStateListener.js';
+import { MemberInfo } from './vtvsdk/src/core/session/models/MemberInfo.js';
+import { MemberType, MemberTypeInfo } from './vtvsdk/src/core/session/models/MemberType.js';
+import { VizbeeDevice } from './vtvsdk/src/core/session/models/VizbeeDevice.js';
+import { VizbeeDeviceType } from './vtvsdk/src/core/session/models/VizbeeDeviceType.js';
+import {
+  PresenceEventResult,
+  PresenceEvent,
+} from './vtvsdk/src/core/session/models/presence/PresenceEventResult.js';
+import { VizbeeMessagingClient } from './vtvsdk/src/core/session/base/VizbeeMessagingClient.js';
+import { VizbeePresenceClient } from './vtvsdk/src/core/session/base/VizbeePresenceClient.js';
+import { VizbeeBicastSession } from './vtvsdk/src/core/session/bicast/VizbeeBicastSession.js';
+import { VizbeeBicastSessionManager } from './vtvsdk/src/core/session/bicast/VizbeeBicastSessionManager.js';
+import { VizbeePresenceManager } from './vtvsdk/src/core/session/bicast/VizbeePresenceManager.js';
+
+export {
+  SessionState,
+  SessionStateUtils,
+  SessionStateListener,
+  MemberInfo,
+  MemberType,
+  MemberTypeInfo,
+  VizbeeDevice,
+  VizbeeDeviceType,
+  PresenceEventResult,
+  PresenceEvent,
+  VizbeeMessagingClient,
+  VizbeePresenceClient,
+  VizbeeBicastSession,
+  VizbeeBicastSessionManager,
+  VizbeePresenceManager,
+};
+
+// ========================
+// Messages
+// ========================
+
+export declare class Track {
+  type: string;
+  id: number;
+
+  toJSON(): Record<string, unknown>;
+  fromJSON(trackInfo: Record<string, unknown>): void;
+}
+
+export declare class SubtitleTrack extends Track {
+  lang: string;
+  subtype: string;
+
+  toJSON(): Record<string, unknown>;
+  fromJSON(trackInfo: Record<string, unknown>): void;
+}
+
+export declare class VideoInfo {
+  guid: string;
+  isLive: boolean;
+  startTime: number;
+  videoUrl: string;
+  deeplink: string;
+  imgUrl: string;
+  title: string;
+  subtitle: string;
+  desc: string;
+  tracks: Track[];
+  cuepoints: number[];
+  customStreamInfo: unknown;
+  customMetadata: unknown;
+
+  toJson(): Record<string, unknown>;
+  fromJson(syncVideoInfo: Record<string, unknown>): void;
+}
+
+export declare class VideoStatus {
+  guid: string;
+  state: string;
+  currentPosition: number;
+  duration: number;
+  isLive: boolean;
+  isDvrSupported: boolean;
+  title: string;
+  subtitle: string;
+  videoUrl: string;
+  imgUrl: string;
+}
+
+export declare class VizbeeEvent {
+  type: string;
+  data: unknown;
+}
+
+export declare class AdStatus {
+  eventType: string;
+  eventData: Record<string, unknown>;
+
+  constructor(eventType: string, eventData: Record<string, unknown>);
+}
+
+export declare class PlayerState {
+  static readonly IDLE: string;
+  static readonly PREPARING: string;
+  static readonly LOADING: string;
+  static readonly STARTED: string;
+  static readonly PLAYING: string;
+  static readonly PAUSED: string;
+  static readonly BUFFERING: string;
+  static readonly INTERRUPTED: string;
+  static readonly ENDED: string;
+  static readonly ERROR: string;
+}
+
+export declare class AdEventType {
+  static readonly AD_POD_WAITING: string;
+  static readonly AD_POD_START: string;
+  static readonly AD_PREPARING: string;
+  static readonly AD_START: string;
+  static readonly AD_PLAYING: string;
+  static readonly AD_PAUSED: string;
+  static readonly AD_END: string;
+  static readonly AD_POD_END: string;
+  static readonly AD_ERROR: string;
+}
+
+// ========================
+// Adapters
+// ========================
+
+export declare class AppAdapter {
+  deeplinkHandler?: (videoInfo: VideoInfo) => void;
+  vizbeeEventHandler?: (event: VizbeeEvent) => void;
+  vizbeeSigninEventHandler?: (event: VizbeeEvent) => void;
+
+  setDeeplinkHandler(handler: (videoInfo: VideoInfo) => void): void;
+  setVizbeeEventHandler(handler: (event: VizbeeEvent) => void): void;
+  /** @deprecated since 7.5 — use setVizbeeEventHandler instead */
+  setSignInHandler(handler: (event: VizbeeEvent) => void): void;
+  /** @deprecated since 7.5 — use setVizbeeEventHandler instead */
+  setVizbeeSigninEventHandler(handler: (event: VizbeeEvent) => void): void;
+}
+
+export declare class BasePlayerAdapter {
+  playHandler?: () => void;
+  pauseHandler?: () => void;
+  seekHandler?: (timeInMs: number) => void;
+  stopHandler?: (stopReason?: string) => void;
+  videoInfoGetter?: () => VideoStatus | undefined;
+  availableTracksGetter?: () => Track[];
+  enabledTracksGetter?: () => Track[];
+  enableTracksHandler?: (trackIds: number[]) => void;
+  disableTracksHandler?: (trackIds: number[]) => void;
+  vizbeeEventHandler?: (event: VizbeeEvent) => void;
+
+  updateVideoInfo(videoInfo: VideoInfo): void;
+  setVideoInfoGetter(getter: () => VideoStatus | undefined): void;
+  getVideoInfo(): VideoStatus | undefined;
+  updateVideoStatus(videoStatus: VideoStatus): void;
+  setPlayHandler(handler: () => void): void;
+  setPauseHandler(handler: () => void): void;
+  setSeekHandler(handler: (timeInMs: number) => void): void;
+  setStopHandler(handler: (stopReason?: string) => void): void;
+  setAvailableTracksGetter(getter: () => Track[]): void;
+  setEnabledTracksGetter(getter: () => Track[]): void;
+  setEnableTracksHandler(handler: (trackIds: number[]) => void): void;
+  setDisableTracksHandler(handler: (trackIds: number[]) => void): void;
+  setVizbeeEventHandler(handler: (event: VizbeeEvent) => void): void;
+}
+
+export declare class PlayerAdapter extends BasePlayerAdapter {
+  playerType: string;
+  playerElement: HTMLElement;
+
+  constructor(playerType: string, playerElement: HTMLElement);
+
+  /** @deprecated since 7.5 — pass playerType in constructor */
+  setPlayerType(playerType: string): void;
+  /** @deprecated since 7.5 — pass playerElement in constructor */
+  setPlayerElement(playerElement: HTMLElement): void;
+  /** @deprecated since 7.5 — use setAvailableTracksGetter */
+  getTracksHandler(handler: () => Track[]): void;
+  /** @deprecated since 7.5 — use setEnabledTracksGetter */
+  getEnabledTracksHandler(handler: () => Track[]): void;
+  setCustomAttributesForMetrics(attributes: Record<string, unknown>): void;
+}
+
+export declare class AVPlayerAdapter extends PlayerAdapter {
+  constructor();
+
+  wrapListener(listener: Record<string, Function>): Record<string, Function>;
+  getListener(): Record<string, Function> | undefined;
+}
+
+export declare class AdAdapter {
+  adType: string;
+  playerElement: HTMLElement;
+
+  constructor(adType: string, playerElement: HTMLElement);
+
+  updateAdStatus(adStatus: AdStatus): void;
+}
+
+export declare class PlayerType {
+  static readonly UNKNOWN: string;
+  static readonly HTML: string;
+  static readonly AVPLAYER: string;
+  static readonly BITMOVIN: string;
+  static readonly VIDEOJS: string;
+  static readonly THEO: string;
+  static readonly SHAKA: string;
+}
+
+export declare class AdType {
+  static readonly UNKNOWN: string;
+  static readonly SSAI: string;
+  static readonly CSAI: string;
+}
+
+export declare class VideoStopReason {
+  static readonly STOP_REASON_UNKNOWN: string;
+  static readonly STOP_BY_USER: string;
+  static readonly STOP_IMPLICIT: string;
+  static readonly STOP_REASON_BEFORE_NEXT_VIDEO: string;
+}
+
+// ========================
+// Options
+// ========================
+
+export declare class ContinuityOptions {
+  configServiceProxyHost: string | undefined;
+  customAttributesForMetrics: Record<string, unknown> | undefined;
+}
+
+// ========================
+// Context
+// ========================
+
+export declare class ContinuityContext {
+  static getInstance(): ContinuityContext;
+
+  start(appId: string): void;
+  startWithOptions(appId: string, options: ContinuityOptions): void;
+
+  getAppAdapter(): AppAdapter;
+  setAppAdapter(appAdapter: AppAdapter): void;
+
+  getPlayerAdapter(): PlayerAdapter | undefined;
+  setPlayerAdapter(playerAdapter: PlayerAdapter): boolean;
+  removePlayerAdapter(playerAdapter: PlayerAdapter): boolean;
+  setPlayerAdapterWithVideoInfo(playerAdapter: PlayerAdapter, videoInfo: VideoInfo): boolean;
+
+  setVideoInfo(videoInfo: VideoInfo): boolean;
+  getVideoInfo(): VideoStatus | undefined;
+
+  getAdAdapter(adAdapterType?: string): AdAdapter | undefined;
+  setAdAdapter(adAdapter: AdAdapter): void | false;
+  removeAdAdapter(adAdapter: AdAdapter): void;
+  setAdType(adType: string): void;
+
+  stopVideo(): void;
+}
+
+// ========================
+// Analytics
+// ========================
+
+export declare class AnalyticsProvider {
+  wasAppLaunchedByVizbee(): boolean;
+  wasVideoStartedByVizbee(): boolean;
+  addProvider(attributesProvider: unknown, filterRegEx?: RegExp): void;
+  removeProvider(attributesProvider: unknown): void;
+  logMetrics(eventName: string, properties?: Record<string, unknown>): void;
+  setCustomAttributes(customAttributes: Record<string, unknown>): void;
+}
+
+// ========================
+// UI
+// ========================
+
+export interface LayoutPositionMap {
+  TOP_LEFT: string;
+  TOP_RIGHT: string;
+  BOTTOM_LEFT: string;
+  BOTTOM_RIGHT: string;
+}
+
+export interface SnackbarTheme {
+  color?: string;
+  bgColor?: string;
+}
+
+export interface SnackbarLayout {
+  position?: string;
+}
+
+export interface SnackbarBorder {
+  color?: string;
+}
+
+export interface SnackbarFont {
+  uri?: string;
+  family?: string;
+  size?: string;
+  weight?: string;
+}
+
+export interface SnackbarIcon {
+  uri?: string;
+}
+
+export declare class SnackbarUIConfig {
+  message: string;
+  theme: SnackbarTheme;
+  layout: SnackbarLayout;
+  border: SnackbarBorder;
+  font: SnackbarFont;
+  icon: SnackbarIcon;
+
+  fromJSON(options: Record<string, unknown>): void;
+  toJSON(): Record<string, unknown>;
+}
+
+export declare class Snackbar {
+  constructor(uiConfig: SnackbarUIConfig);
+
+  show(ttlInSec?: number): void;
+  hide(): void;
+}
+
+// ========================
+// Interceptors (Chromecast CAF)
+// ========================
+
+export declare class LoadRequestInterceptor {
+  constructor(adaptLoadRequest: (loadRequest: unknown) => unknown);
+
+  update(loadRequest: unknown): unknown;
+}
+
+// ========================
+// ContinuityFramework
+// ========================
+
+export interface AdaptersMap {
+  AppAdapter: typeof AppAdapter;
+  PlayerAdapter: typeof PlayerAdapter;
+  BasePlayerAdapter: typeof BasePlayerAdapter;
+  AVPlayerAdapter: typeof AVPlayerAdapter;
+  PlayerType: typeof PlayerType;
+  AdAdapter: typeof AdAdapter;
+  AdType: typeof AdType;
+  VideoStopReason: typeof VideoStopReason;
+}
+
+export interface MessagesMap {
+  VizbeeEvent: typeof VizbeeEvent;
+  VideoInfo: typeof VideoInfo;
+  VideoStatus: typeof VideoStatus;
+  AdEventType: typeof AdEventType;
+  AdStatus: typeof AdStatus;
+  PlayerState: typeof PlayerState;
+  SubtitleTrack: typeof SubtitleTrack;
+}
+
+export interface AnalyticsMap {
+  AnalyticsProvider: typeof AnalyticsProvider;
+}
+
+export interface UIMap {
+  LayoutPosition: LayoutPositionMap;
+  Snackbar: typeof Snackbar;
+  SnackbarUIConfig: typeof SnackbarUIConfig;
+}
+
+export interface XMessagesMap {
+  VizbeeBicastSessionManager: typeof VizbeeBicastSessionManager;
+  VizbeeBicastSession: typeof VizbeeBicastSession;
+  VizbeeMessagingClient: VizbeeMessagingClient;
+  VizbeePresenceManager: typeof VizbeePresenceManager;
+}
+
+export interface InterceptorsMap {
+  LoadRequestInterceptor: typeof LoadRequestInterceptor;
+}
+
+export interface ContinuityFramework {
+  ContinuityContext: typeof ContinuityContext;
+  ContinuityOptions: typeof ContinuityOptions;
+
+  /** Available on Samsung, LG, Vizio, Xbox platforms */
+  adapters: AdaptersMap;
+  /** Available on Samsung, LG, Vizio, Xbox platforms */
+  messages: MessagesMap;
+  /** Available on Samsung, LG, Vizio, Xbox platforms */
+  analytics: AnalyticsMap;
+  /** Available on Samsung, LG, Vizio, Xbox platforms */
+  ui: UIMap;
+
+  /** Available on all platforms */
+  xmessages: XMessagesMap;
+
+  /** Available on Chromecast only */
+  interceptors?: InterceptorsMap;
+  /** @deprecated — use interceptors.LoadRequestInterceptor */
+  LoadRequestInterceptor?: typeof LoadRequestInterceptor;
+}
+
+// ========================
+// Logger
+// ========================
+
+export interface VizbeeLogger {
+  setPrefix(prefix: string): void;
+  error(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  info(...args: unknown[]): void;
+  debug(...args: unknown[]): void;
+  d(...args: unknown[]): void;
+  w(...args: unknown[]): void;
+}
+
+// ========================
+// VizbeeSDK (default export)
+// ========================
+
+export interface VizbeeSDK {
+  /** SDK version string */
+  readonly VERSION: string;
+
+  /** Logger instance */
+  logger: VizbeeLogger;
+
+  /** V2 continuity framework — primary API surface */
+  readonly continuity: ContinuityFramework;
+
+  /** @deprecated — alias for continuity (backward compatibility) */
+  readonly framework: ContinuityFramework;
+
+  /**
+   * Initialize the SDK (V1 API).
+   * For V2 API, use `vizbee.continuity.ContinuityContext.getInstance().start(appId)` instead.
+   */
+  init(
+    appId: string,
+    adapters: Record<string, unknown>,
+    platformConfig?: Record<string, unknown>,
+    vzbOptions?: Record<string, unknown>,
+  ): void;
+
+  // -- V1 legacy methods --
+
+  setVideoGuid(guid: string, isLive?: boolean): boolean | undefined;
+  setVideoInfo(videoInfo: Record<string, unknown>): boolean | undefined;
+  setVideoStop(): boolean | undefined;
+  getAdsManager(): unknown;
+  setAdsVideo(adsVideo: unknown): boolean | undefined;
+  setVideoElement(newVideoElement: HTMLElement): boolean;
+  setAdAdapterType(adAdapterType: string): boolean | undefined;
+  wrapAVPlayerListener(listeners: Record<string, Function>): unknown;
+}
+
+declare const vizbee: VizbeeSDK;
+export default vizbee;

package/types/vtvsdk/src/core/session/SessionState.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Represents the possible states of a Vizbee session.
+ * These states define the lifecycle of a connection between devices.
+ */
+export declare enum SessionState {
+    /** Initial state or when connection is lost/terminated */
+    NOT_CONNECTED = 1,
+    /** Intermediate state while establishing connection */
+    CONNECTING = 2,
+    /** Successfully established connection */
+    CONNECTED = 3
+}
+/**
+ * Utility class providing helper methods for SessionState operations.
+ * This class is not instantiable and serves as a namespace for session state-related functions.
+ */
+export declare class SessionStateUtils {
+    /**
+     * Private constructor to prevent instantiation of utility class.
+     * All methods in this class are static and should be accessed directly via the class.
+     */
+    private constructor();
+    /**
+     * Converts a SessionState enum value to its human-readable string representation.
+     * Useful for logging, debugging, and UI display purposes.
+     *
+     * @param state - The SessionState enum value to convert
+     * @returns A human-readable string representation of the state
+     */
+    static toString(state: SessionState): string;
+    /**
+     * Type guard that checks if a number represents a valid SessionState.
+     * Useful for runtime validation of state values received from external sources.
+     *
+     * @param state - The number to check
+     * @returns A type predicate indicating if the number is a valid SessionState
+     *
+     * @example
+     * if (SessionStateUtils.isValidState(someNumber)) {
+     *   // TypeScript now knows someNumber is a SessionState
+     *   const stateString = SessionStateUtils.toString(someNumber);
+     * }
+     */
+    static isValidState(state: number): state is SessionState;
+}

package/types/vtvsdk/src/core/session/SessionStateListener.d.ts

@@ -0,0 +1,23 @@
+import { SessionState } from './SessionState.js';
+/**
+ * Defines a listener interface for monitoring session state changes in the Vizbee receiver SDK.
+ * This interface is implemented by components that need to react to changes in the connection
+ * state between devices.
+ *
+ * Implementation Note:
+ * This interface is part of the receiver SDK and corresponds to the SessionStateListener
+ * in the receiver-x-sdk, with package name differences to accommodate screen-specific
+ * functionality.
+ *
+ * @interface
+ */
+export interface SessionStateListener {
+    /**
+     * Called when the session state changes.
+     * Implementations should handle the transition to the new state appropriately,
+     * such as updating UI, managing resources, or triggering dependent operations.
+     *
+     * @param newState - The new session state that has been entered
+     */
+    onSessionStateChanged(newState: SessionState): void;
+}

package/types/vtvsdk/src/core/session/base/VizbeeMessagingClient.d.ts

@@ -0,0 +1,38 @@
+import { VizbeeDevice } from '../models/VizbeeDevice.js';
+/**
+ * VizbeeMessagingClient defines the contract for handling device-to-device messaging
+ * in a Vizbee network environment. This interface provides methods for sending messages
+ * to specific devices and managing message receivers.
+ *
+ * @interface
+ */
+export interface VizbeeMessagingClient {
+    /**
+     * Sends a message to a specific device within a designated namespace.
+     *
+     * @param payload - An object containing the message data to be sent
+     * @param namespace - A string identifying the messaging channel/category
+     * @param callback - Optional callback function to handle the send operation result
+     *
+     * @throws {Error} May throw an error if the message cannot be sent or if parameters are invalid
+     */
+    send(payload: Record<string, any>, namespace: string, callback?: (error?: Error) => void): void;
+    /**
+     * Registers a callback function to handle incoming messages for a specific namespace.
+     * Multiple receivers can be registered for the same namespace.
+     *
+     * @param namespace - The namespace to listen for messages on
+     * @param onReceive - Callback function that will be invoked when a message is received
+     *                    The callback receives the message payload, namespace, and source device
+     */
+    addReceiver(namespace: string, onReceive: (payload: Record<string, any>, namespace: string, device: VizbeeDevice) => void): void;
+    /**
+     * Unregisters a previously registered message receiver for a specific namespace.
+     * Both the namespace and callback function must match the original registration.
+     *
+     * @param namespace - The namespace from which to remove the receiver
+     * @param onReceive - The callback function to be removed. Must be the same reference
+     *                    as the one used in addReceiver
+     */
+    removeReceiver(namespace: string, onReceive: (payload: Record<string, any>, namespace: string, device: VizbeeDevice) => void): void;
+}

package/types/vtvsdk/src/core/session/base/VizbeePresenceClient.d.ts

@@ -0,0 +1,7 @@
+import { VizbeeDevice } from '../models/VizbeeDevice.js';
+import { PresenceEventResult } from '../models/presence/PresenceEventResult.js';
+export interface VizbeePresenceClient {
+    subscribe(onPresenceChanged: (result: PresenceEventResult) => void): void;
+    unsubscribe(onPresenceChanged: (result: PresenceEventResult) => void): void;
+    getMembers(): VizbeeDevice[];
+}

package/types/vtvsdk/src/core/session/bicast/VizbeeBicastMemberPresenceClientImpl.d.ts

@@ -0,0 +1,17 @@
+import { VizbeePresenceClient } from '../base/VizbeePresenceClient.js';
+import { PresenceEventResult } from '../models/presence/PresenceEventResult.js';
+import { VizbeeDevice } from '../models/VizbeeDevice.js';
+declare class VizbeeBicastMemberPresenceClientImpl implements VizbeePresenceClient {
+    private static readonly LOG_TAG;
+    private presenceCallbacks;
+    private syncController;
+    constructor();
+    private init;
+    private listenForSyncControllerAvailability;
+    private listenForSyncControllerSessionState;
+    subscribe(onPresenceChanged: (result: PresenceEventResult) => void): void;
+    unsubscribe(onPresenceChanged: (result: PresenceEventResult) => void): void;
+    getMembers(): VizbeeDevice[];
+    private toVizbeeDevice;
+}
+export { VizbeeBicastMemberPresenceClientImpl };

package/types/vtvsdk/src/core/session/bicast/VizbeeBicastMessagingClientImpl.d.ts

@@ -0,0 +1,54 @@
+import { VizbeeMessagingClient } from '../base/VizbeeMessagingClient.js';
+import { VizbeeDevice } from '../models/VizbeeDevice.js';
+/**
+ * Implementation of VizbeeMessagingClient that handles bi-directional messaging
+ * between devices in a Vizbee network. This implementation specifically interfaces
+ * with the global VZB SDK core for message handling.
+ *
+ * Note: This class expects the VZB global object to be available in the window context.
+ *
+ * @implements {VizbeeMessagingClient}
+ */
+declare class VizbeeBicastMessagingClientImpl implements VizbeeMessagingClient {
+    /**
+     * Map storing message receivers for each namespace.
+     * Key: namespace string
+     * Value: callback function to handle received messages
+     */
+    private namespaceAndReceiverMap;
+    constructor();
+    /**
+     * Sends a message through the VZB SDK core within the specified namespace.
+     * Returns a promise that resolves when the message is successfully sent.
+     *
+     * @param payload - The message data to be sent
+     * @param namespace - The target namespace for the message
+     * @returns Promise<void> - Resolves on successful send, rejects on failure
+     * @throws {Error} When the VZB SDK encounters an error during message transmission
+     */
+    send(payload: any, namespace: string): Promise<void>;
+    /**
+     * Registers a callback function to handle incoming messages for a specific namespace.
+     *
+     * @param namespace - The namespace to listen for messages on
+     * @param onReceive - Callback function to be invoked when a message is received
+     */
+    addReceiver(namespace: string, onReceive: (payload: any, namespace: string, device: VizbeeDevice) => void): void;
+    /**
+     * Removes a previously registered message receiver for a specific namespace.
+     *
+     * @param namespace - The namespace from which to remove the receiver
+     * @param onReceive - The callback function to be removed
+     */
+    removeReceiver(namespace: string, onReceive: (payload: any, namespace: string, device: VizbeeDevice) => void): void;
+    /**
+     * Internal message handler that processes incoming messages and routes them
+     * to the appropriate receiver callback based on the namespace.
+     *
+     * @param namespace - The namespace of the received message
+     * @param payload - The message data received
+     * @param device - The source device that sent the message
+     */
+    onReceive(namespace: string, payload: any, device: VizbeeDevice): void;
+}
+export { VizbeeBicastMessagingClientImpl };