/**
 * AST Node Types for OpenSCAD parsing
 */
export type ScadNode = PrimitiveNode | TransformNode | BooleanOpNode | FunctionDefNode | FunctionCallNode | ModuleDefNode | ModuleCallNode | VariableNode | AssignmentNode | IfNode | ExpressionNode | ForLoopNode | ChildrenNode | EchoNode | AssertNode | LetNode | ModifierNode | ListComprehensionNode | ImportNode | AIImportNode | IntersectionForNode;
export interface PrimitiveNode {
    type: 'primitive';
    op: 'cube' | 'sphere' | 'cylinder' | 'cone' | 'pyramid' | 'circle' | 'square' | 'polygon' | 'polyhedron' | 'text';
    params: Record<string, any>;
    line?: number;
}
export interface IntersectionForNode {
    type: 'intersection_for';
    variable: string;
    range: [number, number] | [number, number, number];
    body: ScadNode[];
    line?: number;
}
export interface TransformNode {
    type: 'transform';
    op: 'translate' | 'rotate' | 'scale' | 'mirror' | 'multmatrix' | 'color' | 'linear_extrude' | 'rotate_extrude' | 'projection' | 'offset' | 'resize';
    params: Record<string, any>;
    children: ScadNode[];
    line?: number;
}
export interface BooleanOpNode {
    type: 'boolean';
    op: 'union' | 'difference' | 'intersection' | 'hull' | 'minkowski';
    children: ScadNode[];
    line?: number;
}
export interface FunctionDefNode {
    type: 'function_def';
    name: string;
    params: string[];
    expression: any;
    line?: number;
}
export interface FunctionCallNode {
    type: 'function_call';
    name: string;
    args: any[];
    line?: number;
}
export interface ModuleDefNode {
    type: 'module_def';
    name: string;
    params: string[];
    body: ScadNode[];
    line?: number;
}
export interface ModuleCallNode {
    type: 'module_call';
    name: string;
    params: Record<string, any>;
    children: ScadNode[];
    line?: number;
}
export interface VariableNode {
    type: 'variable';
    name: string;
    line?: number;
}
export interface AssignmentNode {
    type: 'assignment';
    name: string;
    value: any;
    line?: number;
}
export interface IfNode {
    type: 'if';
    condition: any;
    thenBody: ScadNode[];
    elseBody?: ScadNode[];
    line?: number;
}
export interface ExpressionNode {
    type: 'expression';
    operator: string;
    left: any;
    right?: any;
    line?: number;
}
export interface ForLoopNode {
    type: 'for';
    variable: string;
    range: [number, number] | [number, number, number];
    body: ScadNode[];
    line?: number;
}
export interface ChildrenNode {
    type: 'children';
    args?: ScadNode[];
    children?: ScadNode[];
    line?: number;
}
export interface EchoNode {
    type: 'echo';
    values: any[];
    line?: number;
}
export interface AssertNode {
    type: 'assert';
    condition: any;
    message?: any;
    line?: number;
}
export interface LetNode {
    type: 'let';
    bindings: Record<string, any>;
    body: ScadNode[];
    line?: number;
}
export interface ModifierNode {
    type: 'modifier';
    modifier: '!' | '%' | '#' | '*';
    child: ScadNode;
    line?: number;
}
export interface ListComprehensionNode {
    type: 'list_comprehension';
    expression: any;
    comprehensions: Array<{
        variable: string;
        range: [number, number] | [number, number, number];
    }>;
    condition?: any;
    line?: number;
}
export interface ImportNode {
    type: 'import';
    op: 'import' | 'include' | 'use';
    filename: string;
    line?: number;
}
export interface AIImportNode {
    type: 'ai_import';
    modelId: string;
    params: Record<string, any>;
    line?: number;
}
/**
 * Color information for geometry
 */
export interface ColorInfo {
    r: number;
    g: number;
    b: number;
    a?: number;
}
/**
 * Geometry data structure (output from WASM)
 */
export interface Geometry {
    vertices: Float32Array | number[];
    indices: Uint32Array | number[];
    normals: Float32Array | number[];
    bounds: {
        min: [number, number, number];
        max: [number, number, number];
    };
    stats: {
        vertexCount: number;
        faceCount: number;
        volume?: number;
    };
    color?: ColorInfo;
    modifier?: ModifierInfo;
    objects?: GeometryObject[];
}
/**
 * Visualization modifier information
 */
export interface ModifierInfo {
    type: '!' | '%' | '#' | '*';
    opacity?: number;
    highlightColor?: string;
}
/**
 * Interactive highlighting information
 */
export interface HighlightInfo {
    objectId: string;
    nodeId?: string;
    line?: number;
    isHovered?: boolean;
    isSelected?: boolean;
    highlightColor?: [number, number, number];
    originalColor?: ColorInfo;
}
/**
 * Geometry object with interactive metadata
 */
export interface GeometryObject {
    geometry: Geometry;
    highlight?: HighlightInfo;
    children?: GeometryObject[];
}
/**
 * Parser result
 */
export interface ParseResult {
    ast: ScadNode[] | null;
    errors: ParseError[];
    success: boolean;
}
export interface ParseError {
    message: string;
    line: number;
    column: number;
    code: string;
}
/**
 * Evaluator result
 */
export interface EvaluateResult {
    geometry: Geometry | null;
    errors: EvaluationError[];
    success: boolean;
    executionTime: number;
}
export interface EvaluationError {
    message: string;
    line?: number;
    column?: number;
    stack?: string;
    category?: 'syntax' | 'logic' | 'system';
    severity?: 'warning' | 'error' | 'critical';
    code?: string;
    suggestion?: string;
    fixExample?: string;
    documentation?: string;
    codeSnippet?: string;
    context?: string;
}
/**
 * Interactive selection and highlighting messages
 */
export interface HighlightMessage {
    type: 'highlight' | 'select' | 'clear_highlight';
    objectId?: string;
    line?: number;
    highlightColor?: [number, number, number];
}
/**
 * Code-to-geometry mapping
 */
export interface CodeGeometryMap {
    [line: number]: string[];
}
/**
 * WebSocket message types
 */
export interface WsMessage {
    type: 'parse' | 'evaluate' | 'export' | 'error' | 'highlight' | 'select' | 'clear_highlight' | 'progress_update';
    payload: any;
}
export interface EvaluateMessage {
    type: 'evaluate';
    code: string;
    requestId: string;
}
export interface EvaluateResponse {
    type: 'evaluate_response';
    requestId: string;
    geometry: Geometry | null;
    errors: EvaluationError[];
    executionTime: number;
}
/**
 * Export options
 */
export interface ExportOptions {
    format: 'stl' | 'obj' | '3mf';
    binary?: boolean;
    precision?: number;
}
export interface ExportResult {
    data: ArrayBuffer | string;
    format: string;
    filename: string;
}
/**
 * Render progress stages
 */
export type RenderStage = "initializing" | "parsing" | "analyzing" | "evaluating" | "chunking" | "optimizing" | "combining" | "serializing" | "complete" | "error";
/**
 * Progress update for long-running renders
 */
export interface RenderProgress {
    stage: RenderStage;
    progress: number;
    message: string;
    details?: {
        memoryUsageMB?: number;
        currentChunk?: number;
        totalChunks?: number;
        verticesProcessed?: number;
        totalVertices?: number;
        nodesProcessed?: number;
        totalNodes?: number;
        estimatedTimeRemainingMs?: number;
    };
}
/**
 * WebSocket message for progress updates
 */
export interface ProgressMessage {
    type: "progress_update";
    requestId: string;
    progress: RenderProgress;
    timestamp: number;
}
/**
 * Chunked evaluation result (partial geometry)
 */
export interface ChunkedGeometry {
    chunks: Array<{
        vertices: number[];
        indices: number[];
        normals: number[];
        chunkIndex: number;
    }>;
    isChunked: true;
    totalChunks: number;
    totalVertices: number;
    totalFaces: number;
    bounds: {
        min: number[];
        max: number[];
    };
    stats: {
        vertexCount: number;
        faceCount: number;
        volume: number;
    };
}
//# sourceMappingURL=geometry-types.d.ts.map