/**
 * Order Processing - Refactored using SOLID Principles
 *
 * This implementation follows:
 * - Single Responsibility Principle: Each strategy handles one order type
 * - Open/Closed Principle: New order types can be added without modifying existing code
 * - Liskov Substitution Principle: All strategies are interchangeable
 * - Interface Segregation Principle: Focused interfaces for specific behaviors
 * - Dependency Inversion Principle: High-level module depends on abstractions
 */
/**
 * Represents the possible statuses an order can have
 */
export type OrderStatus = 'pending' | 'delivered' | 'shipped' | 'active' | 'cancelled';
/**
 * Represents the supported order types
 */
export type OrderType = 'digital' | 'physical' | 'subscription';
/**
 * Base order interface with common properties
 */
export interface Order {
    readonly id: string;
    readonly type: OrderType;
    status: OrderStatus;
}
/**
 * Digital order with download-specific properties
 */
export interface DigitalOrder extends Order {
    readonly type: 'digital';
    readonly downloadUrl?: string;
}
/**
 * Physical order with shipping-specific properties
 */
export interface PhysicalOrder extends Order {
    readonly type: 'physical';
    readonly shippingAddress?: string;
}
/**
 * Subscription order with subscription-specific properties
 */
export interface SubscriptionOrder extends Order {
    readonly type: 'subscription';
    readonly subscriptionPlan?: string;
}
/**
 * Union type for all order types
 */
export type AnyOrder = DigitalOrder | PhysicalOrder | SubscriptionOrder;
/**
 * Result of processing an order
 */
export interface ProcessingResult {
    readonly success: boolean;
    readonly order: AnyOrder;
    readonly message: string;
}
/**
 * Logger interface for dependency injection
 */
export interface Logger {
    log(message: string): void;
}
/**
 * Strategy interface for processing orders (Open/Closed Principle)
 */
export interface OrderProcessingStrategy {
    /**
     * Check if this strategy can handle the given order type
     */
    canHandle(orderType: OrderType): boolean;
    /**
     * Process the order and return the result
     */
    process(order: AnyOrder, logger: Logger): ProcessingResult;
}
/**
 * Strategy for processing digital orders
 */
export declare class DigitalOrderStrategy implements OrderProcessingStrategy {
    canHandle(orderType: OrderType): boolean;
    process(order: AnyOrder, logger: Logger): ProcessingResult;
}
/**
 * Strategy for processing physical orders
 */
export declare class PhysicalOrderStrategy implements OrderProcessingStrategy {
    canHandle(orderType: OrderType): boolean;
    process(order: AnyOrder, logger: Logger): ProcessingResult;
}
/**
 * Strategy for processing subscription orders
 */
export declare class SubscriptionOrderStrategy implements OrderProcessingStrategy {
    canHandle(orderType: OrderType): boolean;
    process(order: AnyOrder, logger: Logger): ProcessingResult;
}
/**
 * Console-based logger implementation
 */
export declare class ConsoleLogger implements Logger {
    log(message: string): void;
}
/**
 * Main order processor that uses strategies to handle different order types
 */
export declare class OrderProcessor {
    private readonly strategies;
    private readonly logger;
    constructor(strategies: OrderProcessingStrategy[], logger: Logger);
    /**
     * Process an order using the appropriate strategy
     */
    processOrder(order: AnyOrder): ProcessingResult;
}
/**
 * Factory function to create a fully configured OrderProcessor
 */
export declare function createOrderProcessor(logger?: Logger): OrderProcessor;
/**
 * Example usage demonstrating the refactored code
 */
export declare function exampleUsage(): void;
//# sourceMappingURL=order-processor-refactored.d.ts.map