@web-auto/webauto 0.1.4 → 0.1.7

package/dist/modules/xiaohongshu/app/src/workflow/blocks/DetectPageStateBlock.js

@@ -0,0 +1,259 @@
+/**
+ * Workflow Block: DetectPageStateBlock
+ *
+ * 基于 URL + 容器匹配检测当前页面阶段：
+ * - xiaohongshu: login / detail / search / home / unknown
+ * - weibo: login / detail / search / home / unknown
+ *
+ * 用于在进入各 Phase 前做“入口锚点”判定。
+ */
+import { logControllerActionError, logControllerActionResult, logControllerActionStart, } from './helpers/operationLogger.js';
+const PLATFORM_CONTAINERS = {
+    xiaohongshu: [
+        { id: 'xiaohongshu_login.login_guard', name: '登录页', urlPattern: /\/login/ },
+        { id: 'xiaohongshu_detail.modal_shell', name: '详情页', urlPattern: /\/explore\// },
+        {
+            id: 'xiaohongshu_search.search_result_list',
+            name: '搜索结果页',
+            urlPattern: /\/search_result/,
+        },
+        { id: 'xiaohongshu_home', name: '主页/推荐流', urlPattern: /\/explore/ },
+    ],
+    weibo: [
+        { id: 'weibo_login.login_guard', name: '登录页', urlPattern: /\/signin/ },
+        { id: 'weibo_detail.modal_shell', name: '详情页', urlPattern: /\/\d+\// },
+        { id: 'weibo_search.feed_list', name: '搜索结果页', urlPattern: /\/search/ },
+        { id: 'weibo_home.feed_list', name: '主页', urlPattern: /^https:\/\/weibo\.com\/?$/ },
+    ],
+};
+function detectPlatformFromUrl(url) {
+    if (url.includes('xiaohongshu.com'))
+        return 'xiaohongshu';
+    if (url.includes('weibo.com'))
+        return 'weibo';
+    return 'unknown';
+}
+function detectPageByUrl(url, platformContainers) {
+    for (const def of platformContainers) {
+        if (def.urlPattern && def.urlPattern.test(url)) {
+            return def;
+        }
+    }
+    return null;
+}
+function detectPageByContainer(matchIds, platformContainers, currentUrl) {
+    const containerIds = new Set(matchIds);
+    for (const def of platformContainers) {
+        if (containerIds.has(def.id)) {
+            // 对于小红书搜索结果页，额外检查 URL 是否包含 search_result，避免误把首页当成搜索页
+            if (def.id === 'xiaohongshu_search.search_result_list' && !currentUrl.includes('search_result')) {
+                continue;
+            }
+            return def;
+        }
+    }
+    return null;
+}
+function mapContainerIdToStage(platform, containerId) {
+    if (!containerId)
+        return 'unknown';
+    if (platform === 'xiaohongshu') {
+        if (containerId === 'xiaohongshu_login.login_guard')
+            return 'login';
+        if (containerId === 'xiaohongshu_detail.modal_shell')
+            return 'detail';
+        if (containerId === 'xiaohongshu_search.search_result_list')
+            return 'search';
+        if (containerId === 'xiaohongshu_home')
+            return 'home';
+        return 'unknown';
+    }
+    if (platform === 'weibo') {
+        if (containerId === 'weibo_login.login_guard')
+            return 'login';
+        if (containerId === 'weibo_detail.modal_shell')
+            return 'detail';
+        if (containerId === 'weibo_search.feed_list')
+            return 'search';
+        if (containerId === 'weibo_home.feed_list')
+            return 'home';
+        return 'unknown';
+    }
+    return 'unknown';
+}
+function detectRiskControlByUrl(url, platform) {
+    const u = url.toLowerCase();
+    if (platform === 'xiaohongshu') {
+        return (u.includes('/website-login/captcha') ||
+            u.includes('/website-login/verify') ||
+            u.includes('/website-login/security') ||
+            u.includes('verifyuuid=') ||
+            u.includes('verifytype=') ||
+            u.includes('verifybiz='));
+    }
+    if (platform === 'weibo') {
+        return u.includes('/signup/verify') || u.includes('/security/') || u.includes('/sina/verify');
+    }
+    return false;
+}
+function detectLoginByUrl(url, platform) {
+    if (platform === 'xiaohongshu')
+        return /\/login/.test(url);
+    if (platform === 'weibo')
+        return /\/signin/.test(url);
+    return false;
+}
+export async function execute(input) {
+    const { sessionId, platform: platformHint = 'auto', serviceUrl = 'http://127.0.0.1:7701', } = input;
+    const controllerUrl = `${serviceUrl}/v1/controller/action`;
+    async function controllerAction(action, payload = {}) {
+        const opId = logControllerActionStart(action, payload, { source: 'DetectPageStateBlock' });
+        try {
+            const res = await fetch(controllerUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ action, payload }),
+            });
+            if (!res.ok) {
+                throw new Error(`HTTP ${res.status}: ${await res.text()}`);
+            }
+            const data = await res.json();
+            const result = data.data || data;
+            logControllerActionResult(opId, action, result, { source: 'DetectPageStateBlock' });
+            return result;
+        }
+        catch (error) {
+            logControllerActionError(opId, action, error, payload, { source: 'DetectPageStateBlock' });
+            throw error;
+        }
+    }
+    async function getCurrentUrl() {
+        const data = await controllerAction('browser:execute', {
+            profile: sessionId,
+            script: 'window.location.href',
+        });
+        return data?.result || data?.data?.result || '';
+    }
+    async function getDomSummary() {
+        try {
+            const data = await controllerAction('browser:execute', {
+                profile: sessionId,
+                script: `(() => {
+          const hasDetailMask = !!document.querySelector('.note-detail-mask');
+          const hasSearchInput = !!document.querySelector('input[type="search"], #search-input');
+          return {
+            hasDetailMask,
+            hasSearchInput,
+            readyState: document.readyState,
+            title: document.title
+          };
+        })()`
+            });
+            const result = data?.result || data?.data?.result || null;
+            if (result && typeof result === 'object')
+                return result;
+            return {};
+        }
+        catch {
+            return {};
+        }
+    }
+    async function matchContainers() {
+        // Controller's containers:match requires an explicit URL.
+        // Use the current page URL as the match target; this keeps matching aligned with the active document.
+        const currentUrl = await getCurrentUrl().catch(() => '');
+        const data = await controllerAction('containers:match', {
+            profile: sessionId,
+            url: currentUrl,
+        });
+        const rootId = data?.container?.id || data?.data?.container?.id || null;
+        const matches = data?.snapshot?.matches || data?.data?.snapshot?.matches || {};
+        const matchIds = Object.entries(matches)
+            .filter(([, info]) => {
+            const mc = info?.match_count ?? info?.matchCount ?? 0;
+            return mc > 0;
+        })
+            .map(([id]) => id);
+        return { rootId, matchIds };
+    }
+    // 1) 始终优先尝试通过 URL 判定平台和大致页面
+    const url = await getCurrentUrl().catch(() => '');
+    let platform;
+    if (platformHint === 'auto') {
+        platform = url ? detectPlatformFromUrl(url) : 'unknown';
+    }
+    else {
+        platform = platformHint;
+    }
+    if (platform === 'unknown') {
+        return {
+            success: false,
+            sessionId,
+            platform,
+            url,
+            stage: 'unknown',
+            error: url ? 'Unknown platform from URL' : 'URL unavailable',
+        };
+    }
+    // Hard-stop detection (URL-based) to avoid triggering risk-control via repeated container matching.
+    if (url && detectRiskControlByUrl(url, platform)) {
+        return {
+            success: true,
+            sessionId,
+            platform,
+            url,
+            stage: 'login',
+            pageName: 'risk_control',
+            rootId: null,
+            matchIds: [],
+            dom: await getDomSummary(),
+        };
+    }
+    if (url && detectLoginByUrl(url, platform)) {
+        return {
+            success: true,
+            sessionId,
+            platform,
+            url,
+            stage: 'login',
+            pageName: 'login_page',
+            rootId: null,
+            matchIds: [],
+            dom: await getDomSummary(),
+        };
+    }
+    const platformContainers = PLATFORM_CONTAINERS[platform] || [];
+    const urlDetection = url ? detectPageByUrl(url, platformContainers) : null;
+    // 2) 再尝试做一次容器匹配；如果失败则回退到 URL-only 的判定，而不是直接失败
+    let rootId = null;
+    let matchIds = [];
+    let matchError;
+    const dom = await getDomSummary();
+    try {
+        const matched = await matchContainers();
+        rootId = matched.rootId;
+        matchIds = matched.matchIds;
+    }
+    catch (error) {
+        matchError = error?.message || String(error);
+    }
+    const containerDetection = matchIds.length > 0
+        ? detectPageByContainer([rootId, ...matchIds].filter(Boolean), platformContainers, url)
+        : null;
+    // 以容器检测为主，URL 为辅；若容器匹配失败则退回 URL-only
+    const effectiveDetection = containerDetection || urlDetection || null;
+    const stage = mapContainerIdToStage(platform, effectiveDetection?.id);
+    return {
+        success: true,
+        sessionId,
+        platform,
+        url,
+        stage,
+        pageName: effectiveDetection?.name,
+        rootId,
+        matchIds,
+        dom,
+        error: matchError,
+    };
+}
+//# sourceMappingURL=DetectPageStateBlock.js.map

package/dist/modules/xiaohongshu/app/src/workflow/blocks/ErrorRecoveryBlock.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Workflow Block: ErrorRecoveryBlock
+ *
+ * 职责：
+ * - 提供阶段错误后的恢复策略
+ * - 统一恢复到安全起点（搜索页或主页）
+ * - 验证恢复是否成功（锚点回环）
+ * - 支持ESC恢复模式（用于Phase3/4详情页恢复）
+ * - 支持多种恢复路径（home/search/detail）
+ */
+export interface ErrorRecoveryInput {
+    sessionId: string;
+    fromStage: 'search' | 'detail' | 'home';
+    targetStage: 'search' | 'home';
+    serviceUrl?: string;
+    maxRetries?: number;
+    recoveryMode?: 'esc' | 'navigate';
+}
+export interface ErrorRecoveryOutput {
+    success: boolean;
+    recovered: boolean;
+    finalStage: 'search' | 'home' | 'unknown';
+    currentUrl?: string;
+    error?: string;
+    method?: string;
+}
+export declare function execute(input: ErrorRecoveryInput): Promise<ErrorRecoveryOutput>;
+//# sourceMappingURL=ErrorRecoveryBlock.d.ts.map

package/dist/modules/xiaohongshu/app/src/workflow/blocks/ErrorRecoveryBlock.js

@@ -0,0 +1,319 @@
+/**
+ * Workflow Block: ErrorRecoveryBlock
+ *
+ * 职责：
+ * - 提供阶段错误后的恢复策略
+ * - 统一恢复到安全起点（搜索页或主页）
+ * - 验证恢复是否成功（锚点回环）
+ * - 支持ESC恢复模式（用于Phase3/4详情页恢复）
+ * - 支持多种恢复路径（home/search/detail）
+ */
+import { logControllerActionError, logControllerActionResult, logControllerActionStart, } from './helpers/operationLogger.js';
+export async function execute(input) {
+    const { sessionId, fromStage, targetStage, serviceUrl = 'http://127.0.0.1:7701', maxRetries = 2, recoveryMode = 'navigate' } = input;
+    // 开发阶段策略：只允许系统级 ESC 恢复；禁止 navigate/JS click/dispatchEvent 等兜底
+    if (recoveryMode !== 'esc') {
+        return {
+            success: false,
+            recovered: false,
+            finalStage: 'unknown',
+            error: 'ErrorRecoveryBlock: only esc recovery is allowed (navigate disabled)',
+        };
+    }
+    const controllerUrl = `${serviceUrl}/v1/controller/action`;
+    async function controllerAction(action, payload = {}) {
+        const opId = logControllerActionStart(action, payload, { source: 'ErrorRecoveryBlock' });
+        try {
+            const res = await fetch(controllerUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ action, payload }),
+                signal: AbortSignal.timeout ? AbortSignal.timeout(10000) : undefined
+            });
+            if (!res.ok) {
+                throw new Error(`HTTP ${res.status}: ${await res.text()}`);
+            }
+            const data = await res.json();
+            const result = data.data || data;
+            logControllerActionResult(opId, action, result, { source: 'ErrorRecoveryBlock' });
+            return result;
+        }
+        catch (error) {
+            logControllerActionError(opId, action, error, payload, { source: 'ErrorRecoveryBlock' });
+            throw error;
+        }
+    }
+    async function getCurrentUrl() {
+        const data = await controllerAction('browser:execute', {
+            profile: sessionId,
+            script: 'location.href'
+        });
+        return data?.result || data?.data?.result || '';
+    }
+    async function verifyStage(stage) {
+        try {
+            const { verifyAnchorByContainerId } = await import('./helpers/containerAnchors.js');
+            const targetContainerId = stage === 'search'
+                ? 'xiaohongshu_search.search_result_list'
+                : 'xiaohongshu_home';
+            const anchor = await verifyAnchorByContainerId(targetContainerId, sessionId, serviceUrl, '2px solid #4caf50', 1200);
+            if (!anchor.found || !anchor.rect) {
+                return false;
+            }
+            const rectOk = anchor.rect.width > 0 && anchor.rect.height > 0;
+            if (!rectOk) {
+                return false;
+            }
+            // 额外约束：确认“可见的”详情 overlay 已完全消失，避免在仍有详情 overlay 时误判为 search/home
+            try {
+                const domState = await controllerAction('browser:execute', {
+                    profile: sessionId,
+                    script: `(() => {
+            const selectors = [
+              '.note-detail-mask',
+              '.note-detail-page',
+              '.note-detail-dialog',
+              '.note-detail',
+              '.detail-container',
+              '.media-container'
+            ];
+            const isVisible = (el) => {
+              if (!el) return false;
+              const style = window.getComputedStyle(el);
+              if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') return false;
+              const r = el.getBoundingClientRect();
+              if (!r.width || !r.height) return false;
+              if (r.bottom <= 0 || r.top >= window.innerHeight) return false;
+              return true;
+            };
+            let visibleOverlay = null;
+            for (const sel of selectors) {
+              const el = document.querySelector(sel);
+              if (el && isVisible(el)) {
+                visibleOverlay = el;
+                break;
+              }
+            }
+            return { hasDetailOverlayVisible: !!visibleOverlay };
+          })()`,
+                });
+                const payload = domState.result || domState.data?.result || domState;
+                if (payload?.hasDetailOverlayVisible) {
+                    console.warn('[ErrorRecovery] verifyStage: visible detail overlay still present, stage not stable');
+                    return false;
+                }
+            }
+            catch (e) {
+                console.warn('[ErrorRecovery] verifyStage DOM check error:', e.message);
+            }
+            return true;
+        }
+        catch (error) {
+            console.warn('[ErrorRecovery] verifyStage 锚点验证异常:', error.message);
+            return false;
+        }
+    }
+    async function recoverWithEsc() {
+        console.log('[ErrorRecovery] 使用ESC模式恢复...');
+        // 0. 入口锚点：先确认当前确实处于“详情态”（存在“可见的” detail overlay），避免在错误页面上盲动。
+        let hasDetailOverlay = false;
+        try {
+            const domState = await controllerAction('browser:execute', {
+                profile: sessionId,
+                script: `(() => {
+          const selectors = [
+            '.note-detail-mask',
+            '.note-detail-page',
+            '.note-detail-dialog',
+            '.note-detail',
+            '.detail-container',
+            '.media-container'
+          ];
+          const isVisible = (el) => {
+            if (!el) return false;
+            const style = window.getComputedStyle(el);
+            if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') return false;
+            const r = el.getBoundingClientRect();
+            if (!r.width || !r.height) return false;
+            if (r.bottom <= 0 || r.top >= window.innerHeight) return false;
+            return true;
+          };
+          let visibleOverlay = null;
+          for (const sel of selectors) {
+            const el = document.querySelector(sel);
+            if (el && isVisible(el)) {
+              visibleOverlay = el;
+              break;
+            }
+          }
+          return { hasDetailOverlayVisible: !!visibleOverlay };
+        })()`,
+            });
+            const payload = domState.result || domState.data?.result || domState;
+            hasDetailOverlay = Boolean(payload?.hasDetailOverlayVisible);
+        }
+        catch (e) {
+            console.warn(`[ErrorRecovery] detail-overlay DOM probe failed before ESC recovery: ${e.message}`);
+        }
+        if (!hasDetailOverlay) {
+            console.warn('[ErrorRecovery] detail overlay not detected before ESC recovery, continue ESC path based on stage hint');
+            // 这里不再直接返回失败：
+            // - 来到 ErrorRecoveryBlock 且 fromStage=detail 时，调用方已经认为当前处于详情态
+            // - DOM 预探测只是辅助信号，可能因为样式/结构变化导致误判
+            // 因此即便未检测到 overlay，也继续尝试容器关闭与 ESC 按键，由后续 verifyStage 严格确认结果
+        }
+        // 0.1 次级锚点（非强制）：尝试命中详情 modal 容器，用于高亮确认；失败不再视为致命，仅记录日志。
+        try {
+            const { verifyAnchorByContainerId } = await import('./helpers/containerAnchors.js');
+            const detailAnchor = await verifyAnchorByContainerId('xiaohongshu_detail.modal_shell', sessionId, serviceUrl, '2px solid #ff4444', 1200);
+            if (!detailAnchor.found || !detailAnchor.rect) {
+                console.warn('[ErrorRecovery] detail modal anchor not found, continue ESC recovery based on DOM overlay only');
+            }
+        }
+        catch (e) {
+            console.warn(`[ErrorRecovery] verify detail anchor failed before ESC recovery: ${e.message}`);
+            // 容器锚点只是次级信号，这里不再直接失败，后续依赖 DOM + search_result_list 锚点确认恢复效果
+        }
+        // 1) 优先通过容器运行时 + 系统点击关闭详情 modal（点击右上角关闭按钮）
+        try {
+            const clickResult = await controllerAction('container:operation', {
+                containerId: 'xiaohongshu_detail.modal_shell',
+                operationId: 'click',
+                config: {
+                    selector: '.note-detail-mask .close-box, .note-detail-mask .close-circle',
+                    useSystemMouse: true,
+                    retries: 1,
+                },
+                sessionId
+            });
+            console.log('[ErrorRecovery] container-close click result:', JSON.stringify(clickResult));
+            await new Promise((resolve) => setTimeout(resolve, 1500));
+            // 1.1 关闭后通过搜索结果列表锚点 + DOM overlay 检查判断是否已回到安全阶段
+            try {
+                const { verifyAnchorByContainerId } = await import('./helpers/containerAnchors.js');
+                const anchor = await verifyAnchorByContainerId('xiaohongshu_search.search_result_list', sessionId, serviceUrl, '2px solid #4caf50', 1000);
+                const anchorOk = anchor.found && anchor.rect && anchor.rect.width > 0 && anchor.rect.height > 0;
+                let overlayGone = true;
+                try {
+                    const domState = await controllerAction('browser:execute', {
+                        profile: sessionId,
+                        script: `(() => {
+              const selectors = [
+                '.note-detail-mask',
+                '.note-detail-page',
+                '.note-detail-dialog',
+                '.note-detail',
+                '.detail-container',
+                '.media-container'
+              ];
+              const isVisible = (el) => {
+                if (!el) return false;
+                const style = window.getComputedStyle(el);
+                if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') return false;
+                const r = el.getBoundingClientRect();
+                if (!r.width || !r.height) return false;
+                if (r.bottom <= 0 || r.top >= window.innerHeight) return false;
+                return true;
+              };
+              let visibleOverlay = null;
+              for (const sel of selectors) {
+                const el = document.querySelector(sel);
+                if (el && isVisible(el)) {
+                  visibleOverlay = el;
+                  break;
+                }
+              }
+              return { hasDetailOverlayVisible: !!visibleOverlay };
+            })()`,
+                    });
+                    const payload = domState.result || domState.data?.result || domState;
+                    overlayGone = !Boolean(payload?.hasDetailOverlayVisible);
+                }
+                catch (e) {
+                    console.warn(`[ErrorRecovery] overlay DOM check after container-close failed: ${e.message}`);
+                }
+                if (anchorOk && overlayGone) {
+                    console.log('[ErrorRecovery] ✅ detail closed via container operation (anchor matched, overlay gone)');
+                    return { success: true, method: 'container-close' };
+                }
+                if (anchorOk && !overlayGone) {
+                    console.warn('[ErrorRecovery] search_result_list visible but detail overlay still present after container-close, will fallback to ESC key');
+                }
+            }
+            catch (err) {
+                console.warn(`[ErrorRecovery] verify search_result_list after close failed: ${err?.message || err}`);
+            }
+        }
+        catch (err) {
+            console.warn(`[ErrorRecovery] container close failed, fallback to ESC key: ${err?.message || String(err)}`);
+        }
+        // 2) 兜底：再次发送 ESC 键关闭详情页
+        try {
+            await controllerAction('keyboard:press', { profileId: sessionId, key: 'Escape' });
+            await new Promise((resolve) => setTimeout(resolve, 1500));
+            const { verifyAnchorByContainerId } = await import('./helpers/containerAnchors.js');
+            const anchor = await verifyAnchorByContainerId('xiaohongshu_search.search_result_list', sessionId, serviceUrl, '2px solid #4caf50', 1000);
+            const ok = Boolean(anchor.found && anchor.rect && anchor.rect.width > 0 && anchor.rect.height > 0);
+            return { success: ok, method: 'esc-key-double' };
+        }
+        catch (err) {
+            console.warn(`[ErrorRecovery] second ESC fallback failed: ${err?.message || err}`);
+            return { success: false, method: 'esc-key-double-error' };
+        }
+    }
+    console.log(`[ErrorRecovery] 从 ${fromStage} 恢复到 ${targetStage}...`);
+    try {
+        const currentUrl = await getCurrentUrl();
+        const atSearch = await verifyStage('search');
+        const atHome = await verifyStage('home');
+        if ((targetStage === 'search' && atSearch) || (targetStage === 'home' && atHome)) {
+            console.log(`[ErrorRecovery] ✅ 已在目标阶段 ${targetStage}（anchor verified）`);
+            return {
+                success: true,
+                recovered: false,
+                finalStage: targetStage,
+                currentUrl,
+                method: 'already-at-target',
+            };
+        }
+        if (fromStage === 'detail' && targetStage === 'search') {
+            const escResult = await recoverWithEsc();
+            if (escResult.success) {
+                const verified = await verifyStage('search');
+                if (verified) {
+                    return {
+                        success: true,
+                        recovered: true,
+                        finalStage: 'search',
+                        currentUrl: await getCurrentUrl(),
+                        method: escResult.method,
+                    };
+                }
+            }
+            return {
+                success: false,
+                recovered: false,
+                finalStage: 'unknown',
+                currentUrl: await getCurrentUrl(),
+                error: 'esc_recovery_failed',
+                method: 'esc_recovery_failed',
+            };
+        }
+        return {
+            success: false,
+            recovered: false,
+            finalStage: 'unknown',
+            currentUrl,
+            error: `unsupported_recovery_path: from=${fromStage} target=${targetStage} (esc only)`,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            recovered: false,
+            finalStage: 'unknown',
+            error: `恢复异常: ${err.message}`
+        };
+    }
+}
+//# sourceMappingURL=ErrorRecoveryBlock.js.map

package/dist/modules/xiaohongshu/app/src/workflow/blocks/WaitSearchPermitBlock.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Workflow Block: WaitSearchPermitBlock
+ *
+ * 职责：
+ * 1. 向 SearchGate 申请搜索许可
+ * 2. 如果未获许可，自动等待并重试
+ * 3. 只有拿到许可后才成功返回
+ */
+export interface WaitSearchPermitInput {
+    sessionId: string;
+    keyword?: string;
+    gateUrl?: string;
+    serviceUrl?: string;
+    maxWaitMs?: number;
+    skipIfAlreadyOnSearchResult?: boolean;
+    dev?: boolean;
+    devTag?: string;
+}
+export interface WaitSearchPermitOutput {
+    success: boolean;
+    granted: boolean;
+    waitedMs: number;
+    skipped?: boolean;
+    reason?: string | null;
+    retryAfterMs?: number | null;
+    deny?: {
+        code: string;
+        message: string;
+        retryAfterMs: number | null;
+        details: any;
+        suggestedActions: string[];
+    } | null;
+    error?: string;
+}
+export declare function execute(input: WaitSearchPermitInput): Promise<WaitSearchPermitOutput>;
+//# sourceMappingURL=WaitSearchPermitBlock.d.ts.map