dancing-links/built/typings/lib/solvers/factory.d.ts

Fastest JS solver for exact cover problems using Dancing Links

/**
 * Dancing Links Factory
 *
 * Factory class for creating Dancing Links solvers and templates with type safety.
 *
 * @example
 * ```typescript
 * // Simple solver for one-time use
 * const dlx = new DancingLinks<string>()
 * const solver = dlx.createSolver({ columns: 3 })
 * solver.addSparseConstraint('row1', [0, 2])
 * const solutions = solver.findAll()
 *
 * // Template for reusing constraint patterns
 * const template = dlx.createSolverTemplate({ columns: 3 })
 * template.addSparseConstraint('base', [0, 1])
 * const solver1 = template.createSolver()
 * const solver2 = template.createSolver()
 * ```
 */
import { SimpleSolverConfig, ComplexSolverConfig } from '../types/interfaces.js';
import { ProblemSolver } from './solver.js';
import { SolverTemplate } from './template.js';
/**
 * Factory class for creating Dancing Links solvers and templates with type safety.
 *
 * @template T The type of data associated with constraints
 *
 * @example
 * ```typescript
 * const dlx = new DancingLinks<string>()
 * const solver = dlx.createSolver({ columns: 3 })
 * const template = dlx.createSolverTemplate({ primaryColumns: 2, secondaryColumns: 1 })
 * ```
 */
export declare class DancingLinks<T> {
    /**
     * Create a new problem solver for a single problem instance.
     *
     * @param config - Solver configuration (simple or complex mode)
     * @returns Type-safe problem solver instance
     *
     * @example
     * ```typescript
     * // Simple mode (columns only)
     * const solver = dlx.createSolver({ columns: 3 })
     *
     * // Complex mode (primary + secondary columns)
     * const solver = dlx.createSolver({
     *   primaryColumns: 2,
     *   secondaryColumns: 1
     * })
     * ```
     */
    createSolver(config: SimpleSolverConfig): ProblemSolver<T, 'simple'>;
    createSolver(config: ComplexSolverConfig): ProblemSolver<T, 'complex'>;
    /**
     * Create a solver template for reusing constraint patterns across multiple problems.
     *
     * @param config - Solver configuration (simple or complex mode)
     * @returns Type-safe solver template instance
     *
     * @example
     * ```typescript
     * const template = dlx.createSolverTemplate({ columns: 3 })
     * template.addSparseConstraint('base', [0, 1])
     *
     * // Create multiple solvers from the same template
     * const solver1 = template.createSolver()
     * const solver2 = template.createSolver()
     * ```
     */
    createSolverTemplate(config: SimpleSolverConfig): SolverTemplate<T, 'simple'>;
    createSolverTemplate(config: ComplexSolverConfig): SolverTemplate<T, 'complex'>;
}