driftdetect-detectors 0.1.0

package/dist/types/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Types Detectors - Type pattern detection
+ *
+ * Exports all type-related detectors for detecting TypeScript type patterns.
+ *
+ * @requirements 18.1-18.7 - Type pattern detection
+ */
+export { FileLocationDetector, createFileLocationDetector, analyzeFileLocation, shouldExcludeFile as shouldExcludeFileLocation, isTypeFile, detectCentralizedTypes, detectCoLocatedTypes, detectBarrelExports, detectTypeOnlyModule, detectDeclarationFile, detectSharedTypes, detectDomainTypes, detectScatteredTypesViolations, detectInconsistentLocationViolations, CENTRALIZED_TYPES_PATTERNS, CO_LOCATED_TYPES_PATTERNS, BARREL_EXPORT_PATTERNS, TYPE_ONLY_MODULE_PATTERNS, DECLARATION_FILE_PATTERNS, SHARED_TYPES_PATTERNS, DOMAIN_TYPES_PATTERNS, } from './file-location.js';
+export type { FileLocationPatternType, FileLocationViolationType, FileLocationPatternInfo, FileLocationViolationInfo, FileLocationAnalysis, } from './file-location.js';
+export { NamingConventionsDetector, createNamingConventionsDetector, analyzeNamingConventions, shouldExcludeFile as shouldExcludeNamingConventions, detectPascalCaseTypes, detectPascalCaseInterfaces, detectIPrefixInterfaces, detectTPrefixTypes, detectPropsSuffix, detectStateSuffix, detectConfigSuffix, detectEnumPascalCase, detectGenericSingleLetter, detectNonPascalCaseViolations, detectHungarianNotationViolations, detectUnclearGenericViolations, PASCAL_CASE_TYPE_PATTERNS, PASCAL_CASE_INTERFACE_PATTERNS, I_PREFIX_INTERFACE_PATTERNS, T_PREFIX_TYPE_PATTERNS, } from './naming-conventions.js';
+export type { NamingConventionPatternType, NamingConventionViolationType, NamingConventionPatternInfo, NamingConventionViolationInfo, NamingConventionAnalysis, } from './naming-conventions.js';
+export { InterfaceVsTypeDetector, createInterfaceVsTypeDetector, analyzeInterfaceVsType, shouldExcludeFile as shouldExcludeInterfaceVsType, detectInterfaceObject, detectInterfaceExtends, detectInterfaceImplements, detectTypeUnion, detectTypeIntersection, detectTypeMapped, detectTypeConditional, detectTypeUtility, detectDeclarationMerging, detectTypeForObjectViolations, detectUnnecessaryTypeAliasViolations, INTERFACE_OBJECT_PATTERNS, INTERFACE_EXTENDS_PATTERNS, TYPE_UNION_PATTERNS, TYPE_INTERSECTION_PATTERNS, TYPE_MAPPED_PATTERNS, TYPE_CONDITIONAL_PATTERNS, TYPE_UTILITY_PATTERNS, } from './interface-vs-type.js';
+export type { InterfaceVsTypePatternType, InterfaceVsTypeViolationType, InterfaceVsTypePatternInfo, InterfaceVsTypeViolationInfo, InterfaceVsTypeAnalysis, } from './interface-vs-type.js';
+export { GenericPatternsDetector, createGenericPatternsDetector, analyzeGenericPatterns, shouldExcludeFile as shouldExcludeGenericPatterns, detectGenericFunctions, detectGenericArrowFunctions, detectGenericClasses, detectGenericInterfaces, detectGenericTypeAliases, detectConstrainedGenerics, detectDefaultGenerics, detectMultipleTypeParams, detectGenericMethods, detectInferKeyword, detectKeyofConstraint, detectMappedGenerics, detectConditionalGenerics, detectOverlyComplexGenerics, detectUnclearGenericNames, detectTooManyTypeParams, GENERIC_FUNCTION_PATTERNS, GENERIC_ARROW_FUNCTION_PATTERNS, GENERIC_CLASS_PATTERNS, GENERIC_INTERFACE_PATTERNS, GENERIC_TYPE_ALIAS_PATTERNS, CONSTRAINED_GENERIC_PATTERNS, DEFAULT_GENERIC_PATTERNS, MULTIPLE_TYPE_PARAMS_PATTERNS, } from './generic-patterns.js';
+export type { GenericPatternType, GenericViolationType, GenericPatternInfo, GenericViolationInfo, GenericPatternsAnalysis, } from './generic-patterns.js';
+export { UtilityTypesDetector, createUtilityTypesDetector, analyzeUtilityTypes, shouldExcludeFile as shouldExcludeUtilityTypes, detectPartial, detectRequired, detectReadonly, detectPick, detectOmit, detectRecord, detectExclude, detectExtract, detectNonNullable, detectReturnType, detectParameters, detectInstanceType, detectAwaited, detectThisType, detectCustomMapped, detectCustomConditional, detectTemplateLiteral, detectRecursiveType, detectBrandedType, detectDeepPartial, detectDeepReadonly, detectRedundantUtilityViolations, detectNestedUtilityViolations, detectComplexUtilityChainViolations, PARTIAL_PATTERNS, REQUIRED_PATTERNS, READONLY_PATTERNS, PICK_PATTERNS, OMIT_PATTERNS, RECORD_PATTERNS, } from './utility-types.js';
+export type { UtilityTypePatternType, UtilityTypeViolationType, UtilityTypePatternInfo, UtilityTypeViolationInfo, UtilityTypesAnalysis, } from './utility-types.js';
+export { TypeAssertionsDetector, createTypeAssertionsDetector, analyzeTypeAssertions, shouldExcludeFile as shouldExcludeTypeAssertions, detectAsAssertions, detectAsConst, detectAsUnknown, detectAsAny, detectAngleBracket, detectNonNullAssertion, detectDefiniteAssignment, detectSatisfies, detectTypeGuardTypeof, detectTypeGuardInstanceof, detectTypeGuardIn, detectTypePredicate, detectAssertionFunction, detectDoubleAssertion, detectUnsafeAsAnyViolations, detectExcessiveNonNullViolations, detectDoubleAssertionViolations, detectUnnecessaryAssertionViolations, AS_ASSERTION_PATTERNS, AS_CONST_PATTERNS, AS_UNKNOWN_PATTERNS, AS_ANY_PATTERNS, NON_NULL_ASSERTION_PATTERNS, SATISFIES_PATTERNS, TYPE_GUARD_TYPEOF_PATTERNS, TYPE_GUARD_INSTANCEOF_PATTERNS, TYPE_PREDICATE_PATTERNS, } from './type-assertions.js';
+export type { TypeAssertionPatternType, TypeAssertionViolationType, TypeAssertionPatternInfo, TypeAssertionViolationInfo, TypeAssertionsAnalysis, } from './type-assertions.js';
+export { AnyUsageDetector, createAnyUsageDetector, analyzeAnyUsage, shouldExcludeFile as shouldExcludeAnyUsage, detectExplicitAnyAnnotation, detectAnyParameter, detectAnyReturnType, detectAnyGeneric, detectAnyArray, detectAnyRecord, detectAnyObject, detectAnyFunction, detectAnyPromise, detectAnyCast, detectUnknownUsage, detectNeverUsage, detectObjectType, detectFunctionType, detectExplicitAnyViolations, detectAnyInPublicApiViolations, detectAnySpreadViolations, detectAnyIndexSignatureViolations, EXPLICIT_ANY_ANNOTATION_PATTERNS, ANY_PARAMETER_PATTERNS, ANY_RETURN_TYPE_PATTERNS, ANY_GENERIC_PATTERNS, ANY_ARRAY_PATTERNS, ANY_RECORD_PATTERNS, UNKNOWN_USAGE_PATTERNS, NEVER_USAGE_PATTERNS, } from './any-usage.js';
+export type { AnyUsagePatternType, AnyUsageViolationType, AnyUsagePatternInfo, AnyUsageViolationInfo, AnyUsageAnalysis, } from './any-usage.js';
+import { FileLocationDetector } from './file-location.js';
+import { NamingConventionsDetector } from './naming-conventions.js';
+import { InterfaceVsTypeDetector } from './interface-vs-type.js';
+import { GenericPatternsDetector } from './generic-patterns.js';
+import { UtilityTypesDetector } from './utility-types.js';
+import { TypeAssertionsDetector } from './type-assertions.js';
+import { AnyUsageDetector } from './any-usage.js';
+export type TypesDetector = FileLocationDetector | NamingConventionsDetector | InterfaceVsTypeDetector | GenericPatternsDetector | UtilityTypesDetector | TypeAssertionsDetector | AnyUsageDetector;
+export declare function createTypesDetectors(): TypesDetector[];
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"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"}

package/dist/types/index.js

@@ -0,0 +1,43 @@
+/**
+ * Types Detectors - Type pattern detection
+ *
+ * Exports all type-related detectors for detecting TypeScript type patterns.
+ *
+ * @requirements 18.1-18.7 - Type pattern detection
+ */
+// File Location Detector
+export { FileLocationDetector, createFileLocationDetector, analyzeFileLocation, shouldExcludeFile as shouldExcludeFileLocation, isTypeFile, detectCentralizedTypes, detectCoLocatedTypes, detectBarrelExports, detectTypeOnlyModule, detectDeclarationFile, detectSharedTypes, detectDomainTypes, detectScatteredTypesViolations, detectInconsistentLocationViolations, CENTRALIZED_TYPES_PATTERNS, CO_LOCATED_TYPES_PATTERNS, BARREL_EXPORT_PATTERNS, TYPE_ONLY_MODULE_PATTERNS, DECLARATION_FILE_PATTERNS, SHARED_TYPES_PATTERNS, DOMAIN_TYPES_PATTERNS, } from './file-location.js';
+// Naming Conventions Detector
+export { NamingConventionsDetector, createNamingConventionsDetector, analyzeNamingConventions, shouldExcludeFile as shouldExcludeNamingConventions, detectPascalCaseTypes, detectPascalCaseInterfaces, detectIPrefixInterfaces, detectTPrefixTypes, detectPropsSuffix, detectStateSuffix, detectConfigSuffix, detectEnumPascalCase, detectGenericSingleLetter, detectNonPascalCaseViolations, detectHungarianNotationViolations, detectUnclearGenericViolations, PASCAL_CASE_TYPE_PATTERNS, PASCAL_CASE_INTERFACE_PATTERNS, I_PREFIX_INTERFACE_PATTERNS, T_PREFIX_TYPE_PATTERNS, } from './naming-conventions.js';
+// Interface vs Type Detector
+export { InterfaceVsTypeDetector, createInterfaceVsTypeDetector, analyzeInterfaceVsType, shouldExcludeFile as shouldExcludeInterfaceVsType, detectInterfaceObject, detectInterfaceExtends, detectInterfaceImplements, detectTypeUnion, detectTypeIntersection, detectTypeMapped, detectTypeConditional, detectTypeUtility, detectDeclarationMerging, detectTypeForObjectViolations, detectUnnecessaryTypeAliasViolations, INTERFACE_OBJECT_PATTERNS, INTERFACE_EXTENDS_PATTERNS, TYPE_UNION_PATTERNS, TYPE_INTERSECTION_PATTERNS, TYPE_MAPPED_PATTERNS, TYPE_CONDITIONAL_PATTERNS, TYPE_UTILITY_PATTERNS, } from './interface-vs-type.js';
+// Generic Patterns Detector
+export { GenericPatternsDetector, createGenericPatternsDetector, analyzeGenericPatterns, shouldExcludeFile as shouldExcludeGenericPatterns, detectGenericFunctions, detectGenericArrowFunctions, detectGenericClasses, detectGenericInterfaces, detectGenericTypeAliases, detectConstrainedGenerics, detectDefaultGenerics, detectMultipleTypeParams, detectGenericMethods, detectInferKeyword, detectKeyofConstraint, detectMappedGenerics, detectConditionalGenerics, detectOverlyComplexGenerics, detectUnclearGenericNames, detectTooManyTypeParams, GENERIC_FUNCTION_PATTERNS, GENERIC_ARROW_FUNCTION_PATTERNS, GENERIC_CLASS_PATTERNS, GENERIC_INTERFACE_PATTERNS, GENERIC_TYPE_ALIAS_PATTERNS, CONSTRAINED_GENERIC_PATTERNS, DEFAULT_GENERIC_PATTERNS, MULTIPLE_TYPE_PARAMS_PATTERNS, } from './generic-patterns.js';
+// Utility Types Detector
+export { UtilityTypesDetector, createUtilityTypesDetector, analyzeUtilityTypes, shouldExcludeFile as shouldExcludeUtilityTypes, detectPartial, detectRequired, detectReadonly, detectPick, detectOmit, detectRecord, detectExclude, detectExtract, detectNonNullable, detectReturnType, detectParameters, detectInstanceType, detectAwaited, detectThisType, detectCustomMapped, detectCustomConditional, detectTemplateLiteral, detectRecursiveType, detectBrandedType, detectDeepPartial, detectDeepReadonly, detectRedundantUtilityViolations, detectNestedUtilityViolations, detectComplexUtilityChainViolations, PARTIAL_PATTERNS, REQUIRED_PATTERNS, READONLY_PATTERNS, PICK_PATTERNS, OMIT_PATTERNS, RECORD_PATTERNS, } from './utility-types.js';
+// Type Assertions Detector
+export { TypeAssertionsDetector, createTypeAssertionsDetector, analyzeTypeAssertions, shouldExcludeFile as shouldExcludeTypeAssertions, detectAsAssertions, detectAsConst, detectAsUnknown, detectAsAny, detectAngleBracket, detectNonNullAssertion, detectDefiniteAssignment, detectSatisfies, detectTypeGuardTypeof, detectTypeGuardInstanceof, detectTypeGuardIn, detectTypePredicate, detectAssertionFunction, detectDoubleAssertion, detectUnsafeAsAnyViolations, detectExcessiveNonNullViolations, detectDoubleAssertionViolations, detectUnnecessaryAssertionViolations, AS_ASSERTION_PATTERNS, AS_CONST_PATTERNS, AS_UNKNOWN_PATTERNS, AS_ANY_PATTERNS, NON_NULL_ASSERTION_PATTERNS, SATISFIES_PATTERNS, TYPE_GUARD_TYPEOF_PATTERNS, TYPE_GUARD_INSTANCEOF_PATTERNS, TYPE_PREDICATE_PATTERNS, } from './type-assertions.js';
+// Any Usage Detector
+export { AnyUsageDetector, createAnyUsageDetector, analyzeAnyUsage, shouldExcludeFile as shouldExcludeAnyUsage, detectExplicitAnyAnnotation, detectAnyParameter, detectAnyReturnType, detectAnyGeneric, detectAnyArray, detectAnyRecord, detectAnyObject, detectAnyFunction, detectAnyPromise, detectAnyCast, detectUnknownUsage, detectNeverUsage, detectObjectType, detectFunctionType, detectExplicitAnyViolations, detectAnyInPublicApiViolations, detectAnySpreadViolations, detectAnyIndexSignatureViolations, EXPLICIT_ANY_ANNOTATION_PATTERNS, ANY_PARAMETER_PATTERNS, ANY_RETURN_TYPE_PATTERNS, ANY_GENERIC_PATTERNS, ANY_ARRAY_PATTERNS, ANY_RECORD_PATTERNS, UNKNOWN_USAGE_PATTERNS, NEVER_USAGE_PATTERNS, } from './any-usage.js';
+// ============================================================================
+// Factory Function
+// ============================================================================
+import { FileLocationDetector } from './file-location.js';
+import { NamingConventionsDetector } from './naming-conventions.js';
+import { InterfaceVsTypeDetector } from './interface-vs-type.js';
+import { GenericPatternsDetector } from './generic-patterns.js';
+import { UtilityTypesDetector } from './utility-types.js';
+import { TypeAssertionsDetector } from './type-assertions.js';
+import { AnyUsageDetector } from './any-usage.js';
+export function createTypesDetectors() {
+    return [
+        new FileLocationDetector(),
+        new NamingConventionsDetector(),
+        new InterfaceVsTypeDetector(),
+        new GenericPatternsDetector(),
+        new UtilityTypesDetector(),
+        new TypeAssertionsDetector(),
+        new AnyUsageDetector(),
+    ];
+}
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"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"}

package/dist/types/interface-vs-type.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Interface vs Type Detector - Interface vs type alias pattern detection
+ *
+ * Detects patterns for when to use interface vs type including:
+ * - Object shape definitions
+ * - Union and intersection types
+ * - Extending/implementing patterns
+ * - Declaration merging
+ * - Mapped types
+ *
+ * @requirements 18.3 - Interface vs type patterns
+ */
+import type { Violation, QuickFix, PatternCategory, Language } from 'driftdetect-core';
+import { RegexDetector } from '../base/regex-detector.js';
+import type { DetectionContext, DetectionResult } from '../base/base-detector.js';
+export type InterfaceVsTypePatternType = 'interface-object' | 'interface-extends' | 'interface-implements' | 'type-union' | 'type-intersection' | 'type-mapped' | 'type-conditional' | 'type-utility' | 'declaration-merging';
+export type InterfaceVsTypeViolationType = 'type-for-object' | 'interface-for-union' | 'inconsistent-usage' | 'unnecessary-type-alias';
+export interface InterfaceVsTypePatternInfo {
+    type: InterfaceVsTypePatternType;
+    file: string;
+    line: number;
+    column: number;
+    matchedText: string;
+    name?: string | undefined;
+    context?: string | undefined;
+}
+export interface InterfaceVsTypeViolationInfo {
+    type: InterfaceVsTypeViolationType;
+    file: string;
+    line: number;
+    column: number;
+    matchedText: string;
+    issue: string;
+    suggestedFix?: string | undefined;
+    severity: 'high' | 'medium' | 'low';
+}
+export interface InterfaceVsTypeAnalysis {
+    patterns: InterfaceVsTypePatternInfo[];
+    violations: InterfaceVsTypeViolationInfo[];
+    interfaceCount: number;
+    typeCount: number;
+    prefersInterfaces: boolean;
+    confidence: number;
+}
+export declare const INTERFACE_OBJECT_PATTERNS: readonly [RegExp, RegExp];
+export declare const INTERFACE_EXTENDS_PATTERNS: readonly [RegExp, RegExp, RegExp];
+export declare const INTERFACE_IMPLEMENTS_PATTERNS: readonly [RegExp, RegExp];
+export declare const TYPE_UNION_PATTERNS: readonly [RegExp, RegExp];
+export declare const TYPE_INTERSECTION_PATTERNS: readonly [RegExp, RegExp];
+export declare const TYPE_MAPPED_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp];
+export declare const TYPE_CONDITIONAL_PATTERNS: readonly [RegExp, RegExp, RegExp];
+export declare const TYPE_UTILITY_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp];
+export declare const DECLARATION_MERGING_PATTERNS: readonly [RegExp, RegExp];
+export declare const TYPE_FOR_OBJECT_PATTERNS: readonly [RegExp];
+export declare const INTERFACE_FOR_UNION_PATTERNS: readonly [];
+export declare const UNNECESSARY_TYPE_ALIAS_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp];
+export declare function shouldExcludeFile(filePath: string): boolean;
+export declare function detectInterfaceObject(content: string, filePath: string): InterfaceVsTypePatternInfo[];
+export declare function detectInterfaceExtends(content: string, filePath: string): InterfaceVsTypePatternInfo[];
+export declare function detectInterfaceImplements(content: string, filePath: string): InterfaceVsTypePatternInfo[];
+export declare function detectTypeUnion(content: string, filePath: string): InterfaceVsTypePatternInfo[];
+export declare function detectTypeIntersection(content: string, filePath: string): InterfaceVsTypePatternInfo[];
+export declare function detectTypeMapped(content: string, filePath: string): InterfaceVsTypePatternInfo[];
+export declare function detectTypeConditional(content: string, filePath: string): InterfaceVsTypePatternInfo[];
+export declare function detectTypeUtility(content: string, filePath: string): InterfaceVsTypePatternInfo[];
+export declare function detectDeclarationMerging(content: string, filePath: string): InterfaceVsTypePatternInfo[];
+export declare function detectTypeForObjectViolations(content: string, filePath: string): InterfaceVsTypeViolationInfo[];
+export declare function detectUnnecessaryTypeAliasViolations(content: string, filePath: string): InterfaceVsTypeViolationInfo[];
+export declare function analyzeInterfaceVsType(content: string, filePath: string): InterfaceVsTypeAnalysis;
+export declare class InterfaceVsTypeDetector extends RegexDetector {
+    readonly id = "types/interface-vs-type";
+    readonly name = "Interface vs Type Detector";
+    readonly description = "Detects interface vs type alias usage patterns";
+    readonly category: PatternCategory;
+    readonly subcategory = "interface-vs-type";
+    readonly supportedLanguages: Language[];
+    detect(context: DetectionContext): Promise<DetectionResult>;
+    generateQuickFix(_violation: Violation): QuickFix | null;
+}
+export declare function createInterfaceVsTypeDetector(): InterfaceVsTypeDetector;
+//# sourceMappingURL=interface-vs-type.d.ts.map

package/dist/types/interface-vs-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface-vs-type.d.ts","sourceRoot":"","sources":["../../src/types/interface-vs-type.ts"],"names":[],"mappings":"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"}

package/dist/types/interface-vs-type.js

@@ -0,0 +1,440 @@
+/**
+ * Interface vs Type Detector - Interface vs type alias pattern detection
+ *
+ * Detects patterns for when to use interface vs type including:
+ * - Object shape definitions
+ * - Union and intersection types
+ * - Extending/implementing patterns
+ * - Declaration merging
+ * - Mapped types
+ *
+ * @requirements 18.3 - Interface vs type patterns
+ */
+import { RegexDetector } from '../base/regex-detector.js';
+// ============================================================================
+// Constants
+// ============================================================================
+export const INTERFACE_OBJECT_PATTERNS = [
+    /interface\s+(\w+)\s*\{/g,
+    /interface\s+(\w+)\s*<[^>]+>\s*\{/g,
+];
+export const INTERFACE_EXTENDS_PATTERNS = [
+    /interface\s+(\w+)\s+extends\s+\w+/g,
+    /interface\s+(\w+)\s*<[^>]+>\s+extends\s+\w+/g,
+    /interface\s+(\w+)\s+extends\s+\w+(?:\s*,\s*\w+)+/g,
+];
+export const INTERFACE_IMPLEMENTS_PATTERNS = [
+    /class\s+\w+\s+implements\s+(\w+)/g,
+    /class\s+\w+\s+extends\s+\w+\s+implements\s+(\w+)/g,
+];
+export const TYPE_UNION_PATTERNS = [
+    /type\s+(\w+)\s*=\s*[^|]+\s*\|/g,
+    /type\s+(\w+)\s*=\s*\|/g,
+];
+export const TYPE_INTERSECTION_PATTERNS = [
+    /type\s+(\w+)\s*=\s*[^&]+\s*&/g,
+    /type\s+(\w+)\s*=\s*\w+\s*&\s*\w+/g,
+];
+export const TYPE_MAPPED_PATTERNS = [
+    /type\s+(\w+)\s*=\s*\{\s*\[/g,
+    /type\s+(\w+)\s*<[^>]+>\s*=\s*\{\s*\[/g,
+    /\[\s*\w+\s+in\s+keyof\s+\w+\s*\]/g,
+    /\[\s*\w+\s+in\s+\w+\s*\]/g,
+];
+export const TYPE_CONDITIONAL_PATTERNS = [
+    /type\s+(\w+)\s*=\s*[^?]+\s+extends\s+[^?]+\s*\?/g,
+    /type\s+(\w+)\s*<[^>]+>\s*=\s*\w+\s+extends\s+\w+\s*\?/g,
+    /\w+\s+extends\s+\w+\s*\?\s*\w+\s*:\s*\w+/g,
+];
+export const TYPE_UTILITY_PATTERNS = [
+    /type\s+(\w+)\s*=\s*Partial</g,
+    /type\s+(\w+)\s*=\s*Required</g,
+    /type\s+(\w+)\s*=\s*Readonly</g,
+    /type\s+(\w+)\s*=\s*Pick</g,
+    /type\s+(\w+)\s*=\s*Omit</g,
+    /type\s+(\w+)\s*=\s*Record</g,
+    /type\s+(\w+)\s*=\s*Exclude</g,
+    /type\s+(\w+)\s*=\s*Extract</g,
+    /type\s+(\w+)\s*=\s*NonNullable</g,
+    /type\s+(\w+)\s*=\s*ReturnType</g,
+    /type\s+(\w+)\s*=\s*Parameters</g,
+    /type\s+(\w+)\s*=\s*InstanceType</g,
+    /type\s+(\w+)\s*=\s*Awaited</g,
+];
+export const DECLARATION_MERGING_PATTERNS = [
+    /interface\s+(\w+)\s*\{[\s\S]*?\}\s*interface\s+\1\s*\{/g,
+    /declare\s+module\s+['"`]\w+['"`]\s*\{[\s\S]*?interface\s+\w+/g,
+];
+export const TYPE_FOR_OBJECT_PATTERNS = [
+    /type\s+(\w+)\s*=\s*\{\s*\w+\s*:/g, // Simple object type
+];
+export const INTERFACE_FOR_UNION_PATTERNS = [
+// This is actually not possible in TypeScript, but we detect attempts
+];
+export const UNNECESSARY_TYPE_ALIAS_PATTERNS = [
+    /type\s+(\w+)\s*=\s*string\s*;/g,
+    /type\s+(\w+)\s*=\s*number\s*;/g,
+    /type\s+(\w+)\s*=\s*boolean\s*;/g,
+    /type\s+(\w+)\s*=\s*null\s*;/g,
+    /type\s+(\w+)\s*=\s*undefined\s*;/g,
+];
+// ============================================================================
+// Analysis Functions
+// ============================================================================
+export function shouldExcludeFile(filePath) {
+    const excludePatterns = [
+        /\.test\.[jt]sx?$/,
+        /\.spec\.[jt]sx?$/,
+        /__tests__\//,
+        /node_modules\//,
+        /\.min\.[jt]s$/,
+    ];
+    return excludePatterns.some((p) => p.test(filePath));
+}
+export function detectInterfaceObject(content, filePath) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of INTERFACE_OBJECT_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                results.push({
+                    type: 'interface-object',
+                    file: filePath,
+                    line: i + 1,
+                    column: match.index + 1,
+                    matchedText: match[0],
+                    name: match[1],
+                    context: line.trim(),
+                });
+            }
+        }
+    }
+    return results;
+}
+export function detectInterfaceExtends(content, filePath) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of INTERFACE_EXTENDS_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                results.push({
+                    type: 'interface-extends',
+                    file: filePath,
+                    line: i + 1,
+                    column: match.index + 1,
+                    matchedText: match[0],
+                    name: match[1],
+                    context: line.trim(),
+                });
+            }
+        }
+    }
+    return results;
+}
+export function detectInterfaceImplements(content, filePath) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of INTERFACE_IMPLEMENTS_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                results.push({
+                    type: 'interface-implements',
+                    file: filePath,
+                    line: i + 1,
+                    column: match.index + 1,
+                    matchedText: match[0],
+                    name: match[1],
+                    context: line.trim(),
+                });
+            }
+        }
+    }
+    return results;
+}
+export function detectTypeUnion(content, filePath) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of TYPE_UNION_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                results.push({
+                    type: 'type-union',
+                    file: filePath,
+                    line: i + 1,
+                    column: match.index + 1,
+                    matchedText: match[0],
+                    name: match[1],
+                    context: line.trim(),
+                });
+            }
+        }
+    }
+    return results;
+}
+export function detectTypeIntersection(content, filePath) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of TYPE_INTERSECTION_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                results.push({
+                    type: 'type-intersection',
+                    file: filePath,
+                    line: i + 1,
+                    column: match.index + 1,
+                    matchedText: match[0],
+                    name: match[1],
+                    context: line.trim(),
+                });
+            }
+        }
+    }
+    return results;
+}
+export function detectTypeMapped(content, filePath) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of TYPE_MAPPED_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                results.push({
+                    type: 'type-mapped',
+                    file: filePath,
+                    line: i + 1,
+                    column: match.index + 1,
+                    matchedText: match[0],
+                    name: match[1],
+                    context: line.trim(),
+                });
+            }
+        }
+    }
+    return results;
+}
+export function detectTypeConditional(content, filePath) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of TYPE_CONDITIONAL_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                results.push({
+                    type: 'type-conditional',
+                    file: filePath,
+                    line: i + 1,
+                    column: match.index + 1,
+                    matchedText: match[0],
+                    name: match[1],
+                    context: line.trim(),
+                });
+            }
+        }
+    }
+    return results;
+}
+export function detectTypeUtility(content, filePath) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of TYPE_UTILITY_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                results.push({
+                    type: 'type-utility',
+                    file: filePath,
+                    line: i + 1,
+                    column: match.index + 1,
+                    matchedText: match[0],
+                    name: match[1],
+                    context: line.trim(),
+                });
+            }
+        }
+    }
+    return results;
+}
+export function detectDeclarationMerging(content, filePath) {
+    const results = [];
+    // Check for multiple interfaces with same name
+    const interfaceNames = new Map();
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const match = line.match(/interface\s+(\w+)\s*(?:<[^>]+>)?\s*(?:extends|{)/);
+        if (match) {
+            const name = match[1];
+            if (!interfaceNames.has(name)) {
+                interfaceNames.set(name, []);
+            }
+            interfaceNames.get(name).push(i + 1);
+        }
+    }
+    for (const [name, lineNumbers] of interfaceNames) {
+        if (lineNumbers.length > 1) {
+            results.push({
+                type: 'declaration-merging',
+                file: filePath,
+                line: lineNumbers[0],
+                column: 1,
+                matchedText: `interface ${name}`,
+                name,
+                context: `Declared ${lineNumbers.length} times at lines: ${lineNumbers.join(', ')}`,
+            });
+        }
+    }
+    return results;
+}
+export function detectTypeForObjectViolations(content, filePath) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of TYPE_FOR_OBJECT_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                // Check if it's a simple object (not union, intersection, mapped, etc.)
+                const fullLine = line + (lines[i + 1] || '');
+                if (!/[|&\[]/.test(fullLine.slice(match.index))) {
+                    results.push({
+                        type: 'type-for-object',
+                        file: filePath,
+                        line: i + 1,
+                        column: match.index + 1,
+                        matchedText: match[0],
+                        issue: 'Consider using interface for object shapes',
+                        suggestedFix: 'Use interface instead of type for better extensibility',
+                        severity: 'low',
+                    });
+                }
+            }
+        }
+    }
+    return results;
+}
+export function detectUnnecessaryTypeAliasViolations(content, filePath) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of UNNECESSARY_TYPE_ALIAS_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                results.push({
+                    type: 'unnecessary-type-alias',
+                    file: filePath,
+                    line: i + 1,
+                    column: match.index + 1,
+                    matchedText: match[0],
+                    issue: 'Unnecessary type alias for primitive type',
+                    suggestedFix: 'Use the primitive type directly or add semantic meaning',
+                    severity: 'low',
+                });
+            }
+        }
+    }
+    return results;
+}
+export function analyzeInterfaceVsType(content, filePath) {
+    if (shouldExcludeFile(filePath)) {
+        return {
+            patterns: [],
+            violations: [],
+            interfaceCount: 0,
+            typeCount: 0,
+            prefersInterfaces: false,
+            confidence: 1.0,
+        };
+    }
+    const patterns = [
+        ...detectInterfaceObject(content, filePath),
+        ...detectInterfaceExtends(content, filePath),
+        ...detectInterfaceImplements(content, filePath),
+        ...detectTypeUnion(content, filePath),
+        ...detectTypeIntersection(content, filePath),
+        ...detectTypeMapped(content, filePath),
+        ...detectTypeConditional(content, filePath),
+        ...detectTypeUtility(content, filePath),
+        ...detectDeclarationMerging(content, filePath),
+    ];
+    const violations = [
+        ...detectTypeForObjectViolations(content, filePath),
+        ...detectUnnecessaryTypeAliasViolations(content, filePath),
+    ];
+    const interfaceCount = patterns.filter((p) => p.type.startsWith('interface-')).length;
+    const typeCount = patterns.filter((p) => p.type.startsWith('type-')).length;
+    const prefersInterfaces = interfaceCount > typeCount;
+    let confidence = 0.7;
+    if (patterns.length > 0)
+        confidence += 0.15;
+    if (violations.length === 0)
+        confidence += 0.1;
+    confidence = Math.min(confidence, 0.95);
+    return {
+        patterns,
+        violations,
+        interfaceCount,
+        typeCount,
+        prefersInterfaces,
+        confidence,
+    };
+}
+// ============================================================================
+// Detector Class
+// ============================================================================
+export class InterfaceVsTypeDetector extends RegexDetector {
+    id = 'types/interface-vs-type';
+    name = 'Interface vs Type Detector';
+    description = 'Detects interface vs type alias usage patterns';
+    category = 'types';
+    subcategory = 'interface-vs-type';
+    supportedLanguages = ['typescript'];
+    async detect(context) {
+        if (!this.supportsLanguage(context.language)) {
+            return this.createEmptyResult();
+        }
+        const analysis = analyzeInterfaceVsType(context.content, context.file);
+        if (analysis.patterns.length === 0 && analysis.violations.length === 0) {
+            return this.createEmptyResult();
+        }
+        return this.createResult([], [], analysis.confidence, {
+            custom: {
+                patterns: analysis.patterns,
+                violations: analysis.violations,
+                interfaceCount: analysis.interfaceCount,
+                typeCount: analysis.typeCount,
+                prefersInterfaces: analysis.prefersInterfaces,
+            },
+        });
+    }
+    generateQuickFix(_violation) {
+        return null;
+    }
+}
+export function createInterfaceVsTypeDetector() {
+    return new InterfaceVsTypeDetector();
+}
+//# sourceMappingURL=interface-vs-type.js.map