@godscene/visualizer 1.7.11

package/dist/types/component/env-config-reminder/index.d.ts

@@ -0,0 +1,6 @@
+import './index.less';
+interface EnvConfigReminderProps {
+    className?: string;
+}
+export declare const EnvConfigReminder: React.FC<EnvConfigReminderProps>;
+export {};

package/dist/types/component/form-field/index.d.ts

@@ -0,0 +1,17 @@
+import type { z } from '@godscene/core';
+import type React from 'react';
+interface FormFieldProps {
+    name: string;
+    label: string;
+    fieldSchema: z.ZodTypeAny;
+    isRequired: boolean;
+    isLocateField: boolean;
+    marginBottom: number;
+    placeholder?: string;
+}
+export declare const TextField: React.FC<Omit<FormFieldProps, 'isLocateField'>>;
+export declare const LocateField: React.FC<Omit<FormFieldProps, 'isLocateField'>>;
+export declare const EnumField: React.FC<Omit<FormFieldProps, 'isLocateField'>>;
+export declare const NumberField: React.FC<Omit<FormFieldProps, 'isLocateField'>>;
+export declare const BooleanField: React.FC<Omit<FormFieldProps, 'isLocateField'>>;
+export {};

package/dist/types/component/history-selector/index.d.ts

@@ -0,0 +1,13 @@
+import type React from 'react';
+import type { ReactNode } from 'react';
+import type { HistoryItem } from '../../store/history';
+import './index.less';
+interface HistorySelectorProps {
+    onSelect: (history: HistoryItem) => void;
+    history: HistoryItem[];
+    currentType: string;
+    trigger?: ReactNode;
+    popupPlacement?: 'top' | 'bottom';
+}
+export declare const HistorySelector: React.FC<HistorySelectorProps>;
+export {};

package/dist/types/component/index.d.ts

@@ -0,0 +1 @@
+export * from '../types';

package/dist/types/component/logo/index.d.ts

@@ -0,0 +1,5 @@
+import './index.less';
+export declare const LogoUrl: any;
+export declare const Logo: ({ hideLogo }: {
+    hideLogo?: boolean;
+}) => import("react").JSX.Element | null;

package/dist/types/component/misc/index.d.ts

@@ -0,0 +1,6 @@
+import type React from 'react';
+export declare function timeCostStrElement(timeCost?: number): React.JSX.Element;
+export declare const iconForStatus: (status: string) => React.JSX.Element;
+export declare const errorMessageServerNotReady: React.JSX.Element;
+export declare const serverLaunchTip: (notReadyMessage?: React.ReactNode | string) => React.JSX.Element;
+export declare const emptyResultTip: React.JSX.Element;

package/dist/types/component/nav-actions/index.d.ts

@@ -0,0 +1,12 @@
+import type { PlaygroundSDKLike } from '../../types';
+import './style.less';
+export interface NavActionsProps {
+    showEnvConfig?: boolean;
+    showTooltipWhenEmpty?: boolean;
+    showModelName?: boolean;
+    githubUrl?: string;
+    helpUrl?: string;
+    className?: string;
+    playgroundSDK?: PlaygroundSDKLike | null;
+}
+export declare function NavActions({ showEnvConfig, showTooltipWhenEmpty, showModelName, githubUrl, helpUrl, className, playgroundSDK, }: NavActionsProps): import("react").JSX.Element;

package/dist/types/component/player/index.d.ts

@@ -0,0 +1,15 @@
+import './index.less';
+import type { ReportDownloadHandler } from '../../types';
+import type { AnimationScript } from '../../utils/replay-scripts';
+export declare function Player(props?: {
+    replayScripts?: AnimationScript[];
+    imageWidth?: number;
+    imageHeight?: number;
+    reportFileContent?: string | null;
+    key?: string | number;
+    fitMode?: 'width' | 'height';
+    autoZoom?: boolean;
+    canDownloadReport?: boolean;
+    onDownloadReport?: ReportDownloadHandler;
+    onTaskChange?: (taskId: string | null) => void;
+}): import("react").JSX.Element | null;

package/dist/types/component/player/playback-controls.d.ts

@@ -0,0 +1 @@
+export declare function shouldRestartPlaybackFromBeginning(currentFrame: number, effectiveEndFrame: number): boolean;

package/dist/types/component/player/report-download.d.ts

@@ -0,0 +1,32 @@
+import type { ReportDownloadHandler } from '../../types';
+export declare const DEFAULT_REPORT_FILE_NAME = "midscene_report.html";
+interface AnchorLike {
+    href: string;
+    download: string;
+    style: {
+        display: string;
+    };
+    click: () => void;
+}
+interface DocumentLike {
+    body: {
+        appendChild: (node: AnchorLike) => void;
+        removeChild: (node: AnchorLike) => void;
+    };
+    createElement: (tagName: string) => AnchorLike;
+}
+interface UrlLike {
+    createObjectURL: (blob: Blob) => string;
+    revokeObjectURL: (url: string) => void;
+}
+interface TriggerReportDownloadOptions {
+    content: string;
+    defaultFileName?: string;
+    onDownloadReport?: ReportDownloadHandler;
+    documentRef?: DocumentLike;
+    urlRef?: UrlLike;
+    blobFactory?: (parts: BlobPart[], options: BlobPropertyBag) => Blob;
+    scheduleRevoke?: (callback: () => void) => void;
+}
+export declare function triggerReportDownload(options: TriggerReportDownloadOptions): Promise<void>;
+export {};

package/dist/types/component/player/scenes/StepScene.d.ts

@@ -0,0 +1,9 @@
+import type { FrameMap } from './frame-calculator';
+export declare const StepsTimeline: React.FC<{
+    frameMap: FrameMap;
+    autoZoom: boolean;
+    frame: number;
+    width: number;
+    height: number;
+    fps: number;
+}>;

package/dist/types/component/player/scenes/derive-frame-state.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Shared frame state derivation from ScriptFrame timeline.
+ * Used by both Remotion preview (StepScene.tsx) and Canvas export (export-branded-video.ts).
+ */
+import type { ScriptFrame } from './frame-calculator';
+export interface CameraState {
+    left: number;
+    top: number;
+    width: number;
+    pointerLeft: number;
+    pointerTop: number;
+}
+export interface InsightOverlay {
+    highlightElement?: ScriptFrame['highlightElement'];
+    searchArea?: ScriptFrame['searchArea'];
+    alpha: number;
+}
+export interface FrameState {
+    img: string;
+    imageWidth: number;
+    imageHeight: number;
+    prevImg: string | null;
+    camera: CameraState;
+    prevCamera: CameraState;
+    insights: InsightOverlay[];
+    spinning: boolean;
+    spinningElapsedMs: number;
+    currentPointerImg: string;
+    pointerVisible: boolean;
+    title: string;
+    subTitle: string;
+    taskId: string | undefined;
+    frameInScript: number;
+    scriptIndex: number;
+    imageChanged: boolean;
+    pointerMoved: boolean;
+    rawProgress: number;
+}
+export declare function shouldRenderCursor(pointerVisible: boolean, camera: CameraState, prevCamera: CameraState, imageWidth: number, imageHeight: number): boolean;
+export declare function deriveFrameState(scriptFrames: ScriptFrame[], frame: number, baseW: number, baseH: number, fps: number): FrameState;

package/dist/types/component/player/scenes/export-branded-video.d.ts

@@ -0,0 +1,33 @@
+import type { Rect } from '@godscene/core';
+import type { FrameMap } from './frame-calculator';
+interface ExportOverlayViewport {
+    offsetX: number;
+    offsetY: number;
+    contentWidth: number;
+    contentHeight: number;
+    imageWidth: number;
+    imageHeight: number;
+}
+export declare function isExportRenderStalled(elapsedSinceLastFrameMs: number, frameDurationMs: number): boolean;
+export declare function resolveExportCamera(prevCamera: {
+    left: number;
+    top: number;
+    width: number;
+}, camera: {
+    left: number;
+    top: number;
+    width: number;
+}, imageWidth: number, progress: number, autoZoom: boolean): {
+    camLeft: number;
+    camTop: number;
+    camWidth: number;
+};
+export declare function projectNativeRectToExportViewport(rect: Rect, cameraTransform: {
+    zoom: number;
+    tx: number;
+    ty: number;
+}, viewport: ExportOverlayViewport): Rect;
+export declare function exportBrandedVideo(frameMap: FrameMap, options?: {
+    autoZoom?: boolean;
+}, onProgress?: (pct: number) => void): Promise<void>;
+export {};

package/dist/types/component/player/scenes/frame-calculator.d.ts

@@ -0,0 +1,40 @@
+import type { LocateResultElement, Rect } from '@godscene/core';
+import type { AnimationScript } from '../../../utils/replay-scripts';
+export declare const FPS = 30;
+export interface ScriptFrame {
+    type: 'img' | 'insight' | 'clear-insight' | 'pointer' | 'spinning-pointer' | 'sleep';
+    startFrame: number;
+    durationInFrames: number;
+    img?: string;
+    imageWidth?: number;
+    imageHeight?: number;
+    cameraTarget?: {
+        left: number;
+        top: number;
+        width: number;
+        pointerLeft: number;
+        pointerTop: number;
+    };
+    insightPhaseFrames?: number;
+    cameraPhaseFrames?: number;
+    highlightElement?: LocateResultElement;
+    searchArea?: Rect;
+    pointerImg?: string;
+    title?: string;
+    subTitle?: string;
+    taskId?: string;
+}
+export interface FrameMap {
+    scriptFrames: ScriptFrame[];
+    totalDurationInFrames: number;
+    fps: number;
+    stepsDurationInFrames: number;
+    imageWidth: number;
+    imageHeight: number;
+}
+interface CalculateFrameMapOptions {
+    imageWidth?: number;
+    imageHeight?: number;
+}
+export declare function calculateFrameMap(scripts: AnimationScript[], options?: CalculateFrameMapOptions): FrameMap;
+export {};

package/dist/types/component/player/scenes/playback-frame.d.ts

@@ -0,0 +1,3 @@
+import { type FrameState } from './derive-frame-state';
+import type { FrameMap } from './frame-calculator';
+export declare function getPlaybackFrameState(frameMap: FrameMap, frame: number): FrameState | null;

package/dist/types/component/player/scenes/playback-layout.d.ts

@@ -0,0 +1,7 @@
+export interface PlaybackViewport {
+    offsetX: number;
+    offsetY: number;
+    contentWidth: number;
+    contentHeight: number;
+}
+export declare function getPlaybackViewport(containerWidth: number, containerHeight: number, imageWidth: number, imageHeight: number): PlaybackViewport;

package/dist/types/component/player/scenes/pointer-layout.d.ts

@@ -0,0 +1,20 @@
+export declare const POINTER_WIDTH = 44;
+export declare const POINTER_HEIGHT = 56;
+export declare const POINTER_HOTSPOT_X = 6;
+export declare const POINTER_HOTSPOT_Y = 4;
+export interface PointerLayout {
+    scale: number;
+    width: number;
+    height: number;
+    hotspotX: number;
+    hotspotY: number;
+    centerOffsetX: number;
+    centerOffsetY: number;
+}
+export interface SpinnerLayout {
+    size: number;
+    centerOffset: number;
+}
+export declare function resolvePointerLayout(imageWidth: number): PointerLayout;
+export declare function resolveExportPointerLayout(imageWidth: number, contentWidth: number): PointerLayout;
+export declare function resolveSpinnerLayout(pointerLayout: PointerLayout): SpinnerLayout;

package/dist/types/component/player/use-frame-player.d.ts

@@ -0,0 +1,17 @@
+interface UseFramePlayerOptions {
+    durationInFrames: number;
+    fps: number;
+    autoPlay?: boolean;
+    loop?: boolean;
+    playbackRate?: number;
+}
+interface FramePlayer {
+    currentFrame: number;
+    playing: boolean;
+    play: () => void;
+    pause: () => void;
+    toggle: () => void;
+    seekTo: (frame: number) => void;
+}
+export declare function useFramePlayer(options: UseFramePlayerOptions): FramePlayer;
+export {};

package/dist/types/component/playground-result/index.d.ts

@@ -0,0 +1,22 @@
+import type React from 'react';
+import type { PlaygroundResult as PlaygroundResultType, ReportDownloadHandler, ServiceModeType } from '../../types';
+import type { ReplayScriptsInfo } from '../../utils/replay-scripts';
+import './index.less';
+interface PlaygroundResultProps {
+    result: PlaygroundResultType | null;
+    loading: boolean;
+    serverValid?: boolean;
+    serviceMode: ServiceModeType;
+    replayScriptsInfo: ReplayScriptsInfo | null;
+    replayCounter: number;
+    loadingProgressText: string;
+    verticalMode?: boolean;
+    notReadyMessage?: React.ReactNode | string;
+    fitMode?: 'width' | 'height';
+    autoZoom?: boolean;
+    actionType?: string;
+    canDownloadReport?: boolean;
+    onDownloadReport?: ReportDownloadHandler;
+}
+export declare const PlaygroundResultView: React.FC<PlaygroundResultProps>;
+export {};

package/dist/types/component/prompt-input/index.d.ts

@@ -0,0 +1,23 @@
+import type { DeviceAction } from '@godscene/core';
+import React from 'react';
+import type { DeviceType, RunType } from '../../types';
+import type { PromptInputChromeConfig, ServiceModeType } from '../../types';
+import './index.less';
+interface PromptInputProps {
+    runButtonEnabled: boolean;
+    form: any;
+    serviceMode: ServiceModeType;
+    selectedType: RunType;
+    dryMode: boolean;
+    stoppable: boolean;
+    loading: boolean;
+    onRun: () => void;
+    onStop: () => void;
+    clearPromptAfterRun?: boolean;
+    hideDomAndScreenshotOptions?: boolean;
+    actionSpace: DeviceAction<any>[];
+    deviceType?: DeviceType;
+    chrome?: PromptInputChromeConfig;
+}
+export declare const PromptInput: React.FC<PromptInputProps>;
+export {};

package/dist/types/component/screenshot-viewer/index.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import './index.less';
+export type ScreenshotViewerMode = 'default' | 'screen-only';
+interface ScreenshotViewerProps {
+    getScreenshot: () => Promise<{
+        screenshot: string;
+        timestamp: number;
+    } | null>;
+    getInterfaceInfo?: () => Promise<{
+        type: string;
+        description?: string;
+        size?: {
+            width: number;
+            height: number;
+        };
+    } | null>;
+    serverOnline: boolean;
+    isUserOperating?: boolean;
+    mjpegUrl?: string;
+    mode?: ScreenshotViewerMode;
+}
+export default function ScreenshotViewer({ getScreenshot, getInterfaceInfo, serverOnline, isUserOperating, mjpegUrl, mode, }: ScreenshotViewerProps): React.JSX.Element;
+export {};

package/dist/types/component/service-mode-control/index.d.ts

@@ -0,0 +1,6 @@
+import type React from 'react';
+interface ServiceModeControlProps {
+    serviceMode: 'Server' | 'In-Browser';
+}
+export declare const ServiceModeControl: React.FC<ServiceModeControlProps>;
+export {};

package/dist/types/component/shiny-text/index.d.ts

@@ -0,0 +1,12 @@
+import type React from 'react';
+import './index.less';
+type ColorTheme = 'blue' | 'purple' | 'green' | 'rainbow';
+interface ShinyTextProps {
+    text: string;
+    disabled?: boolean;
+    speed?: number;
+    className?: string;
+    colorTheme?: ColorTheme;
+}
+declare const ShinyText: React.FC<ShinyTextProps>;
+export default ShinyText;

package/dist/types/component/universal-playground/empty-state.d.ts

@@ -0,0 +1,3 @@
+import type { ReactNode } from 'react';
+import type { InfoListItem } from '../../types';
+export declare function shouldRenderCustomEmptyState(infoList: InfoListItem[], emptyState?: ReactNode): boolean;

package/dist/types/component/universal-playground/index.d.ts

@@ -0,0 +1,4 @@
+import type { UniversalPlaygroundProps } from '../../types';
+import './index.less';
+export declare function UniversalPlayground({ playgroundSDK, storage, contextProvider, config: componentConfig, branding, className, dryMode, showContextPreview, showPromptInput, onHumanUse, showHumanUse, defaultSelectedType, }: UniversalPlaygroundProps): import("react").JSX.Element;
+export default UniversalPlayground;

package/dist/types/component/universal-playground/providers/context-provider.d.ts

@@ -0,0 +1,37 @@
+import type { UIContext } from '@godscene/core';
+import type { ContextProvider } from '../../../types';
+/**
+ * Base context provider implementation
+ */
+export declare abstract class BaseContextProvider implements ContextProvider {
+    protected cachedContext?: UIContext;
+    abstract getUIContext(): Promise<UIContext>;
+    refreshContext(): Promise<UIContext>;
+}
+/**
+ * Agent-based context provider for local execution modes
+ */
+export declare class AgentContextProvider extends BaseContextProvider {
+    private getAgent;
+    private options?;
+    constructor(getAgent: () => any, options?: {
+        forceSameTabNavigation?: boolean;
+    } | undefined);
+    getUIContext(): Promise<UIContext>;
+}
+/**
+ * Static context provider for pre-determined UI contexts
+ */
+export declare class StaticContextProvider extends BaseContextProvider {
+    private context;
+    constructor(context: UIContext);
+    getUIContext(): Promise<UIContext>;
+    refreshContext(): Promise<UIContext>;
+}
+/**
+ * No-op context provider for cases where context preview is disabled
+ */
+export declare class NoOpContextProvider implements ContextProvider {
+    getUIContext(): Promise<UIContext>;
+    refreshContext(): Promise<UIContext>;
+}

package/dist/types/component/universal-playground/providers/indexeddb-storage-provider.d.ts

@@ -0,0 +1,71 @@
+import type { InfoListItem, StorageProvider } from '../../../types';
+/**
+ * IndexedDB Storage implementation for playground message persistence
+ * Provides much larger storage capacity compared to localStorage
+ */
+export declare class IndexedDBStorageProvider implements StorageProvider {
+    private dbManager;
+    private namespace;
+    private messagesCleanup;
+    private resultsCleanup;
+    constructor(namespace?: string);
+    /**
+     * Save messages to IndexedDB
+     */
+    saveMessages(messages: InfoListItem[]): Promise<void>;
+    /**
+     * Load messages from IndexedDB
+     */
+    loadMessages(): Promise<InfoListItem[]>;
+    /**
+     * Clear all messages from IndexedDB
+     */
+    clearMessages(): Promise<void>;
+    /**
+     * Save a single result to IndexedDB with compression
+     */
+    saveResult(id: string, result: InfoListItem): Promise<void>;
+    /**
+     * Load a single result from IndexedDB
+     */
+    loadResult(id: string): Promise<InfoListItem | null>;
+    /**
+     * Compress result data for storage while preserving playback functionality
+     */
+    private compressResultForStorage;
+    /**
+     * Compress screenshot if it exceeds size threshold
+     */
+    private compressScreenshotIfNeeded;
+    /**
+     * Get storage statistics
+     */
+    getStorageStats(): Promise<{
+        messageCount: number;
+        resultCount: number;
+    }>;
+    /**
+     * Manually trigger cleanup
+     */
+    cleanup(): Promise<void>;
+}
+/**
+ * Memory-based storage provider for IndexedDB fallback
+ */
+export declare class MemoryStorageProvider implements StorageProvider {
+    private messages;
+    private results;
+    saveMessages(messages: InfoListItem[]): Promise<void>;
+    loadMessages(): Promise<InfoListItem[]>;
+    clearMessages(): Promise<void>;
+    saveResult(id: string, result: InfoListItem): Promise<void>;
+}
+/**
+ * No-op storage provider for disabled storage
+ */
+export declare class NoOpStorageProvider implements StorageProvider {
+    saveMessages(_messages: InfoListItem[]): Promise<void>;
+    loadMessages(): Promise<InfoListItem[]>;
+    clearMessages(): Promise<void>;
+    saveResult(_id: string, _result: InfoListItem): Promise<void>;
+}

package/dist/types/component/universal-playground/providers/storage-provider.d.ts

@@ -0,0 +1,58 @@
+import type { InfoListItem, StorageProvider } from '../../../types';
+import { MemoryStorageProvider as IndexedDBMemoryStorageProvider, NoOpStorageProvider as IndexedDBNoOpStorageProvider, IndexedDBStorageProvider } from './indexeddb-storage-provider';
+/**
+ * Local Storage implementation for playground message persistence
+ */
+export declare class LocalStorageProvider implements StorageProvider {
+    private readonly messagesKey;
+    private readonly resultsKey;
+    private readonly maxStorageItems;
+    constructor(namespace?: string);
+    /**
+     * Check available storage space
+     */
+    private checkStorageSpace;
+    saveMessages(messages: InfoListItem[]): Promise<void>;
+    loadMessages(): Promise<InfoListItem[]>;
+    clearMessages(): Promise<void>;
+    saveResult(id: string, result: InfoListItem): Promise<void>;
+    /**
+     * Handle quota exceeded by clearing old data
+     */
+    private handleQuotaExceeded;
+}
+/**
+ * Memory-only storage implementation for non-persistent scenarios
+ */
+export declare class MemoryStorageProvider implements StorageProvider {
+    private messages;
+    private results;
+    saveMessages(messages: InfoListItem[]): Promise<void>;
+    loadMessages(): Promise<InfoListItem[]>;
+    clearMessages(): Promise<void>;
+    saveResult(id: string, result: InfoListItem): Promise<void>;
+}
+/**
+ * No-op storage implementation for cases where persistence is disabled
+ */
+export declare class NoOpStorageProvider implements StorageProvider {
+    saveMessages(_messages: InfoListItem[]): Promise<void>;
+    loadMessages(): Promise<InfoListItem[]>;
+    clearMessages(): Promise<void>;
+    saveResult(_id: string, _result: InfoListItem): Promise<void>;
+}
+/**
+ * Storage type enumeration
+ */
+export declare enum StorageType {
+    INDEXEDDB = "indexeddb",
+    LOCALSTORAGE = "localStorage",
+    MEMORY = "memory",
+    NONE = "none"
+}
+/**
+ * Factory function to create the appropriate storage provider
+ */
+export declare function createStorageProvider(type?: StorageType, namespace?: string): StorageProvider;
+export declare function detectBestStorageType(): StorageType;
+export { IndexedDBStorageProvider, IndexedDBMemoryStorageProvider, IndexedDBNoOpStorageProvider, };

package/dist/types/component/universal-playground/universal-playground-electron.d.ts

@@ -0,0 +1,4 @@
+import type { UniversalPlaygroundProps } from '../../types';
+import './index.less';
+export declare function UniversalPlaygroundElectron({ storage, contextProvider, config: componentConfig, branding, className, dryMode, showContextPreview, showPromptInput, onHumanUse, showHumanUse, defaultSelectedType, }: UniversalPlaygroundProps): import("react").JSX.Element;
+export default UniversalPlaygroundElectron;

package/dist/types/hooks/useMinimalTypeGate.d.ts

@@ -0,0 +1,72 @@
+import type { FormInstance } from 'antd';
+/**
+ * Options for {@link useMinimalTypeGate}.
+ */
+export interface UseMinimalTypeGateOptions {
+    /**
+     * Whether the gate is active. When `false`, the hook is a no-op and all
+     * returned callbacks become stable identity-only functions. Typically
+     * wired to `chrome?.variant === 'minimal'`.
+     */
+    enabled: boolean;
+    /** The antd form that owns `type` / `prompt` / `params` fields. */
+    form: FormInstance;
+    /** Currently selected action type (usually read via `Form.useWatch`). */
+    selectedType: string | undefined;
+    /**
+     * Called when the gate snaps `form.type` back to its default. Hosts use
+     * this hook to clear any sibling state (local `promptValue`, custom
+     * history refs, etc.) alongside the form reset.
+     */
+    onAfterReset?: () => void;
+    /**
+     * The default type to snap back to when the user has not made an
+     * explicit selection. Defaults to `'aiAct'`, matching the natural
+     * language action.
+     */
+    defaultType?: string;
+}
+export interface MinimalTypeGate {
+    /**
+     * Record that the user has explicitly chosen an action — disables the
+     * snap-back effect for the remainder of the component's lifecycle.
+     * Call this from every user-initiated selection path: action dropdown
+     * click, history replay, etc.
+     */
+    markExplicitSelection: () => void;
+    /**
+     * One-shot flag: request that the NEXT run of the caller's
+     * history-restore effect be skipped entirely. Used when a history
+     * replay is about to change `selectedType` and we don't want the
+     * effect to overwrite the fresh form values. The flag auto-clears
+     * after being read via {@link shouldSkipRestoreOnce}.
+     */
+    skipNextRestore: () => void;
+    /**
+     * Read-and-clear accessor for the one-shot flag set by
+     * {@link skipNextRestore}.
+     */
+    shouldSkipRestoreOnce: () => boolean;
+}
+/**
+ * Keeps a minimal-chrome prompt input pinned to its default type until
+ * the user makes an explicit selection. The minimal chrome hides the
+ * type radio row, so any background pathway that lands a non-default
+ * type in the form (e.g. `lastSelectedType` restored from local
+ * storage) would otherwise surface a type the user never asked for.
+ *
+ * Behaviour:
+ * 1. While `enabled` and the user has not called `markExplicitSelection`,
+ *    any `selectedType !== defaultType` triggers a form reset back to
+ *    the default, clearing `prompt` and `params` along with it.
+ * 2. Once the user explicitly picks something, the gate unlocks and
+ *    stays unlocked for the rest of the component's life.
+ * 3. `skipNextRestore` plus `shouldSkipRestoreOnce` give the caller a
+ *    one-tick bypass so its own history-restore effect can skip the
+ *    iteration where the type just changed due to a history replay.
+ *
+ * This replaces the previously inline `minimalHasExplicitTypeSelection`
+ * state + `skipMinimalSyncRef` + reset effect that lived inside
+ * `PromptInput`.
+ */
+export declare function useMinimalTypeGate(options: UseMinimalTypeGateOptions): MinimalTypeGate;