@testspectra/cli 1.1.7 → 1.1.8-rc.2

package/dist/linter/extractor.d.ts

@@ -0,0 +1,67 @@
+export interface DeclaredSpecStep {
+    name: string;
+    line: number;
+    raw: string;
+}
+export interface ExtractedSymbolCall {
+    name: string;
+    line: number;
+    column: number;
+}
+export interface ExtractedCodeSymbols {
+    stepCalls: ExtractedSymbolCall[];
+    itBlocks: Array<{
+        title: string;
+        line: number;
+        column: number;
+    }>;
+    testBlocks: Array<{
+        title: string;
+        line: number;
+        column: number;
+    }>;
+    describeBlocks: Array<{
+        title: string;
+        line: number;
+        column: number;
+    }>;
+    importStatements: Array<{
+        line: number;
+        column: number;
+        specifier: string;
+    }>;
+}
+/**
+ * Extracts @step:<name> tokens from the "## Test Steps" section of spec.md.
+ */
+export declare function extractDeclaredStepsFromSpec(body: string, bodyStartLine: number): DeclaredSpecStep[];
+/**
+ * Parses a TypeScript test file into an AST and extracts Step.* calls,
+ * it() test blocks, describe() suite blocks, and import statements.
+ */
+export declare function extractSymbolsFromTestCode(code: string, filePath: string): ExtractedCodeSymbols;
+/**
+ * Determines whether an it("...") test title aligns with the spec.md title.
+ * In TestSpectra, the it() argument represents the complete test case workflow
+ * and directly corresponds to the title declared in spec.md.
+ */
+export declare function areTitlesAligned(specTitle: string, testTitle: string): boolean;
+export interface ModuleExportResult {
+    hasAnonymousAsyncDefaultExport: boolean;
+    hasNamedExports: boolean;
+    namedExportLines: Array<{
+        line: number;
+        column: number;
+        name: string;
+    }>;
+    testBlocks: Array<{
+        line: number;
+        column: number;
+        name: string;
+    }>;
+}
+/**
+ * Parses a shared module (.step.ts, .action.ts, .hook.ts) into AST
+ * and checks for anonymous async default export compliance.
+ */
+export declare function extractModuleExports(code: string, filePath: string): ModuleExportResult;

package/dist/linter/extractor.js

@@ -0,0 +1,245 @@
+import ts from 'typescript';
+/**
+ * Extracts @step:<name> tokens from the "## Test Steps" section of spec.md.
+ */
+export function extractDeclaredStepsFromSpec(body, bodyStartLine) {
+    const steps = [];
+    const lines = body.split('\n');
+    let inStepsSection = false;
+    for (let i = 0; i < lines.length; i++) {
+        const lineNum = bodyStartLine + i;
+        const rawLine = lines[i];
+        const trimmed = rawLine.trim();
+        if (trimmed.startsWith('## ')) {
+            const heading = trimmed
+                .replace(/^##\s+/, '')
+                .trim()
+                .toLowerCase();
+            if (heading === 'test steps') {
+                inStepsSection = true;
+                continue;
+            }
+            else if (inStepsSection) {
+                break;
+            }
+        }
+        if (inStepsSection) {
+            const stepRegex = /@step:([a-zA-Z0-9_-]+)/g;
+            let match;
+            while ((match = stepRegex.exec(rawLine)) !== null) {
+                steps.push({
+                    name: match[1],
+                    line: lineNum,
+                    raw: match[0],
+                });
+            }
+        }
+    }
+    return steps;
+}
+/**
+ * Parses a TypeScript test file into an AST and extracts Step.* calls,
+ * it() test blocks, describe() suite blocks, and import statements.
+ */
+export function extractSymbolsFromTestCode(code, filePath) {
+    const sourceFile = ts.createSourceFile(filePath, code, ts.ScriptTarget.Latest, true);
+    const stepCalls = [];
+    const itBlocks = [];
+    const testBlocks = [];
+    const describeBlocks = [];
+    const importStatements = [];
+    function visit(node) {
+        // 1. Detect manual import statements (TS-LINT-006)
+        if (ts.isImportDeclaration(node)) {
+            const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+            const specifier = ts.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : '';
+            importStatements.push({
+                line: line + 1,
+                column: character + 1,
+                specifier,
+            });
+        }
+        else if (ts.isImportEqualsDeclaration(node)) {
+            const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+            importStatements.push({
+                line: line + 1,
+                column: character + 1,
+                specifier: '',
+            });
+        }
+        // 2. Detect it(...) / test(...) [forbidden] and describe(...) / suite(...) call expressions (TS-LINT-007, TS-LINT-008, TS-LINT-005)
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+            const fnName = node.expression.text;
+            if (fnName === 'it') {
+                let title = '';
+                if (node.arguments.length > 0) {
+                    const firstArg = node.arguments[0];
+                    if (ts.isStringLiteral(firstArg) || ts.isNoSubstitutionTemplateLiteral(firstArg)) {
+                        title = firstArg.text;
+                    }
+                }
+                const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+                itBlocks.push({
+                    title,
+                    line: line + 1,
+                    column: character + 1,
+                });
+            }
+            else if (fnName === 'test') {
+                let title = '';
+                if (node.arguments.length > 0) {
+                    const firstArg = node.arguments[0];
+                    if (ts.isStringLiteral(firstArg) || ts.isNoSubstitutionTemplateLiteral(firstArg)) {
+                        title = firstArg.text;
+                    }
+                }
+                const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+                testBlocks.push({
+                    title,
+                    line: line + 1,
+                    column: character + 1,
+                });
+            }
+            else if (fnName === 'describe' || fnName === 'suite') {
+                let title = '';
+                if (node.arguments.length > 0) {
+                    const firstArg = node.arguments[0];
+                    if (ts.isStringLiteral(firstArg) || ts.isNoSubstitutionTemplateLiteral(firstArg)) {
+                        title = firstArg.text;
+                    }
+                }
+                const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+                describeBlocks.push({
+                    title,
+                    line: line + 1,
+                    column: character + 1,
+                });
+            }
+        }
+        // 3. Detect Step.<name>() calls
+        if (ts.isCallExpression(node)) {
+            if (ts.isPropertyAccessExpression(node.expression)) {
+                const propAccess = node.expression;
+                if (ts.isIdentifier(propAccess.expression) && propAccess.expression.text === 'Step') {
+                    const stepName = propAccess.name.text;
+                    const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+                    stepCalls.push({
+                        name: stepName,
+                        line: line + 1,
+                        column: character + 1,
+                    });
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return {
+        stepCalls,
+        itBlocks,
+        testBlocks,
+        describeBlocks,
+        importStatements,
+    };
+}
+/**
+ * Determines whether an it("...") test title aligns with the spec.md title.
+ * In TestSpectra, the it() argument represents the complete test case workflow
+ * and directly corresponds to the title declared in spec.md.
+ */
+export function areTitlesAligned(specTitle, testTitle) {
+    if (!specTitle || !testTitle)
+        return true;
+    return specTitle.trim().toLowerCase() === testTitle.trim().toLowerCase();
+}
+function hasModifier(node, kind) {
+    return ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((m) => m.kind === kind) === true;
+}
+/**
+ * Parses a shared module (.step.ts, .action.ts, .hook.ts) into AST
+ * and checks for anonymous async default export compliance.
+ */
+export function extractModuleExports(code, filePath) {
+    const sourceFile = ts.createSourceFile(filePath, code, ts.ScriptTarget.Latest, true);
+    let hasAnonymousAsyncDefaultExport = false;
+    const namedExportLines = [];
+    const testBlocks = [];
+    function visit(node) {
+        // Check for export default async function () {} (FunctionDeclaration with DefaultKeyword)
+        if (ts.isFunctionDeclaration(node)) {
+            const hasExport = hasModifier(node, ts.SyntaxKind.ExportKeyword);
+            const hasDefault = hasModifier(node, ts.SyntaxKind.DefaultKeyword);
+            const hasAsync = hasModifier(node, ts.SyntaxKind.AsyncKeyword);
+            if (hasExport && hasDefault && hasAsync) {
+                if (!node.name) {
+                    hasAnonymousAsyncDefaultExport = true;
+                }
+                else {
+                    // Named function used with export default: export default async function foo() {}
+                    const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+                    const name = node.name.text;
+                    namedExportLines.push({ line: line + 1, column: character + 1, name });
+                }
+            }
+            else if (hasExport && !hasDefault) {
+                // export function foo() {} — named export (forbidden)
+                const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+                const name = node.name?.text || 'default';
+                namedExportLines.push({ line: line + 1, column: character + 1, name });
+            }
+        }
+        // Check for export default async () => {} or export default async function () {} (ExportAssignment)
+        if (ts.isExportAssignment(node)) {
+            const expr = node.expression;
+            if (ts.isArrowFunction(expr)) {
+                const hasAsync = hasModifier(expr, ts.SyntaxKind.AsyncKeyword);
+                if (hasAsync) {
+                    hasAnonymousAsyncDefaultExport = true;
+                }
+            }
+            else if (ts.isFunctionExpression(expr)) {
+                const hasAsync = hasModifier(expr, ts.SyntaxKind.AsyncKeyword);
+                if (hasAsync && !expr.name) {
+                    hasAnonymousAsyncDefaultExport = true;
+                }
+                else if (hasAsync && expr.name) {
+                    const { line, character } = sourceFile.getLineAndCharacterOfPosition(expr.getStart());
+                    namedExportLines.push({ line: line + 1, column: character + 1, name: expr.name.text });
+                }
+            }
+        }
+        // Check for export class (named exports)
+        if (ts.isClassDeclaration(node)) {
+            const hasExport = hasModifier(node, ts.SyntaxKind.ExportKeyword);
+            if (hasExport) {
+                const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+                const name = node.name?.text || 'default';
+                namedExportLines.push({ line: line + 1, column: character + 1, name });
+            }
+        }
+        // Check for export { ... } or export * from '...' (named exports)
+        if (ts.isExportDeclaration(node)) {
+            const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+            const exportName = node.exportClause && ts.isNamedExports(node.exportClause)
+                ? node.exportClause.elements.map((e) => e.name.text).join(', ')
+                : '*';
+            namedExportLines.push({ line: line + 1, column: character + 1, name: exportName });
+        }
+        // Check for forbidden test blocks
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+            const fnName = node.expression.text;
+            if (fnName === 'it' || fnName === 'test' || fnName === 'describe') {
+                const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+                testBlocks.push({ line: line + 1, column: character + 1, name: fnName });
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return {
+        hasAnonymousAsyncDefaultExport,
+        hasNamedExports: namedExportLines.length > 0,
+        namedExportLines,
+        testBlocks,
+    };
+}

package/dist/linter/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types.js';
+export * from './parser.js';
+export * from './schemas/spec.schema.js';
+export * from './schemas/suite.schema.js';
+export * from './discovery.js';
+export * from './extractor.js';
+export * from './spec-linter.js';

package/dist/linter/index.js

@@ -0,0 +1,7 @@
+export * from './types.js';
+export * from './parser.js';
+export * from './schemas/spec.schema.js';
+export * from './schemas/suite.schema.js';
+export * from './discovery.js';
+export * from './extractor.js';
+export * from './spec-linter.js';

package/dist/linter/parser.d.ts

@@ -0,0 +1,24 @@
+import type { LintDiagnostic } from './types.js';
+export interface ParsedFrontmatterResult<T = Record<string, unknown>> {
+    data: T | null;
+    raw: string;
+    hasFrontmatter: boolean;
+    startLine: number;
+    endLine: number;
+    bodyStartLine: number;
+    diagnostics: LintDiagnostic[];
+    keyLineMap: Map<string, number>;
+    body: string;
+}
+/**
+ * Scans lines within a range to locate YAML frontmatter properties before any Markdown heading
+ * or code fence. Returns the 0-indexed line range [first, last] or null if no properties found.
+ */
+export declare function findPropertyRange(lines: string[], startIdx?: number, maxIdx?: number): {
+    first: number;
+    last: number;
+} | null;
+/**
+ * Extracts and parses YAML frontmatter from a Markdown document with line mapping.
+ */
+export declare function parseMarkdownFrontmatter<T = Record<string, unknown>>(content: string, filePath: string): ParsedFrontmatterResult<T>;

package/dist/linter/parser.js

@@ -0,0 +1,219 @@
+import YAML from 'yaml';
+/**
+ * Scans lines within a range to locate YAML frontmatter properties before any Markdown heading
+ * or code fence. Returns the 0-indexed line range [first, last] or null if no properties found.
+ */
+export function findPropertyRange(lines, startIdx = 0, maxIdx = lines.length) {
+    let first = -1;
+    let last = -1;
+    for (let i = startIdx; i < maxIdx; i++) {
+        const raw = lines[i];
+        const trimmed = raw.trim();
+        if (!trimmed) {
+            if (first !== -1) {
+                let hasMorePropsAhead = false;
+                for (let j = i + 1; j < maxIdx; j++) {
+                    const nextTrimmed = lines[j].trim();
+                    if (!nextTrimmed)
+                        continue;
+                    if (nextTrimmed.startsWith('#') || nextTrimmed === '---' || nextTrimmed.startsWith('```')) {
+                        break;
+                    }
+                    if (/^[a-zA-Z0-9_-]+\s*:/.test(nextTrimmed)) {
+                        hasMorePropsAhead = true;
+                    }
+                    break;
+                }
+                if (!hasMorePropsAhead) {
+                    break;
+                }
+            }
+            continue;
+        }
+        if (trimmed.startsWith('#') || trimmed === '---' || trimmed.startsWith('```')) {
+            break;
+        }
+        if (/^[a-zA-Z0-9_-]+\s*:/.test(trimmed) || (first !== -1 && (trimmed.startsWith('- ') || /^\s+/.test(raw)))) {
+            if (first === -1) {
+                first = i;
+            }
+            last = i;
+        }
+        else {
+            break;
+        }
+    }
+    return first !== -1 ? { first, last } : null;
+}
+/**
+ * Extracts and parses YAML frontmatter from a Markdown document with line mapping.
+ */
+export function parseMarkdownFrontmatter(content, filePath) {
+    const diagnostics = [];
+    const keyLineMap = new Map();
+    // Normalize line endings
+    const normalized = content.replace(/\r\n/g, '\n');
+    const lines = normalized.split('\n');
+    if (lines.length === 0 || lines[0].trim() !== '---') {
+        // Check if there is a closing delimiter somewhere in the file
+        let closingIndex = -1;
+        for (let i = 1; i < lines.length; i++) {
+            if (lines[i].trim() === '---') {
+                closingIndex = i;
+                break;
+            }
+        }
+        if (closingIndex !== -1) {
+            // Case 1: Opener delimiter is missing, but closing delimiter exists
+            return {
+                data: null,
+                raw: '',
+                hasFrontmatter: false,
+                startLine: 1,
+                endLine: closingIndex + 1,
+                bodyStartLine: closingIndex + 2,
+                diagnostics: [
+                    {
+                        code: 'testspectra/missing-frontmatter',
+                        severity: 'error',
+                        message: 'Missing opening YAML frontmatter delimiter (---) at line 1',
+                        filePath,
+                        line: 1,
+                    },
+                ],
+                keyLineMap,
+                body: lines.slice(closingIndex + 1).join('\n'),
+            };
+        }
+        // Neither opener nor closing delimiter exists
+        const propRange = findPropertyRange(lines, 0);
+        if (propRange) {
+            // Case 3: No delimiters at all, but frontmatter properties exist
+            return {
+                data: null,
+                raw: '',
+                hasFrontmatter: false,
+                startLine: 1,
+                endLine: propRange.last + 1,
+                bodyStartLine: propRange.last + 2,
+                diagnostics: [
+                    {
+                        code: 'testspectra/missing-frontmatter',
+                        severity: 'error',
+                        message: 'Missing YAML frontmatter delimiters (---) at line 1',
+                        filePath,
+                        line: 1,
+                    },
+                ],
+                keyLineMap,
+                body: normalized,
+            };
+        }
+        // Case 4: Delimiters missing and properties missing
+        return {
+            data: null,
+            raw: '',
+            hasFrontmatter: false,
+            startLine: 1,
+            endLine: 1,
+            bodyStartLine: 1,
+            diagnostics: [
+                {
+                    code: 'testspectra/missing-frontmatter',
+                    severity: 'error',
+                    message: 'Missing YAML frontmatter delimiter (---) at line 1',
+                    filePath,
+                    line: 1,
+                },
+            ],
+            keyLineMap,
+            body: normalized,
+        };
+    }
+    let closingIndex = -1;
+    for (let i = 1; i < lines.length; i++) {
+        if (lines[i].trim() === '---') {
+            closingIndex = i;
+            break;
+        }
+    }
+    if (closingIndex === -1) {
+        // Case 2: Opening delimiter exists at line 1, but closing delimiter is missing
+        return {
+            data: null,
+            raw: '',
+            hasFrontmatter: false,
+            startLine: 1,
+            endLine: lines.length,
+            bodyStartLine: lines.length,
+            diagnostics: [
+                {
+                    code: 'testspectra/missing-frontmatter',
+                    severity: 'error',
+                    message: 'Missing closing YAML frontmatter delimiter (---). Expected closing "---"',
+                    filePath,
+                    line: 1,
+                },
+            ],
+            keyLineMap,
+            body: '',
+        };
+    }
+    const frontmatterLines = lines.slice(1, closingIndex);
+    const rawFrontmatter = frontmatterLines.join('\n');
+    const body = lines.slice(closingIndex + 1).join('\n');
+    const lineCounter = new YAML.LineCounter();
+    const doc = YAML.parseDocument(rawFrontmatter, { lineCounter, keepSourceTokens: true });
+    if (doc.errors && doc.errors.length > 0) {
+        for (const err of doc.errors) {
+            const pos = err.linePos ? err.linePos[0] : { line: 1, col: 1 };
+            diagnostics.push({
+                code: 'testspectra/parse-error',
+                severity: 'error',
+                message: `Malformed YAML syntax in frontmatter: ${err.message}`,
+                filePath,
+                line: 1 + pos.line, // 1 for the leading '---'
+                column: pos.col,
+            });
+        }
+        return {
+            data: null,
+            raw: rawFrontmatter,
+            hasFrontmatter: true,
+            startLine: 1,
+            endLine: closingIndex + 1,
+            bodyStartLine: closingIndex + 2,
+            diagnostics,
+            keyLineMap,
+            body,
+        };
+    }
+    // Populate keyLineMap for exact line numbers
+    if (YAML.isMap(doc.contents)) {
+        for (const item of doc.contents.items) {
+            if (item && item.key) {
+                const keyName = String(item.key);
+                if (item.key.range) {
+                    const pos = lineCounter.linePos(item.key.range[0]);
+                    // 1 (for opening delimiter line) + linePos.line
+                    keyLineMap.set(keyName, 1 + pos.line);
+                }
+                else {
+                    keyLineMap.set(keyName, 1);
+                }
+            }
+        }
+    }
+    const data = doc.toJSON();
+    return {
+        data,
+        raw: rawFrontmatter,
+        hasFrontmatter: true,
+        startLine: 1,
+        endLine: closingIndex + 1,
+        bodyStartLine: closingIndex + 2,
+        diagnostics,
+        keyLineMap,
+        body,
+    };
+}

package/dist/linter/schemas/spec.schema.d.ts

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import type { LintDiagnostic } from '../types.js';
+export declare const PRIORITY_VALUES: readonly ["Critical", "High", "Medium", "Low"];
+export declare const CASE_TYPE_VALUES: readonly ["Positive", "Negative", "Edge"];
+export declare const STATUS_VALUES: readonly ["draft", "ready-for-automation", "automated", "deprecated"];
+export declare const COVERAGE_STATUS_VALUES: readonly ["automated", "manual", "unsupported"];
+export declare const PriorityEnum: z.ZodEnum<["Critical", "High", "Medium", "Low"]>;
+export declare const CaseTypeEnum: z.ZodEnum<["Positive", "Negative", "Edge"]>;
+export declare const StatusEnum: z.ZodEnum<["draft", "ready-for-automation", "automated", "deprecated"]>;
+export declare const CoverageSchema: z.ZodObject<{
+    web: z.ZodOptional<z.ZodEnum<["automated", "manual", "unsupported"]>>;
+    mobile: z.ZodOptional<z.ZodEnum<["automated", "manual", "unsupported"]>>;
+}, "strip", z.ZodTypeAny, {
+    web?: "automated" | "manual" | "unsupported" | undefined;
+    mobile?: "automated" | "manual" | "unsupported" | undefined;
+}, {
+    web?: "automated" | "manual" | "unsupported" | undefined;
+    mobile?: "automated" | "manual" | "unsupported" | undefined;
+}>;
+export declare const SpecFrontmatterSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    priority: z.ZodEnum<["Critical", "High", "Medium", "Low"]>;
+    caseType: z.ZodEnum<["Positive", "Negative", "Edge"]>;
+    status: z.ZodEnum<["draft", "ready-for-automation", "automated", "deprecated"]>;
+    coverage: z.ZodOptional<z.ZodObject<{
+        web: z.ZodOptional<z.ZodEnum<["automated", "manual", "unsupported"]>>;
+        mobile: z.ZodOptional<z.ZodEnum<["automated", "manual", "unsupported"]>>;
+    }, "strip", z.ZodTypeAny, {
+        web?: "automated" | "manual" | "unsupported" | undefined;
+        mobile?: "automated" | "manual" | "unsupported" | undefined;
+    }, {
+        web?: "automated" | "manual" | "unsupported" | undefined;
+        mobile?: "automated" | "manual" | "unsupported" | undefined;
+    }>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    status: "draft" | "ready-for-automation" | "automated" | "deprecated";
+    title: string;
+    priority: "Critical" | "High" | "Medium" | "Low";
+    caseType: "Positive" | "Negative" | "Edge";
+    coverage?: {
+        web?: "automated" | "manual" | "unsupported" | undefined;
+        mobile?: "automated" | "manual" | "unsupported" | undefined;
+    } | undefined;
+    tags?: string[] | undefined;
+}, {
+    id: string;
+    status: "draft" | "ready-for-automation" | "automated" | "deprecated";
+    title: string;
+    priority: "Critical" | "High" | "Medium" | "Low";
+    caseType: "Positive" | "Negative" | "Edge";
+    coverage?: {
+        web?: "automated" | "manual" | "unsupported" | undefined;
+        mobile?: "automated" | "manual" | "unsupported" | undefined;
+    } | undefined;
+    tags?: string[] | undefined;
+}>;
+export type SpecFrontmatter = z.infer<typeof SpecFrontmatterSchema>;
+export interface SectionDefinition {
+    name: string;
+    level: number;
+    required: boolean;
+    headerPattern: RegExp;
+    description: string;
+}
+export declare const REQUIRED_SPEC_SECTIONS: SectionDefinition[];
+export declare const STANDARD_SPEC_SECTIONS: SectionDefinition[];
+export interface ParsedMarkdownHeader {
+    level: number;
+    text: string;
+    line: number;
+    raw: string;
+}
+/**
+ * Extracts markdown headers from document body.
+ */
+export declare function extractMarkdownHeaders(body: string, startLine: number): ParsedMarkdownHeader[];
+/**
+ * Validates markdown body sections against spec rules.
+ */
+export declare function validateSpecSections(body: string, filePath: string, bodyStartLine: number): LintDiagnostic[];