@syrin/cli 1.3.1 → 1.4.0

package/dist/runtime/analysis/rules/errors/e019-unexpected-test-result.d.ts

@@ -1,65 +0,0 @@
-/**
- * E019: Unexpected Test Result
- *
- * Condition: Test's actual outcome doesn't match its expectation
- *
- * Why this is fatal:
- * - Test contract is inaccurate
- * - Tool behavior doesn't match declared guarantees
- * - Can cause false positives/negatives in validation
- * - Indicates mismatch between expectations and reality
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for unexpected test result detection.
- */
-export interface UnexpectedTestResultContext {
-    /** Tool name */
-    toolName: string;
-    /** Test name */
-    testName: string;
-    /** Test input */
-    testInput?: Record<string, unknown>;
-    /** Expected outcome (success/error/timeout) */
-    expectedOutcome: 'success' | 'error' | 'timeout';
-    /** Actual outcome (success/error/timeout) */
-    actualOutcome: 'success' | 'error' | 'timeout';
-    /** Expected error code (if expecting error) */
-    expectedErrorCode?: string;
-    /** Expected error type (if expecting error) */
-    expectedErrorType?: string;
-    /** Actual error code (if actual outcome is error) */
-    actualErrorCode?: string;
-    /** Actual error type (if actual outcome is error) */
-    actualErrorType?: string;
-    /** Expected error details (if expecting specific error) */
-    expectedError?: {
-        type?: string;
-        details?: Record<string, unknown>;
-    };
-    /** Actual error details (if actual outcome is error) */
-    actualError?: {
-        code?: string;
-        type?: string;
-        message?: string;
-    };
-}
-declare class E019UnexpectedTestResultRule extends BaseRule {
-    readonly id: "E019";
-    readonly severity: "error";
-    readonly ruleName = "Unexpected Test Result";
-    readonly description = "Test's actual outcome doesn't match its expectation. Tool behavior doesn't match declared guarantees.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Determine if a diagnostic should be created based on behavioral context.
-     */
-    private shouldCreateDiagnostic;
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: UnexpectedTestResultContext): Diagnostic[];
-}
-export declare const E019UnexpectedTestResult: E019UnexpectedTestResultRule;
-export {};
-//# sourceMappingURL=e019-unexpected-test-result.d.ts.map

package/dist/runtime/analysis/rules/errors/e019-unexpected-test-result.js

@@ -1,109 +0,0 @@
-/**
- * E019: Unexpected Test Result
- *
- * Condition: Test's actual outcome doesn't match its expectation
- *
- * Why this is fatal:
- * - Test contract is inaccurate
- * - Tool behavior doesn't match declared guarantees
- * - Can cause false positives/negatives in validation
- * - Indicates mismatch between expectations and reality
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E019UnexpectedTestResultRule extends BaseRule {
-    id = ERROR_CODES.E019;
-    severity = 'error';
-    ruleName = 'Unexpected Test Result';
-    description = "Test's actual outcome doesn't match its expectation. Tool behavior doesn't match declared guarantees.";
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Determine if a diagnostic should be created based on behavioral context.
-     */
-    shouldCreateDiagnostic(behavioralCtx) {
-        // If outcomes don't match, create diagnostic
-        if (behavioralCtx.expectedOutcome !== behavioralCtx.actualOutcome) {
-            return true;
-        }
-        // Outcomes match - check if error details also match (for error cases)
-        if (behavioralCtx.expectedOutcome === 'error') {
-            const expectedType = behavioralCtx.expectedErrorType?.toLowerCase();
-            const actualType = behavioralCtx.actualErrorType?.toLowerCase();
-            if (expectedType && actualType && expectedType !== actualType) {
-                return true; // Type mismatch
-            }
-            if (expectedType && !actualType) {
-                return true; // Expected type but no actual type
-            }
-            const expectedCode = behavioralCtx.expectedErrorCode;
-            const actualCode = behavioralCtx.actualErrorCode;
-            if (expectedCode && actualCode && expectedCode !== actualCode) {
-                return true; // Code mismatch
-            }
-        }
-        return false; // Everything matches
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        if (!this.shouldCreateDiagnostic(behavioralCtx)) {
-            return diagnostics;
-        }
-        // If we reach here, there's a mismatch - create diagnostic
-        let message = `Test "${behavioralCtx.testName}" in tool "${behavioralCtx.toolName}" expected `;
-        // Build expected description
-        if (behavioralCtx.expectedOutcome === 'success') {
-            message += 'success but got ';
-            if (behavioralCtx.actualOutcome === 'error') {
-                message += `error (${behavioralCtx.actualErrorCode || behavioralCtx.actualErrorType || 'unknown error'})`;
-            }
-            else if (behavioralCtx.actualOutcome === 'timeout') {
-                message += 'timeout';
-            }
-            else {
-                message += behavioralCtx.actualOutcome;
-            }
-        }
-        else if (behavioralCtx.expectedOutcome === 'error') {
-            message += `error`;
-            if (behavioralCtx.expectedErrorType) {
-                message += ` of type "${behavioralCtx.expectedErrorType}"`;
-            }
-            if (behavioralCtx.expectedErrorCode) {
-                message += ` (code: ${behavioralCtx.expectedErrorCode})`;
-            }
-            message += ' but got ';
-            if (behavioralCtx.actualOutcome === 'success') {
-                message += 'success';
-            }
-            else {
-                message += `${behavioralCtx.actualOutcome} (${behavioralCtx.actualErrorCode || behavioralCtx.actualErrorType || 'unknown error'})`;
-            }
-            if (behavioralCtx.actualErrorType &&
-                behavioralCtx.expectedErrorType &&
-                behavioralCtx.actualErrorType.toLowerCase() !==
-                    behavioralCtx.expectedErrorType.toLowerCase()) {
-                message += ' with different type';
-            }
-        }
-        else {
-            message += `${behavioralCtx.expectedOutcome} but got ${behavioralCtx.actualOutcome}`;
-        }
-        diagnostics.push(this.createDiagnostic(message, behavioralCtx.toolName, undefined, 'Update test expectation to match actual tool behavior, or fix tool implementation to match declared guarantees. Ensure test expectations accurately reflect tool behavior.', {
-            testName: behavioralCtx.testName,
-            testInput: behavioralCtx.testInput,
-            expectedOutcome: behavioralCtx.expectedOutcome,
-            actualOutcome: behavioralCtx.actualOutcome,
-            expectedError: behavioralCtx.expectedError,
-            actualError: behavioralCtx.actualError,
-        }));
-        return diagnostics;
-    }
-}
-export const E019UnexpectedTestResult = new E019UnexpectedTestResultRule();
-//# sourceMappingURL=e019-unexpected-test-result.js.map

package/dist/runtime/analysis/rules/errors/e020-unexpected-test-result.d.ts

@@ -1,65 +0,0 @@
-/**
- * E020: Unexpected Test Result
- *
- * Condition: Test's actual outcome doesn't match its expectation
- *
- * Why this is fatal:
- * - Test contract is inaccurate
- * - Tool behavior doesn't match declared guarantees
- * - Can cause false positives/negatives in validation
- * - Indicates mismatch between expectations and reality
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-/**
- * Context for unexpected test result detection.
- */
-export interface UnexpectedTestResultContext {
-    /** Tool name */
-    toolName: string;
-    /** Test name */
-    testName: string;
-    /** Test input */
-    testInput?: Record<string, unknown>;
-    /** Expected outcome (success/error/timeout) */
-    expectedOutcome: 'success' | 'error' | 'timeout';
-    /** Actual outcome (success/error/timeout) */
-    actualOutcome: 'success' | 'error' | 'timeout';
-    /** Expected error code (if expecting error) */
-    expectedErrorCode?: string;
-    /** Expected error type (if expecting error) */
-    expectedErrorType?: string;
-    /** Actual error code (if actual outcome is error) */
-    actualErrorCode?: string;
-    /** Actual error type (if actual outcome is error) */
-    actualErrorType?: string;
-    /** Expected error details (if expecting specific error) */
-    expectedError?: {
-        type?: string;
-        details?: Record<string, unknown>;
-    };
-    /** Actual error details (if actual outcome is error) */
-    actualError?: {
-        code?: string;
-        type?: string;
-        message?: string;
-    };
-}
-declare class E020UnexpectedTestResultRule extends BaseRule {
-    readonly id: "E020";
-    readonly severity: "error";
-    readonly ruleName = "Unexpected Test Result";
-    readonly description = "Test's actual outcome doesn't match its expectation. Tool behavior doesn't match declared guarantees.";
-    check(_ctx: AnalysisContext): Diagnostic[];
-    /**
-     * Determine if a diagnostic should be created based on behavioral context.
-     */
-    private shouldCreateDiagnostic;
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx: UnexpectedTestResultContext): Diagnostic[];
-}
-export declare const E020UnexpectedTestResult: E020UnexpectedTestResultRule;
-export {};
-//# sourceMappingURL=e020-unexpected-test-result.d.ts.map

package/dist/runtime/analysis/rules/errors/e020-unexpected-test-result.js

@@ -1,109 +0,0 @@
-/**
- * E020: Unexpected Test Result
- *
- * Condition: Test's actual outcome doesn't match its expectation
- *
- * Why this is fatal:
- * - Test contract is inaccurate
- * - Tool behavior doesn't match declared guarantees
- * - Can cause false positives/negatives in validation
- * - Indicates mismatch between expectations and reality
- */
-import { BaseRule } from '../base.js';
-import { ERROR_CODES } from '../error-codes.js';
-class E020UnexpectedTestResultRule extends BaseRule {
-    id = ERROR_CODES.E020;
-    severity = 'error';
-    ruleName = 'Unexpected Test Result';
-    description = "Test's actual outcome doesn't match its expectation. Tool behavior doesn't match declared guarantees.";
-    check(_ctx) {
-        // This rule requires behavioral context
-        return [];
-    }
-    /**
-     * Determine if a diagnostic should be created based on behavioral context.
-     */
-    shouldCreateDiagnostic(behavioralCtx) {
-        // If outcomes don't match, create diagnostic
-        if (behavioralCtx.expectedOutcome !== behavioralCtx.actualOutcome) {
-            return true;
-        }
-        // Outcomes match - check if error details also match (for error cases)
-        if (behavioralCtx.expectedOutcome === 'error') {
-            const expectedType = behavioralCtx.expectedErrorType?.toLowerCase();
-            const actualType = behavioralCtx.actualErrorType?.toLowerCase();
-            if (expectedType && actualType && expectedType !== actualType) {
-                return true; // Type mismatch
-            }
-            if (expectedType && !actualType) {
-                return true; // Expected type but no actual type
-            }
-            const expectedCode = behavioralCtx.expectedErrorCode;
-            const actualCode = behavioralCtx.actualErrorCode;
-            if (expectedCode && actualCode && expectedCode !== actualCode) {
-                return true; // Code mismatch
-            }
-        }
-        return false; // Everything matches
-    }
-    /**
-     * Check with behavioral context (called from test orchestrator).
-     */
-    checkWithBehavioralContext(behavioralCtx) {
-        const diagnostics = [];
-        if (!this.shouldCreateDiagnostic(behavioralCtx)) {
-            return diagnostics;
-        }
-        // If we reach here, there's a mismatch - create diagnostic
-        let message = `Test "${behavioralCtx.testName}" in tool "${behavioralCtx.toolName}" expected `;
-        // Build expected description
-        if (behavioralCtx.expectedOutcome === 'success') {
-            message += 'success but got ';
-            if (behavioralCtx.actualOutcome === 'error') {
-                message += `error (${behavioralCtx.actualErrorCode || behavioralCtx.actualErrorType || 'unknown error'})`;
-            }
-            else if (behavioralCtx.actualOutcome === 'timeout') {
-                message += 'timeout';
-            }
-            else {
-                message += behavioralCtx.actualOutcome;
-            }
-        }
-        else if (behavioralCtx.expectedOutcome === 'error') {
-            message += `error`;
-            if (behavioralCtx.expectedErrorType) {
-                message += ` of type "${behavioralCtx.expectedErrorType}"`;
-            }
-            if (behavioralCtx.expectedErrorCode) {
-                message += ` (code: ${behavioralCtx.expectedErrorCode})`;
-            }
-            message += ' but got ';
-            if (behavioralCtx.actualOutcome === 'success') {
-                message += 'success';
-            }
-            else {
-                message += `${behavioralCtx.actualOutcome} (${behavioralCtx.actualErrorCode || behavioralCtx.actualErrorType || 'unknown error'})`;
-            }
-            if (behavioralCtx.actualErrorType &&
-                behavioralCtx.expectedErrorType &&
-                behavioralCtx.actualErrorType.toLowerCase() !==
-                    behavioralCtx.expectedErrorType.toLowerCase()) {
-                message += ' with different type';
-            }
-        }
-        else {
-            message += `${behavioralCtx.expectedOutcome} but got ${behavioralCtx.actualOutcome}`;
-        }
-        diagnostics.push(this.createDiagnostic(message, behavioralCtx.toolName, undefined, 'Update test expectation to match actual tool behavior, or fix tool implementation to match declared guarantees. Ensure test expectations accurately reflect tool behavior.', {
-            testName: behavioralCtx.testName,
-            testInput: behavioralCtx.testInput,
-            expectedOutcome: behavioralCtx.expectedOutcome,
-            actualOutcome: behavioralCtx.actualOutcome,
-            expectedError: behavioralCtx.expectedError,
-            actualError: behavioralCtx.actualError,
-        }));
-        return diagnostics;
-    }
-}
-export const E020UnexpectedTestResult = new E020UnexpectedTestResultRule();
-//# sourceMappingURL=e020-unexpected-test-result.js.map

package/dist/runtime/analysis/rules/warnings/w001-implicit-dependency.d.ts

@@ -1,22 +0,0 @@
-/**
- * W001: Implicit Tool Dependency
- *
- * Condition:
- * - High confidence dependency inferred
- * - Not stated explicitly in description
- *
- * Why:
- * - LLM may not chain tools reliably
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class W001ImplicitDependencyRule extends BaseRule {
-    readonly id = "W001";
-    readonly severity: "warning";
-    readonly ruleName = "Implicit Tool Dependency";
-    readonly description = "Tool appears to depend on another tool, but the dependency is implicit.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const W001ImplicitDependency: W001ImplicitDependencyRule;
-export {};
-//# sourceMappingURL=w001-implicit-dependency.d.ts.map

package/dist/runtime/analysis/rules/warnings/w001-implicit-dependency.js

@@ -1,39 +0,0 @@
-/**
- * W001: Implicit Tool Dependency
- *
- * Condition:
- * - High confidence dependency inferred
- * - Not stated explicitly in description
- *
- * Why:
- * - LLM may not chain tools reliably
- */
-import { BaseRule } from '../base.js';
-class W001ImplicitDependencyRule extends BaseRule {
-    id = 'W001';
-    severity = 'warning';
-    ruleName = 'Implicit Tool Dependency';
-    description = 'Tool appears to depend on another tool, but the dependency is implicit.';
-    check(ctx) {
-        const diagnostics = [];
-        // Check medium to high confidence dependencies (0.6-0.8)
-        const implicitDeps = ctx.dependencies.filter(d => d.confidence >= 0.6 && d.confidence < 0.8);
-        for (const dep of implicitDeps) {
-            // Find the toTool to check its description
-            const toTool = ctx.indexes.toolIndex.get(dep.toTool.toLowerCase());
-            if (!toTool) {
-                continue;
-            }
-            const description = toTool.description || '';
-            // Check if fromTool is mentioned in description
-            const fromToolNameLower = dep.fromTool.toLowerCase();
-            const descLower = description.toLowerCase();
-            if (!descLower.includes(fromToolNameLower)) {
-                diagnostics.push(this.createDiagnostic(`Tool "${dep.toTool}" appears to depend on "${dep.fromTool}", but the dependency is implicit.`, dep.toTool, dep.toField, `Mention "${dep.fromTool}" in the description of "${dep.toTool}" to make the dependency explicit.`));
-            }
-        }
-        return diagnostics;
-    }
-}
-export const W001ImplicitDependency = new W001ImplicitDependencyRule();
-//# sourceMappingURL=w001-implicit-dependency.js.map

package/dist/runtime/analysis/rules/warnings/w002-free-text-without-normalization.d.ts

@@ -1,24 +0,0 @@
-/**
- * W002: Free-Text Output Without Normalization
- *
- * Condition:
- * - Output is string
- * - Not constrained or normalized
- * - Even if not chained
- *
- * Why:
- * - Hard to reuse
- * - Hard to evolve
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class W002FreeTextWithoutNormalizationRule extends BaseRule {
-    readonly id = "W002";
-    readonly severity: "warning";
-    readonly ruleName = "Free-Text Output Without Normalization";
-    readonly description = "Tool returns unconstrained free text. Consider normalizing output.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const W002FreeTextWithoutNormalization: W002FreeTextWithoutNormalizationRule;
-export {};
-//# sourceMappingURL=w002-free-text-without-normalization.d.ts.map

package/dist/runtime/analysis/rules/warnings/w002-free-text-without-normalization.js

@@ -1,40 +0,0 @@
-/**
- * W002: Free-Text Output Without Normalization
- *
- * Condition:
- * - Output is string
- * - Not constrained or normalized
- * - Even if not chained
- *
- * Why:
- * - Hard to reuse
- * - Hard to evolve
- */
-import { BaseRule } from '../base.js';
-class W002FreeTextWithoutNormalizationRule extends BaseRule {
-    id = 'W002';
-    severity = 'warning';
-    ruleName = 'Free-Text Output Without Normalization';
-    description = 'Tool returns unconstrained free text. Consider normalizing output.';
-    check(ctx) {
-        const diagnostics = [];
-        for (const tool of ctx.tools) {
-            for (const output of tool.outputs) {
-                // Check if output is unconstrained string
-                if (output.type !== 'string') {
-                    continue;
-                }
-                const hasEnum = Boolean(output.enum && output.enum.length > 0);
-                const hasPattern = Boolean(output.pattern);
-                const hasDescription = Boolean(output.description && output.description.trim());
-                // If it's a string with no constraints, it's unconstrained free text
-                if (!hasEnum && !hasPattern && !hasDescription) {
-                    diagnostics.push(this.createDiagnostic(`Tool "${tool.name}" returns unconstrained free text (field: "${output.name}"). Consider normalizing output.`, tool.name, output.name, `Add constraints to the output: enum values, regex pattern, or a clear description of the expected format.`));
-                }
-            }
-        }
-        return diagnostics;
-    }
-}
-export const W002FreeTextWithoutNormalization = new W002FreeTextWithoutNormalizationRule();
-//# sourceMappingURL=w002-free-text-without-normalization.js.map

package/dist/runtime/analysis/rules/warnings/w003-missing-examples.d.ts

@@ -1,22 +0,0 @@
-/**
- * W003: Missing Examples for User-Facing Inputs
- *
- * Condition:
- * - Tool takes user-provided input
- * - No examples provided
- *
- * Why:
- * - LLM guessing increases error rate
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class W003MissingExamplesRule extends BaseRule {
-    readonly id = "W003";
-    readonly severity: "warning";
-    readonly ruleName = "Missing Examples for User-Facing Inputs";
-    readonly description = "Tool accepts user-provided input but has no examples. LLM accuracy may be reduced.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const W003MissingExamples: W003MissingExamplesRule;
-export {};
-//# sourceMappingURL=w003-missing-examples.d.ts.map

package/dist/runtime/analysis/rules/warnings/w003-missing-examples.js

@@ -1,84 +0,0 @@
-/**
- * W003: Missing Examples for User-Facing Inputs
- *
- * Condition:
- * - Tool takes user-provided input
- * - No examples provided
- *
- * Why:
- * - LLM guessing increases error rate
- */
-import { BaseRule } from '../base.js';
-import { escapeRegex } from '../../utils.js';
-/**
- * Check if an input field appears to be user-provided.
- * Indicators are treated as plain text (not regex patterns).
- */
-function isUserFacingInput(inputName, description) {
-    const name = inputName.toLowerCase();
-    const desc = (description || '').toLowerCase();
-    // Keywords that suggest user input (treated as plain text, not regex)
-    const userInputIndicators = [
-        'user',
-        'person',
-        'name',
-        'email',
-        'location',
-        'address',
-        'preference',
-        'query',
-        'question',
-        'input',
-        'text',
-        'message',
-    ];
-    // Split into tokens for whole-word matching
-    const nameTokens = name
-        .split(/[^\w]+|(?<=[a-z])(?=[A-Z])/)
-        .filter(t => t.length > 0);
-    const descTokens = desc
-        .split(/[^\w]+|(?<=[a-z])(?=[A-Z])/)
-        .filter(t => t.length > 0);
-    const allTokens = new Set([...nameTokens, ...descTokens]);
-    // Check for whole-word matches using word boundaries
-    // Escape indicators to prevent regex injection
-    return userInputIndicators.some(indicator => {
-        if (allTokens.has(indicator)) {
-            return true;
-        }
-        const escapedIndicator = escapeRegex(indicator);
-        const indicatorRegex = new RegExp(`\\b${escapedIndicator}\\b`, 'i');
-        return indicatorRegex.test(name) || indicatorRegex.test(desc);
-    });
-}
-class W003MissingExamplesRule extends BaseRule {
-    id = 'W003';
-    severity = 'warning';
-    ruleName = 'Missing Examples for User-Facing Inputs';
-    description = 'Tool accepts user-provided input but has no examples. LLM accuracy may be reduced.';
-    check(ctx) {
-        const diagnostics = [];
-        for (const tool of ctx.tools) {
-            for (const input of tool.inputs) {
-                // Only check user-facing inputs
-                if (!isUserFacingInput(input.name, input.description)) {
-                    continue;
-                }
-                // Check if it has an example (treat undefined, empty strings, whitespace-only, and empty arrays/objects as missing)
-                const example = input.example;
-                const isMissing = example === undefined ||
-                    (typeof example === 'string' && example.trim().length === 0) ||
-                    (Array.isArray(example) && example.length === 0) ||
-                    (typeof example === 'object' &&
-                        example !== null &&
-                        Object.keys(example).length === 0);
-                if (isMissing) {
-                    diagnostics.push(this.createDiagnostic(`Tool "${tool.name}" parameter "${input.name}" has no examples. LLM accuracy may be reduced.`, tool.name, input.name, `Add example values to "${input.name}" to help the LLM understand the expected format.`));
-                }
-            }
-        }
-        return diagnostics;
-    }
-}
-export const W003MissingExamples = new W003MissingExamplesRule();
-//# sourceMappingURL=w003-missing-examples.js.map

package/dist/runtime/analysis/rules/warnings/w004-overloaded-responsibility.d.ts

@@ -1,23 +0,0 @@
-/**
- * W004: Overloaded Tool Responsibility
- *
- * Condition:
- * - Tool does multiple conceptual things
- * - Description contains multiple verbs or intents
- *
- * Why:
- * - Tool selection becomes unstable
- * - Hard to compose
- */
-import { BaseRule } from '../base.js';
-import type { AnalysisContext, Diagnostic } from '../../types.js';
-declare class W004OverloadedResponsibilityRule extends BaseRule {
-    readonly id = "W004";
-    readonly severity: "warning";
-    readonly ruleName = "Overloaded Tool Responsibility";
-    readonly description = "Tool appears to handle multiple responsibilities. Tool selection becomes unstable.";
-    check(ctx: AnalysisContext): Diagnostic[];
-}
-export declare const W004OverloadedResponsibility: W004OverloadedResponsibilityRule;
-export {};
-//# sourceMappingURL=w004-overloaded-responsibility.d.ts.map