/**
 * Intent Decomposition Service — Utility Layer
 *
 * Lightweight utility for pre-filtering non-actionable messages and
 * providing regex-based fallback decomposition.
 *
 * Architecture: The orchestrator LLM (Claude Code) performs the actual
 * intent decomposition using its own reasoning — no separate LLM API call
 * is needed. The orchestrator then calls POST /api/intent-tasks/batch
 * with structured task data.
 *
 * This service provides:
 * - Pre-filtering: quickly reject obviously non-actionable messages
 * - Regex fallback: basic decomposition when LLM-based flow is unavailable
 * - Task creation: wraps IntentTaskService for convenience
 *
 * @module services/intent-task/intent-decomposition.service
 */
import type { IntentTask, DecomposedIntent } from '../../types/intent-task.types.js';
/**
 * Utility service for intent task decomposition.
 *
 * The primary decomposition path is:
 * 1. Orchestrator LLM receives a user message
 * 2. Orchestrator extracts tasks using its own reasoning
 * 3. Orchestrator calls POST /api/intent-tasks/batch with structured data
 *
 * This service provides a fallback regex-based path and pre-filtering utilities.
 *
 * @example
 * ```typescript
 * const service = IntentDecompositionService.getInstance();
 *
 * // Check if a message is worth processing
 * if (!service.isObviouslyNonActionable(message)) {
 *   // Let the orchestrator LLM handle decomposition
 * }
 *
 * // Fallback: regex-based decomposition
 * const tasks = service.decomposeWithRegexAndCreate(message, chatMessageId);
 * ```
 */
export declare class IntentDecompositionService {
    private static instance;
    private readonly logger;
    constructor();
    /**
     * Get the singleton instance.
     *
     * @returns Shared IntentDecompositionService instance
     */
    static getInstance(): IntentDecompositionService;
    /**
     * Reset the singleton (for testing).
     */
    static resetInstance(): void;
    /**
     * Quick pre-filter to skip obviously non-actionable messages.
     * Used by the orchestrator to decide whether to bother with
     * intent extraction for a given message.
     *
     * @param message - Trimmed message
     * @returns true if the message is obviously not actionable
     */
    isObviouslyNonActionable(message: string): boolean;
    /**
     * Check if a message is within processable bounds.
     *
     * @param message - Raw message
     * @returns true if the message length is within bounds for processing
     */
    isWithinBounds(message: string): boolean;
    /**
     * Regex-based decomposition fallback.
     * Uses heuristic pattern matching to split messages into intents.
     *
     * @param message - User message
     * @returns Array of decomposed intents
     */
    decomposeWithRegex(message: string): DecomposedIntent[];
    /**
     * Regex-based decomposition with automatic task creation.
     * Falls back to this when the orchestrator LLM path is unavailable.
     *
     * @param message - User message
     * @param chatMessageId - Chat message ID for correlation
     * @returns Array of created IntentTasks
     */
    decomposeWithRegexAndCreate(message: string, chatMessageId: string): IntentTask[];
}
//# sourceMappingURL=intent-decomposition.service.d.ts.map