@modelnex/sdk 0.1.1 → 0.5.3

package/dist/index.d.ts

@@ -2,7 +2,40 @@ import React$1 from 'react';
 import { z } from 'zod';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
-type TourStepType = 'narrate' | 'act' | 'ask_and_fill' | 'user_input' | 'ask_or_fill';
+type ExperienceType = 'tour' | 'onboarding';
+type TourStepType = 'narrate' | 'act' | 'input' | 'ask_and_fill' | 'user_input' | 'ask_or_fill' | 'wait_then_act';
+type TourUserActionEvent = 'click' | 'input' | 'change' | 'blur';
+interface TourActionTarget {
+    uid?: string;
+    testId?: string;
+    fingerprint?: string;
+    textContaining?: string;
+}
+interface TourReplyGate {
+    type: 'none' | 'user_action';
+    event?: TourUserActionEvent;
+    target?: TourActionTarget;
+}
+interface TourReply {
+    id?: string;
+    text: string;
+    delayMs?: number;
+    gate?: TourReplyGate;
+}
+interface TourPathPolicy {
+    /** Relative path captured at record time and used for validation/recovery */
+    recordedPath: string;
+    /** Whether the runtime should attempt to recover by navigating back to the recorded path */
+    recoverOnMismatch?: boolean;
+}
+interface TourExecutionPolicy {
+    /** Clicks and route-changing actions end the current execution cycle */
+    clickIsTerminal?: boolean;
+    /** Capture a screenshot after a terminal action before the next LLM turn */
+    screenshotAfterTerminal?: boolean;
+    /** Start fetching the next speech chunk this long before the current clip ends */
+    ttsPrefetchLeadMs?: number;
+}
 interface TourStepElement {
     /** data-testid value — primary anchor; survives DOM restructuring */
     testId?: string;
@@ -11,13 +44,77 @@ interface TourStepElement {
     /** Visible label at record time — second fallback */
     textContaining: string;
 }
+interface TourRecordedClick {
+    /** Relative URL where the click was captured, including search/hash when present */
+    url: string;
+    /** Human-readable label captured from the clicked element */
+    label: string;
+    /** Tag name of the clicked element */
+    tagName: string;
+    /** data-testid value if available */
+    testId?: string;
+    /** DOM fingerprint captured at record time */
+    fingerprint: string;
+    /** Visible text or placeholder captured at record time */
+    textContaining: string;
+}
+type TourCaptureEventType = 'session_start' | 'route' | 'hover' | 'click' | 'input' | 'note';
+interface TourCaptureEvent {
+    id: string;
+    type: TourCaptureEventType;
+    order: number;
+    timestamp: string;
+    url: string;
+    label?: string;
+    tagName?: string;
+    testId?: string;
+    fingerprint?: string;
+    textContaining?: string;
+    fieldType?: string;
+    valueSample?: string;
+    note?: string;
+    stepTypeHint?: TourStepType;
+    metadata?: Record<string, unknown>;
+}
+interface TourGenerationMetadata {
+    mode: 'capture_v1';
+    generatedAt: string;
+    eventCount: number;
+    noteCount: number;
+    generatedStepCount: number;
+}
+interface OnboardingStepWaitCondition {
+    mode: 'any_input' | 'specific_action' | 'manual_continue';
+    event?: TourUserActionEvent;
+    target?: TourActionTarget;
+    helperText?: string;
+}
+interface OnboardingStepMetadata {
+    expectedUserAction?: 'click' | 'input' | 'change' | 'submit';
+    waitTarget?: TourActionTarget;
+    completionSignal?: 'url_change' | 'modal_open' | 'field_populated' | 'toast_visible' | 'manual_continue';
+    required?: boolean;
+    successStateHint?: string;
+    manualTakeover?: boolean;
+    waitCondition?: OnboardingStepWaitCondition;
+}
+interface TourStepSource {
+    origin: 'generated' | 'manual_note';
+    captureEventIds?: string[];
+    confidence?: number;
+    note?: string;
+}
 interface TourStep {
     order: number;
     type: TourStepType;
-    /** Route pattern for navigation (e.g. "/documents", "/documents/*") */
+    /** Relative URL for the recorded page state (for example "/documents?tab=drafts#filters") */
     url?: string;
+    /** Path validation / recovery metadata */
+    path?: TourPathPolicy;
     /** Target element for highlight / interaction */
     element?: TourStepElement;
+    /** Raw click trail captured while the subscriber recorded this step */
+    recordedClicks?: TourRecordedClick[];
     /** LLM-polished narration spoken via TTS to end user */
     narration: string;
     /** Subscriber's original spoken words — stored for re-editing */
@@ -28,20 +125,72 @@ interface TourStep {
     goal?: string;
     /** Pacing for narrate steps */
     waitFor?: 'voice_next' | 'auto_advance';
-}
-type TourTrigger = 'first_visit' | 'feature_unlock' | 'idle_on_empty_state' | 'return_visit' | 'new_feature' | 'manual';
+    /** Optional queued replies with delays and gating rules */
+    replies?: TourReply[];
+    /** Optional per-step execution overrides */
+    execution?: TourExecutionPolicy;
+    /** How this step was produced during V1 workflow capture */
+    source?: TourStepSource;
+    /** Optional onboarding-specific step metadata */
+    onboarding?: OnboardingStepMetadata;
+}
+type TourTrigger = 'first_visit' | 'feature_launch' | 'feature_unlocked' | 'feature_unlock' | 'new_feature' | 'manual';
+type TourStartPolicy = 'immediate_start' | 'prompt_only' | 'manual_only';
+type TourNotificationType = 'bubble_card' | 'modal';
 interface TourVoiceConfig {
     language: string;
     ttsVoice?: string;
+    ttsPrefetchLeadMs?: number;
+}
+interface ExperienceModalConfig {
+    title?: string;
+    description?: string;
+    buttonText?: string;
+    cancelButtonText?: string;
+    backgroundColor?: string;
+    textColor?: string;
+}
+interface ExperiencePresentation {
+    theme?: {
+        tone?: 'guide' | 'coach' | 'operator';
+        accentColor?: string;
+        icon?: string;
+    };
+    modalConfig?: ExperienceModalConfig;
+}
+interface ExperienceGoal {
+    primaryAction?: string;
+    successMetric?: 'completed' | 'activated_feature' | 'submitted_input';
 }
 interface Tour {
     id: string;
+    type?: ExperienceType;
     name: string;
     websiteId: string;
     targetUserTypes: string[];
     trigger: TourTrigger;
+    startPolicy?: TourStartPolicy;
+    notificationType?: TourNotificationType;
+    featureKey?: string;
     voice: TourVoiceConfig;
+    execution?: TourExecutionPolicy;
     steps: TourStep[];
+    presentation?: ExperiencePresentation;
+    goal?: ExperienceGoal;
+    capture?: {
+        experienceType?: ExperienceType;
+        instructions?: {
+            transcript?: string;
+            noteEvents?: TourCaptureEvent[];
+        };
+        notes?: RecordingStep[];
+        onboardingHints?: {
+            inferredWaitTargets?: number;
+            inferredCompletionSignals?: number;
+        };
+        events?: TourCaptureEvent[];
+        generation?: TourGenerationMetadata;
+    };
     status: 'draft' | 'published';
     createdAt: string;
     updatedAt: string;
@@ -55,21 +204,32 @@ interface UserProfile {
     /** User ID for per-user completion state */
     userId?: string;
 }
+interface TourFacts {
+    /** Feature keys currently available to the user, used for feature_unlocked tours */
+    features?: string[];
+}
 /** Playback state machine states */
-type TourPlaybackState = 'idle' | 'intro' | 'executing' | 'waiting_voice' | 'waiting_input' | 'complete';
+type TourPlaybackState = 'idle' | 'intro' | 'executing' | 'thinking' | 'waiting_voice' | 'waiting_input' | 'paused' | 'complete';
 /** Internal recording step being built */
 interface RecordingStep {
     order: number;
     type: TourStepType;
+    /** Relative URL for the recorded page state (for example "/documents?tab=drafts#filters") */
     url: string;
+    path?: TourPathPolicy;
     element?: TourStepElement & {
         label?: string;
     };
+    recordedClicks?: TourRecordedClick[];
     rawNarration: string;
     narration: string;
     ask?: string;
     goal?: string;
     waitFor?: 'voice_next' | 'auto_advance';
+    replies?: TourReply[];
+    execution?: TourExecutionPolicy;
+    source?: TourStepSource;
+    onboarding?: OnboardingStepMetadata;
 }
 
 /**
@@ -321,15 +481,36 @@ interface ModelNexChatBubbleProps {
     }>;
     /** Welcome message when chat is empty */
     welcomeMessage?: string;
+    /** Name of the AI agent displayed in the header */
+    agentName?: string;
     /** Display name of the app — used in tour intro narration */
     appName?: string;
+    /** Save recorded flows as tours or onboarding without changing the recorder UX */
+    recordingExperienceType?: ExperienceType;
+    /** Custom theme overrides */
+    theme?: {
+        accentColor?: string;
+        accentForeground?: string;
+        panelWidth?: string;
+        panelMaxHeight?: string;
+        bubbleSize?: string;
+        bubbleIconSize?: string;
+        borderRadius?: string;
+        zIndex?: number;
+    };
 }
 /**
  * Chat interface for natural language commands.
  * Shows conversation history; on exit, the agent summarizes what it did and suggests next steps.
  * Use within ModelNexProvider. Omit to use your own UI with useRunCommand.
  */
-declare function ModelNexChatBubble({ placeholder, defaultCommand, className, onCommand, welcomeMessage, appName, }: ModelNexChatBubbleProps): react_jsx_runtime.JSX.Element;
+declare function ModelNexChatBubble({ placeholder, defaultCommand, className, onCommand, welcomeMessage, agentName, appName, recordingExperienceType, theme, }: ModelNexChatBubbleProps): React$1.ReactPortal | null;
+
+interface ModelNexOnboardingPanelProps {
+    appName?: string;
+    title?: string;
+}
+declare function ModelNexOnboardingPanel({ appName, title, }: ModelNexOnboardingPanelProps): react_jsx_runtime.JSX.Element;
 
 /**
  * Toggle and read the action-highlight overlay state.
@@ -388,14 +569,25 @@ declare global {
     }
 }
 interface VoiceHook {
-    /** Speak text via Deepgram TTS (proxied through server). Uses WebRTC loopback for AEC when available. */
-    speak: (text: string, voiceId?: string) => Promise<void>;
+    /** Speak text via Deepgram TTS (proxied through server). Uses WebRTC loopback for AEC when available.
+     * The returned promise always settles when the scheduled playback settles; callers can choose whether to await it.
+     */
+    speak: (text: string, voiceId?: string, options?: {
+        onNearEnd?: () => void;
+        prefetchLeadMs?: number;
+        waitForCompletion?: boolean;
+        interrupt?: boolean;
+    }) => Promise<void>;
     /** Stop any in-progress TTS playback immediately */
     stopSpeaking: () => void;
+    /** Warm a TTS clip into the local cache so playback can start with less latency */
+    prefetchSpeech: (text: string, voiceId?: string) => Promise<void>;
     /** Start STT listening — Deepgram STT with AEC when supported, else Web Speech API */
     startListening: (onResult: (transcript: string) => void, onInterruption?: (transcript: string) => void, onError?: (err: string) => void, options?: {
         continuous?: boolean;
         lang?: string;
+        onSpeechStarted?: () => void;
+        onInterimResult?: (transcript: string) => void;
     }) => void;
     /** Stop STT listening */
     stopListening: () => void;
@@ -409,6 +601,10 @@ interface VoiceHook {
 }
 declare function useVoice(serverUrl: string): VoiceHook;
 
+interface StartTourOptions {
+    reviewMode?: boolean;
+    reviewMetadata?: Record<string, unknown>;
+}
 interface TourPlaybackHook {
     /** Whether a tour is currently running */
     isActive: boolean;
@@ -420,18 +616,57 @@ interface TourPlaybackHook {
     activeTour: Tour | null;
     /** Playback state */
     playbackState: TourPlaybackState;
+    /** Whether current playback is a review/test preview */
+    isReviewMode: boolean;
+    /** Active preview run id if review mode is enabled */
+    previewRunId: string | null;
+    /** Whether a correction is being submitted */
+    reviewSubmitting: boolean;
+    /** Status message for the latest review action */
+    reviewStatusMessage: string | null;
+    /** Prompted tour awaiting user confirmation */
+    pendingTour: Tour | null;
+    /** Latest server-authored state snapshot for this experience */
+    serverState: TourServerState | null;
     /** Start a specific tour manually */
-    startTour: (tour: Tour) => void;
+    startTour: (tour: Tour, options?: StartTourOptions) => void;
+    /** Accept the currently pending prompt and start playback */
+    acceptPendingTour: () => void;
+    /** Dismiss the currently pending prompt */
+    dismissPendingTour: () => void;
     /** Advance to next step (voice "next" command) */
     advanceStep: () => void;
     /** Skip the entire tour */
     skipTour: () => void;
+    /** Explicitly pause the tour agent (for feedback/review) */
+    pauseTour: () => void;
+    /** Resume the tour agent after a pause */
+    resumeTour: () => void;
     /** Repeat current step narration */
     repeatStep: () => void;
     /** Handle a voice input during the tour */
     handleVoiceInput: (transcript: string) => void;
     /** Handle a text input during an ask step */
     handleTextInput: (text: string) => void;
+    /** Save a correction against the current preview step */
+    submitReviewFeedback: (utterance: string, apply?: boolean) => Promise<void>;
+}
+interface TourServerState {
+    runId: number | null;
+    turnId: string | null;
+    stepIndex: number;
+    phase: string;
+    isActive: boolean;
+    isPaused: boolean;
+    awaitingUserInput: boolean;
+    pendingCommandId: string | null;
+    pendingCommandBatch: {
+        commandBatchId: string | null;
+        stepIndex: number | null;
+        turnId: string | null;
+    } | null;
+    currentUrl?: string | null;
+    reason?: string;
 }
 interface UseTourPlaybackOptions {
     serverUrl: string;
@@ -443,16 +678,34 @@ interface UseTourPlaybackOptions {
     socketId?: string | null;
     websiteId?: string;
     userProfile?: UserProfile;
+    tourFacts?: TourFacts;
     voice: VoiceHook;
     appName?: string;
     /** Pass the page's current state to the LLM agent */
     extractedElements?: any[];
+    /** Shared tag store for resilient selector/text fallback resolution */
+    tagStore?: TagStore | null;
     /** Called when a tour step changes — for updating progress panel */
     onStepChange?: (stepIndex: number, total: number, tour: Tour) => void;
     /** Called when tour completes or is skipped */
     onTourEnd?: () => void;
-}
-declare function useTourPlayback({ serverUrl, commandUrl, toursApiBase, socketId, websiteId, userProfile, voice, appName, extractedElements, onStepChange, onTourEnd, }: UseTourPlaybackOptions): TourPlaybackHook;
+    /** Disable tour autoplay/playback while another mode owns voice I/O */
+    disabled?: boolean;
+    /** Shared runtime, but allow a distinct product surface such as onboarding */
+    experienceType?: ExperienceType;
+    /** Whether to show global floating captions (usually true when bubble is minimized, false when expanded) */
+    showCaptions?: boolean;
+    /** Disable internal pending prompt/query discovery when a higher-level controller owns it */
+    enableAutoDiscovery?: boolean;
+}
+declare function useTourPlayback({ serverUrl, commandUrl, toursApiBase, socketId, websiteId, userProfile, tourFacts, voice, appName, extractedElements, tagStore, onStepChange, onTourEnd, disabled, experienceType, showCaptions, enableAutoDiscovery, }: UseTourPlaybackOptions): TourPlaybackHook;
+
+type ExperiencePlaybackHook = TourPlaybackHook;
+declare function useExperiencePlayback(...args: Parameters<typeof useTourPlayback>): TourPlaybackHook;
+
+type UseOnboardingPlaybackOptions = Omit<Parameters<typeof useTourPlayback>[0], 'experienceType'>;
+type OnboardingPlaybackHook = TourPlaybackHook;
+declare function useOnboardingPlayback(options: UseOnboardingPlaybackOptions): TourPlaybackHook;
 
 interface RecordedElement {
     el: HTMLElement;
@@ -467,6 +720,9 @@ interface RecordingModeHook {
     phase: RecordingPhase;
     steps: RecordingStep[];
     stepCount: number;
+    captureEventCount: number;
+    capturedTranscript: string;
+    isVoiceCaptureActive: boolean;
     isRecording: boolean;
     selectedElement: RecordedElement | null;
     pendingNarration: string;
@@ -479,6 +735,7 @@ interface RecordingModeHook {
     cancelSelection: () => void;
     setStepType: (type: TourStepType) => void;
     startNarration: () => void;
+    finishNarration: () => Promise<void>;
     submitTextNarration: (text: string) => Promise<void>;
     approveNarration: () => void;
     redoNarration: () => void;
@@ -486,18 +743,43 @@ interface RecordingModeHook {
     continueRecording: () => void;
     undoLastStep: () => void;
     previewSteps: () => void;
+    prepareToStopRecording: () => void;
     stopRecording: (tourName: string, targetUserTypes: string[]) => Promise<string | null>;
+    toggleVoiceCapture: () => void;
     /** Abandon recording — discard all steps and exit recording mode */
     cancelRecording: () => void;
     handleVoiceCommand: (transcript: string) => void;
 }
 interface UseRecordingModeOptions {
     serverUrl: string;
+    toursApiBase?: string;
     websiteId?: string;
     voice: VoiceHook;
     onPreview?: (steps: RecordingStep[]) => void;
-}
-declare function useRecordingMode({ serverUrl, websiteId, voice, onPreview, }: UseRecordingModeOptions): RecordingModeHook;
+    experienceType?: ExperienceType;
+}
+declare function buildRecordingCapturePayload({ experienceType, steps, captureEvents, capturedTranscript, }: {
+    experienceType?: ExperienceType;
+    steps?: RecordingStep[];
+    captureEvents?: TourCaptureEvent[];
+    capturedTranscript?: string;
+}): {
+    generation: {
+        mode: "capture_v1";
+        generatedAt: string;
+        eventCount: number;
+        noteCount: number;
+        generatedStepCount: number;
+    };
+    instructions?: {
+        noteEvents?: TourCaptureEvent[] | undefined;
+        transcript?: string | undefined;
+    } | undefined;
+    experienceType: ExperienceType;
+    events: TourCaptureEvent[];
+    notes: RecordingStep[];
+};
+declare function useRecordingMode({ serverUrl, toursApiBase, websiteId, voice, onPreview, experienceType, }: UseRecordingModeOptions): RecordingModeHook;
 
 interface TourProgressPanelProps {
     tour: Tour;
@@ -512,11 +794,15 @@ declare function TourProgressPanel({ tour, currentStepIndex, onSkip, voiceOnly }
 interface RecordingOverlayProps {
     stepIndex: number;
     stepCount: number;
+    captureEventCount: number;
+    capturedTranscript: string;
+    isVoiceCaptureActive: boolean;
     phase: RecordingPhase;
     pendingNarration: string;
     polishedNarration: string;
     isListening: boolean;
     onMarkStep: () => void;
+    onToggleVoiceCapture: () => void;
     onElementSelected: (recorded: RecordedElement) => void;
     onPageLevelStep: () => void;
     onStepTypeConfirmed: (type: TourStepType) => void;
@@ -531,13 +817,43 @@ interface RecordingOverlayProps {
     onCancelRecording: () => void;
     onStopRecording: () => void;
 }
-declare function RecordingOverlay({ stepIndex, stepCount, phase, pendingNarration, polishedNarration, isListening, onMarkStep, onElementSelected, onPageLevelStep, onStepTypeConfirmed, onStartNarration, onSubmitTextNarration, onNarrationApprove, onNarrationRedo, onNarrationEdit, onAddNextStep, onDoneRecording, onCancel, onCancelRecording, onStopRecording, }: RecordingOverlayProps): react_jsx_runtime.JSX.Element;
+declare function RecordingOverlay({ stepIndex, stepCount, captureEventCount, capturedTranscript, isVoiceCaptureActive, phase, pendingNarration, polishedNarration, isListening, onMarkStep, onToggleVoiceCapture, onElementSelected, onPageLevelStep, onStepTypeConfirmed, onStartNarration, onSubmitTextNarration, onNarrationApprove, onNarrationRedo, onNarrationEdit, onAddNextStep, onDoneRecording, onCancel, onCancelRecording, onStopRecording, }: RecordingOverlayProps): react_jsx_runtime.JSX.Element;
+
+declare function isAskDrivenInputStepType(stepType?: string | null): boolean;
+declare function isInteractiveInputStepType(stepType?: string | null): boolean;
+declare function isManualOnboardingStep(step?: Pick<TourStep, 'type' | 'onboarding'> | null): boolean;
+declare function buildRecordingStepGoal(stepType: TourStepType, selectedElement: {
+    label?: string;
+    textContaining?: string;
+} | null, recordedClicks?: Array<{
+    label?: string;
+}>): string | undefined;
+declare function inferOnboardingMetadataForStep(step: Pick<TourStep, 'type' | 'element' | 'goal' | 'ask'>): OnboardingStepMetadata | undefined;
+
+declare function shouldShowRecordingOverlay(phase: RecordingPhase): boolean;
+declare function isRecordingDraftGenerating(phase: RecordingPhase): boolean;
+declare function getRecordingDraftActionLabel(phase: RecordingPhase): string;
+declare function getRecordingDraftStatusMessage(phase: RecordingPhase, experienceType: ExperienceType): string;
+
+interface SavedDraftPreview {
+    id: string;
+    experienceType: ExperienceType;
+}
+type PreviewLaunchSource = 'standard' | 'query_param';
+declare function getPreviewQueryParamName(experienceType: ExperienceType): 'modelnex_test_tour' | 'modelnex_test_onboarding';
+declare function buildDraftPreviewUrl(currentUrl: string, draft: SavedDraftPreview): string;
+declare function shouldPromptForPreviewStart(notificationType: TourNotificationType | undefined, _source: PreviewLaunchSource): boolean;
+declare function persistActiveDraftPreview(draft: SavedDraftPreview): void;
+declare function readActiveDraftPreview(): SavedDraftPreview | null;
+declare function clearActiveDraftPreview(experienceType?: ExperienceType): void;
 
 interface ModelNexProviderProps {
-    children: React$1.ReactNode;
+    children?: unknown;
     serverUrl?: string;
     /** Base URL for agent commands. Use same-origin path (e.g. /api/modelnex) to avoid CORS. Default: serverUrl */
     commandUrl?: string;
+    /** Disable the realtime socket connection while still rendering the SDK UI */
+    disableSocket?: boolean;
     /** Identifier for the integrated website, for multi-tenancy */
     websiteId?: string;
     /**
@@ -547,6 +863,8 @@ interface ModelNexProviderProps {
      * userId — used for per-user tour completion state
      */
     userProfile?: UserProfile;
+    /** Optional product facts used for feature-triggered tours */
+    tourFacts?: TourFacts;
     /**
      * Same-origin base for tour API (e.g. /api/modelnex/api).
      * When set, ?modelnex_test_tour= fetches via this path to avoid CORS.
@@ -559,4 +877,4 @@ interface ModelNexProviderProps {
 }
 declare const ModelNexProvider: React$1.FC<ModelNexProviderProps>;
 
-export { type AgentDebug, type AgentTraceLlmInput, type AgentTraceStep, type ChatMessage, type ExtractedElement, ModelNexChatBubble, type ModelNexChatBubbleProps, ModelNexProvider, type ModelNexProviderProps, type RecordingModeHook, RecordingOverlay, type RunCommandResult, StudioOverlay, type TagData, type TagStore, type Tour, type TourPlaybackHook, type TourPlaybackState, TourProgressPanel, type TourStep, type TourStepType, type TourTrigger, UIStateProvider, type UseRegisterActionOptions, type UserProfile, type VoiceHook, extractInteractiveElements, generateFingerprint, useActionHighlight, useAgentViewport, useAutoExtract, useRecordingMode, useRegisterAction, useRunCommand, useTagStore, useTourPlayback, useUIState, useViewportTrack, useVisibleIds, useVoice };
+export { type AgentDebug, type AgentTraceLlmInput, type AgentTraceStep, type ChatMessage, type ExperienceGoal, type ExperiencePlaybackHook, type ExperiencePresentation, type ExperienceType, type ExtractedElement, ModelNexChatBubble, type ModelNexChatBubbleProps, ModelNexOnboardingPanel, type ModelNexOnboardingPanelProps, ModelNexProvider, type ModelNexProviderProps, type OnboardingPlaybackHook, type OnboardingStepMetadata, type PreviewLaunchSource, type RecordingModeHook, RecordingOverlay, type RunCommandResult, type SavedDraftPreview, StudioOverlay, type TagData, type TagStore, type Tour, type TourFacts, type TourNotificationType, type TourPlaybackHook, type TourPlaybackState, TourProgressPanel, type TourStartPolicy, type TourStep, type TourStepType, type TourTrigger, UIStateProvider, type UseRegisterActionOptions, type UserProfile, type VoiceHook, buildDraftPreviewUrl, buildRecordingCapturePayload, buildRecordingStepGoal, clearActiveDraftPreview, extractInteractiveElements, generateFingerprint, getPreviewQueryParamName, getRecordingDraftActionLabel, getRecordingDraftStatusMessage, inferOnboardingMetadataForStep, isAskDrivenInputStepType, isInteractiveInputStepType, isManualOnboardingStep, isRecordingDraftGenerating, persistActiveDraftPreview, readActiveDraftPreview, shouldPromptForPreviewStart, shouldShowRecordingOverlay, useActionHighlight, useAgentViewport, useAutoExtract, useExperiencePlayback, useOnboardingPlayback, useRecordingMode, useRegisterAction, useRunCommand, useTagStore, useTourPlayback, useUIState, useViewportTrack, useVisibleIds, useVoice };