/**
 * SpecForge MCP Type Definitions
 *
 * This module exports TypeScript types for all MCP operations.
 */
/**
 * Project entity
 */
export interface Project {
    id: string;
    name: string;
    description?: string;
    userId: string;
    specCount: number;
    completedSpecCount: number;
    epicCount: number;
    completedEpicCount: number;
    ticketCount: number;
    completedTicketCount: number;
    createdAt: string;
    updatedAt: string;
}
/**
 * Specification status values
 */
export type SpecificationStatus = 'draft' | 'planning' | 'specifying' | 'validating' | 'ready' | 'in_progress' | 'completed';
/**
 * Naming conventions for the specification
 *
 * Defines consistent naming patterns used across the codebase.
 */
export interface NamingConventions {
    /** File naming pattern (e.g., "camelCase.ts") */
    files?: string;
    /** Function naming pattern (e.g., "_hookFunction") */
    functions?: string;
    /** Interface naming pattern (e.g., "FunctionNameProps") */
    interfaces?: string;
    /** Action naming pattern (e.g., "SCREAMING_SNAKE_CASE") */
    actions?: string;
    /** Component naming pattern (e.g., "PascalCase") */
    components?: string;
    /** Variable naming pattern (e.g., "camelCase") */
    variables?: string;
    /** Class naming pattern (e.g., "PascalCase") */
    classes?: string;
    /** Constant naming pattern (e.g., "UPPER_SNAKE_CASE") */
    constants?: string;
}
/**
 * Code standards defined at specification level
 *
 * Forms the top level of the pattern inheritance chain.
 * These standards are inherited by all epics and tickets within the specification.
 */
export interface SpecificationCodeStandards {
    /** Primary language (e.g., "TypeScript") */
    language?: string;
    /** Async pattern (e.g., "async/await") */
    asyncPattern?: string;
    /** Error handling approach (e.g., "Result<T> pattern") */
    errorHandling?: string;
    /** Documentation style (e.g., "JSDoc with @example") */
    documentation?: string;
    /** Testing approach (e.g., "AAA pattern") */
    testing?: string;
    /** Naming conventions */
    naming?: NamingConventions;
    /** State management pattern */
    stateManagement?: string;
    /** API pattern (e.g., "REST", "GraphQL") */
    apiPattern?: string;
    /** Logging approach */
    logging?: string;
    /** Validation approach */
    validation?: string;
    /** Additional custom standards */
    custom?: Record<string, string>;
}
/**
 * Return type patterns for CRUD operations
 *
 * Defines consistent return types for database/API operations.
 */
export interface ReturnTypes {
    /** Create operation return type (e.g., "BusinessCreateResult<T>") */
    create?: string;
    /** Update operation return type (e.g., "BusinessUpdateResult<T>") */
    update?: string;
    /** Delete operation return type (e.g., "BusinessDeleteResult") */
    delete?: string;
    /** List operation return type (e.g., "BusinessListResult<T>") */
    list?: string;
    /** Get single item return type */
    get?: string;
    /** Additional custom return types */
    custom?: Record<string, string>;
}
/**
 * Type guard for SpecificationCodeStandards
 */
export declare function isValidCodeStandards(value: unknown): value is SpecificationCodeStandards;
/**
 * Type guard for ReturnTypes
 */
export declare function isValidReturnTypes(value: unknown): value is ReturnTypes;
/**
 * Specification entity
 */
export interface Specification {
    id: string;
    projectId: string;
    title: string;
    description?: string;
    background?: string;
    scope?: string;
    status: SpecificationStatus;
    progress: number;
    goals?: string[];
    requirements?: string[];
    guardrails?: string[];
    constraints?: string[];
    acceptanceCriteria?: string[];
    architecture?: string;
    fileStructure?: string;
    techStack?: string[];
    dependencies?: string[];
    apiContracts?: any;
    priority?: 'high' | 'medium' | 'low';
    tags?: string[];
    estimatedHours?: number;
    /** Code standards for the specification (inherited by epics/tickets) */
    codeStandards?: SpecificationCodeStandards;
    /** Common imports used across the specification */
    commonImports?: string[];
    /** Return type patterns for CRUD operations */
    returnTypes?: ReturnTypes;
    createdAt: string;
    updatedAt: string;
}
/**
 * Shared patterns defined at epic level
 *
 * These patterns can override specification-level patterns for all tickets
 * within the epic. Useful for epics that need different conventions.
 */
export interface EpicSharedPatterns {
    /** Override error handling for this epic */
    errorHandling?: string;
    /** Epic-specific return type override */
    returnType?: string;
    /** Action prefix for Redux actions (e.g., "CHANNEL_") */
    actionPrefix?: string;
    /** Redux state slice path (e.g., "state.channel") */
    stateSlice?: string;
    /** API base path for this epic */
    apiBasePath?: string;
    /** Component folder for this epic */
    componentFolder?: string;
    /** Hook naming pattern for this epic */
    hookPattern?: string;
    /** Additional custom patterns */
    custom?: Record<string, string>;
}
/**
 * Common files used across all tickets in an epic
 *
 * Defines file paths that are shared/referenced by multiple tickets
 * in the epic. Helps AI understand the epic's file structure.
 */
export interface EpicCommonFiles {
    /** Reducer file path */
    reducer?: string;
    /** Actions file path */
    actions?: string;
    /** Types file path */
    types?: string;
    /** Index/barrel file path */
    index?: string;
    /** Selectors file path */
    selectors?: string;
    /** Hooks file path */
    hooks?: string;
    /** API client file path */
    api?: string;
    /** Test utilities file path */
    testUtils?: string;
    /** Additional custom files */
    custom?: Record<string, string>;
}
/**
 * Type guard for EpicSharedPatterns
 */
export declare function isValidEpicSharedPatterns(value: unknown): value is EpicSharedPatterns;
/**
 * Type guard for EpicCommonFiles
 */
export declare function isValidEpicCommonFiles(value: unknown): value is EpicCommonFiles;
/**
 * Epic status values
 */
export type EpicStatus = 'todo' | 'in_progress' | 'completed';
/**
 * Epic entity
 */
export interface Epic {
    id: string;
    specificationId: string;
    epicNumber: number;
    title: string;
    description: string;
    objective: string;
    content?: string;
    scope?: string;
    goals?: string[];
    guardrails?: string[];
    risks?: string[];
    constraints?: string[];
    assumptions?: string[];
    architecture?: string;
    fileStructure?: string;
    techStack?: string[];
    dependencies?: string[];
    apiContracts?: unknown;
    status: EpicStatus;
    progress: number;
    order: number;
    ticketCount: number;
    completedTicketCount: number;
    todoTicketCount: number;
    inProgressTicketCount: number;
    blockedTicketCount: number;
    priority?: 'high' | 'medium' | 'low';
    tags?: string[];
    estimatedHours?: number;
    acceptanceCriteria?: string[];
    /** Shared patterns for this epic (overrides specification patterns) */
    sharedPatterns?: EpicSharedPatterns;
    /** Additional imports specific to this epic */
    additionalImports?: string[];
    /** Common files shared across tickets in this epic */
    commonFiles?: EpicCommonFiles;
    createdAt: string;
    updatedAt: string;
}
/**
 * Ticket status values
 */
export type TicketStatus = 'todo' | 'queue' | 'in_progress' | 'blocked' | 'done';
/**
 * Supported implementation step action types
 */
export type ImplementationAction = 'create' | 'code' | 'validate' | 'api' | 'dispatch' | 'test' | 'config' | 'refactor' | 'delete' | 'document';
/**
 * A single implementation step with structured details
 */
export interface ImplementationStep {
    /** Execution order (1-based) */
    order: number;
    /** Brief title describing the step */
    title: string;
    /** Type of action to perform */
    action: ImplementationAction;
    /** Detailed description of what to do */
    detail: string;
    /** Optional code snippet for reference */
    codeSnippet?: string;
    /** Optional file path this step applies to */
    targetFile?: string;
    /** Estimated minutes for this step */
    estimatedMinutes?: number;
}
/**
 * Code example for reference
 */
export interface CodeExample {
    /** Name/title of the example */
    name: string;
    /** Programming language */
    language: string;
    /** The actual code */
    code: string;
    /** Optional description */
    description?: string;
}
/**
 * Implementation details stored with a ticket (enhanced schema)
 */
export interface TicketImplementation {
    /** Ordered list of implementation steps */
    steps?: ImplementationStep[];
    /** Optional code examples for reference */
    codeExamples?: CodeExample[];
    /** Optional summary or overview */
    summary?: string;
    /** Optional prerequisites */
    prerequisites?: string[];
    /** @deprecated Use steps[].targetFile with action='create' */
    filesToCreate?: string[];
    /** @deprecated Use steps[].targetFile with action='code' */
    filesToModify?: string[];
    /** @deprecated Use codeExamples or steps[].codeSnippet */
    codeSnippets?: Record<string, string>;
    /** @deprecated Use steps with action='test' */
    testing?: string;
    /** @deprecated Use summary field */
    notes?: string;
}
/**
 * Type guard to check if value is valid TicketImplementation
 */
export declare function isValidImplementation(value: unknown): value is TicketImplementation;
/**
 * HTTP methods for API endpoints
 */
export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
/**
 * File to be created
 */
export interface FileCreate {
    /** File path relative to project root */
    path: string;
    /** Purpose/description of the file */
    purpose: string;
    /** Optional template or boilerplate to use */
    template?: string;
}
/**
 * File to be modified
 */
export interface FileModify {
    /** File path relative to project root */
    path: string;
    /** Description of the change */
    change: string;
    /** Optional specific line range */
    lineRange?: {
        start: number;
        end: number;
    };
}
/**
 * File to be deleted
 */
export interface FileDelete {
    /** File path relative to project root */
    path: string;
    /** Reason for deletion */
    reason: string;
}
/**
 * API endpoint definition
 */
export interface ApiEndpoint {
    /** HTTP method */
    method: HttpMethod;
    /** URL path */
    path: string;
    /** Description of the endpoint */
    description: string;
    /** Optional request body schema */
    requestBody?: string;
    /** Optional response schema */
    responseBody?: string;
}
/**
 * Database operation
 */
export interface DatabaseOperation {
    /** Operation type */
    type: 'create' | 'read' | 'update' | 'delete' | 'migration';
    /** Table/collection name */
    table: string;
    /** Description of the operation */
    description: string;
}
/**
 * Environment variable definition
 */
export interface EnvVarDefinition {
    /** Variable name */
    name: string;
    /** Description of the variable */
    description: string;
    /** Whether the variable is required */
    required: boolean;
}
/**
 * External service dependency
 */
export interface ExternalServiceDependency {
    /** Service name */
    name: string;
    /** Purpose of using the service */
    purpose: string;
}
/**
 * Technical details for a ticket (enhanced schema)
 *
 * Captures file operations, patterns, imports, API endpoints,
 * and other technical requirements in a structured format.
 */
export interface TicketTechnicalDetails {
    /** File operations */
    files?: {
        create?: FileCreate[];
        modify?: FileModify[];
        delete?: FileDelete[];
    };
    /** Pattern references (key: pattern name, value: description/usage) */
    patterns?: Record<string, string>;
    /** Required imports/dependencies */
    imports?: string[];
    /** API endpoints involved */
    endpoints?: ApiEndpoint[];
    /** Database operations */
    database?: DatabaseOperation[];
    /** Environment variables needed */
    envVars?: EnvVarDefinition[];
    /** External service dependencies */
    externalServices?: ExternalServiceDependency[];
    /** @deprecated Use files.create/modify for file operations */
    stack?: string[];
    /** @deprecated Use database field */
    databaseChanges?: string[];
}
/**
 * Type guard for TicketTechnicalDetails
 *
 * Validates that a value conforms to the TicketTechnicalDetails structure.
 */
export declare function isValidTechnicalDetails(value: unknown): value is TicketTechnicalDetails;
/**
 * Reference type for categorizing links
 */
export type ReferenceType = 'documentation' | 'example' | 'related' | 'external';
/**
 * Reference link with optional description
 */
export interface Reference {
    /** URL or document path */
    url: string;
    /** Title or description */
    title: string;
    /** Type of reference */
    type?: ReferenceType;
}
/**
 * Alternative approach consideration
 */
export interface Alternative {
    /** Title of the alternative */
    title: string;
    /** Description of the approach */
    description: string;
    /** Why it wasn't chosen */
    reason?: string;
    /** Pros of this alternative */
    pros?: string[];
    /** Cons of this alternative */
    cons?: string[];
}
/**
 * Notes and context for a ticket (enhanced schema)
 *
 * Captures warnings, best practices, alternatives, references,
 * and other contextual information in a structured format.
 */
export interface TicketNotes {
    /** Important warnings and gotchas */
    warnings?: string[];
    /** Recommended best practices */
    bestPractices?: string[];
    /** Alternative approaches considered */
    alternatives?: Alternative[] | string[];
    /** Reference links and documentation */
    references?: Reference[] | string[];
    /** General context and background */
    context?: string;
    /** Known limitations */
    limitations?: string[];
    /** Future considerations */
    futureWork?: string[];
    /** Related tickets or issues */
    relatedTickets?: string[];
}
/**
 * Type guard for TicketNotes
 *
 * Validates that a value conforms to the TicketNotes structure.
 */
export declare function isValidNotes(value: unknown): value is TicketNotes;
/**
 * Validation status for test validation
 */
export type TestValidationStatus = 'pending' | 'passed' | 'failed' | 'partial';
/**
 * Structured acceptance criterion with validation state
 */
export interface AcceptanceCriterion {
    id: string;
    description: string;
    validated: boolean;
    validatedAt?: string;
    validatedBy?: string;
    notes?: string;
}
/**
 * Test validation summary for a ticket
 */
export interface TestValidation {
    status: TestValidationStatus;
    passedCriteria: number;
    totalCriteria: number;
    lastValidatedAt?: string;
    summary?: string;
}
/**
 * Normalizes acceptance criteria from legacy string[] format to structured AcceptanceCriterion[]
 *
 * Provides backwards compatibility when reading old data stored as string arrays.
 *
 * @param criteria - Array of strings or AcceptanceCriterion objects
 * @returns Normalized array of AcceptanceCriterion objects
 */
export declare function normalizeAcceptanceCriteria(criteria: (string | AcceptanceCriterion)[]): AcceptanceCriterion[];
/**
 * Ticket entity
 */
export interface Ticket {
    id: string;
    epicId: string;
    ticketNumber: number;
    title: string;
    description?: string;
    status: TicketStatus;
    progress: number;
    blockReason?: string;
    priority?: 'high' | 'medium' | 'low';
    complexity?: 'small' | 'medium' | 'large' | 'xlarge';
    tags?: string[];
    /** Notes and context - supports both simple string (legacy) and structured TicketNotes */
    notes?: string | TicketNotes;
    implementation?: TicketImplementation;
    /** Test validation summary (TS-001) */
    testValidation?: TestValidation;
    technicalDetails?: TicketTechnicalDetails;
    estimatedHours?: number;
    /** FK to active WorkSession */
    currentWorkSessionId?: string;
    labels?: string[];
    createdAt: string;
    updatedAt: string;
    /** Enriched acceptance criteria (populated by enrichment utility, not stored on ticket) */
    acceptanceCriteria?: (string | AcceptanceCriterion)[];
}
/**
 * Dependency relationship type
 */
export type DependencyType = 'blocks' | 'requires';
/**
 * Ticket dependency relationship
 */
export interface TicketDependency {
    id: string;
    ticketId: string;
    dependsOnId: string;
    type: DependencyType;
}
/**
 * Related ticket summary
 */
export interface RelatedTicketSummary {
    id: string;
    title: string;
    status: TicketStatus;
    sameEpic: boolean;
}
/**
 * Dependency ticket summary
 */
export interface DependencyTicketSummary {
    id: string;
    title: string;
    status: TicketStatus;
}
/**
 * Test result summary for previous attempts
 */
export interface TestResultSummary {
    id: string;
    testType?: string;
    allPassed: boolean;
    passed: number;
    failed: number;
    total: number;
    runAt: string;
}
/**
 * Previous implementation attempt
 */
export interface PreviousAttempt {
    attemptNumber: number;
    startedAt: string;
    endedAt?: string;
    result: 'completed' | 'failed' | 'in_progress';
    testResults: TestResultSummary[];
    summary?: string;
}
/**
 * Discovery summary for context
 */
export interface DiscoverySummary {
    id: string;
    type: string;
    severity: string;
    status: string;
    title: string;
    description: string;
    createdAt: string;
}
/**
 * Active session summary for context
 */
export interface ActiveSessionSummary {
    id: string;
    status: string;
    startedAt: string;
    config: unknown;
    ticketsCompleted: string[];
    ticketsFailed: string[];
    ticketsSkipped: string[];
    totalActiveMinutes: number;
}
/**
 * Implementation context returned by get_implementation_context
 */
export interface ImplementationContext {
    /** The ticket being implemented */
    ticket: Ticket;
    /** The epic containing the ticket */
    epic: Epic;
    /** The specification containing the epic */
    specification: Specification;
    /** Dependency information */
    dependencies: {
        /** Tickets that must be completed before this one */
        blockedBy: DependencyTicketSummary[];
        /** Tickets waiting on this one */
        blocks: DependencyTicketSummary[];
    };
    /** Related tickets */
    relatedTickets: RelatedTicketSummary[];
    /** Patterns and conventions from the project */
    patterns?: Record<string, unknown>;
    /** Active implementation session (Phase 5) */
    activeSession: ActiveSessionSummary | null;
    /** Previous implementation attempts (Phase 5) */
    previousAttempts: PreviousAttempt[];
    /** Related discoveries (Phase 5) */
    relatedDiscoveries: DiscoverySummary[];
}
/**
 * Work session for tracking implementation state on a ticket
 */
export interface WorkSession {
    id: string;
    ticketId: string;
    specificationId: string;
    projectId: string;
    epicId: string;
    implementationSessionId?: string;
    status: 'active' | 'paused' | 'completed' | 'failed';
    startedAt: string;
    pausedAt?: string;
    completedAt?: string;
    actualHours?: number;
    filesCreated?: string[];
    filesModified?: string[];
    filesDeleted?: string[];
    testsPassed?: boolean;
    retryCount: number;
    retryLog?: unknown;
    actions?: unknown;
    completionAttempts?: unknown;
    tokensUsed?: {
        inputTokens: number;
        outputTokens: number;
    };
    costUsd?: number;
    durationMs?: number;
    commitSha?: string;
    modelUsed?: string;
    createdAt: string;
    updatedAt: string;
}
/**
 * Ticket acceptance criterion (planning data, stored in its own table)
 */
export interface TicketAcceptanceCriterion {
    id: string;
    ticketId: string;
    description: string;
    order: number;
    createdAt?: string;
    updatedAt?: string;
}
/**
 * Work session AC validation (session-scoped validation state)
 */
export interface WorkSessionACValidation {
    id: string;
    workSessionId: string;
    criterionId: string;
    validated: boolean;
    validatedAt?: string;
    notes?: string;
    createdAt?: string;
    updatedAt?: string;
}
/**
 * Ticket implementation step (planning data, stored in its own table)
 */
export interface TicketImplementationStep {
    id: string;
    ticketId: string;
    text: string;
    order: number;
    createdAt?: string;
    updatedAt?: string;
}
/**
 * Work session step completion (session-scoped completion state)
 */
export interface WorkSessionStepCompletion {
    id: string;
    workSessionId: string;
    stepId: string;
    completed: boolean;
    completedAt?: string;
    notes?: string;
    createdAt?: string;
    updatedAt?: string;
}
/**
 * Extended test types for comprehensive validation
 */
export type TestType = 'unit' | 'integration' | 'e2e' | 'manual' | 'typescript' | 'lint' | 'build' | 'typecheck' | 'format' | 'security' | 'custom';
/**
 * Test result for a work session
 */
export interface WorkSessionTestResult {
    id: string;
    workSessionId: string;
    testType: TestType;
    passed: boolean;
    totalTests: number;
    passedTests: number;
    failedTests: number;
    skippedTests: number;
    coverage?: number;
    errorDetails?: string;
    command?: string;
    exitCode?: number;
    durationMs?: number;
    errorCount?: number;
    warningCount?: number;
    summary?: string;
    runAt: string;
}
/** @deprecated Use WorkSessionTestResult instead */
export type TicketTestResult = WorkSessionTestResult;
/**
 * Discovery type
 */
export type DiscoveryType = 'bug' | 'technical_debt' | 'new_requirement' | 'question' | 'blocker' | 'improvement';
/**
 * Discovery severity
 */
export type DiscoverySeverity = 'low' | 'medium' | 'high' | 'critical';
/**
 * Discovery status
 */
export type DiscoveryStatus = 'pending' | 'acknowledged' | 'resolved' | 'deferred';
/**
 * Discovery reported during implementation
 */
export interface Discovery {
    id: string;
    ticketId: string;
    specificationId: string;
    type: DiscoveryType;
    severity: DiscoverySeverity;
    status: DiscoveryStatus;
    title: string;
    description: string;
    resolution?: string;
    resolvedAt?: string;
    createdAt: string;
    updatedAt: string;
}
/**
 * Link type for git artifacts
 */
export type LinkType = 'commit' | 'pull_request' | 'branch';
/**
 * Link between a ticket and a git artifact
 */
export interface TicketLink {
    id: string;
    ticketId: string;
    linkType: LinkType;
    url: string;
    sha?: string;
    prNumber?: number;
    title?: string;
    status?: string;
    createdAt: string;
}
/**
 * List response with pagination
 */
export interface ListResponse<T> {
    items: T[];
    nextToken?: string;
    total?: number;
}
/**
 * Status report for a specification
 */
export interface SpecificationStatusReport {
    specification: Specification;
    epicProgress: Array<{
        epic: Epic;
        completedTickets: number;
        totalTickets: number;
        progress: number;
    }>;
    overallProgress: number;
    actionableTickets: number;
    blockedTickets: number;
}
/**
 * Status report for an epic
 */
export interface EpicStatusReport {
    epic: Epic;
    tickets: Array<{
        ticket: Ticket;
        isBlocked: boolean;
        isActionable: boolean;
    }>;
    progress: number;
}
/**
 * Implementation summary
 */
export interface ImplementationSummary {
    project: Project;
    specifications: Array<{
        specification: Specification;
        completedEpics: number;
        totalEpics: number;
        completedTickets: number;
        totalTickets: number;
    }>;
    recentActivity: Array<{
        ticketId: string;
        ticketTitle: string;
        action: string;
        timestamp: string;
    }>;
}
/**
 * Time report
 */
export interface TimeReport {
    totalHours: number;
    estimatedHours: number;
    variance: number;
    ticketBreakdown: Array<{
        ticketId: string;
        ticketTitle: string;
        estimated: number;
        actual: number;
    }>;
}
/**
 * Blockers report
 */
export interface BlockersReport {
    blockedTickets: Array<{
        ticket: Ticket;
        blockedBy: DependencyTicketSummary[];
        daysBlocked: number;
    }>;
    blockingChains: Array<{
        rootBlocker: Ticket;
        affectedTickets: number;
    }>;
}
/**
 * Session configuration
 */
export interface SessionConfig {
    mode: 'single' | 'autonomous' | 'guided';
    maxTickets: number | null;
    stopOnFailure: boolean;
    autoCommit: boolean;
    reviewAtEpicBoundaries: boolean;
    epicReviewList: string[];
}
/**
 * Implementation session
 */
export interface ImplementationSession {
    id: string;
    specificationId: string;
    projectId: string;
    startedAt: string;
    endedAt: string | null;
    config: SessionConfig;
    status: 'active' | 'paused' | 'completed' | 'aborted';
    currentTicketId: string | null;
    ticketsCompleted: string[];
    ticketsFailed: string[];
    ticketsSkipped: string[];
    totalActiveMinutes: number;
    summary: string | null;
    notes: string | null;
    createdAt: string;
    updatedAt: string;
}
/**
 * Session statistics
 */
export interface SessionStats {
    totalTickets: number;
    completed: number;
    failed: number;
    skipped: number;
    totalDurationMinutes: number;
    averageMinutesPerTicket: number;
}
/**
 * Ticket summary for session context
 */
export interface SessionTicketSummary {
    id: string;
    title: string;
    status: string;
    epicId: string;
    ticketNumber: number;
}
/**
 * Blocked ticket info for session context
 */
export interface SessionBlockedTicketInfo {
    id: string;
    title: string;
    blockReason: string;
    blockedBy: string[];
}
/**
 * Validation commands for a specification
 */
export interface ValidationCommands {
    test?: string;
    lint?: string;
    build?: string;
    typeCheck?: string;
    preValidation?: string;
    postValidation?: string;
    custom?: Record<string, string>;
}
/**
 * Single ticket update for bulk operations
 */
export interface TicketUpdate {
    ticketId: string;
    status?: TicketStatus;
    priority?: 'low' | 'medium' | 'high' | 'critical';
    progress?: number;
    blockReason?: string;
}
/**
 * Request for bulk update tickets operation
 */
export interface BulkUpdateRequest {
    updates: TicketUpdate[];
    validateDependencies?: boolean;
    atomic?: boolean;
}
/**
 * Result of bulk update tickets operation
 */
export interface BulkUpdateResult {
    updated: string[];
    failed: Array<{
        ticketId: string;
        error: string;
    }>;
    rollbackPerformed: boolean;
}
/**
 * Request for reset tickets operation
 */
export interface ResetTicketsRequest {
    specificationId: string;
    ticketIds?: string[];
    fromTicketId?: string;
    epicId?: string;
    allTickets?: boolean;
    targetStatus?: 'todo' | 'queue';
    resetDependents?: boolean;
    includeCompleted?: boolean;
    preserveNotes?: boolean;
    clearTestResults?: boolean;
}
/**
 * Result of reset tickets operation
 */
export interface ResetWorkSessionResult {
    resetWorkSession: string[];
    dependentsReset: string[];
    skipped: Array<{
        ticketId: string;
        reason: string;
    }>;
}
/**
 * Ticket definition for bulk creation
 */
export interface BulkCreateTicketDefinition {
    /** Ticket title (required) */
    title: string;
    /** Ticket description */
    description?: string;
    /** Estimated hours */
    estimatedHours?: number;
    /** Complexity level */
    complexity?: 'small' | 'medium' | 'large' | 'xlarge';
    /** Priority level */
    priority?: 'high' | 'medium' | 'low';
    /** Acceptance criteria */
    acceptanceCriteria?: string[];
    /** Implementation details */
    implementation?: TicketImplementation;
    /** Technical details */
    technicalDetails?: TicketTechnicalDetails;
    /** Tags */
    tags?: string[];
}
/**
 * Inline dependency definition for bulk creation
 */
export interface BulkCreateDependencyDefinition {
    /** Index of the ticket in the tickets array */
    ticket: number;
    /** Index(es) of the ticket(s) it depends on */
    dependsOn: number | number[];
}
/**
 * Request for bulk create tickets operation
 */
export interface BulkCreateTicketsRequest {
    /** Epic ID to create tickets in */
    epicId: string;
    /** Array of ticket definitions */
    tickets: BulkCreateTicketDefinition[];
    /** Optional inline dependencies using array indexes */
    dependencies?: BulkCreateDependencyDefinition[];
}
/**
 * Created ticket info in bulk create response
 */
export interface BulkCreatedTicketInfo {
    /** Generated ticket ID */
    id: string;
    /** Assigned ticket number */
    ticketNumber: number;
    /** Ticket title */
    title: string;
}
/**
 * Result of bulk create tickets operation
 */
export interface BulkCreateTicketsResult {
    /** Number of tickets created */
    created: number;
    /** Created ticket information */
    tickets: BulkCreatedTicketInfo[];
    /** Number of dependencies created */
    dependenciesCreated: number;
}
/**
 * Single dependency definition for bulk add
 */
export interface BulkDependencyDefinition {
    /** ID of the ticket that will depend on another */
    ticketId: string;
    /** ID of the ticket it will depend on */
    dependsOnId: string;
    /** Type of dependency (default: 'requires') */
    type?: 'blocks' | 'requires';
}
/**
 * Request for bulk add dependencies operation
 */
export interface BulkAddDependenciesRequest {
    /** Array of dependency definitions */
    dependencies: BulkDependencyDefinition[];
    /** Skip validation of circular dependencies (default: false) */
    skipCircularCheck?: boolean;
}
/**
 * Result of bulk add dependencies operation
 */
export interface BulkAddDependenciesResult {
    /** Number of dependencies created */
    created: number;
    /** IDs of created dependency records */
    dependencyIds: string[];
    /** Dependencies that were skipped (duplicates) */
    skipped: number;
}
/**
 * Request for lookup_project operation
 */
export interface LookupProjectRequest {
    /** Project name to search for (partial match, case-insensitive) */
    name: string;
}
/**
 * Minimal project info returned by lookup_project
 */
export interface LookupProjectResult {
    /** Project ID */
    id: string;
    /** Project name */
    name: string;
    /** Number of specifications in the project */
    specCount: number;
}
/**
 * Request for lookup_specification operation
 */
export interface LookupSpecificationRequest {
    /** Specification title to search for (partial match, case-insensitive) */
    title: string;
    /** Optional project ID to narrow search */
    projectId?: string;
}
/**
 * Minimal specification info returned by lookup_specification
 */
export interface LookupSpecificationResult {
    /** Specification ID */
    id: string;
    /** Specification title */
    title: string;
    /** Status */
    status: SpecificationStatus;
    /** Number of epics */
    epicCount: number;
}
/**
 * Request for lookup_epic operation
 */
export interface LookupEpicRequest {
    /** Epic title to search for (partial match, case-insensitive) */
    title: string;
    /** Specification ID to search within */
    specificationId: string;
}
/**
 * Minimal epic info returned by lookup_epic
 */
export interface LookupEpicResult {
    /** Epic ID */
    id: string;
    /** Epic title */
    title: string;
    /** Epic number */
    epicNumber: number;
    /** Status */
    status: EpicStatus;
    /** Number of tickets */
    ticketCount: number;
}
/**
 * Request for lookup_ticket operation
 */
export interface LookupTicketRequest {
    /** Ticket title to search for (partial match, case-insensitive) */
    title: string;
    /** Optional epic ID to narrow search */
    epicId?: string;
    /** Optional specification ID to narrow search */
    specificationId?: string;
}
/**
 * Minimal ticket info returned by lookup_ticket
 */
export interface LookupTicketResult {
    /** Ticket ID */
    id: string;
    /** Ticket title */
    title: string;
    /** Ticket number */
    ticketNumber: number;
    /** Status */
    status: TicketStatus;
    /** Epic ID */
    epicId: string;
}
//# sourceMappingURL=index.d.ts.map