driftdetect-core 0.1.3 → 0.4.0

package/dist/parsers/tree-sitter/tree-sitter-python-parser.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Tree-sitter Python Parser
+ *
+ * Main parser implementation using tree-sitter for Python parsing.
+ * Implements the BaseParser interface and provides enhanced AST
+ * extraction with Pydantic model support.
+ *
+ * @requirements 3.5 - Unified AST query interface
+ */
+import { BaseParser } from '../base-parser.js';
+import type { AST, ASTNode, Language, ParseResult } from '../types.js';
+import type { TreeSitterTree, PydanticModelInfo } from './types.js';
+import type { PythonParserConfig } from './config.js';
+/**
+ * Extended parse result with tree-sitter specific information.
+ */
+export interface TreeSitterPythonParseResult extends ParseResult {
+    /** The raw tree-sitter tree (if available) */
+    treeSitterTree: TreeSitterTree | null;
+    /** Whether tree-sitter was used for parsing */
+    usedTreeSitter: boolean;
+    /** Extracted Pydantic models (if enabled) */
+    pydanticModels: PydanticModelInfo[];
+}
+/**
+ * Tree-sitter based Python parser.
+ *
+ * Provides AST parsing using tree-sitter with fallback to regex-based
+ * parsing when tree-sitter is not available.
+ */
+export declare class TreeSitterPythonParser extends BaseParser {
+    readonly language: Language;
+    readonly extensions: string[];
+    private readonly config;
+    private readonly converter;
+    private readonly pydanticExtractor;
+    private parser;
+    /**
+     * Create a new TreeSitterPythonParser.
+     *
+     * @param config - Parser configuration options
+     */
+    constructor(config?: Partial<PythonParserConfig>);
+    /**
+     * Check if tree-sitter is available for Python parsing.
+     *
+     * @returns true if tree-sitter and tree-sitter-python are available
+     */
+    static isAvailable(): boolean;
+    /**
+     * Parse Python source code into an AST.
+     *
+     * @param source - The source code to parse
+     * @param filePath - Optional file path for error reporting
+     * @returns TreeSitterPythonParseResult containing the AST
+     */
+    parse(source: string, filePath?: string): TreeSitterPythonParseResult;
+    /**
+     * Query the AST for nodes matching a pattern.
+     *
+     * Supports tree-sitter query syntax when tree-sitter is available,
+     * otherwise falls back to simple node type matching.
+     *
+     * @param ast - The AST to query
+     * @param pattern - The query pattern (tree-sitter query or node type)
+     * @returns Array of matching AST nodes
+     */
+    query(ast: AST, pattern: string): ASTNode[];
+    /**
+     * Create a fallback result when tree-sitter is not available.
+     */
+    private createFallbackResult;
+    /**
+     * Extract Pydantic models from a tree-sitter tree.
+     */
+    private extractPydanticModelsFromTree;
+    /**
+     * Execute a tree-sitter query on the AST.
+     */
+    private executeTreeSitterQuery;
+    /**
+     * Extract a simple node type from a tree-sitter query pattern.
+     */
+    private extractNodeTypeFromQuery;
+}
+//# sourceMappingURL=tree-sitter-python-parser.d.ts.map

package/dist/parsers/tree-sitter/tree-sitter-python-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-sitter-python-parser.d.ts","sourceRoot":"","sources":["../../../src/parsers/tree-sitter/tree-sitter-python-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACvE,OAAO,KAAK,EAEV,cAAc,EACd,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAGpB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAQtD;;GAEG;AACH,MAAM,WAAW,2BAA4B,SAAQ,WAAW;IAC9D,8CAA8C;IAC9C,cAAc,EAAE,cAAc,GAAG,IAAI,CAAC;IACtC,+CAA+C;IAC/C,cAAc,EAAE,OAAO,CAAC;IACxB,6CAA6C;IAC7C,cAAc,EAAE,iBAAiB,EAAE,CAAC;CACrC;AAMD;;;;;GAKG;AACH,qBAAa,sBAAuB,SAAQ,UAAU;IACpD,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAY;IACvC,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,CAA2B;IAExD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAC5C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqB;IAC/C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAoB;IACtD,OAAO,CAAC,MAAM,CAAiC;IAE/C;;;;OAIG;gBACS,MAAM,GAAE,OAAO,CAAC,kBAAkB,CAAM;IAWpD;;;;OAIG;IACH,MAAM,CAAC,WAAW,IAAI,OAAO;IAI7B;;;;;;OAMG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,2BAA2B;IAqDrE;;;;;;;;;OASG;IACH,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,EAAE;IAoB3C;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAyB5B;;OAEG;IACH,OAAO,CAAC,6BAA6B;IAOrC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAM9B;;OAEG;IACH,OAAO,CAAC,wBAAwB;CAMjC"}

package/dist/parsers/tree-sitter/tree-sitter-python-parser.js

@@ -0,0 +1,177 @@
+/**
+ * Tree-sitter Python Parser
+ *
+ * Main parser implementation using tree-sitter for Python parsing.
+ * Implements the BaseParser interface and provides enhanced AST
+ * extraction with Pydantic model support.
+ *
+ * @requirements 3.5 - Unified AST query interface
+ */
+import { BaseParser } from '../base-parser.js';
+import { PythonASTConverter } from './python-ast-converter.js';
+import { isTreeSitterAvailable, createPythonParser } from './loader.js';
+import { mergeConfig } from './config.js';
+import { PydanticExtractor } from './pydantic/pydantic-extractor.js';
+// ============================================
+// Main Parser Class
+// ============================================
+/**
+ * Tree-sitter based Python parser.
+ *
+ * Provides AST parsing using tree-sitter with fallback to regex-based
+ * parsing when tree-sitter is not available.
+ */
+export class TreeSitterPythonParser extends BaseParser {
+    language = 'python';
+    extensions = ['.py', '.pyw', '.pyi'];
+    config;
+    converter;
+    pydanticExtractor;
+    parser = null;
+    /**
+     * Create a new TreeSitterPythonParser.
+     *
+     * @param config - Parser configuration options
+     */
+    constructor(config = {}) {
+        super();
+        this.config = mergeConfig(config);
+        this.converter = new PythonASTConverter({
+            includeComments: this.config.includeComments,
+            includeAnonymous: this.config.includeAnonymous,
+            maxDepth: 0, // No limit
+        });
+        this.pydanticExtractor = new PydanticExtractor();
+    }
+    /**
+     * Check if tree-sitter is available for Python parsing.
+     *
+     * @returns true if tree-sitter and tree-sitter-python are available
+     */
+    static isAvailable() {
+        return isTreeSitterAvailable();
+    }
+    /**
+     * Parse Python source code into an AST.
+     *
+     * @param source - The source code to parse
+     * @param filePath - Optional file path for error reporting
+     * @returns TreeSitterPythonParseResult containing the AST
+     */
+    parse(source, filePath) {
+        // Check if tree-sitter should be used
+        if (!this.config.useTreeSitter || !isTreeSitterAvailable()) {
+            return this.createFallbackResult(source, filePath);
+        }
+        try {
+            // Initialize parser if needed
+            if (!this.parser) {
+                this.parser = createPythonParser();
+            }
+            // Set timeout if configured
+            if (this.config.parseTimeout > 0) {
+                this.parser.setTimeoutMicros(this.config.parseTimeout * 1000);
+            }
+            // Parse the source
+            const tree = this.parser.parse(source);
+            // Check for parse errors
+            const hasErrors = tree.rootNode.hasError;
+            // Convert to drift AST
+            const ast = this.converter.convertTree(tree, source);
+            // Extract Pydantic models if enabled
+            const pydanticModels = this.config.extractPydanticModels
+                ? this.extractPydanticModelsFromTree(tree, source)
+                : [];
+            return {
+                ast,
+                language: this.language,
+                errors: hasErrors ? [this.createError('Parse errors detected', { row: 0, column: 0 })] : [],
+                success: true,
+                treeSitterTree: tree,
+                usedTreeSitter: true,
+                pydanticModels,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown parse error';
+            return {
+                ...this.createFailureResult([
+                    this.createError(`Tree-sitter parse error: ${errorMessage}`, { row: 0, column: 0 }),
+                ]),
+                treeSitterTree: null,
+                usedTreeSitter: true,
+                pydanticModels: [],
+            };
+        }
+    }
+    /**
+     * Query the AST for nodes matching a pattern.
+     *
+     * Supports tree-sitter query syntax when tree-sitter is available,
+     * otherwise falls back to simple node type matching.
+     *
+     * @param ast - The AST to query
+     * @param pattern - The query pattern (tree-sitter query or node type)
+     * @returns Array of matching AST nodes
+     */
+    query(ast, pattern) {
+        // Simple node type query (works without tree-sitter)
+        if (!pattern.includes('(') && !pattern.includes('@')) {
+            return this.findNodesByType(ast, pattern);
+        }
+        // Tree-sitter query syntax requires tree-sitter
+        if (!isTreeSitterAvailable()) {
+            // Fall back to simple type matching
+            return this.findNodesByType(ast, this.extractNodeTypeFromQuery(pattern));
+        }
+        // Execute tree-sitter query
+        return this.executeTreeSitterQuery(ast, pattern);
+    }
+    // ============================================
+    // Private Methods
+    // ============================================
+    /**
+     * Create a fallback result when tree-sitter is not available.
+     */
+    createFallbackResult(source, _filePath) {
+        // Create a minimal AST structure
+        const lines = source.split('\n');
+        const endPosition = lines.length > 0
+            ? { row: lines.length - 1, column: lines[lines.length - 1]?.length ?? 0 }
+            : { row: 0, column: 0 };
+        const rootNode = this.createNode('Module', source, { row: 0, column: 0 }, endPosition, []);
+        const ast = this.createAST(rootNode, source);
+        return {
+            ...this.createSuccessResult(ast),
+            treeSitterTree: null,
+            usedTreeSitter: false,
+            pydanticModels: [],
+        };
+    }
+    /**
+     * Extract Pydantic models from a tree-sitter tree.
+     */
+    extractPydanticModelsFromTree(tree, source) {
+        return this.pydanticExtractor.extractModels(tree, source, {
+            maxTypeDepth: this.config.maxTypeDepth,
+            includePositions: this.config.includePositions,
+        });
+    }
+    /**
+     * Execute a tree-sitter query on the AST.
+     */
+    executeTreeSitterQuery(ast, pattern) {
+        // This requires access to the original tree-sitter tree
+        // For now, fall back to simple matching
+        return this.findNodesByType(ast, this.extractNodeTypeFromQuery(pattern));
+    }
+    /**
+     * Extract a simple node type from a tree-sitter query pattern.
+     */
+    extractNodeTypeFromQuery(pattern) {
+        // Extract the first node type from patterns like "(class_definition ...)"
+        const match = pattern.match(/\((\w+)/);
+        return match?.[1] ?? pattern;
+    }
+}
+//# sourceMappingURL=tree-sitter-python-parser.js.map

package/dist/parsers/tree-sitter/tree-sitter-python-parser.js.map

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

package/dist/parsers/tree-sitter/types.d.ts

@@ -0,0 +1,399 @@
+/**
+ * Tree-sitter Type Definitions
+ *
+ * TypeScript types for tree-sitter integration, including
+ * tree-sitter core types and Pydantic-specific types for
+ * Python model extraction.
+ *
+ * @requirements 3.5 - Unified AST query interface
+ */
+import type { Position } from '../types.js';
+/**
+ * Represents a tree-sitter syntax node.
+ * This mirrors the tree-sitter Node interface.
+ */
+export interface TreeSitterNode {
+    /** The type of the node (e.g., 'function_definition', 'class_definition') */
+    type: string;
+    /** The text content of the node */
+    text: string;
+    /** Start position in the source */
+    startPosition: TreeSitterPoint;
+    /** End position in the source */
+    endPosition: TreeSitterPoint;
+    /** Start byte offset in the source */
+    startIndex: number;
+    /** End byte offset in the source */
+    endIndex: number;
+    /** Whether this is a named node (vs anonymous) */
+    isNamed: boolean;
+    /** Whether this node has any errors */
+    hasError: boolean;
+    /** Whether this node is missing (error recovery) */
+    isMissing: boolean;
+    /** Child nodes */
+    children: TreeSitterNode[];
+    /** Named child nodes only */
+    namedChildren: TreeSitterNode[];
+    /** Number of children */
+    childCount: number;
+    /** Number of named children */
+    namedChildCount: number;
+    /** Parent node, if any */
+    parent: TreeSitterNode | null;
+    /** Next sibling node */
+    nextSibling: TreeSitterNode | null;
+    /** Previous sibling node */
+    previousSibling: TreeSitterNode | null;
+    /** Next named sibling node */
+    nextNamedSibling: TreeSitterNode | null;
+    /** Previous named sibling node */
+    previousNamedSibling: TreeSitterNode | null;
+    /** Get child by field name */
+    childForFieldName(fieldName: string): TreeSitterNode | null;
+    /** Get children by field name */
+    childrenForFieldName(fieldName: string): TreeSitterNode[];
+    /** Get the first child of a specific type */
+    firstChildForType(type: string): TreeSitterNode | null;
+    /** Get descendant for a position range */
+    descendantForPosition(start: TreeSitterPoint, end?: TreeSitterPoint): TreeSitterNode;
+    /** Get named descendant for a position range */
+    namedDescendantForPosition(start: TreeSitterPoint, end?: TreeSitterPoint): TreeSitterNode;
+    /** Walk the tree */
+    walk(): TreeSitterTreeCursor;
+}
+/**
+ * Represents a point (position) in tree-sitter.
+ */
+export interface TreeSitterPoint {
+    /** Row (0-indexed line number) */
+    row: number;
+    /** Column (0-indexed character offset) */
+    column: number;
+}
+/**
+ * Represents a tree-sitter syntax tree.
+ */
+export interface TreeSitterTree {
+    /** The root node of the tree */
+    rootNode: TreeSitterNode;
+    /** The language of the tree */
+    language: TreeSitterLanguage;
+    /** Walk the tree */
+    walk(): TreeSitterTreeCursor;
+    /** Edit the tree for incremental parsing */
+    edit(edit: TreeSitterEdit): void;
+    /** Get changed ranges after an edit */
+    getChangedRanges(other: TreeSitterTree): TreeSitterRange[];
+    /** Copy the tree */
+    copy(): TreeSitterTree;
+}
+/**
+ * Represents a tree-sitter parser.
+ */
+export interface TreeSitterParser {
+    /** Set the language for parsing */
+    setLanguage(language: TreeSitterLanguage): void;
+    /** Get the current language */
+    getLanguage(): TreeSitterLanguage | null;
+    /** Parse source code */
+    parse(input: string | TreeSitterInput, oldTree?: TreeSitterTree): TreeSitterTree;
+    /** Reset the parser */
+    reset(): void;
+    /** Set timeout in microseconds */
+    setTimeoutMicros(timeout: number): void;
+    /** Get timeout in microseconds */
+    getTimeoutMicros(): number;
+    /** Set included ranges */
+    setIncludedRanges(ranges: TreeSitterRange[]): void;
+    /** Get included ranges */
+    getIncludedRanges(): TreeSitterRange[];
+}
+/**
+ * Represents a tree-sitter language.
+ */
+export interface TreeSitterLanguage {
+    /** Language version */
+    version: number;
+    /** Number of node types */
+    nodeTypeCount: number;
+    /** Get node type name by ID */
+    nodeTypeForId(id: number): string | null;
+    /** Get node type ID by name */
+    nodeTypeIdForName(name: string, isNamed: boolean): number | null;
+    /** Number of fields */
+    fieldCount: number;
+    /** Get field name by ID */
+    fieldNameForId(id: number): string | null;
+    /** Get field ID by name */
+    fieldIdForName(name: string): number | null;
+}
+/**
+ * Represents a tree-sitter tree cursor for efficient traversal.
+ */
+export interface TreeSitterTreeCursor {
+    /** Current node */
+    currentNode: TreeSitterNode;
+    /** Current field name */
+    currentFieldName: string | null;
+    /** Current field ID */
+    currentFieldId: number;
+    /** Go to parent */
+    gotoParent(): boolean;
+    /** Go to first child */
+    gotoFirstChild(): boolean;
+    /** Go to first child for a byte offset */
+    gotoFirstChildForIndex(index: number): boolean;
+    /** Go to next sibling */
+    gotoNextSibling(): boolean;
+    /** Reset to a node */
+    reset(node: TreeSitterNode): void;
+}
+/**
+ * Input function for incremental parsing.
+ */
+export type TreeSitterInput = (startIndex: number, startPoint: TreeSitterPoint | null, endIndex: number | null) => string | null;
+/**
+ * Represents an edit for incremental parsing.
+ */
+export interface TreeSitterEdit {
+    /** Start byte offset */
+    startIndex: number;
+    /** Old end byte offset */
+    oldEndIndex: number;
+    /** New end byte offset */
+    newEndIndex: number;
+    /** Start position */
+    startPosition: TreeSitterPoint;
+    /** Old end position */
+    oldEndPosition: TreeSitterPoint;
+    /** New end position */
+    newEndPosition: TreeSitterPoint;
+}
+/**
+ * Represents a range in the source.
+ */
+export interface TreeSitterRange {
+    /** Start position */
+    startPosition: TreeSitterPoint;
+    /** End position */
+    endPosition: TreeSitterPoint;
+    /** Start byte offset */
+    startIndex: number;
+    /** End byte offset */
+    endIndex: number;
+}
+/**
+ * Represents a tree-sitter query.
+ */
+export interface TreeSitterQuery {
+    /** Execute the query on a node */
+    matches(node: TreeSitterNode, options?: TreeSitterQueryOptions): TreeSitterQueryMatch[];
+    /** Execute the query and get captures */
+    captures(node: TreeSitterNode, options?: TreeSitterQueryOptions): TreeSitterQueryCapture[];
+    /** Pattern count */
+    patternCount: number;
+    /** Capture names */
+    captureNames: string[];
+}
+/**
+ * Options for query execution.
+ */
+export interface TreeSitterQueryOptions {
+    /** Start position */
+    startPosition?: TreeSitterPoint;
+    /** End position */
+    endPosition?: TreeSitterPoint;
+    /** Start byte offset */
+    startIndex?: number;
+    /** End byte offset */
+    endIndex?: number;
+    /** Match limit */
+    matchLimit?: number;
+}
+/**
+ * Represents a query match.
+ */
+export interface TreeSitterQueryMatch {
+    /** Pattern index */
+    pattern: number;
+    /** Captures in this match */
+    captures: TreeSitterQueryCapture[];
+}
+/**
+ * Represents a query capture.
+ */
+export interface TreeSitterQueryCapture {
+    /** Capture name */
+    name: string;
+    /** Captured node */
+    node: TreeSitterNode;
+}
+/**
+ * Information about a Pydantic model.
+ */
+export interface PydanticModelInfo {
+    /** Model class name */
+    name: string;
+    /** Base classes (e.g., BaseModel, BaseSettings) */
+    bases: string[];
+    /** Model fields */
+    fields: PydanticFieldInfo[];
+    /** Model validators */
+    validators: PydanticValidatorInfo[];
+    /** Model configuration (Config class or model_config) */
+    config: PydanticConfigInfo | null;
+    /** Decorators applied to the model */
+    decorators: string[];
+    /** Docstring if present */
+    docstring: string | null;
+    /** Whether this is a Pydantic v1 or v2 model */
+    version: 1 | 2 | 'unknown';
+    /** Start position in source */
+    startPosition: Position;
+    /** End position in source */
+    endPosition: Position;
+}
+/**
+ * Information about a Pydantic field.
+ */
+export interface PydanticFieldInfo {
+    /** Field name */
+    name: string;
+    /** Field type information */
+    type: TypeInfo;
+    /** Default value if any */
+    defaultValue: string | null;
+    /** Whether the field has a default */
+    hasDefault: boolean;
+    /** Whether the field uses Field() */
+    usesField: boolean;
+    /** Field constraints from Field() */
+    constraints: FieldConstraints;
+    /** Field alias if specified */
+    alias: string | null;
+    /** Field description if specified */
+    description: string | null;
+    /** Whether the field is required */
+    required: boolean;
+    /** Start position in source */
+    startPosition: Position;
+    /** End position in source */
+    endPosition: Position;
+}
+/**
+ * Information about a type annotation.
+ */
+export interface TypeInfo {
+    /** Raw type string as written in source */
+    raw: string;
+    /** Base type name (e.g., 'str', 'int', 'List') */
+    base: string;
+    /** Type arguments for generic types (e.g., ['str'] for List[str]) */
+    args: TypeInfo[];
+    /** Whether the type is Optional */
+    isOptional: boolean;
+    /** Whether the type is a Union */
+    isUnion: boolean;
+    /** Whether the type is a List/Sequence */
+    isList: boolean;
+    /** Whether the type is a Dict/Mapping */
+    isDict: boolean;
+    /** Whether the type is a literal type */
+    isLiteral: boolean;
+    /** Literal values if isLiteral is true */
+    literalValues: string[];
+    /** Whether the type references another Pydantic model */
+    isPydanticModel: boolean;
+    /** Referenced model name if isPydanticModel is true */
+    referencedModel: string | null;
+}
+/**
+ * Constraints that can be applied to a Pydantic field.
+ */
+export interface FieldConstraints {
+    /** Minimum value for numeric types */
+    ge: number | null;
+    /** Maximum value for numeric types */
+    le: number | null;
+    /** Greater than (exclusive minimum) */
+    gt: number | null;
+    /** Less than (exclusive maximum) */
+    lt: number | null;
+    /** Minimum length for strings/sequences */
+    minLength: number | null;
+    /** Maximum length for strings/sequences */
+    maxLength: number | null;
+    /** Regex pattern for strings */
+    pattern: string | null;
+    /** Multiple of for numeric types */
+    multipleOf: number | null;
+    /** Whether the field is frozen (immutable) */
+    frozen: boolean;
+    /** Custom validation function names */
+    validators: string[];
+    /** JSON schema extra properties */
+    jsonSchemaExtra: Record<string, unknown> | null;
+}
+/**
+ * Information about a Pydantic validator.
+ */
+export interface PydanticValidatorInfo {
+    /** Validator function name */
+    name: string;
+    /** Fields this validator applies to */
+    fields: string[];
+    /** Validator mode (before, after, wrap, plain) */
+    mode: 'before' | 'after' | 'wrap' | 'plain' | 'unknown';
+    /** Whether this is a field validator or model validator */
+    type: 'field' | 'model' | 'root';
+    /** Whether the validator is a classmethod */
+    isClassmethod: boolean;
+    /** Start position in source */
+    startPosition: Position;
+    /** End position in source */
+    endPosition: Position;
+}
+/**
+ * Information about Pydantic model configuration.
+ */
+export interface PydanticConfigInfo {
+    /** Whether extra fields are allowed */
+    extra: 'allow' | 'forbid' | 'ignore' | null;
+    /** Whether the model is frozen (immutable) */
+    frozen: boolean | null;
+    /** Whether to validate assignment */
+    validateAssignment: boolean | null;
+    /** Whether to use enum values */
+    useEnumValues: boolean | null;
+    /** Whether to validate default values */
+    validateDefault: boolean | null;
+    /** Whether to populate by name */
+    populateByName: boolean | null;
+    /** Arbitrary types allowed */
+    arbitraryTypesAllowed: boolean | null;
+    /** JSON schema extra */
+    jsonSchemaExtra: Record<string, unknown> | null;
+    /** All raw config values */
+    raw: Record<string, unknown>;
+}
+/**
+ * Configuration options for the tree-sitter Python parser.
+ */
+export interface TreeSitterPythonParserConfig {
+    /** Whether to extract Pydantic model information */
+    extractPydanticModels: boolean;
+    /** Maximum depth for type resolution */
+    maxTypeDepth: number;
+    /** Whether to include position information in extracted data */
+    includePositions: boolean;
+    /** Timeout for parsing in milliseconds (0 = no timeout) */
+    parseTimeout: number;
+    /** Whether to use incremental parsing when possible */
+    useIncremental: boolean;
+}
+/**
+ * Default configuration for tree-sitter Python parser.
+ */
+export declare const DEFAULT_TREE_SITTER_PYTHON_CONFIG: TreeSitterPythonParserConfig;
+//# sourceMappingURL=types.d.ts.map