@rankcli/agent-runtime 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,4012 @@
+import OpenAI from 'openai';
+import { exec } from 'child_process';
+
+interface AgentDefinition {
+    name: string;
+    description: string;
+    model: string;
+    temperature: number;
+    max_tokens: number;
+    tools: AgentTool[];
+    system: string;
+    prompt: string;
+}
+interface AgentTool {
+    name: string;
+    description: string;
+}
+interface SEOIssue {
+    severity: 'critical' | 'warning' | 'info';
+    category: 'meta' | 'schema' | 'content' | 'technical' | 'performance' | 'social' | 'accessibility';
+    code: string;
+    message: string;
+    impact: string;
+    element?: string;
+    fix?: {
+        file: string;
+        before: string | null;
+        after: string;
+    };
+}
+interface SEOAnalysisResult {
+    url: string;
+    score: number;
+    core_web_vitals?: {
+        lcp?: {
+            value: string;
+            status: 'good' | 'needs-improvement' | 'poor';
+        };
+        fid?: {
+            value: string;
+            status: 'good' | 'needs-improvement' | 'poor';
+        };
+        cls?: {
+            value: string;
+            status: 'good' | 'needs-improvement' | 'poor';
+        };
+    };
+    issues: SEOIssue[];
+    recommendations: SEORecommendation[];
+}
+interface SEORecommendation {
+    priority: 'high' | 'medium' | 'low';
+    category: string;
+    message: string;
+    impact: string;
+}
+interface CrawlResult {
+    url: string;
+    html: string;
+    statusCode: number;
+    headers: Record<string, string>;
+    loadTime: number;
+}
+interface MetaData {
+    title?: string;
+    description?: string;
+    canonical?: string;
+    robots?: string;
+    viewport?: string;
+    charset?: string;
+    openGraph: {
+        title?: string;
+        description?: string;
+        image?: string;
+        url?: string;
+        type?: string;
+        siteName?: string;
+    };
+    twitter: {
+        card?: string;
+        title?: string;
+        description?: string;
+        image?: string;
+        site?: string;
+    };
+    other: Record<string, string>;
+}
+interface HeadingStructure {
+    tag: string;
+    text: string;
+    level: number;
+}
+interface ImageInfo$1 {
+    src: string;
+    alt: string | null;
+    width?: string;
+    height?: string;
+    loading?: string;
+}
+interface LinkInfo {
+    href: string;
+    text: string;
+    isInternal: boolean;
+    isNofollow: boolean;
+}
+interface SchemaData {
+    type: string;
+    data: Record<string, unknown>;
+}
+interface FrameworkInfo$1 {
+    name: string;
+    version?: string;
+    router?: 'app' | 'pages' | 'file-based' | 'custom';
+    metaPattern: 'metadata-export' | 'head-component' | 'frontmatter' | 'meta-function' | 'html-head';
+}
+interface Fix {
+    issue: {
+        code: string;
+        message: string;
+        severity: string;
+    };
+    file: string;
+    before: string | null;
+    after: string;
+    explanation: string;
+}
+interface ToolResult {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}
+type ToolFunction = (params: Record<string, unknown>) => Promise<ToolResult>;
+
+type IssueSeverity = 'error' | 'warning' | 'notice';
+type IssueCategory = 'crawlability' | 'indexability' | 'on-page' | 'content' | 'links' | 'images' | 'structured-data' | 'performance' | 'security' | 'mobile' | 'international' | 'ai-readiness' | 'social' | 'local-seo' | 'accessibility' | 'framework';
+interface AuditIssue {
+    code: string;
+    severity: IssueSeverity;
+    category: IssueCategory;
+    title: string;
+    description: string;
+    impact: string;
+    howToFix: string;
+    affectedUrls?: string[];
+    details?: Record<string, unknown>;
+}
+interface PageData {
+    url: string;
+    statusCode: number;
+    redirectChain?: string[];
+    html: string;
+    loadTime: number;
+    size: number;
+    headers: Record<string, string>;
+}
+interface CrawlStats {
+    totalUrls: number;
+    crawledUrls: number;
+    errorUrls: number;
+    redirectUrls: number;
+    blockedUrls: number;
+}
+interface HealthScore {
+    overall: number;
+    crawlability: number;
+    indexability: number;
+    onPage: number;
+    content: number;
+    links: number;
+    performance: number;
+    security: number;
+    aiReadiness: number;
+    social: number;
+    localSeo: number;
+    accessibility: number;
+}
+interface AuditReport {
+    url: string;
+    domain: string;
+    timestamp: string;
+    crawlStats: CrawlStats;
+    healthScore: HealthScore;
+    issues: AuditIssue[];
+    pages: PageAudit[];
+    summary: {
+        errors: number;
+        warnings: number;
+        notices: number;
+        passed: number;
+    };
+}
+interface PageAudit {
+    url: string;
+    statusCode: number;
+    title?: string;
+    description?: string;
+    canonical?: string;
+    h1?: string[];
+    wordCount: number;
+    loadTime: number;
+    issues: string[];
+}
+interface IssueDefinition {
+    code: string;
+    severity: IssueSeverity;
+    category: IssueCategory;
+    title: string;
+    description: string;
+    impact: string;
+    howToFix: string;
+}
+declare const ISSUE_DEFINITIONS: Record<string, IssueDefinition>;
+
+interface AuditOptions {
+    url: string;
+    checkBrokenLinks?: boolean;
+    checkHreflangUrls?: boolean;
+    checkCanonicalChain?: boolean;
+    maxPages?: number;
+    cruxApiKey?: string;
+    /**
+     * Maximum number of checks to run. Used for tier enforcement:
+     * - 50: Free unregistered users (core checks only)
+     * - 100: Free registered users (core + some premium checks)
+     * - 280+: Paid users (all checks)
+     */
+    checksLimit?: number;
+}
+declare function runFullAudit(options: AuditOptions): Promise<AuditReport>;
+declare function formatReport(report: AuditReport): string;
+
+interface RobotsTxtResult {
+    exists: boolean;
+    content?: string;
+    blocksAll: boolean;
+    hasSitemap: boolean;
+    sitemapUrls: string[];
+}
+declare function checkRobotsTxt(baseUrl: string): Promise<{
+    issues: AuditIssue[];
+    data: RobotsTxtResult;
+}>;
+declare function checkRedirects(url: string): Promise<{
+    issues: AuditIssue[];
+    chain: string[];
+    finalUrl: string;
+}>;
+declare function runCrawlabilityChecks(baseUrl: string): Promise<AuditIssue[]>;
+
+interface OnPageData {
+    title?: string;
+    titleLength: number;
+    description?: string;
+    descriptionLength: number;
+    canonical?: string;
+    h1s: string[];
+    headings: {
+        level: number;
+        text: string;
+    }[];
+    wordCount: number;
+    textToHtmlRatio: number;
+    hasNoindex: boolean;
+    metaRobots?: string;
+}
+declare function analyzeOnPage(html: string, url: string): {
+    issues: AuditIssue[];
+    data: OnPageData;
+};
+
+interface LinkData {
+    internal: {
+        href: string;
+        text: string;
+        nofollow: boolean;
+    }[];
+    external: {
+        href: string;
+        text: string;
+        nofollow: boolean;
+    }[];
+    totalLinks: number;
+    brokenInternal: string[];
+    brokenExternal: string[];
+    ratio: {
+        internal: number;
+        external: number;
+        internalToExternalRatio: number | null;
+    };
+}
+declare function analyzeLinks(html: string, baseUrl: string, checkBroken?: boolean): Promise<{
+    issues: AuditIssue[];
+    data: LinkData;
+}>;
+
+interface ImageData {
+    total: number;
+    missingAlt: {
+        src: string;
+    }[];
+    emptyAlt: {
+        src: string;
+    }[];
+    missingDimensions: {
+        src: string;
+    }[];
+    largImages: {
+        src: string;
+        size?: number;
+    }[];
+    brokenImages: {
+        src: string;
+    }[];
+    lazyLoaded: number;
+    withDimensions: number;
+}
+declare function analyzeImages(html: string, baseUrl: string, checkBroken?: boolean): Promise<{
+    issues: AuditIssue[];
+    data: ImageData;
+}>;
+
+interface PerformanceData {
+    loadTime: number;
+    ttfb: number;
+    htmlSize: number;
+    compressed: boolean;
+    cacheControl?: string;
+    contentEncoding?: string;
+}
+declare function analyzePerformance(url: string): Promise<{
+    issues: AuditIssue[];
+    data: PerformanceData;
+}>;
+declare function fetchCoreWebVitals(url: string, apiKey?: string): Promise<{
+    lcp?: {
+        value: number;
+        rating: 'good' | 'needs-improvement' | 'poor';
+    };
+    fid?: {
+        value: number;
+        rating: 'good' | 'needs-improvement' | 'poor';
+    };
+    cls?: {
+        value: number;
+        rating: 'good' | 'needs-improvement' | 'poor';
+    };
+    inp?: {
+        value: number;
+        rating: 'good' | 'needs-improvement' | 'poor';
+    };
+} | null>;
+
+interface SecurityData {
+    isHttps: boolean;
+    hasMixedContent: boolean;
+    mixedContentUrls: string[];
+    hasHsts: boolean;
+    hstsMaxAge?: number;
+    certificateExpiry?: Date;
+    certificateIssuer?: string;
+}
+declare function analyzeSecurity(html: string, url: string, headers: Record<string, string>): Promise<{
+    issues: AuditIssue[];
+    data: SecurityData;
+}>;
+declare function checkCertificate(url: string): Promise<{
+    valid: boolean;
+    expiresAt?: Date;
+    issuer?: string;
+    daysUntilExpiry?: number;
+    issues: AuditIssue[];
+}>;
+
+interface SchemaItem {
+    type: string;
+    data: Record<string, unknown>;
+    errors: string[];
+    warnings: string[];
+}
+interface StructuredDataData {
+    schemas: SchemaItem[];
+    hasSchema: boolean;
+    schemaTypes: string[];
+}
+declare function analyzeStructuredData(html: string, url: string): {
+    issues: AuditIssue[];
+    data: StructuredDataData;
+};
+declare function suggestSchemaTypes(html: string, url: string): string[];
+
+interface MobileData {
+    hasViewport: boolean;
+    viewportContent?: string;
+    isResponsive: boolean;
+    tapTargetIssues: number;
+    fontSizeIssues: number;
+}
+declare function analyzeMobile(html: string, url: string): {
+    issues: AuditIssue[];
+    data: MobileData;
+};
+declare function checkMobileResources(html: string, url: string): AuditIssue[];
+
+interface HreflangData {
+    hasHreflang: boolean;
+    entries: HreflangEntry[];
+    hasSelfReference: boolean;
+    hasXDefault: boolean;
+}
+interface HreflangEntry {
+    lang: string;
+    href: string;
+    isValid: boolean;
+    isSelfReference: boolean;
+    statusCode?: number;
+}
+declare function analyzeHreflang(html: string, url: string, options?: {
+    validateUrls?: boolean;
+}): Promise<{
+    issues: AuditIssue[];
+    data: HreflangData;
+}>;
+
+interface SocialMetaData {
+    openGraph: {
+        title?: string;
+        description?: string;
+        image?: string;
+        url?: string;
+        type?: string;
+        siteName?: string;
+    };
+    twitter: {
+        card?: string;
+        title?: string;
+        description?: string;
+        image?: string;
+        site?: string;
+        creator?: string;
+    };
+    hasFavicon: boolean;
+    langAttribute?: string;
+}
+declare function analyzeSocialMeta(html: string, url: string): {
+    issues: AuditIssue[];
+    data: SocialMetaData;
+};
+
+interface Soft404Data {
+    isSoft404: boolean;
+    confidence: number;
+    signals: string[];
+}
+declare function detectSoft404(html: string, url: string, statusCode?: number): {
+    issues: AuditIssue[];
+    data: Soft404Data;
+};
+
+interface AnchorTextData {
+    totalLinks: number;
+    internalLinks: number;
+    externalLinks: number;
+    emptyAnchors: number;
+    genericAnchors: number;
+    anchorDistribution: Record<string, number>;
+    topAnchors: {
+        text: string;
+        count: number;
+    }[];
+}
+declare function analyzeAnchorText(html: string, url: string): {
+    issues: AuditIssue[];
+    data: AnchorTextData;
+};
+
+interface CanonicalData {
+    canonical?: string;
+    isSelfReferencing: boolean;
+    isCrossDomain: boolean;
+    canonicalChain?: string[];
+    finalCanonical?: string;
+}
+declare function analyzeCanonicalAdvanced(html: string, url: string, options?: {
+    checkChain?: boolean;
+    sitemapUrls?: string[];
+}): Promise<{
+    issues: AuditIssue[];
+    data: CanonicalData;
+}>;
+
+interface ContentHashData {
+    url: string;
+    contentHash: string;
+    titleHash: string;
+    title?: string;
+    wordCount: number;
+    textSample: string;
+}
+interface DuplicateDetectionResult {
+    duplicates: Array<{
+        url1: string;
+        url2: string;
+        similarity: number;
+        type: 'exact' | 'near-duplicate';
+    }>;
+    potentialCannibalization: Array<{
+        pages: string[];
+        keyword: string;
+        similarity: number;
+    }>;
+}
+declare function extractContentHash(html: string, url: string): ContentHashData;
+declare function detectDuplicates(pages: ContentHashData[]): DuplicateDetectionResult;
+declare function generateDuplicateIssues(result: DuplicateDetectionResult, currentUrl: string): AuditIssue[];
+
+interface PaginationData {
+    hasPagination: boolean;
+    hasHtmlPaginationLinks: boolean;
+    hasInfiniteScroll: boolean;
+    hasLoadMoreButton: boolean;
+    paginationLinks: string[];
+    relNextPrev: {
+        hasNext: boolean;
+        hasPrev: boolean;
+        nextUrl?: string;
+        prevUrl?: string;
+    };
+    currentPage?: number;
+    totalPages?: number;
+}
+declare function analyzePagination(html: string, url: string, canonical?: string): {
+    issues: AuditIssue[];
+    data: PaginationData;
+};
+
+interface RedirectData {
+    hasRedirect: boolean;
+    redirectChain: RedirectHop$1[];
+    isLoop: boolean;
+    finalUrl?: string;
+    totalHops: number;
+}
+interface RedirectHop$1 {
+    url: string;
+    statusCode: number;
+    location?: string;
+}
+declare function analyzeRedirects(url: string, maxHops?: number): Promise<{
+    issues: AuditIssue[];
+    data: RedirectData;
+}>;
+declare function checkInternalRedirects(internalLinks: string[], batchSize?: number): Promise<{
+    redirectLinks: Array<{
+        source: string;
+        target: string;
+        statusCode: number;
+    }>;
+}>;
+
+interface LlmsTxtResult {
+    exists: boolean;
+    content?: string;
+    valid: boolean;
+    errors: string[];
+}
+interface AIBotBlockingResult {
+    robotsExists: boolean;
+    blockedBots: string[];
+    allowedBots: string[];
+    allBlocked: boolean;
+}
+interface AIReadinessData {
+    llmsTxt: LlmsTxtResult;
+    botBlocking: AIBotBlockingResult;
+    jsRenderingRatio: number;
+}
+/**
+ * Check for llms.txt file
+ * See: https://llmstxt.org/
+ */
+declare function checkLlmsTxt(baseUrl: string): Promise<{
+    issues: AuditIssue[];
+    data: LlmsTxtResult;
+}>;
+/**
+ * Check robots.txt for AI bot blocking
+ */
+declare function checkAIBotBlocking(baseUrl: string): Promise<{
+    issues: AuditIssue[];
+    data: AIBotBlockingResult;
+}>;
+/**
+ * Check JavaScript rendering ratio
+ * Compares static HTML content size vs rendered content
+ */
+declare function checkJSRenderingRatio(html: string, url: string): {
+    issues: AuditIssue[];
+    data: {
+        ratio: number;
+        staticWordCount: number;
+    };
+};
+/**
+ * Run all AI readiness checks
+ */
+declare function runAIReadinessChecks(baseUrl: string, html: string): Promise<{
+    issues: AuditIssue[];
+    data: AIReadinessData;
+}>;
+
+interface SERPPreviewData {
+    title: {
+        text: string;
+        charLength: number;
+        pixelWidth: number;
+        truncated: boolean;
+        displayText: string;
+    };
+    description: {
+        text: string;
+        charLength: number;
+        pixelWidthDesktop: number;
+        pixelWidthMobile: number;
+        truncatedDesktop: boolean;
+        truncatedMobile: boolean;
+        displayTextDesktop: string;
+        displayTextMobile: string;
+    };
+    url: {
+        display: string;
+        breadcrumbs: string[];
+    };
+    preview: {
+        desktop: string;
+        mobile: string;
+    };
+}
+/**
+ * Analyze SERP preview and generate pixel-based issues
+ */
+declare function analyzeSERPPreview(html: string, url: string): {
+    issues: AuditIssue[];
+    data: SERPPreviewData;
+};
+
+interface LocalSEOData {
+    hasLocalBusinessSchema: boolean;
+    hasOrganizationSchema: boolean;
+    detectedPhones: string[];
+    detectedAddresses: string[];
+    schemaData: {
+        name?: string;
+        address?: string;
+        phone?: string;
+        hours?: string[];
+        geo?: {
+            lat: number;
+            lng: number;
+        };
+    } | null;
+    socialProfiles: string[];
+}
+/**
+ * Analyze local SEO elements
+ */
+declare function analyzeLocalSEO(html: string, url: string): {
+    issues: AuditIssue[];
+    data: LocalSEOData;
+};
+
+interface SecurityHeadersData {
+    https: boolean;
+    headers: {
+        hsts: string | null;
+        csp: string | null;
+        xFrameOptions: string | null;
+        xContentTypeOptions: string | null;
+        referrerPolicy: string | null;
+        permissionsPolicy: string | null;
+    };
+    hstsMaxAge: number | null;
+    hstsIncludesSubdomains: boolean;
+    hstsPreload: boolean;
+}
+/**
+ * Analyze security headers
+ */
+declare function analyzeSecurityHeaders(url: string): Promise<{
+    issues: AuditIssue[];
+    data: SecurityHeadersData;
+}>;
+
+interface ContentFreshnessData {
+    lastModified: Date | null;
+    articleModifiedTime: Date | null;
+    articlePublishedTime: Date | null;
+    ogUpdatedTime: Date | null;
+    ageInDays: number | null;
+    isStale: boolean;
+    source: 'last-modified' | 'og-updated-time' | 'article-modified-time' | 'none';
+}
+/**
+ * Analyze content freshness
+ */
+declare function analyzeContentFreshness(url: string, html: string): Promise<{
+    issues: AuditIssue[];
+    data: ContentFreshnessData;
+}>;
+
+interface DOMAnalysisData {
+    nodeCount: number;
+    maxDepth: number;
+    renderBlockingResources: {
+        css: string[];
+        js: string[];
+    };
+    totalRenderBlockingSize: number;
+    criticalPathLength: number;
+}
+/**
+ * Analyze DOM structure and render-blocking resources
+ */
+declare function analyzeDOMStructure(html: string, url: string): {
+    issues: AuditIssue[];
+    data: DOMAnalysisData;
+};
+
+interface ImageInfo {
+    src: string;
+    alt: string | null;
+    width: number | null;
+    height: number | null;
+    loading: string | null;
+    format: string;
+    isModernFormat: boolean;
+    hasDimensions: boolean;
+    isLazyLoaded: boolean;
+}
+interface ModernImagesData {
+    totalImages: number;
+    modernFormatCount: number;
+    legacyFormatCount: number;
+    modernFormatPercentage: number;
+    images: ImageInfo[];
+    hasSourceSet: boolean;
+    hasPictureElements: boolean;
+}
+/**
+ * Analyze image formats and optimization
+ */
+declare function analyzeModernImages(html: string, url: string): {
+    issues: AuditIssue[];
+    data: ModernImagesData;
+};
+
+interface TechnologyInfo {
+    name: string;
+    version?: string;
+    category: 'cms' | 'framework' | 'library' | 'server' | 'analytics' | 'cdn' | 'other';
+    confidence: 'high' | 'medium' | 'low';
+}
+interface TechDetectionData {
+    technologies: TechnologyInfo[];
+    cms: string | null;
+    framework: string | null;
+    jsLibraries: string[];
+    analytics: string[];
+    cdn: string | null;
+    serverHeaders: Record<string, string>;
+}
+/**
+ * Detect technologies from HTML and headers
+ */
+declare function detectTechnologies(html: string, url: string, headers?: Record<string, string>): {
+    issues: AuditIssue[];
+    data: TechDetectionData;
+};
+
+interface KeywordInfo {
+    word: string;
+    count: number;
+    density: number;
+    inTitle: boolean;
+    inH1: boolean;
+    inH2: boolean;
+    inMetaDesc: boolean;
+}
+interface KeywordPhraseInfo {
+    phrase: string;
+    count: number;
+    wordCount: number;
+}
+interface KeywordAnalysisData {
+    totalWords: number;
+    uniqueWords: number;
+    topKeywords: KeywordInfo[];
+    topPhrases: {
+        twoWord: KeywordPhraseInfo[];
+        threeWord: KeywordPhraseInfo[];
+        fourWord: KeywordPhraseInfo[];
+    };
+    keywordDistribution: {
+        title: string[];
+        h1: string[];
+        h2: string[];
+        metaDesc: string[];
+    };
+    potentialStuffing: string[];
+}
+/**
+ * Analyze keyword density and distribution
+ */
+declare function analyzeKeywords(html: string, url: string): {
+    issues: AuditIssue[];
+    data: KeywordAnalysisData;
+};
+
+interface AdsTxtData {
+    exists: boolean;
+    valid: boolean;
+    entries: number;
+    errors: string[];
+}
+interface DMARCData {
+    exists: boolean;
+    policy: string | null;
+    record: string | null;
+}
+interface SPFData {
+    exists: boolean;
+    record: string | null;
+}
+interface AMPData {
+    hasAmpLink: boolean;
+    ampUrl: string | null;
+    ampValid: boolean | null;
+}
+interface AdditionalChecksData {
+    adsTxt: AdsTxtData;
+    dmarc: DMARCData;
+    spf: SPFData;
+    amp: AMPData;
+    plaintextEmails: string[];
+    hasAppleTouchIcon: boolean;
+    faviconFormat: string | null;
+}
+/**
+ * Check for ads.txt file
+ */
+declare function checkAdsTxt(baseUrl: string): Promise<{
+    issues: AuditIssue[];
+    data: AdsTxtData;
+}>;
+/**
+ * Check DMARC DNS record
+ */
+declare function checkDMARC(domain: string): Promise<{
+    issues: AuditIssue[];
+    data: DMARCData;
+}>;
+/**
+ * Check SPF DNS record
+ */
+declare function checkSPF(domain: string): Promise<{
+    issues: AuditIssue[];
+    data: SPFData;
+}>;
+/**
+ * Check for AMP version
+ */
+declare function checkAMP(html: string, url: string): {
+    issues: AuditIssue[];
+    data: AMPData;
+};
+/**
+ * Check for plaintext email addresses
+ */
+declare function checkPlaintextEmails(html: string, url: string): {
+    issues: AuditIssue[];
+    emails: string[];
+};
+/**
+ * Check for Apple Touch Icon
+ */
+declare function checkAppleTouchIcon(html: string, url: string): {
+    issues: AuditIssue[];
+    exists: boolean;
+};
+/**
+ * Run all additional checks
+ */
+declare function runAdditionalChecks(url: string, html: string): Promise<{
+    issues: AuditIssue[];
+    data: AdditionalChecksData;
+}>;
+
+interface TrackerInfo {
+    name: string;
+    type: 'analytics' | 'advertising' | 'social' | 'marketing' | 'heatmap' | 'chat' | 'other';
+    domain: string;
+    impact: 'high' | 'medium' | 'low';
+}
+interface DetectedTracker extends TrackerInfo {
+    scriptUrl?: string;
+    loadMethod: 'sync' | 'async' | 'defer' | 'inline';
+}
+interface TrackerAnalysis {
+    trackers: DetectedTracker[];
+    totalCount: number;
+    byType: Record<string, number>;
+    byImpact: Record<string, number>;
+    estimatedImpactScore: number;
+    recommendations: string[];
+}
+/**
+ * Main function: Analyze page for tracker bloat
+ */
+declare function analyzeTrackerBloat(html: string, url: string): {
+    issues: AuditIssue[];
+    data: TrackerAnalysis;
+};
+
+interface RenderingAnalysis {
+    renderingMethod: 'ssr' | 'ssg' | 'csr' | 'hybrid' | 'unknown';
+    confidence: 'high' | 'medium' | 'low';
+    signals: RenderingSignal[];
+    frameworkDetected: string | null;
+    hasContentInHTML: boolean;
+    hasHydrationMarkers: boolean;
+    hasClientOnlyIndicators: boolean;
+    mainContentCharCount: number;
+    recommendations: string[];
+    metaManagement: string | null;
+    hasDynamicMetaTags: boolean;
+    aiAccessibility: {
+        htmlContentRatio: number;
+        hasSemanticStructure: boolean;
+        keyContentInHTML: boolean;
+        aiReadableScore: number;
+    };
+}
+interface RenderingSignal {
+    indicator: string;
+    suggests: 'ssr' | 'ssg' | 'csr';
+    weight: number;
+}
+/**
+ * Main function: Analyze page rendering method for SEO
+ */
+declare function analyzeClientRendering(html: string, url: string): {
+    issues: AuditIssue[];
+    data: RenderingAnalysis;
+};
+
+interface RedirectHop {
+    url: string;
+    statusCode: number;
+    statusText: string;
+    redirectTo: string | null;
+    responseTime: number;
+}
+interface RedirectChainResult {
+    originalUrl: string;
+    finalUrl: string;
+    hops: RedirectHop[];
+    chainLength: number;
+    totalTime: number;
+    hasHttpsUpgrade: boolean;
+    hasWwwNormalization: boolean;
+    hasTrailingSlashIssue: boolean;
+    isInternalLoop: boolean;
+    issues: string[];
+}
+/**
+ * Main function: Analyze redirects for SEO issues
+ */
+declare function analyzeRedirectChain(url: string): Promise<{
+    issues: AuditIssue[];
+    data: RedirectChainResult;
+}>;
+
+interface ImageAnalysis {
+    src: string;
+    alt: string | null;
+    width: string | null;
+    height: string | null;
+    loading: 'lazy' | 'eager' | null;
+    decoding: 'async' | 'sync' | 'auto' | null;
+    srcset: string | null;
+    sizes: string | null;
+    isAboveFold: boolean;
+    hasExplicitDimensions: boolean;
+    hasResponsiveSrcset: boolean;
+    usesModernFormat: boolean;
+    issues: string[];
+}
+interface ResponsiveImageData {
+    totalImages: number;
+    imagesWithoutDimensions: number;
+    imagesWithoutLazyLoad: number;
+    imagesWithoutSrcset: number;
+    imagesWithoutAlt: number;
+    modernFormatCount: number;
+    legacyFormatCount: number;
+    images: ImageAnalysis[];
+    recommendations: string[];
+}
+/**
+ * Main function: Analyze responsive image best practices
+ */
+declare function analyzeResponsiveImages(html: string, url: string): {
+    issues: AuditIssue[];
+    data: ResponsiveImageData;
+};
+
+interface AboveFoldAnalysis {
+    hasHeadline: boolean;
+    headlineText: string | null;
+    hasCTA: boolean;
+    ctaCount: number;
+    ctaTexts: string[];
+    hasForm: boolean;
+    formType: 'contact' | 'signup' | 'search' | 'calculator' | 'other' | null;
+    hasSocialProof: boolean;
+    socialProofTypes: string[];
+    hasHeroImage: boolean;
+    hasVideo: boolean;
+    estimatedAboveFoldScore: number;
+}
+interface SocialProofAnalysis {
+    hasTestimonials: boolean;
+    testimonialCount: number;
+    hasReviews: boolean;
+    reviewCount: number;
+    hasRatings: boolean;
+    averageRating: number | null;
+    hasClientLogos: boolean;
+    clientLogoCount: number;
+    hasCaseStudies: boolean;
+    hasAwards: boolean;
+    hasCertifications: boolean;
+    hasTrustBadges: boolean;
+    hasStatistics: boolean;
+    statisticsFound: string[];
+    socialProofScore: number;
+}
+interface EngagementTriggers {
+    hasCalculator: boolean;
+    calculatorTypes: string[];
+    hasQuiz: boolean;
+    hasInteractiveElement: boolean;
+    interactiveTypes: string[];
+    hasEmbeddedVideo: boolean;
+    videoCount: number;
+    hasExpandableContent: boolean;
+    hasTabsOrAccordion: boolean;
+    hasChatWidget: boolean;
+    engagementScore: number;
+}
+interface ConversionElementsData {
+    aboveFold: AboveFoldAnalysis;
+    socialProof: SocialProofAnalysis;
+    engagementTriggers: EngagementTriggers;
+    pageType: 'commercial' | 'informational' | 'mixed' | 'unknown';
+    recommendations: string[];
+}
+/**
+ * Main function: Analyze conversion elements
+ */
+declare function analyzeConversionElements(html: string, url: string): {
+    issues: AuditIssue[];
+    data: ConversionElementsData;
+};
+
+interface KeywordPlacementData {
+    detectedKeywords: string[];
+    urlAnalysis: {
+        containsKeyword: boolean;
+        keywordInUrl: string | null;
+        urlSlug: string;
+        isCleanUrl: boolean;
+        hasDynamicParams: boolean;
+    };
+    titleAnalysis: {
+        hasExactMatch: boolean;
+        hasPartialMatch: boolean;
+        titleMatchScore: number;
+        position: 'start' | 'middle' | 'end' | 'none';
+    };
+    h1Analysis: {
+        hasExactMatch: boolean;
+        hasPartialMatch: boolean;
+        h1Text: string | null;
+    };
+    firstParagraphAnalysis: {
+        hasKeyword: boolean;
+        keywordPosition: number | null;
+        firstParagraphPreview: string;
+        isWithinFirst100Words: boolean;
+    };
+    metaDescriptionAnalysis: {
+        hasKeyword: boolean;
+        position: 'start' | 'middle' | 'end' | 'none';
+    };
+    overallPlacementScore: number;
+}
+/**
+ * Main function: Analyze keyword placement
+ */
+declare function analyzeKeywordPlacement(html: string, url: string): {
+    issues: AuditIssue[];
+    data: KeywordPlacementData;
+};
+
+interface InternalLink {
+    href: string;
+    anchorText: string;
+    context: 'navigation' | 'content' | 'footer' | 'sidebar';
+    isDoFollow: boolean;
+    destination: 'internal' | 'external' | 'anchor';
+}
+interface TopicalClusterData {
+    currentUrl: string;
+    internalLinks: InternalLink[];
+    externalLinks: InternalLink[];
+    anchorLinks: InternalLink[];
+    linkMetrics: {
+        totalLinks: number;
+        internalLinkCount: number;
+        externalLinkCount: number;
+        contentLinks: number;
+        uniqueInternalDestinations: number;
+        avgAnchorTextLength: number;
+        hasExactMatchAnchors: boolean;
+    };
+    clusterSignals: {
+        hasHubStructure: boolean;
+        hasSpokeLinks: boolean;
+        hasBreadcrumbs: boolean;
+        hasRelatedPosts: boolean;
+        hasCategoryLinks: boolean;
+        internalToExternalRatio: number;
+    };
+    orphanPageRisk: 'low' | 'medium' | 'high';
+    recommendations: string[];
+}
+/**
+ * Main function: Analyze topical cluster structure
+ */
+declare function analyzeTopicalClusters(html: string, url: string): {
+    issues: AuditIssue[];
+    data: TopicalClusterData;
+};
+
+interface PlatformLink {
+    platform: string;
+    url: string;
+    type: 'profile' | 'content' | 'mention' | 'embed';
+    location: 'header' | 'footer' | 'content' | 'sidebar' | 'schema';
+}
+interface PlatformPresenceData {
+    detectedPlatforms: string[];
+    platformLinks: PlatformLink[];
+    socialProfiles: {
+        platform: string;
+        url: string;
+        hasSchemaMarkup: boolean;
+    }[];
+    embeddedContent: {
+        platform: string;
+        count: number;
+    }[];
+    metrics: {
+        totalPlatforms: number;
+        hasYouTube: boolean;
+        hasTikTok: boolean;
+        hasTwitter: boolean;
+        hasLinkedIn: boolean;
+        hasReddit: boolean;
+        hasFacebook: boolean;
+        hasInstagram: boolean;
+        hasPinterest: boolean;
+        hasPodcast: boolean;
+        hasGitHub: boolean;
+    };
+    schemaPresence: {
+        hasSameAs: boolean;
+        sameAsUrls: string[];
+        hasOrganizationSchema: boolean;
+        hasPersonSchema: boolean;
+    };
+    crossPlatformScore: number;
+    recommendations: string[];
+}
+/**
+ * Main function: Analyze platform presence
+ */
+declare function analyzePlatformPresence(html: string, url: string): {
+    issues: AuditIssue[];
+    data: PlatformPresenceData;
+};
+
+interface InteractiveElement {
+    type: 'calculator' | 'quiz' | 'form' | 'widget' | 'embed' | 'tool' | 'interactive';
+    description: string;
+    location: string;
+    hasUserInput: boolean;
+}
+interface InteractiveToolsData {
+    hasInteractiveTools: boolean;
+    tools: InteractiveElement[];
+    dwellTimeSignals: {
+        hasCalculator: boolean;
+        hasQuiz: boolean;
+        hasInteractiveWidget: boolean;
+        hasVideoEmbed: boolean;
+        hasCodePlayground: boolean;
+        hasConfigurator: boolean;
+        hasChatWidget: boolean;
+    };
+    toolCount: number;
+    dwellTimeScore: number;
+    recommendations: string[];
+}
+/**
+ * Main function: Analyze interactive tools on the page
+ */
+declare function analyzeInteractiveTools(html: string, url: string): {
+    issues: AuditIssue[];
+    data: InteractiveToolsData;
+};
+
+type FunnelStage = 'tofu' | 'mofu' | 'bofu' | 'mixed';
+interface FunnelIntentData {
+    detectedStage: FunnelStage;
+    confidence: number;
+    signals: {
+        tofu: string[];
+        mofu: string[];
+        bofu: string[];
+    };
+    metrics: {
+        informationalScore: number;
+        considerationScore: number;
+        conversionScore: number;
+    };
+    pageType: string;
+    aiOverviewRisk: 'high' | 'medium' | 'low';
+    recommendations: string[];
+}
+/**
+ * Main function: Analyze search funnel intent
+ */
+declare function analyzeFunnelIntent(html: string, url: string): {
+    issues: AuditIssue[];
+    data: FunnelIntentData;
+};
+
+interface NavBoostSignalsData {
+    clickOptimization: {
+        hasClearTitle: boolean;
+        hasCompellingMetaDesc: boolean;
+        titleTruncated: boolean;
+        metaDescTruncated: boolean;
+        estimatedCTRPotential: 'high' | 'medium' | 'low';
+    };
+    engagementSignals: {
+        hasTableOfContents: boolean;
+        hasJumpLinks: boolean;
+        estimatedScrollDepth: 'deep' | 'medium' | 'shallow';
+        hasProgressIndicator: boolean;
+        hasStickyNavigation: boolean;
+        contentSections: number;
+    };
+    bounceRiskFactors: {
+        hasAboveFoldContent: boolean;
+        hasSlowLoadingIndicators: boolean;
+        hasPopupRisk: boolean;
+        hasIntrusiveAds: boolean;
+        contentMatchesTitle: boolean;
+        hasImmediateValue: boolean;
+    };
+    dwellTimeFactors: {
+        estimatedReadTime: number;
+        hasVideo: boolean;
+        hasInteractiveElements: boolean;
+        contentDepth: 'comprehensive' | 'moderate' | 'thin';
+        hasRelatedContent: boolean;
+    };
+    overallNavBoostScore: number;
+    recommendations: string[];
+}
+/**
+ * Main function: Analyze NavBoost optimization signals
+ */
+declare function analyzeNavBoostSignals(html: string, url: string): {
+    issues: AuditIssue[];
+    data: NavBoostSignalsData;
+};
+
+interface EntitySEOData {
+    entitySignals: {
+        hasOrganizationSchema: boolean;
+        hasPersonSchema: boolean;
+        hasProductSchema: boolean;
+        hasSameAsReferences: boolean;
+        sameAsUrls: string[];
+        hasMainEntityOfPage: boolean;
+        hasAboutReference: boolean;
+    };
+    entityClarity: {
+        primaryEntityType: string | null;
+        entityNameConsistency: boolean;
+        hasEntityDefinition: boolean;
+        hasWikipediaStyleIntro: boolean;
+        entityMentionCount: number;
+    };
+    topicalCoverage: {
+        hasRelatedEntities: boolean;
+        relatedEntityCount: number;
+        hasEntityRelationships: boolean;
+        topicalDepthScore: number;
+    };
+    knowledgePanelSignals: {
+        hasCompanyInfo: boolean;
+        hasFounderInfo: boolean;
+        hasHeadquarters: boolean;
+        hasIndustryMention: boolean;
+        hasDateFounded: boolean;
+    };
+    entitySEOScore: number;
+    recommendations: string[];
+}
+/**
+ * Main function: Analyze Entity SEO optimization
+ */
+declare function analyzeEntitySEO(html: string, url: string): {
+    issues: AuditIssue[];
+    data: EntitySEOData;
+};
+
+interface FreshnessSignalsData {
+    dateSignals: {
+        hasDatePublished: boolean;
+        hasDateModified: boolean;
+        hasSchemaDatePublished: boolean;
+        hasSchemaDateModified: boolean;
+        visibleDateOnPage: string | null;
+        schemaDatePublished: string | null;
+        schemaDateModified: string | null;
+        daysSincePublished: number | null;
+        daysSinceModified: number | null;
+    };
+    freshnessIndicators: {
+        hasCurrentYearMention: boolean;
+        hasRecentDateReferences: boolean;
+        hasUpdateNotice: boolean;
+        hasChangeLog: boolean;
+        hasVersionNumber: boolean;
+        contentFreshnessSignal: 'fresh' | 'dated' | 'evergreen' | 'unknown';
+    };
+    qdfRelevance: {
+        isLikelyQDFTopic: boolean;
+        qdfIndicators: string[];
+        updateFrequencyRecommendation: string;
+    };
+    aiCitationOptimization: {
+        hasLastUpdatedMeta: boolean;
+        hasClearDateFormat: boolean;
+        freshnessSchemaComplete: boolean;
+        aiCitationReadiness: 'high' | 'medium' | 'low';
+    };
+    freshnessScore: number;
+    recommendations: string[];
+}
+/**
+ * Main function: Analyze freshness signals
+ */
+declare function analyzeFreshnessSignals(html: string, url: string): {
+    issues: AuditIssue[];
+    data: FreshnessSignalsData;
+};
+
+/**
+ * URL Safety Check (Local Hash Database)
+ *
+ * Implements a Google Safe Browsing-style architecture:
+ * 1. Maintains a local database of hash prefixes
+ * 2. All URL checks happen locally against the hash database
+ * 3. Database can be updated from open threat feeds (URLhaus, etc.)
+ * 4. No external API calls during audit - fully offline capable
+ *
+ * Hash Database Format:
+ * - URLs are canonicalized and hashed with FNV-1a
+ * - 8-character hex prefixes are stored for space efficiency
+ * - Prefixes are stored in a Set for O(1) lookup
+ *
+ * Data Sources for updates:
+ * - URLhaus (abuse.ch) - https://urlhaus.abuse.ch/downloads/csv/
+ * - PhishTank - https://data.phishtank.com/
+ * - OpenPhish - https://openphish.com/
+ */
+
+interface UrlSafetyData {
+    checkedUrls: number;
+    matchedUrls: UrlMatch[];
+    databaseInfo: {
+        prefixCount: number;
+        lastUpdated?: string;
+        sources: string[];
+    };
+    patternMatches: PatternMatch[];
+}
+interface UrlMatch {
+    url: string;
+    hashPrefix: string;
+    matchType: 'exact' | 'domain' | 'pattern';
+    threatType?: string;
+}
+interface PatternMatch {
+    url: string;
+    reasons: string[];
+    riskLevel: 'low' | 'medium' | 'high';
+}
+/**
+ * Analyze URL safety using local hash database and pattern matching
+ *
+ * This function performs two types of checks:
+ * 1. Hash-based lookup against the local threat database
+ * 2. Pattern-based detection for suspicious URL characteristics
+ *
+ * No external API calls are made - all checks are local.
+ */
+declare function analyzeUrlSafety(url: string, externalLinks?: string[]): {
+    issues: AuditIssue[];
+    data: UrlSafetyData;
+};
+/**
+ * Export the threat database for external updates
+ */
+declare const urlSafetyDatabase: {
+    /**
+     * Load URLs from URLhaus CSV format
+     */
+    loadFromUrlhausCsv: (csv: string) => number;
+    /**
+     * Add URLs to the blocklist
+     */
+    addUrls: (urls: string[]) => number;
+    /**
+     * Add domains to the blocklist
+     */
+    addDomains: (domains: string[]) => number;
+    /**
+     * Bulk load hash prefixes (for Supabase integration)
+     * Call this with data from: SELECT hash_prefix, hash_type FROM threat_hashes WHERE is_active = TRUE
+     */
+    loadHashPrefixes: (hashes: Array<{
+        hash_prefix: string;
+        hash_type: "url" | "domain";
+    }>) => number;
+    /**
+     * Clear all hashes (useful before reloading from fresh data)
+     */
+    clear: () => void;
+    /**
+     * Check if database has been populated with threat data
+     */
+    isPopulated: () => boolean;
+    /**
+     * Get database statistics
+     */
+    getStats: () => {
+        prefixCount: number;
+        lastUpdated: string;
+        sources: string[];
+    };
+};
+
+/**
+ * Link Crawler Module
+ *
+ * Discovers pages from a website by following internal links from the homepage.
+ * Prioritizes important pages like /pricing, /about, /features, etc.
+ */
+interface DiscoveredPage {
+    url: string;
+    source: 'homepage' | 'sitemap' | 'internal-link';
+    priority: number;
+}
+/**
+ * Discover pages from HTML content
+ *
+ * @param baseUrl - The base URL of the site
+ * @param html - The HTML content of the homepage
+ * @param maxPages - Maximum number of pages to return
+ * @returns Array of discovered pages sorted by priority
+ */
+declare function discoverPagesFromLinks(baseUrl: string, html: string, maxPages?: number): DiscoveredPage[];
+/**
+ * Parse sitemap XML to extract URLs
+ */
+declare function parseSitemap(xml: string, baseUrl: string): DiscoveredPage[];
+/**
+ * Merge pages from multiple sources, deduplicating by URL
+ */
+declare function mergePages(...pageSets: DiscoveredPage[][]): DiscoveredPage[];
+
+/**
+ * Route Discovery Module
+ *
+ * Discovers routes from repository files based on framework-specific patterns.
+ * Supports: Next.js (App/Pages), Astro, React Router, Vue Router, SvelteKit
+ */
+interface RouteInfo {
+    path: string;
+    type: 'static' | 'dynamic';
+    sourceFile: string;
+}
+type Framework$2 = 'nextjs' | 'astro' | 'react' | 'react-vite' | 'vue' | 'sveltekit' | 'unknown';
+/**
+ * Discover routes based on framework
+ */
+declare function discoverRoutesFromRepo(files: string[], framework: Framework$2, fetchFile: (path: string) => Promise<string | null>): Promise<RouteInfo[]>;
+/**
+ * Convert static routes to full URLs
+ */
+declare function routesToUrls(routes: RouteInfo[], baseUrl: string, maxUrls?: number): string[];
+
+/**
+ * Social Meta Tag Fix Generator
+ *
+ * Generates code fixes for missing Twitter Cards, Open Graph tags, and other social meta.
+ * Supports multiple frameworks: HTML, React, Next.js, Astro, Remix, SvelteKit.
+ */
+
+interface SocialMetaFix {
+    issueCode: string;
+    filePath: string;
+    framework: string;
+    before?: string;
+    after: string;
+    explanation: string;
+}
+interface SocialMetaConfig {
+    title: string;
+    description: string;
+    image: string;
+    url: string;
+    siteName?: string;
+    twitterSite?: string;
+    twitterCreator?: string;
+    type?: 'website' | 'article' | 'product';
+    locale?: string;
+}
+type Framework$1 = 'html' | 'react' | 'nextjs-app' | 'nextjs-pages' | 'astro' | 'remix' | 'sveltekit' | 'vite-react';
+/**
+ * Generates complete social meta tags for HTML
+ */
+declare function generateHTMLSocialMeta(config: SocialMetaConfig): string;
+/**
+ * Generates React Helmet / react-helmet-async component
+ */
+declare function generateReactHelmetSocialMeta(config: SocialMetaConfig): string;
+/**
+ * Generates Next.js App Router metadata export
+ */
+declare function generateNextAppMetadata(config: SocialMetaConfig): string;
+/**
+ * Generates Next.js Pages Router Head component
+ */
+declare function generateNextPagesHead(config: SocialMetaConfig): string;
+/**
+ * Generates Astro frontmatter and BaseHead usage
+ */
+declare function generateAstroMeta(config: SocialMetaConfig): string;
+/**
+ * Generates Remix meta function
+ */
+declare function generateRemixMeta(config: SocialMetaConfig): string;
+/**
+ * Generates SvelteKit +page.ts and svelte:head usage
+ */
+declare function generateSvelteKitMeta(config: SocialMetaConfig): string;
+/**
+ * Generates fix for a specific missing social meta tag
+ */
+declare function generateSocialMetaFix(issueCode: string, framework: Framework$1, existingData: SocialMetaData, pageData: {
+    title?: string;
+    description?: string;
+    url: string;
+}): SocialMetaFix;
+/**
+ * Generates complete social meta setup for a project
+ */
+declare function generateCompleteSocialMetaSetup(framework: Framework$1, config: SocialMetaConfig): {
+    filePath: string;
+    content: string;
+    explanation: string;
+};
+/**
+ * OG Image recommendations based on platform requirements
+ */
+declare const OG_IMAGE_SPECS: {
+    recommended: {
+        width: number;
+        height: number;
+        aspectRatio: string;
+        format: string[];
+        maxSize: string;
+    };
+    twitter: {
+        summary: {
+            width: number;
+            height: number;
+        };
+        summary_large_image: {
+            width: number;
+            height: number;
+        };
+    };
+    facebook: {
+        minimum: {
+            width: number;
+            height: number;
+        };
+        recommended: {
+            width: number;
+            height: number;
+        };
+    };
+    linkedin: {
+        recommended: {
+            width: number;
+            height: number;
+        };
+    };
+};
+
+/**
+ * Fix generators for SEO issues
+ *
+ * These modules generate framework-specific code to fix SEO issues
+ * detected during audits.
+ */
+
+interface FixFile {
+    path: string;
+    content: string;
+}
+interface FixResult {
+    category: string;
+    issues: string[];
+    files: FixFile[];
+}
+/**
+ * Generates all fixes for issues found in an audit report
+ */
+declare function generateAllFixes(report: AuditReport): FixResult[];
+
+/**
+ * Audit Runner
+ *
+ * High-level API for running SEO audits with automatic fix generation
+ * and PR creation. Orchestrates the audit engine, fix generators, and
+ * git helpers.
+ */
+
+interface AuditRunnerOptions extends Partial<AuditOptions> {
+    url: string;
+    generateFixes?: boolean;
+    previousScore?: number;
+}
+interface AuditRunnerResult {
+    report: AuditReport;
+    fixes: FixResult[];
+    score: number;
+    previousScore?: number;
+}
+interface CreateAuditPROptions {
+    baseBranch: string;
+    headBranch: string;
+    dryRun?: boolean;
+    reviewers?: string[];
+    assignees?: string[];
+    draft?: boolean;
+}
+interface AuditPRResult {
+    success: boolean;
+    prUrl?: string;
+    prNumber?: number;
+    error?: string;
+    dryRun?: boolean;
+}
+/**
+ * Runs a full SEO audit and generates fixes for identified issues
+ */
+declare function runAuditWithFixes(options: AuditRunnerOptions): Promise<AuditRunnerResult>;
+/**
+ * Creates a pull request with audit fixes
+ */
+declare function createAuditPR(result: AuditRunnerResult, options: CreateAuditPROptions): Promise<AuditPRResult>;
+
+interface SiteProfile {
+    domain: string;
+    domainAge: 'new' | 'established' | 'authority';
+    backlinkCount: 'none' | 'few' | 'some' | 'many';
+    businessGoal: 'signups' | 'purchases' | 'leads' | 'awareness';
+    contentCapacity: 'low' | 'medium' | 'high';
+    targetGeo: string;
+}
+interface KeywordData {
+    keyword: string;
+    searchVolume: number;
+    keywordDifficulty: number;
+    cpc?: number;
+    trafficPotential?: number;
+    intent?: 'informational' | 'commercial' | 'transactional' | 'navigational';
+    trend?: 'up' | 'down' | 'stable';
+    source: 'gsc' | 'dataforseo' | 'autocomplete' | 'manual' | 'competitor';
+}
+interface KeywordOpportunity$1 extends KeywordData {
+    priorityScore: number;
+    category: 'quick-win' | 'medium-term' | 'long-term';
+    suggestedAction: KeywordAction;
+    currentRanking?: number;
+    impressions?: number;
+    clicks?: number;
+    ctr?: number;
+}
+interface KeywordAction {
+    type: 'add-to-title' | 'add-to-h1' | 'add-to-meta' | 'create-content' | 'optimize-existing';
+    description: string;
+    targetElement?: string;
+    currentValue?: string;
+    suggestedValue?: string;
+    file?: string;
+    line?: number;
+}
+interface KeywordResearchResult {
+    siteProfile: SiteProfile;
+    keywords: KeywordOpportunity$1[];
+    quickWins: KeywordOpportunity$1[];
+    mediumTerm: KeywordOpportunity$1[];
+    longTerm: KeywordOpportunity$1[];
+    recommendations: string[];
+    maxKdThreshold: number;
+}
+interface GSCQueryData {
+    query: string;
+    clicks: number;
+    impressions: number;
+    ctr: number;
+    position: number;
+}
+declare const SITE_PROFILE_QUESTIONS: readonly [{
+    readonly id: "domainAge";
+    readonly question: "How old is your domain?";
+    readonly options: readonly [{
+        readonly value: "new";
+        readonly label: "New (< 6 months)";
+        readonly description: "Just started, building from scratch";
+    }, {
+        readonly value: "established";
+        readonly label: "Established (6 months - 2 years)";
+        readonly description: "Has some history and content";
+    }, {
+        readonly value: "authority";
+        readonly label: "Authority (2+ years)";
+        readonly description: "Well-established with backlinks";
+    }];
+    readonly impact: "Determines the maximum keyword difficulty you should target";
+}, {
+    readonly id: "backlinkCount";
+    readonly question: "How many backlinks does your site have?";
+    readonly options: readonly [{
+        readonly value: "none";
+        readonly label: "None or very few (0-10)";
+        readonly description: "Just starting link building";
+    }, {
+        readonly value: "few";
+        readonly label: "Some (10-50)";
+        readonly description: "A few quality backlinks";
+    }, {
+        readonly value: "some";
+        readonly label: "Moderate (50-200)";
+        readonly description: "Decent backlink profile";
+    }, {
+        readonly value: "many";
+        readonly label: "Many (200+)";
+        readonly description: "Strong backlink profile";
+    }];
+    readonly impact: "Affects your ability to rank for competitive keywords";
+}, {
+    readonly id: "businessGoal";
+    readonly question: "What is your primary business goal?";
+    readonly options: readonly [{
+        readonly value: "signups";
+        readonly label: "Get signups/registrations";
+        readonly description: "SaaS, apps, newsletters";
+    }, {
+        readonly value: "purchases";
+        readonly label: "Generate purchases";
+        readonly description: "E-commerce, products";
+    }, {
+        readonly value: "leads";
+        readonly label: "Capture leads";
+        readonly description: "B2B, services, consulting";
+    }, {
+        readonly value: "awareness";
+        readonly label: "Build brand awareness";
+        readonly description: "Content, community, thought leadership";
+    }];
+    readonly impact: "Weights commercial vs informational keywords";
+}, {
+    readonly id: "contentCapacity";
+    readonly question: "How much content can you produce monthly?";
+    readonly options: readonly [{
+        readonly value: "low";
+        readonly label: "1-2 pages/month";
+        readonly description: "Limited time or resources";
+    }, {
+        readonly value: "medium";
+        readonly label: "3-5 pages/month";
+        readonly description: "Moderate content output";
+    }, {
+        readonly value: "high";
+        readonly label: "5+ pages/month";
+        readonly description: "Dedicated content team";
+    }];
+    readonly impact: "Determines how many keywords to suggest";
+}, {
+    readonly id: "targetGeo";
+    readonly question: "Where are your target customers?";
+    readonly options: readonly [{
+        readonly value: "us";
+        readonly label: "United States";
+        readonly description: "Primary US audience";
+    }, {
+        readonly value: "uk";
+        readonly label: "United Kingdom";
+        readonly description: "Primary UK audience";
+    }, {
+        readonly value: "global";
+        readonly label: "Global";
+        readonly description: "Worldwide audience";
+    }, {
+        readonly value: "other";
+        readonly label: "Other";
+        readonly description: "Specific country or region";
+    }];
+    readonly impact: "Determines which search volume data to use";
+}];
+declare function getMaxKdThreshold(profile: SiteProfile): number;
+declare const PRIORITY_WEIGHTS: {
+    businessValue: number;
+    difficulty: number;
+    trafficPotential: number;
+};
+
+interface DataForSEOCredentials {
+    login: string;
+    password: string;
+}
+declare function getKeywordData(keywords: string[], credentials: DataForSEOCredentials, location?: number): Promise<KeywordData[]>;
+declare function getKeywordSuggestions(seedKeyword: string, credentials: DataForSEOCredentials, location?: number, limit?: number): Promise<KeywordData[]>;
+declare function getRelatedKeywords(seedKeyword: string, credentials: DataForSEOCredentials, location?: number, limit?: number): Promise<KeywordData[]>;
+declare const LOCATION_CODES: {
+    US: number;
+    UK: number;
+    CA: number;
+    AU: number;
+    DE: number;
+    FR: number;
+    ES: number;
+    IT: number;
+    BR: number;
+    IN: number;
+    JP: number;
+};
+declare function checkBalance(credentials: DataForSEOCredentials): Promise<number>;
+
+interface KeywordResearchOptions {
+    seedKeywords: string[];
+    siteProfile: SiteProfile;
+    url?: string;
+    dataForSEOCredentials?: DataForSEOCredentials;
+    maxKeywords?: number;
+}
+interface PageMeta {
+    title?: string;
+    description?: string;
+    h1?: string;
+    url: string;
+}
+declare function runKeywordResearch(options: KeywordResearchOptions): Promise<KeywordResearchResult>;
+declare function formatKeywordReport(result: KeywordResearchResult): string;
+declare function extractSeedKeywords(url: string): Promise<string[]>;
+
+/**
+ * Site Crawler for Keyword Research
+ *
+ * Crawls an entire site to collect text content for AI analysis.
+ * Used to understand what the site does and generate relevant keywords.
+ */
+interface CrawledPage {
+    url: string;
+    title: string;
+    description: string;
+    h1: string;
+    h2s: string[];
+    mainContent: string;
+    wordCount: number;
+    internalLinks: string[];
+    isProductPage: boolean;
+    isPricingPage: boolean;
+    isBlogPost: boolean;
+    isFeaturePage: boolean;
+}
+interface SiteCrawlResult {
+    domain: string;
+    pages: CrawledPage[];
+    aggregatedContent: string;
+    totalWordCount: number;
+    uniqueHeadings: string[];
+    detectedPageTypes: {
+        product: number;
+        pricing: number;
+        blog: number;
+        feature: number;
+        other: number;
+    };
+    crawlStats: {
+        attempted: number;
+        succeeded: number;
+        failed: number;
+        duration: number;
+    };
+}
+/**
+ * Crawl an entire site to collect text content
+ */
+declare function crawlSite(startUrl: string, options?: {
+    maxPages?: number;
+    maxDepth?: number;
+    timeout?: number;
+}): Promise<SiteCrawlResult>;
+/**
+ * Extract key phrases from crawled content
+ */
+declare function extractKeyPhrases(crawlResult: SiteCrawlResult): string[];
+
+/**
+ * AI-Powered Site Summarizer
+ *
+ * Uses OpenAI to understand what a site does from crawled content.
+ * Extracts: product, audience, features, industry, positioning.
+ */
+
+interface SiteSummary {
+    /** Primary product/service name */
+    productName: string;
+    /** What the product does (1-2 sentences) */
+    productDescription: string;
+    /** Target audience description */
+    targetAudience: string;
+    /** Key features/benefits (3-7 items) */
+    keyFeatures: string[];
+    /** Industry/category */
+    industry: string;
+    /** Business model */
+    businessModel: 'saas' | 'ecommerce' | 'marketplace' | 'agency' | 'media' | 'other';
+    /** Unique value proposition */
+    valueProposition: string;
+    /** Niche focus (if specific segment) */
+    nicheFocus?: string;
+    /** Pricing tier detected */
+    pricingTier?: 'free' | 'freemium' | 'paid' | 'enterprise' | 'unknown';
+    /** Geographic focus */
+    geographicFocus?: string;
+    /** Primary use cases */
+    useCases: string[];
+    /** Problems solved */
+    problemsSolved: string[];
+    /** Seed keyword suggestions */
+    suggestedSeedKeywords: string[];
+    /** Confidence score (0-1) */
+    confidence: number;
+    /** What we're uncertain about */
+    uncertainties: string[];
+}
+interface SummarizerOptions {
+    openaiApiKey: string;
+    model?: string;
+    maxTokens?: number;
+}
+/**
+ * Summarize a site using AI
+ */
+declare function summarizeSite(crawlResult: SiteCrawlResult, options: SummarizerOptions): Promise<SiteSummary>;
+/**
+ * Create a basic summary without AI (fallback)
+ */
+declare function createFallbackSummary(crawlResult: SiteCrawlResult): SiteSummary;
+/**
+ * Enhance summary with competitive context
+ */
+declare function enhanceSummaryWithCompetitors(summary: SiteSummary, competitors: string[], options: SummarizerOptions): Promise<SiteSummary & {
+    competitivePositioning: string;
+}>;
+/**
+ * Generate questions to reduce uncertainty
+ */
+declare function generateUncertaintyQuestions(summary: SiteSummary): Array<{
+    id: string;
+    question: string;
+    category: string;
+    impact: number;
+    options?: string[];
+}>;
+
+/**
+ * Advanced NLP Analysis for Keyword Research
+ *
+ * Uses data science techniques:
+ * - TF-IDF for keyword extraction
+ * - N-gram analysis for phrase detection
+ * - BM25 scoring for relevance
+ * - Keyword clustering using cosine similarity
+ * - Embedding-based semantic grouping (OpenAI)
+ * - Topic modeling (LDA-inspired)
+ */
+
+interface TFIDFResult {
+    term: string;
+    tf: number;
+    idf: number;
+    tfidf: number;
+    documentFrequency: number;
+}
+interface NGram {
+    phrase: string;
+    frequency: number;
+    words: number;
+}
+interface KeywordCluster {
+    id: number;
+    name: string;
+    keywords: string[];
+    centroid?: number[];
+    coherenceScore: number;
+}
+interface TopicModel {
+    topics: Array<{
+        id: number;
+        name: string;
+        keywords: string[];
+        weight: number;
+    }>;
+    documentTopicDistribution: Array<{
+        documentId: number;
+        topicWeights: number[];
+    }>;
+}
+interface NLPAnalysisResult {
+    tfidfKeywords: TFIDFResult[];
+    ngrams: {
+        unigrams: NGram[];
+        bigrams: NGram[];
+        trigrams: NGram[];
+    };
+    clusters: KeywordCluster[];
+    topics: TopicModel;
+    entityPhrases: string[];
+    semanticGroups: Array<{
+        theme: string;
+        keywords: string[];
+    }>;
+}
+/**
+ * Tokenize text into words
+ */
+declare function tokenize(text: string): string[];
+/**
+ * Calculate TF-IDF for a corpus
+ */
+declare function calculateTFIDF$1(documents: string[]): TFIDFResult[];
+/**
+ * Extract N-grams from text
+ */
+declare function extractNgrams(text: string, n: number, minFrequency?: number): NGram[];
+/**
+ * BM25 scoring for keyword relevance
+ * BM25 is a bag-of-words retrieval function that ranks documents by relevance
+ */
+declare function calculateBM25(documents: string[], query: string, k1?: number, b?: number): Array<{
+    docIndex: number;
+    score: number;
+}>;
+/**
+ * Cluster keywords using embeddings
+ */
+declare function clusterKeywordsByEmbedding(keywords: string[], openai: OpenAI, numClusters?: number): Promise<KeywordCluster[]>;
+/**
+ * Extract entity-like phrases (capitalized sequences, proper nouns)
+ */
+declare function extractEntityPhrases(text: string): string[];
+/**
+ * Simplified LDA-inspired topic modeling
+ * Groups keywords by co-occurrence patterns
+ */
+declare function extractTopics(documents: string[], numTopics?: number): TopicModel;
+/**
+ * Run full NLP analysis on content
+ */
+declare function runNLPAnalysis(content: string | string[], options?: {
+    openaiApiKey?: string;
+    numClusters?: number;
+    numTopics?: number;
+}): Promise<NLPAnalysisResult>;
+
+/**
+ * AI-Powered Keyword Research Engine
+ *
+ * Tiered access:
+ * - FREE: Basic keyword extraction + score teaser
+ * - PAID: Full NLP, clustering, embeddings, competitive analysis
+ *
+ * Based on Bhanu's "Engineering as Marketing" strategy:
+ * 1. Find low KD keywords (< 10)
+ * 2. High volume (1000+)
+ * 3. Relevant to product
+ * 4. Easy to build free tools for
+ */
+
+type PlanTier = 'free' | 'solo' | 'pro' | 'agency';
+interface AIKeywordResearchOptions {
+    url: string;
+    tier: PlanTier;
+    openaiApiKey?: string;
+    maxPages?: number;
+    userContext?: {
+        productDescription?: string;
+        targetAudience?: string;
+        competitors?: string[];
+        mainProblem?: string;
+        differentiator?: string;
+    };
+    wizardResponses?: Array<{
+        id: string;
+        answer: string;
+    }>;
+    ciMode?: boolean;
+    /** API keys for competitive search (optional but recommended) */
+    competitiveSearchKeys?: {
+        braveApiKey?: string;
+        serperApiKey?: string;
+        githubToken?: string;
+    };
+    /** Enable enhanced tool ideas with LLM judge (default: true for paid tiers) */
+    enableEnhancedToolIdeas?: boolean;
+}
+interface FreeKeywordResult {
+    tier: 'free';
+    /** Basic keyword suggestions (limited) */
+    keywords: Array<{
+        keyword: string;
+        estimatedVolume: 'low' | 'medium' | 'high';
+        estimatedDifficulty: 'low' | 'medium' | 'high';
+        relevance: number;
+    }>;
+    /** Overall keyword opportunity score (teaser) */
+    opportunityScore: number;
+    /** Teaser message */
+    teaserMessage: string;
+    /** What they'd get with upgrade */
+    upgradeFeatures: string[];
+    /** Basic site understanding */
+    siteCategory: string;
+    /** Detected keywords count */
+    totalKeywordsFound: number;
+}
+interface PaidKeywordResult {
+    tier: PlanTier;
+    /** Site summary from AI */
+    siteSummary: SiteSummary;
+    /** Full keyword opportunities */
+    opportunities: KeywordOpportunity[];
+    /** NLP analysis results */
+    nlpAnalysis: NLPAnalysisResult;
+    /** Keyword clusters */
+    clusters: Array<{
+        name: string;
+        keywords: string[];
+        totalVolume: number;
+        avgDifficulty: number;
+    }>;
+    /** Recommended free tools to build */
+    freeToolIdeas: FreeToolIdea[];
+    /** Competitive positioning */
+    competitiveInsights?: CompetitiveInsight[];
+    /** Uncertainty assessment */
+    uncertainty: UncertaintyAssessment;
+    /** Prioritized recommendations */
+    recommendations: KeywordRecommendation[];
+}
+interface KeywordOpportunity {
+    keyword: string;
+    volume: number;
+    difficulty: number;
+    relevance: number;
+    opportunityScore: number;
+    intent: 'informational' | 'commercial' | 'transactional' | 'navigational';
+    suggestedContentType: 'free-tool' | 'landing-page' | 'blog-post' | 'comparison' | 'guide';
+    suggestedCTA: string;
+    rationale: string;
+    cluster?: string;
+}
+interface FreeToolIdea {
+    keyword: string;
+    toolName: string;
+    toolDescription: string;
+    estimatedEffort: 'low' | 'medium' | 'high';
+    ctaConnection: string;
+    volume: number;
+    difficulty: number;
+    priority: number;
+    /** Enhanced fields from LLM judge */
+    inputFormat?: string;
+    outputFormat?: string;
+    productTieIn?: string;
+    ctaText?: string;
+    deepLinkPattern?: string;
+    competitors?: {
+        hasFreeAlternative: boolean;
+        topCompetitor?: string;
+        ourAdvantage: string;
+    };
+    implementationHints?: {
+        suggestedLibraries: string[];
+        estimatedComplexity: 'trivial' | 'simple' | 'moderate' | 'complex';
+        canUseExistingOSS: boolean;
+        ossLibrary?: string;
+    };
+    feasibilityScore?: {
+        feasibility: number;
+        specificity: number;
+        productFit: number;
+        marketOpportunity: number;
+        overallScore: number;
+        passes: boolean;
+        reasoning: string;
+    };
+}
+interface CompetitiveInsight {
+    competitor: string;
+    theirFocus: 'broad' | 'niche';
+    ourAdvantage?: string;
+    keywordsTheyRankFor: string[];
+    keywordsWeCanTarget: string[];
+}
+interface UncertaintyAssessment {
+    overallConfidence: number;
+    siteUnderstanding: number;
+    audienceClarity: number;
+    competitiveClarity: number;
+    canAutomate: boolean;
+    questionsToAsk: Array<{
+        id: string;
+        question: string;
+        impact: number;
+        options?: string[];
+    }>;
+    explanation: string;
+}
+interface KeywordRecommendation {
+    priority: number;
+    keyword: string;
+    action: 'build-tool' | 'create-page' | 'write-content' | 'skip' | 'needs-input';
+    effort: 'low' | 'medium' | 'high';
+    impact: 'low' | 'medium' | 'high';
+    rationale: string;
+}
+/**
+ * Run keyword research based on tier
+ */
+declare function runAIKeywordResearch(options: AIKeywordResearchOptions): Promise<FreeKeywordResult | PaidKeywordResult>;
+
+/**
+ * Keyword Research Wizard
+ *
+ * Interactive wizard to reduce uncertainty in keyword research.
+ * Works with CLI (inquirer-style) and Web (JSON responses).
+ */
+
+interface WizardQuestion {
+    id: string;
+    question: string;
+    description?: string;
+    type: 'select' | 'multi-select' | 'text' | 'confirm';
+    options?: Array<{
+        value: string;
+        label: string;
+        description?: string;
+    }>;
+    required: boolean;
+    impactOnConfidence: number;
+    category: 'product' | 'audience' | 'competition' | 'goals' | 'constraints';
+}
+interface WizardResponse {
+    questionId: string;
+    answer: string | string[];
+    confidence: 'certain' | 'somewhat' | 'unsure';
+}
+interface WizardSession {
+    sessionId: string;
+    url: string;
+    siteSummary: SiteSummary;
+    questions: WizardQuestion[];
+    responses: WizardResponse[];
+    currentQuestionIndex: number;
+    isComplete: boolean;
+    finalConfidence: number;
+}
+interface WizardResult {
+    session: WizardSession;
+    canProceed: boolean;
+    message: string;
+    nextSteps: string[];
+}
+/**
+ * Start a new wizard session
+ */
+declare function startWizardSession(url: string, options?: {
+    openaiApiKey?: string;
+    existingResponses?: WizardResponse[];
+}): Promise<WizardSession>;
+/**
+ * Generate wizard questions based on site summary uncertainty
+ */
+declare function generateWizardQuestions(summary: SiteSummary): WizardQuestion[];
+/**
+ * Process a wizard response and update session
+ */
+declare function processWizardResponse(session: WizardSession, response: WizardResponse): WizardSession;
+/**
+ * Get the next question in the wizard
+ */
+declare function getNextQuestion(session: WizardSession): WizardQuestion | null;
+/**
+ * Complete the wizard and get result
+ */
+declare function completeWizard(session: WizardSession): WizardResult;
+/**
+ * Convert wizard responses to keyword research context
+ */
+declare function wizardResponsesToContext(session: WizardSession): {
+    productDescription?: string;
+    targetAudience?: string;
+    competitors?: string[];
+    mainProblem?: string;
+    differentiator?: string;
+    businessGoal?: string;
+    contentCapacity?: string;
+    domainAuthority?: string;
+};
+/**
+ * Format wizard session for CLI output
+ */
+declare function formatWizardProgress(session: WizardSession): string;
+
+/**
+ * CI Mode for Keyword Research
+ *
+ * Handles automated keyword research in CI/CD pipelines.
+ * - If confidence is high enough, adds keywords to PR
+ * - If uncertainty is high, skips and warns user
+ * - Provides clear instructions for what to do next
+ */
+
+interface CIKeywordOptions {
+    url: string;
+    tier: PlanTier;
+    openaiApiKey?: string;
+    /** Minimum confidence to proceed (default: 0.7) */
+    minConfidence?: number;
+    /** Maximum keywords to include in PR */
+    maxKeywords?: number;
+    /** Branch name for context */
+    branchName?: string;
+    /** PR number if applicable */
+    prNumber?: number;
+    /** Site ID for dashboard link */
+    siteId?: string;
+}
+interface CIKeywordResult {
+    /** Whether keywords can be added to the PR */
+    canAddToPR: boolean;
+    /** Keywords to add (if canAddToPR is true) */
+    keywords: KeywordRecommendation[];
+    /** Warning messages to display */
+    warnings: string[];
+    /** Error messages (if any) */
+    errors: string[];
+    /** Info messages */
+    info: string[];
+    /** Actions user needs to take */
+    requiredActions: CIAction[];
+    /** PR comment body */
+    prCommentBody: string;
+    /** Exit code (0 = success, 1 = needs action, 2 = error) */
+    exitCode: 0 | 1 | 2;
+    /** Detailed explanation */
+    explanation: string;
+    /** Raw result for debugging */
+    rawResult?: PaidKeywordResult | FreeKeywordResult;
+}
+interface CIAction {
+    title: string;
+    description: string;
+    command?: string;
+    webUrl?: string;
+    priority: 'high' | 'medium' | 'low';
+}
+/**
+ * Run keyword research in CI mode
+ */
+declare function runCIKeywordResearch(options: CIKeywordOptions): Promise<CIKeywordResult>;
+/**
+ * Format CI result for console output
+ */
+declare function formatCIResult(result: CIKeywordResult): string;
+
+declare function prioritizeKeywords(keywords: KeywordData[], siteProfile: SiteProfile, existingMeta?: {
+    title?: string;
+    description?: string;
+    h1?: string;
+}): KeywordResearchResult;
+
+interface AutocompleteOptions {
+    language?: string;
+    country?: string;
+}
+declare function getAutocompleteSuggestions(seedKeyword: string, options?: AutocompleteOptions): Promise<KeywordData[]>;
+declare function getExpandedSuggestions(seedKeyword: string, options?: AutocompleteOptions): Promise<KeywordData[]>;
+declare function enrichKeywordsWithEstimates(keywords: KeywordData[]): KeywordData[];
+
+interface GSCQueryOptions {
+    siteUrl: string;
+    startDate: string;
+    endDate: string;
+    dimensions?: string[];
+    rowLimit?: number;
+    startRow?: number;
+}
+declare function transformGSCData(gscData: GSCQueryData[]): KeywordData[];
+declare function findCTROpportunities(gscData: GSCQueryData[]): GSCQueryData[];
+declare function findAlmostPage1Keywords(gscData: GSCQueryData[]): GSCQueryData[];
+declare function findTopPerformers(gscData: GSCQueryData[]): GSCQueryData[];
+declare function buildGSCRequest(options: GSCQueryOptions): object;
+declare function getDateRange(days?: number): {
+    startDate: string;
+    endDate: string;
+};
+
+interface CompetitorKeywordResult {
+    coreKeywords: KeywordData[];
+    missingKeywords: KeywordData[];
+    uniqueKeywords: KeywordData[];
+    keywordUniverse: KeywordData[];
+    competitorOverlap: CompetitorOverlap[];
+}
+interface CompetitorOverlap {
+    competitor: string;
+    sharedKeywords: number;
+    uniqueToThem: number;
+    uniqueToYou: number;
+}
+/**
+ * Scrape competitor rankings from Google SERP for seed keywords
+ * This discovers what keywords competitors appear for
+ */
+declare function discoverCompetitorKeywords(yourDomain: string, seedKeywords: string[], competitors?: string[]): Promise<CompetitorKeywordResult>;
+/**
+ * Format competitor analysis report
+ */
+declare function formatCompetitorReport(result: CompetitorKeywordResult): string;
+
+interface KeywordTopic {
+    topic: string;
+    keywords: KeywordData[];
+    totalVolume: number;
+    avgDifficulty: number;
+    contentType: 'hub' | 'pillar' | 'cluster';
+}
+interface TopicClusterResult {
+    topics: KeywordTopic[];
+    uncategorized: KeywordData[];
+    contentStrategy: ContentRecommendation[];
+}
+interface ContentRecommendation {
+    topic: string;
+    pageType: 'pillar-page' | 'blog-post' | 'faq-page' | 'landing-page';
+    targetKeywords: string[];
+    potentialTraffic: number;
+    difficulty: 'easy' | 'medium' | 'hard';
+}
+/**
+ * Group keywords into topic clusters using multiple strategies:
+ * 1. Shared root words
+ * 2. Semantic similarity (common terms)
+ * 3. Intent matching (questions, how-to, etc.)
+ * 4. N-gram overlap
+ */
+declare function groupKeywordsByTopic(keywords: KeywordData[]): TopicClusterResult;
+/**
+ * Format topic grouping report
+ */
+declare function formatTopicReport(result: TopicClusterResult): string;
+
+/**
+ * Competitive Search Module
+ *
+ * Uses free APIs to find existing tools, competitors, and market intelligence.
+ * Priority order: Brave Search > Serper.dev > GitHub > npm/PyPI
+ */
+interface CompetitorTool {
+    name: string;
+    url: string;
+    description: string;
+    isPaid: boolean;
+    pricing?: string;
+    source: 'search' | 'github' | 'npm' | 'pypi' | 'hackernews';
+    stars?: number;
+    weeklyDownloads?: number;
+}
+interface CompetitiveSearchResult {
+    query: string;
+    existingTools: CompetitorTool[];
+    openSourceOptions: CompetitorTool[];
+    marketInsights: {
+        hasFreeSolutions: boolean;
+        hasPaidSolutions: boolean;
+        dominantPlayer?: string;
+        marketGap?: string;
+    };
+    searchSource: string;
+}
+interface CompetitiveSearchOptions {
+    braveApiKey?: string;
+    serperApiKey?: string;
+    githubToken?: string;
+    maxResults?: number;
+}
+/**
+ * Search for existing tools and competitors
+ */
+declare function searchCompetitors(toolConcept: string, options?: CompetitiveSearchOptions): Promise<CompetitiveSearchResult>;
+/**
+ * Search for specific format converters (e.g., "X to Mermaid converter")
+ */
+declare function searchFormatConverters(targetFormat: string, options?: CompetitiveSearchOptions): Promise<{
+    sourceFormats: string[];
+    existingConverters: CompetitorTool[];
+    opportunities: string[];
+}>;
+/**
+ * Search Hacker News for tool discussions
+ */
+declare function searchHackerNews(query: string, maxResults?: number): Promise<Array<{
+    title: string;
+    url: string;
+    points: number;
+    comments: number;
+}>>;
+
+/**
+ * LLM-as-Judge Module
+ *
+ * Uses AI to evaluate tool feasibility, specificity, and product fit.
+ * Prevents vague or unbuildable tool suggestions.
+ */
+
+interface ToolFeasibilityScore {
+    /** Overall feasibility score 1-5 */
+    feasibility: number;
+    /** Specificity score 1-5 (how detailed/actionable is the idea?) */
+    specificity: number;
+    /** Product fit score 1-5 (how well does it tie into the main product?) */
+    productFit: number;
+    /** Market opportunity score 1-5 */
+    marketOpportunity: number;
+    /** Combined weighted score */
+    overallScore: number;
+    /** Pass/fail based on minimum threshold */
+    passes: boolean;
+    /** Explanation for the scores */
+    reasoning: string;
+    /** Issues that would prevent building */
+    blockers: string[];
+    /** Improvements to make the tool more specific */
+    improvements: string[];
+}
+interface EnhancedToolIdea {
+    keyword: string;
+    toolName: string;
+    description: string;
+    /** Specific input format (e.g., "PlantUML text syntax") */
+    inputFormat: string;
+    /** Specific output format (e.g., "Mermaid diagram code") */
+    outputFormat: string;
+    /** How this tool connects back to the main product */
+    productTieIn: string;
+    /** Specific CTA text */
+    ctaText: string;
+    /** Deep link into product if possible */
+    deepLinkPattern?: string;
+    /** Competitor analysis */
+    competitors: {
+        hasFreeAlternative: boolean;
+        topCompetitor?: string;
+        ourAdvantage: string;
+    };
+    /** Technical implementation hints */
+    implementationHints: {
+        suggestedLibraries: string[];
+        estimatedComplexity: 'trivial' | 'simple' | 'moderate' | 'complex';
+        canUseExistingOSS: boolean;
+        ossLibrary?: string;
+    };
+    /** Feasibility assessment */
+    feasibilityScore: ToolFeasibilityScore;
+    /** Search volume and difficulty from keyword data */
+    volume: number;
+    difficulty: number;
+    priority: number;
+}
+interface LLMJudgeOptions {
+    openaiApiKey: string;
+    minFeasibilityScore?: number;
+    minSpecificityScore?: number;
+    minProductFitScore?: number;
+}
+/**
+ * Evaluate a tool idea for feasibility, specificity, and product fit
+ */
+declare function evaluateToolFeasibility(toolIdea: {
+    keyword: string;
+    toolName: string;
+    toolDescription: string;
+}, siteSummary: SiteSummary, competitiveData: CompetitiveSearchResult | null, options: LLMJudgeOptions): Promise<ToolFeasibilityScore>;
+/**
+ * Enhance a tool idea with specific details using AI
+ */
+declare function enhanceToolIdea(toolIdea: {
+    keyword: string;
+    toolName: string;
+    toolDescription: string;
+    volume: number;
+    difficulty: number;
+}, siteSummary: SiteSummary, competitiveData: CompetitiveSearchResult | null, options: LLMJudgeOptions): Promise<EnhancedToolIdea | null>;
+/**
+ * Batch evaluate and enhance tool ideas
+ */
+declare function evaluateAndEnhanceToolIdeas(toolIdeas: Array<{
+    keyword: string;
+    toolName: string;
+    toolDescription: string;
+    volume: number;
+    difficulty: number;
+}>, siteSummary: SiteSummary, getCompetitiveData: (keyword: string) => Promise<CompetitiveSearchResult | null>, options: LLMJudgeOptions): Promise<EnhancedToolIdea[]>;
+
+interface ReadabilityResult {
+    fleschReadingEase: number;
+    fleschGrade: string;
+    fleschKincaidGrade: number;
+    avgSentenceLength: number;
+    avgSyllablesPerWord: number;
+    avgWordsPerParagraph: number;
+    wordCount: number;
+    sentenceCount: number;
+    paragraphCount: number;
+    syllableCount: number;
+    passiveVoicePercentage: number;
+    complexWordPercentage: number;
+    recommendations: string[];
+    score: number;
+}
+/**
+ * Analyze content readability
+ */
+declare function analyzeReadability(text: string): ReadabilityResult;
+/**
+ * Format readability report
+ */
+declare function formatReadabilityReport(result: ReadabilityResult): string;
+
+type SearchIntent = 'informational' | 'navigational' | 'transactional' | 'commercial';
+interface IntentAnalysis {
+    intent: SearchIntent;
+    confidence: number;
+    signals: string[];
+    recommendedContentFormat: string;
+    contentSuggestions: string[];
+}
+/**
+ * Classify search intent for a keyword/query
+ */
+declare function classifyIntent(query: string): IntentAnalysis;
+/**
+ * Batch classify multiple keywords
+ */
+declare function classifyIntents(keywords: string[]): Map<string, IntentAnalysis>;
+/**
+ * Format intent analysis report
+ */
+declare function formatIntentReport(query: string, analysis: IntentAnalysis): string;
+
+interface HeadlineAnalysis {
+    headline: string;
+    score: number;
+    wordCount: number;
+    charCount: number;
+    breakdown: {
+        length: number;
+        powerWords: number;
+        emotionalWords: number;
+        numbers: number;
+        readability: number;
+        uniqueness: number;
+    };
+    issues: string[];
+    suggestions: string[];
+    type: 'how-to' | 'list' | 'question' | 'statement' | 'guide' | 'other';
+    sentiment: 'positive' | 'negative' | 'neutral';
+}
+/**
+ * Analyze headline effectiveness
+ */
+declare function analyzeHeadline(headline: string): HeadlineAnalysis;
+/**
+ * Generate headline variations
+ */
+declare function generateHeadlineVariations(topic: string, keywords: string[]): string[];
+/**
+ * Format headline analysis report
+ */
+declare function formatHeadlineReport(analysis: HeadlineAnalysis): string;
+
+type SnippetType = 'paragraph' | 'list' | 'table' | 'video' | 'none';
+interface FeaturedSnippetAnalysis {
+    snippetPotential: number;
+    bestSnippetType: SnippetType;
+    hasDirectAnswer: boolean;
+    hasNumberedSteps: boolean;
+    hasBulletList: boolean;
+    hasTable: boolean;
+    hasDefinition: boolean;
+    recommendations: SnippetRecommendation[];
+    suggestedParagraph?: string;
+    suggestedListItems?: string[];
+}
+interface SnippetRecommendation {
+    priority: 'high' | 'medium' | 'low';
+    action: string;
+    example?: string;
+}
+/**
+ * Analyze content for featured snippet optimization
+ */
+declare function analyzeFeaturedSnippetPotential(query: string, content: string, headings: string[]): FeaturedSnippetAnalysis;
+/**
+ * Format featured snippet analysis report
+ */
+declare function formatFeaturedSnippetReport(analysis: FeaturedSnippetAnalysis): string;
+
+interface KeywordDensityAnalysis {
+    primaryKeyword: string;
+    density: number;
+    occurrences: number;
+    wordCount: number;
+    inTitle: boolean;
+    inH1: boolean;
+    inFirstParagraph: boolean;
+    inLastParagraph: boolean;
+    inHeadings: number;
+    isKeywordStuffing: boolean;
+    isUnderOptimized: boolean;
+    lsiKeywords: LSIKeyword[];
+    recommendations: string[];
+}
+interface LSIKeyword {
+    keyword: string;
+    occurrences: number;
+    relevance: 'high' | 'medium' | 'low';
+}
+interface ContentElements {
+    title?: string;
+    h1?: string;
+    headings: string[];
+    body: string;
+    firstParagraph?: string;
+    lastParagraph?: string;
+}
+/**
+ * Analyze keyword density in content
+ */
+declare function analyzeKeywordDensity(primaryKeyword: string, content: ContentElements): KeywordDensityAnalysis;
+/**
+ * Find LSI (Latent Semantic Indexing) keywords in content
+ */
+declare function findLSIKeywords(primaryKeyword: string, content: string): LSIKeyword[];
+/**
+ * Calculate TF-IDF score for keywords in content
+ */
+declare function calculateTFIDF(content: string, documentCount?: number): Map<string, number>;
+/**
+ * Format keyword density report
+ */
+declare function formatKeywordDensityReport(analysis: KeywordDensityAnalysis): string;
+
+/**
+ * Content Generator Module
+ *
+ * Generates SEO-optimized content including blog posts, changelogs,
+ * and README files. Supports GEO (Generative Engine Optimization)
+ * for AI-friendly content.
+ */
+interface BlogPostConfig {
+    topic: string;
+    keywords?: string[];
+    tone?: 'technical' | 'educational' | 'casual' | 'professional';
+    wordCount?: {
+        min: number;
+        max: number;
+    };
+    includeFAQ?: boolean;
+    geoOptimize?: boolean;
+}
+interface ChangelogConfig {
+    fromRef: string;
+    toRef: string;
+    groupByType?: boolean;
+    seoKeywords?: string[];
+    includeBreaking?: boolean;
+}
+interface ReadmeConfig {
+    currentContent: string;
+    projectName: string;
+    keywords?: string[];
+    preserveCustomSections?: boolean;
+}
+interface GeneratedContent {
+    title: string;
+    content: string;
+    metaDescription: string;
+    keywords: string[];
+    readingTime?: string;
+    wordCount?: number;
+    hasFAQ?: boolean;
+    error?: string;
+}
+interface ChangelogResult {
+    content: string;
+    version?: string;
+    date?: string;
+    sections: {
+        features?: string[];
+        fixes?: string[];
+        breaking?: string[];
+        docs?: string[];
+        other?: string[];
+    };
+    metaDescription?: string;
+}
+interface ReadmeResult {
+    content: string;
+    metaDescription?: string;
+    suggestions: string[];
+}
+interface SEOScore {
+    overall: number;
+    headingScore: number;
+    keywordScore: number;
+    lengthScore: number;
+    linkScore: number;
+    mediaScore: number;
+}
+interface ContentGeneratorOptions {
+    llm?: LLMFunction;
+    exec?: ExecFunction;
+}
+type LLMFunction = (prompt: string) => Promise<any>;
+type ExecFunction = (cmd: string) => Promise<{
+    stdout: string;
+    stderr?: string;
+}>;
+/**
+ * Generate an SEO-optimized blog post
+ */
+declare function generateBlogPost(config: BlogPostConfig, options?: ContentGeneratorOptions): Promise<GeneratedContent>;
+/**
+ * Generate a changelog from git commits
+ */
+declare function generateChangelog(config: ChangelogConfig, options?: ContentGeneratorOptions): Promise<ChangelogResult>;
+/**
+ * Optimize a README file for SEO
+ */
+declare function optimizeReadme(config: ReadmeConfig, options?: ContentGeneratorOptions): Promise<ReadmeResult>;
+/**
+ * Score content for SEO quality
+ */
+declare function scoreContentSEO(content: string, options?: {
+    targetKeywords?: string[];
+}): SEOScore;
+
+interface GA4Config {
+    measurementId: string;
+}
+interface InjectionResult {
+    success: boolean;
+    file?: string;
+    message: string;
+    code?: string;
+}
+/**
+ * Generate GA4 tracking script
+ */
+declare function generateGA4Script(config: GA4Config): string;
+/**
+ * Generate GA4 for React/Next.js (component-based)
+ */
+declare function generateGA4ReactComponent(config: GA4Config): string;
+/**
+ * Generate GA4 for Vite/vanilla (index.html injection)
+ */
+declare function generateGA4ViteScript(config: GA4Config): string;
+/**
+ * Auto-detect framework and inject GA4
+ */
+declare function injectGA4(projectPath: string, config: GA4Config): Promise<InjectionResult>;
+/**
+ * Generate environment variable template for GA4
+ */
+declare function generateGA4EnvTemplate(): string;
+
+interface GSCConfig {
+    verificationCode?: string;
+    siteUrl: string;
+    credentials?: GSCCredentials;
+}
+interface GSCCredentials {
+    type: 'service_account' | 'oauth';
+    clientEmail?: string;
+    privateKey?: string;
+    accessToken?: string;
+    refreshToken?: string;
+}
+interface GSCQueryResult {
+    query: string;
+    clicks: number;
+    impressions: number;
+    ctr: number;
+    position: number;
+    page?: string;
+}
+interface GSCPerformanceData {
+    startDate: string;
+    endDate: string;
+    queries: GSCQueryResult[];
+    totalClicks: number;
+    totalImpressions: number;
+    avgCtr: number;
+    avgPosition: number;
+}
+interface QuickWin {
+    query: string;
+    currentPosition: number;
+    impressions: number;
+    clicks: number;
+    ctr: number;
+    opportunity: 'page-1-close' | 'low-ctr' | 'high-impression';
+    suggestedAction: string;
+    potentialGain: number;
+}
+/**
+ * Generate Search Console verification meta tag
+ */
+declare function generateGSCVerificationTag(verificationCode: string): string;
+/**
+ * Inject GSC verification into project
+ */
+declare function injectGSCVerification(projectPath: string, verificationCode: string): Promise<{
+    success: boolean;
+    file?: string;
+    message: string;
+}>;
+/**
+ * Build GSC API request (for use with Google APIs client)
+ * User needs to set up OAuth or service account credentials
+ */
+declare function buildGSCApiRequest(siteUrl: string, startDate: string, endDate: string, options?: {
+    dimensions?: ('query' | 'page' | 'country' | 'device' | 'date')[];
+    rowLimit?: number;
+    startRow?: number;
+}): object;
+/**
+ * Parse GSC API response into our format
+ */
+declare function parseGSCResponse(response: any): GSCPerformanceData;
+/**
+ * Identify quick wins from GSC data
+ */
+declare function identifyQuickWins(data: GSCPerformanceData): QuickWin[];
+/**
+ * Compare two periods to identify trends
+ */
+declare function comparePeriods(current: GSCPerformanceData, previous: GSCPerformanceData): {
+    improved: GSCQueryResult[];
+    declined: GSCQueryResult[];
+    newKeywords: GSCQueryResult[];
+    lostKeywords: GSCQueryResult[];
+    summary: {
+        clicksChange: number;
+        impressionsChange: number;
+        avgPositionChange: number;
+    };
+};
+/**
+ * Generate credentials setup instructions
+ */
+declare function getGSCSetupInstructions(): string;
+
+interface WorkflowConfig {
+    schedule: 'daily' | 'weekly' | 'monthly' | 'manual';
+    siteUrl: string;
+    features: {
+        audit: boolean;
+        tracking: boolean;
+        autoFix: boolean;
+        createIssues: boolean;
+        createPRs: boolean;
+    };
+    apiKey?: string;
+}
+/**
+ * Generate GitHub Action workflow YAML
+ */
+declare function generateWorkflow(config: WorkflowConfig): string;
+/**
+ * Generate the secrets documentation
+ */
+declare function generateSecretsDoc(config: WorkflowConfig): string;
+/**
+ * Generate complete setup package
+ */
+declare function generateGitHubActionSetup(config: WorkflowConfig): {
+    workflowYaml: string;
+    secretsDoc: string;
+    readmeBadge: string;
+};
+/**
+ * Write GitHub Action files to project
+ */
+declare function writeGitHubActionFiles(projectPath: string, config: WorkflowConfig): {
+    files: string[];
+    instructions: string;
+};
+
+interface ReportData {
+    siteUrl: string;
+    generatedAt: string;
+    audit?: AuditReport;
+    tracking?: {
+        current: GSCPerformanceData;
+        previous?: GSCPerformanceData;
+        quickWins: QuickWin[];
+    };
+    comparison?: {
+        improved: any[];
+        declined: any[];
+        newKeywords: any[];
+        lostKeywords: any[];
+        summary: {
+            clicksChange: number;
+            impressionsChange: number;
+            avgPositionChange: number;
+        };
+    };
+}
+/**
+ * Generate comprehensive markdown report
+ */
+declare function generateMarkdownReport(data: ReportData): string;
+/**
+ * Generate JSON report for API/dashboard
+ */
+declare function generateJsonReport(data: ReportData): object;
+
+declare function loadAgent(agentPath: string): AgentDefinition;
+declare function loadAgentByName(name: string, agentsDir?: string): AgentDefinition;
+declare function interpolatePrompt(template: string, variables: Record<string, string>): string;
+
+interface ExecuteOptions {
+    variables?: Record<string, string>;
+    onToolCall?: (name: string, params: Record<string, unknown>) => void;
+    onToolResult?: (name: string, result: ToolResult) => void;
+    cwd?: string;
+}
+interface ExecutionResult {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+    toolCalls?: {
+        name: string;
+        params: unknown;
+        result: ToolResult;
+    }[];
+}
+declare function executeAgent(agent: AgentDefinition, options?: ExecuteOptions): Promise<ExecutionResult>;
+declare function runDirectAnalysis(url: string): Promise<SEOAnalysisResult>;
+
+interface FixGeneratorOptions {
+    cwd: string;
+    url?: string;
+    framework?: FrameworkInfo$1;
+}
+interface GeneratedFix extends Fix {
+    applied?: boolean;
+    skipped?: boolean;
+    skipReason?: string;
+}
+declare function generateFixes(issues: SEOIssue[], options: FixGeneratorOptions): Promise<GeneratedFix[]>;
+declare function applyFixes(fixes: GeneratedFix[], options: {
+    cwd: string;
+    dryRun?: boolean;
+}): Promise<{
+    applied: GeneratedFix[];
+    skipped: GeneratedFix[];
+}>;
+
+declare function crawlUrl(params: {
+    url: string;
+}): Promise<ToolResult>;
+declare function extractMeta(params: {
+    html: string;
+    url: string;
+}): Promise<ToolResult>;
+declare function analyzeHeadings(params: {
+    html: string;
+}): Promise<ToolResult>;
+declare function extractImages(params: {
+    html: string;
+}): Promise<ToolResult>;
+declare function extractLinks(params: {
+    html: string;
+    baseUrl: string;
+}): Promise<ToolResult>;
+declare function extractSchema(params: {
+    html: string;
+}): Promise<ToolResult>;
+declare function checkRobots(params: {
+    url: string;
+}): Promise<ToolResult>;
+declare function checkSitemap(params: {
+    url: string;
+}): Promise<ToolResult>;
+
+declare function readFile(params: {
+    path: string;
+    cwd?: string;
+}): Promise<ToolResult>;
+declare function writeFile(params: {
+    path: string;
+    content: string;
+    cwd?: string;
+}): Promise<ToolResult>;
+declare function listFiles(params: {
+    path: string;
+    cwd?: string;
+    pattern?: string;
+    recursive?: boolean;
+}): Promise<ToolResult>;
+declare function detectFramework$1(params: {
+    cwd?: string;
+}): Promise<ToolResult>;
+declare function findHtmlEntry(params: {
+    cwd?: string;
+}): Promise<ToolResult>;
+declare function findPageFiles(params: {
+    cwd?: string;
+    framework?: string;
+}): Promise<ToolResult>;
+
+declare function analyzeUrl(params: {
+    url: string;
+}): Promise<ToolResult>;
+
+declare const tools: Record<string, ToolFunction>;
+
+/**
+ * Git Commit Helper
+ *
+ * Creates conventional commits for SEO fixes with proper co-authoring.
+ * Supports GitHub Pages and various static site generators.
+ */
+interface CommitConfig {
+    systemName?: string;
+    systemEmail?: string;
+    dryRun?: boolean;
+}
+interface ConventionalCommit {
+    type: 'fix' | 'feat' | 'docs' | 'style' | 'refactor' | 'perf' | 'chore';
+    scope?: string;
+    description: string;
+    body?: string;
+    breaking?: boolean;
+    issues?: string[];
+}
+interface SEOFixCommit {
+    category: string;
+    issues: string[];
+    filesChanged: string[];
+    description: string;
+}
+/**
+ * Formats a conventional commit message
+ */
+declare function formatConventionalCommit(commit: ConventionalCommit): string;
+/**
+ * Formats a commit message for SEO fixes
+ */
+declare function formatSEOCommitMessage(fix: SEOFixCommit, config?: CommitConfig): string;
+/**
+ * Creates a git commit with the SEO fix
+ */
+declare function createSEOCommit(fix: SEOFixCommit, config?: CommitConfig): Promise<{
+    success: boolean;
+    hash?: string;
+    error?: string;
+}>;
+/**
+ * Creates multiple commits, one per category
+ */
+declare function createSEOCommits(fixes: SEOFixCommit[], config?: CommitConfig): Promise<{
+    commits: Array<{
+        fix: SEOFixCommit;
+        result: Awaited<ReturnType<typeof createSEOCommit>>;
+    }>;
+}>;
+/**
+ * Checks if the current directory is a git repository
+ */
+declare function isGitRepo(dir?: string): boolean;
+/**
+ * Initializes a git repository if not already initialized
+ */
+declare function ensureGitRepo(dir?: string): Promise<void>;
+/**
+ * Gets the current git user config
+ */
+declare function getGitUser(): {
+    name?: string;
+    email?: string;
+};
+/**
+ * Detects if this is a GitHub Pages repository
+ */
+declare function detectGitHubPages(dir: string): {
+    isGitHubPages: boolean;
+    type?: 'jekyll' | 'static' | 'docs' | 'custom';
+    baseUrl?: string;
+};
+/**
+ * Generates a summary of commits made
+ */
+declare function generateCommitSummary(commits: Array<{
+    fix: SEOFixCommit;
+    result: {
+        success: boolean;
+        hash?: string;
+        error?: string;
+    };
+}>): string;
+declare const COMMIT_TYPES: readonly [{
+    readonly type: "fix";
+    readonly description: "Bug fix (SEO issue correction)";
+}, {
+    readonly type: "feat";
+    readonly description: "New feature (schema, OG tags, etc.)";
+}, {
+    readonly type: "docs";
+    readonly description: "Documentation update";
+}, {
+    readonly type: "style";
+    readonly description: "Code style changes (formatting)";
+}, {
+    readonly type: "refactor";
+    readonly description: "Code restructuring";
+}, {
+    readonly type: "perf";
+    readonly description: "Performance improvement";
+}, {
+    readonly type: "chore";
+    readonly description: "Maintenance task";
+}];
+declare const SEO_SCOPES: readonly ["seo", "meta", "og", "schema", "images", "links", "content", "security", "mobile", "i18n", "perf"];
+
+/**
+ * PR Helper
+ *
+ * Creates pull requests for SEO fixes using GitHub CLI.
+ * Generates formatted PR titles, bodies, and handles branch management.
+ */
+
+declare const execAsync: typeof exec.__promisify__;
+interface SEOFixSummary {
+    category: string;
+    issues: string[];
+    filesCount: number;
+}
+interface PRConfig {
+    scoreBefore?: number;
+    scoreAfter?: number;
+    reviewers?: string[];
+    assignees?: string[];
+    draft?: boolean;
+}
+interface PRDescription {
+    title: string;
+    body: string;
+    labels: string[];
+    reviewers?: string[];
+    assignees?: string[];
+}
+interface CreatePROptions {
+    title: string;
+    body: string;
+    baseBranch: string;
+    headBranch: string;
+    createBranch?: boolean;
+    labels?: string[];
+    reviewers?: string[];
+    assignees?: string[];
+    draft?: boolean;
+    dryRun?: boolean;
+}
+interface PRResult {
+    success: boolean;
+    url?: string;
+    number?: number;
+    error?: string;
+    dryRun?: boolean;
+}
+interface ExecOptions {
+    execAsync?: typeof execAsync;
+}
+/**
+ * Formats a PR title based on the fixes
+ */
+declare function formatPRTitle(fixes: SEOFixSummary[]): string;
+/**
+ * Formats the PR body with detailed information
+ */
+declare function formatPRBody(fixes: SEOFixSummary[], options?: {
+    scoreBefore?: number;
+    scoreAfter?: number;
+}): string;
+/**
+ * Generates complete PR description including title, body, and labels
+ */
+declare function generatePRDescription(fixes: SEOFixSummary[], config?: PRConfig): PRDescription;
+/**
+ * Creates a pull request using GitHub CLI
+ */
+declare function createPullRequest(options: CreatePROptions, deps?: ExecOptions): Promise<PRResult>;
+/**
+ * Generates a branch name for SEO fixes
+ */
+declare function generateBranchName(prefix?: string): string;
+/**
+ * Checks if gh CLI is available and authenticated
+ */
+declare function checkGitHubCLI(deps?: ExecOptions): Promise<{
+    available: boolean;
+    authenticated: boolean;
+    error?: string;
+}>;
+
+/**
+ * Scheduled Audit Module
+ *
+ * Handles scheduled execution of SEO audits with optional auto-fix PR creation.
+ * Can be used from Edge Functions, CLI cron jobs, or other scheduling mechanisms.
+ */
+type AuditSchedule = 'manual' | 'daily' | 'weekly' | 'on-demand';
+interface ScheduledAuditConfig {
+    projectId: string;
+    url: string;
+    schedule: AuditSchedule;
+    lastRunAt?: string;
+    previousScore?: number;
+    autoFix?: boolean;
+    baseBranch?: string;
+    generateFixes?: boolean;
+}
+interface ScheduledAuditResult {
+    success: boolean;
+    projectId: string;
+    score?: number;
+    scoreChange?: number;
+    issuesFound?: number;
+    fixesGenerated?: number;
+    prCreated?: boolean;
+    prUrl?: string;
+    prNumber?: number;
+    error?: string;
+    completedAt: string;
+    nextRunAt?: string | null;
+}
+/**
+ * Determines if an audit should run based on schedule and last run time
+ */
+declare function shouldRunAudit(config: ScheduledAuditConfig): boolean;
+/**
+ * Calculates the next scheduled run time
+ */
+declare function calculateNextRun(schedule: AuditSchedule): string | null;
+/**
+ * Runs a scheduled audit with optional auto-fix PR creation
+ */
+declare function runScheduledAudit(config: ScheduledAuditConfig): Promise<ScheduledAuditResult>;
+
+/**
+ * Alerts Module
+ *
+ * Sends notifications via Slack, Discord, and email webhooks when SEO events occur.
+ */
+type AlertType = 'error' | 'score_drop' | 'weekly_report' | 'pr_created';
+type AlertChannel = 'slack' | 'discord' | 'email';
+type AlertSeverity = 'info' | 'success' | 'warning' | 'error';
+interface AlertConfig {
+    type: AlertChannel;
+    webhookUrl: string;
+    on: AlertType[];
+    scoreDropThreshold?: number;
+}
+interface AuditAlertPayload {
+    projectId: string;
+    projectName: string;
+    url: string;
+    score: number;
+    previousScore?: number;
+    issuesFound: number;
+    errorCount?: number;
+    prUrl?: string;
+    prNumber?: number;
+    timestamp: string;
+}
+interface AlertMessage {
+    title: string;
+    body: string;
+    severity: AlertSeverity;
+    url?: string;
+}
+interface AlertResult {
+    success: boolean;
+    skipped?: boolean;
+    error?: string;
+}
+/**
+ * Formats an alert message based on type and payload
+ */
+declare function formatAlertMessage(type: AlertType, payload: AuditAlertPayload): AlertMessage;
+/**
+ * Determines if an alert should be sent based on config and payload
+ */
+declare function shouldSendAlert(config: AlertConfig, type: AlertType, payload?: AuditAlertPayload): boolean;
+/**
+ * Sends an alert to Slack webhook
+ */
+declare function sendSlackAlert(webhookUrl: string, type: AlertType, payload: AuditAlertPayload): Promise<AlertResult>;
+/**
+ * Sends an alert to Discord webhook
+ */
+declare function sendDiscordAlert(webhookUrl: string, type: AlertType, payload: AuditAlertPayload): Promise<AlertResult>;
+/**
+ * Sends an alert based on config
+ */
+declare function sendAlert(config: AlertConfig, type: AlertType, payload: AuditAlertPayload): Promise<AlertResult>;
+/**
+ * Sends alerts to multiple configs
+ */
+declare function sendAlerts(configs: AlertConfig[], type: AlertType, payload: AuditAlertPayload): Promise<AlertResult[]>;
+
+/**
+ * Report Generator
+ *
+ * Generates HTML and PDF reports for SEO audits with white-label branding support.
+ */
+interface ReportBranding {
+    companyName?: string;
+    logoUrl?: string;
+    primaryColor?: string;
+    accentColor?: string;
+    whiteLabel?: boolean;
+    contactEmail?: string;
+    websiteUrl?: string;
+}
+interface ReportConfig {
+    branding?: ReportBranding;
+    includeExecutiveSummary?: boolean;
+    includeRecommendations?: boolean;
+    includePageDetails?: boolean;
+    maxIssues?: number;
+}
+interface AuditIssueData {
+    code: string;
+    severity: 'error' | 'warning' | 'notice';
+    category: string;
+    title: string;
+    affectedUrls: string[];
+    description?: string;
+    howToFix?: string;
+}
+interface ReportPageData {
+    url: string;
+    score: number;
+    issues: number;
+}
+interface AuditReportData {
+    url: string;
+    domain: string;
+    timestamp: string;
+    score: number;
+    healthScores: {
+        overall: number;
+        crawlability: number;
+        indexability: number;
+        onPage: number;
+        content: number;
+        links: number;
+        performance: number;
+        security: number;
+        aiReadiness: number;
+        social: number;
+        localSeo: number;
+    };
+    summary: {
+        errors: number;
+        warnings: number;
+        notices: number;
+        passed: number;
+    };
+    issues: AuditIssueData[];
+    pages: ReportPageData[];
+}
+/**
+ * Generates an HTML report from audit data
+ */
+declare function generateHTMLReport(data: AuditReportData, config?: ReportConfig): string;
+/**
+ * Generates a PDF report from audit data
+ * Uses the HTML report as a base and converts to PDF
+ */
+declare function generatePDFReport(data: AuditReportData, config?: ReportConfig): Promise<Buffer>;
+
+/**
+ * GEO (Generative Engine Optimization) Tracker
+ *
+ * Tracks brand visibility in LLM responses to understand how AI models
+ * recommend or mention your brand for relevant queries.
+ */
+type MentionType = 'brand' | 'domain' | 'alternative';
+type LLMProvider = 'openai' | 'anthropic' | 'google' | 'perplexity';
+type Sentiment = 'positive' | 'negative' | 'neutral';
+interface BrandConfig {
+    brandName: string;
+    domains: string[];
+    alternativeNames?: string[];
+}
+interface Mention {
+    type: MentionType;
+    text: string;
+    position: number;
+    context: string;
+}
+interface GEOQuery {
+    keyword: string;
+    brand: BrandConfig;
+    providers: LLMProvider[];
+}
+interface GEOResult {
+    provider: LLMProvider;
+    keyword: string;
+    mentioned: boolean;
+    position: number | null;
+    sentiment: Sentiment | null;
+    score: number;
+    timestamp: string;
+    contextSnippet?: string;
+    error?: string;
+}
+interface ParsedResponse {
+    mentioned: boolean;
+    position: number | null;
+    sentiment: Sentiment | null;
+    contextSnippet: string | null;
+}
+interface TrackingOptions {
+    fetch?: typeof fetch;
+}
+/**
+ * Detects brand mentions in text
+ */
+declare function detectMentions(text: string, config: BrandConfig): Mention[];
+/**
+ * Score a mention based on position, type, and context
+ */
+declare function scoreMention(mention: Mention | null): number;
+/**
+ * Parse an LLM response to extract mention details
+ */
+declare function parseGEOResponse(response: string, config: BrandConfig): ParsedResponse;
+/**
+ * Track LLM visibility for a brand across multiple providers
+ */
+declare function trackLLMVisibility(query: GEOQuery, options?: TrackingOptions): Promise<GEOResult[]>;
+
+/**
+ * GEO History Module
+ *
+ * Tracks LLM visibility over time, detects changes, generates reports,
+ * and compares against competitors.
+ */
+
+type GEOAlertType = 'new_mention' | 'lost_mention' | 'position_improved' | 'position_dropped' | 'sentiment_changed' | 'score_improved' | 'score_dropped';
+type TrendDirection = 'improving' | 'declining' | 'stable' | 'unknown';
+interface GEOHistory {
+    brandName?: string;
+    results: GEOResult[];
+    maxResults?: number;
+}
+interface GEOHistoryOptions {
+    brandName?: string;
+    maxResults?: number;
+}
+interface GEOTrend {
+    direction: TrendDirection;
+    averageScore: number;
+    mentionRate: number;
+    dataPoints: number;
+    firstScore?: number;
+    lastScore?: number;
+}
+interface GEOAlert {
+    type: GEOAlertType;
+    message: string;
+    provider: LLMProvider;
+    keyword: string;
+    previousValue?: any;
+    currentValue?: any;
+    timestamp: string;
+}
+interface GEOReport {
+    brandName?: string;
+    totalQueries: number;
+    mentionRate: number;
+    averageScore: number;
+    byProvider: Record<string, ProviderStats>;
+    byKeyword: Record<string, KeywordStats>;
+    generatedAt: string;
+}
+interface ProviderStats {
+    queries: number;
+    mentions: number;
+    mentionRate: number;
+    averageScore: number;
+    averagePosition: number | null;
+}
+interface KeywordStats {
+    queries: number;
+    mentions: number;
+    mentionRate: number;
+    averageScore: number;
+}
+interface CompetitorComparison {
+    brand: string;
+    competitor: string;
+    brandMentionRate: number;
+    competitorMentionRate: number;
+    brandAverageScore: number;
+    competitorAverageScore: number;
+    brandAveragePosition: number | null;
+    competitorAveragePosition: number | null;
+    winner: string;
+}
+/**
+ * Create a new GEO history instance
+ */
+declare function createGEOHistory(options?: GEOHistoryOptions): GEOHistory;
+/**
+ * Add a tracking result to history
+ */
+declare function addTrackingResult(history: GEOHistory, result: GEOResult): GEOHistory;
+/**
+ * Get visibility trend for a specific provider and keyword
+ */
+declare function getVisibilityTrend(history: GEOHistory, provider: LLMProvider, keyword: string): GEOTrend;
+/**
+ * Detect visibility changes between history and new result
+ */
+declare function detectVisibilityChanges(history: GEOHistory, newResult: GEOResult): GEOAlert[];
+/**
+ * Generate a summary report from history
+ */
+declare function generateGEOReport(history: GEOHistory): GEOReport;
+/**
+ * Compare brand visibility against a competitor
+ */
+declare function compareCompetitorVisibility(brandHistory: GEOHistory, competitorName: string, competitorResults: GEOResult[]): CompetitorComparison;
+
+/**
+ * GEO Content Module
+ *
+ * Generate AI-citation-friendly content with structured data,
+ * comparison tables, FAQs, and key facts formatted for LLM parsing.
+ */
+interface KeyFact {
+    label: string;
+    value: string | number;
+}
+interface FAQItem {
+    question: string;
+    answer: string;
+}
+interface ComparisonRow {
+    feature: string;
+    brand: string | boolean;
+    competitor?: string | boolean;
+    competitors?: Record<string, string | boolean>;
+}
+interface ComparisonConfig {
+    brandName: string;
+    competitorName?: string;
+    competitorNames?: string[];
+    useCheckmarks?: boolean;
+}
+interface AIContentConfig {
+    productName: string;
+    tagline?: string;
+    description?: string;
+    keyFacts?: KeyFact[];
+    faqs?: FAQItem[];
+    comparison?: {
+        competitorName: string;
+        rows: ComparisonRow[];
+    };
+}
+interface KeyFactsOptions {
+    format?: 'bullets' | 'paragraph' | 'inline';
+}
+interface FAQSchemaOptions {
+    format?: 'json-ld' | 'markdown';
+}
+interface OptimizeOptions {
+    brandName?: string;
+    highlightNumbers?: boolean;
+    structureLists?: boolean;
+    emphasizeBrand?: boolean;
+    addSourcePlaceholder?: boolean;
+}
+/**
+ * Generate formatted key facts for AI citation
+ */
+declare function generateKeyFacts(facts: KeyFact[], options?: KeyFactsOptions): string;
+/**
+ * Generate FAQ schema (JSON-LD or Markdown)
+ */
+declare function generateFAQSchema(faqs: FAQItem[], options?: FAQSchemaOptions): string;
+/**
+ * Generate comparison table in markdown
+ */
+declare function generateComparisonTable(rows: ComparisonRow[], config: ComparisonConfig): string;
+/**
+ * Generate complete AI-citable content block
+ */
+declare function generateAICitableContent(config: AIContentConfig): string;
+/**
+ * Optimize existing content for AI citation
+ */
+declare function optimizeForAI(content: string, options?: OptimizeOptions): string;
+
+/**
+ * Framework Detection
+ *
+ * Detects web frameworks from:
+ * 1. HTML signatures (data attributes, meta tags, scripts)
+ * 2. package.json dependencies
+ * 3. File structure patterns
+ */
+type Framework = 'react' | 'nextjs' | 'vue' | 'nuxt' | 'angular' | 'svelte' | 'sveltekit' | 'astro' | 'remix' | 'gatsby' | 'rails' | 'laravel' | 'django' | 'wordpress' | 'unknown';
+interface FrameworkInfo {
+    framework: Framework;
+    version?: string;
+    confidence: 'high' | 'medium' | 'low';
+    detected_from: 'html' | 'package.json' | 'files' | 'headers';
+    meta_framework?: Framework;
+}
+/**
+ * Detect framework from HTML content
+ */
+declare function detectFromHtml(html: string): FrameworkInfo | null;
+/**
+ * Detect framework from package.json content
+ */
+declare function detectFromPackageJson(packageJson: {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+}): FrameworkInfo | null;
+/**
+ * Detect framework from HTTP response headers
+ */
+declare function detectFromHeaders(headers: Record<string, string>): FrameworkInfo | null;
+/**
+ * Combined detection using multiple sources
+ */
+declare function detectFramework(options: {
+    html?: string;
+    packageJson?: {
+        dependencies?: Record<string, string>;
+        devDependencies?: Record<string, string>;
+    };
+    headers?: Record<string, string>;
+    files?: string[];
+}): FrameworkInfo;
+/**
+ * Get human-readable framework name
+ */
+declare function getFrameworkDisplayName(framework: Framework): string;
+
+/**
+ * Framework-Specific SEO Suggestion Engine
+ *
+ * Loads recipe files and provides framework-specific SEO suggestions.
+ * Works with both CLI and Web UI.
+ */
+
+interface FrameworkCheck {
+    code: string;
+    severity: IssueSeverity;
+    title: string;
+    description: string;
+    howToFix: string;
+    impact?: string;
+    detection?: {
+        html_patterns?: string[];
+        missing_content?: boolean;
+        title_in_js?: boolean;
+        title_not_in_html?: boolean;
+    };
+    app_router_only?: boolean;
+    pages_router_only?: boolean;
+}
+interface FrameworkRecipe {
+    framework: Framework;
+    display_name: string;
+    category: string;
+    base_framework?: Framework;
+    ssr_default: boolean;
+    seo_challenges?: string[];
+    seo_strengths?: string[];
+    checks: FrameworkCheck[];
+    performance_tips?: string[];
+    migration_paths?: Record<string, {
+        effort: string;
+        benefits: string[];
+        guide?: string;
+    }>;
+    recommended_plugins?: Record<string, string[]>;
+    recommended_gems?: Record<string, string[]>;
+    integrations?: string[];
+}
+/**
+ * Load a recipe from embedded content or file system
+ */
+declare function loadRecipe(framework: Framework): Promise<FrameworkRecipe | null>;
+/**
+ * Get framework-specific issues based on HTML analysis
+ */
+declare function getFrameworkIssues(frameworkInfo: FrameworkInfo, html: string, url: string): Promise<AuditIssue[]>;
+/**
+ * Get framework-specific suggestions for fixing issues
+ */
+declare function getFrameworkSuggestions(frameworkInfo: FrameworkInfo, issueCode: string): Promise<string | null>;
+/**
+ * Get all available checks for a framework
+ */
+declare function getFrameworkChecks(framework: Framework): Promise<FrameworkCheck[]>;
+/**
+ * Get performance tips for a framework
+ */
+declare function getPerformanceTips(framework: Framework): Promise<string[]>;
+/**
+ * Get SEO challenges for a framework
+ */
+declare function getSeoChallenges(framework: Framework): Promise<string[]>;
+/**
+ * Get migration paths from current framework
+ */
+declare function getMigrationPaths(framework: Framework): Promise<Record<string, {
+    effort: string;
+    benefits: string[];
+    guide?: string;
+}>>;
+/**
+ * Get total number of framework-specific checks
+ */
+declare function getTotalFrameworkChecks(): Promise<number>;
+/**
+ * Get framework summary for display
+ */
+declare function getFrameworkSummary(framework: Framework): Promise<{
+    name: string;
+    category: string;
+    ssrDefault: boolean;
+    checkCount: number;
+    strengths: string[];
+    challenges: string[];
+} | null>;
+/**
+ * Embed recipe content for bundling (called at build time)
+ */
+declare function embedRecipe(framework: Framework, content: string): void;
+
+/**
+ * Framework Detection and SEO Recipes
+ *
+ * Provides framework-specific SEO suggestions for:
+ * - React, Next.js, Gatsby, Remix
+ * - Vue, Nuxt
+ * - Angular
+ * - Svelte, SvelteKit
+ * - Astro
+ * - Ruby on Rails
+ * - Laravel, Django
+ * - WordPress
+ *
+ * Usage:
+ *
+ * ```typescript
+ * import { detectFramework, getFrameworkIssues } from './frameworks';
+ *
+ * // Detect framework from HTML
+ * const frameworkInfo = detectFramework({ html });
+ *
+ * // Get framework-specific issues
+ * const issues = await getFrameworkIssues(frameworkInfo, html, url);
+ * ```
+ */
+
+declare const SUPPORTED_FRAMEWORKS: readonly ["react", "nextjs", "vue", "nuxt", "angular", "svelte", "sveltekit", "astro", "remix", "gatsby", "rails", "laravel", "django", "wordpress"];
+
+type index_Framework = Framework;
+type index_FrameworkCheck = FrameworkCheck;
+type index_FrameworkInfo = FrameworkInfo;
+type index_FrameworkRecipe = FrameworkRecipe;
+declare const index_SUPPORTED_FRAMEWORKS: typeof SUPPORTED_FRAMEWORKS;
+declare const index_detectFramework: typeof detectFramework;
+declare const index_detectFromHeaders: typeof detectFromHeaders;
+declare const index_detectFromHtml: typeof detectFromHtml;
+declare const index_detectFromPackageJson: typeof detectFromPackageJson;
+declare const index_embedRecipe: typeof embedRecipe;
+declare const index_getFrameworkChecks: typeof getFrameworkChecks;
+declare const index_getFrameworkDisplayName: typeof getFrameworkDisplayName;
+declare const index_getFrameworkIssues: typeof getFrameworkIssues;
+declare const index_getFrameworkSuggestions: typeof getFrameworkSuggestions;
+declare const index_getFrameworkSummary: typeof getFrameworkSummary;
+declare const index_getMigrationPaths: typeof getMigrationPaths;
+declare const index_getPerformanceTips: typeof getPerformanceTips;
+declare const index_getSeoChallenges: typeof getSeoChallenges;
+declare const index_getTotalFrameworkChecks: typeof getTotalFrameworkChecks;
+declare const index_loadRecipe: typeof loadRecipe;
+declare namespace index {
+  export { type index_Framework as Framework, type index_FrameworkCheck as FrameworkCheck, type index_FrameworkInfo as FrameworkInfo, type index_FrameworkRecipe as FrameworkRecipe, index_SUPPORTED_FRAMEWORKS as SUPPORTED_FRAMEWORKS, index_detectFramework as detectFramework, index_detectFromHeaders as detectFromHeaders, index_detectFromHtml as detectFromHtml, index_detectFromPackageJson as detectFromPackageJson, index_embedRecipe as embedRecipe, index_getFrameworkChecks as getFrameworkChecks, index_getFrameworkDisplayName as getFrameworkDisplayName, index_getFrameworkIssues as getFrameworkIssues, index_getFrameworkSuggestions as getFrameworkSuggestions, index_getFrameworkSummary as getFrameworkSummary, index_getMigrationPaths as getMigrationPaths, index_getPerformanceTips as getPerformanceTips, index_getSeoChallenges as getSeoChallenges, index_getTotalFrameworkChecks as getTotalFrameworkChecks, index_loadRecipe as loadRecipe };
+}
+
+/**
+ * WASM Adapter
+ *
+ * This file creates the global RankCLI object that the WASM wrapper expects.
+ * It adapts the async runFullAudit to a sync-compatible interface for VM execution.
+ *
+ * When this code is embedded in WASM and executed in a Node.js VM:
+ * - The VM has limited async capabilities
+ * - We provide a sync interface that queues work for the host
+ */
+
+interface SyncAuditResult {
+    success: boolean;
+    score: number;
+    issues: AuditIssue[];
+    checksRun: number;
+    tier: string;
+}
+/**
+ * Synchronous audit function for VM execution
+ * Only runs checks that don't require network requests
+ */
+declare function runSyncAudit(url: string, html: string, checksLimit: number): SyncAuditResult;
+
+export { type AIContentConfig, type AIKeywordResearchOptions, type AgentDefinition, type AgentTool, type AlertChannel, type AlertConfig, type AlertMessage, type AlertResult, type AlertSeverity, type AlertType, type AuditAlertPayload, type AuditIssue, type AuditIssueData, type AuditOptions, type AuditPRResult, type AuditReport, type AuditReportData, type AuditRunnerOptions, type AuditRunnerResult, type AuditSchedule, type BlogPostConfig, type BrandConfig, type CIAction, type CIKeywordOptions, type CIKeywordResult, COMMIT_TYPES, type ChangelogConfig, type ChangelogResult, type CommitConfig, type ComparisonConfig, type ComparisonRow, type CompetitiveInsight, type CompetitiveSearchOptions, type CompetitiveSearchResult, type CompetitorComparison, type CompetitorKeywordResult, type CompetitorOverlap, type CompetitorTool, type ContentElements, type ContentGeneratorOptions, type ContentRecommendation, type ConventionalCommit, type CrawlResult, type CrawlStats, type CrawledPage, type CreateAuditPROptions, type CreatePROptions, type DataForSEOCredentials, type DiscoveredPage, type EnhancedToolIdea, type ExecOptions, type ExecuteOptions, type ExecutionResult, type FAQItem, type FAQSchemaOptions, type FeaturedSnippetAnalysis, type Fix, type FixFile, type FixGeneratorOptions, type FixResult, type FrameworkInfo$1 as FrameworkInfo, type FreeKeywordResult, type FreeToolIdea, type GA4Config, type GEOAlert, type GEOAlertType, type GEOHistory, type GEOHistoryOptions, type GEOQuery, type GEOReport, type GEOResult, type GEOTrend, type GSCConfig, type GSCCredentials, type GSCPerformanceData, type GSCQueryData, type GSCQueryResult, type GeneratedContent, type GeneratedFix, type HeadingStructure, type HeadlineAnalysis, type HealthScore, ISSUE_DEFINITIONS, type ImageInfo$1 as ImageInfo, type InjectionResult, type IntentAnalysis, type IssueCategory, type IssueDefinition, type IssueSeverity, type KeyFact, type KeyFactsOptions, type KeywordAction, type KeywordCluster, type KeywordData, type KeywordDensityAnalysis, type KeywordOpportunity, type KeywordRecommendation, type KeywordResearchOptions, type KeywordResearchResult, type KeywordStats, type KeywordTopic, type LLMJudgeOptions, type LLMProvider, LOCATION_CODES, type LSIKeyword, type LinkInfo, type Mention, type MentionType, type MetaData, type NGram, type NLPAnalysisResult, OG_IMAGE_SPECS, type OptimizeOptions, type PRConfig, type PRDescription, PRIORITY_WEIGHTS, type PRResult, type PageAudit, type PageData, type PageMeta, type PaidKeywordResult, type ParsedResponse, type PlanTier, type ProviderStats, type QuickWin, type ReadabilityResult, type ReadmeConfig, type ReadmeResult, type ReportBranding, type ReportConfig, type ReportData, type ReportPageData, type RouteInfo, type SEOAnalysisResult, type SEOFixCommit, type SEOFixSummary, type SEOIssue, type SEORecommendation, type SEOScore, SEO_SCOPES, SITE_PROFILE_QUESTIONS, type ScheduledAuditConfig, type ScheduledAuditResult, type SchemaData, type SearchIntent, type Sentiment, type SiteCrawlResult, type SiteProfile, type SiteSummary, type SnippetRecommendation, type SnippetType, type SocialMetaConfig, type SocialMetaFix, type SummarizerOptions, type TFIDFResult, type ToolFeasibilityScore, type ToolFunction, type ToolResult, type TopicClusterResult, type TopicModel, type TrackingOptions, type TrendDirection, type UncertaintyAssessment, type WizardQuestion, type WizardResponse, type WizardResult, type WizardSession, type WorkflowConfig, addTrackingResult, analyzeAnchorText, analyzeCanonicalAdvanced, analyzeClientRendering, analyzeContentFreshness, analyzeConversionElements, analyzeDOMStructure, analyzeEntitySEO, analyzeFeaturedSnippetPotential, analyzeFreshnessSignals, analyzeFunnelIntent, analyzeHeadings, analyzeHeadline, analyzeHreflang, analyzeImages, analyzeInteractiveTools, analyzeKeywordDensity, analyzeKeywordPlacement, analyzeKeywords, analyzeLinks, analyzeLocalSEO, analyzeMobile, analyzeModernImages, analyzeNavBoostSignals, analyzeOnPage, analyzePagination, analyzePerformance, analyzePlatformPresence, analyzeReadability, analyzeRedirectChain, analyzeRedirects, analyzeResponsiveImages, analyzeSERPPreview, analyzeSecurity, analyzeSecurityHeaders, analyzeSocialMeta, analyzeStructuredData, analyzeTopicalClusters, analyzeTrackerBloat, analyzeUrl, analyzeUrlSafety, applyFixes, buildGSCApiRequest, buildGSCRequest, calculateBM25, calculateTFIDF$1 as calculateKeywordTFIDF, calculateNextRun, calculateTFIDF, checkAIBotBlocking, checkAMP, checkAdsTxt, checkAppleTouchIcon, checkBalance, checkCertificate, checkDMARC, checkGitHubCLI, checkInternalRedirects, checkJSRenderingRatio, checkLlmsTxt, checkMobileResources, checkPlaintextEmails, checkRedirects, checkRobots, checkRobotsTxt, checkSPF, checkSitemap, classifyIntent, classifyIntents, clusterKeywordsByEmbedding, compareCompetitorVisibility, comparePeriods, completeWizard, crawlSite, crawlUrl, createAuditPR, createFallbackSummary, createGEOHistory, createPullRequest, createSEOCommit, createSEOCommits, detectDuplicates, detectFramework$1 as detectFramework, detectGitHubPages, detectMentions, detectSoft404, detectTechnologies, detectVisibilityChanges, discoverCompetitorKeywords, discoverPagesFromLinks, discoverRoutesFromRepo, enhanceSummaryWithCompetitors, enhanceToolIdea, enrichKeywordsWithEstimates, ensureGitRepo, evaluateAndEnhanceToolIdeas, evaluateToolFeasibility, executeAgent, extractContentHash, extractEntityPhrases, extractImages, extractKeyPhrases, extractLinks, extractMeta, extractNgrams, extractSchema, extractSeedKeywords, extractTopics, fetchCoreWebVitals, findAlmostPage1Keywords, findCTROpportunities, findHtmlEntry, findLSIKeywords, findPageFiles, findTopPerformers, formatAlertMessage, formatCIResult, formatCompetitorReport, formatConventionalCommit, formatFeaturedSnippetReport, formatHeadlineReport, formatIntentReport, formatKeywordDensityReport, formatKeywordReport, formatPRBody, formatPRTitle, formatReadabilityReport, formatReport, formatSEOCommitMessage, formatTopicReport, formatWizardProgress, index as frameworks, generateAICitableContent, generateAllFixes, generateAstroMeta, generateBlogPost, generateBranchName, generateChangelog, generateCommitSummary, generateComparisonTable, generateCompleteSocialMetaSetup, generateDuplicateIssues, generateFAQSchema, generateFixes, generateGA4EnvTemplate, generateGA4ReactComponent, generateGA4Script, generateGA4ViteScript, generateGEOReport, generateGSCVerificationTag, generateGitHubActionSetup, generateHTMLReport, generateHTMLSocialMeta, generateHeadlineVariations, generateJsonReport, generateKeyFacts, generateMarkdownReport, generateNextAppMetadata, generateNextPagesHead, generatePDFReport, generatePRDescription, generateReactHelmetSocialMeta, generateRemixMeta, generateSecretsDoc, generateSocialMetaFix, generateSvelteKitMeta, generateUncertaintyQuestions, generateWizardQuestions, generateWorkflow, getAutocompleteSuggestions, getDateRange, getExpandedSuggestions, getGSCSetupInstructions, getGitUser, getKeywordData, getKeywordSuggestions, getMaxKdThreshold, getNextQuestion, getRelatedKeywords, getVisibilityTrend, groupKeywordsByTopic, identifyQuickWins, injectGA4, injectGSCVerification, interpolatePrompt, isGitRepo, listFiles, loadAgent, loadAgentByName, mergePages, optimizeForAI, optimizeReadme, parseGEOResponse, parseGSCResponse, parseSitemap, prioritizeKeywords, processWizardResponse, readFile, routesToUrls, runAIKeywordResearch, runAIReadinessChecks, runAdditionalChecks, runAuditWithFixes, runCIKeywordResearch, runCrawlabilityChecks, runDirectAnalysis, runFullAudit, runKeywordResearch, runNLPAnalysis, runScheduledAudit, runSyncAudit, scoreContentSEO, scoreMention, searchCompetitors, searchFormatConverters, searchHackerNews, sendAlert, sendAlerts, sendDiscordAlert, sendSlackAlert, shouldRunAudit, shouldSendAlert, startWizardSession, suggestSchemaTypes, summarizeSite, tokenize, tools, trackLLMVisibility, transformGSCData, urlSafetyDatabase, wizardResponsesToContext, writeFile, writeGitHubActionFiles };