@voxket-ai/voxket-live 1.0.35 → 1.0.36

package/dist/components/chat-view.d.ts

@@ -0,0 +1,13 @@
+import { ThemeType } from '../styles';
+import { VoxketClient } from '../core/client';
+import { DisplayType } from './widget';
+interface ChatViewProps {
+    client: VoxketClient;
+    theme?: ThemeType;
+    onBack?: () => void;
+    disabled?: boolean;
+    displayType?: DisplayType;
+    onEndChat?: () => void;
+}
+export declare function ChatView({ client, theme, onBack, disabled, displayType, onEndChat, }: ChatViewProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/compound/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Compound Components
+ * Advanced composable components for Voxket SDK
+ */
+export * from './types';
+export { VoxketSession as VoxketSessionComponent } from './voxket-session';
+export { SessionHeader } from './session-header';
+export { SessionContent } from './session-content';
+export { SessionControls } from './session-controls';
+export { SessionFooter } from './session-footer';
+export { VoxketSession as SessionContainer } from './voxket-session';

package/dist/components/compound/session-content.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from 'react';
+export interface SessionContentProps {
+    showChat?: boolean;
+    showTranscriptions?: boolean;
+    customContent?: ReactNode;
+    className?: string;
+}
+export declare function SessionContent({ showChat, showTranscriptions, customContent, className }: SessionContentProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/compound/session-controls.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+export interface SessionControlsProps {
+    showMicrophoneControl?: boolean;
+    showCameraControl?: boolean;
+    showScreenShareControl?: boolean;
+    showSessionActions?: boolean;
+    customControls?: React.ReactNode;
+    className?: string;
+}
+export declare function SessionControls({ showMicrophoneControl, showCameraControl, showScreenShareControl, showSessionActions, customControls, className }: SessionControlsProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/compound/session-footer.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+export interface SessionFooterProps {
+    showMetrics?: boolean;
+    showParticipants?: boolean;
+    showStatus?: boolean;
+    customFooter?: React.ReactNode;
+    className?: string;
+}
+export declare function SessionFooter({ showMetrics, showParticipants, showStatus, customFooter, className }: SessionFooterProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/compound/session-header.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Session Header Component
+ * Displays session status, agent info, and basic controls
+ */
+export interface SessionHeaderProps {
+    showConnectionStatus?: boolean;
+    showSessionInfo?: boolean;
+    showAgentInfo?: boolean;
+    className?: string;
+}
+export declare function SessionHeader({ showConnectionStatus, showSessionInfo, showAgentInfo, className }: SessionHeaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/compound/types.d.ts

@@ -0,0 +1,28 @@
+import { default as React, ReactNode } from 'react';
+export interface CompoundComponentContext {
+    variant?: 'default' | 'minimal' | 'enterprise';
+    size?: 'sm' | 'md' | 'lg';
+    theme?: string;
+    disabled?: boolean;
+    className?: string;
+}
+export declare const useCompoundContext: () => CompoundComponentContext;
+export interface CompoundProviderProps extends CompoundComponentContext {
+    children: ReactNode;
+}
+export declare function CompoundProvider({ children, ...context }: CompoundProviderProps): import("react/jsx-runtime").JSX.Element;
+export interface SlotProps {
+    name: string;
+    children?: ReactNode;
+    fallback?: ReactNode;
+    className?: string;
+}
+export declare function Slot({ name, children, fallback, className }: SlotProps): import("react/jsx-runtime").JSX.Element;
+export interface CompoundComponentProps {
+    variant?: 'default' | 'minimal' | 'enterprise';
+    size?: 'sm' | 'md' | 'lg';
+    theme?: string;
+    className?: string;
+    children?: ReactNode;
+}
+export declare function withCompoundComponent<T extends Record<string, any>>(Component: React.ComponentType<T>, subComponents?: Record<string, React.ComponentType<any>>): React.ComponentType<T> & Record<string, React.ComponentType<any>>;

package/dist/components/compound/voxket-session.d.ts

@@ -0,0 +1,12 @@
+import { default as React, ReactNode } from 'react';
+import { CompoundComponentProps } from './types';
+import { SessionConfig } from '../../types/core';
+export interface VoxketSessionProps extends CompoundComponentProps {
+    agentId?: string;
+    sessionConfig?: Partial<SessionConfig>;
+    autoStart?: boolean;
+    onSessionStart?: (sessionId: string) => void;
+    onSessionEnd?: (metrics: any) => void;
+    children?: ReactNode;
+}
+export declare const VoxketSession: React.ComponentType<VoxketSessionProps> & Record<string, React.ComponentType<any>>;

package/dist/components/interactive-component.d.ts

@@ -0,0 +1,11 @@
+import { ThemeType } from '../styles';
+import { InteractiveUIState } from '../types/rpc';
+interface InteractiveComponentProps {
+    interaction: InteractiveUIState | null;
+    theme: ThemeType;
+    onDismiss?: () => void;
+    client?: any;
+    addLocalMessage?: (content: string) => void;
+}
+export declare function InteractiveComponent({ interaction, theme, onDismiss, client, addLocalMessage }: InteractiveComponentProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/livekit/agent-control-bar/agent-control-bar.d.ts

@@ -13,8 +13,9 @@ export interface AgentControlBarProps extends React.HTMLAttributes<HTMLDivElemen
         error: Error;
     }) => void;
     theme?: ThemeType;
+    client?: any;
 }
 /**
  * A control bar specifically designed for voice assistant interfaces
  */
-export declare function AgentControlBar({ controls, saveUserChoices, capabilities, className, onSendMessage, onChatOpenChange, onDisconnect, onDeviceError, theme, ...props }: AgentControlBarProps): import("react/jsx-runtime").JSX.Element;
+export declare function AgentControlBar({ controls, saveUserChoices, capabilities, className, onSendMessage, onChatOpenChange, onDisconnect, onDeviceError, theme, client, ...props }: AgentControlBarProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/livekit/agent-control-bar/hooks/use-agent-control-bar.d.ts

@@ -1,5 +1,5 @@
 import { Track } from 'livekit-client';
-import { TrackReferenceOrPlaceholder, useTrackToggle } from '@livekit/components-react';
+import { TrackReferenceOrPlaceholder } from '@livekit/components-react';
 export interface ControlBarControls {
     microphone?: boolean;
     screenShare?: boolean;
@@ -14,13 +14,26 @@ export interface UseAgentControlBarProps {
         source: Track.Source;
         error: Error;
     }) => void;
+    client?: any;
 }
 export interface UseAgentControlBarReturn {
     micTrackRef: TrackReferenceOrPlaceholder;
     visibleControls: ControlBarControls;
-    microphoneToggle: ReturnType<typeof useTrackToggle<Track.Source.Microphone>>;
-    cameraToggle: ReturnType<typeof useTrackToggle<Track.Source.Camera>>;
-    screenShareToggle: ReturnType<typeof useTrackToggle<Track.Source.ScreenShare>>;
+    microphoneToggle: {
+        enabled: boolean;
+        pending: boolean;
+        toggle: (enabled?: boolean) => Promise<void>;
+    };
+    cameraToggle: {
+        enabled: boolean;
+        pending: boolean;
+        toggle: (enabled?: boolean) => Promise<void>;
+    };
+    screenShareToggle: {
+        enabled: boolean;
+        pending: boolean;
+        toggle: (enabled?: boolean) => Promise<void>;
+    };
     handleDisconnect: () => void;
     handleAudioDeviceChange: (deviceId: string) => void;
     handleVideoDeviceChange: (deviceId: string) => void;

package/dist/components/livekit/agent-control-bar/hooks/use-publish-permissions.d.ts

@@ -4,4 +4,4 @@ export interface PublishPermissions {
     screenShare: boolean;
     data: boolean;
 }
-export declare function usePublishPermissions(): PublishPermissions;
+export declare function usePublishPermissions(client?: any): PublishPermissions;

package/dist/components/livekit/device-select.d.ts

@@ -9,6 +9,7 @@ type DeviceSelectProps = React.ComponentProps<typeof SelectTrigger> & {
     onActiveDeviceChange?: (deviceId: string) => void;
     onDeviceListChange?: (devices: MediaDeviceInfo[]) => void;
     variant?: 'default' | 'small';
+    client?: any;
 };
-export declare function DeviceSelect({ kind, track, requestPermissions, onError, ...props }: DeviceSelectProps): import("react/jsx-runtime").JSX.Element;
+export declare function DeviceSelect({ kind, track, requestPermissions, onError, client, ...props }: DeviceSelectProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/livekit/track-toggle.d.ts

@@ -1,8 +1,8 @@
-import { useTrackToggle } from '@livekit/components-react';
+import { Track } from 'livekit-client';
 import { Toggle } from '../../components/ui/toggle';
 import * as React from 'react';
 export type TrackToggleProps = React.ComponentProps<typeof Toggle> & {
-    source: Parameters<typeof useTrackToggle>[0]['source'];
+    source: Track.Source;
     pending?: boolean;
 };
 export declare function TrackToggle({ source, pressed, pending, className, ...props }: TrackToggleProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/session-view.d.ts

@@ -1,5 +1,6 @@
 import { default as React } from 'react';
 import { ThemeType } from '../styles';
+import { DisplayType } from './widget';
 interface SessionViewProps {
     disabled: boolean;
     capabilities: {
@@ -11,6 +12,9 @@ interface SessionViewProps {
     participantName: string;
     loadingText?: string;
     theme?: ThemeType;
+    client?: any;
+    displayType?: DisplayType;
+    onBack?: () => void;
 }
-export declare const SessionView: ({ disabled, capabilities, sessionStarted, ref, participantName, loadingText, theme, }: React.ComponentProps<"div"> & SessionViewProps) => import("react/jsx-runtime").JSX.Element;
+export declare const SessionView: ({ disabled, capabilities, sessionStarted, ref, participantName, loadingText, theme, client, displayType, onBack, }: React.ComponentProps<"div"> & SessionViewProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/video/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Video Components
+ * Export all video-related components
+ */
+export { VideoTile } from './video-tile';
+export { VideoGrid } from './video-grid';
+export { VideoControls } from './video-controls';
+export type { VideoTrack, VideoLayout, VideoTileProps, VideoGridProps, VideoControlsProps, VideoState, VideoHookReturn } from '../../types/video';

package/dist/components/video/video-controls.d.ts

@@ -0,0 +1,2 @@
+import { VideoControlsProps } from '../../types/video';
+export declare function VideoControls({ localTrack, onToggleCamera, onToggleScreenShare, onLayoutChange, showLayoutControls, showCameraControls, showScreenShareControls, className }: VideoControlsProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/video/video-grid.d.ts

@@ -0,0 +1,2 @@
+import { VideoGridProps } from '../../types/video';
+export declare function VideoGrid({ tracks, layout, className, onLayoutChange, onTrackClick, maxVisibleTracks, showPagination }: VideoGridProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/video/video-tile.d.ts

@@ -0,0 +1,2 @@
+import { VideoTileProps } from '../../types/video';
+export declare function VideoTile({ track, participantName, showControls, showName, showMuteIndicator, isPinned, className, onClick, onPin, onUnpin }: VideoTileProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/video-view.d.ts

@@ -0,0 +1,13 @@
+import { ThemeType } from '../styles';
+import { VoxketClient } from '../core/client';
+import { DisplayType } from './widget';
+interface VideoViewProps {
+    client: VoxketClient;
+    theme?: ThemeType;
+    onBack?: () => void;
+    disabled?: boolean;
+    displayType?: DisplayType;
+    onEndCall?: () => void;
+}
+export default function VideoView({ client, theme, onBack, disabled, displayType, onEndCall }: VideoViewProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/welcome.d.ts

@@ -1,7 +1,10 @@
 import { ThemeType } from '../styles';
+import { SessionModality } from '../types/core';
 interface WelcomeProps {
     disabled: boolean;
     onStartCall: () => void;
+    onStartChat: () => void;
+    onStartVideo?: () => void;
     agentId: string;
     participantName: string;
     onAgentIdChange: (value: string) => void;
@@ -11,6 +14,7 @@ interface WelcomeProps {
     title?: string;
     subTitle?: string;
     theme?: ThemeType;
+    modalities?: SessionModality[];
 }
-export declare const Welcome: ({ disabled, onStartCall, prompts, statusMessage, title, subTitle, theme, }: WelcomeProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Welcome: ({ disabled, onStartCall, onStartChat, onStartVideo, prompts, statusMessage, title, subTitle, theme, modalities, }: WelcomeProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/widget.d.ts

@@ -1,4 +1,8 @@
 import { ThemeType } from '../styles';
+import { VoxketClient } from '../core/client';
+import { SessionModality } from '../types/core';
+export type DisplayType = 'fullscreen' | 'widget' | 'popup';
+export type PopupPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
 export interface VoxketWidgetProps {
     agentId: string;
     participantName?: string;
@@ -22,6 +26,13 @@ export interface VoxketWidgetProps {
     enableSessionLogging?: boolean;
     onSessionLogsUpdate?: (logs: any[]) => void;
     onSessionMetricsUpdate?: (metrics: any) => void;
+    modalities?: SessionModality[];
+    displayType?: DisplayType;
+    popupPosition?: PopupPosition;
+    popupTriggerText?: string;
+    onPopupToggle?: (isOpen: boolean) => void;
+    onDisplayTypeChange?: (displayType: DisplayType) => void;
+    voxketClient?: VoxketClient;
 }
 export default function Widget(props: VoxketWidgetProps & {
     prompts?: string[];

package/dist/core/client.d.ts

@@ -0,0 +1,183 @@
+import { default as React } from 'react';
+import { Room, RemoteParticipant, LocalParticipant, ConnectionState, Track } from 'livekit-client';
+import { VoxketEventEmitter } from './event-emitter';
+import { PluginManager } from '../plugins/plugin-system';
+import { VoxketConfig, SessionConfig, VoxketSession, VoxketEvents, SessionState, SessionMetrics, AgentInfo, ParticipantInfo, ChatMessage, TranscriptionSegment, SessionModality } from '../types/core';
+import { VoxketInteractiveView, ViewPresentationMode, InteractiveUIState, RpcEvents } from '../types/rpc';
+import { WidgetTheme } from '../styles';
+import { DisplayType, PopupPosition } from '../components/widget';
+export interface RenderUIOptions {
+    target?: string | HTMLElement;
+    modality?: SessionModality[];
+    theme?: WidgetTheme | 'dark' | 'light' | 'vox';
+    component?: 'widget' | 'session' | 'chat-only' | 'voice-only';
+    className?: string;
+    style?: React.CSSProperties;
+    autoStart?: boolean;
+    agentId?: string;
+    participantName?: string;
+    displayType?: DisplayType;
+    popupPosition?: PopupPosition;
+    popupTriggerText?: string;
+    width?: string;
+    height?: string;
+    onDisplayTypeChange?: (displayType: DisplayType) => void;
+}
+export interface VoxketClientConfig extends VoxketConfig {
+    agentId?: string;
+    participantName?: string;
+    modalities?: SessionModality[];
+    onConnected?: () => void;
+    onDisconnected?: (reason?: string) => void;
+    onError?: (error: Error) => void;
+    onMessageReceived?: (message: ChatMessage) => void;
+    onTranscriptionReceived?: (transcription: TranscriptionSegment) => void;
+    onSessionStateChanged?: (state: SessionState) => void;
+    onSessionStart?: (sessionId: string) => void;
+    onSessionEnd?: (metrics: any) => void;
+    onUserJoined?: (userId: string) => void;
+    onUserLeft?: (userId: string) => void;
+}
+export declare class VoxketClient extends VoxketEventEmitter<VoxketEvents & RpcEvents> {
+    private config;
+    private room;
+    private pluginManager;
+    private rpcManager;
+    private isConnected;
+    private currentSession;
+    private connectionState;
+    private renderedComponents;
+    private textStreamHandlersRegistered;
+    private currentAgentInfo;
+    private chatMessages;
+    constructor(config: VoxketClientConfig);
+    private setupEventListeners;
+    private setupRpcEventForwarding;
+    private initializeClient;
+    private setupRoomEventListeners;
+    private setupTextStreamHandlers;
+    fetchConnectionDetails(agentId?: string, participantName?: string, modalities?: SessionModality[]): Promise<{
+        serverUrl: string;
+        participantToken: string;
+        voxketSessionId: string;
+        agentInfo?: AgentInfo;
+    }>;
+    connect(agentId?: string, participantName?: string, modalities?: SessionModality[]): Promise<{
+        serverUrl: string;
+        participantToken: string;
+        voxketSessionId: string;
+        agentInfo?: AgentInfo;
+    }>;
+    disconnect(): Promise<void>;
+    createSession(config: SessionConfig): Promise<VoxketSession>;
+    startSession(agentId?: string, options?: {
+        participantName?: string;
+        modalities?: SessionModality[];
+        metadata?: Record<string, any>;
+    }): Promise<VoxketSession>;
+    endSession(): Promise<SessionMetrics | null>;
+    getCurrentSession(): VoxketSession | null;
+    getCurrentAgentInfo(): AgentInfo | null;
+    getChatMessages(): ChatMessage[];
+    addChatMessage(message: ChatMessage): void;
+    updateChatMessage(updatedMessage: ChatMessage): void;
+    clearChatMessages(): void;
+    renderUI(options?: RenderUIOptions): void;
+    removeUI(target?: string | HTMLElement): void;
+    removeAllUI(): void;
+    private forceCleanupFullscreenOverlays;
+    private resolveTarget;
+    private getTargetKey;
+    sendMessage(message: string, metadata?: Record<string, any>): Promise<void>;
+    sendChatMessage(message: string, metadata?: Record<string, any>): Promise<void>;
+    sendAttachments(files: File[], metadata?: Record<string, any>): Promise<void>;
+    sendAttachment(file: File, metadata?: Record<string, any>): Promise<void>;
+    toggleMicrophone(enabled?: boolean): Promise<void>;
+    setMicrophoneEnabled(enabled: boolean): Promise<void>;
+    toggleCamera(enabled?: boolean): Promise<void>;
+    setCameraEnabled(enabled: boolean): Promise<void>;
+    enableCamera(): Promise<void>;
+    disableCamera(): Promise<void>;
+    startScreenShare(): Promise<void>;
+    stopScreenShare(): Promise<void>;
+    getAudioInputDevices(): Promise<MediaDeviceInfo[]>;
+    getVideoInputDevices(): Promise<MediaDeviceInfo[]>;
+    setAudioInputDevice(deviceId: string): Promise<void>;
+    setVideoInputDevice(deviceId: string): Promise<void>;
+    getLocalParticipant(): LocalParticipant | null;
+    getRemoteParticipants(): RemoteParticipant[];
+    getPublishPermissions(): {
+        camera: boolean;
+        microphone: boolean;
+        screenShare: boolean;
+        data: boolean;
+    };
+    canPublishSource(source: 'camera' | 'microphone' | 'screenShare'): boolean;
+    getRoom(): Room | null;
+    getConnectionState(): ConnectionState;
+    get connected(): boolean;
+    getMicrophoneTrack(): import('livekit-client').LocalTrack<Track.Kind> | null | undefined;
+    getCameraTrack(): import('livekit-client').LocalTrack<Track.Kind> | null | undefined;
+    getScreenShareTrack(): import('livekit-client').LocalTrack<Track.Kind> | null | undefined;
+    get isMicrophoneEnabled(): boolean;
+    get isCameraEnabled(): boolean;
+    get isScreenShareEnabled(): boolean;
+    registerPlugin(plugin: any): void;
+    getPluginManager(): PluginManager;
+    getParticipants(): ParticipantInfo[];
+    getSessionMetrics(): SessionMetrics | null;
+    updateConfig(updates: Partial<VoxketClientConfig>): void;
+    startRecording(): Promise<void>;
+    stopRecording(): Promise<void>;
+    /**
+     * Register a frontend RPC method with a React component
+     * @param methodName The RPC method name to register
+     * @param component React component that implements VoxketInteractiveView
+     * @param presentationMode How the component should be displayed
+     */
+    registerFrontendRPC(methodName: string, component: VoxketInteractiveView, presentationMode?: ViewPresentationMode): Promise<void>;
+    /**
+     * Get the current interactive RPC component state
+     */
+    getCurrentInteraction(): InteractiveUIState | null;
+    /**
+     * Dismiss the current interactive component
+     */
+    dismissCurrentInteraction(): void;
+    /**
+     * Get all registered RPC methods
+     */
+    getRegisteredRpcMethods(): string[];
+    /**
+     * Unregister an RPC method
+     */
+    unregisterRpcMethod(methodName: string): void;
+    /**
+     * Register a custom event listener for VoxketClient events.
+     * This is a business-friendly alias for the inherited `on` method.
+     * @param eventName The event name to listen for (string)
+     * @param callback The callback function to invoke with event data
+     * @returns Unsubscribe function
+     *
+     * Example:
+     *   client.registerEventListener('chat.message.received', (msg) => { ... });
+     */
+    registerEventListener<K extends keyof (VoxketEvents & RpcEvents)>(eventName: K, callback: (data: any) => void): () => void;
+    /**
+     * Register a custom event emitter for a LiveKit text stream topic.
+     * This allows business/consumer code to listen for custom events sent via text stream.
+     * @param topic The topic name to listen for (string)
+     * @param handler The callback function to invoke with (data, participantInfo)
+     * @returns void
+     *
+     * Example:
+     *   client.registerEventEmitter('custom_event', (data) => { ... });
+     */
+    registerEventEmitter(topic: string, handler: (data: string) => void): void;
+    /**
+     * Convert markdown text to plain text by removing common markdown formatting
+     * @param markdownText The markdown text to convert
+     * @returns Plain text without markdown formatting
+     */
+    private convertMarkdownToText;
+}

package/dist/core/event-emitter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Type-safe event emitter for Voxket SDK
+ */
+export type EventMap = Record<string, (...args: any[]) => void>;
+export declare class VoxketEventEmitter<T extends EventMap> {
+    private listeners;
+    /**
+     * Add an event listener
+     */
+    on<K extends keyof T>(event: K, listener: T[K]): () => void;
+    /**
+     * Add a one-time event listener
+     */
+    once<K extends keyof T>(event: K, listener: T[K]): () => void;
+    /**
+     * Remove an event listener
+     */
+    off<K extends keyof T>(event: K, listener: T[K]): void;
+    /**
+     * Remove all listeners for an event
+     */
+    removeAllListeners<K extends keyof T>(event?: K): void;
+    /**
+     * Emit an event
+     */
+    emit<K extends keyof T>(event: K, ...args: Parameters<T[K]>): void;
+    /**
+     * Get the number of listeners for an event
+     */
+    listenerCount<K extends keyof T>(event: K): number;
+    /**
+     * Get all event names with listeners
+     */
+    eventNames(): (keyof T)[];
+}

package/dist/core/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Voxket SDK Core
+ * Main entry point for core SDK functionality
+ */
+export { VoxketClient } from './client';
+export { VoxketEventEmitter } from './event-emitter';
+export { VoxketClient as VoxketSDK } from './client';
+export type * from '../types/core';
+export type { RenderUIOptions, VoxketClientConfig } from './client';

package/dist/core/rpc-manager.d.ts

@@ -0,0 +1,46 @@
+import { Room } from 'livekit-client';
+import { VoxketEventEmitter } from '../core/event-emitter';
+import { VoxketInteractiveView, ViewPresentationMode, InteractiveUIState, RpcEvents } from '../types/rpc';
+/**
+ * Manager for Frontend RPC functionality
+ */
+export declare class RpcManager extends VoxketEventEmitter<RpcEvents> {
+    private room;
+    private registeredMethods;
+    private activeInteractions;
+    private currentInteraction;
+    constructor(room?: Room);
+    /**
+     * Set the LiveKit room instance
+     */
+    setRoom(room: Room): void;
+    /**
+     * Register a frontend RPC method with a React component
+     */
+    registerFrontendRPC(methodName: string, component: VoxketInteractiveView, presentationMode?: ViewPresentationMode): Promise<void>;
+    private awaitUserInteraction;
+    /**
+     * Clear an active interaction
+     */
+    private clearInteraction;
+    /**
+     * Get current interaction state
+     */
+    getCurrentInteraction(): InteractiveUIState | null;
+    /**
+     * Dismiss current interaction
+     */
+    dismissCurrentInteraction(): void;
+    /**
+     * Get all registered methods
+     */
+    getRegisteredMethods(): string[];
+    /**
+     * Unregister a method
+     */
+    unregisterMethod(methodName: string): void;
+    /**
+     * Clear all registrations and active interactions
+     */
+    clear(): void;
+}

package/dist/examples/agent-rpc-example.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Example: Agent triggers a give_assignment RPC with the exact schema your agent uses
+ * This simulates what an AI agent would do to trigger frontend interactive components
+ */
+export declare const agentRpcExample: {
+    checkAvailableRpcs(voxketClient: any): Promise<any>;
+    triggerAssignment(room: any, participantIdentity: string): Promise<any>;
+    processAssignmentResponse(response: any): Promise<{
+        status: any;
+        assignmentId: any;
+        timeSpent: any;
+        processed: boolean;
+        followupAction: string;
+    }>;
+    getAssignmentExamples(): {
+        marketing: {
+            title: string;
+            description: string;
+            estimated_time_of_completion: string;
+        };
+        technical: {
+            title: string;
+            description: string;
+            estimated_time_of_completion: string;
+        };
+        research: {
+            title: string;
+            description: string;
+            estimated_time_of_completion: string;
+        };
+        quick: {
+            title: string;
+            description: string;
+            estimated_time_of_completion: string;
+        };
+    };
+};
+export default agentRpcExample;

package/dist/examples/assignment-view.d.ts

@@ -0,0 +1,11 @@
+import { VoxketInteractiveView } from '../types/rpc';
+/**
+ * Example Assignment View - demonstrates how businesses can create interactive components
+ * This component receives data that matches the agent's JSON schema:
+ * {
+ *   "title": "string",
+ *   "description": "string",
+ *   "estimated_time_of_completion": "string"
+ * }
+ */
+export declare const AssignmentView: VoxketInteractiveView;

package/dist/examples/rpc-examples.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Example: How to register and use Frontend RPC methods
+ */
+export declare function RpcExamples(): import("react/jsx-runtime").JSX.Element;
+export default RpcExamples;