/**
 * Core types for LLM Browser MCP Server
 */
import type { WebSocketPattern, WebSocketConnection } from './websocket-patterns.js';
export * from './api-patterns.js';
export * from './field-confidence.js';
export * from './decision-trace.js';
export * from './errors.js';
export * from './provenance.js';
export * from './progress.js';
export * from './websocket-patterns.js';
export * from './pattern-health.js';
export * from './verification.js';
export * from './content-change.js';
export * from './pdf-forms.js';
export * from './accessibility.js';
export * from './interaction-patterns.js';
export * from './visual-regression.js';
export * from './vision-matcher.js';
export interface NetworkRequest {
    url: string;
    method: string;
    status: number;
    statusText: string;
    headers: Record<string, string>;
    requestHeaders: Record<string, string>;
    responseBody?: any;
    contentType?: string;
    timestamp: number;
    duration?: number;
}
export interface ConsoleMessage {
    type: 'log' | 'info' | 'warn' | 'error' | 'debug';
    text: string;
    timestamp: number;
    location?: {
        url: string;
        lineNumber?: number;
        columnNumber?: number;
    };
}
export interface ApiPattern {
    endpoint: string;
    method: string;
    confidence: 'high' | 'medium' | 'low';
    canBypass: boolean;
    authType?: 'cookie' | 'bearer' | 'header' | 'session';
    authHeaders?: Record<string, string>;
    responseType?: string;
    params?: Record<string, any>;
    reason?: string;
}
export interface SessionStore {
    domain: string;
    profile?: string;
    cookies: any[];
    localStorage: Record<string, string>;
    sessionStorage: Record<string, string>;
    isAuthenticated: boolean;
    authType?: string;
    lastUsed: number;
    createdAt?: number;
    expiresAt?: number;
    username?: string;
    /** Metadata for session sharing and multi-portal tracking (GAP-009, INT-002) */
    metadata?: {
        /** Domain the session was shared from (GAP-009) */
        sharedFrom?: string;
        /** Timestamp when session was shared (GAP-009) */
        sharedAt?: number;
        /** Identity provider ID connecting domains (GAP-009) */
        providerId?: string;
        /** Portal group identifier for multi-portal tracking (INT-002) */
        portalGroup?: string;
        /** Login sequence number within portal group (INT-002) */
        loginSequence?: number;
        /** Parent session this depends on (INT-002) */
        parentSession?: {
            domain: string;
            profile: string;
        };
        /** Child sessions that depend on this one (INT-002) */
        childSessions?: Array<{
            domain: string;
            profile: string;
        }>;
        /** Whether this is the primary/root session in the group (INT-002) */
        isPrimarySession?: boolean;
        /** Last verified timestamp for session validity (INT-002) */
        lastVerified?: number;
    };
}
export interface KnowledgeBaseEntry {
    domain: string;
    patterns: ApiPattern[];
    lastUsed: number;
    usageCount: number;
    successRate: number;
}
export interface BrowseOptions {
    waitFor?: 'load' | 'domcontentloaded' | 'networkidle';
    waitForSelector?: string;
    timeout?: number;
    captureNetwork?: boolean;
    captureConsole?: boolean;
    sessionProfile?: string;
    dismissCookieBanner?: boolean;
    scrollToLoad?: boolean;
    detectLanguage?: boolean;
    useRateLimiting?: boolean;
    retryOnError?: boolean;
}
export interface BrowseResult {
    url: string;
    title: string;
    content: {
        html: string;
        markdown: string;
        text: string;
    };
    tables?: ExtractedTableResult[];
    network: NetworkRequest[];
    console: ConsoleMessage[];
    discoveredApis: ApiPattern[];
    /** Accessibility tree for AI-friendly element interaction */
    accessibilityTree?: import('./accessibility.js').AccessibilityTree;
    metadata: {
        loadTime: number;
        timestamp: number;
        finalUrl: string;
        language?: string;
        fromCache?: boolean;
        retryCount?: number;
        /**
         * Domain-based authority classification for the browsed URL.
         * Populated automatically on every browse response so consumers
         * can rank or filter by trust tier without classifying URLs
         * themselves. See `AuthorityClassification` in
         * core/source-authority.ts for the full shape and category list.
         */
        authority?: import('../core/source-authority.js').AuthorityClassification;
        /**
         * Raw structured data extracted from the page (JSON-LD,
         * microdata, OpenGraph, Twitter Card, Dublin Core, RDFa, meta
         * tags). Populated when `options.extract !== false`. See
         * `StructuredDataResult` in core/structured-data-extractor.ts
         * for the full shape.
         */
        structuredData?: import('../core/structured-data-extractor.js').StructuredDataResult;
        /**
         * Common fields projected from `structuredData` into a
         * source-agnostic shape. Each field is the highest-priority
         * value found across JSON-LD, microdata, OpenGraph, etc.,
         * with provenance recorded in `extracted.sources`.
         *
         * Use this when you want "the page's title" or "the document
         * author" without caring which markup format the source site
         * happened to use. The raw `structuredData` is still available
         * for callers needing custom shapes.
         *
         * Populated when `options.extract !== false`.
         */
        extracted?: import('../core/structured-projector.js').ProjectedFieldsWithSources;
    };
}
export interface ExtractedTableResult {
    headers: string[];
    data: Record<string, string>[];
    caption?: string;
}
export interface ApiCallOptions {
    method?: string;
    headers?: Record<string, string>;
    body?: any;
    inheritAuth?: boolean;
    sessionProfile?: string;
}
/**
 * Enhanced API pattern with temporal tracking and provenance
 */
export interface EnhancedApiPattern extends ApiPattern {
    createdAt: number;
    lastVerified: number;
    verificationCount: number;
    failureCount: number;
    lastFailure?: FailureContext;
    /** Provenance metadata for tracking pattern origin and history (CX-006) */
    provenance?: import('./provenance.js').ProvenanceMetadata;
}
/**
 * Failure context for learning from errors
 */
export interface FailureContext {
    type: 'auth_expired' | 'rate_limited' | 'site_changed' | 'timeout' | 'blocked' | 'not_found' | 'server_error' | 'unknown';
    responseStatus?: number;
    errorMessage?: string;
    timestamp: number;
    recoveryAttempted?: boolean;
    recoverySucceeded?: boolean;
}
/**
 * Semantic selector information (ARIA role-based)
 * More resilient to DOM structure changes than CSS selectors
 */
export interface SemanticSelector {
    role: string;
    name?: string;
    label?: string;
    placeholder?: string;
    level?: number;
}
/**
 * Selector pattern for content extraction
 */
export interface SelectorPattern {
    selector: string;
    contentType: 'main_content' | 'requirements' | 'fees' | 'timeline' | 'documents' | 'contact' | 'navigation' | 'table';
    priority: number;
    successCount: number;
    failureCount: number;
    lastWorked: number;
    lastFailed?: number;
    domain: string;
    urlPattern?: string;
    semanticSelector?: SemanticSelector;
    preferSemantic?: boolean;
}
/**
 * Selector fallback chain
 */
export interface SelectorChain {
    contentType: SelectorPattern['contentType'];
    selectors: SelectorPattern[];
    domain: string;
}
/**
 * Content change frequency tracking
 */
export interface RefreshPattern {
    urlPattern: string;
    domain: string;
    avgChangeFrequencyHours: number;
    minChangeFrequencyHours: number;
    maxChangeFrequencyHours: number;
    sampleCount: number;
    lastChecked: number;
    lastChanged: number;
    contentHash?: string;
}
/**
 * Cross-domain pattern group
 */
export interface DomainGroup {
    name: string;
    domains: string[];
    sharedPatterns: {
        cookieBannerSelectors: string[];
        contentSelectors: string[];
        navigationSelectors: string[];
        paginationPattern?: PaginationPattern;
        commonAuthType?: 'cookie' | 'none';
        language?: string;
    };
    lastUpdated: number;
}
/**
 * Response validation rules
 */
export interface ContentValidator {
    domain: string;
    urlPattern?: string;
    expectedMinLength: number;
    expectedMaxLength?: number;
    mustContainAny?: string[];
    mustContainAll?: string[];
    mustNotContain: string[];
    expectedLanguage?: string;
    successCount: number;
    failureCount: number;
}
/**
 * Pagination pattern
 */
export interface PaginationPattern {
    type: 'query_param' | 'path_segment' | 'infinite_scroll' | 'next_button' | 'load_more';
    paramName?: string;
    startValue?: number | string;
    increment?: number;
    selector?: string;
    scrollThreshold?: number;
    itemsPerPage?: number;
    maxPages?: number;
    hasMoreIndicator?: string;
}
/**
 * Detection type for bot protection systems
 */
export type BotDetectionType = 'cloudflare' | 'datadome' | 'perimeterx' | 'akamai' | 'recaptcha' | 'turnstile' | 'unknown';
/**
 * Anomaly false positive - record of when anomaly detection incorrectly flagged content
 * This allows the system to learn which anomaly detections are unreliable for specific domains
 */
export interface AnomalyFalsePositive {
    anomalyType: 'challenge_page' | 'error_page' | 'empty_content' | 'redirect_notice' | 'captcha' | 'rate_limited';
    triggerReasons: string[];
    actualContentLength: number;
    occurrences: number;
    firstSeen: number;
    lastSeen: number;
}
/**
 * Problem type for LLM-assisted research
 * Covers all categories of issues the browser might encounter
 */
export type ProblemType = 'bot_detection' | 'extraction_failure' | 'api_discovery' | 'authentication' | 'rate_limiting' | 'javascript_required' | 'dynamic_content' | 'pagination' | 'selector_failure' | 'timeout' | 'unknown';
/**
 * Research suggestion returned when the browser encounters problems
 * Enables LLM-assisted problem-solving feedback loop
 */
export interface ResearchSuggestion {
    /** Category of problem encountered */
    problemType: ProblemType;
    /** Search query to find solutions */
    searchQuery: string;
    /** Recommended sources to search (trusted technical sites) */
    recommendedSources: string[];
    /** For bot detection, the specific system detected */
    detectionType?: BotDetectionType;
    /** Parameters the LLM can adjust on retry */
    retryParameters: Array<'userAgent' | 'headers' | 'useFullBrowser' | 'delayMs' | 'fingerprintSeed' | 'waitForSelector' | 'scrollToLoad' | 'timeout' | 'extractionStrategy'>;
    /** Specific suggestions based on problem type */
    hints: string[];
    /** Relevant documentation URLs if known */
    documentationUrls?: string[];
}
/**
 * Detected interactive challenge element on the page
 * Used to help LLM understand what action might be required
 */
export interface ChallengeElement {
    /** Type of element detected */
    type: 'checkbox' | 'button' | 'captcha' | 'iframe' | 'unknown';
    /** CSS selector that can target this element */
    selector: string;
    /** Text content of the element if any */
    text?: string;
    /** Position on page (for visualization/clicking) */
    boundingBox?: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    /** Whether element is likely clickable */
    clickable: boolean;
    /** Whether clicking was attempted */
    clickAttempted?: boolean;
    /** Result of click attempt if made */
    clickResult?: 'success' | 'failed' | 'no_change' | 'page_changed';
}
/**
 * Problem response with research suggestion for LLM-assisted solving
 */
export interface ProblemResponse {
    /** Whether a problem occurred that needs LLM assistance */
    needsAssistance: true;
    /** Category of problem */
    problemType: ProblemType;
    /** HTTP status code if available */
    statusCode?: number;
    /** For bot detection, the specific system */
    detectionType?: BotDetectionType;
    /** Human-readable explanation of what happened */
    reason: string;
    /** Research suggestion for LLM to investigate solutions */
    researchSuggestion: ResearchSuggestion;
    /** What was already tried */
    attemptedStrategies: string[];
    /** Partial content if any was extracted */
    partialContent?: string;
    /** The URL that had the problem */
    url: string;
    /** Domain for learning purposes */
    domain: string;
    /** Interactive challenge elements detected on the page */
    challengeElements?: ChallengeElement[];
    /** Whether automatic challenge solving was attempted */
    challengeSolveAttempted?: boolean;
    /** Result of automatic challenge solving attempt */
    challengeSolveResult?: 'success' | 'failed' | 'not_attempted' | 'requires_human' | 'no_change';
    /**
     * Current research depth (LR-005).
     * Tracks how many research-assisted retries have been attempted.
     * When this reaches MAX_RESEARCH_DEPTH, no more research suggestions are provided.
     */
    researchDepth: number;
    /**
     * Whether maximum research depth has been reached (LR-005).
     * When true, the LLM should not attempt further research-based retries
     * and should report the issue as unresolvable via automated means.
     */
    maxResearchDepthReached: boolean;
}
/** @deprecated Use ProblemResponse instead */
export type BlockedResponse = ProblemResponse;
/**
 * Retry configuration that LLM can pass after researching solutions
 */
export interface RetryConfig {
    /** Custom User-Agent to try */
    userAgent?: string;
    /** Custom headers to add/override */
    headers?: Record<string, string>;
    /** Force full browser rendering */
    useFullBrowser?: boolean;
    /** Delay before request (ms) */
    delayMs?: number;
    /** Custom fingerprint seed */
    fingerprintSeed?: string;
    /** Specific platform to emulate */
    platform?: 'Windows' | 'macOS' | 'Linux';
    /** Number of retry attempts already made */
    retryAttempt?: number;
    /**
     * Number of research-assisted retries already attempted (LR-005).
     * Used to prevent infinite LLM research loops.
     * Max 2 research attempts per blocked site.
     */
    researchDepth?: number;
    /** Wait for a specific selector before extraction */
    waitForSelector?: string;
    /** Scroll to trigger lazy loading */
    scrollToLoad?: boolean;
    /** Custom timeout (ms) */
    timeout?: number;
    /** Force a specific extraction strategy */
    extractionStrategy?: string;
    /** Custom selectors to try */
    customSelectors?: Record<string, string>;
}
/**
 * CAPTCHA metrics for domain tracking (QA-FIX-002)
 * Tracks CAPTCHA encounter rate to enable automatic fallback to alternative sources
 */
export interface CaptchaMetrics {
    /** Total requests to this domain */
    totalRequests: number;
    /** Number of CAPTCHA encounters */
    captchaEncounters: number;
    /** Most recent CAPTCHA encounter timestamp */
    lastCaptchaAt?: number;
    /** Rolling CAPTCHA rate (encounters / total) */
    captchaRate: number;
    /** Whether this domain should be avoided (high CAPTCHA rate) */
    shouldAvoid: boolean;
    /** Timestamp when avoidance was triggered */
    avoidanceStartedAt?: number;
    /** CAPTCHA types encountered */
    captchaTypes: string[];
}
/**
 * QA-FEAT-002: Source quality metrics for routing decisions
 * Tracks comprehensive quality indicators per domain
 */
export interface SourceQualityMetrics {
    /** Total requests to this domain */
    totalRequests: number;
    /** Successful extractions (got usable data) */
    successfulExtractions: number;
    /** Failed requests (errors, timeouts, etc) */
    failedRequests: number;
    /** Success rate (0-1) */
    successRate: number;
    /** Error rate (0-1) */
    errorRate: number;
    /** Average response time in ms */
    avgResponseTimeMs: number;
    /** Response times for rolling average (last 10) */
    recentResponseTimes: number[];
    /** Last successful extraction timestamp */
    lastSuccessAt?: number;
    /** Last failed request timestamp */
    lastFailureAt?: number;
    /** Average content completeness score (0-1, based on schema match) */
    avgContentCompleteness: number;
    /** Recent completeness scores for rolling average */
    recentCompletenessScores: number[];
    /** Data freshness - how recently data was successfully fetched */
    dataFreshnessMs?: number;
    /** Most common error types */
    errorTypes: Record<string, number>;
    /** Quality score (0-100, composite metric) */
    qualityScore: number;
    /** Quality tier based on score */
    qualityTier: 'excellent' | 'good' | 'fair' | 'poor' | 'avoid';
    /** Recommendation for using this source */
    recommendation: string;
}
/**
 * OWL-009: Lazy-load profile - learned lazy loading patterns
 * Helps decide whether to skip lightweight tier or use scroll simulation
 */
export interface LazyLoadProfile {
    /** Whether lazy loading was detected */
    hasLazyLoad: boolean;
    /** Detected pattern types */
    patterns: string[];
    /** Confidence level of detection */
    confidence: 'low' | 'medium' | 'high';
    /** Number of times lazy loading was detected */
    detectionCount: number;
    /** Whether scroll simulation is required (high confidence) */
    requiresScroll: boolean;
    /** Last detection timestamp */
    lastDetected: number;
    /** Success rate with lightweight tier despite lazy loading */
    lightweightSuccessRate?: number;
}
/**
 * Success profile - what works well for a domain
 * This helps the system remember successful strategies and skip failed ones
 */
export interface SuccessProfile {
    preferredTier: 'intelligence' | 'lightweight' | 'playwright';
    preferredStrategy?: string;
    avgResponseTime: number;
    avgContentLength: number;
    successCount: number;
    lastSuccess: number;
    effectiveUserAgent?: string;
    effectiveHeaders?: Record<string, string>;
    hasStructuredData: boolean;
    hasFrameworkData: boolean;
    hasBypassableApis: boolean;
    lazyLoadProfile?: LazyLoadProfile;
    notes?: string;
}
/**
 * Enhanced knowledge base entry with all learning features
 */
/**
 * Pattern tier for progressive disclosure (PROG-001)
 * - essential: Core patterns always loaded (common APIs, basic selectors)
 * - domain-specific: Loaded when domain matches
 * - advanced: Loaded on explicit need (edge cases, rare patterns)
 */
export type PatternTier = 'essential' | 'domain-specific' | 'advanced';
export interface EnhancedKnowledgeBaseEntry {
    domain: string;
    apiPatterns: EnhancedApiPattern[];
    websocketPatterns?: WebSocketPattern[];
    selectorChains: SelectorChain[];
    refreshPatterns: RefreshPattern[];
    validators: ContentValidator[];
    paginationPatterns: Map<string, PaginationPattern> | Record<string, PaginationPattern>;
    recentFailures: FailureContext[];
    anomalyFalsePositives?: AnomalyFalsePositive[];
    successProfile?: SuccessProfile;
    captchaMetrics?: CaptchaMetrics;
    sourceQualityMetrics?: SourceQualityMetrics;
    domainGroup?: string;
    lastUsed: number;
    usageCount: number;
    overallSuccessRate: number;
    createdAt: number;
    lastUpdated: number;
    tier?: PatternTier;
    loadPriority?: number;
    sizeEstimate?: number;
    contentLoadingPatterns?: ContentLoadingPatternEntry[];
}
/**
 * Content loading pattern entry for persistence (GAP-008)
 */
export interface ContentLoadingPatternEntry {
    /** Unique identifier */
    id: string;
    /** API endpoint that loads content */
    endpoint: string;
    /** URL pattern for matching */
    urlPattern: string;
    /** HTTP method */
    method: 'GET' | 'POST';
    /** When content is triggered to load */
    triggerType: 'immediate' | 'delayed' | 'on_scroll' | 'on_interaction' | 'on_visibility';
    /** Delay in ms for 'delayed' trigger */
    triggerDelay?: number;
    /** Parameters that vary between requests */
    variableParams: string[];
    /** Path to data in response */
    dataPath: string;
    /** Type of data at the path */
    dataType: 'array' | 'object' | 'string';
    /** Estimated item count (for arrays) */
    itemCount?: number;
    /** Size of response in bytes */
    responseSize: number;
    /** Fields that look like content */
    contentFields: string[];
    /** Whether this endpoint is essential for page content */
    isEssential: boolean;
    /** Confidence in this pattern (0-1) */
    confidence: number;
    /** Average response time (ms) */
    avgResponseTime: number;
    /** When pattern was discovered */
    discoveredAt: number;
    /** When pattern was last used */
    lastUsedAt: number;
}
/**
 * Learning event for tracking what was learned
 */
export interface LearningEvent {
    type: 'api_discovered' | 'selector_learned' | 'validator_created' | 'pagination_detected' | 'failure_recorded' | 'pattern_verified' | 'confidence_decayed' | 'content_loading_detected';
    domain: string;
    details: Record<string, unknown>;
    timestamp: number;
}
/**
 * Confidence decay configuration
 */
export interface ConfidenceDecayConfig {
    gracePeriodDays: number;
    decayRatePerWeek: number;
    minConfidenceThreshold: number;
    archiveAfterDays: number;
}
/**
 * A browsing action that can be part of a skill
 */
export interface BrowsingAction {
    type: 'navigate' | 'click' | 'fill' | 'select' | 'scroll' | 'wait' | 'extract' | 'dismiss_banner';
    selector?: string;
    /** Semantic selector (ARIA-based) - more resilient than CSS selectors */
    semanticSelector?: SemanticSelector;
    /** Whether to prefer semantic selector over CSS (default: true if semantic available) */
    preferSemantic?: boolean;
    value?: string;
    url?: string;
    waitFor?: 'load' | 'networkidle' | 'selector';
    timestamp: number;
    success: boolean;
    duration?: number;
}
/**
 * Preconditions for when a skill is applicable
 */
export interface SkillPreconditions {
    urlPatterns?: string[];
    domainPatterns?: string[];
    requiredSelectors?: string[];
    requiredText?: string[];
    pageType?: 'list' | 'detail' | 'form' | 'search' | 'login' | 'unknown';
    language?: string;
    contentTypeHints?: Array<SelectorPattern['contentType']>;
}
/**
 * Skill tier for progressive disclosure (PROG-001)
 * - essential: Always loaded (cookie banners, common patterns)
 * - domain-specific: Loaded when domain matches
 * - advanced: Loaded on explicit need (rare/specialized patterns)
 */
export type SkillTier = 'essential' | 'domain-specific' | 'advanced';
/**
 * A learned browsing skill (procedural memory unit)
 */
export interface BrowsingSkill {
    id: string;
    name: string;
    description: string;
    preconditions: SkillPreconditions;
    actionSequence: BrowsingAction[];
    embedding: number[];
    metrics: {
        successCount: number;
        failureCount: number;
        avgDuration: number;
        /**
         * Timestamp of the most recent invocation, success OR failure.
         * Bumped on every recordSkillExecution call. Use `lastSuccess`
         * when you specifically need "last successful" semantics —
         * `lastUsed` will mislead you on a skill that's recently been
         * attempted but failing.
         */
        lastUsed: number;
        /**
         * Timestamp of the most recent SUCCESSFUL invocation. Distinct
         * from `lastUsed`, which bumps on failure too. Defaults to 0
         * for skills that have never succeeded. Used by downstream
         * freshness policies that care about whether the skill is
         * actually working.
         */
        lastSuccess: number;
        timesUsed: number;
    };
    createdAt: number;
    updatedAt: number;
    sourceUrl?: string;
    sourceDomain?: string;
    verificationChecks?: Array<{
        check: import('./verification.js').VerificationCheck;
        confidence: number;
        learnedFrom: 'success' | 'failure';
    }>;
    tier?: SkillTier;
    loadPriority?: number;
    sizeEstimate?: number;
}
/**
 * A recorded browsing trajectory (for skill extraction)
 */
export interface BrowsingTrajectory {
    id: string;
    startUrl: string;
    endUrl: string;
    domain: string;
    actions: BrowsingAction[];
    success: boolean;
    totalDuration: number;
    extractedContent?: {
        text: string;
        tables: number;
        apis: number;
    };
    timestamp: number;
}
/**
 * Skill retrieval result with similarity score
 */
export interface SkillMatch {
    skill: BrowsingSkill;
    similarity: number;
    preconditionsMet: boolean;
    reason?: string;
}
/**
 * Result of executing a skill's action (TC-003)
 */
export interface SkillActionResult {
    type: BrowsingAction['type'];
    selector?: string;
    success: boolean;
    duration: number;
    error?: string;
}
/**
 * Trace of skill execution for debugging and learning (TC-003)
 */
export interface SkillExecutionTrace {
    skillId: string;
    skillName: string;
    matchReason: string;
    similarity: number;
    success: boolean;
    totalDuration: number;
    actionResults: SkillActionResult[];
    actionsExecuted: number;
    totalActions: number;
    error?: string;
    usedFallback: boolean;
    fallbackSkillId?: string;
}
/**
 * Configuration for the procedural memory system
 */
export interface ProceduralMemoryConfig {
    embeddingDim: number;
    similarityThreshold: number;
    maxSkills: number;
    minTrajectoryLength: number;
    mergeThreshold: number;
    filePath: string;
    maxVersionsPerSkill?: number;
    maxFeedbackLogSize?: number;
    autoRollbackThreshold?: number;
    storagePath?: string;
}
/**
 * Page context for skill matching
 */
export interface PageContext {
    url: string;
    domain: string;
    title?: string;
    language?: string;
    pageType?: SkillPreconditions['pageType'];
    availableSelectors?: string[];
    contentLength?: number;
    hasForm?: boolean;
    hasPagination?: boolean;
    hasTable?: boolean;
}
/**
 * A composed workflow combining multiple skills
 */
export interface SkillWorkflow {
    id: string;
    name: string;
    description: string;
    skillIds: string[];
    preconditions: SkillPreconditions;
    transitions: Array<{
        fromSkillId: string;
        toSkillId: string;
        condition?: 'success' | 'always' | 'has_pagination' | 'has_next' | 'failure' | 'has_form' | 'has_table' | 'content_extracted' | 'custom';
        /** Custom condition function name (for serialization) */
        customConditionName?: string;
    }>;
    metrics: {
        successCount: number;
        failureCount: number;
        avgDuration: number;
        lastUsed: number;
        timesUsed: number;
    };
    embedding?: number[];
    createdAt: number;
    updatedAt: number;
}
/**
 * Result of executing a single skill within a workflow
 */
export interface SkillExecutionResult {
    skillId: string;
    skillName: string;
    success: boolean;
    duration: number;
    output?: unknown;
    error?: string;
    /** The transition condition that was evaluated */
    transitionEvaluated?: string;
    /** Whether to continue to next skill */
    continueExecution: boolean;
}
/**
 * Result of executing an entire workflow
 */
export interface WorkflowExecutionResult {
    workflowId: string;
    workflowName: string;
    success: boolean;
    totalDuration: number;
    skillResults: SkillExecutionResult[];
    /** Index of the skill that failed (if any) */
    failedAtSkillIndex?: number;
    /** Aggregated output from all skills */
    aggregatedOutput?: unknown;
    executedAt: number;
}
/**
 * Context for evaluating workflow transitions
 */
export interface WorkflowTransitionContext {
    /** Result from the previous skill */
    previousResult?: SkillExecutionResult;
    /** Current page context */
    pageContext?: PageContext;
    /** Whether pagination is detected */
    hasPagination?: boolean;
    /** Whether a "next" element is detected */
    hasNext?: boolean;
    /** Custom data from skill execution */
    customData?: Record<string, unknown>;
}
/**
 * Extended transition with more condition types
 */
export type WorkflowTransitionCondition = 'success' | 'always' | 'has_pagination' | 'has_next' | 'failure' | 'has_form' | 'has_table' | 'content_extracted' | 'custom';
/**
 * Options for creating a workflow
 */
export interface CreateWorkflowOptions {
    name: string;
    skillIds: string[];
    description?: string;
    /** Custom transition conditions (default: 'success' between all) */
    transitions?: Array<{
        fromSkillId: string;
        toSkillId: string;
        condition: WorkflowTransitionCondition;
        /** Custom condition evaluator (for 'custom' condition type) */
        customCondition?: (ctx: WorkflowTransitionContext) => boolean;
    }>;
    /** Preconditions that must be met to start the workflow */
    preconditions?: SkillPreconditions;
}
/**
 * Match result when retrieving workflows
 */
export interface WorkflowMatch {
    workflow: SkillWorkflow;
    similarity: number;
    reason: string;
}
/**
 * Options for workflow execution
 */
export interface WorkflowExecutionOptions {
    /** Maximum time for entire workflow (ms) */
    timeout?: number;
    /** Whether to stop on first failure */
    stopOnFailure?: boolean;
    /** Custom transition context data */
    contextData?: Record<string, unknown>;
    /** Callback for each skill completion */
    onSkillComplete?: (result: SkillExecutionResult) => void;
}
/**
 * Coverage tracking for active learning
 */
export interface CoverageStats {
    coveredDomains: string[];
    coveredPageTypes: Array<SkillPreconditions['pageType']>;
    uncoveredDomains: string[];
    uncoveredPageTypes: Array<SkillPreconditions['pageType']>;
    suggestions: Array<{
        type: 'domain' | 'pageType' | 'action';
        value: string;
        reason: string;
        priority: 'high' | 'medium' | 'low';
    }>;
}
/**
 * A snapshot of a skill at a specific version
 */
export interface SkillVersion {
    version: number;
    createdAt: number;
    actionSequence: BrowsingAction[];
    embedding: number[];
    metricsSnapshot: {
        successCount: number;
        failureCount: number;
        successRate: number;
        avgDuration: number;
        timesUsed: number;
    };
    changeReason: 'initial' | 'merge' | 'update' | 'rollback' | 'optimization';
    changeDescription?: string;
}
/**
 * Extended skill with versioning support
 */
export interface VersionedBrowsingSkill extends BrowsingSkill {
    currentVersion: number;
    versionHistory: SkillVersion[];
    rollbackThreshold?: {
        minSuccessRate: number;
        minUsesBeforeRollback: number;
    };
}
/**
 * An anti-pattern - something learned NOT to do
 */
export interface AntiPattern {
    id: string;
    name: string;
    description: string;
    preconditions: SkillPreconditions;
    avoidActions: Array<{
        type: BrowsingAction['type'];
        selector?: string;
        reason: string;
    }>;
    occurrenceCount: number;
    consequences: string[];
    alternatives?: BrowsingAction[];
    createdAt: number;
    updatedAt: number;
    sourceDomain?: string;
    sourceUrl?: string;
}
/**
 * Human-readable explanation of a skill
 */
export interface SkillExplanation {
    summary: string;
    steps: Array<{
        stepNumber: number;
        action: string;
        target?: string;
        purpose: string;
    }>;
    applicability: string;
    reliability: string;
    tips?: string[];
}
/**
 * User feedback on a skill application
 */
export interface SkillFeedback {
    skillId: string;
    rating: 'positive' | 'negative';
    reason?: string;
    context: {
        url: string;
        domain: string;
        timestamp: number;
    };
    processed: boolean;
}
/**
 * Extended preconditions with dependencies and fallbacks
 */
export interface ExtendedSkillPreconditions extends SkillPreconditions {
    prerequisites?: string[];
    fallbackSkillIds?: string[];
}
/**
 * Domain vertical categories for skill organization
 */
export type SkillVertical = 'government' | 'ecommerce' | 'documentation' | 'social' | 'news' | 'developer' | 'finance' | 'travel' | 'healthcare' | 'education' | 'general';
/**
 * Metadata for an exported skill pack
 */
export interface SkillPackMetadata {
    id: string;
    name: string;
    description: string;
    version: string;
    createdAt: number;
    sourceInstance?: string;
    verticals: SkillVertical[];
    domains: string[];
    stats: {
        skillCount: number;
        antiPatternCount: number;
        workflowCount: number;
        totalSuccessCount: number;
        avgSuccessRate: number;
    };
    compatibility: {
        minVersion: string;
        schemaVersion: string;
    };
}
/**
 * A portable skill pack for sharing/importing
 */
export interface SkillPack {
    metadata: SkillPackMetadata;
    skills: BrowsingSkill[];
    antiPatterns: AntiPattern[];
    workflows: SkillWorkflow[];
}
/**
 * Options for exporting skills
 */
export interface SkillExportOptions {
    domainPatterns?: string[];
    verticals?: SkillVertical[];
    includeAntiPatterns?: boolean;
    includeWorkflows?: boolean;
    minSuccessRate?: number;
    minUsageCount?: number;
    packName?: string;
    packDescription?: string;
}
/**
 * Conflict resolution strategy for skill import
 */
export type SkillConflictResolution = 'skip' | 'overwrite' | 'merge' | 'rename';
/**
 * Options for importing skills
 */
export interface SkillImportOptions {
    conflictResolution?: SkillConflictResolution;
    domainFilter?: string[];
    verticalFilter?: SkillVertical[];
    importAntiPatterns?: boolean;
    importWorkflows?: boolean;
    resetMetrics?: boolean;
    namePrefix?: string;
}
/**
 * Result of a skill import operation
 */
export interface SkillImportResult {
    success: boolean;
    skillsImported: number;
    skillsSkipped: number;
    skillsMerged: number;
    antiPatternsImported: number;
    workflowsImported: number;
    errors: string[];
    warnings: string[];
}
/**
 * Metadata for a knowledge base export pack
 */
export interface KnowledgePackMetadata {
    id: string;
    name: string;
    description: string;
    version: string;
    createdAt: number;
    sourceInstance?: string;
    domains: string[];
    stats: {
        domainCount: number;
        apiPatternCount: number;
        selectorCount: number;
        validatorCount: number;
        paginationPatternCount: number;
        antiPatternCount: number;
    };
    compatibility: {
        minVersion: string;
        schemaVersion: string;
    };
}
/**
 * Exported knowledge base pack
 */
export interface KnowledgePack {
    metadata: KnowledgePackMetadata;
    entries: Record<string, EnhancedKnowledgeBaseEntry>;
    antiPatterns?: import('./api-patterns.js').AntiPattern[];
    learningEvents?: LearningEvent[];
}
/**
 * Options for exporting knowledge base
 */
export interface KnowledgeExportOptions {
    domainPatterns?: string[];
    includeAntiPatterns?: boolean;
    includeLearningEvents?: boolean;
    minUsageCount?: number;
    minSuccessRate?: number;
    packName?: string;
    packDescription?: string;
}
/**
 * Conflict resolution strategy for knowledge import
 */
export type KnowledgeConflictResolution = 'skip' | 'overwrite' | 'merge';
/**
 * Options for importing knowledge base
 */
export interface KnowledgeImportOptions {
    conflictResolution?: KnowledgeConflictResolution;
    domainFilter?: string[];
    importAntiPatterns?: boolean;
    importLearningEvents?: boolean;
    resetMetrics?: boolean;
    confidenceAdjustment?: number;
}
/**
 * Result of a knowledge import operation
 */
export interface KnowledgeImportResult {
    success: boolean;
    domainsImported: number;
    domainsSkipped: number;
    domainsMerged: number;
    apiPatternsImported: number;
    selectorsImported: number;
    validatorsImported: number;
    antiPatternsImported: number;
    errors: string[];
    warnings: string[];
}
/**
 * Unified pattern pack combining knowledge base and skills
 */
export interface UnifiedPatternPack {
    metadata: {
        id: string;
        name: string;
        description: string;
        version: string;
        createdAt: number;
        sourceInstance?: string;
        domains: string[];
        stats: {
            domainCount: number;
            apiPatternCount: number;
            selectorCount: number;
            skillCount: number;
            workflowCount: number;
            antiPatternCount: number;
        };
        compatibility: {
            minVersion: string;
            schemaVersion: string;
        };
    };
    knowledge?: KnowledgePack;
    skills?: SkillPack;
}
/**
 * Options for unified export
 */
export interface UnifiedExportOptions {
    includeKnowledge?: boolean;
    includeSkills?: boolean;
    knowledgeOptions?: KnowledgeExportOptions;
    skillOptions?: SkillExportOptions;
    packName?: string;
    packDescription?: string;
}
/**
 * Options for unified import
 */
export interface UnifiedImportOptions {
    importKnowledge?: boolean;
    importSkills?: boolean;
    knowledgeOptions?: KnowledgeImportOptions;
    skillOptions?: SkillImportOptions;
}
/**
 * Result of unified import
 */
export interface UnifiedImportResult {
    success: boolean;
    knowledge?: KnowledgeImportResult;
    skills?: SkillImportResult;
    errors: string[];
    warnings: string[];
}
/**
 * Rendering tier for content fetching
 * - intelligence: Content Intelligence (fastest, ~50-200ms)
 *   - Framework data extraction (__NEXT_DATA__, etc.)
 *   - Structured data (JSON-LD, OpenGraph)
 *   - API prediction and direct calling
 *   - Google Cache / Archive.org fallbacks
 *   - Static HTML parsing
 * - lightweight: HTTP + linkedom + Node VM (medium, ~200-500ms)
 * - playwright: Full Chromium browser (slowest, ~2-5s, OPTIONAL)
 */
export type RenderTier = 'intelligence' | 'lightweight' | 'playwright';
/**
 * Status of a single URL in a batch operation
 */
export type BatchItemStatus = 'success' | 'error' | 'skipped' | 'rate_limited';
/**
 * Result for a single URL in a batch browse operation
 */
export interface BatchBrowseItem<T> {
    url: string;
    status: BatchItemStatus;
    result?: T;
    error?: string;
    errorCode?: string;
    durationMs: number;
    index: number;
}
/**
 * Options for batch browse operations
 */
export interface BatchBrowseOptions {
    concurrency?: number;
    stopOnError?: boolean;
    continueOnRateLimit?: boolean;
    perUrlTimeoutMs?: number;
    totalTimeoutMs?: number;
}
/**
 * Domain-specific rendering preference
 */
export interface DomainRenderPreference {
    domain: string;
    preferredTier: RenderTier;
    successCount: number;
    failureCount: number;
    lastUsed: number;
    avgResponseTime: number;
}
/**
 * Result from tiered fetching
 */
export interface TieredFetchResult {
    html: string;
    content: {
        markdown: string;
        text: string;
        title: string;
    };
    tier: RenderTier;
    finalUrl: string;
    fellBack: boolean;
    tiersAttempted: RenderTier[];
    tierReason: string;
    networkRequests: NetworkRequest[];
    discoveredApis: ApiPattern[];
    websocketConnections?: WebSocketConnection[];
    timing: {
        total: number;
        perTier: Record<RenderTier, number>;
    };
}
//# sourceMappingURL=index.d.ts.map