codecrucible-synth/dist/domain/entities/request.d.ts

Production-Ready AI Development Platform with Multi-Voice Synthesis, Smithery MCP Integration, Enterprise Security, and Zero-Timeout Reliability

/**
 * Request Domain Entity
 * Pure business logic for processing requests
 *
 * Living Spiral Council Applied:
 * - Domain-driven design with immutable request entities
 * - Business rules for request validation and prioritization
 * - No external dependencies or infrastructure concerns
 */
import { RequestPriority } from '../value-objects/voice-values.js';
/**
 * Processing Request Entity
 */
export declare class ProcessingRequest {
    private readonly _id;
    private readonly _content;
    private readonly _type;
    private readonly _priority;
    private readonly _context;
    private readonly _constraints;
    private readonly _timestamp;
    private _status;
    constructor(id: string, content: string, type: RequestType, priority: RequestPriority, context: RequestContext, constraints: RequestConstraints);
    get id(): string;
    get content(): string;
    get type(): RequestType;
    get priority(): RequestPriority;
    get context(): RequestContext;
    get constraints(): RequestConstraints;
    get timestamp(): Date;
    get status(): RequestStatus;
    /**
     * Start processing this request
     */
    startProcessing(): ProcessingRequest;
    /**
     * Complete this request successfully
     */
    complete(): ProcessingRequest;
    /**
     * Mark this request as failed
     */
    fail(error: string): ProcessingRequest;
    /**
     * Cancel this request
     */
    cancel(): ProcessingRequest;
    /**
     * Check if this request requires specific capabilities
     */
    requiresCapabilities(): string[];
    /**
     * Calculate processing complexity score
     */
    calculateComplexity(): number;
    /**
     * Estimate processing time in milliseconds
     */
    estimateProcessingTime(): number;
    /**
     * Get request configuration
     */
    toConfig(): ProcessingRequestConfig;
    /**
     * Create request from configuration
     */
    static fromConfig(config: ProcessingRequestConfig): ProcessingRequest;
    private clone;
    private getTypeComplexity;
    private getContextComplexity;
    private getPriorityMultiplier;
    private validateInputs;
}
/**
 * Request Type Enumeration
 */
export declare enum RequestType {
    CODE_GENERATION = "code-generation",
    CODE_ANALYSIS = "code-analysis",
    ARCHITECTURE_DESIGN = "architecture-design",
    DOCUMENTATION = "documentation",
    OPTIMIZATION = "optimization",
    REVIEW = "review"
}
/**
 * Request Status Enumeration
 */
export declare enum RequestStatus {
    PENDING = "pending",
    PROCESSING = "processing",
    COMPLETED = "completed",
    FAILED = "failed",
    CANCELLED = "cancelled"
}
/**
 * Request Context Interface
 */
export interface RequestContext {
    languages?: string[];
    frameworks?: string[];
    projectSize?: number;
    existingCode?: string;
    requirements?: string[];
    constraints?: string[];
}
/**
 * Request Constraints Interface
 */
export interface RequestConstraints {
    maxResponseTime?: number;
    maxCost?: number;
    requiredQuality?: number;
    excludedVoices?: string[];
    mustIncludeVoices?: string[];
    outputFormat?: string;
}
/**
 * Request Configuration Interface
 */
export interface ProcessingRequestConfig {
    id: string;
    content: string;
    type: RequestType;
    priority: string;
    context: RequestContext;
    constraints: RequestConstraints;
    timestamp: string;
    status: RequestStatus;
}
/**
 * Request Factory
 */
export declare class RequestFactory {
    /**
     * Create a code generation request
     */
    static createCodeGeneration(id: string, content: string, priority: RequestPriority, context: RequestContext): ProcessingRequest;
    /**
     * Create a code analysis request
     */
    static createCodeAnalysis(id: string, content: string, priority: RequestPriority, context: RequestContext): ProcessingRequest;
    /**
     * Create an architecture design request
     */
    static createArchitectureDesign(id: string, content: string, priority: RequestPriority, context: RequestContext): ProcessingRequest;
}
//# sourceMappingURL=request.d.ts.map