/**
 * Core Abstractions and Interfaces
 * These form the foundation of our clean architecture
 */
export type Success<T> = {
    success: true;
    data: T;
};
export type Failure<E = Error> = {
    success: false;
    error: E;
};
export type Result<T, E = Error> = Success<T> | Failure<E>;
export declare class ResultUtil {
    static ok<T>(data: T): Success<T>;
    static fail<E = Error>(error: E): Failure<E>;
    static isSuccess<T, E>(result: Result<T, E>): result is Success<T>;
    static isFailure<T, E>(result: Result<T, E>): result is Failure<E>;
    static map<T, U, E>(result: Result<T, E>, fn: (data: T) => U): Result<U, E>;
    static flatMap<T, U, E>(result: Result<T, E>, fn: (data: T) => Result<U, E>): Result<U, E>;
    static fromPromise<T>(promise: Promise<T>, errorHandler?: (error: unknown) => Error): Promise<Result<T>>;
}
export declare abstract class DomainError extends Error {
    readonly details?: unknown | undefined;
    abstract readonly code: string;
    abstract readonly statusCode: number;
    constructor(message: string, details?: unknown | undefined);
    toJSON(): {
        name: string;
        code: string;
        message: string;
        details: unknown;
        stack: string | undefined;
    };
}
export declare class ConnectionError extends DomainError {
    readonly code = "CONNECTION_ERROR";
    readonly statusCode = 503;
}
export declare class ModelNotFoundError extends DomainError {
    readonly code = "MODEL_NOT_FOUND";
    readonly statusCode = 404;
}
export declare class InvalidOperationError extends DomainError {
    readonly code = "INVALID_OPERATION";
    readonly statusCode = 400;
}
export declare class ValidationError extends DomainError {
    readonly code = "VALIDATION_ERROR";
    readonly statusCode = 422;
}
export declare class COMError extends DomainError {
    readonly code = "COM_ERROR";
    readonly statusCode = 500;
}
/**
 * Connection management interface
 */
export interface IConnection<T = unknown> {
    connect(): Promise<Result<T>>;
    disconnect(): Promise<Result<void>>;
    isConnected(): boolean;
    getConnection(): T | null;
    healthCheck(): Promise<Result<boolean>>;
}
/**
 * Repository pattern interface
 */
export interface IRepository<T, ID = string> {
    findById(id: ID): Promise<Result<T | null>>;
    findAll(): Promise<Result<T[]>>;
    save(entity: T): Promise<Result<T>>;
    update(id: ID, entity: Partial<T>): Promise<Result<T>>;
    delete(id: ID): Promise<Result<void>>;
    exists(id: ID): Promise<Result<boolean>>;
}
/**
 * Unit of Work pattern for transactions
 */
export interface IUnitOfWork {
    begin(): Promise<Result<void>>;
    commit(): Promise<Result<void>>;
    rollback(): Promise<Result<void>>;
    inTransaction(): boolean;
}
/**
 * Command pattern interface
 */
export interface ICommand<TParams = unknown, TResult = unknown> {
    execute(params: TParams): Promise<Result<TResult>>;
    canExecute(params: TParams): Promise<Result<boolean>>;
    validate(params: TParams): Result<void>;
}
/**
 * Query pattern interface
 */
export interface IQuery<TParams = unknown, TResult = unknown> {
    execute(params: TParams): Promise<Result<TResult>>;
    validate(params: TParams): Result<void>;
}
/**
 * Event interface for Observer pattern
 */
export interface IEvent {
    readonly id: string;
    readonly timestamp: Date;
    readonly type: string;
    readonly payload?: unknown;
}
/**
 * Event handler interface
 */
export interface IEventHandler<T extends IEvent = IEvent> {
    handle(event: T): Promise<Result<void>>;
    canHandle(event: IEvent): boolean;
}
/**
 * Event bus interface
 */
export interface IEventBus {
    publish(event: IEvent): Promise<Result<void>>;
    subscribe(eventType: string, handler: IEventHandler): void;
    unsubscribe(eventType: string, handler: IEventHandler): void;
}
/**
 * SolidWorks model types
 */
export declare enum ModelType {
    Part = "Part",
    Assembly = "Assembly",
    Drawing = "Drawing"
}
/**
 * SolidWorks model interface
 */
export interface ISolidWorksModel {
    readonly id: string;
    readonly path: string;
    readonly name: string;
    readonly type: ModelType;
    readonly isActive: boolean;
    readonly isDirty: boolean;
    readonly metadata?: Record<string, unknown>;
}
/**
 * SolidWorks feature interface
 */
export interface ISolidWorksFeature {
    readonly id: string;
    readonly name: string;
    readonly type: string;
    readonly suppressed: boolean;
    readonly parameters?: Record<string, unknown>;
}
/**
 * SolidWorks dimension interface
 */
export interface ISolidWorksDimension {
    readonly name: string;
    readonly value: number;
    readonly feature: string;
    readonly tolerance?: {
        upper: number;
        lower: number;
    };
}
/**
 * SolidWorks API adapter interface
 */
export interface ISolidWorksAdapter {
    connect(): Promise<Result<void>>;
    disconnect(): Promise<Result<void>>;
    isConnected(): boolean;
    openModel(path: string): Promise<Result<ISolidWorksModel>>;
    closeModel(save: boolean): Promise<Result<void>>;
    createPart(): Promise<Result<ISolidWorksModel>>;
    getCurrentModel(): Result<ISolidWorksModel | null>;
    saveModel(path?: string): Promise<Result<void>>;
    createFeature(params: unknown): Promise<Result<ISolidWorksFeature>>;
    getFeatures(): Promise<Result<ISolidWorksFeature[]>>;
    suppressFeature(name: string): Promise<Result<void>>;
    getDimension(name: string): Promise<Result<ISolidWorksDimension>>;
    setDimension(name: string, value: number): Promise<Result<void>>;
    listDimensions(): Promise<Result<ISolidWorksDimension[]>>;
    exportModel(path: string, format: string): Promise<Result<void>>;
}
/**
 * Configuration provider interface
 */
export interface IConfigurationProvider {
    get<T = unknown>(key: string): T | undefined;
    getRequired<T = unknown>(key: string): T;
    set(key: string, value: unknown): void;
    has(key: string): boolean;
    validate(): Result<void>;
    reload(): Promise<Result<void>>;
}
/**
 * Logger interface
 */
export interface ILogger {
    debug(message: string, context?: Record<string, unknown>): void;
    info(message: string, context?: Record<string, unknown>): void;
    warn(message: string, context?: Record<string, unknown>): void;
    error(message: string, error?: Error, context?: Record<string, unknown>): void;
    fatal(message: string, error?: Error, context?: Record<string, unknown>): void;
}
/**
 * Abstract factory interface
 */
export interface IFactory<T, TParams = unknown> {
    create(params: TParams): Result<T>;
    canCreate(params: TParams): boolean;
}
/**
 * Service locator interface (for dependency injection)
 */
export interface IServiceLocator {
    register<T>(token: symbol | string, instance: T): void;
    resolve<T>(token: symbol | string): T;
    has(token: symbol | string): boolean;
    reset(): void;
}
/**
 * Validator interface
 */
export interface IValidator<T = unknown> {
    validate(input: unknown): Result<T>;
    isValid(input: unknown): boolean;
}
/**
 * Validation rule interface
 */
export interface IValidationRule<T = unknown> {
    validate(value: T): Result<void>;
    message: string;
}
/**
 * Middleware interface for request processing pipeline
 */
export interface IMiddleware<TContext = unknown> {
    execute(context: TContext, next: () => Promise<Result<void>>): Promise<Result<void>>;
}
/**
 * Pipeline interface
 */
export interface IPipeline<TContext = unknown> {
    use(middleware: IMiddleware<TContext>): void;
    execute(context: TContext): Promise<Result<void>>;
}
/**
 * Cache interface
 */
export interface ICache<T = unknown> {
    get(key: string): Promise<Result<T | null>>;
    set(key: string, value: T, ttl?: number): Promise<Result<void>>;
    has(key: string): Promise<Result<boolean>>;
    delete(key: string): Promise<Result<void>>;
    clear(): Promise<Result<void>>;
    size(): Promise<Result<number>>;
}
/**
 * Metrics collector interface
 */
export interface IMetricsCollector {
    increment(metric: string, value?: number, tags?: Record<string, string>): void;
    gauge(metric: string, value: number, tags?: Record<string, string>): void;
    histogram(metric: string, value: number, tags?: Record<string, string>): void;
    timing(metric: string, duration: number, tags?: Record<string, string>): void;
}
/**
 * Health check interface
 */
export interface IHealthCheck {
    name: string;
    check(): Promise<Result<HealthStatus>>;
}
export interface HealthStatus {
    status: 'healthy' | 'degraded' | 'unhealthy';
    message?: string;
    details?: Record<string, unknown>;
}
export declare const TypeGuards: {
    isModelType(value: unknown): value is ModelType;
    isSolidWorksModel(value: unknown): value is ISolidWorksModel;
    isError(value: unknown): value is Error;
    isDomainError(value: unknown): value is DomainError;
};
//# sourceMappingURL=core-abstractions.d.ts.map