/**
 * Type definitions for SolidWorks adapter pattern
 * Enhanced with comprehensive operation support and robust error handling
 */
import { z } from 'zod';
import type { SolidWorksFeature, SolidWorksModel } from '../solidworks/types.js';
/**
 * Base interface for all SolidWorks adapters
 */
export interface ISolidWorksAdapter {
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    isConnected(): boolean;
    healthCheck(): Promise<AdapterHealth>;
    execute<T>(command: Command): Promise<AdapterResult<T>>;
    executeRaw(method: string, args: any[]): Promise<any>;
    openModel(filePath: string): Promise<SolidWorksModel>;
    closeModel(save?: boolean): Promise<void>;
    createPart(): Promise<SolidWorksModel>;
    createAssembly(): Promise<SolidWorksModel>;
    createDrawing(): Promise<SolidWorksModel>;
    createExtrusion(params: ExtrusionParameters): Promise<SolidWorksFeature>;
    createRevolve(params: RevolveParameters): Promise<SolidWorksFeature>;
    createSweep(params: SweepParameters): Promise<SolidWorksFeature>;
    createLoft(params: LoftParameters): Promise<SolidWorksFeature>;
    createSketch(plane: string): Promise<string>;
    addLine(x1: number, y1: number, x2: number, y2: number): Promise<void>;
    addCircle(centerX: number, centerY: number, radius: number): Promise<void>;
    addRectangle(x1: number, y1: number, x2: number, y2: number): Promise<void>;
    exitSketch(): Promise<void>;
    getMassProperties(): Promise<MassProperties>;
    exportFile(filePath: string, format: string): Promise<void>;
    getDimension(name: string): Promise<number>;
    setDimension(name: string, value: number): Promise<void>;
}
/**
 * Adapter health status
 */
export interface AdapterHealth {
    healthy: boolean;
    lastCheck: Date;
    errorCount: number;
    successCount: number;
    averageResponseTime: number;
    connectionStatus: 'connected' | 'disconnected' | 'error';
    metrics?: {
        directCOMCalls?: number;
        macroFallbacks?: number;
        successRate?: number;
    };
}
/**
 * Command pattern for SolidWorks operations
 */
export interface Command {
    name: string;
    parameters: Record<string, any>;
    validate(): ValidationResult;
    fallback?: Command;
    timeout?: number;
    retryable?: boolean;
    priority?: number;
}
/**
 * Validation result for commands
 */
export interface ValidationResult {
    valid: boolean;
    errors?: string[];
    warnings?: string[];
}
/**
 * Result wrapper for adapter operations
 */
export interface AdapterResult<T> {
    success: boolean;
    data?: T;
    error?: string;
    timing?: {
        start: Date | number;
        end: Date | number;
        duration: number;
    };
    metadata?: Record<string, any>;
}
/**
 * Base command class with common functionality
 */
export declare abstract class BaseCommand implements Command {
    abstract name: string;
    abstract parameters: Record<string, any>;
    fallback?: Command;
    timeout: number;
    retryable: boolean;
    validate(): ValidationResult;
    /**
     * Transform parameters before execution
     */
    protected transformParameters(): Record<string, any>;
}
/**
 * Extrusion command with validation and fallback
 */
export declare class CreateExtrusionCommand extends BaseCommand {
    name: string;
    parameters: {
        depth: number;
        reverse?: boolean;
        bothDirections?: boolean;
        draft?: number;
        merge?: boolean;
        [key: string]: any;
    };
    constructor(parameters: {
        depth: number;
        reverse?: boolean;
        bothDirections?: boolean;
        draft?: number;
        merge?: boolean;
        [key: string]: any;
    });
    validate(): ValidationResult;
}
/**
 * VBA-based fallback for extrusion
 */
export declare class CreateExtrusionVBACommand extends BaseCommand {
    name: string;
    parameters: Record<string, any>;
    constructor(extrusionParams: Record<string, any>);
}
/**
 * Adapter factory for creating appropriate adapter based on configuration
 */
export declare class AdapterFactory {
    private static adapters;
    static register(type: string, factory: () => Promise<ISolidWorksAdapter>): void;
    static create(type?: string): Promise<ISolidWorksAdapter>;
}
/**
 * Circuit breaker for handling adapter failures
 */
export declare class CircuitBreaker {
    private threshold;
    private timeout;
    private failures;
    private lastFailureTime?;
    private state;
    constructor(threshold?: number, timeout?: number, _halfOpenRequests?: number);
    execute<T>(fn: () => Promise<T>): Promise<T>;
    private onSuccess;
    private onFailure;
    getState(): "CLOSED" | "OPEN" | "HALF_OPEN";
    reset(): void;
}
/**
 * Connection pool for managing multiple SolidWorks connections
 */
export declare class ConnectionPool {
    private factory;
    private minSize;
    private maxSize;
    private connections;
    private available;
    private inUse;
    constructor(factory: () => Promise<ISolidWorksAdapter>, minSize?: number, maxSize?: number);
    initialize(): Promise<void>;
    acquire(): Promise<ISolidWorksAdapter>;
    release(adapter: ISolidWorksAdapter): void;
    destroy(): Promise<void>;
}
/**
 * Batch processor for executing multiple commands efficiently
 */
export declare class BatchProcessor {
    private adapter;
    private batchSize;
    private delay;
    private queue;
    private processing;
    constructor(adapter: ISolidWorksAdapter, batchSize?: number, delay?: number);
    add(command: Command): Promise<void>;
    private process;
}
/**
 * Event types for adapter events
 */
export interface AdapterEvents {
    connected: undefined;
    disconnected: undefined;
    'command:start': {
        command: Command;
    };
    'command:success': {
        command: Command;
        result: any;
    };
    'command:failure': {
        command: Command;
        error: Error;
    };
    'health:check': {
        healthy: boolean;
    };
}
/**
 * Schema definitions for common SolidWorks types
 */
export declare const ModelSchema: z.ZodObject<{
    path: z.ZodString;
    name: z.ZodString;
    type: z.ZodEnum<["Part", "Assembly", "Drawing"]>;
    isActive: z.ZodBoolean;
    configurations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    name: string;
    path: string;
    type: "Part" | "Assembly" | "Drawing";
    isActive: boolean;
    configurations?: string[] | undefined;
}, {
    name: string;
    path: string;
    type: "Part" | "Assembly" | "Drawing";
    isActive: boolean;
    configurations?: string[] | undefined;
}>;
export declare const FeatureSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    type: z.ZodString;
    suppressed: z.ZodBoolean;
    parameters: z.ZodRecord<z.ZodString, z.ZodAny>;
}, "strip", z.ZodTypeAny, {
    id: string;
    name: string;
    parameters: Record<string, any>;
    type: string;
    suppressed: boolean;
}, {
    id: string;
    name: string;
    parameters: Record<string, any>;
    type: string;
    suppressed: boolean;
}>;
export declare const SketchSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    plane: z.ZodString;
    entities: z.ZodArray<z.ZodObject<{
        type: z.ZodString;
        id: z.ZodString;
        coordinates: z.ZodArray<z.ZodNumber, "many">;
    }, "strip", z.ZodTypeAny, {
        id: string;
        type: string;
        coordinates: number[];
    }, {
        id: string;
        type: string;
        coordinates: number[];
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    id: string;
    name: string;
    plane: string;
    entities: {
        id: string;
        type: string;
        coordinates: number[];
    }[];
}, {
    id: string;
    name: string;
    plane: string;
    entities: {
        id: string;
        type: string;
        coordinates: number[];
    }[];
}>;
export type Model = z.infer<typeof ModelSchema>;
export type Feature = z.infer<typeof FeatureSchema>;
export type Sketch = z.infer<typeof SketchSchema>;
/**
 * Parameter types for feature operations
 */
export interface ExtrusionParameters {
    depth: number;
    reverse?: boolean;
    bothDirections?: boolean;
    depth2?: number;
    draft?: number;
    draftOutward?: boolean;
    draftWhileExtruding?: boolean;
    offsetDistance?: number;
    offsetReverse?: boolean;
    translateSurface?: boolean;
    merge?: boolean;
    flipSideToCut?: boolean;
    startCondition?: number;
    endCondition?: number | string;
    thinFeature?: boolean;
    thinThickness?: number;
    thinType?: string;
    capEnds?: boolean;
    capThickness?: number;
}
export interface RevolveParameters {
    angle: number;
    axis?: string;
    direction?: number | string;
    merge?: boolean;
    thinFeature?: boolean;
    thinThickness?: number;
}
export interface SweepParameters {
    profileSketch: string;
    pathSketch: string;
    twistAngle?: number;
    merge?: boolean;
    thinFeature?: boolean;
    thinThickness?: number;
}
export interface LoftParameters {
    profiles: string[];
    guides?: string[];
    guideCurves?: string[];
    centerCurve?: string;
    closed?: boolean;
    close?: boolean;
    startTangency?: string;
    endTangency?: string;
    merge?: boolean;
    thinFeature?: boolean;
    thinThickness?: number;
}
export interface MassProperties {
    mass: number;
    volume: number;
    surfaceArea: number;
    centerOfMass: {
        x: number;
        y: number;
        z: number;
    };
    density?: number;
    momentsOfInertia?: {
        Ixx: number;
        Iyy: number;
        Izz: number;
        Ixy: number;
        Iyz: number;
        Ixz: number;
    };
}
/**
 * Adapter configuration
 */
export interface AdapterConfig {
    type: 'winax' | 'macro-fallback' | 'hybrid' | 'winax-enhanced';
    enableCircuitBreaker?: boolean;
    circuitBreakerThreshold?: number;
    circuitBreakerTimeout?: number;
    enableRetry?: boolean;
    maxRetries?: number;
    retryDelay?: number;
    enableConnectionPool?: boolean;
    poolSize?: number;
    enableMetrics?: boolean;
    enableLogging?: boolean;
    logLevel?: 'debug' | 'info' | 'warn' | 'error';
    macroPath?: string;
}
//# sourceMappingURL=types.d.ts.map